如何用Javascript生成一串数字和字母

我会制作一个函数，生成一个与给定模板匹配的随机序列。类似这样的东西：

function getSequence(template) {
    var r = '', ch, n;
    for (var i = 0; i < template.length; i++) {
        ch = template.substr(i, 1);
        if (ch == "d") {
            r += parseInt(Math.random() * 10);
        } else if (ch == "A") {
            r += String.fromCharCode(65 + parseInt(Math.random() * 26));
        } else if (ch == "w") {
            n = parseInt(Math.random() * 36);
            if (n > 9) {
                r += String.fromCharCode(55 + n);
            } else {
                r += n;
            }
        } else {
            r += ch;
        }
    }
    return r;
}
console.log(getSequence('Add-wwww-AAA-ddA'));

http://jsfiddle.net/xpt9od7c/

在给定的示例中，"A"用于大写字母，"d"用于数字（数字），"w"用于任意一个。因此，"Add wwww"将返回一个由一个大写字母、两个数字、一个连字符组成的序列，然后是四个可以是字母或数字的字符。然后你可以根据你需要的顺序进行调整。

编辑。也许一个更干净、更可重用的实现是创建一个函数，将模板字符转换为从相应字符集中挑选的随机字符，然后调用Array.map将该函数应用于模板字符串的每个字符。

var CHAR_SETS = {
    d: '0123456789',
    A: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    w: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
};
function mapString(s, func) {
    return Array.prototype.map.call(s, func).join('')
}
function randChar(charType) {
    var chars = CHAR_SETS[charType];
    if (chars) {
        return chars.charAt(parseInt(Math.random() * chars.length));
    } else {
        return charType;
    }
}
console.log(mapString('Add-wwww-AAA-ddA', randChar));

http://jsfiddle.net/49hofey8/2/

另一种选择是使用replace:

var CHAR_SETS = {
    d: '0123456789',
    A: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    w: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
};
function randChar(charType) {
    var chars = CHAR_SETS[charType];
    return chars.charAt(parseInt(Math.random() * chars.length));
}
console.log('Add-wwww-AAA-ddA'.replace(/[Adw]/g, randChar));

http://jsfiddle.net/so3pf271/1/

一个非常简单的方法是创建一个包含所有要包含的字符（在您的情况下是数字和大写字母）的字符串，然后使用随机数生成从该字符串中选择要添加的字符。然后你会用一个循环重复这个过程。在适当的地方插入破折号。直到你把绳子搭好。

类似这样的东西：

var sValidCharacters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var sCharCode = "";
for (i = 0; i < 13; i++) {
    sCharCode = sCharCode + sValidCharacters.charAt(parseInt(Math.random() * sValidCharacters.length));
    if ((i === 2) || (i === 6) || (i === 9)) {
        sCharCode = sCharCode + "-";
    }
}
console.log(sCharCode);

这种方法的好处在于，由于它在确定随机数时使用sValidCharacters的长度，因此您可以在不更改任何代码的情况下从"源字符串"中添加或减去有效字符。

一些测试运行的样本输出：

HF1-EH46-RKP-8OL
VJ6-TRE1-DVA-WR7
156-ODA4-350-TP5
XBA-Q599-KZJ-FST
N82-DNM8-QSS-GUK

编辑：

我做了第二次尝试，使其更加灵活，这样您所需要做的就是更改参数以生成您选择的代码。这是新的"功能化"版本：

function generateCode(sSourceCharacters, iCodeLength, sSeperator, aSeparatorPositions) {
    var sNewCode = "";
    for (i = 0; i < iCodeLength; i++) {
        sNewCode = sNewCode + sSourceCharacters.charAt(parseInt(Math.random() * sSourceCharacters.length));
        if (aSeparatorPositions.indexOf(i + 1) !== -1) {
            sNewCode = sNewCode + sSeperator;
        }
    }
    return sNewCode;
}

通过这种方式，您可以根据需要传入任何所需的参数来生成代码。对于您的特定问题，选项将按如下方式传递：

var charGroup = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var length = 13;
var divider = "-";
var dividerLocations = [3, 7, 10]; // the numbers indicate which character to place the divider after
var generatedCode = generateCode(charGroup, length, divider, dividerLocations);

但是，你也可以通过类似的东西：

var charGroup = "0123456789";
var length = 11;
var divider = ".";
var dividerLocations = [3, 6, 9];

获取随机生成的IP地址（尽管，决不能保证有效：D）：示例：

235.232.608.74
125.227.649.68
983.678.369.71
605.708.890.97
537.554.201.23

或者这样，生成一个随机的、4个字母的、"编码"的脏话：：D

var charGroup = "!@#$%^&*()?";
var length = 4;
var divider = "";
var dividerLocations = [];

结果：

@%$%
)?$&
*&(!
!^@)
*))#

我会使用更通用的东西。然后，您可以将函数重新用于其他代码目的。

Number.MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
Number.MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -Number.MAX_SAFE_INTEGER;
Number.toInteger = Number.toInteger || function(inputArg) {
  var number = +inputArg,
    val = 0;
  if (number === number) {
    if (!number || number === Infinity || number === -Infinity) {
      val = number;
    } else {
      val = (number > 0 || -1) * Math.floor(Math.abs(number));
    }
  }
  return val;
};
function clampSafeInt(number) {
  return Math.min(Math.max(Number.toInteger(number), Number.MIN_SAFE_INTEGER), Number.MAX_SAFE_INTEGER);
}
Array.isArray = Array.isArray || function(inputArg) {
  return {}.toString.call(inputArg) === '[object Array]';
}
function isString(inputArg) {
  return {}.toString.call(inputArg) === '[object String]';
}
function generateChars(first, last) {
  first = isString(first) && first.length ? first.charCodeAt(0) : 0;
  last = isString(last) && last.length ? last.charCodeAt(0) : 0;
  var chars = [],
    index;
  for (index = first; index <= last; index += 1) {
    chars.push(String.fromCharCode(index));
  }
  return chars;
}
function randomInt(min, max) {
  var tmp,
    val;
  if (arguments.length === 1) {
    max = min;
    min = 0;
  }
  min = clampSafeInt(min);
  max = clampSafeInt(max);
  if (min > max) {
    tmp = min;
    min = max;
    max = tmp;
  }
  tmp = max - min + 1;
  if (tmp > Number.MAX_SAFE_INTEGER) {
    throw new RangeError('Difference of max and min is greater than Number.MAX_SAFE_INTEGER: ' + tmp);
  } else {
    val = Math.floor(Math.random() * tmp) + min;
  }
  return val;
}
function stringFromPool(ary, howMany) {
  var str = '';
  if (Array.isArray(ary)) {
    for (index = 0, howMany = Number.toInteger(howMany); index < howMany; index += 1) {
      str += ary[randomInt(ary.length - 1)];
    }
  }
  return str;
}
var getSequence = (function() {
  var lower = generateChars('a', 'z'),
    upper = generateChars('A', 'Z'),
    digit = generateChars('0', '9'),
    lowerDigit = lower.concat(digit),
    upperDigit = upper.concat(digit),
    all = lower.concat(upper, digit);
  return function(template) {
    var str = '',
      index,
      length,
      chr;
    if (isString(template) && template.length) {
      for (index = 0, length = template.length; index < length; index += 1) {
        chr = template.charAt(index);
        switch (chr) {
          case 'a':
            str += stringFromPool(lower, 1);
            break;
          case 'A':
            str += stringFromPool(upper, 1);
            break;
          case 'd':
            str += stringFromPool(digit, 1);
            break;
          case 'c':
            str += stringFromPool(lowerDigit, 1);
            break;
          case 'C':
            str += stringFromPool(upperDigit, 1);
            break;
          case 'x':
            str += stringFromPool(all, 1);
            break;
          default:
            str += chr;
        }
      }
    }
    return str;
  };
}());
function generatePattern() {
  return getSequence('CCC-CCCC-CCC-CCC');
}
function runMaxTimes(fn, howMany) {
  howMany = Number.toInteger(howMany);
  var count = 0;
  return function() {
    if (count < howMany) {
      count += 1;
      return fn.apply(this, arguments);
    }
  };
}
document.getElementById('generate').addEventListener('click', runMaxTimes(function(e) {
  this.textContent += generatePattern() + ''n';
}, 5).bind(document.getElementById('out')), false);

<button id="generate">Generate</button>
<pre id="out"></pre>