我想要一个由字符集[a-zA-Z0-9]随机挑选的字符组成的5个字符的字符串。
使用JavaScript执行此操作的最佳方法是什么？
答案 0 :(得分：2057)
let r = Math.random().toString(36).substring(7);
console.log("random", r);
注意：上述算法有以下缺点：
Math.random()可能会产生可预测的（“随机查看”但不是真正随机的）输出，具体取决于实现方式。当您需要保证唯一性或不可预测性时，生成的字符串不适用。答案 1 :(得分：1999)
我认为这对你有用：
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 :(得分：333)
Math.random is bad for this kind of thing
选项1
如果您能够执行 server -side，只需使用crypto模块 -
var crypto = require("crypto");
var id = crypto.randomBytes(20).toString('hex');
// "bb5dc8842ca31d4603d6aa11448d1654"
结果字符串的长度是您生成的随机字节的两倍;编码为十六进制的每个字节为2个字符。 20个字节将是40个十六进制字符。
选项2
如果您必须执行 client -side，也许可以尝试使用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"
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
答案 3 :(得分：152)
返回5个随机字符，而不是此处找到的一些最高评价答案。
Math.random().toString(36).substr(2, 5);
答案 4 :(得分：143)
以下是doubletap's excellent answer的改进。原件有两个缺点，在这里解决：
首先，正如其他人所提到的，它产生短字符串甚至空字符串的可能性很小（如果随机数为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)
说明：
进一步的想法：
<强>更新
以下是我提出的其他几种功能风格的单行。它们与上述解决方案的不同之处在于：
所以，说你选择的字母是
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'以减少几个字节。
答案 5 :(得分：90)
这样的事情应该有效
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');
答案 6 :(得分：67)
最紧凑的解决方案，因为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));
答案 7 :(得分：67)
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));
答案 8 :(得分：46)
/**
* 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 demo
虽然上面使用了对所需（A / N，A，N）输出的附加检查， 让我们将其分解为必需品（仅限Alpha-Numeric）以便更好地理解：
var str = "";，以连接随机字符rand索引号（0..9 + A..Z + a..z = 62 ）rand （因为它是0..61）将其递增一些数字（参见下面的示例）以获取返回正确的CharCode号码和相关的角色。str和String.fromCharCode( incremented rand ) 让我们看一下角色表及其范围：
_____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 |
上表中的conditional operation逻辑：
rand += rand>9 ? ( rand<36 ? 55 : 61 ) : 48 ;
// rand += true ? ( true ? 55 else 61 ) else 48 ;
如果您按照上述说明操作，则应该可以创建字母数字代码：
<强> jsBin demo
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"
<强> Or if you will:
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;
}
答案 9 :(得分：30)
最简单的方法是：
(new Date%9e6).toString(36)
根据当前时间生成5个字符的随机字符串。示例输出为4mtxj或4mv90或4mwp1
这个问题是，如果你在同一秒钟上调用它两次，它将生成相同的字符串。
更安全的方式是：
(0|Math.random()*9e6).toString(36)
这将生成一个4或5个字符的随机字符串，总是不同的。示例输出类似于30jzm或1r591或4su1a
第一部分以两种方式生成随机数。 .toString(36)部分将数字转换为它的base36（alphadecimal）表示。
答案 10 :(得分：20)
这里有一些简单的衬里。更改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"]();});
答案 11 :(得分：17)
我知道每个人都已经把它弄好了，但是我觉得可以用最轻量级的方式去做这个（点亮代码，而不是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的语法是多么棒。
答案 12 :(得分：16)
如果您使用的是Lodash或Underscore，那么就这么简单：
var randomVal = _.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5).join('');
答案 13 :(得分：13)
这是我创建的方法 它将创建一个包含大写和小写字符的字符串 此外，我还包括了将创建字母数字字符串的函数。
工作示例：
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)));
}
答案 14 :(得分：12)
假设您使用underscorejs，可以在两行中优雅地生成随机字符串：
var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var random = _.sample(possible, 5).join('');
答案 15 :(得分：12)
一个班轮：
Array(15).fill(null).map(() => Math.random().toString(36).substr(2)).join('')
// Outputs: 0h61cbpw96y83qtnunwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil
答案 16 :(得分：11)
如果有人对单线程感兴趣（虽然为了方便起见没有格式化），一次分配内存（但请注意，对于小字符串，它确实没关系）这里是如何做到的：< / p>
Array.apply(0, Array(5)).map(function() {
return (function(charset){
return charset.charAt(Math.floor(Math.random() * charset.length))
}('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'));
}).join('')
您可以将5替换为所需字符串的长度。感谢this post中的@AriyaHidayat，map函数的解决方案无法处理由Array(5)创建的稀疏数组。
答案 17 :(得分：11)
为满足要求[a-zA-Z0-9]和长度= 5，请使用
btoa(Math.random()).substr(5, 5);
将出现小写字母，大写字母和数字。
答案 18 :(得分：10)
生成安全的随机字母数字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"
答案 19 :(得分：8)
快速改进的算法。不保证统一（见评论）。
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;
}
答案 20 :(得分：7)
你可以遍历一个项目数组，并递归地将它们添加到一个字符串变量中，例如，如果你想要一个随机的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));
答案 21 :(得分：7)
改进了@Andrew的上述回答：
Array.from({ length : 1 }, () => Math.random().toString(36)[2]).join('');
随机数的基数36转换不一致，因此选择单个索引即可解决该问题。您可以使用所需的确切长度更改字符串的长度。
答案 22 :(得分：6)
我没有找到支持小写和大写字符的干净解决方案。
仅小写支持：
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)以调整为您需要的长度。
答案 23 :(得分：6)
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。
答案 24 :(得分：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>
答案 25 :(得分：5)
回复“我需要随机字符串”问题（无论用哪种语言）的问题实际上每个解决方案都使用字符串长度的有缺陷的主要规范。问题本身很少揭示为什么需要随机字符串，但我会挑战你很少需要随机字符串长度，比如8.你总是需要的是一些唯一字符串，例如，使用作为某种用途的标识符。
有两种主要方法可以获得严格唯一的字符串：确定性（非随机）和存储/比较（这是繁重的）。我们做什么？我们放弃鬼魂。我们改为使用概率唯一性。也就是说，我们接受存在一些（但是很小的）风险，即我们的字符串不会是唯一的。这是理解collision probability和entropy有用的地方。
所以我会将不变的需求重新描述为需要一些具有较小重复风险的字符串。举一个具体的例子，假设你想要产生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”
请注意由于所用字符集中字符总数的不同而导致字符串长度的差异。指定数量的潜在字符串中重复的风险是相同的。字符串长度不是。最重要的是，重复的风险和潜在的字符串数量是明确的。不再猜测字符串长度。
答案 26 :(得分：4)
您可以使用coderain。它是根据给定模式生成随机码的库。使用#作为大写和小写字符以及数字的占位符：
var cr = new CodeRain("#####");
console.log(cr.next());
还有其他占位符，例如A代表大写字母，9代表数字。
可能有用的是，调用.next()将始终为您提供独特的结果，因此您不必担心重复。
以下是generates a list of unique random codes。
的演示应用程序完全披露：我是coderain的作者。
答案 27 :(得分：4)
这样的事情：Date.now().toString(36)
每次调用它时都不是很随机，但很短且非常独特。
答案 28 :(得分：4)
这个小巧的小技巧怎么样？
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('');
答案 29 :(得分：4)
生成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;
}
答案 30 :(得分：3)
如果你只想要 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('')
}
答案 31 :(得分：3)
一行 [a-z]：
String.fromCharCode(97 + Math.floor(Math.random() * 26))
答案 32 :(得分：3)
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
答案 33 :(得分：3)
这是＃1答案的测试脚本（谢谢@ csharptest.net）
该脚本运行makeid() 1 million次，正如您所看到的那样，5并非独一无二。以char长度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');
答案 34 :(得分：2)
这个结合了许多答案。
CurrentView
我已经使用它1个月，效果很好。
答案 35 :(得分：2)
使用 map 的单行，可让您完全控制长度和字符。
const rnd = (len, chars='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') => [...Array(len)].map(() => chars.charAt(Math.floor(Math.random() * chars.length))).join('')
console.log(rnd(12))
答案 36 :(得分：2)
下面如何处理……这将产生真正的随机值：
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);
答案 37 :(得分：2)
通过回答Gertas和Dragon提出的问题，扩展Doubletap的优雅范例。只需添加一个while循环来测试那些罕见的null情况，并将字符限制为五。
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/
答案 38 :(得分：2)
如果图书馆有可能，Chance.js可能会有所帮助：http://chancejs.com/#string
答案 39 :(得分：2)
这就是我用的。一对夫妇在这里的组合。我在循环中使用它，它生成的每个ID都是唯一的。它可能不是5个字符，但它保证唯一。
var newId =
"randomid_" +
(Math.random() / +new Date()).toString(36).replace(/[^a-z]+/g, '');
答案 40 :(得分：1)
如果你在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('');
答案 41 :(得分：1)
以下代码将使用npm软件包 Q1 Q2 Q3 Q4 Q5
0 0.625 6.875 6.25 19.375 38.125
1 1.250 7.500 12.50 20.000 38.750
2 1.875 8.125 18.75 20.625 39.375
生成包含[a-zA-Z0-9]的加密安全随机字符串，其大小为crypto-random-string。使用以下命令安装它：
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
答案 42 :(得分：1)
这是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的数字具有足够的数字。答案 43 :(得分：1)
这会在变量c中存储5个字母数字字符。
for(var c = ''; c.length < 5;) c += Math.random().toString(36).substr(2, 1)
答案 44 :(得分：1)
对于具有大写和小写字母和数字（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 case
rdm62 = 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个字节（由于字符列表）。
答案 45 :(得分：1)
生成任意数量的十六进制字符（例如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);
答案 46 :(得分：1)
如何像这样扩展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));
答案 47 :(得分：1)
此方法将返回一个随机字符串，其中包含任何支持的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。
答案 48 :(得分：1)
[..."abcdefghijklmnopqrsuvwxyz0123456789"].map((e, i, a) => a[Math.floor(Math.random() * a.length)]).join('')
答案 49 :(得分：1)
我喜欢doubletap的Math.random（）。toString（36）.substring（7）回答，但并不是说它有如hacklikecrack正确指出的那么多碰撞。它生成了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);
答案 50 :(得分：1)
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)
}
答案 51 :(得分：1)
",,,,,".replace(/,/g,function (){return "AzByC0xDwEv9FuGt8HsIrJ7qKpLo6MnNmO5lPkQj4RiShT3gUfVe2WdXcY1bZa".charAt(Math.floor(Math.random()*62))});
答案 52 :(得分：1)
程序员用激光切纸，而不是电锯。使用边缘，语言特定的方法来生成最小，最混淆的代码是可爱的，但都不会提供完整的解决方案。您必须使用正确的工具来完成工作。
你想要的是一串字符，字符用字节表示。而且，我们可以使用数字在JavaScript中表示一个字节。那么，我们应该生成这些数字的列表，并将它们转换为字符串。您不需要Date或base64; Math.random（）会得到一个数字，而String.fromCharCode（）会把它变成一个字符串。容易。
但是，哪个数字等于哪个角色？ UTF-8是Web上用于将字节解释为字符的主要标准（尽管JavaScript在内部使用UTF-16，但它们重叠）。程序员解决这个问题的方法是查看文档。
UTF-8列出键盘上的所有键，数字介于0和128之间。有些是非打印键。只需在随机字符串中挑选出您想要的字符，然后使用随机生成的数字搜索它们。
Bellow是一个几乎无限长度的函数，在循环中生成一个随机数，并搜索较低128 UTF-8代码中的所有打印字符。熵是固有的，因为不是每次都会出现所有随机数（非打印字符，空格等）。当你添加更多字符时，它也会表现得更快。
我已经包含了线程中讨论的大多数优化：
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）。
有时，降低抽象级别是创建真正解决方案所需要的。了解手头的基本原理可以让您根据自己的喜好自定义代码。也许你想要一个无限生成的字符串来填充循环缓冲区？也许你想要所有生成的字符串都是回文？为什么要退缩？
答案 53 :(得分：1)
同样基于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);
}
答案 54 :(得分：1)
这是一种基于固定长度的不同方法，没有RegExp替换缺乏（基于@ bendytree的答案）;
function rand(base) {
// default base 10
base = (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('');
}
答案 55 :(得分：1)
"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('');};
将生成一个随机字母数字字符串，其长度为第一个/调用字符串
答案 56 :(得分：1)
随机数值（最多16位）
/**
* Random numeric value (up to 16 digits)
* @returns {String}
*/
function randomUid () {
return String(Math.floor(Math.random() * 9e15))
}
// randomUid() -> "3676724552601324"
答案 57 :(得分：0)
另一种从字符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;
}
答案 58 :(得分：0)
如果您想获取符合您要求的crypto-strong字符串（我看到使用此字符串的答案，但给出无效答案），请使用
let pass = [...crypto.getRandomValues(new Uint8Array(5))]
.map((x,i)=>(i=x/255*61|0,String.fromCharCode(i+(i>9?i>35?61:55:48)))).join``
let pass = [...crypto.getRandomValues(new Uint8Array(5))]
.map((x,i)=>(i=x/255*61|0,String.fromCharCode(i+(i>9?i>35?61:55:48)))).join``
console.log(pass);
答案 59 :(得分：0)
许多答案都基于技巧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)
这里是“生成器”，可以手动查找此类数字
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，所以我不会在这里提出其他解决方案
答案 60 :(得分：0)
以上所有答案都是完美的。但我要补充一点，它非常好且快速，可以生成任何随机字符串值
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
答案 61 :(得分：0)
如果无法键入字符集，请使用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))
答案 62 :(得分：0)
喜欢这个 SO 问题和他们的回答。因此提出了更加灵活和创造性的解决方案。我想出了一个包裹在 函数 中的我的，该函数接收您想要获取的字符串的长度 加上一个 mode 参数来决定如何你希望它是组成的。
Mode 是一个长度为 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:#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) 无法做到的额外代码。
答案 63 :(得分：0)
您可以使用base64：
function randomString(length)
{
var rtn = "";
do {
rtn += btoa("" + Math.floor(Math.random() * 100000)).substring(0, length);
}
while(rtn.length < length);
return rtn;
}
答案 64 :(得分：0)
我使用var randId = 'rand' + new Date().getTime();
答案 65 :(得分：0)
在下面的代码我生成8个字符的随机代码
<infinite-loading :on-infinite="onInfinite" spinner="spiral" ref="infiniteLoading">
<span slot="no-more"></span>
</infinite-loading>
import InfiniteLoading from 'vue-infinite-loading';
export default {
data: function(){
return {
leagueLeaders: [],
playerStats: [],
pagination: 1,
}
},
methods: {
components: {
InfiniteLoading,
},
onInfinite() {
let self = this;
axios.get(config.NBLAPI + config.API.PLAYERSTATS2, {
params: {
page: self.pagination,
}
}).then( (response) => {
let data = response.data.data;
let lastpage = response.data.last_page;
if ( response.status == 200 && data.length > 0) {
self.leagueLeaders = self.leagueLeaders.concat(data);
self.$refs.infiniteLoading.$emit('$InfiniteLoading:loaded');
if(self.pagination <= lastpage){
self.pagination += 1;
}
}
else {
self.$refs.infiniteLoading.$emit('$InfiniteLoading:complete');
}
});
},
},
mounted: function() {
}
}
答案 66 :(得分：0)
试试这个，我每次都用的是：
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>
答案 67 :(得分：0)
非常简单
function getRandomColor(){
var color='';
while(color.length<6){
color=Math.floor(Math.random()*16777215).toString(16);
}
return '#'+color;
}
答案 68 :(得分：0)
功能性方法。这个答案只有实用如果可以在应用程序的其他部分利用功能先决条件。表演可能是垃圾，但写作非常有趣。
// functional prerequisites
const 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 -> String
const idGenerator = srand ([
range (48) (57), // include 0-9
range (65) (90), // include A-Z
range (97) (122) // include a-z
])
console.log (idGenerator (6)) //=> TT688X
console.log (idGenerator (10)) //=> SzaaUBlpI1
console.log (idGenerator (20)) //=> eYAaWhsfvLDhIBID1xRh
在我看来，如果不添加神奇的，多功能的功能，很难超越idGenerator的清晰度。
略有改善可能
// ord : convert char to ascii code
// Char -> Number
const ord = x => x.charCodeAt(0)
// idGenerator : make an identifier of specified length
// Number -> String
const idGenerator = srand ([
range (ord('0')) (ord('9')),
range (ord('A')) (ord('Z')),
range (ord('a')) (ord('z'))
])
玩得开心。让我知道你喜欢什么/学习^ _ ^
答案 69 :(得分：0)
这适用于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 )
答案 70 :(得分：0)
我制作了一个String原型，可以生成一个给定长度的随机字符串。
如果你想要特殊的字符，你也可以隐藏，你可以避免一些。
/**
* 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');
希望它有所帮助。
答案 71 :(得分：0)
简单方法：
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”更改为其他内容。
答案 72 :(得分：0)
递归解决方案：
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")
答案 73 :(得分：0)
正如这里的几个人所指出的那样，将Math.random()的结果直接传递到.string(36)有几个问题。
随机性差。生成的字符数各不相同，平均而言，取决于Java语言中浮点数如何工作的棘手细节。如果我尝试生成11个字符或更少的字符，但不能超过11个字符，这似乎可行，并且它不灵活。没有简单的方法来允许或禁止某些字符。
对于使用lodash的任何人，我都有一个紧凑的解决方案，它没有这些问题：
_.range(11).map(i => _.sample("abcdefghijklmnopqrstuvwxyz0123456789")).join('')
如果要允许某些字符（例如大写字母）或禁止某些字符（例如模糊字符，例如l和1），请修改上面的字符串。
答案 74 :(得分：0)
npm模块anyid提供灵活的API来生成各种字符串ID /代码。
const id = anyid().encode('Aa0').length(5).random().id();
答案 75 :(得分：0)
这是我的方法（使用TypeScript）。
我决定再写一个答复，因为我没有看到使用现代js和干净代码的简单解决方案。
const DEFAULT_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
function getRandomCharFromAlphabet(alphabet: string) {
return alphabet.charAt(Math.floor(Math.random() * alphabet.length));
}
function generateId(idDesiredLength: number, alphabet = DEFAULT_ALPHABET) {
/**
* Create n-long array and map it to random chars from given alphabet.
* Then join individual chars as string
*/
Array.from({length: idDesiredLength}).map(() => {
return getRandomCharFromAlphabet(alphabet);
}).join('');
}
generateId(5); // jNVv7
答案 76 :(得分：0)
我只是编写了一个简单的程序包，以生成具有给定大小，种子和掩码的随机令牌。仅供参考。
dgoss master has been installed to /usr/local/bin/dgoss
$ ls -la /usr/local/bin/ | grep goss
-rwxr-xr-x 1 root root 3803 May 17 08:58 dgoss
-rwxr-xr-x 1 root root 8524064 May 17 08:58 goss
$ which dgoss
/usr/local/bin/dgoss
$ python3 ./infrastructure/build.py
infrastructure/broker
b'/usr/local/bin/dgoss\n'
Traceback (most recent call last):
File "./infrastructure/build.py", line 54, in <module>
test()
File "./infrastructure/build.py", line 42, in test
result = str(check_output(["dgoss", "run", image_tag], cwd=image_path, stderr=subprocess.DEVNULL))
File "/usr/lib/python3.6/subprocess.py", line 356, in check_output
**kwargs).stdout
File "/usr/lib/python3.6/subprocess.py", line 423, in run
with Popen(*popenargs, **kwargs) as process:
File "/usr/lib/python3.6/subprocess.py", line 729, in __init__
restore_signals, start_new_session)
File "/usr/lib/python3.6/subprocess.py", line 1364, in _execute_child
raise child_exception_type(errno_num, err_msg, err_filename)
FileNotFoundError: [Errno 2] No such file or directory: 'dgoss': 'dgoss'
-https://www.npmjs.com/package/@sibevin/random-token
@sibevin/random-token答案 77 :(得分：0)
const c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
const s = Array.from({length:5}, _ => c[Math.floor(Math.random()*c.length)]).join('')
答案 78 :(得分：-1)
这不是一个完美的解决方案，但它应该有效。如果您遇到任何错误，请增加 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);答案 79 :(得分：-1)
//创建一个长度为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)
答案 80 :(得分：-2)
以下是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)
答案 81 :(得分：-3)
这里的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