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

Matemáticas.random es malo para este tipo de cosas

Opción 1

Si usted es capaz de hacer esto servidor -lado, solo tiene que utilizar el crypto módulo

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

// "bb5dc8842ca31d4603d6aa11448d1654"

La cadena resultante será el doble de larga que los bytes aleatorios que generes; cada byte codificado en hexadecimal es de 2 caracteres. 20 bytes serán 40 caracteres de hexadecimal.

Opción 2

Si tiene que hacer esto cliente - lado, tal vez pruebe el uuid módulo

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

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

Opción 3

Si tienes que hacer esto client-side y no tienes que soportar navegadores antiguos, puedes hacerlo sin dependencias

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

Aquí hay una mejora en la excelente respuesta de doubletap. El original tiene dos inconvenientes que se abordan aquí:

Primero, como otros han mencionado, tiene una pequeña probabilidad de producir cadenas cortas o incluso una cadena vacía (si el número aleatorio es 0), lo que puede romper su aplicación. Aquí hay una solución:

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

En segundo lugar, tanto el original como la solución anterior limitan el tamaño de cadena N a 16 caracteres. Lo siguiente devolverá una cadena de tamaño N para cualquier N (pero tenga en cuenta que el uso de N > 16 no aumentará la aleatoriedad o disminuirá la probabilidad de colisiones):

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

Explicación:

1. Elija un número aleatorio en el rango [0,1), es decir, entre 0 (inclusive) y 1 (exclusivo).
2. Convierte el número en una cadena base-36, es decir, usando caracteres 0-9 y a-z.
3. Pad con ceros (resuelve el primer problema).
4. Corta el 0 inicial.'prefijo y ceros de relleno extra.
5. Repita la cadena suficientes veces para tenga al menos N caracteres (uniendo cadenas vacías con la cadena aleatoria más corta utilizada como delimitador).
6. Corta exactamente N caracteres de la cadena.

Otros pensamientos:

• Esta solución no utiliza letras mayúsculas, pero en casi todos los casos (sin juego de palabras) no importa.
• La longitud máxima de cadena en N = 16 en la respuesta original se mide en Chrome. En Firefox es N = 11. Pero como se explicó, la segunda solución es acerca de admite cualquier longitud de cadena solicitada, no se trata de agregar aleatoriedad, por lo que no hace mucha diferencia.
• Todas las cadenas devueltas tienen la misma probabilidad de ser devueltas, al menos en lo que respecta a los resultados devueltos por Math.random() se distribuyen uniformemente (esto no es aleatoriedad de fuerza criptográfica, en cualquier caso).
• No todas las cadenas posibles de tamaño N pueden ser devueltas. En la segunda solución esto es obvio (ya que la cadena más pequeña simplemente se está duplicando), pero también en la respuesta original esto es cierto ya que en la conversión a base - 36 los últimos bits pueden no ser parte de los bits aleatorios originales. Específicamente, si nos fijamos en el resultado de las matemáticas.aleatorio().toString (36), notarás que el último carácter no está distribuido uniformemente. De nuevo, en casi todos los casos no importa, pero cortamos la cadena final desde el principio en lugar del final de la cadena aleatoria para que las cadenas cortas (por ejemplo, N=1) no sean afectar.

Actualización:

Aquí hay un par de otros one-liners de estilo funcional que se me ocurrió. Difieren de la solución anterior en que:

• Utilizan un alfabeto arbitrario explícito (más genérico, y adecuado para la pregunta original que pedía letras mayúsculas y minúsculas).
• Todas las cadenas de longitud N tienen la misma probabilidad de ser devueltas (es decir, las cadenas no contienen repeticiones).
• se basan en un mapa función, en lugar del truco toString(36), que los hace más sencillos y fáciles de entender.

Por lo tanto, digamos que su alfabeto de elección es

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Entonces estos dos son equivalentes entre sí, por lo que puede elegir lo que sea más intuitivo para usted:

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

Y

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

Editar:

Parece que qubyte y Martijn de Milliano llegaron a soluciones similares a la última (kudos!), que de alguna manera me perdí. Ya no se ven tan cortos a simple vista, lo dejaré aquí de todos modos en caso de que alguien realmente quiera una sola línea: -)

También, se reemplazó 'nueva matriz' por 'Matriz' en todas las soluciones para reducir algunos bytes más.

Corto, fácil y fiable

Devuelve exactamente 5 caracteres aleatorios, a diferencia de algunas de las respuestas mejor valoradas que se encuentran aquí.

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

Algo como esto debería funcionar

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

Llame con el conjunto de caracteres predeterminado [a -A-Z0-9] o envíe el suyo propio:

var randomValue = randomString(5);

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

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

La solución más compacta, porque slice es más corto que substring. Restar del final de la cadena permite evitar el símbolo de coma flotante generado por random función:

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

O incluso

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

Generador de Cadenas Aleatorias (Alfanumérico | Alfanumérico | Numérico)

/**
 * RANDOM STRING GENERATOR
 *
 * Info:      http://stackoverflow.com/a/27872144/383904
 * Use:       randomString(length [,"A"] [,"N"] );
 * Default:   return a random alpha-numeric string
 * Arguments: If you use the optional "A", "N" flags:
 *            "A" (Alpha flag)   return random a-Z string
 *            "N" (Numeric flag) return random 0-9 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;
}

randomString(10);        // "4Z8iNQag9v"
randomString(10, "A");   // "aUkZuHNcWw"
randomString(10, "N");   // "9055739230"

Diviértete. jsBin demo

Mientras que lo anterior utiliza comprobaciones adicionales para la salida deseada (A / N, A, N), desglosemos lo esencial (solo Alfanumérico) para una mejor comprensión:

• Crear una función que acepte un argumento (longitud deseada del resultado de la cadena aleatoria)
• Crear una cadena vacía como var str = ""; para concatenar caracteres aleatorios
• Dentro de un bucle crear un número de índice rand de 0 a 61 (0..9 + A..Z+a..z = 62)
• Crear una lógica condicional para Ajustar / corregir rand (ya que es 0..61) incrementándolo en algún número (ver ejemplos a continuación) para recuperar el número CharCode correcto y el Carácter relacionado.
• Dentro del bucle concatenar a str a String.fromCharCode( incremented rand )

Imaginemos la tabla de caracteres y sus rangos:

_____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 ) da un rango de 0..61 (lo que necesitamos). ¿Cómo arreglar (incrementar) el aleatorio para obtener los rangos de charCode correctos?

      |   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 operación condicional lógica de la tabla anterior:

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

Si siguió la explicación anterior, debería ser capaz de crear este fragmento alfanumérico :

jsBin demo

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) ); // "7GL9F0ne6t"

O si se:

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

La forma más sencilla es:

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

Esto genera cadenas aleatorias de 5 caracteres basados en la hora actual. Ejemplo de salida es 4mtxj o 4mv90 o 4mwp1

El problema con esto es que si lo llamas dos veces en el mismo segundo, generará la misma cadena.

La forma más segura es:

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

Esto generará una cadena aleatoria de 4 o 5 caracteres, siempre diferentes. La salida de ejemplo es como 30jzm o 1r591 o 4su1a

En ambos sentidos la primera parte genera un número aleatorio. La parte .toString(36) lanza el número a una representación base36 (alfadecimal) del mismo.

Una versión más reciente con es6 operador de propagación :

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

• El 30 es un número arbitrario, puede elegir cualquier longitud de token que desee
• El 36 es el número radix máximo que puede pasar a numérico.toString () , que significa todos los números y letras minúsculas de la a a la z
• El 3 se usa para elegir el 3er número de la cadena aleatoria que se ve así: "0.mfbiohx64i", podríamos tomar cualquier índice después de 0.

Aquí hay algunas frases fáciles. Cambie new Array(5) para establecer la longitud.

Incluido 0-9a-z

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

Incluido 0-9a-zA-Z

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

Si estás usando Lodash o Underscore , entonces es tan simple:

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

Sé que todo el mundo tiene razón ya, pero me sentí como tener una oportunidad en este de la manera más ligera posible (luz en el código, no 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));

Toma un poco de tiempo envolver tu cabeza, pero creo que realmente muestra lo impresionante que es la sintaxis de javascript.

Suponiendo que use underscorejs es posible generar elegantemente cadenas aleatorias en solo dos líneas:

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

Este es el método que he creado.
Creará una cadena que contenga caracteres mayúsculas y minúsculas.
Además he incluido la función que creará una cadena alfanumérica también.

Ejemplos de Trabajo:
http://jsfiddle.net/greatbigmassive/vhsxs/ (alfa sólo)
http://jsfiddle.net/greatbigmassive/PJwg8/ (alfanumérico)

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

Actualización julio 2015
Esto hace lo mismo pero tiene más sentido y incluye todas las 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)));
}

En caso de que alguien esté interesado en una línea única (aunque no formateada como tal para su conveniencia) que asigne la memoria a la vez (pero tenga en cuenta que para cadenas pequeñas realmente no importa) aquí es cómo hacerlo:

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

Puede reemplazar 5 por la longitud de la cadena que desea. Gracias a @AriyaHidayat en este post para la solución a la función map que no funciona en la matriz dispersa creada por Array(5).

Para cumplir con el requisito [a -A-Z0-9] y length = 5 use

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

Se producirán letras minúsculas, mayúsculas y números.

Algoritmo rápido y mejorado. No garantiza la uniformidad (ver comentarios).

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

Esto es lo más limpio posible. Es rápido también, http://jsperf.com/ay-random-string .

Puede recorrer una matriz de elementos y agregarlos recursivamente a una variable de cadena, por ejemplo, si desea una secuencia de ADN aleatoria:

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

No encontré una solución limpia para soportar tanto caracteres en minúsculas como en mayúsculas.

Solo soporte en minúsculas:

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

Basándose en esa solución para soportar minúsculas y mayúsculas:

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

Cambia el 5 en substr(2, 5) para ajustarlo a la longitud que necesitas.

¿Qué tal algo como esto: Date.now().toString(36) No muy aleatorio, pero corto y bastante único cada vez que lo llamas.

Esto funciona con seguridad

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

Genera una cadena de 10 caracteres. La longitud se establece por parámetro (por defecto 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;
}

Aquí hay un script de prueba para la respuesta #1 (gracias @csharptest.net)

El script se ejecuta makeid() 1 million tiempos y como se puede ver 5 no es un muy único. ejecutarlo con una longitud de carbón de 10 es bastante confiable. He corrido alrededor de 50 veces y no he visto un duplicado todavía :-)

Nota: el límite de tamaño de la pila de nodos excede alrededor de 4 millones, por lo que no puede ejecutar este 5 millones de veces que nunca terminará.

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

Puede usar coderain. Es una biblioteca para generar códigos aleatorios de acuerdo con el patrón dado. Use # como marcador de posición para caracteres mayúsculas y minúsculas, así como dígitos:

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

Hay otros marcadores de posición como A para las letras mayúsculas o 9 para los dígitos.

Lo que puede ser útil es que llamar a .next() siempre le dará un resultado único para que no tenga que preocuparse por los duplicados.

Aquí hay una aplicación de demostración que genera una lista de códigos aleatorios .

Revelación completa: Soy el autor de coderain.

¿Qué tal este pequeño truco compacto?

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

Necesita el Array.apply allí para engañar a la matriz vacía para que sea una matriz de indefinidos.

Si está codificando para ES2015, entonces construir la matriz es un poco más simple:

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

El problema con las respuestas a las preguntas "Necesito cadenas aleatorias" (en cualquier idioma) es que prácticamente todas las soluciones utilizan una especificación primaria defectuosa de la longitud de la cadena . Las preguntas en sí rara vez revelan por qué se necesitan las cadenas aleatorias, pero yo desafiaría a que rara vez se necesitan cadenas aleatorias de longitud, digamos 8. Lo que invariablemente necesita es algún número de cadenas únicas, por ejemplo, para usar como identificadores para algún propósito.

Hay dos líderes formas de obtener cadenas estrictamente únicas: deterministamente (que no es aleatorio) y almacenar/comparar (que es oneroso). ¿Qué hacemos? Renunciamos al fantasma. Vamos con singularidad probabilística en su lugar. Es decir, aceptamos que existe algún riesgo (por pequeño que sea) de que nuestras cadenas no sean únicas. Aquí es donde la comprensión probabilidad de colisión y entropía son útiles.

Así que voy a reformular la necesidad invariable como la necesidad de algunos número de cadenas con un pequeño riesgo de repetición. Como ejemplo concreto, digamos que desea generar un potencial de 5 millones de ID. No desea almacenar y comparar cada cadena nueva, y desea que sean aleatorias, por lo que acepta algún riesgo de repetición. Como ejemplo, digamos un riesgo de menos de 1 en un trillón de probabilidad de repetición. Entonces, ¿qué longitud de cuerda necesitas? Bueno, esa pregunta es poco específica, ya que depende de los caracteres utilizados. Pero lo más importante es que está equivocado. Lo que necesitas es un especificación de la entropía de las cuerdas, no de su longitud. La entropía puede estar directamente relacionada con la probabilidad de una repetición en algún número de cuerdas. La longitud de la cadena no puede.

Y aquí es donde una biblioteca como EntropyString puede ayudar. Para generar ID aleatorios que tienen menos de 1 en un trillón de probabilidad de repetición en 5 millones de cadenas 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-string utiliza un conjunto de caracteres con 32 caracteres por defecto. Alli son otros conjuntos de caracteres predefinidos, y también puede especificar sus propios caracteres. Por ejemplo, generando IDs con la misma entropía que la anterior pero usando caracteres hexadecimales:

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

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

const string = random.string(bits)

"27b33372ade513715481f"

Tenga en cuenta la diferencia en la longitud de la cadena debido a la diferencia en el número total de caracteres en el conjunto de caracteres utilizado. El riesgo de repetición en el número especificado de cadenas potenciales es el mismo. Las longitudes de las cuerdas no lo son. Y lo mejor de todo, el riesgo de repetir y el número potencial de cadenas es explícito. No más adivinanzas con la longitud de la cuerda.

Ampliando el elegante ejemplo de Doubletap respondiendo a los problemas que Gertas y Dragon mencionaron. Simplemente agregue un bucle while para probar esas raras circunstancias nulas y limite los caracteres a cinco.

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

Aquí hay un jsfiddle que te alerta con un resultado: http://jsfiddle.net/pLJJ7 /