Dla rozwiązania zgodnego z RFC4122 Wersja 4, To rozwiązanie jednowarstwowe (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ż coś w rodzaju Moduł uuid [Zastrzeżenie: Jestem autorem], który używa wyższej jakości interfejsów API RNG, jeśli są dostępne.

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 : Dobry artykuł od twórców Chrome omawiający Stan matematyki.losowa jakość 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ę JS wizardy, za które 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());

Naprawdę podoba mi się, jak czysta jest odpowiedź Broofa, ale szkoda, że słabe implementacje Math.random pozostawiają 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. W ten sposób, nawet jeśli Math.random znajduje się na tym samym seedu, obaj klienci będą musieli wygenerować UUID dokładnie w tej samej milisekundzie (lub 10,000+ lat później), aby uzyskać ten sam 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);
    });
}

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:

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

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 musi się z nimi zajmować. 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. Należy również pamiętać, że możemy użyć indeksowania tablicy ciągów, aby zachować jego elegancką architekturę szablonów ciągów:

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

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.funkcja random() wywołuje i wykorzystuje wszystkie te losowe bity zamiast wyrzucać 87% z nich za pomocą Losowego bufora, który otrzymuje / align = "left" / 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
}

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 krótszym czasie: {]}

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
}

Kolejna optymalizacja to kolejny klasyk. Ponieważ zajmujemy się tylko 4-bitami wyjście w każdej iteracji pętli, wytnijmy 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 funkcją 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
}

Próbowałem E6 (), która przetwarza 16 bitów na raz, nadal używając 256-elementowego LUT i pokazała malejące zwroty optymalizacja. 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 napisać to wszystko ręcznie. Próbowałem tego raz z pojedynczą zmienną losową r, którą ponownie przypisywałem, a wydajność spadła. Ale z czterema zmiennymi przypisanymi losowymi danymi w górę w tym celu należy użyć tabeli wyszukiwania i zastosować odpowiednie bity RFC, ta wersja usuwa 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];
}

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 polega na wyrażaniu jej w formacie String z zgodnością z RFC, a najlepiej jest to osiągnąć za pomocą 16 bajtów losowych danych, rozwijanej pętli i tabeli wyszukiwania.

Mam nadzieję, że moja logika jest poprawna -- to bardzo łatwe do popełnij błąd w tego rodzaju żmudnej pracy. 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 obejmują ważne tematy, takie jak kolizje i naprawdę losowe liczby, które są ważne dla generowania dobrych uuid.

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 ([email protected]).
 * @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! :-)

var uniqueId = Math.random().toString(36).substring(2) 
               + (new Date()).getTime().toString(36);

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.

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

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

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

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

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');

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!

EDIT: 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.

Przydałby się serwis internetowy.

Quick Google found: http://www.hoskinson.net/GuidGenerator/

Nie mogę ręczyć za tę implementację, ale ktoś musi opublikować generator GUID bonafide.

Dzięki takiej usłudze internetowej można stworzyć interfejs REST web, który zużywa usługę GUID i obsługuje ją przez AJAX do javascript w przeglądarce.

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

EDIT:

Ponownie odwiedziłem mój projekt, który używał tej funkcji i nie lubił słowności. - Ale potrzebowałem odpowiedniej przypadkowości.

Wersja oparta na odpowiedzi Briguy37 i niektórych operatorach bitowych do wyodrębniania okien o małych rozmiarach z bufora.

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

Prosty moduł JavaScript jako połączenie najlepszych odpowiedzi w tym wątku.

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"

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

From good ol' wikipedia there ' s a link to a javascript implementation of UUID.

Wygląda dość elegancko i być może można by go poprawić poprzez zasolenie Hashem adresu IP klienta. Ten hash może być wstawiony do dokumentu html po stronie serwera do użytku przez javascript po stronie klienta.

Aktualizacja: oryginalna strona miała shuffle, tutaj jest zaktualizowana wersja

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

This create version 4 UUID (created from pseudo random numbers):

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

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

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

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
              ?      // genetate 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}

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

To tylko proste wywołanie AJAX...

Po stronie serwera:

[WebMethod()]
public static string GenerateGuid()
{
    return Guid.NewGuid().ToString();
}

Po stronie klienta:

var myNewGuid = null;
PageMethods.GenerateGuid(
    function(result, userContext, methodName)
    {
        myNewGuid = result;
    },
    function()
    {
        alert("WebService call failed.");
    }
);

Dla tych, którzy chcą rozwiązania zgodnego z rfc4122 w wersji 4 z uwzględnieniem szybkości (kilka wywołań do Math.random ()):

function UUID() {
    var nbr, randStr = "";
    do {
        randStr += (nbr = Math.random()).toString(16).substr(2);
    } 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)
        ].join("");
}

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

Wiem, to stare pytanie. Dla kompletności, jeśli twoim środowiskiem jest SharePoint, istnieje funkcja użytkowa o nazwie SP.Guid.newGuid (msdn link), 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;
};

Istnieje wtyczka jQuery, która ładnie obsługuje Guid ' a @ http://plugins.jquery.com/project/GUID_Helper

jQuery.Guid.Value()

Zwraca wartość wewnętrznego identyfikatora Guid. Jeśli nie podano identyfikatora guid, zwraca nowy (wartość jest wtedy przechowywana wewnętrznie).

jQuery.Guid.New()

Zwraca nowy identyfikator Guid i ustawia jego wartość wewnętrznie.

jQuery.Guid.Empty()

Zwraca pusty identyfikator Guid 00000000-0000-0000-0000-0000000000000.

jQuery.Guid.IsEmpty()

Zwraca wartość logiczną. True if empty/undefined/blank / null.

jQuery.Guid.IsValid()

Zwraca wartość logiczną. True valid guid, false jeśli nie.

jQuery.Guid.Set()

Retrns Guid. Ustawia identyfikator Guid na podany przez użytkownika identyfikator Guid, jeśli jest nieprawidłowy, zwraca pusty identyfikator guid.

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()}`;
}

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

Dziwne, że nikt jeszcze o tym nie wspomniał, ale dla kompletności, jest mnóstwo generatorów guid na npm jestem skłonny założyć, że większość z nich działa również w przeglądarce.