Erstellen Sie eine eindeutige Nummer mit Javascript-Zeit

Ich muss im Handumdrehen eindeutige ID-Nummern mit Javascript generieren. In der Vergangenheit habe ich dazu eine Zahl mit der Zeit erstellt. Die Zahl würde sich aus dem vierstelligen Jahr, dem zweistelligen Monat, dem zweistelligen Tag, der zweistelligen Stunde, der zweistelligen Minute, der zweistelligen Sekunde und der dreistelligen Millisekunde zusammensetzen. Es würde also ungefähr so ​​aussehen: 20111104103912732 ... dies würde genug Sicherheit für eine eindeutige Nummer für meine Zwecke geben.

Es ist schon eine Weile her, seit ich das getan habe und ich habe den Code nicht mehr. Hat jemand den Code dafür oder einen besseren Vorschlag zum Generieren einer eindeutigen ID?

Wenn Sie nur eine eindeutige Nummer möchten, dann

var timestamp = new Date().getUTCMilliseconds();

würde dir eine einfache Nummer geben. Wenn Sie jedoch die lesbare Version benötigen, müssen Sie einige Schritte ausführen:

var now = new Date();

timestamp = now.getFullYear().toString(); // 2011
timestamp += (now.getMonth < 9 ? '0' : '') + now.getMonth().toString(); // JS months are 0-based, so +1 and pad with 0's
timestamp += ((now.getDate < 10) ? '0' : '') + now.getDate().toString(); // pad with a 0
... etc... with .getHours(), getMinutes(), getSeconds(), getMilliseconds()

Ein besserer Ansatz wäre:

new Date().valueOf();

anstatt

new Date().getUTCMilliseconds();

valueOf () ist "höchstwahrscheinlich" eine eindeutige Zahl. http://www.w3schools.com/jsref/jsref_valueof_date.asp .

Der kürzeste Weg, um eine Zahl zu erstellen, von der Sie ziemlich sicher sein können, ist unter so vielen verschiedenen Instanzen, wie Sie sich vorstellen können, eindeutig

Date.now() + Math.random()

Wenn der Funktionsaufruf einen Unterschied von 1 Millisekunde aufweist, wird zu 100% garantiert, dass eine andere Nummer generiert wird . Bei Funktionsaufrufen innerhalb derselben Millisekunde sollten Sie sich nur dann Sorgen machen, wenn Sie innerhalb derselben Millisekunde mehr als einige Millionen Nummern erstellen, was nicht sehr wahrscheinlich ist.

Weitere Informationen zur Wahrscheinlichkeit, innerhalb einer Millisekunde eine wiederholte Nummer zu erhalten, finden Sie unter https://stackoverflow.com/a/28220928/4617597

Dies kann einfach mit dem folgenden Code erreicht werden:

var date = new Date();
var components = [
    date.getYear(),
    date.getMonth(),
    date.getDate(),
    date.getHours(),
    date.getMinutes(),
    date.getSeconds(),
    date.getMilliseconds()
];

var id = components.join("");

Folgendes mache ich, wenn ich etwas kleineres als ein paar Zahlen möchte - Basis ändern.

var uid = (new Date().getTime()).toString(36)

Dies ist schneller als das Erstellen einer DateInstanz, verwendet weniger Code und erzeugt immer eine eindeutige Nummer (lokal):

function uniqueNumber() {
    var date = Date.now();

    // If created at same millisecond as previous
    if (date <= uniqueNumber.previous) {
        date = ++uniqueNumber.previous;
    } else {
        uniqueNumber.previous = date;
    }

    return date;
}

uniqueNumber.previous = 0;

jsfiddle: http://jsfiddle.net/j8aLocan/

Ich habe dies auf Bower und npm veröffentlicht: https://github.com/stevenvachon/unique-number

Sie können auch etwas Ausgefeilteres wie cuid , puid oder shortid verwenden , um eine Nicht-Zahl zu generieren.

ich benutze

Math.floor(new Date().valueOf() * Math.random())

Wenn also zufällig der Code zur gleichen Zeit ausgelöst wird, besteht auch eine winzige Chance, dass die Zufallszahlen gleich sind.

Dies sollte tun:

var uniqueNumber = new Date().getTime(); // milliseconds since 1st Jan. 1970

Wenn Sie nach einigen Millisekunden eine eindeutige Nummer Date.now()wünschen, verwenden Sie, wenn Sie sie innerhalb von for loopverwenden möchten, verwenden Sie sie Date.now() and Math.random()zusammen

eindeutige Nummer innerhalb einer for-Schleife

function getUniqueID(){
    for(var i = 0; i< 5; i++)
      console.log(Date.now() + ( (Math.random()*100000).toFixed()))
}
getUniqueID()

output :: alle Zahlen sind eindeutig

15598251485988384 155982514859810330 155982514859860737 155982514859882244 155982514859883316

eindeutige Nummer ohne Math.random()

function getUniqueID(){
        for(var i = 0; i< 5; i++)
          console.log(Date.now())
    }
    getUniqueID()

output :: Numbers werden wiederholt

1559825328327 1559825328327 1559825328327 1559825328328 1559825328328

Bei der Online-Untersuchung habe ich das folgende Objekt gefunden, das pro Sitzung eine eindeutige ID erstellt:

        window.mwUnique ={
        prevTimeId : 0,
        prevUniqueId : 0,
        getUniqueID : function(){
            try {
                var d=new Date();
                var newUniqueId = d.getTime();
                if (newUniqueId == mwUnique.prevTimeId)
                    mwUnique.prevUniqueId = mwUnique.prevUniqueId + 1;
                else {
                    mwUnique.prevTimeId = newUniqueId;
                    mwUnique.prevUniqueId = 0;
                }
                newUniqueId = newUniqueId + '' + mwUnique.prevUniqueId;
                return newUniqueId;                     
            }
            catch(e) {
                mwTool.logError('mwUnique.getUniqueID error:' + e.message + '.');
            }
        }            
    }

Es ist vielleicht hilfreich für einige Leute.

Prost

Andrew

Dies sollte auch tun:

(function() {
    var uniquePrevious = 0;
    uniqueId = function() {
        return uniquePrevious++;
    };
}());

In ES6:

const ID_LENGTH = 36
const START_LETTERS_ASCII = 97 // Use 64 for uppercase
const ALPHABET_LENGTH = 26

const uniqueID = () => [...new Array(ID_LENGTH)]
  .map(() => String.fromCharCode(START_LETTERS_ASCII + Math.random() * ALPHABET_LENGTH))
 .join('')

Beispiel:

 > uniqueID()
 > "bxppcnanpuxzpyewttifptbklkurvvetigra"

Erhalten Sie immer eine eindeutige ID in JS

function getUniqueId(){
   return (new Date().getTime()).toString(36) + new Date().getUTCMilliseconds();
}

getUniqueId()    // Call the function

------------results like

//"ka2high4264"

//"ka2hj115905"

//"ka2hj1my690"

//"ka2hj23j287"

//"ka2hj2jp869"

Im Jahr 2020 können Sie die Crypto-API im Browser verwenden , um kryptografisch starke Zufallswerte zu generieren.

function getRandomNumbers() {
  const typedArray = new Uint8Array(10);
  const randomValues = window.crypto.getRandomValues(typedArray);
  return randomValues.join('');
}

console.log(getRandomNumbers());
// 1857488137147725264738

Sowohl Uint8Array als auch Crypto.getRandomValues werden in allen gängigen Browsern, einschließlich IE11, unterstützt

Posten Sie dieses Code-Snippet hier als meine eigene zukünftige Referenz (nicht garantiert, aber zufriedenstellend "einzigartig" genug):

// a valid floating number
window.generateUniqueNumber = function() {
    return new Date().valueOf() + Math.random();
};

// a valid HTML id
window.generateUniqueId = function() {
    return "_" + new Date().valueOf() + Math.random().toFixed(16).substring(2);
};

Dies schafft eine fast garantierte eindeutige Client-Seite mit 32 Zeichen, wenn Sie nur Zahlen möchten, ändern Sie die "Zeichen" -Vari.

var d = new Date().valueOf();
var n = d.toString();
var result = '';
var length = 32;
var p = 0;
var chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

for (var i = length; i > 0; --i){
    result += ((i & 1) && n.charAt(p) ? '<b>' + n.charAt(p) + '</b>' : chars[Math.floor(Math.random() * chars.length)]);
    if(i & 1) p++;
};

https://jsfiddle.net/j0evrdf1/1/

Verwenden Sie dies: zum Erstellen einer eindeutigen Nummer in Javascript

var uniqueNumber=(new Date().getTime()).toString(36);

Es funktioniert wirklich. :) :)

    function UniqueValue(d){
        var dat_e = new Date();
        var uniqu_e = ((Math.random() *1000) +"").slice(-4)

        dat_e = dat_e.toISOString().replace(/[^0-9]/g, "").replace(dat_e.getFullYear(),uniqu_e);
        if(d==dat_e)
            dat_e = UniqueValue(dat_e);
        return dat_e;
    }

Aufruf 1: UniqueValue ('0')
Aufruf 2: UniqueValue (UniqueValue ('0')) // ist komplex

Beispielausgabe:
for (var i = 0; i <10; i ++) {console.log (UniqueValue (UniqueValue ( '0')));}
60950116113248802
26780116113248803
53920116113248803
35840116113248803
47430116113248803
41680116113248803
42980116113248804
34750116113248804
20950116113248804
03730116113248804

Da Millisekunden nicht jede Millisekunde im Knoten aktualisiert werden, folgt eine Antwort. Dies erzeugt eine eindeutige, von Menschen lesbare Ticketnummer. Ich bin neu in Programmierung und NodeJS. Bitte korrigieren Sie mich, wenn ich falsch liege.

function get2Digit(value) {
if (value.length == 1) return "0" + "" + value;
else return value;

}}

function get3Digit(value) {
if (value.length == 1) return "00" + "" + value;
else return value;

}}

function generateID() {
    var d = new Date();
    var year = d.getFullYear();
    var month = get2Digit(d.getMonth() + 1);
    var date = get2Digit(d.getDate());
    var hours = get2Digit(d.getHours());
    var minutes = get2Digit(d.getMinutes());
    var seconds = get2Digit(d.getSeconds());
    var millSeconds = get2Digit(d.getMilliseconds());
    var dateValue = year + "" + month + "" + date;
    var uniqueID = hours + "" + minutes + "" + seconds + "" + millSeconds;

    if (lastUniqueID == "false" || lastUniqueID < uniqueID) lastUniqueID = uniqueID;
    else lastUniqueID = Number(lastUniqueID) + 1;
    return dateValue + "" + lastUniqueID;
}

Angenommen, die von @abarber vorgeschlagene Lösung ist eine gute Lösung, da sie verwendet wird, (new Date()).getTime()sodass sie ein Fenster von Millisekunden hat und tickbei Kollisionen in diesem Intervall a summiert. Wir könnten in Betracht ziehen, die integrierte Lösung zu verwenden, wie wir hier in Aktion deutlich sehen können:

Zunächst können wir hier sehen, wie es zu Kollisionen im 1/1000 Fensterrahmen kommen kann, indem wir (new Date()).getTime():

console.log( (new Date()).getTime() ); console.log( (new Date()).getTime() )
VM1155:1 1469615396590
VM1155:1 1469615396591
console.log( (new Date()).getTime() ); console.log( (new Date()).getTime() )
VM1156:1 1469615398845
VM1156:1 1469615398846
console.log( (new Date()).getTime() ); console.log( (new Date()).getTime() )
VM1158:1 1469615403045
VM1158:1 1469615403045

Zweitens versuchen wir die vorgeschlagene Lösung, die Kollisionen im 1/1000 Fenster vermeidet:

console.log( window.mwUnique.getUniqueID() ); console.log( window.mwUnique.getUniqueID() ); 
VM1159:1 14696154132130
VM1159:1 14696154132131

Das heißt, wir könnten in Betracht ziehen, Funktionen wie den Knoten process.nextTick, der in der Ereignisschleife aufgerufen wird, als einzelne zu verwenden, tickund dies wird hier gut erklärt . Natürlich gibt es im Browser keine, process.nextTickalso müssen wir herausfinden, wie das geht. Diese Implementierung wird eine Installation von nextTickFunktion im Browser mit den meisten näheren Funktionen an das I / O in dem Browser, sind setTimeout(fnc,0), setImmediate(fnc), window.requestAnimationFrame. Wie hier vorgeschlagen , könnten wir das hinzufügen window.postMessage, aber ich überlasse dies dem Leser, da es auch ein benötigt addEventListener. Ich habe die ursprünglichen Modulversionen geändert, um es hier einfacher zu halten:

getUniqueID = (c => {
 if(typeof(nextTick)=='undefined')
nextTick = (function(window, prefixes, i, p, fnc) {
    while (!fnc && i < prefixes.length) {
        fnc = window[prefixes[i++] + 'equestAnimationFrame'];
    }
    return (fnc && fnc.bind(window)) || window.setImmediate || function(fnc) {window.setTimeout(fnc, 0);};
})(window, 'r webkitR mozR msR oR'.split(' '), 0);
 nextTick(() => {
   return c( (new Date()).getTime() )  
 })
})

Also haben wir im 1/1000 Fenster:

getUniqueID(function(c) { console.log(c); });getUniqueID(function(c) { console.log(c); });
undefined
VM1160:1 1469615416965
VM1160:1 1469615416966

Vielleicht wäre es sogar noch besser, getTime () oder valueOf () zu verwenden, aber auf diese Weise wird eine eindeutige plus vom Menschen verständliche Zahl (die Datum und Uhrzeit darstellt) zurückgegeben:

window.getUniqNr = function() {
  var now = new Date(); 
  if (typeof window.uniqCounter === 'undefined') window.uniqCounter = 0; 
  window.uniqCounter++; 
  var m = now.getMonth(); var d = now.getDay(); 
  var h = now.getHours(); var i = now.getMinutes(); 
  var s = now.getSeconds(); var ms = now.getMilliseconds();
  timestamp = now.getFullYear().toString() 
  + (m <= 9 ? '0' : '') + m.toString()
  +( d <= 9 ? '0' : '') + d.toString() 
  + (h <= 9 ? '0' : '') + h.toString() 
  + (i <= 9 ? '0' : '') + i.toString() 
  + (s <= 9 ? '0' : '') + s.toString() 
  + (ms <= 9 ? '00' : (ms <= 99 ? '0' : '')) + ms.toString() 
  + window.uniqCounter; 

  return timestamp;
};
window.getUniqNr();

let now = new Date();
let timestamp = now.getFullYear().toString();
let month = now.getMonth() + 1;
timestamp += (month < 10 ? '0' : '') + month.toString();
timestamp += (now.getDate() < 10 ? '0' : '') + now.getDate().toString();
timestamp += (now.getHours() < 10 ? '0' : '') + now.getHours().toString();
timestamp += (now.getMinutes() < 10 ? '0' : '') + now.getMinutes().toString();
timestamp += (now.getSeconds() < 10 ? '0' : '') + now.getSeconds().toString();
timestamp += (now.getMilliseconds() < 100 ? '0' : '') + now.getMilliseconds().toString();

Einfach und immer einzigartig:

const uniqueValue = (new Date()).getTime() + Math.trunc(365 * Math.random());
**OUTPUT LIKE THIS** : 1556782842762

Ich habe es so gemacht

function uniqeId() {
   var ranDom = Math.floor(new Date().valueOf() * Math.random())
   return _.uniqueId(ranDom);
}

function getUniqueNumber() {

    function shuffle(str) {
        var a = str.split("");
        var n = a.length;
        for(var i = n - 1; i > 0; i--) {
            var j = Math.floor(Math.random() * (i + 1));
            var tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
        return a.join("");
    }
    var str = new Date().getTime() + (Math.random()*999 +1000).toFixed() //string
    return Number.parseInt(shuffle(str));   
}

in Bezug auf die # Marcelo Lazaroni-Lösung oben

Date.now() + Math.random()

Gibt eine Zahl wie diese 1567507511939.4558 (auf 4 Dezimalstellen begrenzt) zurück und gibt alle 0,1% nicht eindeutige Zahlen (oder Kollisionen) an.

Durch Hinzufügen von toString () wird dies behoben

Date.now() + Math.random().toString()

gibt '15675096840820.04510962122198503' (eine Zeichenfolge) zurück und ist außerdem so 'langsam', dass Sie sowieso nie die 'gleiche' Millisekunde erhalten.

let uuid = ((new Date().getTime()).toString(36))+'_'+(Date.now() + Math.random().toString()).split('.').join("_")

Beispielergebnis "k3jobnvt_15750033412250_18299601769317408"

Mit toString(36), etwas langsam, ist hier die schnellere und einzigartige Lösung:

new Date().getUTCMilliseconds().toString() +
"-" +
Date.now() +
"-" +
filename.replace(/\s+/g, "-").toLowerCase()

So erhalten Sie eine eindeutige Nummer:

function getUnique(){
    return new Date().getTime().toString() + window.crypto.getRandomValues(new Uint32Array(1))[0];
}
// or 
function getUniqueNumber(){
    const now = new Date();
    return Number([
        now.getFullYear(),
        now.getMonth(),
        now.getDate(),
        now.getHours(),
        now.getMinutes(),
        now.getUTCMilliseconds(),
        window.crypto.getRandomValues(new Uint8Array(1))[0]
    ].join(""));
}

Beispiel:

getUnique()
"15951973277543340653840"

for (let i=0; i<5; i++){
    console.log( getUnique() );
}
15951974746301197061197
15951974746301600673248
15951974746302690320798
15951974746313778184640
1595197474631922766030

getUniqueNumber()
20206201121832230

for (let i=0; i<5; i++){
    console.log( getUniqueNumber() );
}
2020620112149367
2020620112149336
20206201121493240
20206201121493150
20206201121494200

Sie können die Länge ändern mit:

new Uint8Array(1)[0]
// or
new Uint16Array(1)[0]
// or
new Uint32Array(1)[0]

100% garantiert eine andere Anzahl zu generieren ...

var Q;
Q = {};
Q.timeInterval;

function genUniqueID(kol) {
	Q.timeInterval = setTimeout(function() {
		document.querySelector('#demo').innerHTML += new Date().valueOf() + '<br>';
		kol--;
		if (kol > 0) {
			genUniqueID(kol);
		}
	}, document.querySelector('#i2').value);
}

<div><input id="i1" type="number" value="5" style="width: 60px;"><label> - Amount</label><br>
    <input id="i2" type="number" value="10" style="width: 60px;"><label> - Millisecond interval</label></div><br>
<div>
    <button onclick="genUniqueID(document.querySelector('#i1').value);">Start</button>
    <button onclick="clearTimeout(Q.timeInterval);">Stop</button>
    <button onclick="document.querySelector('#demo').innerHTML = ''">Clear</button>
</div><br>
<div id="demo"></div>