Cadeia alfanumérica aleatória em JavaScript?

Qual é o caminho mais curto (dentro da razão) para gerar uma string aleatória alfanumérica (letras maiúsculas, minúsculas e números) em JavaScript para usar como um identificador provavelmente único?

Se você quiser apenas permitir caracteres específicos, você também pode fazer assim:

function randomString(length, chars) { var result = ''; for (var i = length; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)]; return result; } var rString = randomString(32, '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'); 

Aqui está um jsfiddle para demonstrar: http://jsfiddle.net/wSQBx/

Outra maneira de fazer isso seria usar uma string especial que informa à function que tipos de caracteres devem ser usados. Você poderia fazer isso assim:

 function randomString(length, chars) { var mask = ''; if (chars.indexOf('a') > -1) mask += 'abcdefghijklmnopqrstuvwxyz'; if (chars.indexOf('A') > -1) mask += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; if (chars.indexOf('#') > -1) mask += '0123456789'; if (chars.indexOf('!') > -1) mask += '~`!@#$%^&*()_+-={}[]:";\'<>?,./|\\'; var result = ''; for (var i = length; i > 0; --i) result += mask[Math.floor(Math.random() * mask.length)]; return result; } console.log(randomString(16, 'aA')); console.log(randomString(32, '#aA')); console.log(randomString(64, '#A!')); 

Violino: http://jsfiddle.net/wSQBx/2/

Alternativamente, para usar o método base36 como descrito abaixo, você poderia fazer algo parecido com isto:

 function randomString(length) { return Math.round((Math.pow(36, length + 1) - Math.random() * Math.pow(36, length))).toString(36).slice(1); } 

Acabei de encontrar isso como uma solução muito legal e elegante:

 Math.random().toString(36).slice(2) 

Outra variação de resposta sugerida por JAR.JAR.beans

 (Math.random()*1e32).toString(36) 

Ao alterar o multiplicador 1e32 você pode alterar o comprimento da string aleatória.

Ou para aproveitar o que Jar Jar sugeriu, foi isso que usei em um projeto recente (para superar as restrições de tamanho):

 var randomString = function (len, bits) { bits = bits || 36; var outStr = "", newStr; while (outStr.length < len) { newStr = Math.random().toString(bits).slice(2); outStr += newStr.slice(0, Math.min(newStr.length, (len - outStr.length))); } return outStr.toUpperCase(); }; 

Usar:

 randomString(12, 16); // 12 hexadecimal characters randomString(200); // 200 alphanumeric characters 

Isso é mais limpo

 Math.random().toString(36).substr(2, length) 

Exemplo

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

One-liner com lodash, para 20 caracteres randoms (minúsculas alfanuméricas):

 _.times(20, () => _.random(35).toString(36)).join(''); 

por 32 caracteres:

 for(var c = ''; c.length < 32;) c += Math.random().toString(36).substr(2, 1) 

Caráter random:

 String.fromCharCode(i); //where is an int 

Int random:

 Math.floor(Math.random()*100); 

Coloque tudo junto:

 function randomNum(hi){ return Math.floor(Math.random()*hi); } function randomChar(){ return String.fromCharCode(randomNum(100)); } function randomString(length){ var str = ""; for(var i = 0; i < length; ++i){ str += randomChar(); } return str; } var RandomString = randomString(32); //32 length string 

Violino: http://jsfiddle.net/maniator/QZ9J2/

 function randomString(len) { var p = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; return [...Array(len)].reduce(a=>a+p[~~(Math.random()*p.length)],''); } 

Resumo:

  1. Crie uma matriz do tamanho que queremos (porque não há range(len) equivalente no javascript.
  2. Para cada elemento na matriz: escolha um caractere random de p e adicione-o a uma string
  3. Retorna a string gerada.

Alguma explicação:

[...Array(len)]

Array (len) ou new Array (len) cria um array com ponteiro (s) indefinido (s) . Os one-liners serão mais difíceis de serem executados. A syntax Spread define convenientemente os pointers (agora eles apontam para objects indefinidos!).

.reduce(

Reduza o array para, neste caso, uma única string. A funcionalidade reduzida é comum na maioria das linguagens e vale a pena aprender.

a=>a+...

Estamos usando uma function de seta .

a é o acumulador. Neste caso, é a string de resultado final que vamos retornar quando terminarmos (você sabe que é uma string porque o segundo argumento para a function reduce, o initialValue é uma string vazia: '' ). Então, basicamente: converta cada elemento na matriz com p[~~(Math.random()*p.length)] , acrescente o resultado a a string e dê-me quando terminar.

p[...]

p é a string de caracteres da qual estamos selecionando. Você pode acessar chars em uma string como um índice (por exemplo, "abcdefg"[3] nos dá "d" )

~~(Math.random()*p.length)

Math.random() retorna um ponto flutuante entre [0, 1] Math.floor(Math.random()*max) é o padrão de fato para obter um inteiro random em javascript . ~ é o operador NOT bit a bit no javascript. ~~ é uma maneira mais curta, discutivelmente às vezes mais rápida e definitivamente mais divertida de dizer Math.floor(

Eu acho que o seguinte é a solução mais simples que permite um determinado comprimento:

Array(myLength).fill(0).map(x => Math.random().toString(36).charAt(2)).join('')

Depende da syntax da function de seta.

 var randomString = function(length) { var str = ''; var chars ='0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz'.split( ''); var charsLen = chars.length; if (!length) { length = ~~(Math.random() * charsLen); } for (var i = 0; i < length; i++) { str += chars[~~(Math.random() * charsLen)]; } return str; }; 

Usando lodash:

 function createRandomString(length) { var chars = "abcdefghijklmnopqrstufwxyzABCDEFGHIJKLMNOPQRSTUFWXYZ1234567890" var pwd = _.sample(chars, length || 12) // lodash v4: use _.sampleSize return pwd.join("") } 

Quando eu vi essa pergunta, pensei em quando eu tinha que gerar UUIDs. Eu não posso levar o crédito pelo código, como tenho certeza que encontrei aqui no stackoverflow. Se você não quiser os traços na sua string, retire os traços. Aqui está a function:

 function generateUUID() { var d = new Date().getTime(); var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,function(c) { var r = (d + Math.random()*16)%16 | 0; d = Math.floor(d/16); return (c=='x' ? r : (r&0x7|0x8)).toString(16); }); return uuid.toUpperCase(); } 

Violino: http://jsfiddle.net/nlviands/fNPvf/11227/

Esta function deve fornecer uma string aleatória em qualquer tamanho.

 function randString(length) { var l = length > 25 ? 25 : length; var str = Math.random().toString(36).substr(2, l); if(str.length >= length){ return str; } return str.concat(this.randString(length - str.length)); } 

Eu testei com o seguinte teste que foi bem sucedido.

 function test(){ for(var x = 0; x < 300000; x++){ if(randString(x).length != x){ throw new Error('invalid result for len ' + x); } } } 

A razão pela qual eu escolhi 25 é que, na prática, o comprimento da string retornado de Math.random().toString(36).substr(2, 25) tem comprimento 25. Esse número pode ser alterado como você deseja.

Essa function é recursiva e, portanto, chamar a function com valores muito grandes pode resultar em um Maximum call stack size exceeded . Do meu teste, consegui obter uma string no comprimento de 300.000 caracteres.

Esta function pode ser convertida em uma recursion final enviando a string para a function como um segundo parâmetro. Não tenho certeza se o JS usa a otimização da chamada Tail

Gerador de Chave Aleatória

O argumento keyLength é o tamanho do caractere que você deseja para a chave.

 function keyGen(keyLength) { var i, key = "", characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; var charactersLength = characters.length; for (i = 0; i < keyLength; i++) { key += characters.substr(Math.floor((Math.random() * charactersLength) + 1), 1); } return key; } keyGen(12) "QEt9mYBiTpYD" 

Agradável e simples, e não limitado a um certo número de caracteres:

 let len = 20, str = ""; while(str.length < len) str += Math.random().toString(36).substr(2); str = str.substr(0, len); 

Use a biblioteca md5: https://github.com/blueimp/JavaScript-MD5

O caminho mais curto:

md5(Math.random())

Se você quiser limitar o tamanho a 5:

md5(Math.random()).substr(0, 5)