【问题标题】：Generate random string/characters in JavaScript在 JavaScript 中生成随机字符串/字符
【发布时间】：2010-11-23 21:06:08
【问题描述】：

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

用 JavaScript 最好的方法是什么？

【问题讨论】：

警告：没有一个答案有true-random 结果！他们只是pseudo-random。当使用随机字符串进行保护或安全时，不要使用其中任何一个！！！尝试以下 api 之一：random.org
Math.random().toString(36).replace(/[^a-z]+/g, '')
请将解决方案放入解决方案中。
Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
注意HTML5 webcrypto randomness API 提供真正的随机性。

标签： javascript string random

【解决方案1】：

我已经制作了一个字符串原型，它可以生成一个给定长度的随机字符串。

如果你想要特殊字符，你也可以指定，你可以避免一些。

/**
 * 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 chars
var password = String().randomGenerator(true, 10, 'iIlL');

希望对你有帮助。

【讨论】：

通常扩展原生对象被认为是不好的做法（你可能会释放 Cthulhu）。见 - stackoverflow.com/questions/14034180/…

【解决方案2】：

随机 unicode 字符串

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

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

基本原理

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

【讨论】：

【解决方案3】：

授人以渔：

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

你要的是一串字符，字符用字节表示。而且，我们可以在 JavaScript 中使用一个数字来表示一个字节。那么，我们应该生成这些数字的列表，并将它们转换为字符串。您不需要 Date 或 base64； 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);
  else
    view.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) 等 McDonald 方法中解脱出来。

有时，需要降低抽象级别才能创建真正的解决方案。了解手头的基本原则可以让您根据需要自定义代码。也许您想要一个无限生成的字符串来填充循环缓冲区？也许您希望所有生成的字符串都是回文？为什么要阻止自己？

【讨论】：

天啊...维护这段代码会很痛苦。太hacky而且不可读。始终为人类编写代码，最终可以由机器执行，而不是相反。而所有这些不必要的微优化都是邪恶的……CPU 周期很便宜。推送到数组是否比连接更快或者神秘的双波浪号是否比 Math.floor 快并不重要。
这都是基于意见的。自从我为这个答案编写代码以来，这段代码一直在完美运行。我在一个分布式系统中使用它，该系统在高吞吐量期间广播更新并每分钟生成数千个唯一 ID。取消注释一行以添加字符非常简单。在您的“不需要做就不要做”的理念中，我认为程序员的空间不大。
我不知道。所有人都想编程，却忘记了面前有一台机器。在 80 年代，了解编程的数学是件好事。今天很高兴拥有？阅读链式条件真的很重要吗？不！不适合我！那么语言很重要。但是口语功能和符号对我来说很高兴。两个世界的结合，你就是一个熟练的程序员！我无法相信反对票。这不是堆栈溢出
你误解了我@Duco。我不宣扬“如果不需要做就不要做”。我不知道你从哪里得出的结论，我从来没有说过这样的话。事实上，我经常被批评重新发明轮子，我为此感到自豪！避免使用图书馆并自己动手是件好事……有时！有个限度。例如，Math.floor 是核心的一部分。我在这里的主要抱怨是代码很笨拙且难以阅读。顺便说一句，稍后使用的注释代码也是不好的做法。如果你想控制它的行为，让你的函数接受另一个参数。

【解决方案4】：

这是doubletap 的answer 的略微改进版本。当Math.random()返回0、0.5、0.25、0.125等时，它会考虑gertas对该案例的评论。

((Math.random()+3*Number.MIN_VALUE)/Math.PI).toString(36).slice(-5)

它可以防止将零传递给toString 我将最小的浮点数添加到Math.random()。
它通过除以一个几乎无理数来确保传递给toString 的数字有足够的位数。

【讨论】：

【解决方案5】：

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

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

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

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

如果要允许某些字符（如大写字母）或禁止某些字符（如l和1等模糊字符），请修改上面的字符串。

【讨论】：

【解决方案6】：

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

@sibevin/random-token - https://www.npmjs.com/package/@sibevin/random-token

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

【讨论】：

【解决方案7】：

像这样扩展 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));

【讨论】：

【解决方案8】：

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

【讨论】：

【解决方案9】：

[..."abcdefghijklmnopqrsuvwxyz0123456789"].map((e, i, a) => a[Math.floor(Math.random() * a.length)]).join('')

【讨论】：

【解决方案10】：

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

function randomString(length) {
    if ( length <= 0 ) return "";
    var getChunk = function(){
        var i, //index iterator
            rand = Math.random()*10e16, //execute random once
            bin = rand.toString(2).substr(2,10), //random binary sequence
            lcase = (rand.toString(36)+"0000000000").substr(0,10), //lower case random string
            ucase = lcase.toUpperCase(), //upper case random string
            a = [lcase,ucase], //position them in an array in index 0 and 1
            str = ""; //the chunk string
        b = 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 next
        return str;
    },
    str = ""; //the result string
    while ( str.length < length  )
        str += getChunk();
    str = str.substr(0,length);
    return str;
}

【讨论】：

【解决方案11】：

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

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

【讨论】：

【解决方案12】：

在下面的代码中，我正在生成 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);

【讨论】：

【解决方案13】：

试试这个，我每次都用什么：

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>

【讨论】：

【解决方案14】：

很简单

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

【讨论】：

【解决方案15】：

你可以使用 base64：

function randomString(length)
{
    var rtn = "";

    do {
        rtn += btoa("" + Math.floor(Math.random() * 100000)).substring(0, length);
    }
    while(rtn.length < length);

    return rtn;
}

【讨论】：

【解决方案16】：

递归解：

function generateRamdomId (seedStr) {
const len = seedStr.length
console.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")

【讨论】：

【解决方案17】：

简单方法：

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”更改为其他内容。

【讨论】：

【解决方案18】：

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)

这里是“生成器”，允许手动查找此类数字

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>

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

【讨论】：

【解决方案19】：

以下代码将使用 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);

总结：我们正在替换一个大的随机 base64 字符串中的 /、+、= 并获取最后 N 个字符。

PS：在substr中使用-N

【讨论】：

【解决方案20】：

如果您无法输入字符集，使用 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 blocks
console.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))

【讨论】：

【解决方案21】：

喜欢这个 SO 问题及其答案。因此，提出了更明智和创造性的解决方案。我想出了一个包装在 function 中的我的方法，该函数接收您要获取的字符串的 length 以及一个 mode 参数来决定如何你希望它被组合起来。

Mode 是一个长度为 3 的字符串，它只接受 '1s' 和 '0s' 来定义您希望在最终字符串中包含哪些字符子集。它由 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:#subsets）。 '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) 无法做到的少量额外代码。

【讨论】：

【解决方案22】：

使用 aA-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 char
        seeds = [
            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 result
        result += 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
}

【讨论】：

【解决方案23】：

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

【讨论】：

这与随机相反。如果您需要随机 ID 并使用这种方法在 for 循环中生成多个 ID，您可能会得到一些相同的 ID。此外，用户可以通过设置计算机的日期/时间来影响您的 ID 选择。这不是你可能想做的事情。
这真的取决于你需要什么，在我的情况下，我需要在用户添加行时将 id 添加到行中，而你不能在 1 毫秒内点击两次，
但是，您可以双击，就像某个后台进程或其他 JavaScript 代码将浏览器挂起几毫秒一样，这会导致接下来的两个点击事件在“相同”毫秒内处理.当然，这不太可能发生，但也不是不可能。因此代码是不可预测的。特别是如果您不能保证在您的网站/应用程序将在其上运行的所有设备上运行时间等。
我想看一个演示，在我看来这是不可能的，除非你用机器人点击?
给你：gist.github.com/JochemKuijpers/86217cec7c860c0af0dfc06bbddacc42 我设法在 Chrome 上获得了一些相同的 ID（在我的第 6 代 i5 机器上很容易重现）。我可以想象这在计时器不太准确的移动浏览器上是一个更大的问题。

【解决方案24】：

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

function randomStringGenerator(stringLength) {
  var randomString = ""; // Empty value of the selective variable
  const allCharacters = "'`~!@#$%^&*()_+-={}[]:;\'<>?,./|\\ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'"; // listing of all alpha-numeric letters
  while (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

【讨论】：

Date.now() 肯定不会产生十三个“随机”数字
@Molomby，兄弟，感谢您的宝贵时间，但请写出逻辑，在这种情况下它不会产生 13 个“随机”数字。
随机性为the lack of predictability。 Date.now() 产生的数字代表调用函数的机器的当前日期/时间。它们是高度可预测的，并且在任何定义上都不是“随机的”。真正的随机性很难；甚至Math.random() 也不是真正随机的，而是伪随机的。您将在此线程中看到其他答案，推荐更好的 crypto 模块（但仍然不是真正随机的）。从这里开始了解更多信息：developer.mozilla.org/en-US/docs/Glossary/RNG

【解决方案25】：

//创建一个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)

【讨论】：

这只是非常小的修改的最佳答案之一。
我只是试着让它更容易阅读。

【解决方案26】：

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

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

【讨论】：

【解决方案27】：

这是 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)

【讨论】：

【解决方案28】：

这是 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

【讨论】：