在 javascript 中生成具有要求的随机密码字符串

强制使用固定数量的字符是 很糟糕的一个想法。它不会提高密码的质量。更糟糕的是，它减少了可能的密码数量，因此通过强制手段进行黑客攻击变得更加容易。

若要生成由字母数字字符组成的随机单词，请使用:

var randomstring = Math.random().toString(36).slice(-8);

它是怎么工作的？

Math.random()                        // Generate random number, eg: 0.123456
.toString(36)           // Convert  to base-36 : "0.4fzyo82mvyr"
.slice(-8);// Cut off last 8 characters : "yo82mvyr"

Number.prototype.toString和 string.prototype.slice方法的文档。

虽然还没有完全优化，但应该可以用。

var chars = "ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
var string_length = 8;
var randomstring = '';
var charCount = 0;
var numCount = 0;


for (var i=0; i<string_length; i++) {
// If random bit is 0, there are less than 3 digits already saved, and there are not already 5 characters saved, generate a numeric value.
if((Math.floor(Math.random() * 2) == 0) && numCount < 3 || charCount >= 5) {
var rnum = Math.floor(Math.random() * 10);
randomstring += rnum;
numCount += 1;
} else {
// If any of the above criteria fail, go ahead and generate an alpha character from the chars string
var rnum = Math.floor(Math.random() * chars.length);
randomstring += chars.substring(rnum,rnum+1);
charCount += 1;
}
}


alert(randomstring);

这里有一个 jsfiddle 供您测试: http://jsfiddle.net/sJGW4/3/

var letters = ['a','b','c','d','e','f','g','h','i','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'];
var numbers = [0,1,2,3,4,5,6,7,8,9];
var randomstring = '';


for(var i=0;i<5;i++){
var rlet = Math.floor(Math.random()*letters.length);
randomstring += letters[rlet];
}
for(var i=0;i<3;i++){
var rnum = Math.floor(Math.random()*numbers.length);
randomstring += numbers[rnum];
}
alert(randomstring);

我根据你的回答写了一小段:

(function(){g=function(){c='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';p='';for(i=0;i<8;i++){p+=c.charAt(Math.floor(Math.random()*62));}return p;};p=g();while(!/[A-Z]/.test(p)||!/[0-9]/.test(p)||!/[a-z]/.test(p)){p=g();}return p;})()

这个函数返回密码，可以在 bookmarklet 中使用，比如:

javascript:alert(TheCodeOfTheFunction);

一种更易于维护和安全的方法。

一个更新来扩展我的意思和它是如何工作的。

1. Secure . MDN 对于 使用 Math.random 任何与安全有关的东西非常明确:

   Math.random() 没有提供加密安全的随机数。不要将它们用于与安全相关的任何事情。改为使用 WebCryptoAPI，更确切地说，使用 window.crypto.getRandomValues()方法。

   看看2020年的 getRandomValues的能-我-用途，你可能不再需要 msCrypto和 Math.random了，除非你关心古老的浏览器。

2. 可维护的 主要是关于 RegExp _pattern，它是定义密码中允许的字符类的一种简单方法。但是还有3件事情是每个人都要做的: 定义一个模式，尽可能安全地获取一个随机字节，提供一个公共 API 来组合这两者。

var Password = {
 

_pattern : /[a-zA-Z0-9_\-\+\.]/,
  

  

_getRandomByte : function()
{
// http://caniuse.com/#feat=getrandomvalues
if(window.crypto && window.crypto.getRandomValues)
{
var result = new Uint8Array(1);
window.crypto.getRandomValues(result);
return result[0];
}
else if(window.msCrypto && window.msCrypto.getRandomValues)
{
var result = new Uint8Array(1);
window.msCrypto.getRandomValues(result);
return result[0];
}
else
{
return Math.floor(Math.random() * 256);
}
},
  

generate : function(length)
{
return Array.apply(null, {'length': length})
.map(function()
{
var result;
while(true)
{
result = String.fromCharCode(this._getRandomByte());
if(this._pattern.test(result))
{
return result;
}
}
}, this)
.join('');
}
    

};

<input type='text' id='p'/><br/>
<input type='button' value ='generate' onclick='document.getElementById("p").value = Password.generate(16)'>

最后，不使用浮点黑客:

function genpasswd(n) {
// 36 ** 11 > Number.MAX_SAFE_INTEGER
if (n > 10)
throw new Error('Too big n for this function');
var x = "0000000000" + Math.floor(Number.MAX_SAFE_INTEGER * Math.random()).toString(36);
return x.slice(-n);
}

我不建议使用强制密码，因为它限制了用户的安全性，但无论如何，有几种方法可以做到这一点-

传统 JavaScript 方法 -

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

使用随机字符串

安装随机字符串:

npm install randomstring

在 App.js-中使用它

var randStr = require('randomstring');


var yourString = randStr.generate(8);

密码的值保存在变量 yourString中。

不要使用强制密码！

强制密码可以损害您的安全，因为所有的密码将在同一个字符集，这可能很容易被破解！

许多答案(包括这个的原始答案)实际上并没有回答 OP 中的字母和数字要求。

下面是两种解决方案: 通用的(没有最小字母/数字) ，以及在 OP 中指定的规则。

更新12/2022再“安全”

许多其他的答案指责使用 Math.Random () ，然后继续使用一个更好的随机数生成器，这个生成器是非均匀应用的，最终结果是(就像使用 Math.Random!)不是加密安全的。不管怎么说，这个更新的地址是两个，我相信其他的答案都不会这样。

一般情况:

这种方法的优点:

• 它比接受/最高投票的答案更安全，也更通用，因为首先，它支持任何大小写敏感的字符(包括任何约150k (在撰写本文时) unicode 字符，而不仅仅是36个大小写不敏感的字母数字字符之一) ，其次，它使用一个安全的随机生成器 统一使用的
• 它比其他答案更简洁(一般情况下，最多3行; 可以是一行)(好吧，这取决于你眯着眼睛看一条“线”的程度)
• 它只使用本地 Javascript-不需要安装或其他库

请注意:

• 假设 crypt.getRRandom Value 和 Array.fill ()都可用

三线:

var pwdChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var pwdLen = 10;
var randPassword = new Array(pwdLen).fill(0).map(x => (function(chars) { let umax = Math.pow(2, 32), r = new Uint32Array(1), max = umax - (umax % chars.length); do { crypto.getRandomValues(r); } while(r[0] > max); return chars[r[0] % chars.length]; })(pwdChars)).join('');

或者，作为一句俏皮话:

var randPassword = new Array(10).fill("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz").map(x => (function(chars) { let umax = Math.pow(2, 32), r = new Uint32Array(1), max = umax - (umax % chars.length); do { crypto.getRandomValues(r); } while(r[0] > max); return chars[r[0] % chars.length]; })(x)).join('');

字母/数字规则

现在，上面的一个变体。这将从给定的字符集(字母、数字或者其中一个)生成三个随机字符串，然后扰乱结果。

首先，作为一种功能:

function randPassword(letters, numbers, either) {
var chars = [
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", // letters
"0123456789", // numbers
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" // either
];


function randInt(this_max) { // return int between 0 and this_max - 1
let umax = Math.pow(2, 32);
let max = umax - (umax % this_max);
let r = new Uint32Array(1);
do {
crypto.getRandomValues(r);
} while(r[0] > max);
return r[0] % this_max;
}


function randCharFrom(chars) {
return chars[randInt(chars.length)];
}


function shuffle(arr) { // https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm
for (let i = 0, n = arr.length; i < n - 2; i++) {
let j = randInt(n - i);
[arr[j], arr[i]] = [arr[i], arr[j]];
}
return arr;
}


return shuffle([letters, numbers, either].map(function(len, i) {
return Array(len).fill(chars[i]).map(x => randCharFrom(x)).join('');
}).concat().join('').split('')).join('')
}


// invoke like so: randPassword(5,3,2);

同样的事情，作为一个3线(嗯，更像是很多线粉碎成3线。不推荐，但有时候还是挺有趣的) :

var chars = ["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz","0123456789", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"];
function randInt(this_max) { let umax = Math.pow(2, 32); let max = umax - (umax % this_max); let r = new Uint32Array(1); do { crypto.getRandomValues(r); } while(r[0] > max); return r[0] % this_max; };


var randPassword = [[5,3,2].map(function(len, i) { return new Array(len).fill(chars[i]).map(x => (function(chars) { let umax = Math.pow(2, 32), r = new Uint32Array(1), max = umax - (umax % chars.length); do { crypto.getRandomValues(r); } while(r[0] > max); return chars[r[0] % chars.length]; })(x)).join(''); }).join('')].map(s => { let arr = s.split(''); for (let i = 0, n = arr.length; i < n - 2; i++) { let j = randInt(n - i); [arr[j], arr[i]] = [arr[i], arr[j]]; } return arr.join(''); })[0];

有一个选定长度的随机密码字符串生成器

let input = document.querySelector("textarea");
let button = document.querySelector("button");
let length = document.querySelector("input");


function generatePassword(n)
{
let pwd = "";


while(!pwd || pwd.length < n)
{
pwd += Math.random().toString(36).slice(-22);
}
  

return pwd.substring(0, n);
}


button.addEventListener("click", function()
{
input.value = generatePassword(length.value);
});

<div>password:</div>
<div><textarea cols="70" rows="10"></textarea></div>
<div>length:</div>
<div><input type="number" value="200"></div>
<br>
<button>gen</button>

如果你需要一个至少有1个数字，1个大写字母和1个小写字母的密码:

function generatePassword(passwordLength) {
var numberChars = "0123456789";
var upperChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var lowerChars = "abcdefghijklmnopqrstuvwxyz";
var allChars = numberChars + upperChars + lowerChars;
var randPasswordArray = Array(passwordLength);
randPasswordArray[0] = numberChars;
randPasswordArray[1] = upperChars;
randPasswordArray[2] = lowerChars;
randPasswordArray = randPasswordArray.fill(allChars, 3);
return shuffleArray(randPasswordArray.map(function(x) { return x[Math.floor(Math.random() * x.length)] })).join('');
}


function shuffleArray(array) {
for (var i = array.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
return array;
}


alert(generatePassword(12));

如果你想玩/测试: http://jsfiddle.net/sJGW4/155/，这是小提琴

支持@mwag 让我开始创建这个。

正如@RobW 所指出的，按照 OP 方案中的提议，将密码限制为固定数量的字符是 坏主意。但更糟糕的是，提出基于 Math.random的代码的答案是 真是个坏主意。

让我们从 坏主意开始。OP 代码是从一组62个字符中随机选择一个8个字符的字符串。将随机字符串限制为5个字母和3个数字意味着得到的密码将具有28.5位的熵(相对于取消5个字母和3个数字的分布限制后的47.6位的可能性)。这可不太好。但事实上，情况更糟。代码的 充其量方面被使用 Math.random作为产生密码熵的手段所破坏。Math.random是 伪随机数发生器伪随机数发生器。由于伪随机数生成器的确定性，得到的密码熵是 非常糟糕，使得任何这样的解决方案成为 真是个坏主意。假设这些密码是分发给最终用户的(这有什么意义) ，一个活跃的对手收到这样的密码，很有可能预测未来的密码分发给其他用户，这可能不是一件好事。

但回到刚才的 坏主意。假设使用加密强的伪随机数生成器代替 Math.random。你为什么要把密码限制在28.5位？如前所述，这不是很好。据推测，5个字母，3个数字方案是为了帮助用户管理随机分发的密码。但是让我们面对它，你必须平衡 易于使用和 value of use，并且28.5比特的熵对于防御一个活跃的对手没有太大的价值。

坏事说够了。让我们提出一条前进的道路。我将使用 JavaScript熵字符串库，它“有效地从各种字符集中生成具有指定熵的加密强随机字符串”。与 OP 62字符不同，我将使用一个包含32个字符的字符集，以减少易混淆字符的使用或英语单词的构成。而不是5个字母，3个数字方案(它有太少的熵) ，我将宣布密码将有60位的熵(这是轻松与价值的平衡)。

import { Entropy, charSet32 } from 'entropy-string'
const random = new Entropy({ bits: 60, charset: charset32 })
const string = random.string()

“ Q7LfR8Jn7RDp”

请注意，Entropy的参数指定所需的熵位，而不是更常见的随机字符串生成解决方案，后者指定传递一个字符串长度(这既有误导性，也通常没有指定，但那是另一回事)。

对于那些正在寻找一个最简单的脚本。没有 while (true)，没有 if/else，没有声明。

基于 mwag 的 回答但这个使用的是 crypto.getRandomValues比 Math.random更强的随机数。

var generatePassword = (
length = 20,
wishlist = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@-#$'
) =>
Array.from(crypto.getRandomValues(new Uint32Array(length)))
.map((x) => wishlist[x % wishlist.length])
.join('')


console.log(generatePassword())

书签

javascript:prompt("Random password:",((o=20,n="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@-#$")=>Array.from(crypto.getRandomValues(new Uint32Array(o))).map(o=>n[o%n.length]).join(""))())

Node.js

const crypto = require('crypto')


const generatePassword = (
length = 20,
wishlist = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@-#$'
) =>
Array.from(crypto.randomFillSync(new Uint32Array(length)))
.map((x) => wishlist[x % wishlist.length])
.join('')


console.log(generatePassword())

巨蟒

#!/usr/bin/env python


import os




def rand(length: int) -> str:
bytes = os.urandom(length)
chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-"
cl = len(chars)
rs = ''
for i in bytes:
rs += chars[i % cl]
return rs




print(rand(18))

去吧

见: https://stackoverflow.com/a/67035900/1099314

用一个大写字符保护密码。

let once = false;


let newPassword = Math.random().toString(36).substr(2, 8).split('').map((char) => {
if(!Number(char) && !once){
once = true;
return char.toUpperCase();
}
return char;
}).join('');


console.log(newPassword)

我的加密技术基于这个问题。使用 ES6并省略任何浏览器特性检查。对安全性或性能有何评论？

const generatePassword = (
passwordLength = 12,
passwordChars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
) =>
[...window.crypto.getRandomValues(new Uint32Array(passwordLength))]
.map(x => passwordChars[x % passwordChars.length])
.join('');

试试这个，很管用。

Enishant/Random _ password. js

将脚本下载到您的 javascript 应用程序并调用函数 随机密码()

你可以在最新版本的浏览器中使用 window.crypto 对象。

只需要一行代码就能得到一个随机数:

let n = window.crypto.getRandomValues(new Uint32Array(1))[0];

它还有助于加密和解密数据。 详情请浏览 MDN Web docs-window.crypto。

创建一个密码生成器服务，称为 Pass 覆盖生成器服务

import { Injectable } from '@angular/core';


@Injectable()
export class PasswordGeneratorService {


generatePassword(length:number,upper:boolean,numbers:boolean,symbols:boolean) {
const passwordLength = length || 12;
const addUpper =  upper;
const addNumbers =  numbers;
const addSymbols =  symbols;


const lowerCharacters = ['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'];
const upperCharacters = ['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'];
const numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
const symbols = ['!', '?', '@'];


const getRandom = array => array[Math.floor(Math.random() * array.length)];


let finalCharacters = '';


if (addUpper) {
finalCharacters = finalCharacters.concat(getRandom(upperCharacters));
}


if (addNumbers) {
finalCharacters = finalCharacters.concat(getRandom(numbers));
}


if (addSymbols) {
finalCharacters = finalCharacters.concat(getRandom(symbols));
}


for (let i = 1; i < passwordLength - 3; i++) {
finalCharacters = finalCharacters.concat(getRandom(lowerCharacters));
}


return  finalCharacters.split('').sort(() => 0.5 - Math.random()).join('');
}
}

不要忘记在您使用的模块上添加服务

@NgModule({
imports: [
CommonModule,
SharedModule,
CommonModule,
RouterModule.forChild(routes),
FormsModule,
ReactiveFormsModule,
FlexLayoutModule,
TranslateModule,
ExistingUserDialogModule,
UserDocumentsUploadDialogModule
],
declarations: [
UserListComponent,
EditUserDialogComponent,
UserEditorComponent
],
entryComponents: [
EditUserDialogComponent
],
providers: [
AuthService,
PasswordGeneratorService
]
})
export class UsersModule {
}

在您的控制器上添加一个方法，该方法在服务内调用 generatpassword 方法，并在 password 字段上设置结果

  constructor(
private passwordGenerator: PasswordGeneratorService,
)
get newPassword() {
return this.password.get('newPassword');
}
generatePassword() {
this.newPassword.setValue(this.passwordGenerator.generatePassword(8,true,true,true));
}

好的，如果我理解得很好，你试图得到一个随机字符串密码，它包含5个字母和3个随机位置的数字，所以它的长度是8个字符，你可以接受 maj 和 min 字母，你可以用下面的函数做到这一点:

function randPass(lettersLength,numbersLength) {
var j, x, i;
var result           = '';
var letters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
var numbers       = '0123456789';
for (i = 0; i < lettersLength; i++ ) {
result += letters.charAt(Math.floor(Math.random() * letters.length));
}
for (i = 0; i < numbersLength; i++ ) {
result += numbers.charAt(Math.floor(Math.random() * numbers.length));
}
result = result.split("");
for (i = result.length - 1; i > 0; i--) {
j = Math.floor(Math.random() * (i + 1));
x = result[i];
result[i] = result[j];
result[j] = x;
}
result = result.join("");
return result
}

function randPass(lettersLength,numbersLength) {
var j, x, i;
var result           = '';
var letters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
var numbers       = '0123456789';
for (i = 0; i < lettersLength; i++ ) {
result += letters.charAt(Math.floor(Math.random() * letters.length));
}
for (i = 0; i < numbersLength; i++ ) {
result += numbers.charAt(Math.floor(Math.random() * numbers.length));
}
result = result.split("");
for (i = result.length - 1; i > 0; i--) {
j = Math.floor(Math.random() * (i + 1));
x = result[i];
result[i] = result[j];
result[j] = x;
}
result = result.join("");
return result
}
console.log(randPass(5,3))

使用 Math.Random ()生成的任何密码都是 非常糟糕。

这个函数使用系统时间作为随机数生成器的种子。任何知道密码生成时间的人都可以很容易地强制输入密码。

在几乎所有情况下，这些数据都很容易获得——只需要在一个被破解的数据库中获取 register _ time 列，并使用15到0分钟前的时间测试由 Math.Random ()算法生成的所有值。

使用 Math.Random ()生成的密码完全没有价值 ，因为首次使用密码的时间足以破解它。

这里有一种方法可以创建一个灵活的生成器，允许您添加一些规则:

function generatePassword(length, rules) {
if (!length || length == undefined) {
length = 8;
}


if (!rules || rules == undefined) {
rules = [
{chars: "abcdefghijklmnopqrstuvwxyz", min: 3},  // As least 3 lowercase letters
{chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZ", min: 2},  // At least 2 uppercase letters
{chars: "0123456789", min: 2},                  // At least 2 digits
{chars: "!@#$&*?|%+-_./:;=()[]{}", min: 1}      // At least 1 special char
];
}


var allChars = "", allMin = 0;
rules.forEach(function(rule) {
allChars += rule.chars;
allMin += rule.min;
});
if (length < allMin) {
length = allMin;
}
rules.push({chars: allChars, min: length - allMin});
    

var pswd = "";
rules.forEach(function(rule) {
if (rule.min > 0) {
pswd += shuffleString(rule.chars, rule.min);
}
});
    

return shuffleString(pswd);
}


function shuffleString(str, maxlength) {
var shuffledString = str.split('').sort(function(){return 0.5-Math.random()}).join('');
if (maxlength > 0) {
shuffledString = shuffledString.substr(0, maxlength);
}
return shuffledString;
}


var pswd = generatePassword(15, [
{chars: "abcdefghijklmnopqrstuvwxyz", min: 4},  // As least 4 lowercase letters
{chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZ", min: 1},  // At least 1 uppercase letters
{chars: "0123456789", min: 3},                  // At least 3 digits
{chars: "!@#$&*?|%+-_./:;=()[]{}", min: 2}      // At least 2 special chars
]);


console.log(pswd, pswd.length);

基于以上@Ryan Shillington 的回答，你可能会发现这种增强也很有帮助。 认为这比上面问题中的原始请求中的请求更安全。

1. 生成的密码至少包含1个数字、1个大写字符、1个小写字符和1个特殊字符
2. 密码长度是动态的

//Password generated with at least 1 number, 1 upper case character, 1 lower case character and 1 Special character
function generatePassword()
{
var passwordLength = randomIntFromInterval(10,20);
var numberChars = "0123456789";
var upperChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var lowerChars = "abcdefghijklmnopqrstuvwxyz";
var specialChars = "~!#$%&*-+|";
var allChars = numberChars + upperChars + lowerChars + specialChars;
var randPasswordArray = Array(passwordLength);
randPasswordArray[0] = numberChars;
randPasswordArray[1] = upperChars;
randPasswordArray[2] = lowerChars;
randPasswordArray[3] = specialChars;
randPasswordArray = randPasswordArray.fill(allChars, 4);
if(window.crypto && window.crypto.getRandomValues)
{
return shuffleArray(randPasswordArray.map(function(x) { return x[Math.floor(window.crypto.getRandomValues(new Uint32Array(1))[0] / (0xffffffff + 1) * x.length)] })).join('');
}
else if(window.msCrypto && window.msCrypto.getRandomValues)
{
return shuffleArray(randPasswordArray.map(function(x) { return x[Math.floor(window.msCrypto.getRandomValues(new Uint32Array(1))[0] / (0xffffffff + 1) * x.length)] })).join('');
}else{
return shuffleArray(randPasswordArray.map(function(x) { return x[Math.floor(Math.random() * x.length)] })).join('');
}
      

}


function shuffleArray(array)
{
for (var i = array.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
     

return array;
}


//generate random number in the range (min and max included)
function randomIntFromInterval(min, max) {
return Math.floor(Math.random() * (max - min + 1) + min);
}

<input type='text' id='p9'/>
<input type='button' value ='pass generator' onclick='document.getElementById("p9").value = generatePassword()'>

生成一个长度为8到32个字符的随机密码，其中至少有1个小写、1个大写、1个数字、1个 spl char (！@ $&)

    function getRandomUpperCase() {
return String.fromCharCode( Math.floor( Math.random() * 26 ) + 65 );
}
    

function getRandomLowerCase() {
return String.fromCharCode( Math.floor( Math.random() * 26 ) + 97 );
}
    

function getRandomNumber() {
return String.fromCharCode( Math.floor( Math.random() * 10 ) + 48 );
}
    

function getRandomSymbol() {
// const symbol = '!@#$%^&*(){}[]=<>/,.|~?';
const symbol = '!@$&';
return symbol[ Math.floor( Math.random() * symbol.length ) ];
}
    

const randomFunc = [ getRandomUpperCase, getRandomLowerCase, getRandomNumber, getRandomSymbol ];
    

function getRandomFunc() {
return randomFunc[Math.floor( Math.random() * Object.keys(randomFunc).length)];
}
    

function generatePassword() {
let password = '';
const passwordLength = Math.random() * (32 - 8) + 8;
for( let i = 1; i <= passwordLength; i++ ) {
password += getRandomFunc()();
}
//check with regex
const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,32}$/
if( !password.match(regex) ) {
password = generatePassword();
}
return password;
}
    

console.log( generatePassword() );

你可以用乐达仕。

import * as _ from 'lodash';


export const generateCustomPassword = (
lowerCaseCount: number,
upperCaseCount: number,
numbersCount: number,
specialsCount: number,
) => {
const chars = 'abcdefghijklmnopqrstuvwxyz';
const numberChars = '0123456789';
const specialChars = '!"£$%^&*()-=+_?';
const pickedChars = _.sampleSize(chars, lowerCaseCount)
.concat(_.sampleSize(chars.toUpperCase(), upperCaseCount))
.concat(_.sampleSize(numberChars, numbersCount))
.concat(_.sampleSize(specialChars, specialsCount));
return _.shuffle(pickedChars).join('');
};




generateCustomPassword(4, 4, 4, 1)

使用这个 npm 包生成安全密码:

Npm 我生成-安全-密码

Https://www.npmjs.com/package/generate-secure-password

示例代码:

const generatePassword = require('generate-secure-password');
let yourPassword = generatePassword({
// None of the arguments are mandatory
length: 8,//not less than 4
numbers: false,//false if number needs to be excluded from password, else true
symbols: false,//false if symbols needs to be excluded from password, else true
lowercase: false,//false if lowercase character  needs to be excluded from password, else true
uppercase: false,//false if uppercase character needs to be excluded from password, else true
exclude: ['"','%'] //symbols to exclude, Pass it as an array
});
console.log(yourPassword)

这里的每个人都在使用 Math.random()也就是 加密不安全

使用这个代替使用 crypto API。

const crypto = require("crypto");


function generatePassword() {
return Array(12)
.fill("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
.map(function (x) {
return x[crypto.randomInt(0, 10_000) % x.length];
})
.join("");
}

编辑: 如果使用 crypto-browserfy，则需要使用 randomBytes方法。

const crypto = require("crypto");


function generatePassword() {
return Array(12)
.fill("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
.map(function (x) {
let int = crypto.randomBytes(4, function(ex, buf) {
var hex = buf.toString('hex');
var myInt32 = parseInt(hex, 16);
});
return x[int % x.length];
})
.join("");
}

从每个数组元素生成至少1个字符的密码

generatePassword(length:number){
let password ="";
const chars= [
"ABCDEFGHIJKLMNOPQRSTUVWXYZ",
"abcdefghijklmnopqrstuvwxyz",
"@$!%*?&",
"1234567890"
];
for(let j=0; j<chars.length; j++){
password += chars[j].charAt(Math.floor(Math.random() * chars[j].length));
}
if(length > chars.length){
length = length - chars.length;
for(let i=0; i<length; i++){
const index = Math.floor(Math.random() * chars.length);
password += chars[index].charAt(Math.floor(Math.random() * chars[index].length));
}
}
return  password.split('').sort(function(){return 0.5-Math.random()}).join('');
}

我写了这个函数，它应该可以在大多数情况下工作。

 function generatePassword(length, options) {
const optionsChars = {
digits: "1234567890",
lowercase: "abcdefghijklmnopqrstuvwxyz",
uppercase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
symbols: "@$!%&"
}
const chars = [];
for (let key in options) {
if (options.hasOwnProperty(key) && options[key] && optionsChars.hasOwnProperty(key)) {
chars.push(optionsChars[key]);
}
}


if (!chars.length)
return '';


let password = "";


for (let j = 0; j < chars.length; j++) {
password += chars[j].charAt(Math.floor(Math.random() * chars[j].length));
}
if (length > chars.length) {
length = length - chars.length;
for (let i = 0; i < length; i++) {
const index = Math.floor(Math.random() * chars.length);
password += chars[index].charAt(Math.floor(Math.random() * chars[index].length));
}
}


return password;
}


const password = generatePassword(9, {digits: true, lowercase: true, uppercase: true, symbols: true});


console.log(password)