JavaScript中的随机字母数字字符串？

在JavaScript中生成随机字母数字（大写、小写和数字）字符串以用作可能唯一的标识符的最短方法（合理范围内）是什么？

随机字符：

String.fromCharCode(i); //where is an int

随机整数：

Math.floor(Math.random()*100);

总而言之：

function randomNum(hi){
    return Math.floor(Math.random()*hi);
} 
function randomChar(){
    return String.fromCharCode(randomNum(100));
}
function randomString(length){
   var str = "";
   for(var i = 0; i < length; ++i){
        str += randomChar();
   }
   return str;
}
var RandomString = randomString(32); //32 length string

函数随机数（hi）{
返回Math.floor（Math.random（）*hi）；
} 
函数randomChar（）{
返回字符串.fromCharCode（randomNum（100））；
}
函数随机字符串（长度）{
var str=“”；
对于（变量i=0；i

---

Fiddle:

如果您只想允许使用特定字符，也可以这样做：

function randomString(length, chars) {
    var result = '';
    for (var i = length; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)];
    return result;
}
var rString = randomString(32, '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');

function randomString(length, chars) {
    var mask = '';
    if (chars.indexOf('a') > -1) mask += 'abcdefghijklmnopqrstuvwxyz';
    if (chars.indexOf('A') > -1) mask += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    if (chars.indexOf('#') > -1) mask += '0123456789';
    if (chars.indexOf('!') > -1) mask += '~`!@#$%^&*()_+-={}[]:";\'<>?,./|\\';
    var result = '';
    for (var i = length; i > 0; --i) result += mask[Math.floor(Math.random() * mask.length)];
    return result;
}

console.log(randomString(16, 'aA'));
console.log(randomString(32, '#aA'));
console.log(randomString(64, '#A!'));

function randomString(length) {
    return Math.round((Math.pow(36, length + 1) - Math.random() * Math.pow(36, length))).toString(36).slice(1);
}

下面是一个要演示的JSFIDLE：

另一种方法是使用一个特殊的字符串，告诉函数要使用什么类型的字符。你可以这样做：

function randomString(length, chars) {
    var result = '';
    for (var i = length; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)];
    return result;
}
var rString = randomString(32, '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');

function randomString(length, chars) {
    var mask = '';
    if (chars.indexOf('a') > -1) mask += 'abcdefghijklmnopqrstuvwxyz';
    if (chars.indexOf('A') > -1) mask += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    if (chars.indexOf('#') > -1) mask += '0123456789';
    if (chars.indexOf('!') > -1) mask += '~`!@#$%^&*()_+-={}[]:";\'<>?,./|\\';
    var result = '';
    for (var i = length; i > 0; --i) result += mask[Math.floor(Math.random() * mask.length)];
    return result;
}

console.log(randomString(16, 'aA'));
console.log(randomString(32, '#aA'));
console.log(randomString(64, '#A!'));

function randomString(length) {
    return Math.round((Math.pow(36, length + 1) - Math.random() * Math.pow(36, length))).toString(36).slice(1);
}

---

我只是觉得这是一个非常好和优雅的解决方案：

Math.random().toString(36).slice(2)

关于这一实施的说明：

• 这将产生一个长度介于0到12个字符之间的字符串，通常为11个字符，因为浮点字符串化会删除尾随的零
• 它不会生成大写字母，只生成小写和数字
• 由于随机性来自

  Math.random（）

  ，因此输出可能是可预测的，因此不一定是唯一的
• 即使假设是一个理想的实现，输出也最多有52位的熵，这意味着在生成大约7000万个字符串后，您可以预期会出现重复

---

或者在Jar建议的基础上，我在最近的一个项目中使用了以下内容（以克服长度限制）：

对于32个字符：

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

let len = 20, str = "";
while(str.length < len) str += Math.random().toString(36).substr(2);
str = str.substr(0, len);

for（var c=''；c.length<32；）c+=Math.random（）.toString（36）.substr（2,1）

当我看到这个问题时，我想到了我必须生成UUID的时候。我不能把代码归功于它，因为我确信我在stackoverflow上找到了它。如果你不想在你的字符串破折号，然后拿出破折号。以下是函数：

function generateUUID() {
    var d = new Date().getTime();
    var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,function(c) {
        var r = (d + Math.random()*16)%16 | 0;
        d = Math.floor(d/16);
        return (c=='x' ? r : (r&0x7|0x8)).toString(16);
    });
    return uuid.toUpperCase();
}

---

Fiddle:

JAR.JAR.beans建议的答案的另一种变体

(Math.random()*1e32).toString(36)

通过更改乘法器

1e32

可以更改随机字符串的长度。

使用lodash：

函数createRandomString（长度）{
var chars=“abcdefghijklmnopqrstufxyzabcdefghijklmnopqrstufxyz1234567890”
var pwd=u.sampleSize（字符，长度| | 12）//lodash v4:use u.sampleSize
返回pwd.join（“”）
}
document.write（createRandomString（8））

var randomString=函数（长度）{
var-str=''；
var chars='0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZABCDFGHIKLMNOPQRSTUVXYZ'。拆分(
'');
var charsLen=字符长度；
如果（！长度）{
长度=~~（Math.random（）*charsLen）；
}
对于（变量i=0；i

使用md5库：

最短路径：

md5（Math.random（））

如果要将大小限制为5：

md5（Math.random（））.substr（0,5）

这更干净

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

范例

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

---

此函数应提供任意长度的随机字符串

function randString(length) {
    var l = length > 25 ? 25 : length;
    var str = Math.random().toString(36).substr(2, l);
    if(str.length >= length){
        return str;
    }
    return str.concat(this.randString(length - str.length));
}

我已经用下面的测试成功了

function test(){
    for(var x = 0; x < 300000; x++){
        if(randString(x).length != x){
            throw new Error('invalid result for len ' + x);
        }
    }
}

功能测试（）{
对于（变量x=0；x<300000；x++）{
if（随机字符串（x）.length！=x）{
抛出新错误（'len'+x的结果无效）；
}
}
}

我之所以选择25，是因为实际上从

Math.random（）.toString（36）.substr（2，25）

返回的字符串长度为25。您可以根据需要更改此号码

此函数是递归函数，因此使用非常大的值调用该函数可能会导致超出最大调用堆栈大小。通过测试，我可以得到长度为300000个字符的字符串

通过将字符串作为第二个参数发送给函数，可以将此函数转换为尾部递归。我不确定JS是否使用尾部调用优化

随机密钥生成器

keyLength参数是要为键指定的字符长度

function keyGen(keyLength) {
    var i, key = "", characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

    var charactersLength = characters.length;

    for (i = 0; i < keyLength; i++) {
        key += characters.substr(Math.floor((Math.random() * charactersLength) + 1), 1);
    }

    return key;
}


keyGen(12)
"QEt9mYBiTpYD"

功能键根（键长）{
变量i，key=“”，characters=“abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzo123456789”；
var charactersLength=characters.length；
对于（i=0；i

简洁明了，不限于一定数量的字符：

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

let len = 20, str = "";
while(str.length < len) str += Math.random().toString(36).substr(2);
str = str.substr(0, len);

让len=20，str=”“；
而（str.length

更新： 一行解决方案，用于随机20个字符（字母数字小写）：

或更短的含lodash：

_.times(20, () => _.random(35).toString(36)).join('');

总结：

创建一个我们想要的大小的数组（因为javascript中没有

range（len）

等价物）

对于数组中的每个元素：从

p

中选择一个随机字符并将其添加到字符串中

返回生成的字符串

一些解释：

[…数组（len）]

数组（len）或新数组（len）。单行程序将更难实现。可以方便地定义指针（现在它们指向未定义的对象！）

.reduce（

在本例中，数组是一个字符串。值得学习

a=>a+…

我们用的是一种新的方法

a

是累加器。在本例中，它是我们完成后要返回的最终结果字符串（您知道它是字符串，因为reduce函数的第二个参数initialValue是空字符串：

'

）。因此基本上：使用

p[~~（Math.random（）*p.length]转换数组中的每个元素

，将结果附加到

a

字符串，完成后给我

a

p
Array(myLength).fill(0).map(x => Math.random().toString(36).charAt(2)).join('')

var letters = {
  1: ["q","w","e","r","t","y","u","i","o","p","a","s","d","f","g","h","j","k","l","z","x","c","v","b","n","m"],
  2: ["Q","W","E","R","T","Y","U","I","O","P","A","S","D","F","G","H","J","K","L","Z","X","C","V","B","N","M"]
},i,letter,final="";
random = (max,min) => {
  return Math.floor(Math.random()*(max-min+1)+min);
}
function go(length) {
  final="",letter="";
  for (i=1; i<=length; i++){
    letter = letters[random(0,3)][random(0,25)];
    final+=letter;
  }
  return final;
}