javascript - number - typescript random string




Generar cadenas/caracteres aleatorios en JavaScript (20)

Generador de cadenas aleatorias (Alfanumérico | Alfa | 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"

Que te diviertas. demo jsbin

Mientras que lo anterior usa comprobaciones adicionales para la salida deseada (A / N, A, N), analicemos lo esencial (sólo alfanumérico) para una mejor comprensión:

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

Imaginemos la tabla de personajes 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 ) ofrece un rango de 0..61 (lo que necesitamos). ¿Cómo arreglar (incrementar) el azar para obtener los rangos de caracteres 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 lógica de operación condicional de la tabla de arriba:

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

Si siguió la explicación anterior, debería poder crear este fragmento de código alfanumérico :

demo jsbin

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

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

Quiero una cadena de 5 caracteres compuesta de caracteres seleccionados al azar del conjunto [a-zA-Z0-9] .

¿Cuál es la mejor manera de hacer esto con JavaScript?


Corto, fácil y fiable.

Devuelve exactamente 5 caracteres aleatorios, a diferencia de algunas de las respuestas más 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;
}

Llama con el juego de caracteres predeterminado [a-zA-Z0-9] o envía el tuyo:

var randomValue = randomString(5);

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

Algoritmo rápido y mejorado. No garantiza 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;
}

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

Incluyendo 0-9a-z

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

Incluyendo 0-9a-zA-Z

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

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

la secuencia de comandos ejecuta makeid() 1 million veces y, como se puede ver, 5 no es algo único. ejecutarlo con una longitud de 10 caracteres es bastante confiable. Lo he corrido unas 50 veces y todavía no he visto un duplicado :-)

nota: el límite de tamaño de la pila de nodos supera los 4 millones, por lo que no puede ejecutar estos 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');

Creo que esto funcionará para usted:

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

console.log(makeid());


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 le desafiaría a que rara vez necesite cadenas aleatorias de longitud, por ejemplo 8. Lo que siempre necesita es un número de cadenas únicas , por ejemplo, para usar como identificadores para algún propósito.

Hay dos formas principales de obtener cadenas estrictamente únicas : determinísticamente (que no es aleatoria) y almacenar / comparar (que es onerosa). qué hacemos? Renunciamos al fantasma. Vamos con unicidad probabilística en su lugar. Es decir, aceptamos que existe un riesgo (por pequeño que sea) de que nuestras cadenas no sean únicas. Aquí es donde entender la probabilidad de colisión y la entropy son útiles.

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

Y aquí es donde una biblioteca como EntropyString puede ayudar. Para generar IDs aleatorios que tengan menos de 1 en un billón de posibilidades de repetición en 5 millones de cadenas utilizando 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-stringutiliza un conjunto de caracteres con 32 caracteres por defecto. Hay otros conjuntos de caracteres predefinidos, y también puede especificar sus propios caracteres. Por ejemplo, generar ID con la misma entropía que arriba 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 posibles es el mismo. Las longitudes de cadena no son. Y lo mejor de todo, el riesgo de repetición y el número potencial de cadenas es explícito. No más adivinanzas con la longitud de la cuerda.


Esto funciona seguro

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

Generar 10 caracteres de cadena larga. 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;
}

La solución más compacta, porque la slice es más corta que la substring . Restar del final de la cadena permite evitar el símbolo de punto flotante generado por developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… función developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… :

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


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

Soporte en minúsculas solamente:

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

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

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

Cambie los 5 en substr(2, 5) para ajustar la longitud que necesita.


Puede recorrer un conjunto 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));


Puedes usar coderain . Es una biblioteca para generar códigos aleatorios de acuerdo con el patrón dado. Use # como marcador de posición para los caracteres en mayúsculas y minúsculas, así como los 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 únicos .

Revelación completa: soy el autor de coderain.


Sé que todos ya lo han entendido bien, pero sentí que tenía ganas de hacerlo de la manera más liviana posible (ligero en el código, no en la 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));

Se necesita un poco de tiempo para comprenderlo, pero creo que realmente muestra cuán impresionante es la sintaxis de JavaScript.


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

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

Una nueva versión con operador de propagación es6 :

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

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

Math.random es malo para este tipo de cosas

Opción 1

Si puede hacer esto en el lado del servidor , solo use el módulo crypto

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

// "bb5dc8842ca31d4603d6aa11448d1654"

La cadena resultante será dos veces más larga que los bytes aleatorios que genere; Cada byte codificado en hexadecimal es de 2 caracteres. 20 bytes serán 40 caracteres de hex.

opcion 2

Si tiene que hacer este lado del cliente , tal vez pruebe el módulo uuid

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

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

Opcion 3

Si tiene que hacer este lado del cliente y no tiene que admitir navegadores antiguos, puede 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"


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


Ampliando el elegante ejemplo de Doubletap respondiendo a los problemas que Gertas y Dragon mencionaron. Simplemente agregue en 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 le alerta con un resultado: http://jsfiddle.net/pLJJ7/





random