如何创建 GUID/UUID？

Question

如何在 JavaScript 中创建 GUID（全局唯一标识符）？ GUID / UUID 应至少为 32 个字符，并且应保持在 ASCII 范围内，以避免传递它们时出现麻烦。

我不确定所有浏览器上都有哪些例程，内置随机数生成器的“随机性”和种子是如何的，等等。

Answer 1

这是一个完全不兼容但非常高性能的实现，用于生成 ASCII 安全的类似 GUID 的唯一标识符。

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

生成 26 个 [a-z0-9] 字符，生成比符合 RFC 的 GUID 更短且更独特的 UID。 如果人类可读性很重要，可以简单地添加破折号。

以下是此函数的使用示例和时间安排以及该问题的其他几个答案。 计时在 Chrome m25 下进行，每次迭代 1000 万次。

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

Answer 2

来自 sagi shkedy 的技术博客：

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 只是提供足够大的键域，以将碰撞的变化减少到几乎为零。

Answer 3

以下是投票最高的答案的组合，以及Chrome 的冲突：

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

它是 on jsbin 如果你想测试它。

Answer 4

以下是 2011 年 10 月 9 日用户 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
      )
}

Answer 5

您可以使用 node-uuid。 它提供简单、快速的 RFC4122 UUIDS 生成。

功能：

• 生成 RFC4122 版本 1 或版本 4 UUID
• 在 Node.js 和浏览器中运行。
• 支持平台上的加密强随机 # 生成。
• 占用空间小（想要更小的东西？看看这个！）

---

使用 NPM 安装：

npm install uuid

---

或通过浏览器使用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'

---

ECMAScript 2015 (ES6)：

import uuid from 'uuid/v4';
const id = uuid();

Answer 6

UUID（通用唯一标识符），也称为 GUID（全局唯一标识符），根据 RFC 4122 是旨在提供某些唯一性保证的标识符。

虽然可以通过几行 JavaScript 代码实现符合 RFC 的 UUID（例如，请参阅下面的 @broofa 的回答） ）有几个常见的陷阱：

• 无效的 id 格式（UUID 的格式必须是“xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx”，其中 x 是 [0-9, af] 之一M 是 [1-5] 之一，N 是 [8、9、a 或 b]
• 使用低质量随机源（例如 Math.random）

因此，鼓励为生产环境编写代码的开发人员使用严格的、维护良好的实现，例如 uuid 模块。

Answer 7

[于 2023 年 3 月 5 日编辑，以反映生成符合 RFC4122 的 UUID 的最新最佳实践]

crypto.randomUUID() 现在是所有现代浏览器和 JS 运行时的标准。 但是，由于新的浏览器 API 仅限于安全上下文，此方法仅适用于本地（localhost 或 127.0.0.1）或通过 HTTPS 提供的页面。

对于对其他 UUID 版本、在旧平台或非安全环境中生成 UUID 感兴趣的读者，可以查看 uuid模块。 它经过了良好的测试和支持。

如果上述方法失败，还有这种方法（基于这个问题的原始答案）：

function uuidv4() {
  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c =>
    (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
  );
}

console.log(uuidv4());

注意：强烈建议不要使用任何依赖于Math.random()的UUID生成器（包括本答案之前版本中的片段） ）原因最好解释在这里。 TL;DR：基于 Math.random() 的解决方案不能提供良好的唯一性保证。

Answer 8

以下是在支持的浏览器上使用crypto.getRandomValues(a)的简单代码a>（Internet Explorer 11+、iOS 7+、Firefox 21+、Chrome 和 Android Chrome）。

它避免使用 Math.random()，因为这可能会导致冲突（例如，在真实情况下，Muxa）。

function uuid() {
    function randomDigit() {
        if (crypto && crypto.getRandomValues) {
            var rands = new Uint8Array(1);
            crypto.getRandomValues(rands);
            return (rands[0] % 16).toString(16);
        } else {
            return ((Math.random() * 16) | 0).toString(16);
        }
    }

    var crypto = window.crypto || window.msCrypto;
    return 'xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx'.replace(/x/g, randomDigit);
}

注意：

• 针对代码可读性而不是速度进行了优化，因此它适合每秒数百个 UUID。 它在我的笔记本电脑上使用 http://jsbin.com/fuwigo/1 在 Chromium 中每秒生成大约 10000 个 uuid() 来衡量性能。
• 它仅使用 8 表示“y”，因为这样可以简化代码的可读性（y 允许为 8、9、A 或 B）。

Answer 9

如果您只需要一个没有特定格式的随机 128 位字符串，您可以使用：

function uuid() {
    return crypto.getRandomValues(new Uint32Array(4)).join('-');
}

这将返回类似 2350143528-4164020887-938913176-2513998651 的内容。

Answer 10

只是另一个更具可读性的变体，只有两个突变。

function uuid4()
{
  function hex (s, b)
  {
    return s +
      (b >>> 4   ).toString (16) +  // high nibble
      (b & 0b1111).toString (16);   // low nibble
  }

  let r = crypto.getRandomValues (new Uint8Array (16));

  r[6] = r[6] >>> 4 | 0b01000000; // Set type 4: 0100
  r[8] = r[8] >>> 3 | 0b10000000; // Set variant: 100

  return r.slice ( 0,  4).reduce (hex, '' ) +
         r.slice ( 4,  6).reduce (hex, '-') +
         r.slice ( 6,  8).reduce (hex, '-') +
         r.slice ( 8, 10).reduce (hex, '-') +
         r.slice (10, 16).reduce (hex, '-');
}

Answer 11

更好的方法：

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,
                  ?              // generate 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}

Answer 12

我用一些额外的东西调整了我自己的 UUID/GUID 生成器 here 。

我正在使用 以下 Kybos 随机数生成器，以便在加密方面更加可靠。

下面是我的脚本，不包括来自 baagoe.com 的 Mash 和 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));

Answer 13

ES6 示例

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

Answer 14

我找不到任何使用单个 16 字节 TypedArray 和 DataView 的答案，因此我认为以下解决方案可以为每个 RFC 将在这里独立存在：

const uuid4 = () => {
    const ho = (n, p) => n.toString(16).padStart(p, 0); /// Return the hexadecimal text representation of number `n`, padded with zeroes to be of length `p`; e.g. `ho(13, 2)` returns `"0d"`
    const data = crypto.getRandomValues(new Uint8Array(16)); /// Fill a buffer with random bits
    data[6] = (data[6] & 0xf) | 0x40; /// Patch the 6th byte to reflect a version 4 UUID
    data[8] = (data[8] & 0x3f) | 0x80; /// Patch the 8th byte to reflect a variant 1 UUID (version 4 UUIDs are)
    const view = new DataView(data.buffer); /// Create a view backed by the 16-byte buffer
    return `${ho(view.getUint32(0), 8)}-${ho(view.getUint16(4), 4)}-${ho(view.getUint16(6), 4)}-${ho(view.getUint16(8), 4)}-${ho(view.getUint32(10), 8)}${ho(view.getUint16(14), 4)}`; /// Compile the canonical textual form from the array data
};

我更喜欢它，因为：

• 它只依赖于可用的功能标准 ECMAScript 平台，如果可能的话——这只是一个过程，
• 它只使用一个缓冲区，最大限度地减少数据复制，这在理论上应该产生性能优势

在撰写本文时，getRandomValues 不是Node.js 中为 crypto 对象实现的东西。 但是，它具有等效的 randomBytes 函数，可以用来代替。

Answer 15

本机 URL.createObjectURL 正在生成 UUID。 您可以利用这一点。

function uuid() {
  const url = URL.createObjectURL(new Blob())
  const [id] = url.toString().split('/').reverse()
  URL.revokeObjectURL(url)
  return id
}

Answer 16

我想了解 broofa 的答案，所以我扩展了它并补充评论：

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

Answer 17

对于那些想要一个符合 RFC 4122 版本 4 并考虑速度的解决方案（很少调用 Math 。随机的（））：

var rand = Math.random;

function UUID() {
    var nbr, randStr = "";
    do {
        randStr += (nbr = rand()).toString(16).substr(3, 6);
    } 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)
    );
}

console.log( UUID() );

上述函数应该在速度和随机性之间取得良好的平衡。

Answer 18

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

Answer 19

GitHub 上的 JavaScript 项目 - https://github.com/LiosK/UUID.js

UUID.js 用于 JavaScript 的符合 RFC 的 UUID 生成器。

请参阅 RFC 4122 http://www.ietf.org/rfc/rfc4122.txt。

功能生成符合 RFC 4122 的 UUID。

版本 4 UUID（来自随机数的 UUID）和版本 1 UUID
（基于时间的 UUID）可用。

UUID对象允许对UUID进行各种访问，包括访问
UUID 字段。

JavaScript 的低时间戳分辨率通过随机来补偿
数字。

Answer 20

以下版本改编自 broofa 的答案，但已更新包含一个“真正的”随机函数，该函数使用可用的加密库，并使用 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 https://web.archive.org/web/20120502223108/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);
  });
};

Answer 21

添加于：v15.6.0、v14.17.0 内置了 crypto.randomUUID() 函数。

import { randomUUID } from "node:crypto";

const uuid = crypto.randomUUID();

在浏览器中，crypto.randomUUID() 目前在 Chromium 92+ 和 Firefox 95+ 中受支持。

Answer 22

var uuid = function() {
    var buf = new Uint32Array(4);
    window.crypto.getRandomValues(buf);
    var idx = -1;
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        idx++;
        var r = (buf[idx>>3] >> ((idx%8)*4))&15;
        var v = c == 'x' ? r : (r&0x3|0x8);
        return v.toString(16);
    });
};

这个版本基于 Briguy37 的答案和一些按位运算符从缓冲区中提取半字节大小的窗口。

它应该遵循 RFC Type 4（随机）模式，因为我上次使用 Java 的 UUID 解析不兼容的 UUID 时遇到了问题。

Answer 23

简单的 JavaScript 模块作为这个问题的最佳答案的组合。

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);
    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('1. New Guid:   ' + Guid.newGuid());

// DEMO: Show empty GUID
console.log('2. Empty Guid: ' + Guid.empty);

用法：

<块引用>

Guid.newGuid()

<块引用>

“c6c2d12f-d76b-5739-e551-07e6de5b0807”

<块引用>

Guid.empty

<块引用>

“00000000-0000-0000-0000-000000000000”

Answer 24

这将创建版本 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('');
}

以下是生成的 UUID 的示例：

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

Answer 25

使用 Blob 的一行解决方案。

window.URL.createObjectURL(new Blob([])).substring(31);

末尾的值 (31) 取决于 URL 的长度。

---

编辑：

一个更紧凑和通用的解决方案，如rinogo建议的：

URL.createObjectURL(new Blob([])).slice(-36);

Answer 26

这是最快的类似 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.
 * @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）。
• 然后我们将这个数字进行转换
  将其转换为以 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() 函数将其截断，使其恰好是九个字符（右边补零）。
• 精确添加 9 个零的原因是因为最坏的情况，即 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。
• 我将 GUID 分为四块，每块分为两种类型（或格式）：XXXXXXXX 和 -XXXX-XXXX。
• 现在我正在使用这两种类型构建 GUID，以调用四个部分来组装 GUID，如下所示： XXXXXXXX -XXXX-XXXX -XXXX-XXXX< /代码> <代码>XXXXXXXX。
• 为了区分这两种类型，我向对创建函数 _p8(s) 添加了一个标志参数，s 参数告诉函数是否添加破折号。
• 最终，我们使用以下链接构建 GUID：_p8() + _p8(true) + _p8(true) + _p8() 并返回它。

链接到我博客上的这篇文章

享受吧！ :-)

Answer 27

以下是一些基于 RFC 4122 的代码，第 4.4 节（从真正随机创建 UUID 的算法）或伪随机数）。

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

Answer 28

使用：

let uniqueId = Date.now().toString(36) + Math.random().toString(36).substring(2);

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

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

如果 ID 的生成间隔超过 1 毫秒，则它们 100% 是唯一的。

如果以较短的间隔生成两个 ID，并假设随机方法是真正随机的，则这将生成 99.999999999999999% 可能是全局唯一的 ID（10^15 中的 1 发生冲突）。

您可以通过添加更多数字来增加此数字，但要生成 100% 唯一 ID，您将需要使用全局计数器。

如果您需要 RFC 兼容性，此格式将作为有效的版本 4 GUID 传递：

let u = Date.now().toString(16) + Math.random().toString(16) + '0'.repeat(16);
let guid = [u.substr(0,8), u.substr(8,4), '4000-8' + u.substr(13,3), u.substr(16,12)].join('-');

let u = Date.now().toString(16)+Math.random().toString(16)+'0'.repeat(16);
let guid = [u.substr(0,8), u.substr(8,4), '4000-8' + u.substr(13,3), u.substr(16,12)].join('-');
document.getElementById("unique").innerHTML = guid;

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

上面的代码遵循了意图，但没有遵循 RFC 的字面意思。 除其他差异外，还少了几个随机数字。 （如果需要，可以添加更多随机数字）优点是速度非常快:)
您可以在此处测试 GUID 的有效性

Answer 29

broofa的答案确实非常巧妙 - 非常聪明，真的...符合 RFC4122 标准，具有一定的可读性且紧凑。 惊人的！

但如果您查看该正则表达式，就会发现许多 replace() 回调、toString() 和 Math.random()函数调用（他只使用结果的四位并浪费其余部分），您可能会开始怀疑性能。 事实上，joelpt 甚至决定用 generateQuickGUID 抛出一个用于通用 GUID 速度的 RFC。

但是，我们能否获得速度和 RFC 合规性？ 我说，是的！我们能保持可读性吗？ 嗯...不是真的，但是如果你跟着做的话就很容易了。

但首先，我的结果与 broofa、guid（已接受的答案）和不符合 rfc 的 generateQuickGuid 相比：

                  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.

因此，通过我的第六次优化迭代，我击败了最受欢迎的答案超过12次，接受的答案超过9次，快速不合规的答案超过2-3次 >。 而且我仍然符合 RFC 4122 标准。

感兴趣如何？ 我已将完整源代码放在 http://jsfiddle.net/jcward/7hyaC/3/ 和 https://jsben.ch/xczxS 上的

解释，让我们从 broofa 的代码开始：

function broofa() {
    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(broofa())

因此，它将 x 替换为任意随机的十六进制数字，将 y 替换为随机数据（除了按照 RFC 规范强制将前两位替换为 10），并且正则表达式与 - 或 4 字符不匹配，因此他不必处理它们。 非常非常光滑。

首先要知道的是，函数调用是昂贵的，正则表达式也是如此（虽然他只使用了 1 个，但它有 32 个回调，每个匹配一个，并且在 32 个回调中的每一个中它调用 Math.random() 和 v。到字符串（16））。

提高性能的第一步是消除 RegEx 及其回调函数，并使用简单的循环。 这意味着我们必须处理 - 和 4 字符，而 broofa 则不需要。 另外，请注意，我们可以使用字符串数组索引来保持其灵活的字符串模板架构：

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

console.log(e1())

基本上，内部逻辑相同，除了我们检查 - 或 4 并使用 while 循环（而不是 replace() 回调）我们几乎提高了 3 倍！

下一步在桌面上只是一小步，但在移动设备上却会产生很大的影响。 让我们减少 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
}

console.log(e2())

这可以为我们节省 10-30%，具体取决于平台。 不错。 但下一个重大步骤是通过经典优化——查找表来完全摆脱 toString 函数调用。 一个简单的 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
}

console.log(e4())

接下来的优化又是一个经典。 由于我们在每次循环迭代中仅处理四位输出，因此我们将循环数量减半并在每次迭代中处理八位。 这很棘手，因为我们仍然必须处理符合 RFC 的位位置，但这并不是太难。 然后，我们必须创建一个更大的查找表（16x16 或 256）来存储 0x00 - 0xFF，并且我们仅在 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
}

console.log(e5())

我尝试了一次处理 16 位的 e6()，仍然使用 256 元素 LUT，它显示了优化收益递减。 虽然它的迭代次数较少，但内部逻辑因处理量的增加而变得复杂，并且在桌面上执行相同的操作，而在移动设备上仅快 10% 左右。

最后应用的优化技术 - 展开循环。 由于我们循环固定次数，因此从技术上讲，我们可以手动将其全部写出来。 我用一个随机变量 r 尝试过一次，我不断地重新分配该变量，但性能却下降了。 但是，通过预先分配随机数据的四个变量，然后使用查找表，并应用正确的 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];
}

console.log(e7())

模块化： http://jcward.com/UUID.js - UUID.generate()< /code>

有趣的是，生成 16 字节的随机数据是比较容易的部分。 整个技巧是以符合 RFC 的字符串格式来表达它，并且它是通过 16 字节的随机数据、展开的循环和查找表最紧密地完成的。

我希望我的逻辑是正确的——在这种繁琐的工作中很容易犯错误。 但输出对我来说看起来不错。 我希望您喜欢这段代码优化的疯狂之旅！

请注意：我的主要目标是展示和教授潜在的优化策略。 其他答案涵盖了重要主题，例如碰撞和真正的随机数，这对于生成良好的 UUID 非常重要。

Answer 30

我真的很喜欢Broofa的答案是多么干净，但不幸的是Math.random 的糟糕实现可能会导致冲突。

这是一个类似的符合 RFC4122 版本 4 的解决方案，它通过偏移前 13 个十六进制数字来解决该问题时间戳的十六进制部分，以及自页面加载以来微秒的十六进制部分的一旦耗尽偏移量。 这样，即使 Math.random 位于同一种子上，两个客户端也必须在页面加载后的微秒数（如果支持高性能时间）和准确的时间生成 UUID。相同的毫秒（或 10,000 多年后）获得相同的 UUID：

function generateUUID() { // Public Domain/MIT
    var d = new Date().getTime();//Timestamp
    var d2 = ((typeof performance !== 'undefined') && performance.now && (performance.now()*1000)) || 0;//Time in microseconds since page-load or 0 if unsupported
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        var r = Math.random() * 16;//random number between 0 and 16
        if(d > 0){//Use timestamp until depleted
            r = (d + r)%16 | 0;
            d = Math.floor(d/16);
        } else {//Use microseconds since page-load if supported
            r = (d2 + r)%16 | 0;
            d2 = Math.floor(d2/16);
        }
        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
    });
}

var onClick = function(){
    document.getElementById('uuid').textContent = generateUUID();
}
onClick();

#uuid { font-family: monospace; font-size: 1.5em; }

<p id="uuid"></p>
<button id="generateUUID" onclick="onClick();">Generate UUID</button>

这是一个要测试的小提琴。

---

ES6 的现代化代码片段

const generateUUID = () => {
  let
    d = new Date().getTime(),
    d2 = ((typeof performance !== 'undefined') && performance.now && (performance.now() * 1000)) || 0;
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
    let r = Math.random() * 16;
    if (d > 0) {
      r = (d + r) % 16 | 0;
      d = Math.floor(d / 16);
    } else {
      r = (d2 + r) % 16 | 0;
      d2 = Math.floor(d2 / 16);
    }
    return (c == 'x' ? r : (r & 0x7 | 0x8)).toString(16);
  });
};

const onClick = (e) => document.getElementById('uuid').textContent = generateUUID();

document.getElementById('generateUUID').addEventListener('click', onClick);

onClick();

#uuid { font-family: monospace; font-size: 1.5em; }

<p id="uuid"></p>
<button id="generateUUID">Generate UUID</button>