Utwórz unikalny numer z czasem javascript

Muszę generować unikalne numery identyfikacyjne w locie, używając javascript. W przeszłości robiłem to, tworząc liczbę za pomocą czasu. Liczba składałaby się z czterocyfrowego roku, dwucyfrowego miesiąca, dwucyfrowego dnia, dwucyfrowej godziny, dwucyfrowej minuty, dwucyfrowej sekundy i trzycyfrowej milisekundy. Więc wyglądałoby to mniej więcej tak: 20111104103912732 ... to dałoby wystarczającą pewność co do unikalnego numeru do moich celów.

Minęło trochę czasu, odkąd to zrobiłem i nie mam już kodu. Czy ktoś ma do tego kod lub ma lepszą sugestię dotyczącą wygenerowania unikalnego identyfikatora?

Jeśli chcesz mieć tylko unikalny numer, to

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

przyniesie prosty numer. Ale jeśli potrzebujesz czytelnej wersji, czeka Cię trochę przetwarzania:

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

Lepszym podejściem byłoby:

new Date().valueOf();

zamiast

new Date().getUTCMilliseconds();

valueOf () jest „najprawdopodobniej” unikalną liczbą. http://www.w3schools.com/jsref/jsref_valueof_date.asp .

Najkrótszym sposobem na utworzenie liczby, co do której możesz być pewien, że będzie wyjątkowa wśród tylu oddzielnych instancji, o ile możesz sobie wyobrazić, jest

Date.now() + Math.random()

Jeśli różnica w wywołaniu funkcji wynosi 1 milisekundę, generowanie innej liczby jest w 100% gwarantowane . W przypadku wywołań funkcji w ciągu tej samej milisekundy należy się martwić tylko wtedy, gdy tworzysz więcej niż kilka milionów liczb w tej samej milisekundzie, co jest mało prawdopodobne.

Więcej informacji na temat prawdopodobieństwa uzyskania powtarzającej się liczby w ciągu tej samej milisekundy można znaleźć na stronie https://stackoverflow.com/a/28220928/4617597

Można to osiągnąć po prostu za pomocą następującego kodu:

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

var id = components.join("");

Oto, co robię, gdy chcę czegoś mniejszego niż kilka liczb - zmień bazę.

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

Działa to szybciej niż tworzenie Dateinstancji, używa mniej kodu i zawsze generuje unikalny numer (lokalnie):

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/

Wydałem to na Bower i npm: https://github.com/stevenvachon/unique-number

Możesz również użyć czegoś bardziej wyszukanego, takiego jak cuid , puid lub shortid, aby wygenerować liczbę niebędącą liczbą.

używam

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

Więc jeśli przypadkiem kod zostanie uruchomiony w tym samym czasie, istnieje również malutka szansa, że ​​losowe liczby będą takie same.

To powinno wystarczyć:

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

jeśli chcesz mieć unikalny numer po kilku miliardach sekund, użyj Date.now(), jeśli chcesz go użyć wewnątrz for loopa, użyj Date.now() and Math.random()razem

unikalny numer wewnątrz pętli for

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

wyjście :: wszystkie liczby są unikalne

15598251485988384 155982514859810330 155982514859860737 155982514859882244 155982514859883316

unikalny numer bez Math.random()

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

wyjście :: Liczby są powtarzane

1559825328327 1559825328327 1559825328327 1559825328328 1559825328328

Z badania w Internecie wymyśliłem następujący obiekt, który tworzy unikalny identyfikator na sesję:

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

To może być pomocne dla niektórych osób.

Twoje zdrowie

Andrzej

Powinno to również wystarczyć:

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

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

Przykład:

 > uniqueID()
 > "bxppcnanpuxzpyewttifptbklkurvvetigra"

Zawsze otrzymuj unikalny identyfikator w JS

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

getUniqueId()    // Call the function

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

//"ka2high4264"

//"ka2hj115905"

//"ka2hj1my690"

//"ka2hj23j287"

//"ka2hj2jp869"

W 2020 r. Możesz użyć Crypto API w przeglądarce do generowania silnych kryptograficznie wartości losowych.

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

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

zarówno Uint8Array, jak i Crypto.getRandomValues są obsługiwane we wszystkich głównych przeglądarkach, w tym IE11

Publikuję tutaj ten fragment kodu do wykorzystania w przyszłości (bez gwarancji, ale wystarczający „unikalny”):

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

Tworzy to prawie gwarantowany unikalny klucz 32-znakowy po stronie klienta, jeśli chcesz, aby tylko liczby zmieniły zmienną "znaki".

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/

użyj tego: do tworzenia unikalnego numeru w javascript

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

To naprawdę działa. :)

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

Połączenie 1: UniqueValue ('0')
Połączenie 2: UniqueValue (UniqueValue ('0')) // będzie złożone

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

Ponieważ milisekundy nie są aktualizowane co milisekundę w węźle, następująca jest odpowiedź. W ten sposób generowany jest unikalny, czytelny dla człowieka numer biletu. Jestem nowy w programowaniu i nodejs. Proszę, popraw mnie jeśli się mylę.

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

Zakładając, że rozwiązanie zaproponowane przez @abarber to dobre rozwiązanie, ponieważ używa (new Date()).getTime()tak, że ma okienka milisekund i sumę a tickw przypadku kolizji w tym interwale, moglibyśmy rozważyć użycie wbudowanego, co wyraźnie widać tutaj w akcji:

Po pierwsze, możemy zobaczyć, jak mogą wystąpić kolizje w ramie okna 1/1000 przy użyciu (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

Następnie wypróbowujemy proponowane rozwiązanie, które pozwala uniknąć kolizji w oknie 1/1000:

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

To powiedziawszy, moglibyśmy rozważyć użycie funkcji, takich jak węzeł, process.nextTickktóry jest wywoływany w pętli zdarzeń, jako pojedynczego ticki jest to dobrze wyjaśnione tutaj . Oczywiście w przeglądarce nie ma, process.nextTickwięc musimy wymyślić, jak to zrobić. Ta realizacja będzie zainstalować nextTickfunkcję w przeglądarce przy użyciu najbardziej bliższych funkcje I / O w przeglądarce, które są setTimeout(fnc,0), setImmediate(fnc), window.requestAnimationFrame. Jak sugerowano tutaj, możemy dodać window.postMessage, ale zostawiam to czytelnikowi, ponieważ potrzebuje addEventListenerrównież. Zmodyfikowałem oryginalne wersje modułów, aby było to prostsze tutaj:

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

Mamy więc w oknie 1/1000:

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

Może nawet lepiej byłoby użyć getTime () lub valueOf (), ale w ten sposób zwraca unikalną i zrozumiałą dla człowieka liczbę (reprezentującą datę i godzinę):

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

Łatwo i zawsze uzyskaj wyjątkową wartość:

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

Zrobiłem w ten sposób

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

w odniesieniu do powyższego rozwiązania #Marcelo Lazaroni

Date.now() + Math.random()

zwraca liczbę, taką jak ta 1567507511939.4558 (ograniczona do 4 miejsc po przecinku), i daje nieunikalne liczby (lub kolizje) co 0,1%.

dodanie metody toString () rozwiązuje ten problem

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

zwraca „15675096840820.04510962122198503” (ciąg znaków) i jest dalej tak „powolny”, że i tak nigdy nie otrzymasz „tej samej” milisekundy.

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

przykładowy wynik „k3jobnvt_15750033412250_18299601769317408”

Używając toString(36), nieco powolnego, oto szybsze i unikalne rozwiązanie:

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

Aby uzyskać unikalny numer:

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

Przykład:

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

możesz zmienić długość za pomocą:

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

proste rozwiązanie, które znalazłem

var dzisiaj = nowa data () .wartośćOf ();

console.log (dzisiaj);