javascript - জাভাস্ক্রিপ্টে GUID/UUID তৈরি করবেন?




(20)

আমি সত্যিই ব্রোওফা এর উত্তর কতটা পরিষ্কার তা পছন্দ করি, কিন্তু এটা দুর্ভাগ্যজনক যে Math.randomMath.random দুর্বল প্রয়োগগুলি সংঘর্ষের সুযোগ ছেড়ে দেয়।

এখানে একটি অনুরূপ ietf.org/rfc/rfc4122.txt সংস্করণ 4 সম্মিলিত সমাধান যা টাইমস্ট্যাম্পের হেক্স অংশ দ্বারা প্রথম 13 হেক্সা নম্বরগুলি অফসেট করে সেই সমস্যাটিকে সমাধান করে। এইভাবে, যদি Math.random একই Math.random থাকে তবে উভয় ক্লায়েন্টকে অবশ্যই একই মিলিসেকেন্ডে (অথবা 10,000+ বছর পরে) একই UUID পেতে UUID তৈরি করতে হবে:

function generateUUID() { // Public Domain/MIT
    var d = new Date().getTime();
    if (typeof performance !== 'undefined' && typeof performance.now === 'function'){
        d += performance.now(); //use high-precision timer if available
    }
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
        var r = (d + Math.random() * 16) % 16 | 0;
        d = Math.floor(d / 16);
        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
    });
}


এখানে পরীক্ষা করার জন্য একটি বাজে কথা।

আমি জাভাস্ক্রিপ্টে বিশ্বব্যাপী অনন্য সনাক্তকারী তৈরি করার চেষ্টা করছি। আমি নিশ্চিত নই যে সকল ব্রাউজারে রুটিনগুলি কীভাবে পাওয়া যায়, কিভাবে "র্যান্ডম" এবং অন্তর্নির্মিত এলোমেলো নম্বর জেনারেটর বীজবদ্ধ হয় ইত্যাদি ..

GUID / UUID কমপক্ষে 32 টি অক্ষর হওয়া উচিত এবং আশেপাশে যাওয়ার সময় সমস্যাগুলি এড়াতে ASCII পরিসরে থাকতে হবে।


এই একটি দম্পতি প্রচেষ্টা হয়েছে। প্রশ্নটি হল: আপনি কি প্রকৃত GUID, অথবা কেবল এলোমেলো সংখ্যা চান যা GUID গুলির মতো? এটা র্যান্ডম সংখ্যা উৎপন্ন যথেষ্ট সহজ।

function guid() {
  function s4() {
    return Math.floor((1 + Math.random()) * 0x10000)
      .toString(16)
      .substring(1);
  }
  return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
}

তবে, মনে রাখবেন যে মানগুলি প্রকৃত GUID নয়

দ্রষ্টব্য : প্রদত্ত কোড স্নিপেটটি RFC4122 অনুসরণ করে না যার জন্য সংস্করণটি ( 4 ) জেনারেট আউটপুট স্ট্রিংয়ে একত্রিত করতে হবে। আপনি যদি অনুবর্তী GUIDs প্রয়োজন হলে এই উত্তরটি ব্যবহার করবেন না

ব্যবহার করুন:

var uuid = guid();

ডেমো:

function guid() {
  return "ss-s-s-s-sss".replace(/s/g, s4);
}

function s4() {
  return Math.floor((1 + Math.random()) * 0x10000)
    .toString(16)
    .substring(1);
}

document.getElementById('jsGenId').addEventListener('click', function() {
  document.getElementById('jsIdResult').value = guid();
})
input { font-family: monospace; }
<button id="jsGenId" type="button">Generate GUID</button>
<br>
<input id="jsIdResult" type="text" placeholder="Results will be placed here..." readonly size="40"/>


একটি ওয়েব সেবা দরকারী হবে।

দ্রুত গুগল পাওয়া যায়: http://www.hoskinson.net/GuidGenerator/

এই বাস্তবায়নের জন্য উত্সাহিত করতে পারছি না, তবে কিছুক্ষন অবশ্যই একটি দুর্দান্ত GUID জেনারেটর প্রকাশ করতে হবে।

এই ধরনের ওয়েব পরিষেবাদির মাধ্যমে, আপনি একটি জিএসআইডি ওয়েব পরিষেবা ব্যবহার করে একটি REST ওয়েব ইন্টারফেস বিকাশ করতে পারেন এবং এটি ব্রাউজারে AJAX থেকে জাভাস্ক্রিপ্টের মাধ্যমে সরবরাহ করে।


এখানে Chrome এর সংঘর্ষের জন্য একটি কার্যকর কাজ সহ শীর্ষ ভোটের উত্তরের সমন্বয় রয়েছে:

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 উপর


এখানে https://gist.github.com/982883 এ ব্যবহারকারী জেডের একটি মন্তব্য থেকে 9 অক্টোবর, ২011 এর একটি সমাধান রয়েছে:

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

এখানে একটি সম্পূর্ণ অননুমোদিত কিন্তু খুব কার্যকরী বাস্তবায়ন একটি ASCII- নিরাপদ GUID- মত অনন্য সনাক্তকারী তৈরি করতে।

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

26 [একটি-জেড -9 -9] অক্ষর জেনারেট করে, যা একটি UID প্রদান করে যা উভয়টি ছোট এবং RFC সম্মিলিত GUID এর চেয়ে অনন্য। মানুষের পঠনযোগ্যতা বিষয় যদি ড্যাশ trivially যোগ করা যেতে পারে।

এখানে এই ফাংশন এবং এই প্রশ্নের অন্যান্য উত্তরগুলির জন্য কয়েকটি ব্যবহার উদাহরণ এবং সময়। সময়টি Chrome M25 এর অধীনে 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');

ব্রোওফা এর উত্তর বেশ চটচটে, প্রকৃতপক্ষে - চিত্তাকর্ষক চতুর, সত্যিই ... rfc4122 অনুবর্তী, কিছুটা পঠনযোগ্য, এবং কম্প্যাক্ট। অসাধারণ!

কিন্তু আপনি যে নিয়মিত অভিব্যক্তিটি দেখছেন, সেগুলি অনেকগুলি replace() কলব্যাকগুলি, toString() এর এবং Math.random() ফাংশন কলগুলি (যেখানে সে শুধুমাত্র ফলাফলের 4 বিট ব্যবহার করে এবং বাকিগুলি নষ্ট করে), আপনি শুরু করতে পারেন কর্মক্ষমতা সম্পর্কে বিস্মিত। প্রকৃতপক্ষে, jelptpt generic GUID গতির জন্য generQuickGUID এর সাথে RFC টাস্ক করার সিদ্ধান্ত নিয়েছে।

কিন্তু, আমরা গতি এবং আরএফসি সম্মতি পেতে পারি? আমি বলতে হ্যাঁ! আমরা কি পঠনযোগ্যতা বজায় রাখতে পারি? আচ্ছা ... সত্যিই না, তবে আপনি যদি অনুসরণ করেন তবে এটি সহজ।

কিন্তু প্রথমত, আমার ফলাফল, ব্রোওফা, guid (গ্রহণযোগ্য উত্তর) এবং অ-আরএফসি-সম্মিলিত generateQuickGuid QuickGuid এর তুলনায়:

                  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 এর দ্রুত-অ- সম্মতিপূর্ণ উত্তরটি বীট করেছি । এবং আমি এখনও rfc4122 সঙ্গতিশীল।

কিভাবে আগ্রহী? আমি http://jsfiddle.net/jcward/7hyaC/3/ এবং http://jsfiddle.net/jcward/7hyaC/3/ এ সম্পূর্ণ উত্স রেখেছি

ব্যাখ্যা করার জন্য, ব্রোওফার কোড দিয়ে শুরু করি:

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

সুতরাং এটি র্যান্ডম হেক্সা ডিজিটের সাথে কোনও র্যান্ডম হেক্সা ডিজিট সহ y অক্ষকে প্রতিস্থাপিত করে (উপরের 2 বিটগুলি 10 থেকে RFC স্পেক প্রতি 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() পরিবর্তে) আমাদের প্রায় 3X উন্নতি পায়!

পরবর্তী ধাপটি ডেস্কটপে একটি ছোট ছোট কিন্তু মোবাইলে একটি শালীন পার্থক্য করে। আসুন কম Math.Random () কে র্যান্ডম বিটকে কল করি এবং 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-উপাদান সন্ধানের টেবিলটি কম সময়ের মধ্যে স্ট্রিং (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-বিট পরিচালনা করছি, তাই আমরা প্রতিটি অর্ধেক loops সংখ্যা কাটা এবং প্রতিটি পুনরাবৃত্তি 8-বিট প্রক্রিয়া করি। এটি কঠিন কারণ আমরা এখনও RFC সামঞ্জস্যপূর্ণ বিট অবস্থানগুলি পরিচালনা করতে হবে, তবে এটি খুব কঠিন নয়। আমরা তখন 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
}

আমি একটি e6 () চেষ্টা করেছিলাম যা একটি সময়ে 16-বিট প্রসেস করে, এখনও 256-উপাদান LUT ব্যবহার করে, এবং এটি অপ্টিমাইজেশনের হ্রাসপ্রাপ্ত আয়গুলি দেখায়। যদিও এটি কম পুনরাবৃত্তি ছিল, অভ্যন্তরীণ যুক্তি বৃদ্ধি প্রসেসিং দ্বারা জটিল ছিল, এবং এটি ডেস্কটপে একইভাবে সঞ্চালিত হয়েছিল, এবং কেবলমাত্র ~ 10% দ্রুত মোবাইলে।

প্রয়োগ করার চূড়ান্ত অপ্টিমাইজেশান কৌশল - লুপ আনলোল। যেহেতু আমরা একটি নির্দিষ্ট সংখ্যক সময় looping করছি, আমরা প্রযুক্তিগতভাবে হাত দ্বারা সব এই লিখতে পারেন। আমি একবার এটি একটি একক র্যান্ডম পরিবর্তনশীল আর দিয়ে চেষ্টা করেছি যা আমি পুনরায় বরাদ্দ রাখা, এবং কর্মক্ষমতা ট্যাঙ্ক। কিন্তু চারটি ভেরিয়েবল সামনে এলোমেলো তথ্য প্রদান করে, তারপর সন্ধান টেবিলটি ব্যবহার করে এবং সঠিক RFC বিট প্রয়োগ করে, এই সংস্করণটি তাদের সকলকে ধোঁকা দেয়:

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 বাইট জেনারেশনটি সহজ অংশ। পুরো কৌশলটি RFC সম্মতির সাথে স্ট্রিং ফর্ম্যাটে এটি প্রকাশ করছে এবং এটি 16 টি বাইট র্যান্ডম ডেটা, একটি অরোল্লড লুপ এবং সন্ধানের টেবিলে সর্বাধিক শক্তভাবে সম্পন্ন হয়।

আমি আশা করি আমার যুক্তি সঠিক - এই ধরনের ক্লান্তিকর বিট-কাজে ভুল করা খুব সহজ। কিন্তু আউটপুট আমার জন্য ভাল চেহারা। আমি আশা করি আপনি কোড অপ্টিমাইজেশান মাধ্যমে এই পাগল যাত্রায় আস্বাদিত!

পরামর্শ দেওয়া: আমার প্রাথমিক লক্ষ্য সম্ভাব্য অপ্টিমাইজেশান কৌশল প্রদর্শন এবং শেখান ছিল। অন্যান্য উত্তরগুলিতে গুরুত্বপূর্ণ বিষয়গুলি যেমন সংঘর্ষ এবং সত্যিকারের র্যান্ডম সংখ্যাগুলি অন্তর্ভুক্ত রয়েছে যা ভাল UUID তৈরির জন্য গুরুত্বপূর্ণ।


সাগী শেকডি এর প্রযুক্তিগত ব্লগ থেকে :

function generateGuid() {
  var result, i, j;
  result = '';
  for(j=0; j<32; j++) {
    if( j == 8 || j == 12|| j == 16|| j == 20) 
      result = result + '-';
    i = Math.floor(Math.random()*16).toString(16).toUpperCase();
    result = result + i;
  }
  return result;
}

ActiveX নিয়ন্ত্রণ ব্যবহার করে জড়িত অন্যান্য পদ্ধতি আছে, কিন্তু এই থেকে দূরে থাকুন!

সম্পাদনা করুন: আমি মনে করি এটি কোনও GUID জেনারেটর অনন্য কীগুলি গ্যারান্টি দেয় ( উইকিপিডিয়া নিবন্ধটি পরীক্ষা করে দেখুন) এটি মূল্যবান বলে বিবেচিত। সংঘর্ষের একটি সুযোগ সবসময় আছে। একটি GUID সহজভাবে প্রায় nil সংঘর্ষ পরিবর্তন হ্রাস করার জন্য কী একটি বড় যথেষ্ট মহাবিশ্ব প্রস্তাব।


আমি ব্রোফা এর উত্তর বুঝতে চেয়েছিলাম, তাই আমি এটি প্রসারিত করেছি এবং মন্তব্য যোগ করেছি:

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

এই থ্রেড সেরা উত্তর সমন্বয় হিসাবে সহজ জাভাস্ক্রিপ্ট মডিউল।

var crypto = window.crypto || window.msCrypto || null; // IE11 fix

var Guid = Guid || (function() {

  var EMPTY = '00000000-0000-0000-0000-000000000000';

  var _padLeft = function(paddingString, width, replacementChar) {
    return paddingString.length >= width ? paddingString : _padLeft(replacementChar + paddingString, width, replacementChar || ' ');
  };

  var _s4 = function(number) {
    var hexadecimalResult = number.toString(16);
    return _padLeft(hexadecimalResult, 4, '0');
  };

  var _cryptoGuid = function() {
    var buffer = new window.Uint16Array(8);
    window.crypto.getRandomValues(buffer);
    return [_s4(buffer[0]) + _s4(buffer[1]), _s4(buffer[2]), _s4(buffer[3]), _s4(buffer[4]), _s4(buffer[5]) + _s4(buffer[6]) + _s4(buffer[7])].join('-');
  };

  var _guid = function() {
    var currentDateMilliseconds = new Date().getTime();
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(currentChar) {
      var randomChar = (currentDateMilliseconds + Math.random() * 16) % 16 | 0;
      currentDateMilliseconds = Math.floor(currentDateMilliseconds / 16);
      return (currentChar === 'x' ? randomChar : (randomChar & 0x7 | 0x8)).toString(16);
    });
  };

  var create = function() {
    var hasCrypto = crypto != 'undefined' && crypto !== null,
      hasRandomValues = typeof(window.crypto.getRandomValues) != 'undefined';
    return (hasCrypto && hasRandomValues) ? _cryptoGuid() : _guid();
  };

  return {
    newGuid: create,
    empty: EMPTY
  };
})();

// DEMO: Create and show GUID
console.log(Guid.newGuid());

ব্যবহার:

Guid.newGuid ()

"C6c2d12f-d76b-5739-e551-07e6de5b0807"

Guid.empty

"00000000-0000-0000-0000-000000000000"


এটি শুধু একটি সহজ AJAX কল ...

যদি কেউ এখনও আগ্রহী, এখানে আমার সমাধান।

সার্ভার পাশে:

[WebMethod()]
public static string GenerateGuid()
{
    return Guid.NewGuid().ToString();
}

ক্লায়েন্ট পাশে:

var myNewGuid = null;
PageMethods.GenerateGuid(
    function(result, userContext, methodName)
    {
        myNewGuid = result;
    },
    function()
    {
        alert("WebService call failed.");
    }
);

ভাল উপায়:

function(
  a,b                // placeholders
){
  for(               // loop :)
      b=a='';        // b - result , a - numeric variable
      a++<36;        // 
      b+=a*51&52  // if "a" is not 9 or 14 or 19 or 24
                  ?  //  return a random number or 4
         (
           a^15      // if "a" is not 15
              ?      // genetate a random number from 0 to 15
           8^Math.random()*
           (a^20?16:4)  // unless "a" is 20, in which case a random number from 8 to 11
              :
           4            //  otherwise 4
           ).toString(16)
                  :
         '-'            //  in other cases (if "a" is 9,14,19,24) insert "-"
      );
  return b
 }

ন্যূনতম:

function(a,b){for(b=a='';a++<36;b+=a*51&52?(a^15?8^Math.random()*(a^20?16:4):4).toString(16):'-');return b}

ভাল ol 'উইকিপিডিয়া থেকে UUID এর একটি জাভাস্ক্রিপ্ট বাস্তবায়ন লিঙ্ক আছে।

এটি মোটামুটি মার্জিত দেখাচ্ছে এবং সম্ভবত ক্লায়েন্টের আইপি ঠিকানার হ্যাশের সাথে স্যালিং করে উন্নত করা যেতে পারে। ক্লায়েন্ট-সাইড জাভাস্ক্রিপ্ট দ্বারা এই হ্যাশ সম্ভবত HTML ডকুমেন্ট সার্ভার-সাইডে ঢোকানো যেতে পারে।

আপডেট: আসল সাইটে একটি শ্যাফেল হয়েছে, এখানে আপডেট সংস্করণ


here কিছু অতিরিক্ত সঙ্গে আমার নিজস্ব UUID / GUID জেনারেটর সামঞ্জস্য ।

আমি একটু বেশি ক্রিপ্টোগ্রাফিকভাবে শব্দ হতে নিম্নলিখিত Kybos র্যান্ডম সংখ্যা জেনারেটরের ব্যবহার করছি ।

নীচের baagoe.com থেকে মাশ এবং Kybos পদ্ধতি সঙ্গে আমার স্ক্রিপ্ট বাদ দেওয়া হয়।

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

অদ্ভুত যে কেউ এখনো এটিকে উল্লেখ করেনি কিন্তু সম্পূর্ণতার জন্য, এনপিএম-এ গুইড জেনারেটরদের প্রচুর পরিমাণে আমি ব্রাউজারে তাদের বেশিরভাগ কাজই বাজি করতে ইচ্ছুক।


আচ্ছা, এই ইতিমধ্যে উত্তর একটি গুচ্ছ আছে, কিন্তু দুর্ভাগ্যবশত গুচ্ছ একটি "সত্য" র্যান্ডম নেই। নীচের সংস্করণ ব্রোফা এর উত্তরের একটি অভিযোজন, কিন্তু একটি "সত্য" র্যান্ডম ফাংশন অন্তর্ভুক্ত করার জন্য আপডেট করা হয়েছে যেখানে ক্রিপ্টো লাইব্রেরিগুলি উপলব্ধ রয়েছে এবং আলে () ফাংশব্যাক হিসাবে কাজ করে।

  Math.log2 = Math.log2 || function(n){ return Math.log(n) / Math.log(2); }
  Math.trueRandom = (function() {
  var crypt = window.crypto || window.msCrypto;

  if (crypt && crypt.getRandomValues) {
      // if we have a crypto library, use it
      var random = function(min, max) {
          var rval = 0;
          var range = max - min;
          if (range < 2) {
              return min;
          }

          var bits_needed = Math.ceil(Math.log2(range));
          if (bits_needed > 53) {
            throw new Exception("We cannot generate numbers larger than 53 bits.");
          }
          var bytes_needed = Math.ceil(bits_needed / 8);
          var mask = Math.pow(2, bits_needed) - 1;
          // 7776 -> (2^13 = 8192) -1 == 8191 or 0x00001111 11111111

          // Create byte array and fill with N random numbers
          var byteArray = new Uint8Array(bytes_needed);
          crypt.getRandomValues(byteArray);

          var p = (bytes_needed - 1) * 8;
          for(var i = 0; i < bytes_needed; i++ ) {
              rval += byteArray[i] * Math.pow(2, p);
              p -= 8;
          }

          // Use & to apply the mask and reduce the number of recursive lookups
          rval = rval & mask;

          if (rval >= range) {
              // Integer out of acceptable range
              return random(min, max);
          }
          // Return an integer that falls within the range
          return min + rval;
      }
      return function() {
          var r = random(0, 1000000000) / 1000000000;
          return r;
      };
  } else {
      // From http://baagoe.com/en/RandomMusings/javascript/
      // Johannes Baagøe <[email protected]>, 2010
      function Mash() {
          var n = 0xefc8249d;

          var mash = function(data) {
              data = data.toString();
              for (var i = 0; i < data.length; i++) {
                  n += data.charCodeAt(i);
                  var h = 0.02519603282416938 * n;
                  n = h >>> 0;
                  h -= n;
                  h *= n;
                  n = h >>> 0;
                  h -= n;
                  n += h * 0x100000000; // 2^32
              }
              return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
          };

          mash.version = 'Mash 0.9';
          return mash;
      }

      // From http://baagoe.com/en/RandomMusings/javascript/
      function Alea() {
          return (function(args) {
              // Johannes Baagøe <[email protected]>, 2010
              var s0 = 0;
              var s1 = 0;
              var s2 = 0;
              var c = 1;

              if (args.length == 0) {
                  args = [+new Date()];
              }
              var mash = Mash();
              s0 = mash(' ');
              s1 = mash(' ');
              s2 = mash(' ');

              for (var i = 0; i < args.length; i++) {
                  s0 -= mash(args[i]);
                  if (s0 < 0) {
                      s0 += 1;
                  }
                  s1 -= mash(args[i]);
                  if (s1 < 0) {
                      s1 += 1;
                  }
                  s2 -= mash(args[i]);
                  if (s2 < 0) {
                      s2 += 1;
                  }
              }
              mash = null;

              var random = function() {
                  var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32
                  s0 = s1;
                  s1 = s2;
                  return s2 = t - (c = t | 0);
              };
              random.uint32 = function() {
                  return random() * 0x100000000; // 2^32
              };
              random.fract53 = function() {
                  return random() +
                      (random() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53
              };
              random.version = 'Alea 0.9';
              random.args = args;
              return random;

          }(Array.prototype.slice.call(arguments)));
      };
      return Alea();
  }
}());

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

আমি জানি, এটি একটি পুরানো প্রশ্ন। শুধু সম্পূর্ণতার জন্য, যদি আপনার পরিবেশটি SharePoint হয়, তবে একটি নতুন গিড তৈরি করে এমন একটি ইউটিলিটি ফাংশন SP.Guid.newGuid( MSDN লিঙ্ক ) তৈরি হয়। এই ফাংশন 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;
};

এই এক তারিখ উপর ভিত্তি করে, এবং একটি "রুপান্তরিত" স্বতন্ত্রতা একটি র্যান্ডম প্রতিক্রিয়া যোগ করুন। CSS সনাক্তকারীর জন্য ভাল কাজ করে। এটা সবসময় ভালো কিছু ফেরত এবং হ্যাক করা সহজ:

ইউআইডি-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.99999999999999% বিশ্বব্যাপী অনন্য হওয়ার সম্ভাবনা রয়েছে (10 ^ 15 এর মধ্যে সংঘর্ষের 1)

আপনি আরও সংখ্যার যোগ করে এই সংখ্যাটি বাড়িয়ে তুলতে পারেন তবে 100% অনন্য আইডি তৈরি করতে আপনাকে একটি বিশ্বব্যাপী কাউন্টার ব্যবহার করতে হবে।

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






uuid