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

【问题标题】：Generate random password string with requirements in javascript在javascript中生成具有要求的随机密码字符串
【发布时间】：2012-03-31 22:50:15
【问题描述】：

我想生成一个随机字符串，该字符串必须包含 5 个 a-z 字母和 3 个数字。

如何使用 JavaScript 做到这一点？

我有以下脚本，但它不符合我的要求。

        var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        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);
        }

【问题讨论】：

如果它符合您的要求，那还有什么问题呢？此外，您的强制密码要求是一个坏主意。
xkcd.com/936
new Array(12).fill().map(() => String.fromCharCode(Math.random()*86+40)).join("") 漂亮的一行以非常轻量级的方式生成一个 12 字符的密码，其中包含特殊字符的上下数字
@RobW 为什么这是个坏主意？请解释一下！

标签： javascript random

【解决方案1】：

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

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

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 方法的文档。

【讨论】：

我同意，但有时你无法决定;)
DO NOT USE THIS：由于数字是从二进制转换为十进制的，并且没有足够的位来“填满”整个十进制空间，因此只能从某个集合中选择最后一位的价值观。例如，在我的电脑上，最后一位数字只有“i”、“r”和“9”。改用这个：Math.random().toString(36).substr(2, 8)
解释 36 的作用：来自mozilla toString() 方法解析其第一个参数，并尝试返回指定基数（基数）的字符串表示形式。对于大于 10 的基数，字母表中的字母表示大于 9 的数字。例如，对于十六进制数（以 16 为基数），使用 a 到 f。所以根据这个，使用基数 36，我们得到 az 之后0-9.
@ShishirGupta .toString 只接受不超过 36 的基数。这个答案是作为非加密随机字符串的单线。如果您也想使用大写字母，请使用Math.random（或crypto.getRandomValues，如果可用）并将结果映射到a-z、A-Z、0-9。例如在下面使用 saaj 的答案。
没有看到这如何满足 OP 要求“5 个字母从 a-z 和 3 个数字”。我明白了，作者认为这是个坏主意……但这仍然是要求

【解决方案2】：

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

更新以扩展我的意思及其工作原理。

安全。 MDN 对the use of Math.random 非常明确任何与安全相关的事情：

Math.random() 不提供密码安全的随机数。不要将它们用于与安全相关的任何事情。请改用 Web Crypto API，更准确地说是 window.crypto.getRandomValues() 方法。

看看 2020 年的 the can-i-use for getRandomValues，你可能不再需要 msCrypto 和 Math.random 后备，除非你关心古老的浏览器。
可维护主要是关于 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)'>

【讨论】：

此外，这并不总是在生成的代码中添加一个数字，并且 OP 需要至少 3 个。
找到了一个支持window.crypto.getRandomValues并且在node.js中也能工作的库github.com/bermi/password-generator
只是想说我需要一些东西来在紧要关头生成密码，这很完美。谢谢！
似乎每个回答的人都随机输入了密码，哈哈。如果调整后的升位实际上可以更匹配问题，则您的非常接近，将_pattern更改为_charset，实际上，添加_pattern匹配以确定条件playcode.io/774196

【解决方案3】：

许多答案（包括这个答案的原件）没有解决 OP 的字母和数字计数要求。以下是两种解决方案：通用（无最小字母/数字）和有规则。

一般：

我相信这是比上述更好的通用解决方案，因为：

它比接受/最高投票的答案更安全，也更通用，因为它以区分大小写的方式支持任何字符集
比其他答案更简洁（对于一般解决方案，最多 3 行；可以是单行）
它仅使用本机 Javascript - 无需安装或其他库

注意

要在 IE 上工作，Array.fill() 原型必须是 polyfilled
如果可用，最好使用 window.crypto.getRandomValues() 而不是 Math.random()（感谢 @BenjaminH 指出）

三线：

var pwdChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var pwdLen = 10;
var randPassword = Array(pwdLen).fill(pwdChars).map(function(x) { return x[Math.floor(Math.random() * x.length)] }).join('');

或者，作为单行：

var randPassword = Array(10).fill("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz").map(function(x) { return x[Math.floor(Math.random() * x.length)] }).join('');

带字母/数字规则

现在，上面的变体。这将从给定的字符集（字母、数字等）生成三个随机字符串，然后对结果进行打乱。

请注意，以下使用 sort() 仅用于说明目的。对于生产用途，请将以下 sort() 函数替换为 shuffle 函数，例如 Durstenfeld。

首先，作为一个函数：

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

  return [letters, numbers, either].map(function(len, i) {
    return Array(len).fill(chars[i]).map(function(x) {
      return x[Math.floor(Math.random() * x.length)];
    }).join('');
  }).concat().join('').split('').sort(function(){
    return 0.5-Math.random();
  }).join('')
}

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

同样的事情，作为 2-liner（诚然，非常长且丑陋的线条 - 如果您使用适当的随机播放功能，就不会是 1-liner。不推荐，但有时它仍然很有趣）：

var chars = ["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz","0123456789", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"];
var randPwd = [5,3,2].map(function(len, i) { return Array(len).fill(chars[i]).map(function(x) { return x[Math.floor(Math.random() * x.length)] }).join('') }).concat().join('').split('').sort(function(){return 0.5-Math.random()}).join('');

【讨论】：

很好的答案，但大写字母 Y 永远不会出现在您生成的任何密码中。
谢谢。我在 OP 问题中使用了字符集，但看起来它有缺陷。现已更新。
您说“它比接受/最高投票的答案更安全”。能否详细说明原因？
Math.random() 的使用也是可以预测的。因此，为了生成密码，最好使用 window.crypto.getRandomValues 之类的函数。
它更安全的原因是因为它支持的输出中可能的字符数量比使用 toString(36) 更多。对于固定的输出长度（例如 8 个），如果您最多有 36 个字符可供选择，那么您的排列比如果您有 62 个字符（如示例中）或更好的是，整个 95 个可打印（ascii ) 字符，或者如果使用 unicode，则每个字节的可能性更大。

【解决方案4】：

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

基于mwag的answer，但是这个使用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())

Python

#!/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

【讨论】：

由于未定义的偏移量，这不会始终提供 20 个长度的密码。 + 1 部分不是必需的，可以删除。
好消息@bryc。更新。谢谢。
有用且简单的解决方案。任何希望在 NodeJS 中执行此操作的人都可以简单地将 crypto.getRandomValues 替换为 crypto.randomFillSync。
添加了 Node.js 版本。谢谢@Rvy Pandey。

【解决方案5】：

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

让我们从坏主意开始。 OP 代码是从一组 62 个字符中随机选择一个包含 8 个字符的字符串。将随机字符串限制为 5 个字母和 3 个数字意味着生成的密码将具有，充其量 , 28.5 位的熵（如果去除 5 个字母和 3 个数字的分布限制，则可能是 47.6 位）。那不是很好。但实际上，情况更糟。代码的充其量方面被使用Math.random 作为为密码生成熵的手段而被破坏。 Math.random 是一个伪随机数生成器。由于伪随机数生成器的确定性，生成的密码的熵非常糟糕，使得任何此类提议的解决方案都成为非常糟糕的主意 .假设这些密码被分发给最终用户（o/w 有什么意义），收到这样一个密码的活跃对手很有可能预测未来分发给其他用户的密码，这可能不是一件好事。

但回到刚才的坏主意。假设使用加密强伪随机数生成器而不是Math.random。为什么要将密码限制为 28.5 位？如前所述，这不是很好。大概5个字母，3个数字的方案是为了帮助用户管理随机发放的密码。但让我们面对现实吧，您必须在 易用性 与 使用价值 之间取得平衡，而 28.5 位的熵在防御主动对手方面并没有多大价值。 p>

但坏事已经够多了。让我们提出一条前进的道路。我将使用 JavaScript EntropyString 库，它“有效地从各种字符集中生成具有指定熵的加密强随机字符串”。而不是 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 的参数指定了所需的熵位，而不是更常见的随机字符串生成解决方案，该解决方案指定传入字符串长度（这既是错误的，也通常是未指定的，但这是另一回事）。

【讨论】：

谢谢！请注意，此处的示例不再有效。
代码 sn-p 已更新为库的较新版本。库 README 和 GitHub repo 中也有很多示例。

【解决方案6】：

这并没有完全优化，但它应该可以工作。

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/

【讨论】：

chars.substring(rnum, rnum+1) 就像chars.charAt(rnum)

【解决方案7】：

如果您需要生成至少包含 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 让我开始创建它。

【讨论】：

您缺少小写字母j :P 否则，这里有好东西。稍微修改一下以满足我的要求。

【解决方案8】：

受您的回答启发，我写了一篇小文章：

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

此函数返回密码，可以在书签中使用，如：

javascript:alert(TheCodeOfTheFunction);

【讨论】：

【解决方案9】：

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

此函数使用系统时间作为随机数生成器的种子。任何知道密码生成时间的人都可以轻松地暴力破解密码。

在几乎所有情况下，这些数据都很容易获得 - 只需获取被黑数据库中的 registration_time 列，并使用 15 到 0 分钟前的时间测试 Math.random() 算法生成的所有值。

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

【讨论】：

【解决方案10】：

好的，如果我理解得很好，您正在尝试获取一个随机字符串密码，其中包含 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))

【讨论】：

【解决方案11】：

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

传统的 JavaScript 方法 -

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

使用随机字符串

安装随机字符串：

npm install randomstring

在 App.js 中使用它-

var randStr = require('randomstring');

var yourString = randStr.generate(8);

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

不要使用强制密码！

强制密码会损害您的安全，因为所有密码都使用相同的字符集，很容易被破解！

【讨论】：

Force != Enforce.. 让用户输入 123456?.. 在安全系统中，它实际上需要根据验证所需的条件生成密码。如果没有条件生成，代码可能会创建无效密码，即 >= 8 个字符，至少 1 个大小写和一个数字或特殊字符。确保用户拥有强密码不会限制用户的安全

【解决方案12】：

我的 Crypto 基于对这个问题的看法。使用 ES6 并省略任何浏览器功能检查。任何关于安全性或性能的 cmet？

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

【讨论】：

这很好用。它比我更喜欢的大多数其他函数更具可读性。

【解决方案13】：

根据上面的@Ryan Shillington 回答，您可能会发现此增强功能也很有帮助。认为这比上述问题中的原始请求更安全。

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

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

【讨论】：

【解决方案14】：

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

【讨论】：

【解决方案15】：

最后，不使用浮点技巧：

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

【讨论】：

【解决方案16】：

使用一个大写字符的安全密码。

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)

【讨论】：

【解决方案17】：

创建一个名为 PassswordGeneratorService 的密码生成器服务

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

在您的控制器上添加一个方法，该方法在服务内调用生成密码方法并在密码字段中设置结果

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

【讨论】：

我只是剥离了函数generatePassword 并使用它，不需要整个课程。谢谢

【解决方案18】：

这是一种创建灵活生成器的方法，允许您添加一些规则：

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

【讨论】：

【解决方案19】：

试试这个，它有效。

enishant/random_password.js

将脚本下载到您的 javascript 应用程序并调用函数 randomPassword()

【讨论】：

【解决方案20】：

生成长度为 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() );

【讨论】：

【解决方案21】：

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

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>

【讨论】：

【解决方案22】：

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

只需要一行代码就可以得到一个随机数：

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

它还有助于加密和解密数据。更多信息请访问MDN Web docs - window.crypto。

【讨论】：

【解决方案23】：

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

【讨论】：

【解决方案24】：

你可以使用 lodash。

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)

【讨论】：