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

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

用JavaScript做这件事的最好方法是什么？

2473103 次浏览
小开
最佳答案

我认为这将为你工作：

function makeid(length) {var result           = '';var characters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';var charactersLength = characters.length;for ( var i = 0; i < length; i++ ) {result += characters.charAt(Math.floor(Math.random() * charactersLength));}return result;}
console.log(makeid(5));

小开

这样的东西应该有用

function randomString(len, charSet) {charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';var randomString = '';for (var i = 0; i < len; i++) {var randomPoz = Math.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');
小开 

function randomstring(L) {var s = '';var randomchar = function() {var n = Math.floor(Math.random() * 62);if (n < 10) return n; //1-10if (n < 36) return String.fromCharCode(n + 55); //A-Zreturn String.fromCharCode(n + 61); //a-z}while (s.length < L) s += randomchar();return s;}console.log(randomstring(5));

小开

这肯定管用

<script language="javascript" type="text/javascript">function randomString() {var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";var string_length = 8;var randomstring = '';for (var i=0; i<string_length; i++) {var rnum = Math.floor(Math.random() * chars.length);randomstring += chars.substring(rnum,rnum+1);}document.randform.randomfield.value = randomstring;}</script>
小开

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

function rand(length, current) {current = current ? current : '';return length ? rand(--length, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz".charAt(Math.floor(Math.random() * 60)) + current) : current;}
console.log(rand(5));

这需要一点时间来理解，但我认为它确实显示了javascript的语法有多棒。

小开 

//Can change 7 to 2 for longer results.let r = (Math.random() + 1).toString(36).substring(7);console.log("random", r);

注意：上述算法有以下弱点：

  • 它将生成0到6个字符之间的任何位置，因为在字符串化浮点时会删除尾随零。
  • 它在很大程度上取决于用于对浮点数进行字符串化的算法，这是非常复杂的。
  • 根据实现，Math.random()可能会产生可预测的（“看起来随机”但不是真正随机）输出。当您需要保证唯一性或不可预测性时，生成的字符串不适合。
  • 即使它产生了6个均匀随机的、不可预测的字符，由于生日悖论，您也可以期望在生成大约50,000个字符串后看到重复的字符。（sqrt（36^6）=46656）
小开

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

function randomDNA(len) {len = len || 100var nuc = new Array("A", "T", "C", "G")var i = 0var n = 0s = ''while (i <= len - 1) {n = Math.floor(Math.random() * 4)s += nuc[n]i++}return s}
console.log(randomDNA(5));

小开 
function randomString (strLength, charSet) {var result = [];    
strLength = strLength || 5;charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';    
while (strLength--) { // (note, fixed typo)result.push(charSet.charAt(Math.floor(Math.random() * charSet.length)));}    
return result.join('');}

这就像它会得到的一样干净。它也很快，http://jsperf.com/ay-random-string。

小开

生成10个字符长的字符串。长度由参数设置（默认10）。

function random_string_generator(len) {var len = len || 10;var str = '';var i = 0;
for(i=0; i<len; i++) {switch(Math.floor(Math.random()*3+1)) {case 1: // digitstr += (Math.floor(Math.random()*9)).toString();break;
case 2: // small letterstr += String.fromCharCode(Math.floor(Math.random()*26) + 97); //'a'.charCodeAt(0));break;
case 3: // big letterstr += String.fromCharCode(Math.floor(Math.random()*26) + 65); //'A'.charCodeAt(0));break;
default:break;}}return str;}
小开

如果有人对一次分配内存的单行代码（尽管为了方便起见没有格式化）感兴趣（但请注意，对于小字符串来说，这真的无关紧要），这里是如何做到的：

Array.apply(0, Array(5)).map(function() {return (function(charset){return charset.charAt(Math.floor(Math.random() * charset.length))}('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'));}).join('')

您可以将5替换为所需的字符串长度。感谢这篇文章中的@AriyaHidayat解决了map函数无法在Array(5)创建的稀疏数组上工作的问题。

小开

扩展Doubletap的优雅示例，回答Gertas和dragon提出的问题。只需添加一个这时候循环来测试那些罕见的空情况，并将字符限制为五个。 

function rndStr() {x=Math.random().toString(36).substring(7).substr(0,5);while (x.length!=5){x=Math.random().toString(36).substring(7).substr(0,5);}return x;}

这是一个jsfiddle提醒您结果：http://jsfiddle.net/pLJJ7/

小开 
"12345".split('').map(function(){return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.charAt(Math.floor(62*Math.random()));}).join('');
//or
String.prototype.rand = function() {return this.split('').map(function(){return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.charAt(Math.floor(62*Math.random()));}).join('');};

将生成一个随机的字母数字字符串，长度为第一个/调用字符串

小开

同样基于doubletap的答案，这个处理任意长度的随机所需字符（仅限较低），并不断生成随机数，直到收集到足够的字符。

function randomChars(len) {var chars = '';
while (chars.length < len) {chars += Math.random().toString(36).substring(2);}
// Remove unnecessary additional characters.return chars.substring(0, len);}
小开

这个紧凑的小把戏怎么样？

var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';var stringLength = 5;
function pickRandom() {return possible[Math.floor(Math.random() * possible.length)];}
var randomString = Array.apply(null, Array(stringLength)).map(pickRandom).join('');

您需要Array.apply来欺骗空数组成为未定义数组。

如果您正在为ES2015编码，那么构建数组会简单一些：

var randomString = Array.from({ length: stringLength }, pickRandom).join('');
小开

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

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

function randString(x){var s = "";while(s.length<x&&x>0){var r = Math.random();s+= String.fromCharCode(Math.floor(r*26) + (r>0.5?97:65));}return s;}

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

var s = "";while(s.length<x&&x>0){v = Math.random()<0.5?32:0;s += String.fromCharCode(Math.round(Math.random()*((122-v)-(97-v))+(97-v)));}
小开 
",,,,,".replace(/,/g,function (){return "AzByC0xDwEv9FuGt8HsIrJ7qKpLo6MnNmO5lPkQj4RiShT3gUfVe2WdXcY1bZa".charAt(Math.floor(Math.random()*62))});
小开

这是我使用的。这里是一对组合。我在循环中使用它，它产生的每个ID都是唯一的。它可能不是5个字符，但它保证是唯一的。

var newId ="randomid_" +(Math.random() / +new Date()).toString(36).replace(/[^a-z]+/g, '');
小开

另一种从字符A-Za-z0-9随机化字符串的好方法：

function randomString(length) {if ( length <= 0 ) return "";var getChunk = function(){var i, //index iteratorrand = Math.random()*10e16, //execute random oncebin = rand.toString(2).substr(2,10), //random binary sequencelcase = (rand.toString(36)+"0000000000").substr(0,10), //lower case random stringucase = lcase.toUpperCase(), //upper case random stringa = [lcase,ucase], //position them in an array in index 0 and 1str = ""; //the chunk stringb = rand.toString(2).substr(2,10);for ( i=0; i<10; i++ )str += a[bin[i]][i]; //gets the next character, depends on the bit in the same position as the character - that way it will decide what case to put nextreturn str;},str = ""; //the result stringwhile ( str.length < length  )str += getChunk();str = str.substr(0,length);return str;}
小开

这是对Doubletap的好答案的改进。原始版本有两个缺点，在这里解决：

首先，正如其他人提到的，它产生短字符串甚至空字符串的概率很小（如果随机数为0），这可能会破坏您的应用程序。这是一个解决方案：

(Math.random().toString(36)+'00000000000000000').slice(2, N+2)

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

Array(N+1).join((Math.random().toString(36)+'00000000000000000').slice(2, 18)).slice(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";

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

Array(N).join().split(',').map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');

和

Array.apply(null, Array(N)).map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');

编辑：

我似乎字节和martijndemilliano想出了类似于后者的解决方案（荣誉！），但我不知何故错过了。由于它们乍一看并不那么短，我还是把它留在这里，以防有人真的想要一行代码：-）

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

小开

如果库是一种可能性，Chance.js可能会有所帮助：http://chancejs.com/#string

小开

这将在变量c中存储5个字母数字字符。

for(var c = ''; c.length < 5;) c += Math.random().toString(36).substr(2, 1)
小开

这里有一些简单的单行线。更改new Array(5)以设置长度。

包括0-9a-z

new Array(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.random()<.5?"toString":"toUpperCase"]();});

适用于ES6（0-9a-z）

Array(5).fill().map(n=>(Math.random()*36|0).toString(36)).join('')
小开

这是#1答案的测试脚本（谢谢@csharptest.net）

这个脚本运行了makeid()1 million次，正如你所看到的，5不是一个非常独特的脚本。以10的字符长度运行它是相当可靠的。我已经运行了大约50次，还没有看到重复的:-)

注意：节点堆栈大小限制超过400万左右，因此您无法运行此500万次，它永远不会完成。

function makeid(){var text = "";var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
for( var i=0; i < 5; i++ )text += possible.charAt(Math.floor(Math.random() * possible.length));
return text;}
ids ={}count = 0for (var i = 0; i < 1000000; i++) {tempId = makeid();if (typeof ids[tempId] !== 'undefined') {ids[tempId]++;if (ids[tempId] === 2) {count ++;}count++;}else{ids[tempId] = 1;}}console.log("there are "+count+ ' duplicate ids');
小开

下面是CoffeeScript中的一个例子：

String::add_Random_Letters   = (size )->charSet = 'abcdefghijklmnopqrstuvwxyz'@ + (charSet[Math.floor(Math.random() * charSet.length)]  for i in [1..size]).join('')

可用于

value = "abc_"value_with_exta_5_random_letters = value.add_Random_Letters(5)
小开

我喜欢doubletap的Math.random（）. toString（36）. substring（7）答案的精彩，但并不是因为它有那么多的碰撞，正如hacklikecack正确指出的那样。它生成了11个字符的字符串，但在100万的样本量中重复率为11%。

这是一个更长（但仍然很短）和更慢的替代方案，在100万的样本空间中只有133个重复项。在极少数情况下，字符串仍然会短于11个字符：

Math.abs(Math.random().toString().split('').reduce(function(p,c){return (p<<5)-p+c})).toString(36).substr(0,11);
小开

Math.random对这种东西不好

备选案文1

如果你能做到这一点服务器侧，只需使用加密模块-

var crypto = require("crypto");var id = crypto.randomBytes(20).toString('hex');
// "bb5dc8842ca31d4603d6aa11448d1654"

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

备选案文2

如果您必须执行此客户端端，也许可以尝试uuid模块-

var uuid = require("uuid");var id = uuid.v4();
// "110ec58a-a0f2-4ac4-8393-c866d813b8d1"

备选案文3

如果你必须这样做客户端端，并且你不必支持旧的浏览器，你可以在没有依赖的情况下做到这一点-

// dec2hex :: Integer -> String// i.e. 0-255 -> '00'-'ff'function dec2hex (dec) {return dec.toString(16).padStart(2, "0")}
// generateId :: Integer -> Stringfunction generateId (len) {var arr = new Uint8Array((len || 40) / 2)window.crypto.getRandomValues(arr)return Array.from(arr, dec2hex).join('')}
console.log(generateId())// "82defcf324571e70b0521d79cce2bf3fffccd69"
console.log(generateId(20))// "c1a050a4cd1556948d41"

更多信息#0-

crypto.getRandomValues()方法可让您获得加密强随机值。作为参数给出的数组由随机数填充（在其加密含义中是随机的）。

这是一个小小的控制台示例-

> var arr = new Uint8Array(4) # make array of 4 bytes (values 0-255)> arrUint8Array(4) [ 0, 0, 0, 0 ]
> window.cryptoCrypto { subtle: SubtleCrypto }
> window.crypto.getRandomValues()TypeError: Crypto.getRandomValues requires at least 1 argument, but only 0 were passed
> window.crypto.getRandomValues(arr)Uint8Array(4) [ 235, 229, 94, 228 ]

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

(window.crypto || window.msCrypto).getRandomValues(arr)

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

小开

这是Firefox Chrome代码（插件等）

它可以节省您几个小时的研究时间。

function randomBytes( amount ){let bytes = Cc[ '@mozilla.org/security/random-generator;1' ]
.getService         ( Ci.nsIRandomGenerator ).generateRandomBytes( amount, ''            )
return bytes.reduce( bytes2Number )

function bytes2Number( previousValue, currentValue, index, array ){return Math.pow( 256, index ) * currentValue + previousValue}}

使用它作为：

let   strlen   = 5, radix    = 36, filename = randomBytes( strlen ).toString( radix ).splice( - strlen )
小开

随机字符串生成器（α-数字|α|数字）

/*** Pseudo-random string generator* http://stackoverflow.com/a/27872144/383904* Default: return a random alpha-numeric string** @param {Integer} len Desired length* @param {String} an Optional (alphanumeric), "a" (alpha), "n" (numeric)* @return {String}*/function randomString(len, an) {an = an && an.toLowerCase();var str = "",i = 0,min = an == "a" ? 10 : 0,max = an == "n" ? 10 : 62;for (; i++ < len;) {var r = Math.random() * (max - min) + min << 0;str += String.fromCharCode(r += r > 9 ? r < 36 ? 55 : 61 : 48);}return str;}
console.log(randomString(10));      // i.e: "4Z8iNQag9v"console.log(randomString(10, "a")); // i.e: "aUkZuHNcWw"console.log(randomString(10, "n")); // i.e: "9055739230"

虽然上面对所需的A/N， A， N输出使用了额外的检查，让我们把它分解成基本要素（仅限字母数字），以便更好地理解：

  • 创建一个接受参数的函数（随机String结果的所需长度）
  • 创建像var str = "";这样的空字符串来连接随机字符
  • 在0到61的循环创建#0索引号中（0…9+A… Z+a… z=62）
  • 创建一个条件逻辑到调整/修复#0（因为它是0…61），将其递增一些数字（参见下面的示例）以获得正确的CharCode数字和相关字符。
  • 在循环内部连接到str aString.fromCharCode( incremented rand )

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

_____0....9______A..........Z______a..........z___________  Character| 10 |      |    26    |      |    26    |             Tot = 62 characters48....57    65..........90    97..........122           CharCode ranges

Math.floor( Math.random * 62 )给出了0..61（我们需要的）的范围。
让我们修复随机以获得正确的charCode范围：

      |   rand   | charCode |  (0..61)rand += fix            = charCode ranges |------+----------+----------+--------------------------------+-----------------+0..9  |   0..9   |  48..57  |  rand += 48                    =     48..57      |A..Z  |  10..35  |  65..90  |  rand += 55 /*  90-35 = 55 */  =     65..90      |a..z  |  36..61  |  97..122 |  rand += 61 /* 122-61 = 61 */  =     97..122     |

条件操作逻辑从上表中：

   rand += rand>9 ? ( rand<36 ? 55 : 61 ) : 48 ;// rand +=  true  ? (  true   ? 55 else 61 ) else 48 ;

根据上面的解释，这是结果字母数字片段：

function randomString(len) {var str = "";                                // String resultfor (var i = 0; i < len; i++) {              // Loop `len` timesvar rand = Math.floor(Math.random() * 62); // random: 0..61var charCode = rand += rand > 9 ? (rand < 36 ? 55 : 61) : 48; // Get correct charCodestr += String.fromCharCode(charCode);      // add Character to str}return str; // After all loops are done, return the concatenated string}
console.log(randomString(10)); // i.e: "7GL9F0ne6t"

或者如果你愿意：

const randomString = (n, r='') => {while (n--) r += String.fromCharCode((r=Math.random()*62|0, r+=r>9?(r<36?55:61):48));return r;};
console.log(randomString(10))

小开

最简单的方法是： 

(new Date%9e6).toString(36)

这将根据当前时间生成5个字符的随机字符串。示例输出是4mtxj或4mv90或4mwp1

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

更安全的方法是： 

(0|Math.random()*9e6).toString(36)

这将生成一个包含4或5个字符的随机字符串，始终不同。示例输出如30jzm或1r591或4su1a

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

小开

假设您使用underScorejs，只需两行即可优雅地生成随机字符串：

var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';var random = _.sample(possible, 5).join('');
小开

最紧凑的解决方案，因为#0比#1短。从字符串末尾减去允许避免#2函数生成的浮点符号：

Math.random().toString(36).slice(-5);

甚至

(+new Date).toString(36).slice(-5);

更新时间：使用#0方法添加了一种方法：

btoa(Math.random()).slice(0, 5);btoa(+new Date).slice(-7, -2);btoa(+new Date).substr(-7, 5);

// Using Math.random and Base 36:console.log(Math.random().toString(36).slice(-5));
// Using new Date and Base 36:console.log((+new Date).toString(36).slice(-5));
// Using Math.random and Base 64 (btoa):console.log(btoa(Math.random()).slice(0, 5));
// Using new Date and Base 64 (btoa):console.log(btoa(+new Date).slice(-7, -2));console.log(btoa(+new Date).substr(-7, 5));

小开

将字符作为map函数中的thisArg将创建一个“单行”：

Array.apply(null, Array(5)).map(function(){return this[Math.floor(Math.random()*this.length)];}, "abcdefghijklmnopqrstuvwxyz").join('');
小开

如果您使用的是Lodash或下划线，那么很简单：

var randomVal = _.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5).join('');
小开

这是Coffeescript版本的一行代码

genRandomString = (length,set) -> [0...length].map( -> set.charAt Math.floor(Math.random() * set.length)).join('')

用法： 

genRandomString 5, 'ABCDEFTGHIJKLMNOPQRSTUVWXYZ'

输出：

'FHOOV' # random string of length 5 in possible set A~Z
小开

函数式方法。这个答案只是实用的如果功能先决条件可以在应用程序的其他部分中利用。性能可能是垃圾，但写起来非常有趣。

// functional prerequisitesconst U = f=> f (f)const Y = U (h=> f=> f (x=> h (h) (f) (x)))const comp = f=> g=> x=> f (g (x))const foldk = Y (h=> f=> y=> ([x, ...xs])=>x === undefined ? y : f (y) (x) (y=> h (f) (y) (xs)))const fold = f=> foldk (y=> x=> k=> k (f (y) (x)))const map = f=> fold (y=> x=> [...y, f (x)]) ([])const char = x=> String.fromCharCode(x)const concat = x=> y=> y.concat(x)const concatMap = f=> comp (fold (concat) ([])) (map (f))const irand = x=> Math.floor(Math.random() * x)const sample = xs=> xs [irand (xs.length)]
// range : make a range from x to y; [x...y]// Number -> Number -> [Number]const range = Y (f=> r=> x=> y=>x > y ? r : f ([...r, x]) (x+1) (y)) ([])
// srand : make random string from list or ascii code ranges// [(Range a)] -> Number -> [a]const srand = comp (Y (f=> z=> rs=> x=>x === 0 ? z : f (z + sample (rs)) (rs) (x-1)) ([])) (concatMap (map (char)))
// idGenerator : make an identifier of specified length// Number -> Stringconst idGenerator = srand ([range (48) (57),  // include 0-9range (65) (90),  // include A-Zrange (97) (122)  // include a-z])
console.log (idGenerator (6))  //=> TT688Xconsole.log (idGenerator (10)) //=> SzaaUBlpI1console.log (idGenerator (20)) //=> eYAaWhsfvLDhIBID1xRh

在我看来，如果不添加神奇的、做太多事情的功能，很难击败idGenerator的清晰度。

略有改善可能是

// ord : convert char to ascii code// Char -> Numberconst ord = x => x.charCodeAt(0)
// idGenerator : make an identifier of specified length// Number -> Stringconst idGenerator = srand ([range (ord('0')) (ord('9')),range (ord('A')) (ord('Z')),range (ord('a')) (ord('z'))])

玩得开心。让我知道你喜欢/学什么^_^

小开

简单，简单，可靠

返回5个随机字符，而不是此处找到的一些最受欢迎的答案。

Math.random().toString(36).slice(2, 7);
小开

npm模块anyid提供了灵活的API来生成各种字符串ID/代码。

const id = anyid().encode('Aa0').length(5).random().id();
小开

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

function getRandomId(length) {if (!length) {return '';}
const possible ='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';let array;
if ('Uint8Array' in self && 'crypto' in self && length <= 65536) {array = new Uint8Array(length);self.crypto.getRandomValues(array);} else {array = new Array(length);
for (let i = 0; i < length; i++) {array[i] = Math.floor(Math.random() * 62);}}
let result = '';
for (let i = 0; i < length; i++) {result += possible.charAt(array[i] % 62);}
return result;}
小开

您可以使用coderain。它是一个根据给定模式生成随机代码的库。使用#作为大小写字符和数字的占位符：

var cr = new CodeRain("#####");console.log(cr.next());

还有其他占位符，例如A用于大写字母或9用于数字。

可能有用的是，调用.next()总是会给你一个唯一的结果，所以你不必担心重复。

这是一个生成一个唯一随机代码列表的演示应用程序。

完全披露：我是coderain的作者。

小开

我用var randId = 'rand' + new Date().getTime();

小开

在下面的代码中，我正在为8个字符生成随机代码

function RandomUnique(){var charBank = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012346789";var random= '';var howmanycharacters = 8;for (var i = 0; i < howmanycharacters ; i++) {random+= charBank[parseInt(Math.random() * charBank.lenght)];}return random;}var random = RandomUnique();console.log(random);
小开

试试这个，我每次都用的：

function myFunction() {var hash = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012346789";var random8 = '';for(var i = 0; i < 5; i++){random8 += hash[parseInt(Math.random()*hash.length)];}console.log(random8);document.getElementById("demo").innerHTML = "Your 5 character string ===> "+random8;}
<!DOCTYPE html><html><body>
<p>Click the button to genarate 5 character random string .</p>
<button onclick="myFunction()">Click me</button>
<p id="demo"></p>


</body></html>

小开

非常简单

function getRandomColor(){var color='';while(color.length<6){color=Math.floor(Math.random()*16777215).toString(16);}return '#'+color;}
小开

随机数值（最多16位）

/*** Random numeric value (up to 16 digits)* @returns {String}*/function randomUid () {return String(Math.floor(Math.random() * 9e15))}
// randomUid() -> "3676724552601324"
小开

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

有两种主要方法可以获取严格独特字符串：确定性（不是随机的）和存储/比较（这很麻烦）。我们该怎么办？我们放弃幽灵。我们使用概率唯一性。也就是说，我们接受我们的字符串不唯一的一些风险（无论多小）。这就是理解碰撞概率和熵很有帮助的地方。

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

这就是像EntropyString这样的库可以提供帮助的地方。要使用entropy-string生成在500万字符串中重复概率小于万亿分之一的随机ID：

import {Random, Entropy} from 'entropy-string'
const random = new Random()const bits = Entropy.bits(5e6, 1e12)
const string = random.string(bits)

"44hTNghjNHGGRHqH9"

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

import {Random, Entropy, charSet16} from './entropy-string'
const random = new Random(charSet16)const bits = Entropy.bits(5e6, 1e12)
const string = random.string(bits)

"27 b 33372 a de 513715481 f"

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

小开

这是一个不同的方法，固定长度的基地，没有RegExp替换缺乏（基于@bendytree的答案）；

function rand(base) {// default base 10base = (base >= 2 && base <= 36) ? base : 10;for (var i = 0, ret = []; i < base; i++) {ret[i] = ((Math.random() * base) | 0).toString(base)// include 0-9a-zA-Z?// [Math.random() < .5 ? 'toString' : 'toUpperCase']();}return ret.join('');}
小开

这个结合了许多答案。

var randNo = Math.floor(Math.random() * 100) + 2 + "" + new Date().getTime() +  Math.floor(Math.random() * 100) + 2 + (Math.random().toString(36).replace(/[^a-zA-Z]+/g, '').substr(0, 5));
console.log(randNo);

我已经用了一个月了，效果很好。

小开

教一个人钓鱼：

程序员用激光切割纸张，而不是电锯。使用边缘、特定语言的方法来生成最小、最模糊的代码很可爱，但永远不会提供完整的解决方案。你必须使用正确的工具来完成这项工作。

你需要的是一串字符，字符用字节表示。而且，我们可以用数字在JavaScript中表示一个字节。那么，我们应该生成这些数字的列表，并将它们转换为字符串。你不需要Date或base 64；Math.random（）会给你一个数字，String.fromCharCode（）会把它转换成字符串。很简单。

但是，哪个数字等于哪个字符？UTF-8是Web上用来将字节解释为字符的主要标准（尽管JavaScript内部使用UTF-16，但它们重叠）。程序员解决这个问题的方法是查看留档。

UTF-8列出了键盘上0到128之间数字的所有键。有些是非打印的。只需在随机字符串中挑选出您想要的字符，并使用随机生成的数字搜索它们。

Bellow是一个几乎无限长的函数，在循环中生成一个随机数，并搜索较低的128个UTF-8代码中的所有打印字符。熵是固有的，因为并非所有随机数每次都会命中（非打印字符、空格等）。随着您添加更多字符，它的执行速度也会更快。

我已经包含了线程中讨论的大多数优化：

  • 双波浪比Math.floor快
  • “if”语句比正则表达式更快
  • 推送到数组比字符串连接更快

function randomID(len) {var char;var arr = [];var len = len || 5;
do {char = ~~(Math.random() * 128);
if (((char > 47 && char < 58) || // 0-9(char > 64 && char < 91) || // A-Z(char > 96 && char < 123) // a-z
// || (char > 32 && char < 48) // !"#$%&,()*+'-./// || (char > 59 && char < 65) // <=>?@// || (char > 90 && char < 97) // [\]^_`// || (char > 123 && char < 127) // {|}~)//security conscious removals: " ' \ `//&& (char != 34 && char != 39 && char != 92 && char != 96)
) { arr.push(String.fromCharCode(char)) }
} while (arr.length < len);
return arr.join('')}
var input = document.getElementById('length');
input.onfocus = function() { input.value = ''; }
document.getElementById('button').onclick = function() {var view = document.getElementById('string');var is_number = str => ! Number.isNaN( parseInt(str));    
if ( is_number(input.value))view.innerText = randomID(input.value);elseview.innerText = 'Enter a number';}
#length {width: 3em;color: #484848;}
#string {color: #E83838;font-family: 'sans-serif';word-wrap: break-word;}
<input id="length" type="text" value='#'/><input id="button" type="button" value="Generate" /><p id="string"></p>

为什么要用这种乏味的方式来做呢？因为你可以。你是一个程序员。你可以让计算机做任何事情！此外，如果你想要一串希伯来文字符怎么办？这并不难。在UTF-8标准中找到这些字符并搜索它们。将自己从toString（36）等麦当劳方法中解放出来。

有时，降级到较低级别的抽象是创建真正解决方案所需要的。了解手头的基本原理可以让你按照自己的意愿自定义代码。也许你想要一个无限生成的字符串来填充循环缓冲区？也许你希望所有生成的字符串都是回文？为什么要退缩？

小开

这样的东西怎么样：Date.now().toString(36)不是很随机，但每次调用它时都很简短且非常独特。

小开

我做了一个字符串原型，可以生成一个给定长度的随机字符串。

如果你想要特殊的字符，你也可以安全，你可以避免一些。

/*** STRING PROTOTYPE RANDOM GENERATOR* Used to generate a random string* @param {Boolean} specialChars* @param {Number} length* @param {String} avoidChars*/String.prototype.randomGenerator = function (specialChars = false, length = 1, avoidChars = '') {let _pattern = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';_pattern += specialChars === true ? '(){}[]+-*/=' : '';if (avoidChars && avoidChars.length) {for (let char of avoidChars) {_pattern = _pattern.replace(char, '');}}let _random = '';for (let element of new Array(parseInt(length))) {_random += _pattern.charAt(Math.floor(Math.random() * _pattern.length));}return _random;};

你可以像这样使用：

// Generate password with specialChars which contains 10 chars and avoid iIlL charsvar password = String().randomGenerator(true, 10, 'iIlL');

希望有帮助。

小开

es6点差算子的新版本：

[...Array(30)].map(() => Math.random().toString(36)[2]).join('')

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

我没有找到支持小写和大写字符的干净解决方案。

仅支持小写：

Math.random().toString(36).substr(2, 5)

基于该解决方案来支持小写和大写：

Math.random().toString(36).substr(2, 5).split('').map(c => Math.random() < 0.5 ? c.toUpperCase() : c).join('');

更改substr(2, 5)中的5以调整到所需的长度。

小开

你可以使用bas64：

function randomString(length){var rtn = "";
do {rtn += btoa("" + Math.floor(Math.random() * 100000)).substring(0, length);}while(rtn.length < length);
return rtn;}
小开

随机Unicode字符串

此方法将返回一个包含任何支持的Unicode字符的随机字符串，这不是OP要求的100%，而是我要找的：

function randomUnicodeString(length){return Array.from({length: length}, ()=>{return String.fromCharCode(Math.floor(Math.random() * (65536)))}).join('')}

理由

这是谷歌搜索“随机字符串javascript”时的最高结果，但OP只要求a-zA-Z0-9。

小开

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

对于浏览器：

btoa(Math.random().toString()).substring(10,15);

对于nodejs：

Buffer.from(Math.random().toString()).toString("base64").substring(10,15);

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

（它与打字稿兼容）

小开

递归解决方案：

function generateRamdomId (seedStr) {const len = seedStr.lengthconsole.log('possibleStr', seedStr , ' len ', len)if(len <= 1){return seedStr}const randomValidIndex  = Math.floor(Math.random() * len)const randomChar = seedStr[randomValidIndex]const chunk1 = seedStr.slice(0, randomValidIndex)const chunk2 = seedStr.slice(randomValidIndex +1)const possibleStrWithoutRandomChar = chunk1.concat(chunk2)
return randomChar + generateRamdomId(possibleStrWithoutRandomChar)

}

你可以使用你想要的种子，如果你不愿意，不要重复字符。例子 

generateRandomId("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
小开

对于带有大写和小写字母和数字（0-9a-zA-Z）的字符串，这可能是最能缩小的版本：

function makeId(length) {var id = '';var rdm62;while (length--) {// Generate random integer between 0 and 61, 0|x works for Math.floor(x) in this caserdm62 = 0 | Math.random() * 62;// Map to ascii codes: 0-9 to 48-57 (0-9), 10-35 to 65-90 (A-Z), 36-61 to 97-122 (a-z)id += String.fromCharCode(rdm62 + (rdm62 < 10 ? 48 : rdm62 < 36 ? 55 : 61))}return id;}

此函数的内容缩小到97个字节，而顶部答案需要149个字节（因为字符列表）。

小开

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

function randStr(len) {let s = '';while (s.length < len) s += Math.random().toString(36).substr(2, len - s.length);return s;}
// usageconsole.log(randStr(50));

这个函数的好处是可以得到不同长度的随机字符串，它保证了字符串的长度。

大小写敏感所有字符：

function randStr(len) {let s = '';while (len--) s += String.fromCodePoint(Math.floor(Math.random() * (126 - 33) + 33));return s;}
// usageconsole.log(randStr(50));

自定义Chars

function randStr(len, chars='abc123') {let s = '';while (len--) s += chars[Math.floor(Math.random() * chars.length)];return s;}
// usageconsole.log(randStr(50));console.log(randStr(50, 'abc'));console.log(randStr(50, 'aab')); // more a than b

小开

这是双击的回答的略微改进版本。它考虑了gertas对案例的注释，当Math.random()返回0、0.5、0.25、0.125等时。

((Math.random()+3*Number.MIN_VALUE)/Math.PI).toString(36).slice(-5)
  1. 它可以防止零传递给toString，我将最小的浮点数添加到Math.random()。
  2. 它通过除以一个几乎无理数来确保传递给toString的数字有足够的数字。
小开

正如这里的一些人所指出的，将Math.random()的结果直接传递给.string(36)有几个问题。

它的随机性很差。生成的字符数各不相同，平均取决于JavaScript中浮点数如何工作的棘手细节。如果我尝试生成11个或更少的字符，但不超过11个，它似乎可以工作。而且它不灵活。没有简单的方法允许或禁止某些字符。

我有一个紧凑的解决方案，没有这些问题，对于任何使用洛达什的人：

_.range(11).map(i => _.sample("abcdefghijklmnopqrstuvwxyz0123456789")).join('')

如果您想允许某些字符（例如大写字母）或禁止某些字符（例如l和1等模棱两可的字符），请修改上面的字符串。

小开

下面这个怎么样……这将产生真正的随机值：

function getRandomStrings(length) {const value = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';const randoms = [];for(let i=0; i < length; i++) {randoms.push(value[Math.floor(Math.random()*value.length)]);}return randoms.join('');}

但是如果你在ES6中寻找更短的语法：

const getRandomStrings = length => Math.random().toString(36).substr(-length);
小开

以上所有答案都是完美的。但我添加的是非常好和快速的生成任何随机字符串值

function randomStringGenerator(stringLength) {var randomString = ""; // Empty value of the selective variableconst allCharacters = "'`~!@#$%^&*()_+-={}[]:;\'<>?,./|\\ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'"; // listing of all alpha-numeric letterswhile (stringLength--) {randomString += allCharacters.substr(Math.floor((Math.random() * allCharacters.length) + 1), 1); // selecting any value from allCharacters varible by using Math.random()}return randomString; // returns the generated alpha-numeric string}
console.log(randomStringGenerator(10));//call function by entering the random string you want

或

console.log(Date.now())// it will produce random thirteen numeric character value every time.console.log(Date.now().toString().length)// print length of the generated string

小开

这是我的方法（使用TypeScript）。

我决定再写一个响应，因为我没有看到任何使用现代js和干净代码的简单解决方案。

const DEFAULT_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
function getRandomCharFromAlphabet(alphabet: string): string {return alphabet.charAt(Math.floor(Math.random() * alphabet.length));}
function generateId(idDesiredLength: number, alphabet = DEFAULT_ALPHABET): string {/*** Create n-long array and map it to random chars from given alphabet.* Then join individual chars as string*/return Array.from({length: idDesiredLength}).map(() => {return getRandomCharFromAlphabet(alphabet);}).join('');}
generateId(5); // jNVv7
小开

我只是编写一个简单的包来生成一个具有给定大小、种子和掩码的随机令牌。仅供参考。

@sibevin/random-token-https://www.npmjs.com/package/@sibvan/随机令牌

import { RandomToken } from '@sibevin/random-token'
RandomToken.gen({ length: 32 })// JxpwdIA37LlHan4otl55PZYyyZrEdsQT
RandomToken.gen({ length: 32, seed: 'alphabet' })// NbbtqjmHWJGdibjoesgomGHulEJKnwcI
RandomToken.gen({ length: 32, seed: 'number' })// 33541506785847193366752025692500
RandomToken.gen({ length: 32, seed: 'oct' })// 76032641643460774414624667410327
RandomToken.gen({ length: 32, seed: 'hex' })// 07dc6320bf1c03811df7339dbf2c82c3
RandomToken.gen({ length: 32, seed: 'abc' })// bcabcbbcaaabcccabaabcacbcbbabbac
RandomToken.gen({ length: 32, mask: '123abcABC' })// vhZp88dKzRZGxfQHqfx7DOL8jKTkWUuO
小开 
const c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'const s = [...Array(5)].map(_ => c[~~(Math.random()*c.length)]).join('')
小开

简单方法：

function randomString(length) {let chars = [], output = '';for (let i = 32; i < 127; i ++) {chars.push(String.fromCharCode(i));}for (let i = 0; i < length; i ++) {output += chars[Math.floor(Math.random() * chars.length )];}return output;}

如果您想要更多或更少的字符，请将“127”更改为其他字符。

小开

一个班轮：

Array(15).fill(null).map(() => Math.random().toString(36).substr(2)).join('')// Outputs: 0h61cbpw96y83qtnunwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil
小开

//创建一个长度为10的随机代码，您可以根据自己的意愿将其更改为您的代码

function createRandomCode(length) {let randomCodes = '';let characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';let charactersLength = characters.length;for (let i = 0; i < length; i++ ) {randomCodes += characters.charAt(Math.floor(Math.random() * charactersLength))}console.log("your reference code is: ".toLocaleUpperCase() + randomCodes);};createRandomCode(10)
小开

生成任意数量的十六进制字符（例如32）：

(function(max){let r='';for(let i=0;i<max/13;i++)r+=(Math.random()+1).toString(16).substring(2);return r.substring(0,max).toUpperCase()})(32);
小开

加密强

如果你想得到满足你要求的加密强字符串（我看到答案使用这个，但给出了无效的答案）使用

let pass = n=> [...crypto.getRandomValues(new Uint8Array(n))].map((x,i)=>(i=x/255*61|0,String.fromCharCode(i+(i>9?i>35?61:55:48)))).join``

let pass = n=> [...crypto.getRandomValues(new Uint8Array(n))].map((x,i)=>(i=x/255*61|0,String.fromCharCode(i+(i>9?i>35?61:55:48)))).join``
console.log(pass(5));

更新：感谢Zibri评论我更新代码以获得任意长的密码

小开

审查

许多答案都基于技巧Math.random().toString(36)，但这种方法的问题是，Math.random总是产生以36为基至少有5个字符的数字。

let testRnd = n => console.log(`num dec: ${n}, num base36: ${n.toString(36)}, string: ${n.toString(36).substr(2, 5)}`);

[Math.random(),// and much more less than 0.5...0.5,0.50077160493827161,0.5015432098765432,0.5023148148148148,0.5030864197530864,// and much more....0.9799597050754459].map(n=>testRnd(n));
console.log('... and so on');
Each of below example (except first) numbers result with less than 5 characters (which not meet OP question requirements)

Here is "generator" which allows manually find such numbers

function base36Todec(hex) {hex = hex.split(/\./);return (parseInt(hex[1],36))*(36**-hex[1].length)+ +(parseInt(hex[0],36));}
function calc(hex) {let dec = base36Todec(hex);msg.innerHTML = `dec: <b>${dec}</b><br>hex test: <b>${dec.toString(36)}</b>`}
function calc2(dec) {msg2.innerHTML = `dec: <b>${dec}</b><br>hex test: <b>${(+dec).toString(36)}</b>`}
let init="0.za1";inp.value=init;calc(init);
Type number in range 0-1 using base 36 (0-9,a-z) with less than 5 digits after dot<br><input oninput="calc(this.value)" id="inp" /><div id="msg"></div><br>If above <i>hex test</i> give more digits than 5 after dot - then you can try to copy dec number to below field and join some digit to dec num right side and/or change last digit - it sometimes also produce hex with less digits<br><input oninput="calc2(this.value)" /><br><div id="msg2"></div>

我已经给出了答案这里，所以我不会在这里放另一个解决方案

小开

以下代码将使用npm包crypto-random-string生成一个大小为[a-zA-Z0-9]的加密安全随机字符串。使用以下命令安装它：

npm install crypto-random-string

要在集合[a-zA-Z0-9]中获取30个字符的随机字符串：

const cryptoRandomString = require('crypto-random-string');cryptoRandomString({length: 100, type: 'base64'}).replace(/[/+=]/g,'').substr(-30);

摘要：我们正在替换一个大型随机bas64字符串中的 /, +, = 并获取最后N个字符。

PS：在substr中使用-N

小开

如果您无法输入字符集，使用String.fromCharCode和范围Math.random允许您在任何Unicode代码点范围内创建随机字符串。例如，如果您想要17个随机藏文字符，您可以输入ranstr(17,0xf00,0xfff)，其中(0xf00,0xfff)对应于藏文Unicode块。在我的实现中，如果您不指定代码点范围，生成器将输出ASCII文本。

    function ranchar(a,b) {a = (a === undefined ? 0 : a);b = (b === undefined ? 127 : b);return String.fromCharCode(Math.floor(Math.random() * (b - a) + a));}    
function ranstr(len,a,b) {a = a || 32;var result = '';for(var i = 0; i < len; i++) {result += ranchar(a,b)}return result;}

//Here are some examples from random Unicode blocksconsole.log('In Latin Basic block: '+ ranstr(10,0x0000,0x007f))console.log('In Latin-1 Supplement block: '+ ranstr(10,0x0080,0x0ff))console.log('In Currency Symbols block: ' + ranstr(10,0x20a0,0x20cf))console.log('In Letterlike Symbols block: ' + ranstr(10,0x2100,0x214f))console.log('In Dingbats block:' + ranstr(10,0x2700,0x27bf))

小开

如何像这样扩展String对象。

String.prototype.random = function(length) {var result = '';for (var i = 0; i < length; i++) {result += this.charAt(Math.floor(Math.random() * this.length));}
return result;};

使用它：

console.log("ABCDEFG".random(5));
小开

改进了@Andrew上面的回答：

Array.from({ length : 1 }, () => Math.random().toString(36)[2]).join('');

随机数的基数36转换不一致，因此选择单个索引可以解决此问题。您可以使用所需的确切长度更改字符串的长度。

小开 
function generate(length) {var letters = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","0","1","2","3","4","5","6","7","8","9"];var IDtext = "";var i = 0;while (i < length) {var letterIndex = Math.floor(Math.random() * letters.length);var letter = letters[letterIndex];IDtext = IDtext + letter;i++;}console.log(IDtext)}
小开

生成一个安全的随机字母数字Base-62字符串：

function generateUID(length){return window.btoa(String.fromCharCode(...window.crypto.getRandomValues(new Uint8Array(length * 2)))).replace(/[+/]/g, "").substring(0, length);}
console.log(generateUID(22)); // "yFg3Upv2cE9cKOXd7hHwWp"console.log(generateUID(5)); // "YQGzP"

小开

这不是一个完美的解决方案，但它应该可以工作。如果你遇到任何错误，请增加Uint8Array（）构造函数中给出的值。此方法的优点是它使用获取随机值方法生成加密强随机值。

var array = new Uint8Array(20);crypto.getRandomValues(array);var arrayEncoded =  btoa(String.fromCharCode(...array)).split('');var arrayFiltered = arrayEncoded.filter(value => {switch (value){case "+" :return false;case "/" :return false;case "=" :return false;default :return true;}});var password = arrayFiltered.slice(0,5).join('');console.log(password);

一个紧凑的版本

var array = new Uint8Array(20);crypto.getRandomValues(array);var password = btoa(String.fromCharCode(...array)).split('').filter(value => {return !['+', '/' ,'='].includes(value);}).slice(0,5).join('');console.log(password);

小开

如果你只想要大写字母（A-Z）：

randomAZ(n: number): string {return Array(n).fill(null).map(() => Math.random()*100%25 + 'A'.charCodeAt(0)).map(a => String.fromCharCode(a)).join('')}

如果你只希望第一个字母是大写（A-Z），其余的是小写（a-z）：

function RandomWord(n: number): string {return Array(n).fill(null).map(() => Math.random()*100%25 + 'A'.charCodeAt(0)).map((a, i) => i === 0? String.fromCharCode(a) : String.fromCharCode(a+32)).join('')}
小开

一行[a-z]：

String.fromCharCode(97 + Math.floor(Math.random() * 26))
小开

喜欢这个SO问题和他们的答案。所以提出了切肉刀和创造性的解决方案。我想出了我的，它被包裹在一个函数中，它接收你想要获得的字符串的长度加上一个模式参数来决定你希望它如何组成。

模式是一个3长度的字符串，只接受'1'和'0'，它们定义了您要在最终字符串中包含的字符子集。它由3个不同的子集分组（[0-9]、[A-B]、[a-b]）

'100': [0-9]'010': [A-B]'101': [0-9] + [a-b]'111': [0-9] + [A-B] + [a-b]

有8种可能的组合（2^N，包含N：#子集）。'000'模式返回一个空字符串。

function randomStr(l = 1, mode = '111') {if (mode === '000') return '';const r = (n) => Math.floor(Math.random() * n);const m = [...mode].map((v, i) => parseInt(v, 10) * (i + 1)).filter(Boolean).map((v) => v - 1);return [...new Array(l)].reduce((a) => a + String.fromCharCode([(48 + r(10)), (65 + r(26)), (97 + r(26))][m[r(m.length)]]), '')}

一个简单的用例将是：

random = randomStr(50, '101')// ii3deu9i4jk6dp4gx43g3059vss9uf7w239jl4itv0cth5tj3e// Will give you a String[50] composed of [0-9] && [a-b] chars only.

这里的主要思想是使用UNICODE表而不是像我在许多答案中看到的那样随机化十六进制。这种方法的强大之处在于，您可以非常容易地扩展它以包含UNICODE表的其他子集，其中包含少量额外的代码，这是随机int（16）无法做到的。

小开

如果你在node js上开发，最好使用crypto。这是一个实现randomStr()函数的示例

const crypto = require('crypto');const charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghiklmnopqrstuvwxyz';const randomStr = (length = 5) => new Array(length).fill(null).map(() => charset.charAt(crypto.randomInt(charset.length))).join('');

如果您不在服务器环境中工作，只需更换随机数生成器：

const charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghiklmnopqrstuvwxyz';const randomStr = (length = 5) => new Array(length).fill(null).map(() => charset.charAt(Math.floor(Math.random() * charset.length))).join('');
小开 
[..."abcdefghijklmnopqrsuvwxyz0123456789"].map((e, i, a) => a[Math.floor(Math.random() * a.length)]).join('')
小开

使用地图的单行代码，可让您完全控制长度和字符。

const rnd = (len, chars='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') => [...Array(len)].map(() => chars.charAt(Math.floor(Math.random() * chars.length))).join('')
console.log(rnd(12))
小开

这是没有最好的方法。你可以以任何你喜欢的方式进行，只要结果符合你的要求。为了说明，我创建了许多不同的示例，它们都应该提供相同的最终结果

此页面上的大多数其他答案忽略大写字符要求。

这是我的最快的解决方案和最可读。它基本上与公认的解决方案相同，只是它快一点。

function readableRandomStringMaker(length) {for (var s=''; s.length < length; s += 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'.charAt(Math.random()*62|0));return s;}console.log(readableRandomStringMaker(length));// e3cbN

这是一个紧凑递归版本，可读性要低得多：

const compactRandomStringMaker = (length) => length-- && "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".charAt(Math.random()*62|0) + (compactRandomStringMaker(length)||"");console.log(compactRandomStringMaker(5));// DVudj

A更紧凑的单线：

Array(5).fill().map(()=>"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".charAt(Math.random()*62)).join("")// 12oEZ

上面的一个变体：

"     ".replaceAll(" ",()=>"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".charAt(Math.random()*62))

最紧凑单行代码，但效率低下且不可读-它添加随机字符并删除非法字符，直到长度为l：

((l,f=(p='')=>p.length<l?f(p+String.fromCharCode(Math.random()*123).replace(/[^a-z0-9]/i,'')):p)=>f())(5)

密码安全版本，为了紧凑而浪费熵，并且无论如何都是浪费，因为生成的字符串太短：

[...crypto.getRandomValues(new Uint8Array(999))].map((c)=>String.fromCharCode(c).replace(/[^a-z0-9]/i,'')).join("").substr(0,5)// 8fzPq

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

((f=(p='')=>p.length<5?f(p+String.fromCharCode(Math.random()*123).replace(/[^a-z0-9]/i,'')):p)=>f())()// EV6c9

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

((l,s=((l)=>l--&&"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".charAt(Math.random()*62|0)+(s(l)||""))) => s(l))(5);// qzal4

这是一个“魔法”变量，每次访问它时都会提供一个随机字符：

const c = new class { [Symbol.toPrimitive]() { return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".charAt(Math.random()*62|0) } };console.log(c+c+c+c+c);// AgMnz

上面的一个更简单的变体：

const c=()=>"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".charAt(Math.random()*62|0);c()+c()+c()+c()+c();// 6Qadw
小开

只需一个简单的map或reduce实现就足够了：

const charset: string ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
const random1: string = [...Array(5)].map((_) => charset[Math.floor(Math.random() * charset.length)]).join("");
const random2: string = [...Array(5)].reduce<string>((acc) => acc += charset[Math.floor(Math.random() * charset.length)],"",);
小开

为后人发布ES6兼容版本。如果这被大量调用，请务必将. long值存储到常量变量中。

// USAGE://      RandomString(5);//      RandomString(5, 'all');//      RandomString(5, 'characters', '0123456789');const RandomString = (length, style = 'frictionless', characters = '') => {const Styles = {'all':          allCharacters,'frictionless': frictionless,'characters':   provided}
let result              = '';const allCharacters     = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';const frictionless      = 'ABCDEFGHJKMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789';const provided          = characters;
const generate = (set) => {return set.charAt(Math.floor(Math.random() * set.length));};
for ( let i = 0; i < length; i++ ) {switch(Styles[style]) {case Styles.all:result += generate(allCharacters);break;case Styles.frictionless:result += generate(frictionless);break;case Styles.characters:result += generate(provided);break;}}return result;}
export default RandomString;
小开

使用A-zZ和0-9字符集合生成随机字符串。只需使用长度参数调用此函数。

所以要回答这个问题：generateRandomString(5)

generateRandomString(length){let result = "", seeds
for(let i = 0; i < length - 1; i++){//Generate seeds array, that will be the bag from where randomly select generated charseeds = [Math.floor(Math.random() * 10) + 48,Math.floor(Math.random() * 25) + 65,Math.floor(Math.random() * 25) + 97]        
//Choise randomly from seeds, convert to char and append to resultresult += String.fromCharCode(seeds[Math.floor(Math.random() * 3)])}
return result}

生成不带数字的字符串的版本：

generateRandomString(length){let result = "", seeds
for(let i = 0; i < length - 1; i++){seeds = [Math.floor(Math.random() * 25) + 65,Math.floor(Math.random() * 25) + 97]result += String.fromCharCode(seeds[Math.floor(Math.random() * 2)])}
return result}
小开

要从数组中生成哈希作为盐，在本例中为[0,1,2,3]，通过这种方式，我们可以稍后检索哈希以填充条件。

只需提供一个随机数组，或者使用额外的安全和快速的数组指纹。

/* This method is very fast and is suitable into intensive loops *//* Return a mix of uppercase and lowercase chars */
/* This will always output the same hash, since the salt array is the same */console.log(btoa(String.fromCharCode(...new Uint8Array( [0,1,2,3] ))))
/* Always output a random hex hash of here: 30 chars  */console.log(btoa(String.fromCharCode(...new Uint8Array( Array(30).fill().map(() => Math.round(Math.random() * 30)) ))))

使用来自加密API的HMAC，了解更多：https://stackoverflow.com/a/56416039/2494754

小开

//返回一个随机字母

let alpha = "ABCDEFGHIGKLMNOPQRSTUVWXYZ";console.log(alpha.charAt(Math.floor(Math.random() * alpha.length)));
小开

您可以使用Web Crypto的API：

console.log(self.crypto.getRandomValues(new Uint32Array(1))[0])

(original answer here)


提交答案