Wie man eine GUID / UUID erstellt

Question

Ich versuche, in JavaScript global eindeutige Bezeichner zu erstellen. Ich bin mir nicht sicher, welche Routinen in allen Browsern verfügbar sind, wie "zufällig" und gesetzt der eingebaute Zufallszahlengenerator ist, usw.

Die GUID / UUID sollte mindestens 32 Zeichen lang sein und im ASCII-Bereich bleiben, um Probleme bei der Weitergabe zu vermeiden.

Answer 1

Ich habe auf allem, was hier erwähnt wurde, aufgebaut, um etwas doppelt so Schnelles zu erzeugen, das in allen Umgebungen, einschließlich Node, portabel ist, und habe von Math.random() auf kryptostarke Zufälligkeit umgestellt. Man könnte meinen, dass eine UUID keine Kryptostärke braucht, aber das bedeutet, dass die Wahrscheinlichkeit einer Kollision noch geringer ist, was der ganze Sinn einer UUID ist.

function random() {
    const
        fourBytesOn = 0xffffffff, // 4 bytes, all 32 bits on: 4294967295
        c = typeof crypto === "object"
            ? crypto // Node.js or most browsers
            : typeof msCrypto === "object" // Stinky non-standard Internet Explorer
                ? msCrypto // eslint-disable-line no-undef
                : null; // What old or bad environment are we running in?
        return c
            ? c.randomBytes
                ? parseInt(c.randomBytes(4).toString("hex"), 16) / (fourBytesOn + 1) - Number.EPSILON // Node.js
                : c.getRandomValues(new Uint32Array(1))[0] / (fourBytesOn + 1) - Number.EPSILON // Browsers
            : Math.random();
}

function uuidV4() { // eslint-disable-line complexity
    // If possible, generate a single random value, 128 bits (16 bytes)
    // in length. In an environment where that is not possible, generate
    // and make use of four 32-bit (4-byte) random values.
    // Use crypto-grade randomness when available, else Math.random()
    const
        c = typeof crypto === "object"
            ? crypto // Node.js or most browsers
            : typeof msCrypto === "object" // Stinky non-standard Internet Explorer
                ? msCrypto // eslint-disable-line no-undef
            : null; // What old or bad environment are we running in?
    let
        byteArray = c
            ? c.randomBytes
                ? c.randomBytes(16) // Node.js
                : c.getRandomValues(new Uint8Array(16)) // Browsers
            : null,
        uuid = [ ];

    /* eslint-disable no-bitwise */
    if ( ! byteArray) { // No support for generating 16 random bytes
                        // in one shot -- this will be slower
        const
            int = [
                random() * 0xffffffff | 0,
                random() * 0xffffffff | 0,
                random() * 0xffffffff | 0,
                random() * 0xffffffff | 0
            ];
        byteArray = [ ];
        for (let i = 0; i < 256; i++) {
            byteArray[i] = int[i < 4 ? 0 : i < 8 ? 1 : i < 12 ? 2 : 3] >> i % 4 * 8 & 0xff;
        }
    }
    byteArray[6] = byteArray[6] & 0x0f | 0x40; // Always 4, per RFC, indicating the version
    byteArray[8] = byteArray[8] & 0x3f | 0x80; // Constrained to [89ab], per RFC for version 4
    for (let i = 0; i < 16; ++i) {
        uuid[i] = (byteArray[i] < 16 ? "0" : "") + byteArray[i].toString(16);
    }
    uuid =
        uuid[ 0] + uuid[ 1] + uuid[ 2] + uuid[ 3] + "-" +
        uuid[ 4] + uuid[ 5]                       + "-" +
        uuid[ 6] + uuid[ 7]                       + "-" +
        uuid[ 8] + uuid[ 9]                       + "-" +
        uuid[10] + uuid[11] + uuid[12] + uuid[13] + uuid[14] + uuid[15];
    return uuid;
    /* eslint-enable no-bitwise */
}

Answer 2

Für die UUID gibt es derzeit einen Vorschlag zur Aufnahme in die Standardbibliothek, der hier unterstützt werden kann ECMAScript-Vorschlag: JavaScript-Standardbibliothek UUID

Der Vorschlag umfasst die folgenden UUIDs:

// We're not yet certain as to how the API will be accessed (whether it's in the global, or a
// future built-in module), and this will be part of the investigative process as we continue
// working on the proposal.
uuid(); // "52e6953d-edbe-4953-be2e-65ed3836b2f0"

Diese Implementierung folgt demselben Layout wie die V4-Zufalls-UUID-Generierung, die Sie hier finden: https://www.npmjs.com/package/uuid

const uuidv4 = require('uuid/v4');
uuidv4(); //  '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

Ich denke, es ist bemerkenswert, wie viel Bandbreite durch eine offizielle Implementierung in der Standardbibliothek eingespart werden könnte. Die Autoren des Vorschlags haben auch festgestellt:

Die 12 kB uuid Modul wird mehr als 62.000.000 Mal pro Monat von npm heruntergeladen (Juni 2019); die Bereitstellung in der Standardbibliothek spart letztendlich weltweit TB an Bandbreite. Wenn wir weiterhin Benutzeranforderungen wie uuid mit der Standardbibliothek erfüllen, summieren sich die Bandbreiteneinsparungen.

Answer 3

Basierend auf die Arbeit von broofa habe ich etwas mehr Zufälligkeit hinzugefügt, indem ich den Zeitstempel zu math.random() :

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

Answer 4

Hier finden Sie eine sehr kleine Funktion die UUIDs erzeugt.

Eine der endgültigen Fassungen lautet:

function b(
  a                  // Placeholder
){
  var cryptoObj = window.crypto || window.msCrypto; // For Internet Explorer 11
  return a           // If the placeholder was passed, return
    ? (              // a random number from 0 to 15
      a ^            // unless b is 8,
      cryptoObj.getRandomValues(new Uint8Array(1))[0]  // 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
      )
}

Answer 5

Wir können replace und crypto.getRandomValues verwenden, um eine Ausgabe wie diese zu erhalten:

xxxxxxxx-xxxx-4xxx-xxxx-xxxxxxxxxxxx

Wenn wir nach einer Opti-Lösung suchen, müssen wir die crypto.getRandomValues(new Uint8Array(1))[0] durch ein Array(32).

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

console.log(uuidv4());

Um diesen Code zu erhalten:

function uuidv4() {
  let bytes = window.crypto.getRandomValues(new Uint8Array(32));
  const randomBytes = () => (bytes = bytes.slice(1)) && bytes[0];

  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c =>
      (c ^ randomBytes() & 15 >> c / 4).toString(16)
    );
}

for (var i = 0; i < 10; i++)
  console.log(uuidv4());

Kollision:

Wir können es wie Google Analytics machen und einen Zeitstempel hinzufügen mit : uuidv4() + "." + (+new Date()) .