एएससीआईआई-सुरक्षित GUID- जैसे अद्वितीय पहचानकर्ता उत्पन्न करने के लिए यहां एक पूरी तरह से गैर-अनुपालन लेकिन बहुत ही निष्पादन कार्यान्वयन है।

function generateQuickGuid() {
    return Math.random().toString(36).substring(2, 15) +
        Math.random().toString(36).substring(2, 15);
}

26 [ए-जेड -9] वर्ण उत्पन्न करता है, जो एक यूआईडी उत्पन्न करता है जो आरएफसी अनुपालन GUID से छोटा और अधिक अद्वितीय होता है। मानव-पठनीयता के मामले में डैश को छोटा रूप से जोड़ा जा सकता है।

इस फ़ंक्शन के लिए उपयोग उदाहरण और समय और इस प्रश्न के कई अन्य उत्तरों यहां दिए गए हैं। समय क्रोम एम 25 के तहत किया गया था, प्रत्येक 10 मिलियन पुनरावृत्तियों।

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

एक वेब सेवा उपयोगी होगी।

त्वरित Google मिला: http://www.hoskinson.net/GuidGenerator/

इस कार्यान्वयन के लिए झुकाव नहीं कर सकते, लेकिन किसी को एक भरोसेमंद GUID जेनरेटर प्रकाशित करना होगा।

ऐसी वेब सेवा के साथ, आप एक आरईएसटी वेब इंटरफ़ेस विकसित कर सकते हैं जो GUID वेब सेवा का उपभोग करता है, और ब्राउज़र में AJAX के माध्यम से जावास्क्रिप्ट के माध्यम से कार्य करता है।

ब्रोफा का जवाब बहुत चालाक है, वास्तव में - प्रभावशाली चालाक, वास्तव में ... आरएफसी 4122 अनुपालन, कुछ हद तक पठनीय, और कॉम्पैक्ट। बहुत बढ़िया!

लेकिन यदि आप उस नियमित अभिव्यक्ति को देख रहे हैं, तो वे कई replace() कॉलबैक, toString() और Math.random() फ़ंक्शन कॉल (जहां वह केवल परिणाम के 4 बिट्स का उपयोग कर रहा है और बाकी को बर्बाद कर रहा है), आप शुरू कर सकते हैं प्रदर्शन के बारे में आश्चर्य करने के लिए। दरअसल, जेलेट ने जेनरेटिक जीआईआईडी गति के लिए जेनरेटिक्यूड के साथ आरएफसी को टॉस करने का भी फैसला किया।

लेकिन, क्या हम गति और आरएफसी अनुपालन प्राप्त कर सकते हैं? मैं हां कहूंगा! क्या हम पठनीयता को बनाए रख सकते हैं? खैर ... वास्तव में नहीं, लेकिन अगर आप साथ चलते हैं तो यह आसान है।

लेकिन सबसे पहले, मेरे परिणाम, ब्रोफा, guid (स्वीकृत उत्तर) की तुलना में, और गैर-आरएफसी-अनुपालन जेनरक्विकगुइड:

                  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.

तो ऑप्टिमाइज़ेशन के अपने 6 वें पुनरावृत्ति के द्वारा, मैंने 12X से अधिक का सबसे लोकप्रिय उत्तर, 9एक्स से अधिक स्वीकार्य उत्तर, और 2-3X द्वारा तेजी से गैर-अनुपालन उत्तर को हराया । और मैं अभी भी आरएफसी 4122 अनुपालन कर रहा हूँ।

कैसे दिलचस्पी है? मैंने http://jsfiddle.net/jcward/7hyaC/3/ पर पूर्ण स्रोत डाला है और http://jsperf.com/uuid-generator-opt/4

स्पष्टीकरण के लिए, आइए ब्रोफा के कोड से शुरू करें:

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

इसलिए यह किसी भी यादृच्छिक हेक्स अंक के साथ x को प्रतिस्थापित करता है, y यादृच्छिक डेटा के साथ (शीर्ष 2 बिट्स को आरएफसी स्पेक के प्रति 10 तक मजबूर करने के अलावा), और रेगेक्स - या 4 अक्षरों से मेल नहीं खाता है, इसलिए उसे सौदा करने की ज़रूरत नहीं है उनके साथ। बहुत, बहुत चालाक।

पहली बात यह जानना है कि फ़ंक्शन कॉल महंगे हैं, जैसे कि नियमित अभिव्यक्तियां हैं (हालांकि वह केवल 1 का उपयोग करता है, इसमें 32 कॉलबैक हैं, प्रत्येक मैच के लिए एक है, और 32 कॉलबैक में से प्रत्येक में यह Math.random () और v को कॉल करता है। toString (16))।

प्रदर्शन की ओर पहला कदम RegEx और उसके कॉलबैक फ़ंक्शंस को खत्म करना और इसके बजाय एक साधारण लूप का उपयोग करना है। इसका मतलब है कि हमें - और 4 वर्णों से निपटना होगा जबकि ब्रोफा नहीं था। साथ ही, ध्यान दें कि हम अपनी स्लिम स्ट्रिंग टेम्पलेट आर्किटेक्चर रखने के लिए स्ट्रिंग ऐरे इंडेक्सिंग का उपयोग कर सकते हैं:

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

असल में, एक ही आंतरिक तर्क, सिवाय इसके कि हम - या 4 जांच करते हैं, और थोड़ी देर के लूप का उपयोग करते हैं (बदले replace() कॉलबैक के बजाय) हमें लगभग 3 एक्स सुधार मिलता है!

अगला कदम डेस्कटॉप पर एक छोटा सा है लेकिन मोबाइल पर एक अच्छा अंतर बनाता है। आइए कम गणित करें। यादृच्छिक () कॉल करें और उनमें से 87% को एक यादृच्छिक बफर के साथ फेंकने के बजाय उन सभी यादृच्छिक बिट्स का उपयोग करें जो प्रत्येक पुनरावृत्ति को स्थानांतरित कर देते हैं। आइए उस टेम्पलेट परिभाषा को लूप से बाहर ले जाएं, बस अगर यह मदद करता है:

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
}

यह प्लेटफार्म के आधार पर हमें 10-30% बचाता है। बुरा नहीं। लेकिन अगला बड़ा कदम टूस्टिंग फ़ंक्शन से छुटकारा पाता है, ऑप्टिमाइज़ेशन क्लासिक - लुक-अप टेबल के साथ पूरी तरह से कॉल करता है। एक साधारण 16-तत्व लुकअप टेबल बहुत कम समय में ToString (16) का काम करेगा:

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
}

अगला अनुकूलन एक और क्लासिक है। चूंकि हम केवल प्रत्येक लूप पुनरावृत्ति में आउटपुट के 4-बिट्स को संभालने वाले हैं, चलो आधे में लूप की संख्या में कटौती करें और प्रत्येक पुनरावृत्ति 8-बिट्स को संसाधित करें। यह मुश्किल है क्योंकि हमें अभी भी आरएफसी अनुपालन बिट स्थिति को संभालना है, लेकिन यह बहुत कठिन नहीं है। हमें 0x00 - 0xff स्टोर करने के लिए एक बड़ी लुकअप टेबल (16x16, या 256) बनाना है, और हम इसे 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
}

मैंने एक ई 6 () की कोशिश की जो एक समय में 16-बिट्स को संसाधित करता है, फिर भी 256-तत्व LUT का उपयोग करता है, और यह ऑप्टिमाइज़ेशन के घटते रिटर्न दिखाता है। हालांकि इसमें कम पुनरावृत्ति थी, आंतरिक तर्क जटिल प्रसंस्करण से जटिल था, और यह डेस्कटॉप पर और मोबाइल पर केवल ~ 10% तेज प्रदर्शन करता था।

आवेदन करने के लिए अंतिम अनुकूलन तकनीक - लूप अनलोल करें। चूंकि हम निश्चित समय को लूप कर रहे हैं, इसलिए हम इसे तकनीकी रूप से हाथ से लिख सकते हैं। मैंने एक बार एक यादृच्छिक परिवर्तनीय आर के साथ यह कोशिश की कि मैंने फिर से असाइन किया है, और प्रदर्शन टैंक किया गया है। लेकिन चार चर के साथ यादृच्छिक डेटा को सामने रखा गया है, फिर लुकअप टेबल का उपयोग करके, और उचित आरएफसी बिट्स को लागू करने के साथ, यह संस्करण उन सभी को धूम्रपान करता है:

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

मॉड्यूलिज्ड: http://jcward.com/UUID.js - UUID.generate()

मजाकिया बात यह है कि यादृच्छिक डेटा के 16 बाइट उत्पन्न करना आसान हिस्सा है। पूरी चाल इसे आरएफसी अनुपालन के साथ स्ट्रिंग प्रारूप में व्यक्त कर रही है, और यह यादृच्छिक डेटा के 16 बाइट्स, एक अनियंत्रित लूप और लुकअप टेबल के साथ सबसे कड़ाई से पूरा किया गया है।

मुझे उम्मीद है कि मेरा तर्क सही है - इस तरह के कठिन काम में गलती करना बहुत आसान है। लेकिन आउटपुट मेरे लिए अच्छा लग रहा है। मुझे उम्मीद है कि आपने कोड अनुकूलन के माध्यम से इस पागल सवारी का आनंद लिया!

सलाह दी जानी चाहिए: मेरा प्राथमिक लक्ष्य संभावित अनुकूलन रणनीतियों को दिखाना और पढ़ाना था। अन्य उत्तरों टकराव और वास्तव में यादृच्छिक संख्या जैसे महत्वपूर्ण विषयों को कवर करते हैं, जो अच्छे यूयूआईडी उत्पन्न करने के लिए महत्वपूर्ण हैं।

यहां 9 अक्टूबर, 2011 को उपयोगकर्ता जेड द्वारा एक टिप्पणी से 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)}

यह वर्तमान उच्चतम रेटेड उत्तर के समान लक्ष्य प्राप्त करता है, लेकिन 50, कम बाइट्स में जबरन, रिकर्सन और घातीय नोटेशन का शोषण करके। उन उत्सुक लोगों के लिए जो यह काम करता है, यहां फ़ंक्शन के पुराने संस्करण का एनोटेटेड रूप है:

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

क्रोम के टकराव के लिए कामकाज के साथ शीर्ष वोट वाले उत्तर का संयोजन यहां दिया गया है :

generateGUID = (typeof(window.crypto) != 'undefined' && 
                typeof(window.crypto.getRandomValues) != 'undefined') ?
    function() {
        // If we have a cryptographically secure PRNG, use that
        // https://.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://.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);
        });
    };

यदि आप इसका परीक्षण करना चाहते हैं तो jsbin पर ।

ietf.org/rfc/rfc4122.txt , सेक्शन 4.4 (ट्रूली रैंडम या छद्म-यादृच्छिक संख्या से यूयूआईडी बनाने के लिए एल्गोरिदम) के आधार पर कुछ कोड यहां दिया गया है।

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

XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX प्रारूप में स्ट्रिंग जेनरेटर विधि की तरह सबसे तेज़ GUID। यह मानक-अनुपालन GUID उत्पन्न नहीं करता है।

इस कार्यान्वयन के दस लाख निष्पादन केवल 32.5 सेकेंड लेते हैं, जो कि मैंने कभी भी ब्राउज़र में देखा है (लूप / पुनरावृत्तियों के बिना एकमात्र समाधान)।

समारोह उतना आसान है जितना:

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

प्रदर्शन का परीक्षण करने के लिए, आप यह कोड चला सकते हैं:

console.time('t'); 
for (var i = 0; i < 10000000; i++) { 
    guid(); 
};
console.timeEnd('t');

मुझे यकीन है कि आप में से अधिकांश समझेंगे कि मैंने वहां क्या किया है, लेकिन शायद कम से कम एक व्यक्ति है जिसे स्पष्टीकरण की आवश्यकता होगी:

एल्गोरिदम:

• Math.random() फ़ंक्शन दशमलव अंश बिंदु के बाद 16 अंकों के साथ 0 और 1 के बीच दशमलव संख्या देता है (उदाहरण के लिए 0.4363923368509859 )।
• फिर हम इस नंबर को लेते हैं और इसे आधार 16 के साथ एक स्ट्रिंग में परिवर्तित करते हैं (ऊपर दिए गए उदाहरण से हम 0.6fb7687f प्राप्त 0.6fb7687f )।
  Math.random().toString(16) ।
• फिर हमने 0. उपसर्ग ( 0.6fb7687f => 6fb7687f ) काट दिया और आठ हेक्साडेसिमल वर्णों के साथ एक स्ट्रिंग प्राप्त की।
  (Math.random().toString(16).substr(2,8) ।
• कभी-कभी Math.random() फ़ंक्शन छोटे नंबर (उदाहरण के लिए 0.4363 ) 0.4363 , अंत में शून्य के कारण (ऊपर दिए गए उदाहरण से, वास्तव में संख्या 0.4363000000000000 )। यही कारण है कि मैं इस स्ट्रिंग "000000000" (नौ शून्य के साथ एक स्ट्रिंग) में संलग्न कर रहा हूं और फिर इसे substr() फ़ंक्शन के साथ काट रहा हूं ताकि इसे नौ अक्षरों को सही बनाया जा सके (दाईं ओर शून्य को भरना)।
• बिल्कुल नौ शून्य जोड़ने का कारण खराब स्थिति परिदृश्य के कारण है, जो तब होता है जब Math.random() फ़ंक्शन बिल्कुल 0 या 1 (उनमें से प्रत्येक के लिए 1/10 ^ 16 की संभावना Math.random() वापस आ जाएगा। यही कारण है कि हमें इसमें नौ शून्य जोड़ने की आवश्यकता थी ( "0"+"000000000" या "1"+"000000000" ), और उसके बाद आठ वर्णों की लंबाई के साथ दूसरी अनुक्रमणिका (तीसरा चरित्र) से इसे काट दिया गया। शेष मामलों के लिए, शून्य के अतिरिक्त परिणाम को नुकसान नहीं पहुंचाएगा क्योंकि यह इसे किसी भी तरह से काट रहा है।
  Math.random().toString(16)+"000000000").substr(2,8) ।

सभा:

• GUID निम्न प्रारूप XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX ।
• मैंने GUID को 4 टुकड़ों में विभाजित किया, प्रत्येक टुकड़ा 2 प्रकार (या स्वरूप) में विभाजित: XXXXXXXX और -XXXX-XXXX ।
• अब मैं निम्न 4 प्रकारों के साथ GUID को इकट्ठा करने के लिए इन 2 प्रकारों का उपयोग करके GUID का निर्माण कर रहा हूं, निम्नानुसार: XXXXXXXX -XXXX-XXXX -XXXX-XXXX XXXXXXXX ।
• इन दो प्रकारों के बीच अंतर करने के लिए, मैंने एक जोड़ी निर्माता फ़ंक्शन _p8(s) ध्वज पैरामीटर जोड़ा, s पैरामीटर फ़ंक्शन को बताता है कि डैश जोड़ने या नहीं।
• आखिरकार हम निम्न श्रृंखला के साथ GUID बनाते हैं: _p8() + _p8(true) + _p8(true) + _p8() , और इसे वापस करें।

मेरे ब्लॉग पर इस पोस्ट से लिंक करें

का आनंद लें! :-)

ईएस 6 नमूना

const guid=()=> {
  const s4=()=> Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);     
  return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;
}

उन लोगों के लिए जो आरएफसी 4122 संस्करण 4 अनुपालन समाधान चाहते हैं, गति विचारों के साथ (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("");
}

उपरोक्त फ़ंक्शन में गति और यादृच्छिकता के बीच एक सभ्य संतुलन होना चाहिए।

मैं ब्रोफा के जवाब को समझना चाहता था, इसलिए मैंने इसे विस्तारित किया और टिप्पणियां जोड़ दीं:

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

यह संस्करण 4 यूयूआईडी (छद्म यादृच्छिक संख्या से बनाया गया) बनाते हैं:

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

उत्पन्न यूयूआईडी का नमूना यहां दिया गया है:

682db637-0f31-4847-9cdf-25ba9613a75c
97d19478-3ab2-4aa1-b8cc-a1c3540f54aa
2eed04c9-2692-456d-a0fd-51012f947136

here कुछ अतिरिक्त के साथ अपना स्वयं का यूयूआईडी / GUID जनरेटर समायोजित here ।

मैं निम्नलिखित Kybos यादृच्छिक संख्या जनरेटर का उपयोग थोड़ा और क्रिप्टोग्राफिक ध्वनि होने के लिए कर रहा हूँ ।

Baagoe.com से मैश और क्यबोस विधियों के साथ मेरी स्क्रिप्ट नीचे दी गई है।

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

GitHub पर जावास्क्रिप्ट प्रोजेक्ट - https://github.com/LiosK/UUID.js

UUID.js जावास्क्रिप्ट के लिए आरएफसी-अनुपालन यूयूआईडी जनरेटर।

आरएफसी 4122 ietf.org/rfc/rfc4122.txt देखें ।

विशेषताएं आरएफसी 4122 अनुपालन यूयूआईडी उत्पन्न करती हैं।

संस्करण 4 यूयूआईडी (यादृच्छिक संख्या से यूयूआईडी) और संस्करण 1 यूयूआईडी (समय-आधारित यूयूआईडी) उपलब्ध हैं।

यूयूआईडी ऑब्जेक्ट यूयूआईडी क्षेत्रों तक पहुंच सहित यूयूआईडी तक विभिन्न प्रकार की पहुंच की अनुमति देता है।

जावास्क्रिप्ट का कम टाइमस्टैम्प रिज़ॉल्यूशन यादृच्छिक संख्या से मुआवजा दिया जाता है।

आप नोड-यूयूआईडी ( https://github.com/kelektiv/node-uuid ) का उपयोग कर सकते हैं

ietf.org/rfc/rfc4122.txt 4122 ietf.org/rfc/rfc4122.txt की सरल, तेज पीढ़ी ।

विशेषताएं:

• आरएफसी 4122 संस्करण 1 या संस्करण 4 यूयूआईडी उत्पन्न करें
• Node.js और ब्राउज़रों में चलाता है।
• सहायक प्लेटफार्मों पर क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक # पीढ़ी।
• छोटे पदचिह्न (कुछ छोटा चाहते हैं? इसे https://gist.github.com/982883 )

एनपीएम का उपयोग कर स्थापित करें:

npm install uuid

या ब्राउजर के माध्यम से यूयूआईडी का उपयोग करना:

रॉ फ़ाइल डाउनलोड करें (uuid v1): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v1.js रॉ फ़ाइल डाउनलोड करें (uuid v4): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v4.js

भी छोटा चाहते हैं? इसे देखें: https://gist.github.com/jed/982883

उपयोग:

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

एक jQuery प्लगइन है जो ग्रिड की अच्छी तरह से @ http://plugins.jquery.com/project/GUID_Helper संभालती हैhttp://plugins.jquery.com/project/GUID_Helper

jQuery.Guid.Value()

आंतरिक ग्रिड का मूल्य देता है। यदि कोई guid निर्दिष्ट नहीं किया गया है, तो एक नया लौटाता है (मान आंतरिक रूप से संग्रहीत किया जाता है)।

jQuery.Guid.New()

एक नया ग्रिड देता है और आंतरिक रूप से इसका मूल्य निर्धारित करता है।

jQuery.Guid.Empty()

एक खाली ग्रिड 00000000-0000-0000-0000-000000000000 देता है।

jQuery.Guid.IsEmpty()

बूलियन देता है। सही है अगर खाली / अपरिभाषित / खाली / शून्य।

jQuery.Guid.IsValid()

बूलियन देता है। सही मान्य guid, अगर नहीं तो झूठी।

jQuery.Guid.Set()

ग्रिड retrns। उपयोगकर्ता निर्दिष्ट GUID को ग्रिड सेट करता है, अगर अमान्य है, तो एक खाली guid देता है।

मुझे पता है, यह एक पुराना सवाल है। बस पूर्णता के लिए, यदि आपका पर्यावरण SharePoint है, तो एक उपयोगिता फ़ंक्शन है जिसे SP.Guid.newGuid( msdn लिंक ) कहा जाता है जो एक नया guid बनाता है। यह फ़ंक्शन sp.init.js फ़ाइल के अंदर है। यदि आप इस फ़ंक्शन को फिर से लिखते हैं (अन्य निजी कार्यों से कुछ अन्य निर्भरताओं को हटाने के लिए), ऐसा लगता है:

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

यह एक तिथि पर आधारित है, और विशिष्टता सुनिश्चित करने के लिए एक यादृच्छिक प्रत्यय जोड़ें। सीएसएस पहचानकर्ताओं के लिए अच्छी तरह से काम करता है। यह हमेशा कुछ ऐसा देता है और हैक करना आसान है:

यूआईडी-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;
        };

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

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

यदि आईडी 1 मिलीसेकंड से अधिक उत्पन्न होती है, तो वे 100% अद्वितीय हैं।

यदि छोटे अंतराल पर दो आईडी उत्पन्न होते हैं, और यह मानते हुए कि यादृच्छिक विधि वास्तव में यादृच्छिक है, तो यह 99 उत्पन्न हो जाएगा जो 99.9 99 99 99 99 99 999% वैश्विक रूप से अद्वितीय होने की संभावना है (10 ^ 15 में से टक्कर)

आप अधिक अंक जोड़कर इस नंबर को बढ़ा सकते हैं, लेकिन 100% अद्वितीय आईडी उत्पन्न करने के लिए आपको वैश्विक काउंटर का उपयोग करने की आवश्यकता होगी।

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

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