බෘෆාගේ පිළිතුර ඉතා සිනිඳුයි, ඇත්තෙන්ම - ඉතා දක්ෂ, ඇත්තෙන්ම ... rfc4122 අනුකූල, තරමක් කියවිය හැකි සහ සංයුක්තයි. නියමයි!
නමුත් ඔබ එම නිත්‍ය ප්‍රකාශනය දෙස බලන්නේ නම්, එම බොහෝ replace()ඇමතුම්, toString()සහ Math.random()ක්‍රියාකාරී ඇමතුම් (එහිදී ඔහු ප්‍රති the ලයෙන් බිටු 4 ක් පමණක් භාවිතා කර ඉතිරි කොටස නාස්ති කරයි), ඔබ කාර්ය සාධනය ගැන කල්පනා කිරීමට පටන් ගත හැකිය. ඇත්ත වශයෙන්ම, ජොයෙල්ප්ට් විසින් සාමාන්‍ය GUID වේගය සඳහා RFC ඉවත් කිරීමට පවා තීරණය කළේය generateQuickGUID.
නමුත්, අපට වේගය සහ RFC අනුකූලතාවය ලබා ගත හැකිද? මම කියනවා, ඔව්! අපට කියවීමේ හැකියාව පවත්වා ගත හැකිද? හොඳයි ... ඇත්ත වශයෙන්ම නොවේ, නමුත් ඔබ අනුගමනය කරන්නේ නම් එය පහසුය.
නමුත් පළමුව, මගේ ප්‍රති results ල, බෘෆා හා සසඳන විට guid(පිළිගත් පිළිතුර) සහ ආර්එෆ්සී අනුකූල නොවන generateQuickGuid:
Desktop Android
broofa: 1617ms 12869ms
e1: 636ms 5778ms
e2: 606ms 4754ms
e3: 364ms 3003ms
e4: 329ms 2015ms
e5: 147ms 1156ms
e6: 146ms 1035ms
e7: 105ms 726ms
guid: 962ms 10762ms
generateQuickGuid: 292ms 2961ms
- Note: 500k iterations, results will vary by browser/cpu.
එබැවින් මගේ 6 වන ප්‍රශස්තිකරණය අනුව, මම වඩාත් ජනප්‍රිය පිළිතුර 12X ට වඩා , පිළිගත් පිළිතුර 9X ට වඩා , සහ වේගයෙන් නොගැලපෙන පිළිතුර 2-3X මගින් පරාජය කළෙමි. . මම තවමත් rfc4122 අනුකූලයි.
කෙසේද? මම සම්පූර්ණ මූලාශ්‍රය http://jsfiddle.net/jcward/7hyaC/3/ සහ http://jsperf.com/uuid-generator-opt/4 මත තබා ඇත
පැහැදිලි කිරීමක් සඳහා, අපි බ ro ෆාගේ කේතය සමඟ ආරම්භ කරමු:
function broofa() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
return v.toString(16);
});
}
console.log(broofa())
එබැවින් එය xඕනෑම අහඹු හෙක්ස් ඉලක්කම් yසමඟ, අහඹු දත්ත සමඟ ප්‍රතිස්ථාපනය කරයි ( 10RFC පිරිවිතරයට අනුව ඉහළම බිටු 2 බල කිරීම හැර ), සහ රීජෙක්ස් නොගැලපේ -හෝ4 අක්ෂර සමඟ , එබැවින් ඔහුට ඒවා සමඟ ගනුදෙනු කිරීමට අවශ්‍ය නැත. ඉතා සිනිඳුයි.
දැනගත යුතු පළමු දෙය නම් නිත්‍ය ප්‍රකාශන මෙන් ක්‍රියාකාරී ඇමතුම් මිල අධික බවය (ඔහු 1 ක් පමණක් භාවිතා කළද, එයට ඇමතුම් 32 ක් ඇත, සෑම තරඟයක් සඳහාම එකක් ඇත, සහ එක් එක් ඇමතුම් 32 න් එය Math.random () සහ v. toString (16)).
කාර්ය සාධනය සඳහා වන පළමු පියවර වන්නේ රෙජෙක්ස් සහ එහි ඇමතුම් ආපසු ගැනීමේ කාර්යයන් ඉවත් කර ඒ වෙනුවට සරල පුඩුවක් භාවිතා කිරීමයි. මෙයින් අදහස් කරන්නේ බෘෆා නොකළ නමුත් චරිත -හා 4චරිත සමඟ අප කටයුතු කළ යුතු බවයි. ඔහුගේ සිහින් නූල් අච්චු ගෘහ නිර්මාණ ශිල්පය තබා ගැනීමට අපට String Array දර්ශක භාවිතා කළ හැකි බව සලකන්න:
function e1() {
var u='',i=0;
while(i++<36) {
var c='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'[i-1],r=Math.random()*16|0,v=c=='x'?r:(r&0x3|0x8);
u+=(c=='-'||c=='4')?c:v.toString(16)
}
return u;
}
console.log(e1())
මූලික වශයෙන්, එකම අභ්‍යන්තර තර්කනය, අප පරීක්ෂා කිරීම -හෝ කාල 4ලූපයක් භාවිතා කිරීම හැර (ඒ වෙනුවටreplace() කෝල්බැක් ) අපට 3X කට ආසන්න වැඩිදියුණු කිරීමක් ලැබේ!
ඊළඟ පියවර ඩෙස්ක්ටොප් එකේ කුඩා එකක් නමුත් ජංගම දුරකථනයේ හොඳ වෙනසක් ඇති කරයි. අපි Math.random () ඇමතුම් අඩු කර එම අහඹු බිටු 87% ක් අහඹු බෆරයකින් ඉවතට විසි කරනවා වෙනුවට එක් එක් පුනරාවර්තනයෙන් ඉවත් කරමු. එම අච්චු අර්ථ දැක්වීම ලූපයෙන් ඉවතට ගෙන යමු.
function e2() {
var u='',m='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx',i=0,rb=Math.random()*0xffffffff|0;
while(i++<36) {
var c=m[i-1],r=rb&0xf,v=c=='x'?r:(r&0x3|0x8);
u+=(c=='-'||c=='4')?c:v.toString(16);rb=i%8==0?Math.random()*0xffffffff|0:rb>>4
}
return u
}
console.log(e2())
වේදිකාව මත පදනම්ව මෙය අපට 10-30% ක් ඉතිරි කරයි. නරක නැහැ. නමුත් ඊළඟ විශාල පියවර ටෝස්ට්‍රිං ශ්‍රිත ඇමතුම් මුළුමනින්ම ප්‍රශස්තිකරණ සම්භාව්‍යයකින් ඉවත් කරයි - බැලීමේ වගුව. මූලද්‍රව්‍ය 16 කින් යුත් සරල බැලීමේ වගුවක් මඟින් ටෝස්ට්‍රිං (16) හි කාර්යය ඉතා අඩු කාලයක් තුළ ඉටු කරනු ඇත:
function e3() {
var h='0123456789abcdef';
var k='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
/* same as e4() below */
}
function e4() {
var h=['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'];
var k=['x','x','x','x','x','x','x','x','-','x','x','x','x','-','4','x','x','x','-','y','x','x','x','-','x','x','x','x','x','x','x','x','x','x','x','x'];
var u='',i=0,rb=Math.random()*0xffffffff|0;
while(i++<36) {
var c=k[i-1],r=rb&0xf,v=c=='x'?r:(r&0x3|0x8);
u+=(c=='-'||c=='4')?c:h[v];rb=i%8==0?Math.random()*0xffffffff|0:rb>>4
}
return u
}
console.log(e4())
ඊළඟ ප්‍රශස්තිකරණය තවත් සම්භාව්‍යයකි. අපි එක් එක් ලූප පුනරාවර්තනයේ බිටු 4 ක නිමැවුමක් පමණක් හසුරුවන බැවින්, අපි ලූප ගණන අඩකින් කපා එක් එක් පුනරාවර්තනයේ බිටු 8 ක් සකස් කරමු. අපට තවමත් RFC අනුකූල බිට් ස්ථාන හැසිරවිය යුතු බැවින් මෙය ව්‍යාකූල ය, නමුත් එය එතරම් අපහසු නැත. 0x00 - 0xff ගබඩා කිරීම සඳහා අපට පසුව විශාල බැලීමේ වගුවක් (16x16, හෝ 256) සෑදිය යුතු අතර, අපි එය ගොඩනඟන්නේ e5 () ශ්‍රිතයෙන් පිටත එක් වරක් පමණි.
var lut = []; for (var i=0; i<256; i++) { lut[i] = (i<16?'0':'')+(i).toString(16); }
function e5() {
var k=['x','x','x','x','-','x','x','-','4','x','-','y','x','-','x','x','x','x','x','x'];
var u='',i=0,rb=Math.random()*0xffffffff|0;
while(i++<20) {
var c=k[i-1],r=rb&0xff,v=c=='x'?r:(c=='y'?(r&0x3f|0x80):(r&0xf|0x40));
u+=(c=='-')?c:lut[v];rb=i%4==0?Math.random()*0xffffffff|0:rb>>8
}
return u
}
console.log(e5())
මම වරකට බිටු 16 ක් ක්‍රියාවට නංවන ඊ 6 () උත්සාහ කළෙමි, තවමත් මූලද්‍රව්‍ය 256 LUT භාවිතා කරමින්, එය ප්‍රශස්තිකරණයේ ප්‍රතිලාභ අඩුවෙමින් පවතින බව පෙන්නුම් කළෙමි. එය අඩු පුනරාවර්තන ප්‍රමාණයක් තිබුණද, වැඩි දියුණු කරන ලද සැකසුම් මගින් අභ්‍යන්තර තර්කනය සංකීර්ණ වූ අතර එය ඩෙස්ක්ටොප් පරිගණකයේද ක්රියාත්මක වූ අතර ජංගම දුරකතනයට වඩා ~ 10% ක් පමණි.
අයදුම් කිරීමට ඇති අවසාන ප්‍රශස්තිකරණ තාක්ෂණය - ලූපය ඉවත් කරන්න. අපි ස්ථාවර වාර ගණනක් ලූප කරන බැවින්, අපට තාක්‍ෂණිකව මේ සියල්ල අතින් ලිවිය හැකිය. මම නැවත වරක් පැවරූ තනි අහඹු විචල්‍ය r සමඟ මෙය උත්සාහ කළෙමි. නමුත් විචල්‍යයන් හතරක් සමඟ අහඹු දත්ත ඉදිරියෙන් තබා, පසුව බැලීමේ වගුව භාවිතා කර, නිසි RFC බිටු යෙදීමෙන්, මෙම අනුවාදය ඒවා සියල්ලම දුම් පානය කරයි:
var lut = []; for (var i=0; i<256; i++) { lut[i] = (i<16?'0':'')+(i).toString(16); }
function e7()
{
var d0 = Math.random()*0xffffffff|0;
var d1 = Math.random()*0xffffffff|0;
var d2 = Math.random()*0xffffffff|0;
var d3 = Math.random()*0xffffffff|0;
return lut[d0&0xff]+lut[d0>>8&0xff]+lut[d0>>16&0xff]+lut[d0>>24&0xff]+'-'+
lut[d1&0xff]+lut[d1>>8&0xff]+'-'+lut[d1>>16&0x0f|0x40]+lut[d1>>24&0xff]+'-'+
lut[d2&0x3f|0x80]+lut[d2>>8&0xff]+'-'+lut[d2>>16&0xff]+lut[d2>>24&0xff]+
lut[d3&0xff]+lut[d3>>8&0xff]+lut[d3>>16&0xff]+lut[d3>>24&0xff];
}
console.log(e7())
නවීකරණය කරන ලද: http://jcward.com/UUID.js -UUID.generate()
හාස්‍යජනක දෙය නම්, අහඹු දත්ත බයිට් 16 ක් උත්පාදනය කිරීම පහසුම කොටසයි. සමස්ත උපක්‍රමයම එය RFC අනුකූලතාවයෙන් String ආකෘතියෙන් ප්‍රකාශ කරන අතර එය වඩාත් තදින් සපුරා ඇත්තේ අහඹු දත්ත බයිට් 16 ක්, පාලනය නොකළ ලූපයක් සහ බැලීමේ වගුවක් මගිනි.
මගේ තර්කනය නිවැරදි යැයි මම විශ්වාස කරමි - මේ ආකාරයේ වෙහෙසකර වැඩ වලදී වැරැද්දක් කිරීම ඉතා පහසුය. නමුත් ප්‍රතිදානයන් මට හොඳ පෙනුමක්. කේත ප්‍රශස්තිකරණය හරහා ඔබ මෙම පිස්සු ගමන භුක්ති වින්දා යැයි මම විශ්වාස කරමි!
අවවාද කරන්න: මගේ මූලික ඉලක්කය වූයේ විභව ප්‍රශස්තිකරණ උපාය මාර්ග පෙන්වීම සහ ඉගැන්වීමයි. වෙනත් පිළිතුරු මගින් හොඳ UUIDs උත්පාදනය සඳහා වැදගත් වන isions ට්ටන සහ සැබවින්ම අහඹු සංඛ්‍යා වැනි වැදගත් මාතෘකා ආවරණය කරයි.