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

Question

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

我想为我的 uids (guids) 提供类似“aX4j9Z”的东西。

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

Answer 1

有关预打包的解决方案（shortid package），请参阅 @Mohamed's answer。如果您没有特殊要求，请优先使用此页面而不是此页面上的任何其他解决方案。

---

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 2

2020 年 8 月更新：

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

• 小。 108 字节（压缩和压缩）。没有依赖关系。 Size Limit 控制大小。
• 快速。它比 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 个 url 友好字符：A-Z、a-z、0-9、_-
• 不连续，因此不可预测。
• 支持集群（自动）、自定义种子、自定义字母表。
• 可以生成任意数量的不重复的 ID，甚至每天数百万。
• 非常适合游戏，尤其是如果您担心作弊，因此您不想要一个容易猜到的 ID。
• 应用程序可以重新启动任意次数，没有任何重复 id 的机会。
• Mongo ID/Mongoose ID 的流行替代品。
• 适用于 Node、io.js 和 Web 浏览器。
• 包括 Mocha 测试。

用法

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

Answer 3

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

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

console.log(uuid);

Answer 4

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

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

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

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

Answer 5

以下生成 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 6

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 7

这将生成一系列唯一值。它通过在用尽所有值时增加字符串长度来改进 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());
}

This gist 包含上述实现和递归版本。

Answer 8

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

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 9

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

Jeff Atwood 多年前曾在博客中提到过：
Equipping our ASCII Armor

Answer 10

您可以使用 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 11

此解决方案将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
• 不适合数据库存储