Генерация случайной строки / символов в JavaScript

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

Какой лучший способ сделать это с помощью JavaScript?

28.08.2009 21:14:41
Внимание: ни один из ответов не дал true-randomрезультата! Они только pseudo-random. При использовании случайных строк для защиты или безопасности не используйте ни одну из них !!! Попробуйте один из этих API: random.org
Ron van der Heijden 29.05.2013 11:33:09
Math.random (). ToString (36) .replace (/ [^ az] + / g, '')
Muaz Khan 14.09.2013 14:47:12
Пожалуйста, поместите решение в решение.
chryss 24.09.2013 04:36:34
Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
frieder 15.08.2014 09:28:25
Обратите внимание, что HTML5 webcrypto randomness API обеспечивает реальную случайность.
mikemaccana 9.01.2016 16:54:56
30 ОТВЕТОВ
РЕШЕНИЕ

Я думаю, что это будет работать для вас:

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

2368
23.04.2019 22:30:16
Это хорошо для коротких строк, но будьте осторожны, использование +=таких строк вызывает поведение O (n ^ 2). Если вы хотите создать более длинные строки, вы должны создать массив отдельных символов и соединить их вместе в конце.
dan_waterworth 10.05.2012 10:55:59
@dan_waterworth Это, вероятно, не имеет значения почти в любом случае: codinghorror.com/blog/2009/01/…
Alex Reece 10.01.2013 20:55:47
@dan_waterworth, на самом деле, +=часто почему-то быстрее, даже используется внутри циклов - jsperf.com/join-vs-concatenation
Konrad Borowski 1.05.2013 12:29:14
@JonathanPaulson Покажи мне цифры . Смотрите предыдущий комментарий со ссылкой jsperf или jsperf.com/sad-tragedy-of-microoptimization или sitepen.com/blog/2008/05/09/string-performance-an-analysis и т. Д. Кроме того, этот вопрос включает в себя только 5 объединений ,
Alex Reece 7.05.2013 22:34:53
@codenamejames Пожалуйста , не используйте это для посола пароля. Это только псевдослучайный и небезопасный. Предполагая, что вы используете Node (я даже не уверен, с чего начать, если вы солите на стороне клиента), используйте cryptoвместо этого.
Hydrothermal 9.01.2015 23:37:23

Как то так должно работать

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');
99
28.08.2009 21:28:20
Вариант примера здесь можно найти здесь: mediacollege.com/internet/javascript/number/random.html
David 31.08.2012 18:17:38
может также просто уменьшить lenпрямо в whileцикле
drzaus 6.03.2013 14:59:19
Спасибо, я только что опубликовал ниже вариант coffeescript этого примера: stackoverflow.com/a/26682781/262379
Dinis Cruz 31.10.2014 20:20:31
Если они будут использоваться публично, то вам, вероятно, следует удалить гласные. Немного меньше энтропии, но намного безопаснее, так как вы не можете генерировать слова, которые могут оскорбить людей. Вот почему мне это нравится, так как я могу отправить свою собственную строку символов. Отличная работа.
Nate Bunney 18.04.2017 18:22:39
Довольно хардкор, работал для меня, спасибо!
Zaki Mohammed 26.12.2019 13:00:55

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

71
29.06.2017 10:17:53
Мне нравится это лучше всего. Вы можете легко изменить, чтобы принимать дополнительные параметры и возвращать только числа, понижения или ограничения. Я не думаю, что ультра-сжатый стиль необходимwhile(s.length< L) s+= randomchar();
mastaBlasta 17.01.2014 19:24:12
И while(L--)сделаем это
vsync 17.06.2014 12:30:43
Лучше использовать более надежный 'A'.charCodeAt(0), чем магический номер 55(и аналогично для 61). Тем более что на моей платформе все равно магическое число, которое возвращается 65. Этот код также лучше документирует себя.
Grumdrig 10.07.2017 06:00:13
Я создал вариант вашей реализации, оптимизированный для минимизации (на 46 байт меньше): stackoverflow.com/a/52412162
Waruyama 20.09.2018 07:18:30
Удачи в отладке этого @Waruyama. Вот для чего вебпак!
Dylan Watson 11.10.2019 09:18:44

Это работает точно

<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>
5
3.12.2009 08:48:06

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

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.

20
29.06.2017 11:08:40
Если вы пытаетесь сделать код коротким, зачем писать, current = current ? current : '';когда вы можете писать current = current || '';
CaffGeek 8.08.2011 13:45:19
поскольку здесь мы говорим о микрооптимизации, я бы предложил полностью пропустить присвоение переменной, если не нужно:current || (current = '');
Thomas Heymann 13.12.2013 10:36:23
Попытка микрооптимизации при использовании «хорошего», но рекурсивного алгоритма траты ресурсов не имеет смысла :-) Цикл for по-прежнему является лучшим в Javascript и превосходит рекурсию до тех пор, пока не достигнут действительно значительный прогресс в оптимизации кода времени выполнения.
Mörre 26.06.2019 09:52:14

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

Примечание. Приведенный выше алгоритм имеет следующие недостатки:

  • Он будет генерировать от 0 до 6 символов из-за того, что конечные нули удаляются при строковом преобразовании с плавающей запятой.
  • Это глубоко зависит от алгоритма, используемого для преобразования чисел с плавающей запятой, который является чрезвычайно сложным. (См. Статью «Как правильно печатать числа с плавающей точкой» .)
  • Math.random()может генерировать предсказуемый («случайный», но не случайный) результат в зависимости от реализации. Результирующая строка не подходит, когда вам нужно гарантировать уникальность или непредсказуемость.
  • Даже если он произвел 6 равномерно случайных, непредсказуемых символов, вы можете ожидать появления дубликата после генерации всего около 50 000 строк из-за парадокса дня рождения . (sqrt (36 ^ 6) = 46656)
2296
5.02.2019 17:43:49
Math.random().toString(36).substr(2, 5), потому что .substring(7)заставляет его быть длиннее 5 символов. Полный балл, все же!
dragon 7.05.2012 08:13:42
@Scoop toStringМетод числового типа в javascript принимает необязательный параметр для преобразования числа в заданную базу. Например, если вы передадите два, вы увидите, что ваш номер представлен в двоичном виде. Как и в шестнадцатеричном (основание 16), основание 36 использует буквы для представления цифр за пределами 9. Преобразовав случайное число в основание 36, вы получите кучу, казалось бы, случайных букв и цифр.
Chris Baker 3.01.2013 20:45:26
Выглядит красиво, но в некоторых случаях это создает пустую строку! Если случайный возврат 0, 0,5, 0,25, 0,125 ... приведет к пустой или короткой строке.
gertas 15.03.2013 19:55:53
@gertas Этого можно избежать(Math.random() + 1).toString(36).substring(7);
George Reith 11.08.2013 17:17:15
Парень, это практически бесполезно. Запустите его всего 1000000 раз, и вы получите около 110000 повторений: var values ​​= {}, i = 0, duplicateCount = 0, val; while (i <1000000) {val = Math.random (). toString (36) .substring (7); if (values ​​[val]) {duplicateCount ++; } значения [val] = 1; я ++; } console.log ("ВСЕГО ДУБЛИКАТОВ", duplicateCount);
hacklikecrack 1.12.2013 15:04:49

Вы можете перебрать массив элементов и рекурсивно добавить их в строковую переменную, например, если вы хотите случайную последовательность ДНК:

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

7
29.06.2017 10:31:37
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 .

6
10.01.2013 02:07:23
Для меня это всегда генерирует случайные строки с strLength - 1: - /
xanderiel 22.11.2013 11:43:05
Переключение с, --strLengthчтобы strLength--исправить это для меня.
xanderiel 22.11.2013 11:43:59

Генерировать 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;
}
4
11.01.2013 11:00:36

В случае, если кто-то заинтересован в одной строке (хотя для вашего удобства она не отформатирована как таковая), которая выделяет память сразу (но учтите, что для небольших строк это действительно не имеет значения), вот как это сделать:

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

13
23.05.2017 12:02:58
Каждая javascript-программа является «однострочной», если вы отформатируете ее так
hacklikecrack 1.12.2013 14:56:50

Расширяя элегантный пример Doubletap, отвечая на вопросы, поднятые Гертами и Драконом. Просто добавьте цикл while для проверки этих редких нулевых обстоятельств и ограничьте число символов пятью.

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/

2
17.03.2013 00:44:10
"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('');};

сгенерирует случайную буквенно-цифровую строку с длиной первой / вызывающей строки

1
20.03.2013 17:13:32

Также основанный на ответе даблтапа, он обрабатывает любую длину случайных обязательных символов (только ниже) и продолжает генерировать случайные числа, пока не будет собрано достаточное количество символов.

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);
}
2
2.04.2013 14:09:08

Как насчет этого компактного трюка?

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('');
4
3.05.2017 09:32:25

Вот метод, который я создал.
Это создаст строку, содержащую как прописные, так и строчные буквы.
Кроме того, я включил функцию, которая будет также создавать буквенно-цифровую строку.

Рабочие примеры:
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)));
}
13
27.07.2015 11:54:09
С помощью этой функции вы никогда не сможете получить заглавную букву больше, чем «M», или строчную букву меньше, чем «n».
erkanyildiz 21.01.2015 14:21:32
В самом деле? ооо! вероятно, будет проверять это больше тогда. Хм, однако, учитывая, что это случайная строка, и нам все равно, какие буквы в ней (если они случайные), тогда она все равно делает то, что мы хотим, и это все, что имеет значение, но да, обеспечит обновить, спасибо.
Adam 27.07.2015 11:50:14
",,,,,".replace(/,/g,function (){return "AzByC0xDwEv9FuGt8HsIrJ7qKpLo6MnNmO5lPkQj4RiShT3gUfVe2WdXcY1bZa".charAt(Math.floor(Math.random()*62))});
1
3.08.2014 02:28:44
слишком много регулярных выражений Слишком медленно.
brunoais 3.09.2014 08:48:57

Это то, что я использовал. Сочетание пары здесь. Я использую его в цикле, и каждый его идентификатор уникален. Это может быть не 5 символов, но это гарантированно уникально.

var newId =
    "randomid_" +
    (Math.random() / +new Date()).toString(36).replace(/[^a-z]+/g, '');
3
31.03.2014 06:36:42
Что бы это ни стоило, это не гарантированно уникально, просто очень вероятно, что оно будет уникальным. Учтите, что Math.random () может вернуть ноль дважды. Более того, если в .replace вводятся два разных числа из базы-36 (/ [^ az] + / g, ''); имеют одинаковую последовательность нечисловых символов (например, abc1 и abc2), они будут возвращать один и тот же идентификатор.
Milosz 11.12.2013 23:47:24

Еще один хороший способ рандомизировать строку из символов 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;
}
0
31.10.2013 16:21:18

Вот улучшение превосходного ответа даблтапа . У оригинала есть два недостатка, которые рассматриваются здесь:

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

Редактировать:

Мне кажется, что Qubyte и Martijn de Milliano придумали решения, подобные последним (слава!), Которые я почему-то упустил. Так как они не выглядят короткими с первого взгляда, я все равно оставлю это здесь на тот случай, если кто-то действительно захочет получить одну строчку :-)

Кроме того, во всех решениях заменили «новый массив» на «массив», чтобы сбрить еще несколько байтов.

157
23.05.2017 12:02:58
Почему бы просто не добавить 1? (Math.random()+1).toString(36).substring(7);
emix 8.01.2015 10:00:28
Потому что добавление 1 не решает ни одну из двух обсуждаемых здесь проблем. Например, (1) .toString (36) .substring (7) создает пустую строку.
amichair 19.01.2015 11:36:02
Использование Math.random().toString(36).substring(2,7)дает ожидаемый результат, который больше похож на.substring(2, n+2)
Joseph Rex 13.11.2015 13:04:17
Array.apply(null, {length: 5}).map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('')
Muhammad Umer 13.11.2015 14:54:27
Это замечательно, но при исполнении в Firefox с N = 16 последние ~ 6 цифр в конечном итоге становятся равными нулю ... (Но, тем не менее, он удовлетворяет желание ОП получить 5 случайных символов).
Edward Newell 10.06.2016 23:15:39

Если библиотека возможна, Chance.js может помочь: http://chancejs.com/#string

2
15.04.2014 16:29:33

Это хранит 5 буквенно-цифровых символов в переменной c.

for(var c = ''; c.length < 5;) c += Math.random().toString(36).substr(2, 1)
1
30.06.2014 19:19:41

Вот несколько простых лайнеров. Изменить, 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"]();});
22
26.10.2015 14:57:31

Вот тестовый скрипт для ответа № 1 (спасибо @ csharptest.net)

скрипт выполняется makeid() 1 millionраз, и, как вы можете видеть, 5 не является уникальным. запускать его с длиной символа 10 довольно надежно. Я запустил его около 50 раз и еще не видел дубликат:-)

примечание: ограничение размера стека узла превышает около 4 миллионов, поэтому вы не можете выполнить это 5 миллионов раз, когда оно не закончится.

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');
3
7.08.2014 02:08:55

Вот пример в 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)
-1
31.10.2014 20:19:33

Мне очень понравился краткий ответ Math.random (). ToString (36) .substring (7) от doubletap, но не то, чтобы в нем было так много коллизий, как правильно указывал hacklikecrack. Он генерировал строки из 11 символов, но частота дублирования составляла 11% при размере выборки 1 миллион.

Вот более длинная (но все еще короткая) и более медленная альтернатива, в которой было всего 133 дубликата на выборке в 1 миллион. В редких случаях строка все равно будет короче 11 символов:

Math.abs(Math.random().toString().split('')
    .reduce(function(p,c){return (p<<5)-p+c})).toString(36).substr(0,11);
1
5.11.2014 22:31:48

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

447
12.04.2019 22:00:22
Точно. Хотя UUID отлично подходит для назначения идентификатора вещи, использование его в качестве строки случайных символов не является хорошей идеей по этой (и, вероятно, другим) причинам.
wmassingham 4.08.2015 17:42:22
Нет необходимости .map()в варианте 3. Array.from(arr, dec2hex).join('')=== Array.from(arr).map(dec2hex).join(''). Спасибо за то, что познакомили меня с этими функциями :-)
Fred Gandt 11.05.2017 19:28:28
В ответе следует упомянуть, что для работы варианта 2 также необходим node.js, это не чистый javascript.
Esko 21.08.2018 11:47:37
Будучи более криптографически безопасным, на самом деле это не удовлетворяет требованиям вопроса, поскольку выводит только 0-9 и af (шестнадцатеричное), а не 0-9, az, AZ.
qJake 17.10.2018 19:46:59
Разве requireмодуль не может быть использован только на стороне сервера?
aJetHorn 18.02.2019 15:39:13

Это для Firefox Chrome Code (аддоны и тому подобное)

Это может сэкономить вам несколько часов исследований.

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 )
0
8.01.2015 22:52:41

Генератор случайных строк (буквенно-цифровой | буквенно-цифровой)

/**
 * 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 , давайте разберем их с основными (только буквенно-цифровыми) для лучшего понимания:

  • Создайте функцию, которая принимает аргумент (желаемая длина случайного результата String)
  • Создать пустую строку, как var str = "";для объединения случайных символов
  • Внутри цикла создайте randпорядковый номер от 0 до 61 (0..9 + A..Z + a..z = 62)
  • Создайте условную логику для Adjust / Fixrand (так как это 0..61), увеличивая ее на некоторое число (см. Примеры ниже), чтобы получить верное CharCodeчисло и соответствующий символ.
  • Внутри цикла объединить strсString.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))

58
13.02.2020 10:21:39

Самый простой способ:

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

Это генерирует случайные строки из 5 символов на основе текущего времени. Пример вывода - 4mtxjили 4mv90или4mwp1

Проблема в том, что если вы вызываете его два раза в одну и ту же секунду, он генерирует одну и ту же строку.

Более безопасный способ:

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

Это сгенерирует случайную строку из 4 или 5 символов, всегда отличающихся. Пример вывода похож на 30jzmили 1r591или4su1a

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

33
11.03.2015 22:19:43
Я не совсем уверен, как это отвечает на вопрос; Это 7-летний вопрос со многими действительными ответами уже. Если вы решите предоставить новый ответ, вам следует проявить особую осторожность, чтобы убедиться, что ваш ответ хорошо объяснен и задокументирован.
Claies 11.03.2015 22:01:33
Если вы используете дату, почему бы вам просто не использовать это как:(+new Date).toString(36)
seniorpreacher 15.07.2015 13:47:54
Мне нравится ваше решение для случайных чисел, но 9e6 дает только 9 миллионов возможностей из 60,4 миллионов для 5 цифр (36 ^ 5), так что вы можете заменить его, (0|Math.random()*6.04e7).toString(36)чтобы покрыть его.
Le Droid 5.01.2016 13:54:19
Я хотел длинную случайную строку с подпрограммой с кратким изложением возможных вариантов (для демонстрации кода), которая не должна быть удивительной с точки зрения криптографии, просто создайте какой-нибудь приятный случайный визуальный «пух». Мне больше нравится этот ответ (ваш второй), так что спасибо. Мои два цента: я могу побить его для краткости одним нажатием клавиши меньше, и это, как правило , производят 13 случайных символов (без периода) (Math.random()*1e20).toString(36).
Andrew Willems 27.02.2016 19:11:35
у меня есть одно затруднение с этим ответом: он не будет использовать [AZ], как это было в оригинальном вопросе.
user.friendly 11.10.2017 22:16:49

Предполагая, что вы используете underscorejs , можно элегантно сгенерировать случайную строку всего за две строки:

var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var random = _.sample(possible, 5).join('');
12
18.05.2015 11:48:25
Это позволит возвращаемому значению иметь все уникальные символы. Кроме того, длина строки ограничена возможной длиной переменной.
Yefu 21.11.2016 01:37:23