Jak utworzyć GUID / uuid

Dla RFC4122 rozwiązanie zgodne z wersją 4, To rozwiązanie jednoliniowe (ish) jest najbardziej kompaktowe, jakie mogłem wymyślić:

function uuidv4() {
  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(uuidv4());

Update, 2015-06-02: Należy pamiętać, że unikalność UUID zależy w dużej mierze od podstawowego generatora liczb losowych (RNG). Powyższe rozwiązanie wykorzystuje Math.random() dla zwięzłości, jednak Math.random() jest , a nie gwarantowane jako wysokiej jakości RNG. Zobacz doskonały tekst Adama Hylanda z matematyki.random () dla szczegółów. Na bardziej solidne rozwiązanie, rozważ użycie modułu uuid , który wykorzystuje wyższej jakości interfejsy API RNG.

Update, 2015-08-26: na marginesie, ten gist opisuje, jak określić, ile identyfikatorów można wygenerować przed osiągnięciem pewnego prawdopodobieństwa kolizji. Na przykład z 3. 26x10¹⁵ wersja 4 RFC4122 UUIDs MASZ 1 na milion szans na kolizję.

Aktualizacja, 2017-06-28 : a dobry artykuł od twórców Chrome omówienie stanu jakości PRNG w Chrome, Firefox i Safari. tl; dr - na koniec-2015 jest "całkiem dobry", ale nie Jakość kryptograficzna. Aby rozwiązać ten problem, Oto zaktualizowana wersja powyższego rozwiązania, które wykorzystuje ES6, API crypto i trochę Kreatora JavaScript, za który nie mogę wziąć kredytu :

function uuidv4() {
  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
  );
}

console.log(uuidv4());

Aktualizacja, 2020-01-06: istnieje propozycja w pracach dla standardowego modułu uuid w ramach JavaScript język

Naprawdę podoba mi się, jak czysta jest odpowiedź Broofa, ale szkoda, że słabe implementacje Math.random zostaw szansę na kolizję.

Oto podobne rozwiązanie zgodne z RFC4122 w wersji 4, które rozwiązuje ten problem poprzez przesunięcie pierwszych 13 liczb szesnastkowych o część szesnastkową znacznika czasu, a raz uszczuplone przesunięcia o część szesnastkową mikrosekund od obciążenia strony. W ten sposób, nawet jeśli Math.random jest na tym samym seed, obaj klienci musieliby wygenerować UUID dokładna liczba mikrosekund od pageload (jeśli jest obsługiwany czas wysokiej perfomancji) i przy tej samej milisekundzie (lub 10,000 + lat później), aby uzyskać ten sam UUID:

function generateUUID() { // Public Domain/MIT
    var d = new Date().getTime();//Timestamp
    var d2 = (performance && performance.now && (performance.now()*1000)) || 0;//Time in microseconds since page-load or 0 if unsupported
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        var r = Math.random() * 16;//random number between 0 and 16
        if(d > 0){//Use timestamp until depleted
            r = (d + r)%16 | 0;
            d = Math.floor(d/16);
        } else {//Use microseconds since page-load if supported
            r = (d2 + r)%16 | 0;
            d2 = Math.floor(d2/16);
        }
        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
    });
}

console.log(generateUUID())

tu masz skrzypce do przetestowania.

Odpowiedź Broofy jest całkiem sprytna , rzeczywiście-imponująco mądra, naprawdę... zgodny z rfc4122, nieco czytelny i kompaktowy. Super!

Ale jeśli patrzysz na to wyrażenie regularne, te wiele wywołań funkcji replace(), toString() i Math.random() (gdzie używa tylko 4 bitów wyniku i marnuje resztę), możesz zacząć się zastanawiać nad wydajnością. W rzeczywistości joelpt zdecydował się nawet odrzucić RFC dla ogólnej prędkości GUID z generateQuickGUID.

Ale czy możemy uzyskać prędkość i zgodność z RFC? Mówię, tak! Czy możemy zachować czytelność? Cóż... Nie bardzo, ale to proste, jeśli się nadążasz.

Ale najpierw moje wyniki, w porównaniu do broofa, guid (zaakceptowana odpowiedź) i nie-zgodny z rfc 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.

Więc przez moją szóstą iterację optymalizacji, pokonałem najpopularniejszą odpowiedź przez ponad 12x, zaakceptowaną odpowiedź przez ponad 9X , A szybką-niezgodną odpowiedź przez 2-3x. I nadal jestem rfc4122 zgodny.

Zainteresowany w jaki sposób? Umieściłem pełne źródło na http://jsfiddle.net/jcward/7hyaC/3 / i na http://jsperf.com/uuid-generator-opt/4

Dla wyjaśnienia, zacznijmy od kodu broofa:

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())

Zastępuje więc x dowolną przypadkową cyfrą szesnastkową, y przypadkowymi danymi (z wyjątkiem wymuszenia 2 pierwszych bitów na 10 zgodnie ze specyfikacją RFC), a regex nie pasuje do znaków - lub 4, więc nie ma żeby sobie z nimi poradzić. Bardzo, bardzo sprytne.

Pierwszą rzeczą, którą należy wiedzieć jest to, że wywołania funkcji są drogie, podobnie jak wyrażenia regularne (choć używa tylko 1, ma 32 wywołania zwrotne, po jednym dla każdego dopasowania, a w każdym z 32 wywołań zwrotnych wywołuje Math.random() i v. toString(16)).

Pierwszym krokiem w kierunku wydajności jest wyeliminowanie wyrażenia regularnego i jego funkcji zwrotnych i zamiast tego użycie prostej pętli. Oznacza to, że mamy do czynienia ze znakami - i 4, podczas gdy broofa nie. Zauważ również, że możemy użyć indeksowania tablicy łańcuchowej, aby zachować jego elegancką architekturę szablonów łańcuchowych: {]}

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())

Zasadniczo ta sama wewnętrzna logika, z wyjątkiem tego, że sprawdzamy pod kątem - lub 4, a użycie pętli while (zamiast replace() wywołań zwrotnych) daje nam prawie 3-krotną poprawę!

Następny krok jest mały na pulpicie, ale robi przyzwoitą różnicę na urządzeniach mobilnych. Mniej matematyki.random() wywołuje i wykorzystuje wszystkie losowe bity zamiast rzucać 87% z nich z przypadkowym buforem, który zostaje przesunięty w każdej iteracji. Przesuńmy również definicję szablonu z pętli, na wszelki wypadek, gdyby to pomogło:

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())

To oszczędza nam 10-30% w zależności od platformy. Nieźle. Ale następnym dużym krokiem pozbędzie się wywołań funkcji toString w całości z klasykiem optymalizacji-tabelą wyszukiwania. Prosta 16-elementowa tabela wyszukiwania wykona zadanie toString (16) w znacznie mniej czas:

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())

Kolejna optymalizacja to kolejny klasyk. Ponieważ obsługujemy tylko 4-bitowe wyjście w każdej iteracji pętli, przetnijmy liczbę pętli na pół i przetworzmy 8-bitową każdą iterację. Jest to trudne, ponieważ nadal musimy obsługiwać pozycje bitów zgodne z RFC, ale nie jest to zbyt trudne. Następnie musimy utworzyć większą tabelę wyszukiwania (16x16, lub 256), aby zapisać 0x00-0xff, i zbudujemy ją tylko raz, poza e5() funkcja.

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())

Próbowałem E6 (), która przetwarza 16-bitowe na raz, nadal używając 256-elementowego LUT i pokazała malejące zwroty optymalizacji. Chociaż miał mniej iteracji, wewnętrzna logika była skomplikowana przez zwiększone przetwarzanie i działała tak samo na komputerze stacjonarnym, a tylko ~10% szybciej na urządzeniach mobilnych.

Ostateczna technika optymalizacji do zastosowania-rozwiń pętlę. Ponieważ zapętlamy określoną liczbę razy, możemy technicznie napisz to wszystko ręcznie. Próbowałem tego raz z pojedynczą zmienną losową r, którą ponownie przypisywałem, a wydajność spadła. Jednak z czterema zmiennymi przypisanymi do losowych danych z przodu, a następnie za pomocą tabeli wyszukiwania i stosując odpowiednie bity RFC, ta wersja pali je wszystkie:

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())

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

Zabawne jest to, że generowanie 16 bajtów losowych danych jest łatwą częścią. Cała sztuczka wyraża jest w formacie String z zgodnością z RFC, a to jest ściśle wykonane z 16 bajtów losowych danych, rozwijanej pętli i tabeli wyszukiwania.

Mam nadzieję, że moja logika jest poprawna -- bardzo łatwo jest popełnić błąd w tego rodzaju żmudnej pracy nad bitem. Ale wyjścia wyglądają dobrze dla mnie. Mam nadzieję, że podobała ci się ta szalona jazda przez optymalizację kodu!

Uwaga: [32]} moim głównym celem było pokazanie i nauczenie potencjalnych strategii optymalizacji. Inne odpowiedzi dotyczą ważnych tematów takich jako kolizje i naprawdę losowe liczby, które są ważne dla generowania dobrych uuid.

let uniqueId = Date.now().toString(36) + Math.random().toString(36).substring(2);

document.getElementById("unique").innerHTML =
  Math.random().toString(36).substring(2) + (new Date()).getTime().toString(36);

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

Jeśli identyfikatory są generowane w odległości większej niż 1 milisekunda, są w 100% unikalne.

Jeśli dwa ID są generowane w krótszych odstępach czasu i zakładając, że metoda losowa jest naprawdę losowa, wygeneruje to ID, które są 99.99999999999999999% prawdopodobnie będą unikalne globalnie (kolizja w 1 z 10^15)

Możesz zwiększyć tę liczbę dodając więcej cyfr, ale aby wygenerować 100% unikalnych identyfikatorów, musisz użyć globalnego licznika.

Jeśli potrzebujesz Kompatybilność z RFC, formatowanie to przejdzie jako ważny identyfikator GUID wersji 4:

let u = Date.now().toString(16) + Math.random().toString(16) + '0'.repeat(16);
let guid = [u.substr(0,8), u.substr(8,4), '4000-8' + u.substr(13,3), u.substr(16,12)].join('-');

let u = Date.now().toString(16)+Math.random().toString(16)+'0'.repeat(16);
let guid = [u.substr(0,8), u.substr(8,4), '4000-8' + u.substr(13,3), u.substr(16,12)].join('-');
document.getElementById("unique").innerHTML = guid;

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

Edit: powyższy kod jest zgodny z intencją, ale nie z literą RFC. Wśród innych rozbieżności jest kilka losowych cyfr. (Dodaj więcej losowych cyfr, jeśli potrzebujesz) plusem jest to, że jest to naprawdę szybkie :) Możesz przetestować ważność swojego GUID tutaj

Oto kod oparty na RFC 4122 , sekcja 4.4 (algorytmy tworzenia UUID z prawdziwie losowej lub Pseudolosowej liczby).

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;
}

Najszybsza Metoda GUID jak string generator w formacie XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX. Nie generuje to zgodnego ze standardami identyfikatora GUID.

Dziesięć milionów wykonań tej implementacji zajmuje tylko 32,5 sekundy, co jest najszybsze, jakie kiedykolwiek widziałem w przeglądarce (jedyne rozwiązanie bez pętli/iteracji).

Funkcja jest prosta:

/**
 * Generates a GUID string.
 * @returns {string} The generated GUID.
 * @example af8a8416-6e18-a307-bd9c-f2c947bbb3aa
 * @author Slavik Meltser.
 * @link http://slavik.meltser.info/?p=142
 */
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();
}

Aby przetestować wydajność, możesz uruchomić ten kod:

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

Jestem pewien, że większość z was zrozumie, co tam zrobiłem, ale może tam jest co najmniej jedną osobą, która będzie potrzebowała wyjaśnienia:

Algorytm:

• Funkcja Math.random() Zwraca liczbę dziesiętną od 0 do 1 z 16 cyframi po punkcie ułamka dziesiętnego (dla przykład 0.4363923368509859).
• następnie bierzemy tę liczbę i konwertujemy to do Ciągu o podstawie 16 (z powyższego przykładu otrzymamy 0.6fb7687f).
  Math.random().toString(16).
• następnie odcinamy prefiks 0. (0.6fb7687f => 6fb7687f) i otrzymujemy ciąg znaków z ośmioma szesnastkami postacie długa.
  (Math.random().toString(16).substr(2,8).
• czasami Funkcja Math.random() zwróci krótsza Liczba (na przykład 0.4363), ze względu na zera na końcu (z powyższego przykładu, w rzeczywistości liczba to 0.4363000000000000). Dlatego dodaję do tego ciągu "000000000" (ciąg z dziewięcioma zerami), a następnie odcinam go za pomocą funkcji substr(), aby uczynić go dokładnie dziewięcioma znakami (wypełniając zera po prawej stronie).
• powodem dodania dokładnie dziewięciu zer jest gorszy scenariusz, czyli gdy Math.random() funkcja zwróci dokładnie 0 LUB 1 (prawdopodobieństwo 1/10^16 dla każdego z nich). Dlatego musieliśmy dodać do niego dziewięć zer ("0"+"000000000" lub "1"+"000000000"), a następnie odciąć go od drugiego indeksu (trzeciego znaku) o długości ośmiu znaków. W pozostałych przypadkach dodanie zer nie zaszkodzi wynikowi, ponieważ i tak go odcina.
  Math.random().toString(16)+"000000000").substr(2,8).

Zgromadzenie:

• GUID jest w następującym formacie XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.
• podzieliłem GUID na 4 kawałki, każdy kawałek podzielony na 2 typy (lub formaty): XXXXXXXX i -XXXX-XXXX.
• teraz buduję GUID używając tych 2 typów do złożenia GUID z wywołaniem 4 sztuk, w następujący sposób: XXXXXXXX -XXXX-XXXX -XXXX-XXXX XXXXXXXX.
• aby odróżnić te dwa typy, dodałem parametr flag do funkcji kreatora pary _p8(s), parametr s mówi funkcji, czy dodać myślniki, czy nie.
• ostatecznie budujemy GUID za pomocą następującego łańcucha: _p8() + _p8(true) + _p8(true) + _p8() i zwracamy to.

Link do tego wpisu na moim blogu

Smacznego! :-)

Oto całkowicie niezgodna, ale bardzo wydajna implementacja do generowania unikalnego identyfikatora GUID ASCII.

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

Generuje 26 znaków [a-z0-9], dając UID, który jest krótszy i bardziej unikalny niż zgodne z RFC GUID. Myślniki mogą być trywialnie dodane, jeśli liczy się czytelność człowieka.

Oto przykłady użycia i czasy dla tej funkcji oraz kilka innych odpowiedzi na to pytanie. Czas został wykonany pod chromem M25, 10 milionów iteracji każdy.

>>> 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

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

Oto kombinacja top voted answer , z obejściem dla zderzeń Chrome ' a :

generateGUID = (typeof(window.crypto) != 'undefined' &&
                typeof(window.crypto.getRandomValues) != 'undefined') ?
    function() {
        // If we have a cryptographically secure PRNG, use that
        // https://stackoverflow.com/questions/6906916/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&0x3|0x8);
            return v.toString(16);
        });
    };

Jest to na jsbin Jeśli chcesz go przetestować.

Oto rozwiązanie datowane na Październik. 9, 2011 z komentarza użytkownika jed w 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)}

To osiąga ten sam cel co aktualna najwyżej oceniana ODPOWIEDŹ , ale w 50 + mniej bajtów, wykorzystując przymus, rekurencję i notację wykładniczą. Dla ciekawych, Jak to działa, oto annotowana forma starszej wersji funkcji:

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
      )
}

Z technicznego bloga 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;
}

Istnieją inne metody, które wymagają użycia kontrolki ActiveX , ale trzymaj się od nich z daleka!

Pomyślałem, że warto zwrócić uwagę, że żaden generator GUID nie może zagwarantować unikalnych kluczy(sprawdź artykuł W Wikipedii ). Zawsze jest szansa na kolizję. GUID po prostu oferuje wystarczająco duży wszechświat klawiszy, aby zmniejszyć zmianę kolizji do prawie zerowego.

Możesz użyć node-uuid ( https://github.com/kelektiv/node-uuid )

Proste, szybkie generowanie RFC4122 uuid.

Cechy:

• generowanie identyfikatorów uuid RFC4122 w wersji 1 lub 4
• Działa w node.js i przeglądarki.
• silne kryptograficznie losowe # generowanie na platformach wspierających.
• Small footprint (chcesz coś mniejszego? Zobacz to!)

Zainstaluj Za Pomocą NPM:

npm install uuid

Lub używając uuid poprzez przeglądarkę:

Pobierz plik Raw (uuid v1): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v1.js Pobierz plik Raw (uuid v4): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v4.js

Użycie:

// 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();

var uuid = function() {
    var buf = new Uint32Array(4);
    window.crypto.getRandomValues(buf);
    var idx = -1;
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        idx++;
        var r = (buf[idx>>3] >> ((idx%8)*4))&15;
        var v = c == 'x' ? r : (r&0x3|0x8);
        return v.toString(16);
    });
};

Ta wersja jest oparta na odpowiedzi Briguy37 i niektórych operatorach bitowych, aby wyodrębnić okna o małych rozmiarach z bufora.

Powinien on być zgodny ze schematem RFC Type 4 (random), ponieważ ostatnio miałem problemy podczas parsowania niezgodnych uuid z uuid Javy.

Tworzy to UUID wersji 4 (utworzony z pseudo liczb losowych):

function uuid()
{
   var chars = '0123456789abcdef'.split('');

   var uuid = [], rnd = Math.random, r;
   uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
   uuid[14] = '4'; // version 4

   for (var i = 0; i < 36; i++)
   {
      if (!uuid[i])
      {
         r = 0 | rnd()*16;

         uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r & 0xf];
      }
   }

   return uuid.join('');
}

Oto próbka wygenerowanych uuid:

682db637-0f31-4847-9cdf-25ba9613a75c
97d19478-3ab2-4aa1-b8cc-a1c3540f54aa
2eed04c9-2692-456d-a0fd-51012f947136

Prosty moduł JavaScript jako połączenie najlepszych odpowiedzi na to pytanie.

var crypto = window.crypto || window.msCrypto || null; // IE11 fix

var Guid = Guid || (function() {

  var EMPTY = '00000000-0000-0000-0000-000000000000';

  var _padLeft = function(paddingString, width, replacementChar) {
    return paddingString.length >= width ? paddingString : _padLeft(replacementChar + paddingString, width, replacementChar || ' ');
  };

  var _s4 = function(number) {
    var hexadecimalResult = number.toString(16);
    return _padLeft(hexadecimalResult, 4, '0');
  };

  var _cryptoGuid = function() {
    var buffer = new window.Uint16Array(8);
    window.crypto.getRandomValues(buffer);
    return [_s4(buffer[0]) + _s4(buffer[1]), _s4(buffer[2]), _s4(buffer[3]), _s4(buffer[4]), _s4(buffer[5]) + _s4(buffer[6]) + _s4(buffer[7])].join('-');
  };

  var _guid = function() {
    var currentDateMilliseconds = new Date().getTime();
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(currentChar) {
      var randomChar = (currentDateMilliseconds + Math.random() * 16) % 16 | 0;
      currentDateMilliseconds = Math.floor(currentDateMilliseconds / 16);
      return (currentChar === 'x' ? randomChar : (randomChar & 0x7 | 0x8)).toString(16);
    });
  };

  var create = function() {
    var hasCrypto = crypto != 'undefined' && crypto !== null,
      hasRandomValues = typeof(window.crypto.getRandomValues) != 'undefined';
    return (hasCrypto && hasRandomValues) ? _cryptoGuid() : _guid();
  };

  return {
    newGuid: create,
    empty: EMPTY
  };
})();

// DEMO: Create and show GUID
console.log(Guid.newGuid());

Użycie:

Guid.newGuid()

"c6c2d12f-d76b-5739-e551-07e6de5b0807"

Guid.empty

"00000000-0000-0000-0000-000000000000"

Cóż, to ma już kilka odpowiedzi, ale niestety nie ma" prawdziwego " losowego w tej grupie. Poniższa wersja jest adaptacją odpowiedzi broofa, ale zaktualizowana o "prawdziwą" funkcję losową, która wykorzystuje biblioteki kryptograficzne, jeśli są dostępne, oraz funkcję Alea() jako awaryjną.

  Math.log2 = Math.log2 || function(n){ return Math.log(n) / Math.log(2); }
  Math.trueRandom = (function() {
  var crypt = window.crypto || window.msCrypto;

  if (crypt && crypt.getRandomValues) {
      // if we have a crypto library, use it
      var random = function(min, max) {
          var rval = 0;
          var range = max - min;
          if (range < 2) {
              return min;
          }

          var bits_needed = Math.ceil(Math.log2(range));
          if (bits_needed > 53) {
            throw new Exception("We cannot generate numbers larger than 53 bits.");
          }
          var bytes_needed = Math.ceil(bits_needed / 8);
          var mask = Math.pow(2, bits_needed) - 1;
          // 7776 -> (2^13 = 8192) -1 == 8191 or 0x00001111 11111111

          // Create byte array and fill with N random numbers
          var byteArray = new Uint8Array(bytes_needed);
          crypt.getRandomValues(byteArray);

          var p = (bytes_needed - 1) * 8;
          for(var i = 0; i < bytes_needed; i++ ) {
              rval += byteArray[i] * Math.pow(2, p);
              p -= 8;
          }

          // Use & to apply the mask and reduce the number of recursive lookups
          rval = rval & mask;

          if (rval >= range) {
              // Integer out of acceptable range
              return random(min, max);
          }
          // Return an integer that falls within the range
          return min + rval;
      }
      return function() {
          var r = random(0, 1000000000) / 1000000000;
          return r;
      };
  } else {
      // From https://web.archive.org/web/20120502223108/http://baagoe.com/en/RandomMusings/javascript/
      // Johannes Baagøe <[email protected]>, 2010
      function Mash() {
          var n = 0xefc8249d;

          var mash = function(data) {
              data = data.toString();
              for (var i = 0; i < data.length; i++) {
                  n += data.charCodeAt(i);
                  var h = 0.02519603282416938 * n;
                  n = h >>> 0;
                  h -= n;
                  h *= n;
                  n = h >>> 0;
                  h -= n;
                  n += h * 0x100000000; // 2^32
              }
              return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
          };

          mash.version = 'Mash 0.9';
          return mash;
      }

      // From http://baagoe.com/en/RandomMusings/javascript/
      function Alea() {
          return (function(args) {
              // Johannes Baagøe <[email protected]>, 2010
              var s0 = 0;
              var s1 = 0;
              var s2 = 0;
              var c = 1;

              if (args.length == 0) {
                  args = [+new Date()];
              }
              var mash = Mash();
              s0 = mash(' ');
              s1 = mash(' ');
              s2 = mash(' ');

              for (var i = 0; i < args.length; i++) {
                  s0 -= mash(args[i]);
                  if (s0 < 0) {
                      s0 += 1;
                  }
                  s1 -= mash(args[i]);
                  if (s1 < 0) {
                      s1 += 1;
                  }
                  s2 -= mash(args[i]);
                  if (s2 < 0) {
                      s2 += 1;
                  }
              }
              mash = null;

              var random = function() {
                  var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32
                  s0 = s1;
                  s1 = s2;
                  return s2 = t - (c = t | 0);
              };
              random.uint32 = function() {
                  return random() * 0x100000000; // 2^32
              };
              random.fract53 = function() {
                  return random() +
                      (random() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53
              };
              random.version = 'Alea 0.9';
              random.args = args;
              return random;

          }(Array.prototype.slice.call(arguments)));
      };
      return Alea();
  }
}());

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

Projekt JavaScript na GitHub- https://github.com/LiosK/UUID.js

UUID.js zgodny z RFC generator UUID dla JavaScript.

Zobacz RFC 4122 http://www.ietf.org/rfc/rfc4122.txt .

Funkcje generują uuid zgodne z RFC 4122.

UID w wersji 4 (uuid z liczb losowych) i uuid w wersji 1 (uuid oparte na czasie) są dostępne.

Obiekt uuid pozwala na różnoraki dostęp do UUID w tym dostęp do pola UUID.

Niska rozdzielczość znacznika czasu JavaScript jest kompensowana przez losowe liczby.

  // RFC 4122
  //
  // A UUID is 128 bits long
  //
  // String representation is five fields of 4, 2, 2, 2, and 6 bytes.
  // Fields represented as lowercase, zero-filled, hexadecimal strings, and
  // are separated by dash characters
  //
  // A version 4 UUID is generated by setting all but six bits to randomly
  // chosen values
  var uuid = [
    Math.random().toString(16).slice(2, 10),
    Math.random().toString(16).slice(2, 6),

    // Set the four most significant bits (bits 12 through 15) of the
    // time_hi_and_version field to the 4-bit version number from Section
    // 4.1.3
    (Math.random() * .0625 /* 0x.1 */ + .25 /* 0x.4 */).toString(16).slice(2, 6),

    // Set the two most significant bits (bits 6 and 7) of the
    // clock_seq_hi_and_reserved to zero and one, respectively
    (Math.random() * .25 /* 0x.4 */ + .5 /* 0x.8 */).toString(16).slice(2, 6),

    Math.random().toString(16).slice(2, 14)].join('-');

Chciałem zrozumieć odpowiedź broofa, więc rozszerzyłem ją i dodałem Komentarze:

var uuid = function () {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(
        /[xy]/g,
        function (match) {
            /*
            * Create a random nibble. The two clever bits of this code:
            *
            * - Bitwise operations will truncate floating point numbers
            * - For a bitwise OR of any x, x | 0 = x
            *
            * So:
            *
            * Math.random * 16
            *
            * creates a random floating point number
            * between 0 (inclusive) and 16 (exclusive) and
            *
            * | 0
            *
            * truncates the floating point number into an integer.
            */
            var randomNibble = Math.random() * 16 | 0;

            /*
            * Resolves the variant field. If the variant field (delineated
            * as y in the initial string) is matched, the nibble must
            * match the mask (where x is a do-not-care bit):
            *
            * 10xx
            *
            * This is achieved by performing the following operations in
            * sequence (where x is an intermediate result):
            *
            * - x & 0x3, which is equivalent to x % 3
            * - x | 0x8, which is equivalent to x + 8
            *
            * This results in a nibble between 8 inclusive and 11 exclusive,
            * (or 1000 and 1011 in binary), all of which satisfy the variant
            * field mask above.
            */
            var nibble = (match == 'y') ?
                (randomNibble & 0x3 | 0x8) :
                randomNibble;

            /*
            * Ensure the nibble integer is encoded as base 16 (hexadecimal).
            */
            return nibble.toString(16);
        }
    );
};

Dla tych, którzy chcą rozwiązanie zgodne z RFC 4122 wersja 4 z uwzględnieniem szybkości (kilka wywołań do matematyki.random ()):

var rand = Math.random;

function UUID() {
    var nbr, randStr = "";
    do {
        randStr += (nbr = rand()).toString(16).substr(3, 6);
    } while (randStr.length < 30);
    return (
        randStr.substr(0, 8) + "-" +
        randStr.substr(8, 4) + "-4" +
        randStr.substr(12, 3) + "-" +
        ((nbr*4|0)+8).toString(16) + // [89ab]
        randStr.substr(15, 3) + "-" +
        randStr.substr(18, 12)
    );
}

console.log( UUID() );

Powyższa funkcja powinna mieć przyzwoitą równowagę między szybkością a losowością.

Dostosowałem swój własny generator UUID/GUID z dodatkami tutaj .

Używam następującego generatora liczb losowych Kybos, aby być nieco bardziej kryptograficznie dźwięcznym.

Poniżej mój skrypt z metodami Mash i Kybos z baagoe.com wykluczone.

//UUID/Guid Generator
// use: UUID.create() or UUID.createSequential()
// convenience:  UUID.empty, UUID.tryParse(string)
(function(w){
  // From http://baagoe.com/en/RandomMusings/javascript/
  // Johannes Baagøe <[email protected]>, 2010
  //function Mash() {...};

  // From http://baagoe.com/en/RandomMusings/javascript/
  //function Kybos() {...};

  var rnd = Kybos();

  //UUID/GUID Implementation from http://frugalcoder.us/post/2012/01/13/javascript-guid-uuid-generator.aspx
  var UUID = {
    "empty": "00000000-0000-0000-0000-000000000000"
    ,"parse": function(input) {
      var ret = input.toString().trim().toLowerCase().replace(/^[\s\r\n]+|[\{\}]|[\s\r\n]+$/g, "");
      if ((/[a-f0-9]{8}\-[a-f0-9]{4}\-[a-f0-9]{4}\-[a-f0-9]{4}\-[a-f0-9]{12}/).test(ret))
        return ret;
      else
        throw new Error("Unable to parse UUID");
    }
    ,"createSequential": function() {
      var ret = new Date().valueOf().toString(16).replace("-","")
      for (;ret.length < 12; ret = "0" + ret);
      ret = ret.substr(ret.length-12,12); //only least significant part
      for (;ret.length < 32;ret += Math.floor(rnd() * 0xffffffff).toString(16));
      return [ret.substr(0,8), ret.substr(8,4), "4" + ret.substr(12,3), "89AB"[Math.floor(Math.random()*4)] + ret.substr(16,3),  ret.substr(20,12)].join("-");
    }
    ,"create": function() {
      var ret = "";
      for (;ret.length < 32;ret += Math.floor(rnd() * 0xffffffff).toString(16));
      return [ret.substr(0,8), ret.substr(8,4), "4" + ret.substr(12,3), "89AB"[Math.floor(Math.random()*4)] + ret.substr(16,3),  ret.substr(20,12)].join("-");
    }
    ,"random": function() {
      return rnd();
    }
    ,"tryParse": function(input) {
      try {
        return UUID.parse(input);
      } catch(ex) {
        return UUID.empty;
      }
    }
  };
  UUID["new"] = UUID.create;

  w.UUID = w.Guid = UUID;
}(window || this));

Próbka ES6

const guid=()=> {
  const s4=()=> Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);     
  return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;
}

Jeśli potrzebujesz tylko losowego 128-bitowego ciągu w żadnym konkretnym formacie, możesz użyć:

function uuid() {
    return crypto.getRandomValues(new Uint32Array(4)).join('-');
}

Który zwróci coś w rodzaju 2350143528-4164020887-938913176-2513998651.

Kolejny bardziej czytelny wariant z dwiema mutacjami.

function uuid4()
{
  function hex (s, b)
  {
    return s +
      (b >>> 4   ).toString (16) +  // high nibble
      (b & 0b1111).toString (16);   // low nibble
  }

  let r = crypto.getRandomValues (new Uint8Array (16));

  r[6] = r[6] >>> 4 | 0b01000000; // Set type 4: 0100
  r[8] = r[8] >>> 3 | 0b10000000; // Set variant: 100

  return r.slice ( 0,  4).reduce (hex, '' ) +
         r.slice ( 4,  6).reduce (hex, '-') +
         r.slice ( 6,  8).reduce (hex, '-') +
         r.slice ( 8, 10).reduce (hex, '-') +
         r.slice (10, 16).reduce (hex, '-');
}

Rodzimy URL.createObjectURL generuje uuid. Możesz to wykorzystać.

function uuid() {
  const url = URL.createObjectURL(new Blob())
  const [id] = url.toString().split('/').reverse()
  URL.revokeObjectURL(url)
  return id
}

Wiem, to stare pytanie. Dla kompletności, jeśli twoim środowiskiem jest SharePoint, istnieje funkcja użytkowa o nazwie SP.Guid.newGuid (LINK MSDN , który tworzy nowy identyfikator GUID. Funkcja ta znajduje się wewnątrz sp.init.plik js. Jeśli przepisujesz tę funkcję (aby usunąć niektóre inne zależności z innych prywatnych funkcji), wygląda to tak:

var newGuid = function () {
    var result = '';
    var hexcodes = "0123456789abcdef".split("");

    for (var index = 0; index < 32; index++) {
        var value = Math.floor(Math.random() * 16);

        switch (index) {
        case 8:
            result += '-';
            break;
        case 12:
            value = 4;
            result += '-';
            break;
        case 16:
            value = value & 3 | 8;
            result += '-';
            break;
        case 20:
            result += '-';
            break;
        }
        result += hexcodes[value];
    }
    return result;
};

The better way:

function(
  a, b               // Placeholders
){
  for(               // Loop :)
      b = a = '';    // b - result , a - numeric variable
      a++ < 36;      //
      b += a*51&52   // If "a" is not 9 or 14 or 19 or 24
                  ?  //  return a random number or 4
           (
               a^15              // If "a" is not 15,
                  ?              // generate a random number from 0 to 15
               8^Math.random() *
               (a^20 ? 16 : 4)   // unless "a" is 20, in which case a random number from 8 to 11,
                  :
               4                 //  otherwise 4
           ).toString(16)
                  :
         '-'                     //  In other cases, (if "a" is 9,14,19,24) insert "-"
      );
  return b
 }

: {]}

function(a,b){for(b=a='';a++<36;b+=a*51&52?(a^15?8^Math.random()*(a^20?16:4):4).toString(16):'-');return b}

Ten jest oparty na dacie i dodaj losowy przyrostek, aby "zapewnić" wyjątkowość. Działa dobrze dla identyfikatorów css. Zawsze zwraca coś takiego i jest łatwy do zhakowania:

Uid-139410573297741

var getUniqueId = function (prefix) {
            var d = new Date().getTime();
            d += (parseInt(Math.random() * 100)).toString();
            if (undefined === prefix) {
                prefix = 'uid-';
            }
            d = prefix + d;
            return d;
        };

Prosty kod, który używa crypto.getRandomValues(a) na obsługiwanych przeglądarkach (IE11+, IOS7+, Ff21+, Chrome, Android Chrome). Unika używania Math.random(), ponieważ może to powodować kolizje (na przykład 20 kolizji dla 4000 wygenerowanych uuid w rzeczywistej sytuacji przez Muxa).

function uuid() {
    function randomDigit() {
        if (crypto && crypto.getRandomValues) {
            var rands = new Uint8Array(1);
            crypto.getRandomValues(rands);
            return (rands[0] % 16).toString(16);
        } else {
            return ((Math.random() * 16) | 0).toString(16);
        }
    }
    var crypto = window.crypto || window.msCrypto;
    return 'xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx'.replace(/x/g, randomDigit);
}

Uwagi:

• zoptymalizowany pod kątem czytelności kodu, a nie szybkości, więc nadaje się do powiedzmy kilkuset uuid na sekundę. Generuje około 10000 uuid () na sekundę w Chromium na moim laptopie za pomocą http://jsbin.com/fuwigo/1 do pomiaru wydajności.
• używa tylko 8 Dla "y", ponieważ upraszcza to czytelność kodu (Y może być 8, 9, A lub B).

OK, używając pakietu uuid, obsługa IT dla wersji 1, 3, 4 i 5 uuid do:

yarn add uuid

A następnie:

const uuidv1 = require('uuid/v1');
uuidv1(); // ⇨ '45745c60-7b1a-11e8-9c9c-2d42b21b1a3e'

Możesz to zrobić również za pomocą w pełni określonych opcji:

const v1options = {
  node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
  clockseq: 0x1234,
  msecs: new Date('2011-11-01').getTime(),
  nsecs: 5678
};
uuidv1(v1options); // ⇨ '710b962e-041c-11e1-9234-0123456789ab'

Aby uzyskać więcej informacji, odwiedź Stronę npm tutaj