web-dev-qa-db-fra.com

Générer des chaînes/caractères aléatoires en JavaScript

Je veux une chaîne de 5 caractères composée de caractères choisis au hasard dans l'ensemble [a-zA-Z0-9].

Quelle est la meilleure façon de faire cela avec JavaScript?

1348
Tom Lehman

Je pense que cela fonctionnera pour vous:

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

1873
csharptest.net

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

Remarque: l'algorithme ci-dessus présente les faiblesses suivantes:

  • Il générera entre 0 et 6 caractères en raison du fait que les zéros de fin sont supprimés lors de la chaîne de caractères des points flottants.
  • Cela dépend profondément de l'algorithme utilisé pour stringer les nombres en virgule flottante, ce qui est horriblement complexe. (Voir l'article "Comment imprimer des nombres en virgule flottante avec précision" .)
  • Math.random() peut produire une sortie prévisible ("aléatoire" mais pas vraiment aléatoire) en fonction de l'implémentation. La chaîne résultante ne convient pas lorsque vous devez garantir l'unicité ou l'imprévisibilité.
  • Même si elle produisait 6 caractères aléatoires et imprévisibles de manière uniforme, vous pouvez vous attendre à une copie après avoir généré seulement environ 50 000 chaînes, en raison du paradoxe anniversaire . (sqrt (36 ^ 6) = 46656)
1969
doubletap

Math.random est mauvais pour ce genre de chose

Option 1

Si vous êtes capable de faire cela serveur-, utilisez simplement le module crypto

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

// "bb5dc8842ca31d4603d6aa11448d1654"

La chaîne résultante sera deux fois plus longue que les octets aléatoires que vous générez; chaque octet encodé en hexadécimal est composé de 2 caractères. 20 octets seront 40 caractères hexadécimaux.


Option 2

Si vous devez faire cela client-, essayez peut-être le module uuid

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

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

Option 3

Si vous devez faire ceci client- et que vous n'avez pas à supporter les anciens navigateurs, vous pouvez le faire sans dépendances

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

302
user633183

Court, facile et fiable

Renvoie exactement 5 caractères aléatoires, par opposition à certaines des réponses les mieux notées trouvées ici.

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

Voici une amélioration de l'excellente réponse de doubletap . L'original a deux inconvénients qui sont abordés ici:

Tout d’abord, comme d’autres l’ont déjà mentionné, il existe une faible probabilité que des chaînes courtes ou même vides (si le nombre aléatoire est 0) soient générées, ce qui risque de briser votre application. Voici une solution:

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

Deuxièmement, l’original et la solution ci-dessus limitent la taille de chaîne N à 16 caractères. Les éléments suivants renverront une chaîne de taille N pour tout N (mais notez que l'utilisation de N> 16 n'augmentera pas le caractère aléatoire ni la probabilité de collision):

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

Explication:

  1. Choisissez un nombre aléatoire compris dans l’intervalle [0,1), c’est-à-dire entre 0 (inclus) et 1 (exclusif).
  2. Convertissez le nombre en chaîne base 36, c’est-à-dire en utilisant les caractères 0 à 9 et a-z.
  3. Pad avec zéros (résout le premier problème).
  4. Couper le «0» en tête préfixes et zéros de remplissage supplémentaires.
  5. Répétez la chaîne suffisamment de fois pour contenir au moins N caractères (en joignant des chaînes vides avec la chaîne aléatoire la plus courte utilisée comme délimiteur).
  6. Tranche exactement N caractères de la chaîne.

Autres réflexions:

  • Cette solution n'utilise pas de lettres majuscules, mais dans presque tous les cas (sans jeu de mots), cela n'a pas d'importance.
  • La longueur maximale de la chaîne N = 16 dans la réponse initiale est mesurée en chrome. Dans Firefox, il s'agit de N = 11. Mais comme expliqué précédemment, la deuxième solution consiste à prendre en charge la longueur de chaîne demandée et non à ajouter un caractère aléatoire. Elle ne fait donc pas une grande différence.
  • Toutes les chaînes renvoyées ont une probabilité égale d'être renvoyées, au moins dans la mesure où les résultats renvoyés par Math.random () sont également distribués (ce n'est pas aléatoire, de manière cryptographique).
  • Toutes les chaînes possibles de taille N ne peuvent pas être retournées. Ceci est évident dans la deuxième solution (puisque la chaîne la plus petite est simplement dupliquée), mais cela est également vrai dans la réponse d'origine, car lors de la conversion en base 36, les derniers bits peuvent ne pas faire partie des bits aléatoires d'origine. Plus précisément, si vous regardez le résultat de Math.random (). ToString (36), vous remarquerez que le dernier caractère n’est pas distribué de manière égale. Encore une fois, dans presque tous les cas, cela n'a pas d'importance, mais nous coupons la dernière chaîne au début plutôt que la fin de la chaîne aléatoire de manière à ne pas affecter les chaînes courtes (par exemple, N = 1).

Mettre à jour:

Voici quelques autres modèles monolithes fonctionnels que j'ai créés. Ils diffèrent de la solution ci-dessus en ce que:

  • Ils utilisent un alphabet arbitraire explicite (plus générique, et adapté à la question initiale qui demandait à la fois des lettres majuscules et minuscules).
  • Toutes les chaînes de longueur N ont une probabilité égale d’être renvoyées (c’est-à-dire que les chaînes ne contiennent aucune répétition).
  • Ils sont basés sur une fonction map plutôt que sur l'astuce toString (36), ce qui les rend plus simples et faciles à comprendre.

Alors, dites que votre alphabet de choix est

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Ensuite, ces deux sont équivalents, vous pouvez donc choisir celle qui vous semble la plus intuitive:

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

et

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

Modifier:

Il me semble que qubyte et Martijn de Milliano ont proposé des solutions similaires à celle-ci (félicitations!), Qui me manquaient. Comme ils ne semblent pas aussi courts en un coup d'œil, je vais le laisser ici au cas où quelqu'un voudrait vraiment un one-liner :-)

Également, remplacé «new Array» par «Array» dans toutes les solutions pour supprimer quelques octets supplémentaires.

139
amichair

Quelque chose comme ça devrait marcher

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

Appelez avec le jeu de caractères par défaut [a-zA-Z0-9] ou envoyez le vôtre:

var randomValue = randomString(5);

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

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

67
kennebec

La solution la plus compacte, car slice est plus courte que substring . La soustraction de la fin de la chaîne permet d’éviter les symboles en virgule flottante générés par random function:

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

ou même

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

59
Valentin

Générateur de chaîne aléatoire (Alpha-Numeric | Alpha | Numeric)

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

S'amuser. jsBin demo


Alors que ce qui précède utilise des vérifications supplémentaires pour le résultat souhaité (A/N, A, N), divisons-le en éléments essentiels (alphanumérique uniquement) pour une meilleure compréhension:

  • Créer une fonction qui accepte un argument (longueur souhaitée du résultat aléatoire de la chaîne)
  • Créez une chaîne vide comme var str = ""; pour concaténer des caractères aléatoires
  • Dans une boucle créer un numéro Rand de 0 à 61 (0..9 + A..Z + a..z = 62)
  • Créez une logique conditionnelle pour Ajuster/corriger Rand (puisqu'il s'agit de 0..61) en l'incrémentant d'un nombre (voir les exemples ci-dessous) pour obtenir le nombre correct CharCode et le caractère associé.
  • À l’intérieur de la boucle, concaténez-vous à str une String.fromCharCode( incremented Rand )

Imaginons la table Character et leurs plages:

_____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 ) donne une plage de 0..61 (ce dont nous avons besoin). Comment corriger (incrémenter) la valeur aléatoire pour obtenir les plages correctes charCode?

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

Le opération conditionnelle logic du tableau ci-dessus:

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

Si vous avez suivi l'explication ci-dessus, vous devriez pouvoir créer cet extrait alphanumérique:

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"

ou si vous voulez:

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;
}
45
Roko C. Buljan

Le moyen le plus simple est: 

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

Cela génère des chaînes aléatoires de 5 caractères en fonction de l'heure actuelle. Exemple de sortie: 4mtxj ou 4mv90 ou 4mwp1

Le problème, c'est que si vous l'appelez deux fois à la même seconde, la même chaîne sera générée. 

Le moyen le plus sûr est: 

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

Cela générera une chaîne aléatoire de 4 ou 5 caractères, toujours différente. Exemple de sortie ressemblant à 30jzm ou 1r591 ou 4su1a

Dans les deux cas, la première partie génère un nombre aléatoire. La partie .toString(36) transtype le nombre en une représentation base36 (alphadecimal). 

29
MasqueradeCircus

Voici quelques lignes faciles. Modifiez new Array(5) pour définir la longueur.

Y compris 0-9a-z

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

Y compris 0-9a-zA-Z

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

Je sais que tout le monde a déjà compris, mais j'avais envie d'essayer celui-ci de la manière la plus légère possible (code léger, pas de processeur):

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

console.log(Rand(5));

Cela prend un peu de temps pour réfléchir, mais je pense que cela montre à quel point la syntaxe de javascript est géniale.

17
Roderick

Si vous utilisez Lodash ou Underscore , alors c'est si simple:

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

Voici la méthode que j'ai créée.
Il créera une chaîne contenant à la fois des caractères majuscules et minuscules.
En outre, j'ai inclus la fonction qui créera également une chaîne alphanumérique.

Exemples de travail:
http://jsfiddle.net/greatbigmassive/vhsxs/ (alpha uniquement)
http://jsfiddle.net/greatbigmassive/PJwg8/ (alphanumérique)

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

Mise à jour juillet 2015
Cela fait la même chose mais a plus de sens et inclut toutes les lettres.

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

En supposant que vous utilisiez underscorejs , il est possible de générer élégamment une chaîne aléatoire en seulement deux lignes:

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

Si vous êtes intéressé par un one-liner (bien que non formaté en tant que tel pour votre commodité) qui alloue la mémoire à la fois (mais notez que pour les petites chaînes, cela n'a pas d'importance), voici comment procéder:

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

Vous pouvez remplacer 5 par la longueur de la chaîne souhaitée. Merci à @AriyaHidayat dans cet article pour la solution à la fonction map qui ne fonctionne pas sur le tableau fragmenté créé par Array(5).

11
Martijn de Milliano

Pour répondre à l'exigence [a-zA-Z0-9] et à la longueur = 5, utilisez

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

Des lettres minuscules, des lettres majuscules et des chiffres vont apparaître.

11
Sergio Cabral

Algorithme rapide et amélioré. Ne garantit pas l'uniforme (voir commentaires).

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

Vous pouvez parcourir un tableau d'éléments et les ajouter récursivement à une variable chaîne, par exemple si vous voulez une séquence d'ADN aléatoire:

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

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

C'est aussi propre que possible. C'est rapide aussi, http://jsperf.com/ay-random-string .

6
Gajus

Cela fonctionne à coup sûr

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

Génère une chaîne longue de 10 caractères. La longueur est définie par paramètre (10 par défaut).

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

Vous pouvez utiliser coderain . C'est une bibliothèque pour générer des codes aléatoires selon un modèle donné. Utilisez # comme espace réservé pour les caractères majuscules et minuscules, ainsi que pour les chiffres:

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

Il existe d'autres espaces réservés tels que A pour les lettres majuscules ou 9 pour les chiffres.

Ce qui peut être utile, c'est que l'appel de .next() vous donnera toujours un résultat unique, de sorte que vous n'avez pas à vous soucier des doublons.

Voici une application de démonstration qui génère une liste de codes aléatoires uniques .

Divulgation complète: je suis l'auteur de coderain.

4
Lukasz Wiktor

Que diriez-vous de quelque chose comme ceci: Date.now().toString(36) Pas très aléatoire, mais court et assez unique à chaque fois que vous l'appelez.

4
Swergas

Caractères alphanumériques insensibles à la casse:

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

L'avantage de cette fonction est que vous pouvez obtenir une chaîne aléatoire de longueur différente et garantir sa longueur.

Sensible à la casse tous les caractères:

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

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

Personnages personnalisés

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

3
Ali

Voici un script de test pour la réponse n ° 1 (merci @ csharptest.net)

le script exécute makeid()1 million fois et, comme vous pouvez le constater, 5 n’est pas très unique. l'exécuter avec une longueur de caractère de 10 est assez fiable. Je l'ai couru environ 50 fois et je n'ai pas encore vu de duplicata :-) 

remarque: la taille maximale de la pile de nœuds dépasse 4 millions. Vous ne pouvez donc pas exécuter ces 5 millions de fois.

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');
3
James Harrington

Que diriez-vous de ce petit truc compact?

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

Vous avez besoin du Array.apply pour que le tableau vide devienne un tableau d'indéfinis.

Si vous codez pour ES2015, la construction du tableau est un peu plus simple:

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

Celui-ci combine de nombreuses réponses.

var randNo = Math.floor(Math.random() * 100) + 2 + "" + new Date().getTime() +  Math.floor(Math.random() * 100) + 2 + (Math.random().toString(36).replace(/[^a-zA-Z]+/g, '').substr(0, 5));

console.log(randNo);

Je l'utilise depuis 1 mois avec d'excellents résultats.

2
miodus

C'est ce que j'ai utilisé. Une combinaison d'un couple ici. Je l'utilise en boucle et chaque identifiant produit est unique. Ce n'est peut-être pas 5 caractères, mais c'est garanti unique.

var newId =
    "randomid_" +
    (Math.random() / +new Date()).toString(36).replace(/[^a-z]+/g, '');
2
Andrew Plank

Si une bibliothèque est une possibilité, Chance.js pourrait vous aider: http://chancejs.com/#string

2
Luca Bonavita

En développant l'élégant exemple de Doubletap en répondant aux questions soulevées par Gertas et Dragon. Ajoutez simplement une boucle while pour tester ces rares circonstances nulles et limitez le nombre de caractères à cinq. 

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

Voici un jsfiddle vous alertant par un résultat: http://jsfiddle.net/pLJJ7/

2
Steven DAmico

Pour une chaîne avec des lettres majuscules et minuscules et des chiffres (0-9a-zA-Z), il peut s'agir de la version qui minimise le mieux:

function makeId(length) {
  var id = '';
  var rdm62;
  while (length--) {
   // Generate random integer between 0 and 61, 0|x works for Math.floor(x) in this case 
   rdm62 = 0 | Math.random() * 62; 
   // Map to ascii codes: 0-9 to 48-57 (0-9), 10-35 to 65-90 (A-Z), 36-61 to 97-122 (a-z)
   id += String.fromCharCode(rdm62 + (rdm62 < 10 ? 48 : rdm62 < 36 ? 55 : 61)) 
  }
  return id;
}

Le contenu de cette fonction est réduit à 97 octets, tandis que la réponse supérieure nécessite 149 octets (en raison de la liste de caractères).

1
Waruyama

Voici une approche différente avec longueur fixe par base, sans RegExp replace replace ((basé sur la réponse de @ bendytree);

function Rand(base) {
    // default base 10
    base = (base >= 2 && base <= 36) ? base : 10;
    for (var i = 0, ret = []; i < base; i++) {
        ret[i] = ((Math.random() * base) | 0).toString(base)
            // include 0-9a-zA-Z?
            // [Math.random() < .5 ? 'toString' : 'toUpperCase']();
    }
    return ret.join('');
}
1
K-Gun

Également basé sur la réponse de doubletap, celui-ci gère n'importe quelle longueur de caractères obligatoires aléatoires (uniquement inférieur) et continue de générer des nombres aléatoires jusqu'à ce que suffisamment de caractères aient été collectés.

function randomChars(len) {
    var chars = '';

    while (chars.length < len) {
        chars += Math.random().toString(36).substring(2);
    }

    // Remove unnecessary additional characters.
    return chars.substring(0, len);
}
1
qubyte

J'ai adoré la brièveté de la réponse Math.random (). ToString (36) .substring (7) de doubletap, mais cela ne signifie pas qu'elle ait eu autant de collisions que hacklikecrack a correctement souligné. Il a généré des chaînes de 11 caractères mais présente un taux de duplication de 11% sur un échantillon d'un million.

Voici une alternative plus longue (mais toujours courte) et plus lente qui ne comptait que 133 doublons dans un espace exemple de 1 million. Dans de rares cas, la chaîne sera toujours inférieure à 11 caractères:

Math.abs(Math.random().toString().split('')
    .reduce(function(p,c){return (p<<5)-p+c})).toString(36).substr(0,11);
1
Dwayne
"12345".split('').map(function(){return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.charAt(Math.floor(62*Math.random()));}).join('');

//or

String.prototype.Rand = function() {return this.split('').map(function(){return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.charAt(Math.floor(62*Math.random()));}).join('');};

va générer une chaîne alphanumérique aléatoire avec la longueur de la première chaîne/appelante

1
nclu

Ceci est une version légèrement améliorée de doubletap de answer . Il prend en compte le commentaire de gertas sur le cas, lorsque Math.random() renvoie 0, 0,5, 0,25, 0,125, etc.

((Math.random()+3*Number.MIN_VALUE)/Math.PI).toString(36).slice(-5)
  1. Cela évite que zéro soit passé à toString my en ajoutant le plus petit float à Math.random().
  2. Cela garantit que le nombre passé à toString a assez de chiffres en divisant par un nombre presque irrationnel.
1
ceving

Ceci stocke 5 caractères alphanumériques dans la variable c.

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

Apprendre à un homme à pêcher:

Les programmeurs coupent le papier avec des lasers, pas avec des scies à chaîne. Utiliser des méthodes spécifiques aux langages pour produire le code le plus petit et le plus obscur est mignon et tout, mais n'offrira jamais une solution complète. Vous devez utiliser le bon outil pour le travail. 

Ce que vous voulez, c'est une chaîne de caractères, et les caractères sont représentés par des octets. Et, nous pouvons représenter un octet en JavaScript en utilisant un nombre. Nous devrions donc générer une liste de ces nombres et les convertir en chaînes. Vous n'avez pas besoin de Date ou de base64; Math.random () vous donnera un nombre et String.fromCharCode () le transformera en chaîne. Facile.

Mais, quel nombre est égal à quel personnage? UTF-8 est le principal standard utilisé sur le Web pour interpréter les octets en tant que caractères (bien que JavaScript utilise UTF-16 en interne, ils se chevauchent). Pour résoudre ce problème, le programmeur consulte la documentation. 

UTF-8 répertorie toutes les touches du clavier avec un nombre compris entre 0 et 128. Certaines ne sont pas imprimables. Choisissez simplement les caractères que vous voulez dans vos chaînes aléatoires et recherchez-les à l'aide de nombres générés aléatoirement.

Bellow est une fonction qui prend une longueur pratiquement infinie, génère un nombre aléatoire dans une boucle et recherche tous les caractères d'impression dans les 128 codes de code UTF-8 inférieurs. L'entropie est inhérente, car tous les nombres aléatoires ne sont pas systématiquement touchés (caractères non imprimables, espaces, etc.). Il fonctionnera également plus rapidement si vous ajoutez plus de caractères.

J'ai inclus la plupart des optimisations abordées dans le fil de discussion:

  • Le double tilde est plus rapide que Math.floor
  • Les instructions "if" sont plus rapides que les expressions régulières
  • pousser dans un tableau est plus rapide que la concaténation de chaînes

function randomID(len) {
  var char;
  var arr = [];
  var len = len || 5;

  do {
    char = ~~(Math.random() * 128);

    if ((
        (char > 47 && char < 58) || // 0-9
        (char > 64 && char < 91) || // A-Z
        (char > 96 && char < 123) // a-z

        // || (char > 32 && char < 48) // !"#$%&,()*+'-./
        // || (char > 59 && char < 65) // <=>?@
        // || (char > 90 && char < 97) // [\]^_`
        // || (char > 123 && char < 127) // {|}~
      )
      //security conscious removals: " ' \ ` 
      //&& (char != 34 && char != 39 && char != 92 && char != 96) 

    ) { arr.Push(String.fromCharCode(char)) }

  } while (arr.length < len);

  return arr.join('')
}

var input = document.getElementById('length');

input.onfocus = function() { input.value = ''; }

document.getElementById('button').onclick = function() {
  var view = document.getElementById('string');
  var is_number = str => ! Number.isNaN( parseInt(str));
    
  if ( is_number(input.value))
    view.innerText = randomID(input.value);
  else
    view.innerText = 'Enter a number';
}
#length {
  width: 3em;
  color: #484848;
}

#string {
  color: #E83838;
  font-family: 'sans-serif';
  Word-wrap: break-Word;
}
<input id="length" type="text" value='#'/>
<input id="button" type="button" value="Generate" />
<p id="string"></p>

Pourquoi le faire de cette manière fastidieuse? Parce que vous pouvez. Tu es un programmeur. Vous pouvez faire un ordinateur faire n'importe quoi! En outre, si vous voulez une chaîne de caractères hébreux? C'est pas difficile. Recherchez ces caractères dans le standard UTF-8 et recherchez-les. Libérez-vous de ces méthodes McDonald comme toString (36).

Parfois, il est nécessaire de réduire le niveau d'abstraction pour créer une solution réelle. Comprendre les principes fondamentaux en main peut vous permettre de personnaliser votre code comme vous le souhaitez. Vous voulez peut-être qu'une chaîne générée à l'infini remplisse un tampon circulaire? Peut-être que vous voulez que toutes vos chaînes générées soient des palindromes? Pourquoi vous retenir?

1
Duco
",,,,,".replace(/,/g,function (){return "AzByC0xDwEv9FuGt8HsIrJ7qKpLo6MnNmO5lPkQj4RiShT3gUfVe2WdXcY1bZa".charAt(Math.floor(Math.random()*62))});
1
guest271314

Chaîne aléatoire unicode

Cette méthode renverra une chaîne aléatoire avec l'un des caractères unicode pris en charge, ce qui n'est pas à 100% ce que demande OP, mais ce que je cherchais:

function randomUnicodeString(length){
    return Array.from({length: length}, ()=>{
        return String.fromCharCode(Math.floor(Math.random() * (65536)))
    }).join('')
}

Raisonnement

Ceci est le meilleur résultat de Google lors de la recherche de "chaîne aléatoire javascript", mais OP demande uniquement a-zA-Z0-9. 

1
Automatico

Valeur numérique aléatoire (jusqu'à 16 chiffres)

/**
 * Random numeric value (up to 16 digits)
 * @returns {String}
 */
function randomUid () {
  return String(Math.floor(Math.random() * 9e15))
}

// randomUid() -> "3676724552601324"
1
artnikpro

J'utilise var randId = 'Rand' + new Date().getTime();

1
CMS

Ceci est pour le code Firefox Firefox (addons et autres)

Cela peut vous faire économiser quelques heures de recherche.

function randomBytes( amount )
{
    let bytes = Cc[ '@mozilla.org/security/random-generator;1' ]

        .getService         ( Ci.nsIRandomGenerator )
        .generateRandomBytes( amount, ''            )

    return bytes.reduce( bytes2Number )


    function bytes2Number( previousValue, currentValue, index, array )
    {
      return Math.pow( 256, index ) * currentValue + previousValue
    }
}

Utilisez-le comme:

let   strlen   = 5
    , radix    = 36
    , filename = randomBytes( strlen ).toString( radix ).splice( - strlen )
0
user1115652

Une autre bonne façon de randomiser une chaîne à partir des caractères A-Za-z0-9:

function randomString(length) {
    if ( length <= 0 ) return "";
    var getChunk = function(){
        var i, //index iterator
            Rand = Math.random()*10e16, //execute random once
            bin = Rand.toString(2).substr(2,10), //random binary sequence
            lcase = (Rand.toString(36)+"0000000000").substr(0,10), //lower case random string
            ucase = lcase.toUpperCase(), //upper case random string
            a = [lcase,ucase], //position them in an array in index 0 and 1
            str = ""; //the chunk string
        b = Rand.toString(2).substr(2,10);
        for ( i=0; i<10; i++ )
            str += a[bin[i]][i]; //gets the next character, depends on the bit in the same position as the character - that way it will decide what case to put next
        return str;
    },
    str = ""; //the result string
    while ( str.length < length  )
        str += getChunk();
    str = str.substr(0,length);
    return str;
}
0
Slavik Meltser

J'ai fabriqué un prototype de chaîne capable de générer une chaîne aléatoire d'une longueur donnée.

Vous pouvez également spécifier si vous voulez des caractères spéciaux et en éviter certains.

/**
 * STRING PROTOTYPE RANDOM GENERATOR
 * Used to generate a random string
 * @param {Boolean} specialChars
 * @param {Number} length
 * @param {String} avoidChars
 */
String.prototype.randomGenerator = function (specialChars = false, length = 1, avoidChars = '') {
    let _pattern = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    _pattern += specialChars === true ? '(){}[]+-*/=' : '';
    if (avoidChars && avoidChars.length) {
        for (let char of avoidChars) {
            _pattern = _pattern.replace(char, '');
        }
    }
    let _random = '';
    for (let element of new Array(parseInt(length))) {
        _random += _pattern.charAt(Math.floor(Math.random() * _pattern.length));
    }
    return _random;
};

Vous pouvez utiliser comme ceci:

// Generate password with specialChars which contains 10 chars and avoid iIlL chars
var password = String().randomGenerator(true, 10, 'iIlL');

J'espère que ça aide.

0
Sparw

Comme plusieurs personnes ici l'ont fait remarquer, transmettre le résultat de Math.random() directement à .string(36) pose plusieurs problèmes.

Il a un mauvais hasard. Le nombre de caractères générés varie et dépend en moyenne des détails délicats du fonctionnement des nombres à virgule flottante en Javascript. Cela semble fonctionner si j'essaie de générer 11 caractères ou moins, mais pas plus de 11 caractères. Et ce n'est pas flexible. Il n'y a pas de moyen facile d'autoriser ou d'interdire certains personnages.

J'ai une solution compacte, qui ne pose pas ces problèmes, pour toute personne utilisant lodash:

_.range(11).map(i => _.sample("abcdefghijklmnopqrstuvwxyz0123456789")).join('')

Si vous souhaitez autoriser certains caractères (tels que les lettres majuscules) ou interdire certains caractères (tels que les caractères ambigus tels que l et 1), modifiez la chaîne ci-dessus.

0
Elias Zamaria

dans le code ci-dessous, je génère un code aléatoire pour 8 caractères

function RandomUnique(){
                    var charBank = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012346789";
                    var random= '';
                    var howmanycharacters = 8;
                    for (var i = 0; i < howmanycharacters ; i++) {
                        random+= charBank[parseInt(Math.random() * charBank.lenght)];
                    }
                    return random;
                }
        var random = RandomUnique();
        console.log(random);
0
Ratan Uday Kumar

Une approche fonctionnelle. Cette réponse est pratique uniquement si les conditions préalables fonctionnelles peuvent être exploitées dans d'autres parties de votre application. La performance est probablement de la malbouffe, mais c'était super amusant d'écrire.

// functional prerequisites
const U = f=> f (f)
const Y = U (h=> f=> f (x=> h (h) (f) (x)))
const comp = f=> g=> x=> f (g (x))
const foldk = Y (h=> f=> y=> ([x, ...xs])=>
  x === undefined ? y : f (y) (x) (y=> h (f) (y) (xs)))
const fold = f=> foldk (y=> x=> k=> k (f (y) (x)))
const map = f=> fold (y=> x=> [...y, f (x)]) ([])
const char = x=> String.fromCharCode(x)
const concat = x=> y=> y.concat(x)
const concatMap = f=> comp (fold (concat) ([])) (map (f))
const irand = x=> Math.floor(Math.random() * x)
const sample = xs=> xs [irand (xs.length)]

// range : make a range from x to y; [x...y]
// Number -> Number -> [Number]
const range = Y (f=> r=> x=> y=>
  x > y ? r : f ([...r, x]) (x+1) (y)
) ([])

// srand : make random string from list or ascii code ranges
// [(Range a)] -> Number -> [a]
const srand = comp (Y (f=> z=> rs=> x=>
  x === 0 ? z : f (z + sample (rs)) (rs) (x-1)
) ([])) (concatMap (map (char)))

// idGenerator : make an identifier of specified length
// Number -> String
const idGenerator = srand ([
  range (48) (57),  // include 0-9
  range (65) (90),  // include A-Z
  range (97) (122)  // include a-z
])

console.log (idGenerator (6))  //=> TT688X
console.log (idGenerator (10)) //=> SzaaUBlpI1
console.log (idGenerator (20)) //=> eYAaWhsfvLDhIBID1xRh

À mon avis, il est difficile de battre la clarté de idGenerator sans ajouter de fonctions magiques, faites-trop-beaucoup de choses.

Une légère amélioration pourrait être

// ord : convert char to ascii code
// Char -> Number
const ord = x => x.charCodeAt(0)

// idGenerator : make an identifier of specified length
// Number -> String
const idGenerator = srand ([
  range (ord('0')) (ord('9')),
  range (ord('A')) (ord('Z')),
  range (ord('a')) (ord('z'))
])

Aie du plaisir avec ça. Faites-moi savoir ce que vous aimez/apprendre ^ _ ^

0
user633183

Au-dessus de toutes les réponses sont parfaites. mais j'ajoute ce qui est très bon et rapide pour générer une valeur de chaîne aléatoire

function randomStringGenerator(stringLength) {
  var randomString = ""; // Empty value of the selective variable
  const allCharacters = "'`~!@#$%^&*()_+-={}[]:;\'<>?,./|\\ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'"; // listing of all alpha-numeric letters
  while (stringLength--) {
    randomString += allCharacters.substr(Math.floor((Math.random() * allCharacters.length) + 1), 1); // selecting any value from allCharacters varible by using Math.random()
  }
  return randomString; // returns the generated alpha-numeric string
}

console.log(randomStringGenerator(10));//call function by entering the random string you want

ou

console.log(Date.now())// it will produce random thirteen numeric character value every time.
console.log(Date.now().toString().length)// print length of the generated string
0
Parth Raval

solution récursive:

function generateRamdomId (seedStr) {
const len = seedStr.length
console.log('possibleStr', seedStr , ' len ', len)
if(len <= 1){
    return seedStr
}
const randomValidIndex  = Math.floor(Math.random() * len)
const randomChar = seedStr[randomValidIndex]
const chunk1 = seedStr.slice(0, randomValidIndex)
const chunk2 = seedStr.slice(randomValidIndex +1)
const possibleStrWithoutRandomChar = chunk1.concat(chunk2)

return randomChar + generateRamdomId(possibleStrWithoutRandomChar)

}

vous pouvez utiliser avec la graine que vous voulez, ne répétez pas les caractères si vous ne voulez pas Exemple 

generateRandomId("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") 
0
Pascual Muñoz

très simple

function getRandomColor(){
  var color='';
  while(color.length<6){
    color=Math.floor(Math.random()*16777215).toString(16);
  }
  return '#'+color;
}
0
Behnam Mohammadi

Placez les caractères en tant que thisArg dans la fonction map créera un "one-liner":

Array.apply(null, Array(5))
.map(function(){ 
    return this[Math.floor(Math.random()*this.length)];
}, "abcdefghijklmnopqrstuvwxyz")
.join('');
0
user1506145

Vous pouvez utiliser base64:

function randomString(length)
{
    var rtn = "";

    do {
        rtn += btoa("" + Math.floor(Math.random() * 100000)).substring(0, length);
    }
    while(rtn.length < length);

    return rtn;
}
0
Antinous

Essayez ceci, ce que j'utilise à chaque fois:

function myFunction() {
        var hash = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012346789";
        var random8 = '';
        for(var i = 0; i < 5; i++){
            random8 += hash[parseInt(Math.random()*hash.length)];
        }
        console.log(random8);
    document.getElementById("demo").innerHTML = "Your 5 character string ===> "+random8;
}        
        
<!DOCTYPE html>
<html>
<body>

<p>Click the button to genarate 5 character random string .</p>

<button onclick="myFunction()">Click me</button>

<p id="demo"></p>



</body>
</html>

const c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
const s = Array.from({length:5}, _ => c[Math.floor(Math.random()*c.length)]).join('')
0
Nahuel Greco

Voici mon approche (avec TypeScript).

J'ai décidé d'écrire encore une autre réponse parce que je ne voyais pas de solution simple utilisant js moderne et code propre.

const DEFAULT_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

function getRandomCharFromAlphabet(alphabet: string) {
  return alphabet.charAt(Math.floor(Math.random() * alphabet.length));
}

function generateId(idDesiredLength: number, alphabet = DEFAULT_ALPHABET) {
  /**
   * Create n-long array and map it to random chars from given alphabet.
   * Then join individual chars as string
   */
  Array.from({length: idDesiredLength}).map(() => {
    return getRandomCharFromAlphabet(alphabet);
  }).join('');
}

generateId(5); // jNVv7
0
pie6k

Je viens d'écrire un paquet simple pour générer un jeton aléatoire avec une taille, une graine et un masque donnés. FYI.

@sibevin/random-token - https://www.npmjs.com/package/@sibevin/random-token

import { RandomToken } from '@sibevin/random-token'

RandomToken.gen({ length: 32 })
// JxpwdIA37LlHan4otl55PZYyyZrEdsQT

RandomToken.gen({ length: 32, seed: 'alphabet' })
// NbbtqjmHWJGdibjoesgomGHulEJKnwcI

RandomToken.gen({ length: 32, seed: 'number' })
// 33541506785847193366752025692500

RandomToken.gen({ length: 32, seed: 'oct' })
// 76032641643460774414624667410327

RandomToken.gen({ length: 32, seed: 'hex' })
// 07dc6320bf1c03811df7339dbf2c82c3

RandomToken.gen({ length: 32, seed: 'abc' })
// bcabcbbcaaabcccabaabcacbcbbabbac

RandomToken.gen({ length: 32, mask: '123abcABC' })
// vhZp88dKzRZGxfQHqfx7DOL8jKTkWUuO
0
Sibevin Wang

Que diriez-vous de cela ci-dessous ... cela produira les valeurs vraiment aléatoires:

function getRandomStrings(length) {
  const value = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  const randoms = [];
  for(let i=0; i < length; i++) {
     randoms.Push(value[Math.floor(Math.random()*value.length)]);
  }
  return randoms.join('');
}

Mais si vous cherchez une syntaxe plus courte, utilisez ES6:

const getRandomStrings = length => Math.random().toString(36).substr(-length);
0
Alireza

Le module npm anyid fournit une API flexible pour générer divers types d’ID/code de chaîne.

const id = anyid().encode('Aa0').length(5).random().id();
0
aleung