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

Question

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

使用JavaScript执行此操作的最佳方法是什么？

Answer 1

我认为这对你有用:

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

Answer 2

let r = Math.random().toString(36).substring(7);
console.log("random", r);

注意:上述算法有以下缺点:

• 它将生成0到6个字符之间的任何位置,因为在对浮点进行字符串化时会删除尾随零.
• 它很大程度上取决于用于字符串化浮点数的算法,这种算法非常复杂.(参见文章"如何准确打印浮点数".)
• Math.random()可能会产生可预测的("随机的"但不是真正随机的)输出,具体取决于实现方式.当您需要保证唯一性或不可预测性时,生成的字符串不适合.
• 即使它产生了6个均匀随机,不可预测的字符,由于生日悖论,你可能会在生成大约50,000个字符串之后看到重复.(sqrt(36 ^ 6)= 46656)

Answer 3

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 ('0' + dec.toString(16)).substr(-2)
}

// generateId :: Integer -> String
function 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"

Answer 4

简短,轻松,可靠

返回5个随机字符,而不是这里找到的一些最高评分的答案.

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

Answer 5

这是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. 将数字转换为base-36字符串,即使用字符0-9和az.
3. 用零填充(解决第一个问题).
4. 切掉领先的'0' 前缀和额外的填充零.
5. 重复字符串足够多次以使其中至少包含N个字符(通过将空字符串与用作分隔符的较短随机字符串连接起来).
6. 从字符串中精确切割N个字符.

进一步思考:

• 这个解决方案不使用大写字母,但几乎在所有情况下(没有双关语)都没关系.
• 在Chrome中测量原始答案中N = 16的最大字符串长度.在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('');

编辑:

我好像是qubyte,Martijn de Milliano提出了类似于后者的解决方案(kudos!),我不知何故错过了.因为它们一目了然看起来不那么短,所以无论如何我都会把它留在这里以防有人真的想要一个单线:-)

此外,在所有解决方案中将'new Array'替换为'Array'以减少更多字节.

Answer 6

最紧凑的解决方案,因为slice比较短substring.从字符串末尾减去允许避免random函数生成的浮点符号:

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

甚至

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

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

Answer 7

这样的事情应该有效

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

Answer 8

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

Answer 9

随机字符串生成器(Alpha-Numeric | Alpha | Numeric)

/**
 * RANDOM STRING GENERATOR
 *
 * Info:      http://stackoverflow.com/a/27872144/383904
 * Use:       randomString(length [,"A"] [,"N"] );
 * Default:   return a random alpha-numeric string
 * Arguments: If you use the optional "A", "N" flags:
 *            "A" (Alpha flag)   return random a-Z string
 *            "N" (Numeric flag) return random 0-9 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;
}

randomString(10);        // "4Z8iNQag9v"
randomString(10, "A");   // "aUkZuHNcWw"
randomString(10, "N");   // "9055739230"

玩得开心.jsBin演示

虽然上面使用了对所需(A/N,A,N)输出的附加检查,但是为了更好地理解, 我们将其分解为基本要素(仅限字母数字):

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

让我们看一下Character表及其范围:

_____0....9______A..........Z______a..........z___________  Character
     | 10 |      |    26    |      |    26    |             Tot = 62 characters
    48....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 ;

如果您按照上述说明操作,则应该能够创建此字母数字代码段:

jsBin演示

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

console.log( randomString(10) ); // "7GL9F0ne6t"

或者如果你愿意:

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

Answer 10

带有es6 扩展运算符的更新版本:

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

• 这30是任意数字,您可以选择任何您想要的令牌长度
• 这36是您可以传递给numeric.toString()的最大基数,这意味着所有数字和az小写字母
• 本2是用来接从它看起来像这样的随机字符串的第3号:"0.mfbiohx64i",我们可以采取任何索引后0.

Answer 11

最简单的方法是:

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

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

这个问题是如果你在同一秒钟上调用它两次,它将生成相同的字符串.

更安全的方式是:

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

这将生成一个4或5个字符的随机字符串,总是不同的.示例输出类似于30jzm或1r591或4su1a

在两种方式中,第一部分生成随机数.该.toString(36)部分将数字转换为它的base36(alphadecimal)表示.

Answer 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

更紧凑的单行：

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

Answer 13

这里有一些简单的衬里.更改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"]();});

Answer 14

我知道每个人都已经把它弄好了,但我觉得可以用最轻量级的方式去做这个(代码轻,不是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的语法是多么棒.

Answer 15

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

function generateUID(length)
{
    return window.btoa(Array.from(window.crypto.getRandomValues(new Uint8Array(length * 2))).map((b) => String.fromCharCode(b)).join("")).replace(/[+/]/g, "").substring(0, length);
}

console.log(generateUID(22)); // "yFg3Upv2cE9cKOXd7hHwWp"
console.log(generateUID(5)); // "YQGzP"

Answer 16

如果你正在使用Lodash或下划线,那么就这么简单:

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

Answer 17

const c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
const s = [...Array(5)].map(_ => c[~~(Math.random()*c.length)]).join('')

Answer 18

改进了上面@Andrew 的回答：

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

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

Answer 19

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

工作示例:
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)));
}

Answer 20

一个班轮：

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

Answer 21

如果有人对单线程感兴趣(虽然为了方便起见没有格式化),一次分配内存(但请注意,对于小字符串,它确实无关紧要)以下是如何做到这一点:

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

Answer 22

假设您使用underscorejs,可以在两行中优雅地生成随机字符串:

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

Answer 23

满足要求[a-zA-Z0-9]和长度= 5使用

btoa(Math.random()).substr(5, 5);

将出现小写字母,大写字母和数字.

Answer 24

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

• repeat创建 5 个字符（可以概括为n）
• repeat用正则表达式/./g替换这 5 个字符
• 该公式是从 62 个字符 A-Za-z0-9 字符串中随机选取一个字符

let ans = "x".repeat(5)
             .replace(/./g, c => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[Math.floor(Math.random() * 62) ] );
console.log(ans);

Answer 25

这个小巧的小技巧怎么样？

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

Answer 26

加密强

如果您想获得满足您要求的加密强字符串（我看到使用此字符串但给出无效答案的答案），请使用

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``

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

Answer 27

快速改进的算法.不保证统一(见评论).

function getRandomId(length) {
    if (!length) {
        return '';
    }

    const possible =
        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    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);
        }
    }

    for (let i = 0; i < length; i++) {
        result += possible.charAt(array[i] % 62);
    }

    return result;
}

Answer 28

您可以遍历项目数组并以递归方式将它们添加到字符串变量中,例如,如果您需要随机DNA序列:

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

console.log(randomDNA(5));

Answer 29

这是一种函数式风格的方法。性能不是最优的，但写起来很有趣 -

const char = a =>
  String .fromCharCode (a)

const irand = x =>
  Math .floor (Math .random () * x)

const sample = xs =>
  xs .at (irand (xs.length))

const range = x => y =>
  x > y
    ? []
    : [ x, ...range (x + 1) (y) ]

const srand = rs => n =>
  n <= 0
    ? ""
    : char (sample (rs)) + srand (rs) (n - 1)

const identifier = srand ([
  ...range (48) (57),   // include 0-9
  ...range (65) (90),   // include A-Z
  ...range (97) (122),  // include a-z
])

console .log (identifier (6))  //=> xUCXPI
console .log (identifier (10)) //=> JQvct8XeGt
console .log (identifier (20)) //=> ZVDwQSdRQLJEF5Wqjs17

很难超越 的清晰度identifier。也许稍有改进可能是 -

const ord = x =>
  x .charCodeAt (0)

const idGenerator = srand ([
  ...range (ord('0')) (ord('9')),
  ...range (ord('A')) (ord('Z')),
  ...range (ord('a')) (ord('z')),
])

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

Answer 30

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

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

// usage
console.log(randStr(50));

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

区分大小写的所有字符：

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

// usage
console.log(randStr(50));

自定义字符

function randStr(len, chars='abc123') {
  let s = '';
  while (len--) s += chars[Math.floor(Math.random() * chars.length)];
  return s;
}

// usage
console.log(randStr(50));
console.log(randStr(50, 'abc'));
console.log(randStr(50, 'aab')); // more a than b

Answer 31

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

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

console.log(rnd(12))

Answer 32

只需一个简单的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)],
    "",
  );

Answer 33

function randomString (strLength, charSet) {
    var result = [];

    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 34

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

获得严格唯一的字符串有两种主要方法：确定性（不是随机的）和存储/比较（繁琐的）。我们做什么？我们放弃了幽灵。我们代之以概率唯一性。也就是说，我们接受我们的字符串存在唯一性的风险（但很小）。在这里，了解碰撞概率和熵很有帮助。

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

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

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)

“ 27b33372ade513715481f”

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

Answer 35

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

小写仅支持:

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

更改5在substr(2, 5)调整到你需要的长度.

Answer 36

一个班轮 [az]：

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

Answer 37

这肯定有用

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

Answer 38

生成 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: // digit
            str += (Math.floor(Math.random()*9)).toString();
        break;

        case 2: // small letter
            str += String.fromCharCode(Math.floor(Math.random()*26) + 97); //'a'.charCodeAt(0));
        break;

        case 3: // big letter
            str += String.fromCharCode(Math.floor(Math.random()*26) + 65); //'A'.charCodeAt(0));
        break;

        default:
        break;
    }
}
return str;
}

Answer 39

这样的事情怎么样：Date.now().toString(36) 不是很随机，但是每次调用时都很短而且很独特。

Answer 40

这是我的方法（使用 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