Gerar caracteres / caracteres aleatórios em JavaScript

Math.random é mau para este tipo de coisas.

Opção 1

Se for capaz de fazer isto servidor - lado, basta usar o crypto Módulo

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

// "bb5dc8842ca31d4603d6aa11448d1654"

A sequência resultante terá o dobro do tempo que os bytes aleatórios que gerar; cada byte codificado para hex tem 2 caracteres. 20 bytes serão 40 caracteres de hex.

Opção 2

Se você tem que fazer isso cliente -lado, talvez tente o uuid módulo

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

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

Opção 3

Se você tem que fazer isso cliente - lado e você não tem que suportar navegadores antigos, você pode fazê-lo sem dependências

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

Primeiro, como outros já mencionaram, tem uma pequena probabilidade de produzir cadeias curtas ou mesmo uma cadeia vazia (se o número aleatório for 0), o que pode quebrar a sua aplicação. Aqui está uma solução:

(Math.random().toString(36)+'00000000000000000').slice(2, N+2)

Em segundo lugar, tanto o original como a solução acima limitam o tamanho do texto N A 16 caracteres. O seguinte irá devolver uma sequência de tamanho N Para qualquer N (mas note que o uso de n > 16 não irá aumentar a aleatoriedade ou diminuir a probabilidade de colisões):

Array(N+1).join((Math.random().toString(36)+'00000000000000000').slice(2, 18)).slice(0, N)

Explicação:

1. escolha um número aleatório na gama [0,1], ou seja, entre 0 (inclusive) e 1 (exclusivo).
2. converter o número para uma cadeia de base-36, ou seja, usando caracteres 0-9 e a-Z.
Pad com zeros (resolve a primeira edição). Corta a parte principal. prefixo e zeros de enchimento extra.
3. repete o texto o suficiente vezes para ter pelo menos n caracteres nela (juntando strings vazias com a string aleatória mais Curta usada como delimitador).
4. cortar exactamente n caracteres do texto.

Mais pensamentos:

• esta solução não usa letras maiúsculas, mas em quase todos os casos (sem trocadilhos) não importa.
• o comprimento máximo da cadeia A N = 16 na resposta original é medido em cromado. No Firefox é N = 11. Mas, como explicado, a segunda solução é sobre suportar qualquer comprimento de cadeia solicitado, não sobre adicionar aleatoriedade, por isso não faz muita diferença.
• todas as cadeias devolvidas têm uma probabilidade igual de serem devolvidas, pelo menos até os resultados devolvidos pela matemática.random() are uniformely distributed (this is not cryptographic-strength randomness, in any case).
• nem todas as cadeias possíveis de tamanho N podem ser devolvidas. Na segunda solução isso é óbvio (uma vez que a cadeia menor está simplesmente sendo duplicada), mas também na resposta original isso é verdade uma vez que na conversão para base-36 os últimos bits podem não ser parte dos bits aleatórios originais. Especificamente, se você olhar para o resultado da Matemática.aleatorio().toString (36), você vai notar que o último personagem não está uniformemente distribuído. Mais uma vez, em quase todos os casos não importa, mas nós cortamos a corda final do início ao invés do fim da cadeia aleatória de modo que as cordas curtas (por exemplo, N=1) não são afectado.

Actualizar:

• eles usam um alfabeto arbitrário explícito (mais genérico, e adequado para a pergunta original que pedia letras maiúsculas e minúsculas).
• todas as cadeias de comprimento N têm uma probabilidade igual de serem devolvidas (ou seja, as cadeias não contêm repetições).
Eles são baseados num mapa. function, rather than the toString (36) trick, which makes them more straightforce and easy to understand.

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Então estes dois são equivalentes um ao outro, então você pode escolher o que for mais intuitivo para você:

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

E

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

Editar:

Parece que qubytee Martijn de Milliano surgiu com soluções semelhantes a este último (Parabéns!), que eu de alguma forma perdi. Desde eles não parecem tão curtos de relance, eu vou deixá-lo aqui de qualquer maneira, no caso de alguém realmente quer um liner: -)

Também substituiu "new Array" por "Array" em todas as soluções para cortar mais alguns bytes.

Curto, fácil e fiável

Devolve exactamente 5 caracteres aleatórios, em oposição a algumas das respostas topadas encontradas aqui.

Math.random().toString(36).substr(2, 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;
}

Chamada com codificação predefinida [a-zA-Z0-9] ou enviar a sua própria:

var randomValue = randomString(5);

var randomValue = randomString(5, 'PICKCHARSFROMTHISSET');

A solução mais compacta, porque slice é menor que substring. Subtrair do fim do texto permite evitar o símbolo de ponto flutuante gerado por random Função:

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

Ou mesmo

(+new Date).toString(36).slice(-5);

// Using Math.random
console.log(Math.random().toString(36).slice(-5));

// Using new Date
console.log((+new Date).toString(36).slice(-5));

A maneira mais simples é:

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

Isto gera cadeias aleatórias de 5 caracteres com base na hora actual. Exemplo de saída é 4mtxj ou 4mv90 ou 4mwp1

O problema com isso é que se você chamá-lo duas vezes no mesmo segundo, ele irá gerar a mesma string.

A maneira mais segura é:

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

Isto irá gerar uma cadeia aleatória de 4 ou 5 caracteres, sempre diferente. Exemplo de saída é como 30jzm ou 1r591 ou 4su1a

Em ambos os sentidos o a primeira parte gera um número aleatório. A parte .toString(36) moldou o número para uma representação base36 (alfadecimal) dela.

Uma versão mais recente com es6 operador de spread:

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

• o {[1] } é um número arbitrário, você pode escolher qualquer comprimento token que quiser
• o 36 é o número máximo de radix que pode passar para numérico.toString () , o que significa todos os números e letras minúsculas A-z
• o 3 é usado para escolher o terceiro número da cadeia aleatória que se parece com isto: "0.mfbiohx64i", podemos tirar qualquer índice depois 0.

Incluindo 0-9a-z

new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36);})

Incluindo 0-9a-zA-Z

new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36)[Math.random()<.5?"toString":"toUpperCase"]();});

Se está a usar Lodash ou Underscore , então é tão simples:

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

Eu sei que todos já acertaram, mas eu senti como se tivesse uma tentativa nesta da maneira mais leve possível (luz em código, não CPU):

function rand(length, current) {
  current = current ? current : '';
  return length ? rand(--length, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz".charAt(Math.floor(Math.random() * 60)) + current) : current;
}

console.log(rand(5));

É preciso um pouco de tempo para pensar, mas acho que realmente mostra como a sintaxe do javascript é incrível.

Assumindo que usa sublinhado é possível gerar elegantemente cadeia aleatória em apenas duas linhas:

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

Exemplos de Trabalho:
http://jsfiddle.net/greatbigmassive/vhsxs/ (alpha só)
http://jsfiddle.net/greatbigmassive/PJwg8/ (alfanuméricos)

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

Actualizar Julho 2015
Isto faz a mesma coisa, mas faz mais sentido e inclui todas as letras.

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

No caso de alguém interessado em um one-liner (embora não formatado como tal para sua conveniência), que aloca a memória de uma só vez (mas note-se que, para pequenas cadeias realmente não importa) aqui está como fazê-lo:

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

Você pode substituir 5 pelo comprimento do texto que deseja. Graças a @AriyaHidayat em este post para a solução para a função map não trabalhando na matriz esparsa criada por Array(5).

Para cumprir o requisito [a-zA-Z0-9] e comprimento = 5 utilizar

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

Letras minúsculas, letras maiúsculas e números irão ocorrer.

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

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

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

    return result;
}

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

Pode fazer um ciclo através de um conjunto de itens e adicioná-los recursivamente a uma variável de cadeia de caracteres, por exemplo, se quiser uma sequência aleatória de ADN:

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

Não encontrei uma solução limpa para suportar caracteres minúsculos e maiúsculos.

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

Partindo dessa solução para suportar minúsculas e maiúsculas:

Math.random().toString(36).substr(2, 5).split('').map(c => Math.random() < 0.5 ? c.toUpperCase() : c).join('');

Muda o 5 em substr(2, 5) para ajustar ao comprimento que precisas.

Isto funciona com certeza

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

Gerar 10 caracteres de cadeia longa. O comprimento é definido pelo parâmetro (padrão 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;
}

Aqui está um script de teste para a resposta # 1 (obrigado @csharptest.net)

O programa corre makeid() 1 million vezes e como você pode ver 5 não é muito único. executá-lo com um comprimento de char de 10 é bastante confiável. Já o fiz umas 50 vezes e ainda não vi um duplicado.:-)

Nota: O limite de tamanho da pilha de nós excede cerca de 4 milhões, por isso não pode executar este 5 milhões de vezes que não vai acabar.

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

Pode usar coderain . É uma biblioteca para gerar códigos aleatórios de acordo com um determinado padrão. Usar # Como substituição para caracteres superiores e minúsculos, bem como dígitos:

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

Existem outras substituições como A para letras maiúsculas ou 9 para dígitos.

O que pode ser útil é que chamar .next() sempre lhe dará um resultado único para que você não tenha que se preocupar com duplicados.

Aqui está uma aplicação de demonstração que gera uma lista de códigos aleatórios únicos.

sou o autor do coderain.

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

Você precisa do {[[2]} lá para enganar a matriz vazia para ser uma matriz de indefinidos.

var randomString = Array.from({ length: stringLength }, pickRandom).join('');

O problema com as respostas a "Eu preciso de cadeias aleatórias" perguntas (em qualquer língua)é que praticamente todas as soluções usam uma especificação primária falha de comprimento das cadeias . As próprias perguntas raramente revelam por que as cordas aleatórias são necessárias, mas eu desafio você raramente precisa de cordas aleatórias de comprimento, digamos 8. O que você invariavelmente precisa é de um número de cadeias únicas , por exemplo, para usar como identificadores para algum propósito.

import {Random, Entropy} from 'entropy-string'

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

const string = random.string(bits)

"44hTNghjNHGGRHqH9"

entropy-string usa um conjunto de caracteres com 32 caracteres por padrão. Existem outros conjuntos predefinidos de caracteres, e você pode especificar os seus próprios caracteres também. Por exemplo, gerando IDs com a mesma entropia que acima, mas usando caracteres hex:

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

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

const string = random.string(bits)

"27b33372ade513715481f"

Note a diferença no comprimento do texto devido à diferença no número total de caracteres no conjunto de caracteres utilizado. O risco de repetição no número especificado de cadeias potenciais é o mesmo. Os comprimentos das cordas não são. E o melhor de tudo, o risco de repetir e o número potencial de strings é explícito. Chega de adivinhar com o comprimento do fio.

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