Я хочу, щоб 5-символьний рядок складався з символів, вибраних випадковим чином із набору [a-zA-Z0-9].

Який найкращий спосіб зробити це за допомогою JavaScript?

Я думаю, це допоможе вам:

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

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

Примітка. Наведений вище алгоритм має такі слабкі сторони:

• Він генеруватиме де-небудь від 0 до 6 символів через те, що затримані нулі видаляються при строфікації плаваючих точок.
• Це глибоко залежить від алгоритму, який використовується для строфікації чисел з плаваючою точкою, який жахливо складний. (Див. Статтю "Як точно друкувати номери з плаваючою комою" .)
• Math.random()може давати передбачуваний ("випадковий вигляд", але насправді не випадковий) результат залежно від реалізації. Отриманий рядок не підходить, коли потрібно гарантувати унікальність або непередбачуваність.
• Навіть якщо він створив 6 рівномірно випадкових, непередбачуваних символів, ви можете розраховувати на те, що ви побачите дублікат після створення лише близько 50 000 рядків через парадокс дня народження . (sqrt (36 ^ 6) = 46656)

Math.random поганий для подібних речей

Варіант 1

Якщо ви можете зробити це на сервері , просто використовуйте крипто модуль -

var crypto = require("crypto");
var id = crypto.randomBytes(20).toString('hex');

// "bb5dc8842ca31d4603d6aa11448d1654"

Отриманий рядок буде вдвічі довшим, ніж генеровані випадковими байтами; кожен байт, закодований у шістнадцяткові, - це 2 символи. 20 байт становитиме 40 символів у шістнадцятковій кількості

Варіант 2

Якщо вам доведеться робити цей клієнтський бік, можливо, спробуйте модуль uuid -

var uuid = require("uuid");
var id = uuid.v4();

// "110ec58a-a0f2-4ac4-8393-c866d813b8d1"

Варіант 3

Якщо вам потрібно зробити цей клієнт, і вам не потрібно підтримувати старі браузери, ви можете це робити без залежностей -

// dec2hex :: Integer -> String
// 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-

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

Короткий, легкий і надійний

Повертає рівно 5 випадкових символів, на відміну від деяких найкраще оцінених відповідей, знайдених тут.

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

Ось покращення щодо відмінної відповіді подвійного дотику . У оригіналу є два недоліки, які вирішено тут:

По-перше, як уже згадували інші, є невелика ймовірність створення коротких рядків або навіть порожнього рядка (якщо випадкове число дорівнює 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)

Пояснення:

1. Виберіть випадкове число в діапазоні [0,1), тобто між 0 (включно) і 1 (виключно).
2. Перетворіть число в рядок base-36, тобто використовуючи символи 0-9 та az.
3. Площадка з нулями (вирішує перше питання).
4. Відріжте провідний '0.' приставка та додаткові нульові накладки.
5. Повторіть рядок достатньо разів, щоб у ньому було принаймні N символів (шляхом з'єднання порожніх рядків із коротшою випадковою рядком, що використовується як роздільник).
6. Виріжте рівно N символів з рядка.

Подальші думки:

• У цьому рішенні не використовуються великі літери, але майже у всіх випадках (каламбур не призначений) це не має значення.
• Максимальна довжина рядка при N = 16 у вихідній відповіді вимірюється в Chrome. У Firefox це N = 11. Але, як було пояснено, друге рішення полягає у підтримці будь-якої потрібної довжини рядка, а не в додаванні випадковості, тому це не має великої різниці.
• Усі повернуті рядки мають однакову ймовірність повернення, принаймні, наскільки результати, повернені Math.random (), розподіляються рівномірно (це в будь-якому випадку не є випадковістю криптографічної сили).
• Не всі можливі рядки розміром N можуть бути повернуті. У другому рішенні це очевидно (оскільки менший рядок просто дублюється), але також в оригінальній відповіді це вірно, оскільки при перетворенні в base-36 останні кілька бітів можуть не входити до початкових випадкових біт. Зокрема, якщо ви подивитеся на результат від Math.random (). ToString (36), ви помітите, що останній символ не розподілений рівномірно. Знову ж таки, майже у всіх випадках це не має значення, але ми нарізаємо остаточний рядок з початку, а не з кінця випадкової рядки, щоб короткі рядки (наприклад, N = 1) не впливали.

Оновлення:

Ось пара інших однокласників у функціональному стилі, які я придумав. Вони відрізняються від рішення вище тим, що:

• Вони використовують явний довільний алфавіт (більш загальний і підходить до оригінального запитання, в якому задаються як великі, так і малі літери).
• Усі рядки довжиною N мають однакову ймовірність повернення (тобто рядки не містять повторів).
• Вони базуються на функції карти, а не на фокусі toString (36), який робить їх більш простими та зрозумілими.

Отже, скажіть, ваш алфавіт на вибір

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Тоді ці двоє рівнозначні один одному, тож ви можете вибрати те, що інтуїтивніше для вас:

Array(N).join().split(',').map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');

і

Array.apply(null, Array(N)).map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');

Редагувати:

Мені здається, що квабіт і Мартійн де Мільяно придумали подібні до останніх рішення (кудо!), Які я якось пропустив. Оскільки вони з першого погляду не виглядають такими короткими, я все одно залишлю його на випадок, якщо хтось дійсно хоче однолінійку :-)

Крім того, замінив "новий масив" на "масив" у всіх рішеннях, щоб відголити ще кілька байтів.

Найбільш компактне рішення, тому що 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));

Щось подібне повинно працювати

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

Більш нова версія з оператором розповсюдження es6 :

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

• 30Довільне число, ви можете вибрати будь-який маркер довжину ви хочете
• 36Максимальне число радікс ви можете перейти до numeric.toString () , що означає все номера і азимуту малі літери
• 2Використовуються , щоб вибрати 3 - ї індекс від випадкової рядки , яка виглядає наступним чином : "0.mfbiohx64i"ми могли б взяти будь-який індекс після0.

Генератор випадкових рядків (альфа-числовий | альфа | числовий)

/**
 * Pseudo-random string generator
 * http://stackoverflow.com/a/27872144/383904
 * Default: return a random alpha-numeric string
 * 
 * @param {Integer} len Desired length
 * @param {String} an Optional (alphanumeric), "a" (alpha), "n" (numeric)
 * @return {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;
}

console.log(randomString(10));      // i.e: "4Z8iNQag9v"
console.log(randomString(10, "a")); // i.e: "aUkZuHNcWw"
console.log(randomString(10, "n")); // i.e: "9055739230"

Хоча вищезазначене використовує додаткові перевірки на потрібний вихід A / N, A, N , давайте розбимо його на основні (лише для Alpha-Numeric) для кращого розуміння:

• Створіть функцію, яка приймає аргумент (потрібна довжина випадкового результату String)
• Створіть порожній рядок, як var str = "";об'єднати випадкові символи
• Всередині циклу створіть randчисло індексу від 0 до 61 (0..9 + A..Z + a..z = 62)
• Створіть умовну логіку для налаштування / виправленняrand (оскільки це 0..61), збільшивши її на деяку кількість (див. Приклади нижче), щоб повернути потрібне CharCodeчисло та відповідний символ.
• Всередині петля з'єднується в straString.fromCharCode( incremented rand )

Давайте зобразимо діапазони таблиць символів ASCII :

_____0....9______A..........Z______a..........z___________  Character
     | 10 |      |    26    |      |    26    |             Tot = 62 characters
    48....57    65..........90    97..........122           CharCode ranges

Math.floor( Math.random * 62 )дає діапазон від 0..61(що нам потрібно).
Давайте виправимо випадковий вибір правильних діапазонів charCode :

      |   rand   | charCode |  (0..61)rand += fix            = charCode ranges |
------+----------+----------+--------------------------------+-----------------+
0..9  |   0..9   |  48..57  |  rand += 48                    =     48..57      |
A..Z  |  10..35  |  65..90  |  rand += 55 /*  90-35 = 55 */  =     65..90      |
a..z  |  36..61  |  97..122 |  rand += 61 /* 122-61 = 61 */  =     97..122     |

Умовна операція логіка з наведених вище таблиць:

   rand += rand>9 ? ( rand<36 ? 55 : 61 ) : 48 ;
// rand +=  true  ? (  true   ? 55 else 61 ) else 48 ;

З наведеного вище пояснення, ось одержуваний алфа-числовий фрагмент :

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)); // i.e: "7GL9F0ne6t"

Або якщо ви будете:

const randomString = (n, r='') => {
  while (n--) r += String.fromCharCode((r=Math.random()*62|0, r+=r>9?(r<36?55:61):48));
  return r;
};

console.log(randomString(10))

Найпростіший спосіб:

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

Це генерує випадкові рядки з 5 символів на основі поточного часу. Приклад виведення є 4mtxjабо 4mv90чи4mwp1

Проблема з цим полягає в тому, що якщо ви викликаєте його два рази за одну і ту ж секунду, він генерує ту саму струну.

Більш безпечний спосіб:

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

Це створить випадковий рядок з 4 або 5 символів, завжди різний. Приклад вихідних даних , як 30jzmабо 1r591чи4su1a

В обох напрямках перша частина генерує випадкове число. .toString(36)Частина відкидати число в base36 (alphadecimal) уявлення про нього.

Ось кілька простих лайнерів. Змініть, 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"]();});

Я знаю, що всі це вже зрозуміли, але мені здалося, що я хотів би перейти на цей самий легкий спосіб (світло на код, а не процесор):

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.

Якщо ви використовуєте Lodash або Underscore , то це так просто:

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

Для задоволення вимоги [a-zA-Z0-9] та довжини = 5 використовуйте

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

З'являться малі літери, великі літери та цифри.

Якщо когось цікавить однолінійний (хоча не відформатований як такий для вашої зручності), який виділяє пам'ять відразу (але зауважте, що для невеликих рядків це дійсно не має значення) ось як це зробити:

Array.apply(0, Array(5)).map(function() {
    return (function(charset){
        return charset.charAt(Math.floor(Math.random() * charset.length))
    }('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'));
}).join('')

Ви можете замінити 5на потрібну довжину рядка. Завдяки @AriyaHidayat в цій публікації за рішення mapфункції, яка не працює на розрідженому масиві, створеному Array(5).

Ось метод, який я створив.
Це створить рядок, що містить як великі, так і малі символи.
Крім того, я включив функцію, яка також створить буквено-цифровий рядок.

Приклади роботи:
http://jsfiddle.net/greatbigmassive/vhsxs/ (лише альфа)
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
Це робить те саме, але має більше сенсу та включає всі листи.

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

Якщо припустити, що ви підкреслили, ви можете елегантно генерувати випадкову рядок всього в двох рядках:

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

const c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
const s = [...Array(5)].map(_ => c[~~(Math.random()*c.length)]).join('')

Швидкий і вдосконалений алгоритм. Не гарантує рівномірності (див. Коментарі).

function getRandomId(length) {
    if (!length) {
        return '';
    }

    const possible =
        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    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);
        }
    }

    let result = '';

    for (let i = 0; i < length; i++) {
        result += possible.charAt(array[i] % 62);
    }

    return result;
}

Проблема з відповідями на запитання "Мені потрібні випадкові рядки" (будь-якою мовою) практично в кожному рішенні використовується хибна первинна специфікація довжини рядка . Самі запитання рідко виявляють, для чого потрібні випадкові рядки, але я б заперечував, що вам рідко потрібні випадкові рядки довжини, скажімо 8. Те, що вам незмінно потрібно, це деяка кількість унікальних рядків , наприклад, щоб використовувати як ідентифікатори для певної мети.

Є два провідні способи отримання строго унікальних рядків: детерміновано (що не випадково) та зберігати / порівнювати (що є обтяжливим). Що ми робимо? Ми відмовляємося від привида. Натомість ми ідемо з імовірнісною унікальністю . Тобто ми приймаємо, що існує певний (хоча і малий) ризик того, що наші струни не будуть унікальними. Тут розуміють вірогідність зіткнення та ентропію допомагають .

Тож я перефразую незмінну потребу як потребу в певній кількості рядків з невеликим ризиком повторення. В якості конкретного прикладу, скажімо, ви хочете створити потенціал у 5 мільйонів ідентифікаторів. Ви не хочете зберігати та порівнювати кожен новий рядок, а ви хочете, щоб вони були випадковими, тому ви приймаєте певний ризик повторення. Наприклад, скажімо, ризик менший за 1 на трильйон шансів повторити. То яка довжина струни вам потрібна? Ну, це питання не визначено, оскільки це залежить від використовуваних персонажів. Але що ще важливіше - це помилково. Вам потрібно конкретизувати ентропію струн, а не їх довжину. Ентропія може бути безпосередньо пов'язана з ймовірністю повторення в деякій кількості рядків. Довжина рядка не може.

І тут може допомогти бібліотека на зразок EntropyString . Для створення випадкових ідентифікаторів, які мають менше 1 на трильйон шансів повторити в 5 мільйонах рядків, використовуючи entropy-string:

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 символами за замовчуванням. Є й інші заздалегідь задані набори символів, і ви можете також вказати власні символи. Наприклад, генерування ідентифікаторів з тією ж ентропією, що описана вище, але з використанням шістнадцяткових символів:

import {Random, Entropy, charSet16} from './entropy-string'

const random = new Random(charSet16)
const bits = Entropy.bits(5e6, 1e12)

const string = random.string(bits)

"27b33372ade513715481f"

Зверніть увагу на різницю в довжині рядка через різницю в загальній кількості символів у використаному наборі символів. Ризик повторення у вказаній кількості потенційних рядків однаковий. Довжина рядків не є. І найкраще, що ризик повторення та потенційна кількість рядків є явним. Більше не вгадуйте з довжиною рядка.

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 .

Ви можете перебирати масив елементів та рекурсивно додавати їх до рядкової змінної, наприклад, якщо вам потрібна випадкова послідовність ДНК:

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

Я не знайшов чіткого рішення для підтримки як малих, так і великих літер.

Підтримка лише малих літер:

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)пристосуватися до довжини вам.

Один вкладиш:

Array(15).fill(null).map(() => Math.random().toString(36).substr(2)).join('')
// Outputs: 0h61cbpw96y83qtnunwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil

Це працює точно

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

Як щодо щось подібне: Date.now().toString(36) не дуже випадковий, але короткий і досить унікальний кожен раз, коли ви його називаєте.

Алфавітно-цифрові символи регістру:

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

Створіть 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;
}

Можна використовувати кодерин . Це бібліотека для генерування випадкових кодів за заданою схемою. Використовуйте #як заповнювач для великих і малих символів, а також цифр:

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

Є й інші заповнювачі, такі як Aвеликі літери або9 для цифр.

Що може бути корисним - це дзвінок .next() завжди дадуть вам унікальний результат, тому вам не доведеться турбуватися про дублікати.

Ось демонстраційний додаток, який генерує список унікальних випадкових кодів .

Повне розкриття: Я автор кодерена.