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

程序员文章站 2022-05-29 15:37:59

...

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

用JavaScript做到这一点的最佳方法是什么？

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

#2楼

这样的事情应该工作

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

#3楼

 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); //AZ return String.fromCharCode(n + 61); //az } while (s.length < L) s += randomchar(); return s; } console.log(randomstring(5));

#4楼

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也很快。

#5楼

生成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;
}

#6楼

如果有人对一次性分配内存（虽然为了方便起见而没有格式化）感兴趣（但请注意，对于小字符串，这实际上没关系），这是如何做的：

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)创建的稀疏数组map运行的解决方案。

#7楼

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

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

#8楼

这肯定可以工作

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

#9楼

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

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

#10楼

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

说明：

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

进一步的想法：

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

更新：

这是我想到的其他几个功能样式的单线纸。它们与上述解决方案的不同之处在于：

他们使用一个明确的任意字母（更通用，并且适用于要求同时使用大写和小写字母的原始问题）。
所有长度为N的字符串都有相等的返回概率（即字符串不包含重复）。
它们基于映射函数，而不是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提出了与后者类似的解决方案（赞！），我以某种方式错过了。由于它们看起来不那么短，所以我还是把它留在这里，以防有人真的想要单线:-)

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

#11楼

这是一些简单的衬板。更改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"]();});

#12楼

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

该脚本运行makeid() 1 million次，并且您可以看到5 makeid()非常独特的。以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 = 0
for (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');

#13楼

Math.random对这种事情不利

选项1

如果您能够在服务器端执行此操作，则只需使用crypto模块-

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 // ie 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"

有关crypto.getRandomValues更多信息-

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

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

> var arr = new Uint8Array(4) # make array of 4 bytes (values 0-255)
> arr
Uint8Array(4) [ 0, 0, 0, 0 ]

> window.crypto
Crypto { 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

#14楼

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

/**
 * RANDOM STRING GENERATOR
 *
 * Info:      http://*.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）输出使用了额外的检查，但是为了更好地理解 ， 我们将其分解为基本内容（仅字母数字）。

创建一个接受参数的函数（随机String结果的期望长度）
创建一个空字符串，如var str = ""; 连接随机字符
在循环内创建从0到61 的rand索引号 （0..9 + A..Z + a..z = 62）
创建一个条件逻辑来调整/固定rand （因为它是0..61），将其递增某个数字（请参见下面的示例），以获取正确的CharCode号和相关的Character。
在循环内连接一个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;
}

#15楼

最简单的方法是：

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

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

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

比较安全的方法是：

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

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

无论哪种方式，第一部分都会生成一个随机数。 .toString(36)部分将数字转换为它的base36（字母十进制）表示形式。

#16楼

假设您使用underscorejs，则可以仅在两行中优雅地生成随机字符串：

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

#17楼

最紧凑的解决方案，因为slice比substring短。从字符串的末尾减去可以避免由random函数生成的浮点符号：

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

甚至

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

更新：添加了另一种使用btoa方法的方法：

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

#18楼

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

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

#19楼

简短，简单且可靠

返回恰好5个随机字符，与此处找到的一些评价最高的答案相反。

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

#20楼

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

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

#21楼

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

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

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

可能有用的是，调用.next()总是会给您带来独特的结果，因此您不必担心重复。

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

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

#22楼

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

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

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

这就是像EntropyString这样的库可以提供帮助的地方。使用entropy-string在500万个字符串中重复概率小于1万亿的随机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)

“ 27b33372ade513715481f”

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

#23楼

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

#24楼

带有es6 传播算子的较新版本：

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

30是任意数字，您可以选择所需的任何令牌长度
36是您可以传递给numeric.toString（）的最大基数，表示所有数字和小写字母az
2用于从如下所示的随机字符串中选择第二个数字： "0.mfbiohx64i" ，我们可以在0.之后获取任何索引0.

#25楼

我找不到同时支持小写和大写字符的干净解决方案。

仅支持小写字母：

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)调整到你需要的长度。

#26楼

为了满足要求[a-zA-Z0-9]并且长度= 5，请使用

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

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

#27楼

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

 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

#28楼

我知道每个人都已经做好了，但是我想尽可能以最轻便的方式（轻巧的代码而不是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的语法多么出色。

#29楼

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

注意：以上算法具有以下缺点：

由于在对浮点进行字符串化时会删除尾随零，因此它将生成0到6个字符之间的任意位置。
这在很大程度上取决于用于对浮点数进行字符串化的算法，该算法极其复杂。（请参阅论文“如何准确打印浮点数” 。）
Math.random()可能会产生可预测的（“看起来很随机”，但不是真正随机的）输出。当您需要保证唯一性或不可预测性时，结果字符串不适合。
即使它产生了6个均匀随机且不可预测的字符，由于生日悖论，您也可以期望仅生成大约50,000个字符串后看到重复项。（sqrt（36 ^ 6）= 46656）

#30楼

您可以遍历一系列项并将其递归地添加到字符串变量中，例如，如果您需要随机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));

上一篇： js 判断字符串中是否包含某个字符串

下一篇： C++，string怎样判断字符串里面是否含有某个字符串？