在JavaScript中生成随机字符串/字符

Question

我想要一个5个字符的字符串，由从集合中随机选择的字符组成[a-zA-Z0-9].

使用JavaScript实现这一点的最佳方法是什么？

Answer 1

我认为这对你很有用：

函数makeid（长度）{让结果=“”；const characters=“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789”；const charactersLength=characters.length；让计数器=0；while（计数器<长度）{结果+=characters.charAt（Math.floor（Math.random（）*charactersLength））；计数器+=1；}返回结果；}console.log（makeid（5））；

Answer 2

//可以将7更改为2以获得更长的结果。设r=（Math.random（）+1）.toString（36）.substring（7）；console.log（“随机”，r）；

注：上述算法存在以下缺点：

• 它将生成0到6个字符之间的任意字符，这是因为字符串化浮点时去掉了尾随的零。
• 它在很大程度上依赖于用于字符串化浮点数的算法，这非常复杂。（见论文“如何准确打印浮点数字”.)
• 数学随机数（）根据实现，可能会产生可预测的（“随机”，但不是真正随机的）输出。当需要保证唯一性或不可预测性时，结果字符串不适用。
• 即使它生成了6个统一的随机、不可预测的字符，由于生日悖论.（平方码（36^6）=46656）

Answer 3

数学.随机对这种事情不好

服务器端

使用节点加密模块-

var crypto=require（“crypto”）；var id=crypto.randomBytes（20）.toString（'hex'）；//“bb5dc8842ca31d4603d6aa11448d1654”

结果字符串的长度将是您生成的随机字节的两倍；编码为十六进制的每个字节是2个字符。20个字节将是40个十六进制字符。

---

客户端

使用浏览器的加密模块-

const id=window.crypto.randomUUID（）console.log（id）//bd4d099b-3d39-4aad-a59c-c45dfac8eaf0

或者加密.get随机值-

这个crypto.getRandomValues（）方法可以获得加密的强随机值。作为参数给出的数组由随机数填充（密码意义上的随机数）。

//dec2hex:：Integer->字符串//即0-255->'00'-'f'功能dec2hex（dec）{return dec.toString（16）.padStart（2，“0”）}//generateId:：Integer->字符串函数生成器ID（len）{var arr=新的Uint8数组（（len||40）/2）window.crypto.getRandomValues（arr）return Array.from（arr，dec2hex）.join（“”）}console.log（generateId（））//“82defcf324571e70b0521d79cce2bf3fffccd69”console.log（生成ID（20））//“c1a050a4cd1556948d41”

分步控制台示例-

>var arr=new Uint8Array（4）#make 4字节数组（值0-255）>阿珥Uint8Array（4）[0，0，0，0]>窗口.加密加密{精细：精细加密}>window.crypto.getRandomValues（）TypeError:Crypto.getRandomValues需要至少1个参数，但只传递了0个>window.crypto.getRandomValues（arr）Uint8Array（4）[235、229、94、228]

对于IE11支持，您可以使用-

（window.crypto ||window.msCrypto）.getRandomValues（arr）

有关浏览器覆盖范围，请参阅https://caniuse.com/#feat=getrandomvalues

---

客户端（旧浏览器）

如果必须支持旧浏览器，请考虑以下内容乌伊德-

const uuid=要求（“uuid”）；常量id=uuid.v4（）；//“110ec58a-a0f2-4ac4-8393-c866d813b8d1”

Answer 4

简短、简单、可靠

只返回5个随机字符，而不是此处的一些排名靠前的答案。

Math.random（）.toString（36）.slice（2,7）；

Answer 5

以下是对的改进doubletap的最佳答案。原始版本有两个缺点，现予说明：

首先，正如其他人所提到的那样，它产生短字符串甚至空字符串的可能性很小（如果随机数为0），这可能会中断您的应用程序。这里有一个解决方案：

（Math.random（）.toString（36）+00000000000000000'）.slice（2，N+2）

其次，原始和上述解决方案都将字符串大小N限制为16个字符。以下将为任何N返回大小为N的字符串（但请注意，使用N>16不会增加随机性或降低碰撞概率）：

数组（N+1）.join（（Math.random（）.toString（36）+'00000000000000'）.slice（2，18））.slic（0，N）

说明：

1. 选择[0,1）范围内的一个随机数，即介于0（包含）和1（不包含）之间。
2. 将数字转换为以36为基数的字符串，即使用字符0-9和a-z。
3. 用零填充（解决第一个问题）。
4. 切掉前导的“0.”前缀和额外的填充零。
5. 重复字符串足够多次，使其至少包含N个字符（通过将空字符串与用作分隔符的较短随机字符串连接）。
6. 从字符串中精确切分N个字符。

进一步思考：

• 这个解决方案不使用大写字母，但在几乎所有情况下（没有双关语），这并不重要。
• 原始答案中N=16时的最大字符串长度是用Chrome测量的。在Firefox中是N=11。但如前所述，第二种解决方案是支持任何请求的字符串长度，而不是增加随机性，因此没有太大区别。
• 至少在Math.random（）返回的结果均匀分布的情况下，所有返回的字符串返回的概率相等（在任何情况下，这都不是加密强度随机性）。
• 不能返回所有可能的大小为N的字符串。在第二种解决方案中，这是显而易见的（因为较小的字符串只是被复制），但在原始答案中也是如此，因为在转换为base-36的过程中，最后几位可能不是原始随机位的一部分。具体来说，如果您查看Math.random（）.toString（36）的结果，您会注意到最后一个字符并不是均匀分布的。同样，在几乎所有情况下，这都无关紧要，但我们从随机字符串的开头而不是末尾切割最后一个字符串，这样短字符串（例如N=1）就不会受到影响。

更新：

下面是我想出的几个其他功能风格的单句。它们与上述解决方案的不同之处在于：

• 他们使用明确的任意字母表（更通用，适用于要求大写字母和小写字母的原始问题）。
• 所有长度为N的字符串返回的概率相等（即字符串不包含重复）。
• 它们基于一个map函数，而不是toString（36）技巧，这使得它们更加简单易懂。

那么，假设你选择的字母表是

var s=“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”；

然后这两者是等价的，所以您可以选择对您更直观的：

数组（N）.join（）.split（'，'）.map（function（）{returns s.charAt（Math.floor（Math.random（）*s.length））；}）.jjoin（''）；

和

Array.apply（null，Array（N））.map（function（）{returns s.charAt（Math.floor（Math.random（）*s.length））；}）.join（''）；

编辑：

我看起来像量子字节和玛丽亚诺提出了与后者类似的解决方案（荣誉！），但我不知怎么错过了。因为它们看起来一眼就不那么短，所以我还是把它留在这里，以防有人真的想要一句单句：-）

此外，在所有解决方案中，将“new Array”替换为“Array”，以节省更多字节。

Answer 6

最紧凑的解决方案，因为片短于子串。从字符串末尾减法可以避免由随机的，随机的功能：

Math.random（）.toString（36）.slice（-5）；

甚至是

（+new Date）.toString（36）.slice（-5）；

更新：添加了另一种方法，使用英国电信运营商协会方法：

btoa（Math.random（））.slice（0,5）；btoa（+新日期）。切片（-7，-2）；btoa（+新日期）.substr（-7,5）；

//使用Math.random和Base 36：console.log（Math.random（）.toString（36）.slice（-5））；//使用新的日期和基准36：console.log（（+new Date）.toString（36）.slice（-5））；//使用Math.random和Base 64（btoa）：console.log（btoa（Math.random（））.slice（0,5））；//使用新的日期和基数64（btoa）：console.log（btoa（+new Date）.slice（-7，-2））；console.log（btoa（+new Date）.substr（-7,5））；

Answer 7

具有的较新版本电子系统6 扩散算子:

[…数组（30）].map（（）=>Math.random（）.toString（36）[2]）.join（''）

• 这个30是一个任意数字，您可以选择所需的任何令牌长度
• 这个36是可以传递给的最大基数numerical.toString（），这意味着所有数字和a-z小写字母
• 这个2用于从如下所示的随机字符串中选择第三个索引：“0.mfbiohx64i”，我们可以在之后获取任何索引0

Answer 8

这样应该行得通

函数randomString（len，charSet）{charSet=charSet ||'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'；var randomString=“”；对于（var i=0；i<len；i++）{var randomPoz=数学.floor（Math.random（）*charSet.length）；randomString+=charSet.substring（randomPoz，randomPoz+1）；}return randomString；}

使用默认字符集[a-zA-Z0-9]调用或发送您自己的：

var randomValue=randomString（5）；var randomValue=randomString（5，'PICKCHARSFROMTHISSET'）；

Answer 9

函数randomstring（L）{var s=“”；var randomchar=函数（）{var n=数学地板（Math.random（）*62）；如果（n<10），则返回n//1-10如果（n<36）返回String.fromCharCode（n+55）//A-Z（A-Z）从CharCode返回String.（n+61）//a-z型}而（s.length<L）s+=randomchar（）；返回s；}console.log（randomstring（5））；

Answer 10

随机字符串生成器（Alpha-Numeric|Alpha|Numeric）

/***伪随机字符串生成器* http://stackoverflow.com/a/27872144/383904*默认值：返回随机字母数字字符串* *@param{Integer}len所需长度*@param｛String｝an可选（字母数字）、“a”（字母）、“n”（数字）*@return{String}*/函数randomString（len，an）{an=一个&&an.toLowerCase（）；var str=“”，i=0，min=an==“a”？10:0，max=an==“n”？10 : 62;对于（；i++<len；）{var r=数学随机数（）*（max-min）+min<<0；str+=String.fromCharCode（r+=r>9？r<36？55:61:48）；}返回str；}console.log（randomString（10））；//即：“4Z8iNQag9v”console.log（randomString（10，“a”））；//即：“aUkZuHNcWw”console.log（randomString（10，“n”））；//即：“9055739230”

---

虽然上述使用额外的检查A/N、A、N输出，为了更好地理解，让我们将其分解为要点（仅限字母-数字）：

• 创建一个接受参数的函数（随机String结果所需的长度）
• 创建一个空字符串，如var str=“”；连接随机字符
• 在循环内部创建兰特索引编号从0到61（0..9+A..Z+A..Z=62）
• 创建一个条件逻辑到调整/修复兰特（因为它是0..61）将其增加一些数字（参见下面的示例）以返回正确值字符码数字和相关字符。
• 在循环内部连接到字符串一字符串.fromCharCode（递增rand）

让我们想象一下ASCII字符表范围：

_____0….9 ______ A……….Z ______ A…….Z ___________字符|10||26||26|总计=62个字符48….57 65…….90 97…….122字符代码范围

数学地板（数学随机*62）给出的范围为0..61（我们需要什么）。
让我们修正随机数以获得正确值charCode范围:

|rand | charCode |（0..61）rand+=fix=charCode范围|------+----------+----------+--------------------------------+-----------------+0..9|0..9|48..57|rand+=48=48..57|A..Z|10..35|65..90|兰特+=55/*90-35=55*/=65..90|a..z|36..61|97..122|rand+=61/*122-61=61*/=97..122|

这个有条件操作逻辑从上表中可以看出：

兰德+=兰德>9？（兰特<36？55:61）:48；//rand+=真？（对吗？其他55人61人）其他48人；

根据上面的解释，结果如下字母数字片段:

函数randomString（len）{var str=“”；//字符串结果for（var i=0；i<len；i++）{//循环`len`次var rand=数学地板（Math.random（）*62）；//随机：0..61var charCode=rand+=rand>9？（兰特<36？55:61）:48；//获取正确的charCodestr+=字符串.fromCharCode（charCode）；//将字符添加到str}return str；//完成所有循环后，返回连接的字符串}console.log（randomString（10））；//即：“7GL9F0ne6t”

或者如果您愿意：

const randomString=（n，r=“”）=>{而（n-）r+=String.fromCharCode（（r=Math.random（）*62|0，r+=r>9？（r<36？55:61）:48）；返回r；};console.log（randomString（10））

Answer 11

要满足要求[a-zA-Z0-9]和5个字符的长度，请使用

对于浏览器:

btoa（Math.random（）.toString（））.substring（10,15）；

对于节点JS:

缓冲区.from（Math.random（）.toString（））.toString（“base64”）.substring（10,15）；

将出现小写字母、大写字母和数字。

（它与打字兼容）

Answer 12

最简单的方法是：

（新日期%9e6）.toString（36）

这将根据当前时间生成5个字符的随机字符串。输出示例为400万吨/年或4毫伏90或4兆瓦1

这方面的问题是，如果在同一秒调用它两次，它将生成相同的字符串。

更安全的方法是：

（0|Math.random（）*9e6）.toString（36）

这将生成一个4或5个字符的随机字符串，始终不同。示例输出如下30日圆或第1轮591或4su1a型

在这两种方式中，第一部分生成一个随机数。这个.toString（36）部分将数字转换为以36为基数（字母十进制）的表示形式。

Answer 13

这里有一些简单的单句。更改新建数组（5）设置长度。

包括0-9a-z

new数组（5）.join（）.replace（/（.|$）/g，function（）{return（（Math.random（）*36）|0）.toString（36）；}）

其中0-9a-zA-Z

new Array（5）.join（）.replace（/（.|$）/g，function（）{return（（Math.random（）*36）|0）.toString（36）[Math.rendom（）<.5？“toString”：“toUpperCase”]（）；}）；

用于ES6的Codegolfed(0-9a-z)

数组（5）.fill（）.map（n=>（Math.random（）*36|0）.toString（36））.join（''）

Answer 14

有没有最好的方法这样做。只要结果符合您的要求，您可以按自己喜欢的方式进行。为了说明，我创建了许多不同的示例，所有这些示例都应该提供相同的最终结果

本页上的大多数其他答案都忽略了大写字母的要求。

这是我的最快的解决方案和可读性最强它基本上与公认的解决方案相同，只是速度稍快一些。

函数readableRandomStringMaker（长度）{for（var s=''；s.length＜length；s+='abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'.charAt（Math.random（）*62|0））；返回s；}console.log（readableRandomStringMaker（长度））；//电子3cbN

这里有一个紧凑，递归可读性差得多的版本：

const compactRandomStringMaker=（length）=>length--&&“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”.charAt（Math.random（）*62|0）+（compactRandomStringMaker（length||“”）；console.log（compactRandomStringMaker（5））；//DVudj公司

A类更紧凑的一个衬垫:

数组（5）.fill（）.map（（）=>“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”.charAt（Math.random（）*62））.join（“”）//东经12度

上述变化：

“”“.replaceAll（”“，（）=>”abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789“.charAt（Math.random（）*62））

这个最紧凑的一行，但效率低且不可读-它添加随机字符并删除非法字符，直到长度为我:

（（l，f=（p=''）=>p.长度<l？f（p+String.fromCharCode（Math.random（）*123）.replace（/[^a-z0-9]/i，''））：p）=>f（））（5）

A类加密安全版本，这是为了紧凑而浪费熵，而且不管怎样都是浪费，因为生成的字符串太短了：

[…crypto.getRandomValues（new Uint8Array（999））].map（（c）=>String.fromCharCode（c）.replace（/[^a-z0-9]/i，''））.join（“”）.substr（0,5）//8平方英尺

或者，如果没有长度参数，它甚至更短：

（f=（p=“”）=>p.长度<5？f（p+String.fromCharCode（Math.random（）*123）.replace（/[^a-z0-9]/i，''））：p）=>f（））（）//电动汽车6c9

然后更具挑战性-使用无名递归箭头函数:

（（l，s=（（l）=>l--&&“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”.charAt（数学随机数（）*62|0）+（s（l）||“”））=>s（1））（5）；//qzal4号机组

这是一个“魔术”变量它在每次访问时提供随机字符：

const c=新类{[Symbol.toPrimitive]（）{return“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”.charAt（Math.random（）*62|0）}}；console.log（c+c+c~+c+c）；//AgMnz公司

上述的简单变体：

const c=（）=>“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”.charAt（数学.random（）*62|0）；c（）+c（）+c（）+c（）+c（）；//6卡德夫

Answer 15

我知道每个人都已经做对了，但我想尝试以最轻量级的方式（轻量级的代码，而不是CPU）：

函数rand（长度，电流）{电流=电流？当前：“”；返回长度？rand（--长度，“0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz”.charAt（数学地板（数学.random（）*60））+当前）：当前；}控制台.log（rand（5））；

这需要一点时间来让你回过头来，但我认为这确实说明了javascript的语法有多棒。

Answer 16

生成安全的随机字母数字底座62字符串：

函数生成器UID（长度）{return window.btoa（String.fromCharCode（…window.crypto.getRandomValues（new Uint8Array（length*2）））.replace（/[+/]/g，“”）.substring（0，length）；}console.log（生成UID（22））；//“yFg3以上v2cE9cKOXd7hHwWp”console.log（生成UID（5））；//“YQGzP”

Answer 17

如果有人对一次性分配内存的一行程序感兴趣（尽管为了方便起见没有这样的格式）（但请注意，对于小字符串，这确实无关紧要），下面是如何实现的：

Array.apply（0，Array（5））.map（function（））{return（函数（字符集）{return charset.charAt（数学地板（Math.random（）*charset.length））}（'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'）；}).join（“”）

您可以替换5根据所需字符串的长度。感谢@AriyaHidayat这个帖子对于地图函数无法处理由创建的稀疏数组阵列（5）.

Answer 18

如果您正在使用洛达什或强调:

var randomVal=_.sample（'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'，5）.join（''）；

Answer 19

const c='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'const s=[…数组（5）].map（_=>c[~~（Math.random（）*c.length）]）.join（''）

Answer 20

虽然这个答案与其他答案几乎相似，但不同之处在于它使用了：

• 重复创建5个字符（可以概括为n个)
• 代替带正则表达式/./克替换这5个字符
• 公式是从62个字符的a-Za-z0-9字符串中随机选取一个字符

设ans=“x”。重复（5）.替换（/./g，c=>“abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”[数学地板（Math.random（）*62）]）；控制台.log（ans）；

Answer 21

这是我创建的方法。
它将创建一个包含大写和小写字符的字符串。
此外，我还包含了创建字母数字字符串的函数。

工作示例：
http://jsfiddle.net/greatbigmassive/vhsxs/（仅阿尔法）
http://jsfiddle.net/greatbigmassive/PJwg8/（字母数字）

函数randString（x）{var s=“”；while（s.length<x&&x>0）{var r=数学随机数（）；s+=字符代码中的字符串（数学地板（r*26）+（r>0.5？97:65））；}返回s；}

2015年7月升级
这是同样的事情，但更有意义，包括所有字母。

var s=“”；while（s.length<x&&x>0）{v=数学随机数（）<0.5？32:0;s+=String.fromCharCode（数学.round（Math.random（）*（（122-v）-（97-v））+（97-v））；}

Answer 22

一个衬垫：

数组（15）.fill（null）.map（（）=>Math.random（）.toString（36）.substr（2））.join（“”）//输出：0h61cbpw96y83qtnuwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil

Answer 23

改进了@Andrew上面的回答：

数组.from（{length:1}，（）=>Math.random（）.toString（36）[2]）.join（''）；

以36为基数的随机数转换是不一致的，所以选择一个索引可以修复这个问题。您可以使用所需的精确长度更改字符串的长度。

Answer 24

假设您使用内衣只需两行就可以优雅地生成随机字符串：

var possible=“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789”；var random=_.sample（可能，5）.join（''）；

Answer 25

函数randomString（strLength，charSet）{var结果=[]；strLength=strLength||5；charSet=charSet ||'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'；while（strLength--）{//（注意，修复了输入错误）result.push（charSet.charAt（Math.floor（Math.random（）*charSet.length））；}return result.join（“”）；}

这是最干净的。它也很快，http://jsperf.com/ay-random-string.

Answer 26

快速改进的算法。不保证统一（见注释）。

函数getRandomId（长度）{if（！长度）{返回“”；}常量可能='EFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvxyz0123456789'；let数组；if（self中的'Uint8Array'和self&&length中的'crypto'<=65536）{array=新Uint8Array（长度）；self.crypto.getRandomValues（数组）；}其他{array=新数组（长度）；for（设i=0；i<长度；i++）{array[i]=数学地板（Math.random（）*62）；}}让结果=“”；for（设i=0；i<长度；i++）{result+=可能。charAt（array[i]%62）；}返回结果；}

Answer 27

这个小技巧怎么样？

var possible=“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnomqrstuvxyz0123456789”；var字符串长度=5；函数pickRandom（）{return possible[Math.floor（Math.random（）*possible.length）]；}var randomString=Array.apply（null，Array（stringLength））.map（pickRandom）.jjoin（''）；

你需要阵列应用这样可以将空数组变为未定义数组。

如果您正在为ES2015编码，那么构建阵列要简单一些：

var randomString=Array.from（{length:stringLength}，pickRandom）.join（''）；

Answer 28

您可以循环遍历项目数组，并将其递归添加到字符串变量中，例如，如果您想要一个随机DNA序列：

函数randomDNA（len）{len=长度||100var nuc=新数组（“A”、“T”、“C”、“G”）var i=0var n=0s=“”while（i<=len-1）{n=数学地板（Math.random（）*4）s+=nuc[n]我++}返回s}console.log（randomDNA（5））；

Answer 29

不区分大小写的字母数字字符：

函数randStr（len）{设s=''；while（s.length<len）s+=Math.random（）.toString（36）.substr（2，len-s.length）；返回s；}//使用console.log（randStr（50））；

此函数的优点是可以获得不同长度的随机字符串，并确保字符串的长度。

区分大小写的所有字符：

函数randStr（len）{设s=''；while（len--）s+=String.fromCodePoint（Math.floor（Math.random（）*（126-33）+33））；返回s；}//用法console.log（randStr（50））；

自定义字符

函数randStr（len，chars='abc123'）{设s=''；while（len--）s+=chars[Math.floor（Math.random（）*chars.length）]；返回s；}//使用console.log（randStr（50））；控制台.log（randStr（50，'abc'））；console.log（randStr（50，'aab'））；//a多于b

Answer 30

回应的问题“我需要随机字符串”问题（无论用什么语言）实际上每个解决方案都使用有缺陷的主要规范字符串长度这些问题本身很少揭示为什么需要随机字符串，但我想挑战一下，你很少需要长度为8的随机字符串。你总是需要一些唯一字符串例如，出于某种目的用作标识符。

有两种主要方法可以获得严格唯一字符串：确定性（非随机）和存储/比较（繁重）。我们该怎么办？我们放弃了鬼魂。我们一起去概率唯一性而不是。也就是说，我们接受字符串不唯一的风险（无论多么小）。这就是理解碰撞概率和熵都很有帮助。

因此，我将把不变的需求重新表述为需要一些数量的字符串，重复的风险很小。作为一个具体的例子，假设您希望生成500万个ID。您不想存储和比较每个新字符串，并且希望它们是随机的，因此您会承担一些重复的风险。例如，让我们假设重复的风险不到万亿分之一。那么你需要多长的绳子？嗯，这个问题没有具体说明，因为它取决于使用的字符。但更重要的是，它被误导了。您需要的是字符串熵的规范，而不是字符串长度的规范。熵可以直接与某些字符串中重复的概率相关。字符串长度不能。

这就是图书馆喜欢的地方条目字符串可以提供帮助。要生成在500万个字符串中重复的概率小于万亿分之一的随机ID，请使用熵弦:

从“Entropy-string”导入{Random，Entropy}const random=新随机（）常量位=熵位（5e6，1e12）const字符串=random.string（位）

“44hTNghjNHGGRHqH9”

熵弦默认情况下使用32个字符的字符集。还有其他预定义的字符集，您也可以指定自己的字符。例如，生成具有与上述相同熵但使用十六进制字符的ID：

从'导入{Random、Entropy、charSet16}/熵弦const random=新随机（charSet16）常量位=熵位（5e6，1e12）const字符串=random.string（位）

“27b33372ade513715481f”

注意字符串长度的差异是由于所使用的字符集中的字符总数的差异造成的。在指定数量的潜在字符串中重复的风险是相同的。字符串长度不是。最重要的是，重复的风险和字符串的潜在数量是明确的。不再猜测字符串长度。