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 verwende diese Version. Sie ist sicher und einfach. Es ist nicht formatiert uids zu generieren, ist es nur zufällige Zeichenfolgen von Zeichen, die Sie benötigen, zu generieren.

export function makeId(length) {
  let result = '';
  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  const charactersLength = characters.length;

  for (let i = 0; i < length; i++) {
    let letterPos = crypto.getRandomValues(new Uint8Array(1))[0] / 255 * charactersLength - 1
    result += characters[letterPos]
  }
  return result;
}

Answer 2

Die coolste Art:

function uuid(){
    var u = URL.createObjectURL(new Blob([""]))
    URL.revokeObjectURL(u);
    return u.split("/").slice(-1)[0]
}

Es ist wahrscheinlich nicht schnell, effizient, oder unterstützt in IE2, aber es ist sicher cool

Answer 3

Hier ein praktisches Beispiel. Es erzeugt eine 32-stellige einzigartig UUID.

function generateUUID() {
    var d = new Date();
    var k = d.getTime();
    var str = k.toString(16).slice(1)
    var UUID = 'xxxx-xxxx-4xxx-yxxx-xzx'.replace(/[xy]/g, function (c)
    {
        var r = Math.random() * 16 | 0;
        v = c == 'x' ? r : (r & 3 | 8);
        return v.toString(16);
    });

    var newString = UUID.replace(/[z]/, str)
    return newString;
}

var x = generateUUID()
console.log(x, x.length)

Answer 4

Dieses Angebot liefert 5 Gruppen von 8 Ziffern von a-z,0-9 Das meiste davon ist zufällig, aber es berücksichtigt die Tageszeit und hat einen zufällig aufsteigenden Zähler. Sie können jede beliebige Basis angeben (hex, dezimal, 36), standardmäßig wird für jede 8er-Gruppe eine zufällige Basis im Bereich von Basis 16 bis 36 gewählt.

function newId(base) {
return[
 Math.random,
 function (){ return (newId.last ? windowId.last + Math.random() : Math.random() ) },
 Math.random,
 Date.now,
 Math.random
].map(function(fn){
    return fn().toString(base||(16+(Math.random()*20))).substr(-8);
}).join('-');
}

var demo = function(base){
    document.getElementById('uuid').textContent = newId(base);
}
demo(16);

#uuid { font-family: monospace; font-size: 1.5em; }

<p id="uuid"></p>
<button onclick="demo(16);">Hex (base 16)</button>
<button onclick="demo(36);">Base 36</button>
<button onclick="demo(10);">Decimal (base 10)</button>
<button onclick="demo();">Random base</button>

Answer 5

Dies ist nur ein Konzept, das sicherlich in vielerlei Hinsicht verbessert werden kann, aber nicht so langsam ist, wie ich dachte.

Im Allgemeinen enthält dieser Code einen hexadezimal kodierten Zeitstempel in Millisekunden (mit etwas Hacking ergibt er 12 Ziffern, so dass der Code auch nach 2527-06-24 funktioniert, aber nicht nach 5138-11-16), was bedeutet, dass er sortierbar ist. Es ist nicht so zufällig, es verwendet die MAC-Adresse für die letzten 12 Ziffern. Der 13. Buchstabe ist fest mit 1 kodiert, damit er sortierbar bleibt.

Danach kommen die nächsten 6 Ziffern aus einer halbzufälligen Zeichenfolge, wobei die ersten Ziffern aus der Anzahl der in dieser Millisekunde erzeugten Datensätze stammen und die anderen Ziffern zufällig erzeugt werden. Dieser 6-stellige Teil enthält einen Bindestrich und den hart kodierten Buchstaben "a", um die Datensätze sortierbar zu halten.

Ich weiß, dass man das Verfahren verkürzen und die Leistung verbessern könnte, aber ich bin mit den Ergebnissen zufrieden (außer der MAC-Adresse).

currentNanoseconds = () => {
  return nodeMode ? process.hrtime.bigint() : BigInt(Date.now() * 1000000);
}

nodeFindMacAddress = () => {
  // Extract MAC address
  const interfaces = require('os').networkInterfaces();
  let result = null;
  for (index in interfaces) {
    let entry = interfaces[index];
    entry.forEach(item => {
      if (item.mac !== '00:00:00:00:00:00') {
        result = '-' + item.mac.replace(/:/g, '');
      }
    });
  }
  return result;
}

const nodeMode = typeof(process) !== 'undefined';
let macAddress = nodeMode ? nodeFindMacAddress() : '-a52e99ef5efc';
let startTime = currentNanoseconds();

let uuids = []; // Array for storing generated UUIDs, useful for testing
let currentTime = null; // Holds the last value of Date.now(), used as a base for generating the UUID
let timePart = null; // Part of the UUID generated from Date.now()
let counter = 0; // Used for counting records created at certain millisecond
let lastTime = null; // Used for resetting the record counter

const limit = 1000000;

for (let testCounter = 0; testCounter < limit; testCounter++) {
  let uuid = testMe();

  if (nodeMode || testCounter <= 50) {
    uuids.push(uuid);
  }
}

const timePassed = Number(currentNanoseconds() - startTime);

if (nodeMode) {
  const fs = require('fs');
  fs.writeFileSync('temp.txt', JSON.stringify(uuids).replace(/,/g, ',\n'));
} else {
  console.log(uuids);
}

console.log({
  operationsPerSecond: (1000 * limit / timePassed).toString() + 'm',
  nanosecondsPerCycle: timePassed / limit,
  milliSecondsPassed: timePassed / 1000000,
  microSecondsPassed: timePassed / 1000,
  nanosecondsPassed: timePassed
});

function testMe() {
  currentTime = Date.now();
  let uuid = null; // Function result

  if (currentTime !== lastTime) {
    // Added a 9 before timestamp, so that the hex-encoded timestamp is 12 digits long. Currently, it is 11 digits long, and it will be until 2527-06-24
    // console.log(Date.parse("2527-06-24").toString(16).length)
    // Code will stop working on 5138-11-17, because the timestamp will be 15 digits long, and the code only handles up to 14 digit timestamps
    // console.log((Date.parse("5138-11-17")).toString().length)
    timePart = parseInt(('99999999999999' + currentTime).substr(-14)).toString(16);
    timePart = timePart.substr(0, 8) + '-' + timePart.substr(8, 4) + '-1';
    counter = 0;
  }

  randomPart = ('000000' + Math.floor(10 * (counter + Math.random()))).slice(-6);
  randomPart = randomPart.substr(0, 3) + '-a' + randomPart.substr(3, 3);
  uuid = timePart + randomPart + macAddress;

  counter++;

  lastTime = currentTime;

  return uuid;
}