Voglio una stringa di 5 caratteri composta da personaggi scelti casualmente dal set [a-zA-Z0-9].

Qual è il modo migliore per farlo con JavaScript?

Penso che questo funzionerà per te:

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

Nota: l'algoritmo sopra riportato presenta i seguenti punti deboli:

• Genererà ovunque tra 0 e 6 caratteri a causa del fatto che gli zeri finali vengono rimossi quando si stringono i punti mobili.
• Dipende profondamente dall'algoritmo utilizzato per stringere i numeri in virgola mobile, che è terribilmente complesso. (Vedi il documento "Come stampare con precisione i numeri in virgola mobile" .)
• Math.random()può produrre un output prevedibile ("dall'aspetto casuale" ma non realmente casuale) a seconda dell'implementazione. La stringa risultante non è adatta quando è necessario garantire unicità o imprevedibilità.
• Anche se ha prodotto 6 personaggi uniformemente casuali e imprevedibili, puoi aspettarti di vedere un duplicato dopo aver generato solo circa 50.000 stringhe, a causa del paradosso del compleanno . (sqrt (36 ^ 6) = 46656)

Math.random è dannoso per questo tipo di cose

opzione 1

Se riesci a fare questo lato server , usa semplicemente il modulo crypto -

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

// "bb5dc8842ca31d4603d6aa11448d1654"

La stringa risultante sarà lunga il doppio dei byte casuali generati; ogni byte codificato in esadecimale è di 2 caratteri. 20 byte saranno 40 caratteri esadecimali.

opzione 2

Se devi fare questo lato client , forse prova il modulo uuid -

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

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

Opzione 3

Se devi fare questo lato client e non devi supportare i vecchi browser, puoi farlo senza dipendenze -

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

Per ulteriori informazioni su crypto.getRandomValues-

Il crypto.getRandomValues()metodo consente di ottenere valori casuali crittograficamente forti. L'array fornito come parametro è riempito con numeri casuali (casuale nel suo significato crittografico).

Ecco un piccolo esempio di console:

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

Per il supporto IE11 è possibile utilizzare -

(window.crypto || window.msCrypto).getRandomValues(arr)

Per la copertura del browser, consultare https://caniuse.com/#feat=getrandomvalues

Breve, facile e affidabile

Restituisce esattamente 5 caratteri casuali, al contrario di alcune delle risposte più votate trovate qui.

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

Ecco un miglioramento sulla risposta eccellente di doubletap . L'originale presenta due inconvenienti che sono affrontati qui:

In primo luogo, come altri hanno già detto, ha una piccola probabilità di produrre stringhe brevi o persino una stringa vuota (se il numero casuale è 0), che potrebbe interrompere l'applicazione. Ecco una soluzione:

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

In secondo luogo, sia l'originale che la soluzione sopra limitano la dimensione della stringa N a 16 caratteri. Di seguito verrà restituita una stringa di dimensione N per qualsiasi N (ma si noti che l'uso di N> 16 non aumenterà la casualità o diminuirà la probabilità di collisioni):

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

Spiegazione:

1. Scegli un numero casuale nell'intervallo [0,1), ovvero tra 0 (incluso) e 1 (esclusivo).
2. Converti il ​​numero in una stringa di base 36, cioè usando i caratteri 0-9 e az.
3. Pad con zeri (risolve il primo numero).
4. Taglia il principale '0.' prefisso e zeri di riempimento extra.
5. Ripeti la stringa abbastanza volte da contenere almeno N caratteri (Unendo le stringhe vuote con la stringa casuale più corta utilizzata come delimitatore).
6. Taglia esattamente N caratteri dalla stringa.

Ulteriori pensieri:

• Questa soluzione non utilizza lettere maiuscole, ma in quasi tutti i casi (non è previsto il gioco di parole) non importa.
• La lunghezza massima della stringa a N = 16 nella risposta originale viene misurata in Chrome. In Firefox è N = 11. Ma, come spiegato, la seconda soluzione riguarda il supporto di qualsiasi lunghezza di stringa richiesta, non l'aggiunta di casualità, quindi non fa molta differenza.
• Tutte le stringhe restituite hanno la stessa probabilità di essere restituite, almeno nella misura in cui i risultati restituiti da Math.random () sono distribuiti uniformemente (questa non è casualità di forza crittografica, in ogni caso).
• Non è possibile restituire tutte le stringhe possibili di dimensione N. Nella seconda soluzione questo è ovvio (poiché la stringa più piccola viene semplicemente duplicata), ma anche nella risposta originale ciò è vero poiché nella conversione in base-36 gli ultimi bit potrebbero non far parte dei bit casuali originali. In particolare, se guardi il risultato di Math.random (). ToString (36), noterai che l'ultimo carattere non è distribuito uniformemente. Ancora una volta, in quasi tutti i casi non importa, ma tagliamo la stringa finale dall'inizio piuttosto che la fine della stringa casuale in modo che le stringhe corte (ad es. N = 1) non siano interessate.

Aggiornare:

Qui ci sono un paio di altri one-liner in stile funzionale che ho ideato. Differiscono dalla soluzione sopra in quanto:

• Usano un alfabeto arbitrario esplicito (più generico e adatto alla domanda originale che chiedeva sia lettere maiuscole che minuscole).
• Tutte le stringhe di lunghezza N hanno la stessa probabilità di essere restituite (ovvero le stringhe non contengono ripetizioni).
• Si basano su una funzione della mappa, piuttosto che sul trucco toString (36), che li rende più semplici e facili da capire.

Quindi, supponiamo che il tuo alfabeto preferito sia

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Quindi questi due sono equivalenti tra loro, quindi puoi scegliere quello che è più intuitivo per te:

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

Modificare:

Mi sembra che il qubyte e Martijn de Milliano abbiano escogitato soluzioni simili a quest'ultima (complimenti!), Che in qualche modo mi mancavano. Dal momento che non sembrano a prima vista, lo lascerò comunque nel caso in cui qualcuno voglia davvero un one-liner :-)

Inoltre, ha sostituito il "nuovo array" con "Array" in tutte le soluzioni per eliminare qualche byte in più.

La soluzione più compatta, perché sliceè più corta di substring. La sottrazione dall'estremità della stringa consente di evitare il simbolo a virgola mobile generato dalla randomfunzione:

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

o anche

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

Aggiornamento: aggiunto un altro approccio usando il btoametodo:

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

Qualcosa del genere dovrebbe funzionare

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

Chiama con il set di caratteri predefinito [a-zA-Z0-9] o invia il tuo:

var randomValue = randomString(5);

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

Una versione più recente con operatore di diffusione es6 :

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

• È un 30numero arbitrario, puoi scegliere la lunghezza del token che desideri
• Il 36è il numero massimo radix è possibile passare a numeric.toString () , il che significa che tutti i numeri e le lettere minuscole az
• Il 2viene utilizzato per raccogliere l'indice 3 ° dalla stringa casuale che assomiglia a questo: "0.mfbiohx64i"potremmo prendere qualsiasi indice dopo0.

Generatore di stringhe casuali (alfanumerico | alfa | numerico)

/**
 * 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"

Mentre quanto sopra utilizza controlli aggiuntivi per l' output A / N, A, N desiderato, analizziamo l'essenziale (solo alfanumerico) per una migliore comprensione:

• Creare una funzione che accetta un argomento (lunghezza desiderata del risultato String casuale)
• Crea una stringa vuota come var str = "";concatenare caratteri casuali
• All'interno di un ciclo creare un randnumero indice compreso tra 0 e 61 (0..9 + A..Z + a..z = 62)
• Crea una logica condizionale per regolare / correggererand (dato che è 0..61) incrementandola di un numero (vedi esempi sotto) per ottenere il CharCodenumero giusto e il carattere correlato.
• All'interno del ciclo concatenare ad strunString.fromCharCode( incremented rand )

Immaginiamo gli intervalli della tabella dei caratteri 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 )dà una gamma da 0..61(ciò di cui abbiamo bisogno).
Risolviamo il casuale per ottenere gli intervalli charCode corretti :

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

La logica dell'operazione condizionale dalla tabella sopra:

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

Dalla spiegazione sopra, ecco lo snippet alfanumerico risultante :

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"

O se vuoi:

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

Il modo più semplice è:

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

Questo genera stringhe casuali di 5 caratteri in base all'ora corrente. L'output di esempio è 4mtxjo 4mv90o4mwp1

Il problema è che se lo chiami due volte nello stesso secondo, genererà la stessa stringa.

Il modo più sicuro è:

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

Questo genererà una stringa casuale di 4 o 5 caratteri, sempre diversa. L'output di esempio è come 30jzmo 1r591o4su1a

In entrambi i modi la prima parte genera un numero casuale. La .toString(36)parte ha lanciato il numero su una rappresentazione base36 (alfa-decimale).

Ecco alcune semplici linee. Cambia new Array(5)per impostare la lunghezza.

Compreso 0-9a-z

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

Compreso 0-9a-zA-Z

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

So che tutti hanno già capito bene, ma mi è sembrato di provarlo nel modo più leggero possibile (codice leggero, non 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));

Ci vuole un po 'di tempo per avvolgere la testa, ma penso che mostri davvero quanto sia fantastica la sintassi di JavaScript.

Se stai usando Lodash o Underscore , è così semplice:

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

Per soddisfare il requisito [a-zA-Z0-9] e lunghezza = 5 utilizzare

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

Verranno visualizzate lettere minuscole, lettere maiuscole e numeri.

Nel caso in cui qualcuno sia interessato a un one-liner (anche se non formattato come tale per comodità) che alloca la memoria in una sola volta (ma nota che per le stringhe di piccole dimensioni non importa davvero) ecco come farlo:

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

Puoi sostituirlo 5con la lunghezza della stringa che desideri. Grazie a @AriyaHidayat in questo post per la soluzione alla mapfunzione che non funziona sull'array sparse creato da Array(5).

Ecco il metodo che ho creato.
Creerà una stringa contenente caratteri sia maiuscoli che minuscoli.
Inoltre ho incluso la funzione che creerà anche una stringa alfanumerica.

Esempi di lavoro:
http://jsfiddle.net/greatbigmassive/vhsxs/ (solo alfa)
http://jsfiddle.net/greatbigmassive/PJwg8/ (alfanumerico)

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

Aggiornamento luglio 2015
Fa la stessa cosa ma ha più senso e include tutte le lettere.

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

Supponendo che tu usi underscorejs è possibile generare elegantemente una stringa casuale in sole due righe:

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

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

Algoritmo veloce e migliorato. Non garantisce l'uniforme (vedi commenti).

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

Il problema con le risposte alle domande "Ho bisogno di stringhe casuali" (in qualsiasi lingua) è praticamente ogni soluzione utilizza una specifica primaria imperfetta della lunghezza della stringa . Le domande stesse raramente rivelano il motivo per cui sono necessarie stringhe casuali, ma sfiderei che raramente hai bisogno di stringhe casuali di lunghezza, diciamo 8. Ciò di cui hai inevitabilmente bisogno è un numero di stringhe uniche , ad esempio, da usare come identificatori per qualche scopo.

Esistono due modi principali per ottenere stringhe rigorosamente uniche : deterministicamente (che non è casuale) e store / compare (che è oneroso). Cosa facciamo? Rinunciamo al fantasma. Andiamo invece con unicità probabilistica . Cioè, accettiamo che ci sia qualche (anche se piccolo) rischio che le nostre stringhe non siano uniche. È qui che sono utili la comprensione della probabilità di collisione e dell'entropia .

Quindi riformulerò il bisogno invariabile in quanto necessitano di un numero di stringhe con un piccolo rischio di ripetizione. Ad esempio, supponiamo che tu voglia generare un potenziale di 5 milioni di ID. Non vuoi archiviare e confrontare ogni nuova stringa e vuoi che siano casuali, quindi accetti qualche rischio di ripetizione. Ad esempio, diciamo un rischio inferiore a 1 in una trilione di possibilità di ripetizione. Quindi di quale lunghezza hai bisogno? Bene, questa domanda è sottostimata in quanto dipende dai personaggi usati. Ma soprattutto, è fuorviato. Ciò di cui hai bisogno è una specifica dell'entropia delle stringhe, non della loro lunghezza. L'entropia può essere direttamente correlata alla probabilità di una ripetizione in un certo numero di stringhe. La lunghezza della stringa non può.

Ed è qui che può aiutare una libreria come EntropyString . Per generare ID casuali che hanno meno di 1 in trilioni di possibilità di ripetizione in 5 milioni di stringhe usando 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-stringutilizza un set di caratteri con 32 caratteri per impostazione predefinita. Esistono altri set di caratteri predefiniti e puoi anche specificare i tuoi personaggi. Ad esempio, generare ID con la stessa entropia di cui sopra ma utilizzando caratteri esadecimali:

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

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

const string = random.string(bits)

"27b33372ade513715481f"

Notare la differenza nella lunghezza della stringa dovuta alla differenza nel numero totale di caratteri nel set di caratteri utilizzato. Il rischio di ripetizione nel numero specificato di stringhe potenziali è lo stesso. Le lunghezze delle stringhe non lo sono. E soprattutto, il rischio di ripetizione e il potenziale numero di stringhe sono espliciti. Non dovrai più indovinare con la lunghezza della stringa.

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

Questo è pulito come sarà. È anche veloce, http://jsperf.com/ay-random-string .

È possibile eseguire il ciclo tra una serie di elementi e aggiungerli in modo ricorsivo a una variabile stringa, ad esempio se si desidera una sequenza casuale di DNA:

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

Non ho trovato una soluzione pulita per supportare sia i caratteri minuscoli che maiuscoli.

Supporto solo in minuscolo:

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

Basandosi su quella soluzione per supportare lettere minuscole e maiuscole:

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

Cambia 5in substr(2, 5)per regolare la lunghezza che ti serve.

Una fodera:

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

Questo funziona di sicuro

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

Che ne dici di qualcosa del genere: Date.now().toString(36) non molto casuale, ma breve e piuttosto unico ogni volta che lo chiami.

Caratteri alfanumerici insensibili alle maiuscole:

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

Il vantaggio di questa funzione è che puoi ottenere una stringa casuale di diversa lunghezza e garantisce la lunghezza della stringa.

Tutti i caratteri sensibili al maiuscolo / minuscolo:

function randStr(len) {
  let s = '';
  while (len--) s += String.fromCodePoint(Math.floor(Math.random() * (126 - 33) + 33));
  return s;
}

// usage
console.log(randStr(50));

Caratteri personalizzati

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

Genera una stringa lunga di 10 caratteri. La lunghezza è impostata dal parametro (valore predefinito 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;
}

Puoi usare coderain . È una libreria per generare codici casuali secondo uno schema dato. Utilizzare #come segnaposto per caratteri maiuscoli e minuscoli e cifre:

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

Esistono altri segnaposto come Alettere maiuscole o 9cifre.

Ciò che può essere utile è che chiamare .next()ti darà sempre un risultato unico, così non dovrai preoccuparti dei duplicati.

Ecco un'applicazione demo che genera un elenco di codici casuali univoci .

Divulgazione completa: sono l'autore di Coderain.