إنشاء GUID/UUID في JavaScript؟




(20)

أسرع GUID مثل طريقة مولد سلسلة في تنسيق XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX . هذا لا إنشاء 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() رقم عشري بين 0 و 1 مع 16 رقماً بعد نقطة الكسر العشري (على سبيل المثال 0.4363923368509859 ).
  • ثم نأخذ هذا الرقم 0.6fb7687f إلى سلسلة بـ base 16 (من المثال أعلاه سنحصل على 0.6fb7687f ).
    Math.random().toString(16) .
  • ثم نقطع البادئة 0. ( 0.6fb7687f => 6fb7687f ) ونحصل على سلسلة ذات ثمانية حروف سداسية عشرية طويلة.
    (Math.random().toString(16).substr(2,8) .
  • في بعض الأحيان ستقوم الدالة Math.random() بإرجاع عدد أقل (على سبيل المثال 0.4363 ) ، بسبب الأصفار في النهاية (من المثال أعلاه ، فعليًا الرقم هو 0.4363000000000000 ). لهذا السبب أقوم بإلحاق هذه السلسلة "000000000" (سلسلة ذات تسعة أصفار) ثم قطعها باستخدام وظيفة substr() لجعلها تسع أحرف بالضبط (تعبئة الأصفار إلى اليمين).
  • يرجع السبب في إضافة تسعة أصفار بالضبط إلى سيناريو الحالة الأسوأ ، وهو عندما تقوم الدالة Math.random() بإرجاع 0 أو 1 بالضبط (احتمال 1/10 ^ 16 لكل واحد منهم). لهذا السبب كنا بحاجة لإضافة تسعة أصفار إليها ( "0"+"000000000" أو "1"+"000000000" ) ، ثم قطعها من الفهرس الثاني (الحرف الثالث) بطول ثمانية أحرف. بالنسبة لبقية الحالات ، فإن إضافة الأصفار لن تضر النتيجة لأنها تقطعها على أية حال.
    Math.random().toString(16)+"000000000").substr(2,8) .

التجمع:

  • GUID بالتنسيق التالي XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX .
  • قسمت المعرف الفريد العمومي إلى 4 قطع ، كل قطعة مقسمة إلى 2 أنواع (أو تنسيقات): XXXXXXXX و -XXXX-XXXX .
  • الآن أنا إنشاء GUID باستخدام هذه الأنواع 2 لتجميع GUID مع استدعاء 4 قطع ، كما يلي: XXXXXXXX -XXXX-XXXX -XXXX-XXXX XXXXXXXX .
  • _p8(s) بين هذين النوعين ، أضفت معلمة علم إلى دالة _p8(s) ، تخبر المعلمة s الدالة ما إذا كنت تريد إضافة شرطات أم لا.
  • في نهاية المطاف نبني GUID بالسلاسل التالية: _p8() + _p8(true) + _p8(true) + _p8() ، وإعادته.

رابط لهذه المشاركة على مدونتي

استمتع! :-)

أحاول إنشاء معرّفات فريدة عالميًا في جافا سكريبت. لست متأكدا ما هي الروتينية المتاحة على جميع المتصفحات ، وكيف "عشوائي" وبذر المولد رقم عشوائي المدمج ، وما إلى ذلك.

يجب أن يتكون GUID / UUID من 32 حرفًا على الأقل ويجب أن يبقى في نطاق ASCII لتجنب حدوث أي مشكلات عند تمريرها.


أنا حقاً أحب طريقة إجابة Broofa ، لكن من المؤسف أن التطبيقات الضعيفة لـ Math.random تترك الفرصة للتصادم.

فيما يلي حل متوافق مع ietf.org/rfc/rfc4122.txt الإصدار 4 يعمل على حل هذه المشكلة عن طريق موازنة الأرقام ietf.org/rfc/rfc4122.txt عشر الأولى الأولى بواسطة جزء سداسي عشرية من الطابع الزمني. وبهذه الطريقة ، حتى لو كان Math.random على نفس البذرة ، سيتعين على كلا العملاء إنشاء UUID بنفس ميلي ثانية واحدة (أو أكثر من 10000 سنة لاحقة) للحصول على نفس 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);
    });
}


وهنا كمان للاختبار.


ستكون خدمة الويب مفيدة.

العثور السريع على Google: http://www.hoskinson.net/GuidGenerator/

لا يمكن ضمان هذا التنفيذ ، ولكن يجب على SOMEONE نشر مولد GUID.

باستخدام خدمة ويب هذه ، يمكنك تطوير واجهة ويب REST تستهلك خدمة ويب GUID ، وتخدمها من خلال AJAX إلى javascript في المستعرض.


في ما يلي حل مؤرخ في 9 تشرين الأول 2011 من تعليق بواسطة المستخدم jed على 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
      )
}

فيما يلي بعض التعليمات البرمجية التي تستند إلى ietf.org/rfc/rfc4122.txt ، القسم 4.4 (خوارزميات لإنشاء UUID من Random Random أو Pseudo-Random Number).

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

فيما يلي تطبيق غير متوافق تمامًا ولكنه ذو أداء عالي جدًا لإنشاء معرّف فريد مثل ASID GUID آمن مثل.

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

ينشئ 26 حرفًا [a-z0-9] ، مما يؤدي إلى الحصول على UID قصيرًا وفريدًا أكثر من GUIDs المتوافقة مع RFC. ﻳﻤﻜﻦ إﺿﺎﻓﺔ اﻟﺸﻄﻒ ﺑﺴﻬﻮﻟﺔ إذا آﺎﻧﺖ اﻟﻘﺮاءة اﻟﺒﺸﺮﻳﺔ ﻣﻬﻤﺔ.

فيما يلي أمثلة الاستخدام وتوقيت هذه الوظيفة والعديد من الإجابات الأخرى لهذا السؤال. تم تنفيذ التوقيت تحت كروم 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 الإصدار 4 ، فإن حل الخطوط RFC4122 (ish) هذا هو الأكثر تعقيدًا الذي يمكنني الحصول عليه:

function uuidv4() {
  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);
  });
}

console.log(uuidv4())

Update، 2015-06-02 : كن على دراية بأن تفرد UUID يعتمد بشكل كبير على مولد الأرقام العشوائية الأساسي (RNG). يستخدم الحل أعلاه Math.random() للإيجاز ، لكن Math.random() غير مضمون أن يكون RNG عالي الجودة. شاهد كتابة آدم هيلاند الممتازة على Math.random () لمزيد من التفاصيل. للحصول على حل أكثر قوة ، ضع في اعتبارك شيئًا مثل الوحدة النمطية uuid [إخلاء المسؤولية: أنا المؤلف] ، والذي يستخدم واجهات برمجة تطبيقات RNG ذات جودة أعلى حيثما كان ذلك متاحًا.

التحديث ، 2015-08-26 : كملاحظة جانبية ، يوضح هذا gist كيفية تحديد عدد المعرفات التي يمكن إنشاؤها قبل الوصول إلى احتمال معين من الاصطدام. على سبيل المثال ، مع الإصدار 3.26x10 15 الإصدار 4 من RFC4122 UUID ، يكون لديك فرصة واحدة للتصادم بحدود 1 مليون مرة.

التحديث ، 2017-06-28 : مقالة جيدة من مطوري Chrome تناقش حالة جودة Math.random PRNG في Chrome و Firefox و Safari. tl؛ dr - اعتبارًا من أواخر 2015 "جيد جدًا" ، ولكن ليس جودة تشفير. لمعالجة هذه المشكلة ، إليك إصدار محدّث من الحل أعلاه يستخدم ES6 ، وواجهة برمجة تطبيقات crypto ، ونموذجًا صغيرًا لمعالج JS ، لا يمكنني الحصول على الفضل في :

function uuidv4() {
  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
  )
}

console.log(uuidv4());


من مدونة sagi shkedyy الفنية :

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 ، ولكن ابتعدي عن هذه!

EDIT: أعتقد أنه كان من المفيد الإشارة إلى أنه لا يوجد مولد GUID يمكن أن يضمن مفاتيح فريدة (راجع مقالة wikipedia ). هناك دائما فرصة للتصادم. يوفر المعرف الفريد العمومي (GUID) ببساطة مجموعة كبيرة من المفاتيح لتقليص التغير في التصادمات إلى الصفر تقريباً.


إنها مجرد مكالمة 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}

لأولئك الذين يرغبون في حل متوافق مع الإصدار rfc4122 مع اعتبارات السرعة (عدد قليل من المكالمات إلى 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("");
}

الوظيفة المذكورة أعلاه يجب أن يكون لها توازن لائق بين السرعة والعشوائية.


هذا إنشاء الإصدار 4 UUID (تم إنشاؤه من أرقام عشوائية زائفة):

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

هنا عينة من UUIDs ولدت:

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

أنا أعلم ، إنه سؤال قديم. فقط من أجل اكتمالها ، إذا كانت البيئة الخاصة بك هي 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;
};

الغريب أن لا أحد قد ذكر هذا بعد ولكن للاكتمال ، هناك وفرة من المولدات guid على npm أنا على استعداد للمراهنة معظمهم يعملون في المتصفح أيضا.


حسنا ، هذا لديه مجموعة من الإجابات بالفعل ، ولكن للأسف ليس هناك عشوائي "صحيح" في المجموعة. يعتبر الإصدار أدناه تكيّفًا لإجابة البروف ، ولكن تم تحديثه ليشمل وظيفة عشوائية "حقيقية" تستخدم مكتبات التشفير حيث تكون متاحة ، ووظيفة Alea () كخلفية احتياطية.

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

مشروع JavaScript على GitHub - https://github.com/LiosK/UUID.js

UUID.js مولد UUID المتوافق مع RFC لجافا سكريبت.

انظر RFC 4122 ietf.org/rfc/rfc4122.txt .

ميزات Generates UUIDs متوافقة مع RFC 4122.

يتوفر الإصدار 4 UUID (UUIDs من أرقام عشوائية) و UUIDs الإصدار 1 (UUIDs المستندة إلى الوقت).

يسمح كائن UUID بمجموعة متنوعة من الوصول إلى UUID بما في ذلك الوصول إلى حقول UUID.

يتم تعويض انخفاض دقة طابع زمني لجافا سكريبت بأرقام عشوائية.


هذا يعتمد على التاريخ ، وإضافة لاحقة عشوائية "ضمان" التفرد. يعمل بشكل جيد مع معرفات 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;
        };

هناك المساعد jQuery الذي يعالج جيد Guid @ 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()

إرجاع منطقي. صحيح صحيح ارشد ، كاذبة إن لم يكن.

jQuery.Guid.Set()

Retrns Guid. مجموعات Guid إلى المستخدم المحدد Guid ، إذا كان غير صالح ، تقوم بإرجاع guid فارغة.


  // 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٪ من المحتمل أن يكون فريدًا عالميًا (الاصطدام في 1 من 10 ^ 15)

يمكنك زيادة هذا الرقم بإضافة المزيد من الأرقام ، ولكن لإنشاء معرّف فريد 100٪ ، ستحتاج إلى استخدام عداد عالمي.

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







uuid