如何生成像“aX4j9Z”这样的短uid （JS 中）

Question

对于我的网络应用程序（在 JavaScript 中），我想生成简短的 guid（对于不同的对象 - 实际上是不同的类型 - 字符串和字符串数组），

我想要像“aX4j9Z”这样的东西作为我的 uids（guid）。

因此，这些 uid 对于 Web 传输和 js 字符串处理来说应该足够轻量，并且对于不庞大的结构（不超过 10k 元素）来说非常独特。我所说的“非常独特”是指在生成 uid 后，我可以检查该 uid 是否已存在于结构中，如果存在则重新生成它。

Answer 1

获取一个简单的计数器，从 100000000 开始，将数字转换为基数 36。

(100000000).toString(36);  //1njchs

(2100000000).toString(36); //yqaadc

您可以轻松拥有 20 亿个优雅的唯一 ID，就像 YouTube 一样

Answer 2

以下生成 62^3 (238,328) 个 3 个字符的唯一值，前提是区分大小写是唯一的并且所有位置都允许使用数字。如果需要不区分大小写，请从 chars 字符串中删除大写或小写字符，它将生成 35^3 (42,875) 个唯一值。

可以很容易地进行调整，以便第一个字符始终是一个字母或所有字母。

毫无疑问，它可以被优化，并且在达到限制时也可以拒绝返回 id。

var nextId = (function() {
  var nextIndex = [0,0,0];
  var chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
  var num = chars.length;

  return function() {
    var a = nextIndex[0];
    var b = nextIndex[1];
    var c = nextIndex[2];
    var id = chars[a] + chars[b] + chars[c];

    a = ++a % num;

    if (!a) {
      b = ++b % num; 

      if (!b) {
        c = ++c % num; 
      }
    }
    nextIndex = [a, b, c]; 
    return id;
  }
}());

Answer 3

考虑到 ES6 功能的实际威力，我们可以在 JavaScript 中生成哈希 ID，而无需依赖第三方库。

我使用 JavaScript 目前为我们提供的内置函数实现了一个非常简单的生成器。此实现使用 Crypto.getRandomValues() 和 Uint8Array ()如下代码所示：

const hashID = size => {
  const MASK = 0x3d
  const LETTERS = 'abcdefghijklmnopqrstuvwxyz'
  const NUMBERS = '1234567890'
  const charset = `${NUMBERS}${LETTERS}${LETTERS.toUpperCase()}`.split('')

  const bytes = new Uint8Array(size)
  crypto.getRandomValues(bytes)

  return bytes.reduce((acc, byte) => `${acc}${charset[byte & MASK]}`, '')
}

console.log({id: hashID(6)})

此实现使用这些字符：[AZ]、[az]、[0-9] 如果我们添加，总共有 62 个字符_ 和 - 最多可完成 64 个字符，如下所示：

const hashID = size => {
  const MASK = 0x3d
  const LETTERS = 'abcdefghijklmnopqrstuvwxyz'
  const NUMBERS = '1234567890'
  const charset = `${NUMBERS}${LETTERS}${LETTERS.toUpperCase()}_-`.split('')

  const bytes = new Uint8Array(size)
  crypto.getRandomValues(bytes)

  return bytes.reduce((acc, byte) => `${acc}${charset[byte & MASK]}`, '')
}

console.log(`id: ${hashID(6)}`)

注意：

每小时生成 1000 个 ID 长度为 6 个字符的 ID，大约需要 2 天时间才能有 1% 的概率发生至少 1 次冲突。将其实施到您的项目中时请记住这一点。

Answer 4

var letters = 'abcdefghijklmnopqrstuvwxyz';
var numbers = '1234567890';
var charset = letters + letters.toUpperCase() + numbers;

function randomElement(array) {
    with (Math)
        return array[floor(random()*array.length)];
}

function randomString(length) {
    var R = '';
    for(var i=0; i<length; i++)
        R += randomElement(charset);
    return R;
}

Answer 5

这将生成一系列唯一值。它通过在所有值都用尽时增加字符串长度来改进 RobG 的答案。

var IdGenerator = (function () {

    var defaultCharset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()_-+=[]{};:?/.>,<|".split("");

    var IdGenerator = function IdGenerator(charset) {
        this._charset = (typeof charset === "undefined") ? defaultCharset : charset;
        this.reset();
    };

    IdGenerator.prototype._str = function () {
        var str = "",
            perm = this._perm,
            chars = this._charset,
            len = perm.length,
            i;
        for (i = 0; i < len; i++) {
            str += chars[perm[i]];
        }
        return str;
    };

    IdGenerator.prototype._inc = function () {
        var perm = this._perm,
            max = this._charset.length - 1,
            i;
        for (i = 0; true; i++) {
            if (i > perm.length - 1) {
                perm.push(0);
                return;
            } else {
                perm[i]++;
                if (perm[i] > max) {
                    perm[i] = 0;
                } else {
                    return;
                }
            }
        }
    };

    IdGenerator.prototype.reset = function () {
        this._perm = [];
    };

    IdGenerator.prototype.current = function () {
        return this._str();
    };

    IdGenerator.prototype.next = function () {
        this._inc();
        return this._str();
    };

    return IdGenerator;

}).call(null);

用法：

var g = new IdGenerator(),
    i;

for (i = 0; i < 100; i++) {
   console.log(g.next());
}

此要点包含上述实现和递归版本。

Answer 6

只是随机生成一些字符串：

function getUID(len){
    var chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
          out = '';

    for(var i=0, clen=chars.length; i<len; i++){
       out += chars.substr(0|Math.random() * clen, 1);
    }

    // ensure that the uid is unique for this page
    return getUID.uids[out] ? getUID(len) : (getUID.uids[out] = out);
}
getUID.uids = {};

Answer 7

您可以将 GUID 缩短为 20 个可打印 ASCII 字符，而不会丢失 GUID 的信息或唯一性。

杰夫·阿特伍德（Jeff Atwood）几年前在博客中谈到了这一点：
装备我们的 ASCII Armor

Answer 8

该解决方案将 Math.random() 与计数器结合起来。

Math.random() 应该给出大约 53 位的熵（与 UUIDv4 的 128 位相比），但是当与计数器结合使用时，应该为临时 ID 提供足够的唯一性。

let _id_counter = 0
function id() {
  return '_' + (_id_counter++).toString(36) + '_' + Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(36)
}

console.log(Array.from({length: 100}).map(() => id()))

特点：

• 实现简单
• 输出约 13 个字符
• 不区分大小写
• 可以安全地用作 HTML id 和 React key
• 不适合数据库存储

Answer 9

您可以使用 md5 算法生成随机字符串。 md5 是节点包，

 var randomChars = Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 2);
 var shortUrl = md5(originalUrl + randomChars + new Date()).substring(0, 5).toString();
 console.log(shortUrl);

每次都会生成唯一的字符串。

Answer 10

我使用此 TypeScript 函数在数据库中创建比 UUID 更具可读性的唯一标识符。请注意，插入记录时，我捕获重复键异常并使用新 ID 重试。

const idChars: string = 'ABCDEFGHJKMNPQRSTUVWXYZ'

export function generateId(): string {
  const now: Date = new Date()
  let id = now.getUTCFullYear().toString()
  id += now.getUTCMonth().toString().padStart(2, '0')
  id += now.getUTCDay().toString().padStart(2, '0')
  for (let i = 0; i < 6; i++) id += idChars[Math.floor(Math.random() * idChars.length)]
  return id
}

它生成类似 20230506VJDMQD 的 ID。

日期前缀对唯一性有很大帮助，特别是当您在数据库中长期创建数千条记录时。它对于客户编号或发票编号等内容也非常有帮助，其中日期部分提供了附加信息，而不仅仅是唯一性。

可以很容易地将其适应您喜欢的任何字符集，如果您不需要日期前缀，则可以轻松地从代码中删除该部分。

如果您每天需要生成数百万个 ID，那么您可以将循环计数从 6 增加到更大的数字，但在某些时候您也可能只使用 UUID。

如果你真的只想要 6 个字符，那么 JavaScript 中的简化版本是

const idChars = 'ABCDEFGHJKMNPQRSTUVWXYZ'

function generateId() {
  let id = ''
  for (let i = 0; i < 6; i++) id += idChars[Math.floor(Math.random() * idChars.length)]
  return id
}

Answer 11

有关预打包解决方案，请参阅 @Mohamed 的回答（shortid 包）。如果您没有特殊要求，请首选该解决方案，而不是本页上的任何其他解决方案。

---

6 个字符的字母数字序列足以随机索引 10k 集合（36⁶ = 22 亿和 36³ = 46656）。

function generateUID() {
    // I generate the UID from two parts here 
    // to ensure the random number provide enough bits.
    var firstPart = (Math.random() * 46656) | 0;
    var secondPart = (Math.random() * 46656) | 0;
    firstPart = ("000" + firstPart.toString(36)).slice(-3);
    secondPart = ("000" + secondPart.toString(36)).slice(-3);
    return firstPart + secondPart;
}

随机生成的UID在生成~√N个数字后会发生冲突（生日悖论），因此需要6位数字才能安全生成而不进行检查（旧版本仅生成4位数字，如果不检查则在1300个ID后会发生冲突） 。

如果进行碰撞检查，位数可以减少 3 或 4，但请注意，当生成越来越多的 UID 时，性能会线性下降。

var _generatedUIDs = {};
function generateUIDWithCollisionChecking() {
    while (true) {
        var uid = ("0000" + ((Math.random() * Math.pow(36, 4)) | 0).toString(36)).slice(-4);
        if (!_generatedUIDs.hasOwnProperty(uid)) {
            _generatedUIDs[uid] = true;
            return uid;
        }
    }
}

如果您需要唯一性而不是不可预测性，请考虑使用顺序生成器（例如 user134_item1、user134_item2...）。您可以“散列”顺序生成的字符串以恢复不可预测性。

使用 Math.random 生成的 UID 并不安全（无论如何您都不应该信任客户端）。在关键任务中不要依赖其独特性或不可预测性。

Answer 12

08/2020 更新：

shortid 已被弃用，取而代之的是更小的 nanoid更快：

• 小。 108 字节（缩小并压缩）。没有依赖性。大小限制控制大小。
• 快。它比 UUID 快 40%。
• 安全。它使用加密的强随机 API。可以在集群中使用。
• 紧凑。它使用比 UUID (A-Za-z0-9_-) 更大的字母表。因此 ID 大小从 36 个符号减少到 21 个符号。
• 便携式。 Nano ID 已移植到 14 种编程语言。

import { nanoid } from 'nanoid'

// 21 characters (default)
// ~149 billion years needed, in order to have a 1% probability of at least one collision.
console.log(nanoid()) //=> "V1StGXR8_Z5jdHi6B-myT"

// 11 characters
// ~139 years needed, in order to have a 1% probability of at least one collision.
console.log(nanoid(11)) //=> "bdkjNOkq9PO"

更多信息请参见：https://zelark.github.io/nano-id-cc/

---

旧答案

还有一个很棒的npm包：shortid

非常短的非连续 URL 友好的唯一 ID 生成器。

ShortId 创建令人惊讶的短非连续 url 友好的唯一 ID。非常适合 url 缩短器、MongoDB 和 Redis id，以及用户可能看到的任何其他 id。

• 默认为 7-14 个网址友好字符：AZ、az、0-9、_-
• 非连续性，因此不可预测。
• 支持集群（自动）、自定义种子、自定义字母表。
• 可以生成任意数量且不重复的 ID，甚至每天数百万个。
• 非常适合游戏，特别是如果您担心作弊，因此不想使用容易被猜到的 ID。
• 应用可以重新启动任意次数，而不会出现重复 ID 的情况。
• Mongo ID/Mongoose ID 的热门替代品。
• 适用于 Node、io.js 和网络浏览器。
• 包括 Mocha 测试。

用法

var shortid = require('shortid');
console.log(shortid.generate()); //PPBqWA9

Answer 13

这是一个单行，但它只给出小写字母和数字：

var uuid = Math.random().toString(36).slice(-6);

console.log(uuid);