Kurti GUID / UUID javascript?

Aš bandau sukurti visuotinai unikalius identifikatorius javascript'e. Nesu įsitikinęs, kokios eilutės yra prieinamos visose naršyklėse, pvz., „Atsitiktinis“ ir sėjamos su įmontuotu atsitiktinių skaičių generatoriumi ir tt

GUID / UUID turi būti mažiausiai 32 simboliai ir turi likti ASCII diapazone, kad būtų išvengta problemų perdavimo metu.

3498
19 сент. Jason Cohen paprašė rugsėjo 19 d. 2008-09-19 23:01 '08 at 11:01 pm 2008-09-19 23:01
@ 55 atsakymai
  • 1
  • 2

UUID (Universal Unique Identifier), taip pat žinomas kaip GUID (Global Unique Identifier), pagal RFC 4122 yra identifikatoriai, turintys tam tikrą unikalumo garantiją.

Geriausias būdas juos generuoti yra laikytis nurodyto RFC įgyvendinimo instrukcijų, naudoti vieną iš daugelio įrodytų atviro kodo diegimo būdų arba naudoti integruotą diegimą kalbomis, kuriose jis yra.

Čia pateikiami kai kurie atviro kodo įrankiai, skirti dirbti su UUID, kai kuriose populiariose programavimo kalbose.

„Javascript“

Php

Eiti

Ruby

pythonas


Atkreipkite dėmesį, kad tiesiog atsitiktinai generuojant identifikatorius pagal baitą arba požymių požymių nesuteikia jums tokių pačių garantijų kaip atitinkamas įgyvendinimas. Be to, labai svarbu, kad sistemos, veikiančios su suderinamais UUID, gali nepriimti atsitiktinai sugeneruotų sistemų, o daugelis atviro kodo tikrintojų faktiškai tikrina, ar struktūra yra teisinga.

UUID turi turėti šį formatą:

 xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx 

Kai pozicijos M ir N gali turėti tik tam tikras reikšmes. Šiuo metu vienintelės galiojančios M vertės yra 1, 2, 3, 4 ir 5, todėl atsitiktinai sukuriant šią poziciją dauguma rezultatų bus nepriimtini.

2078 m
19 сент. John Millikin atsakymas rugsėjo 19 d 2008-09-19 23:05 '08, 11:05 val. 2008-09-19 23:05

RFC4122 4 versijoje šis vieno linijos (ish) sprendimas yra kompaktiškiausias, kurį galiu valdyti.

puikaus „Math.random“ () įrašo .  Norėdami gauti patikimesnį sprendimą, apsvarstykite kažką panašaus į „ Uuid“ modulį [Atsakomybės apribojimas: aš esu autorius], kuris naudoja geresnes RNG API, jei tokių yra. 

border=0

Atnaujinimas, 2015-08-26 . Atkreipkite dėmesį, kad šiame apraše aprašoma, kaip nustatyti, kiek identifikatorių galima sukurti prieš pasiekiant tam tikrą susidūrimo tikimybę. Pavyzdžiui, naudojant UUID su RFC4122 4,26x10 15 versijos 4 dažniu, jūs turite 1 milijono susidūrimo tikimybę.

Atnaujinimas, 2017-06-28 : geras „Chrome“ kūrėjo straipsnis , aptariantis „Math.random PRNG“ kokybės būklę „Chrome“, „Firefox“ ir „Safari“. tl; dr - Nuo 2015 m. pabaigos tai yra „labai gera“, bet ne kriptografinė. Norėdami išspręsti šią problemą, čia yra atnaujinta pirmiau minėto sprendimo versija, kurioje naudojama ES6, crypto API ir kai kurie JS vedliai. Negaliu kredituoti už :

3359
22 янв. atsakymas duotas broofa 22 sausio. 2010-01-22 16:40 '10, 16:40, 2010-01-22 16:40

Man labai patinka, kaip atsakymas yra švarus, bet, deja, prastas Math.random įgyvendinimas palieka susidūrimo galimybę.

Čia yra panašus sprendimas, kuris yra suderinamas su RFC4122 4 versija, kuri išsprendžia šią problemą kompensuodama pirmuosius 13 heksadeciminių skaičių su šešioliktainiu laiko žymos dalimi. Taigi, net jei Math.random yra tame pačiame semestre, abu klientai turės generuoti UUID, turinčią tą pačią milisekundę (arba po 10 000 metų), kad gautų tą patį UUID:

 function generateUUID() { // Public Domain/MIT var d = new Date().getTime(); if (typeof performance !== 'undefined'  typeof performance.now === 'function'){ d += performance.now(); //use high-precision timer if available } return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) { var r = (d + Math.random() * 16) % 16 | 0; d = Math.floor(d / 16); return (c === 'x' ? r : (r  0x3 | 0x8)).toString(16); }); } 


Čia yra testavimui skirtas smuikas.

720
10 янв. Atsakymas pateikiamas Briguy37 10 sausis 2012-01-10 22:38 '12, 10:38 val. 2012-01-10 22:38

Atsakymas į antakį yra gana aptakus, tikrai įspūdingai protingas, tikrai ... rfc4122 suderinamas, šiek tiek skaitomas ir kompaktiškas. Nuostabus!

Tačiau, jei pažvelgsite į tą reguliarią išraišką, daugelis replace() skambučių Math.random() toString() ir „ Math.random() funkcijų skambučius (kur jis naudoja tik 4 bitus rezultatu ir švaistosi poilsį), galite pradėti stebėti kokybę. Iš tiesų, joelpt net nusprendė išmesti RFC visam GUID greičiui, naudodamas generateQuickGUID .

Bet ar galime pasiekti greitį ir RFC? Sakau taip! Ar galime išlaikyti skaitomumą? Na ... Ne iš tikrųjų, bet tai lengva, jei jį sekate.

Tačiau, pirma, mano rezultatai, lyginant su broofa, guid (priimtu atsakymu), taip pat su ne RFC suderinamu 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. 

Taigi, mano 6-osios optimizacijos iteracijos metu, aš nugalėjau populiariausią atsakymą daugiau nei 12X , priimtą atsakymą daugiau nei 9X ir greitą atsakymą, neatitinkantį 2-3X reikalavimų. Ir aš vis dar suderinu su rfc4122.

Ar domitės? Įdėjau visą šaltinį adresu http://jsfiddle.net/jcward/7hyaC/3/ ir http://jsperf.com/uuid-generator-opt/4

Norėdami paaiškinti, leiskite pradėti nuo „crony“ kodo

 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) { var r = Math.random()*16|0, v = c == 'x' ? r : (r return v.toString(16); }); 

Taigi jis pakeičia x bet kokiu atsitiktiniu šešioliktainiu skaitmeniu, y su atsitiktiniais duomenimis (išskyrus tai, kad viršutiniai 2 bitai RFC specifikacijoje yra iki 10 ), o įprastinė išraiška nesutampa - arba 4 simboliai, todėl jiems nereikia spręsti . Labai, labai sklandžiai.

Pirmas dalykas, kurį reikia žinoti, yra tai, kad funkcijų skambučiai yra brangūs, kaip ir reguliarios išraiškos (nors ji naudoja tik 1, ji turi 32 atsiliepimų, po vieną kiekvienai rungtynei ir kiekviename iš 32 skambučių ji vadinama „Math.random“ () ir v. ToString (16)).

Pirmasis žingsnis į darbą yra pašalinti RegEx ir jos atgalinio ryšio funkcijas ir naudoti paprastą kilpą. Tai reiškia, kad turime susidoroti su - ir 4 simboliais, o ne. Taip pat atkreipkite dėmesį, kad galime naudoti eilutės eilutės indeksą, kad išlaikytume sklandų styginių struktūrą:

 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 u+=(c=='-'||c=='4')?c:v.toString(16) } return u; } 

Iš esmės ta pati vidinė logika, išskyrus tikrinimą - arba 4 , ir naudojant „loop“ (vietoj „callbacks“ replace() ), mums suteikia beveik 3 kartus didesnį patobulinimą!

Kitas žingsnis yra nedidelis darbalaukyje, tačiau mobiliesiems telefonams yra tinkamas skirtumas. Padarykime mažiau skambučių į Math.random () ir naudokitės visais šiais atsitiktiniais bitais, o ne iš jų 87% nukrenta atsitiktiniu buferiu, kuris yra perkeliamas iš kiekvieno iteracijos. Tegul tai taip pat perkelia šį modelio apibrėžimą iš kilpos, tik tuo atveju, jei jis padeda:

 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 u+=(c=='-'||c=='4')?c:v.toString(16);rb=i%8==0?Math.random()*0xffffffff|0:rb>>4 } return u } 

Tai sutaupo 10-30% priklausomai nuo platformos. Ne blogai Tačiau kitas didelis žingsnis pašalina skambučius į „toString“ funkciją apskritai su optimizavimo klasika - atskaitos lentele. Paprasta 16 elementų paieškos lentelė atliks „ToString“ (16) užduotį daug mažiau laiko:

 function e3() { var h='0123456789abcdef'; var k='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';  } 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 u+=(c=='-'||c=='4')?c:h[v];rb=i%8==0?Math.random()*0xffffffff|0:rb>>4 } return u } 

Kitas optimizavimas yra dar viena klasika. Kadangi mes apdorojame 4 bitų išvestį kiekvienoje kontūro atkarpoje, leiskite sumažinti pusių skaičių ir apdoroti 8 bitus per iteraciją. Tai sunku, nes vis dar turime tvarkyti bitų pozicijas, kurios atitinka RFC, tačiau tai nėra pernelyg sudėtinga. Tada mums reikia sukurti didelę paieškos lentelę (16x16 arba 256), skirtą saugoti 0x00 - 0xff, ir mes ją sukursime tik vieną kartą už e5 () funkcijos.

 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 u+=(c=='-')?c:lut[v];rb=i%4==0?Math.random()*0xffffffff|0:rb>>8 } return u } 

Bandžiau e6 (), kuris vienu metu apdoroja 16 bitų, vis dar naudoja 256 elementą LUT, ir parodė optimizavimo pelno sumažėjimą. Nors ji turėjo mažiau iteracijų, vidinę logiką apsunkino padidėjęs apdorojimas, ir jis buvo atliktas darbalaukyje ir tik 10% greičiau mobiliuosiuose įrenginiuose.

Galutinis taikytinas optimizavimo metodas yra kilpos išplėtimas. Kaip įstrigo fiksuotu skaičiumi kartų, mes galime tai techniškai parašyti rankiniu būdu. Aš vieną kartą bandžiau su vienu atsitiktiniu kintamuoju r, kurį ir toliau diegiau, ir cisternų našumą. Tačiau su keturiais kintamaisiais, atsitiktiniai duomenys buvo priskirti prie priekio, tada, naudojant paieškos lentelę ir pritaikius teisingus RFC bitus, ši versija smogia juos visus:

 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 lut[d1 lut[d2 lut[d3 } 

Modifikuota: http://jcward.com/UUID.js - UUID.generate()

Juokingas dalykas yra tai, kad 16 baitų atsitiktinių duomenų yra lengva dalis. Visas triukas tai išreiškia eilutės formatu su RFC atitiktimi, ir jis yra stipriausiai įvykdytas naudojant 16 baitų atsitiktinių duomenų, nekontroliuojamą kilpą ir paieškos lentelę.

Tikiuosi, kad mano logika yra teisinga - labai lengva padaryti klaidą tokiame varginame darbe. Bet rezultatai man atrodo gerai. Tikiuosi, kad jums patiko šis nenormalus važiavimas per kodo optimizavimą!

Būkite atsargūs: mano pagrindinis tikslas yra parodyti ir mokyti galimas optimizavimo strategijas. Kiti atsakymai apima tokias svarbias temas kaip susidūrimai ir tikrai atsitiktiniai skaičiai, kurie yra svarbūs kuriant gerus UUID.

349
23 февр. Atsakymas pateiktas Jeff Ward 23 vasario mėn. 2014-02-23 04:46 '14 at 4:46 2014-02-23 04:46

Čia yra kodas, pagrįstas RFC 4122 4.4 skyriumi (algoritmai, skirti sukurti UUID iš tikrai atsitiktinio ar pseudo-atsitiktinio skaičiaus).

 function createUUID() { // http://www.ietf.org/rfc/rfc4122.txt var s = []; var hexDigits = "0123456789abcdef"; for (var i = 0; i < 36; i++) { s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1); } s[14] = "4"; // bits 12-15 of the time_hi_and_version field to 0010 s[19] = hexDigits.substr((s[19]  0x3) | 0x8, 1); // bits 6-7 of the clock_seq_hi_and_reserved to 01 s[8] = s[13] = s[18] = s[23] = "-"; var uuid = s.join(""); return uuid; } 
142
17 мая '09 в 6:39 2009-05-17 06:39 atsakė Kevin Hakanson gegužės 17 d. 09:39 2009-05-17 06:39

Greičiausias GUID, kaip eilutės generatoriaus metodas XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX formatu. Tai nesukuria standartinio GUID.

Dešimt milijonų šios programos vykdymo trukmė trunka tik 32,5 sekundes, o tai yra greičiausias, kurį aš kada nors mačiau naršyklėje (vienintelis sprendimas be ciklų / iteracijų).

Ši funkcija yra tokia paprasta kaip:

  function guid() { function _p8(s) { var p = (Math.random().toString(16)+"000000000").substr(2,8); return s ? "-" + p.substr(0,4) + "-" + p.substr(4,4) : p ; } return _p8() + _p8(true) + _p8(true) + _p8(); } 

Jei norite patikrinti našumą, galite paleisti šį kodą:

 console.time('t'); for (var i = 0; i < 10000000; i++) { guid(); }; console.timeEnd('t'); 

Esu tikras, kad dauguma iš jūsų supras, ką aš ten darau, bet galbūt yra bent vienas asmuo, kuriam reikia paaiškinimo:

Algoritmas:

  • Funkcija Math.random() grąžina dešimtainį skaičių nuo 0 iki 1 po 16 skaitmenų po kablelio (pvz., 0.4363923368509859 ).
  • Tada mes 0.6fb7687f šį skaičių ir konvertuojame į eilutę su 16 bazėmis (iš aukščiau pateikto pavyzdžio gauname 0.6fb7687f ).
    Math.random().toString(16) .
  • Tada mes 0.6fb7687f priešdėlį 0. ( 0.6fb7687f => 6fb7687f ) ir gauname aštuonių šešioliktainių simbolių eilutę.
    (Math.random().toString(16).substr(2,8) .
  • Kartais Math.random() grąžina trumpesnį skaičių (pavyzdžiui, 0.4363 ) dėl nulio pabaigoje (iš aukščiau pateikto pavyzdžio, ši vertė iš 0.4363000000000000 yra 0.4363000000000000 ). Štai kodėl prie šios linijos pridedu "000000000" (linija su devyniomis nuliais), o tada išjunkite jį, naudojant substr() funkciją, kad ji būtų lygiai devyni simboliai (užpildant nulius dešinėje).
  • Priežastis, kodėl reikia tiksliai pridėti devynis nulius, yra blogiausiu atveju, kai Math.random() grąžina tiksliai 0 arba 1 ( Math.random() ^ 16 tikimybė kiekvienam iš jų). Todėl mes turėjome pridėti devynis nulius ( "0"+"000000000" arba "1"+"000000000" ), o tada nukirpti jį nuo antrojo indekso (3 ženklas) aštuonių ženklų ilgio. Kitais atvejais nulio pridėjimas nepažeidžia rezultato, nes jis bet kuriuo atveju jį išjungia.
    Math.random().toString(16)+"000000000").substr(2,8) .

Asamblėja:

  • GUID yra tokiame formate: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX .
  • Aš padaliau GUID į 4 dalis, kurių kiekvienas suskirstytas į 2 tipus (arba formatus): XXXXXXXX ir -XXXX-XXXX .
  • Dabar sukuriu GUID, naudojant šiuos 2 tipus, norint sukurti GUID, naudojant 4 dalių skambutį, pvz., -XXXX-XXXX XXXXXXXX -XXXX-XXXX -XXXX-XXXX .
  • Norėdami atskirti šiuos du tipus, aš pridėjau žymos parametrą _p8(s) porų funkcijai _p8(s) , s parametras nurodo funkciją, ar pridėti brūkšnį, ar ne.
  • Galiausiai sukuriame GUID su tokia grandine: _p8() + _p8(true) + _p8(true) + _p8() ir grąžinkite jį.

Nuoroda į šį dienoraščio įrašą

Mėgaukitės! :-)

82
22 мая '13 в 16:50 2013-05-22 16:50 atsakymą pateikė Slavik Meltser , gegužės 22 d. 13 val. 16:50 2013-05-22 16:50
 var uniqueId = Math.random().toString(36).substring(2) + (new Date()).getTime().toString(36); 

 <div id="unique"> </div> 

Jei identifikatorius generuojamas per 1 milisekundę, jis yra 100% unikalus.

Jei du identifikatoriai generuojami trumpesniais intervalais ir darant prielaidą, kad atsitiktinis metodas yra iš tikrųjų atsitiktinis, tai sukurs identifikatorių, kuris visuotinai yra unikalus 99,9999999999999% tikimybe (susidūrimas 1 iš 10 ^ 15)

Šį skaičių galite padidinti pridėdami daugiau skaitmenų, tačiau norėdami sukurti 100% unikalų identifikatorių, turėsite naudoti pasaulinį skaitiklį.

jei tikrai reikia RFC atitikties, šis formatavimas bus laikomas galiojančiu 4 versijos GUID:

 var r = (new Date()).getTime().toString(16) + Math.random().toString(16).substring(2) + "0".repeat(16); var guid = r.substr(0,8) + '-' + r.substr(8,4) + '-4000-8' + r.substr(12,3) + '-' + r.substr(15,12); 

 <div id="unique"> </div> 

Pakeisti: aukščiau nurodytas kodas atitinka RFC tikslą, bet ne jo raidę. Tarp kitų neatitikimų yra keletas atsitiktinių skaičių. (Jei reikia, pridėkite daugiau atsitiktinių skaičių). Privalumas yra tas, kad jis yra tikrai greitas, palyginti su 100% suderinamu kodu. Čia galite patikrinti savo GUID.

78
19 мая '17 в 23:50 2017-05-19 23:50 atsakymą pateikė Simon Rigét gegužės 17–17 d. 23:50

Čia pateikiamas aukščiausio lygio atsakymas su „ Chrome“ susidūrimo problema :

 generateGUID = (typeof(window.crypto) != 'undefined'  typeof(window.crypto.getRandomValues) != 'undefined') ? function() { // If we have a cryptographically secure PRNG, use that // /questions/1755/collisions-when-generating-uuids-in-javascript var buf = new Uint16Array(8); window.crypto.getRandomValues(buf); var S4 = function(num) { var ret = num.toString(16); while(ret.length < 4){ ret = "0"+ret; } return ret; }; return (S4(buf[0])+S4(buf[1])+"-"+S4(buf[2])+"-"+S4(buf[3])+"-"+S4(buf[4])+"-"+S4(buf[5])+S4(buf[6])+S4(buf[7])); } : function() { // Otherwise, just use Math.random // https://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523 return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) { var r = Math.random()*16|0, v = c == 'x' ? r : (r return v.toString(16); }); }; 

„Jsbin“, jei norite jį patikrinti.

60
12 дек. atsakymas duotas ripper234 12 Dec. 2011-12-12 13:13 '11, 13:13, 2011-12-12 13:13

Čia pateikiamas 2011 m. Spalio 9 d. Iš „jed“ naudotojo komentaras pateiktas sprendimas šiuo adresu : https://gist.github.com/982883 :

 UUIDv4 = function b(a){return a?(a^Math.random()*16>>a/4).toString(16):([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g,b)} 

Jis pasiekia tą patį tikslą, kaip ir dabartinio aukščiausio lygio atsakas , bet 50 + mažiau baitų, naudojant prievartą, rekursiją ir eksponentinį žymėjimą. Tiems, kurie domisi, kaip tai veikia, čia yra anotuotos senesnės funkcijos versijos forma:

 UUIDv4 = function b( a // placeholder ){ return a // if the placeholder was passed, return ? ( // a random number from 0 to 15 a ^ // unless b is 8, Math.random() // in which case * 16 // a random number from >> a/4 // 8 to 11 ).toString(16) // in hexadecimal : ( // or otherwise a concatenated string: [1e7] + // 10000000 + -1e3 + // -1000 + -4e3 + // -4000 + -8e3 + // -80000000 + -1e11 // -100000000000, ).replace( // replacing /[018]/g, // zeroes, ones, and eights with b // random hex digits ) } 
55
15 авг. Jed Schmidt atsakymas, rugpjūčio 15 d. 2011-08-15 05:27 '11 at 5:27 am 2011-08-15 05:27

Čia yra visiškai nesuderinamas, bet labai efektyvus įgyvendinimas, siekiant sukurti unikalų identifikatorių su suderinamu ASCII GUID.

 function generateQuickGuid() { return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15); } 

Sukuria 26 [a-z0-9] simbolių, suteikiant trumpesnį ir unikalesnį UID nei RFC suderinamas GUID. Tylėjimas gali būti trivialiai pridedamas, jei svarbus žmogaus suprantamumas.

Čia pateikiami šios funkcijos naudojimo ir laiko nustatymo pavyzdžiai, o kai kurie iš jų yra kiti atsakymai. Datos buvo atliktos „Chrome“ m25, 10 mln. Iteracijų.

 >>> generateQuickGuid() "nvcjf1hs7tf8yyk4lmlijqkuo9" "yq6gipxqta4kui8z05tgh9qeel" "36dh5sec7zdj90sk2rx7pjswi2" runtime: 32.5s >>> GUID() // John Millikin "7a342ca2-e79f-528e-6302-8f901b0b6888" runtime: 57.8s >>> regexGuid() // broofa "396e0c46-09e4-4b19-97db-bd423774a4b3" runtime: 91.2s >>> createUUID() // Kevin Hakanson "403aa1ab-9f70-44ec-bc08-5d5ac56bd8a5" runtime: 65.9s >>> UUIDv4() // Jed Schmidt "f4d7d31f-fa83-431a-b30c-3e6cc37cc6ee" runtime: 282.4s >>> Math.uuid() // broofa "5BD52F55-E68F-40FC-93C2-90EE069CE545" runtime: 225.8s >>> Math.uuidFast() // broofa "6CB97A68-23A2-473E-B75B-11263781BBE6" runtime: 92.0s >>> Math.uuidCompact() // broofa "3d7b7a06-0a67-4b67-825c-e5c43ff8c1e8" runtime: 229.0s >>> bitwiseGUID() // jablko "baeaa2f-7587-4ff1-af23-eeab3e92" runtime: 79.6s >>>> betterWayGUID() // Andrea Turri "383585b0-9753-498d-99c3-416582e9662c" runtime: 60.0s >>>> UUID() // John Fowler "855f997b-4369-4cdb-b7c9-7142ceaf39e8" runtime: 62.2s 

Čia yra sinchronizavimo kodas.

 var r; console.time('t'); for (var i = 0; i < 10000000; i++) { r = FuncToTest(); }; console.timeEnd('t'); 
54
15 нояб. atsakymas, kurį pateikė Joelpt lapkričio 15 d 2012-11-15 21:04 '12 at 9:04 PM 2012-11-15 21:04

Galite naudoti mazgo-uuid ( https://github.com/kelektiv/node-uuid )

Paprasta, greita RFC4122 UUIDS generacija.

Savybės:

  • Sukurkite UUID RFC4122 1 arba 4 versiją
  • Veikia node.js ir naršyklėse.
  • Kriptografiškai stiprus atsitiktinių skaičių generavimas pagalbinėse platformose.
  • Mažas pėdsakas (noriu kažką mažesnio?)

Įdiegti naudojant NPM:

 npm install uuid 

Arba naudodami uuid per naršyklę:

Atsisiųskite „Raw“ failą (uuid v1): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v1.js Atsisiųskite „Raw“ failą (uuid v4): https://raw.githubusercontent.com/kelektiv/node -uuid / master / v4.js


Norite dar mažiau? Patikrinkite: https://gist.github.com/jed/982883


Naudoti:

 // Generate a v1 UUID (time-based) const uuidV1 = require('uuid/v1'); uuidV1(); // -> '6c84fb90-12c4-11e1-840d-7b25c5ee775a' // Generate a v4 UUID (random) const uuidV4 = require('uuid/v4'); uuidV4(); // -> '110ec58a-a0f2-4ac4-8393-c866d813b8d1' // Generate a v5 UUID (namespace) const uuidV5 = require('uuid/v5'); // ... using predefined DNS namespace (for domain names) uuidV5('hello.example.com', v5.DNS)); // -> 'fdda765f-fc57-5604-a269-52a7df8164ec' // ... using predefined URL namespace (for, well, URLs) uuidV5('http://example.com/hello', v5.URL); // -> '3bbcee75-cecc-5b56-8031-b6641c1ed1f1' // ... using a custom namespace const MY_NAMESPACE = '(previously generated unique uuid string)'; uuidV5('hello', MY_NAMESPACE); // -> '90123e1c-7512-523e-bb28-76fab9f2f73d' 

ES6:

 import uuid from 'uuid/v4'; const id = uuid(); 
32
ответ дан Kyros Koh 13 окт. '15 в 4:50 2015-10-13 04:50

Из технического журнала sagi shkedy :

 function generateGuid() { var result, i, j; result = ''; for(j=0; j<32; j++) { if( j == 8 || j == 12 || j == 16 || j == 20) result = result + '-'; i = Math.floor(Math.random()*16).toString(16).toUpperCase(); result = result + i; } return result; }