Chaîne alphanumérique aléatoire dans JavaScript?

Quel est le moyen le plus court (dans le motif) de générer une chaîne alphanumérique aléatoire (majuscules, minuscules et nombres) dans JavaScript pour utiliser comme identifiant probablement unique?

    Si vous voulez seulement autoriser des caractères spécifiques, vous pouvez également le faire comme ceci:

    function randomString(length, chars) { var result = ''; for (var i = length; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)]; return result; } var rString = randomString(32, '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'); 

    Voici un jsfiddle à démontrer: http://jsfiddle.net/wSQBx/

    Une autre façon de le faire pourrait être d'utiliser une chaîne spéciale qui indique à la fonction quels types de caractères utiliser. Vous pourriez faire cela comme ça:

     function randomString(length, chars) { var mask = ''; if (chars.indexOf('a') > -1) mask += 'abcdefghijklmnopqrstuvwxyz'; if (chars.indexOf('A') > -1) mask += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; if (chars.indexOf('#') > -1) mask += '0123456789'; if (chars.indexOf('!') > -1) mask += '~`!@#$%^&*()_+-={}[]:";\'<>?,./|\\'; var result = ''; for (var i = length; i > 0; --i) result += mask[Math.floor(Math.random() * mask.length)]; return result; } console.log(randomString(16, 'aA')); console.log(randomString(32, '#aA')); console.log(randomString(64, '#A!')); 

    Fiddle: http://jsfiddle.net/wSQBx/2/

    Alternativement, pour utiliser la méthode base36 comme décrit ci-dessous, vous pouvez faire quelque chose comme ceci:

     function randomString(length) { return Math.round((Math.pow(36, length + 1) - Math.random() * Math.pow(36, length))).toString(36).slice(1); } 

    Je viens de trouver cette solution vraiment agréable et élégante:

     Math.random().toString(36).slice(2) 

    Une autre variante de réponse proposée par JAR.JAR.beans

     (Math.random()*1e32).toString(36) 

    En changeant le multiplicateur 1e32 vous pouvez changer la longueur de la chaîne aléatoire.

    Ou pour s'appuyer sur ce que Jar Jar a suggéré, c'est ce que j'ai utilisé dans un projet récent (pour surmonter les restrictions de longueur):

     var randomString = function (len, bits) { bits = bits || 36; var outStr = "", newStr; while (outStr.length < len) { newStr = Math.random().toString(bits).slice(2); outStr += newStr.slice(0, Math.min(newStr.length, (len - outStr.length))); } return outStr.toUpperCase(); }; 

    Utilisation:

     randomString(12, 16); // 12 hexadecimal characters randomString(200); // 200 alphanumeric characters 

    C'est plus propre

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

    Exemple

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

    Caractère aléatoire:

     String.fromCharCode(i); //where is an int 

    Random int:

     Math.floor(Math.random()*100); 

    Mets le tout ensemble:

     function randomNum(hi){ return Math.floor(Math.random()*hi); } function randomChar(){ return String.fromCharCode(randomNum(100)); } function randomString(length){ var str = ""; for(var i = 0; i < length; ++i){ str += randomChar(); } return str; } var RandomString = randomString(32); //32 length string 

    Fiddle: http://jsfiddle.net/maniator/QZ9J2/

    Pour 32 caractères:

     for(var c = ''; c.length < 32;) c += Math.random().toString(36).substr(2, 1) 
     var randomString = function(length) { var str = ''; var chars ='0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz'.split( ''); var charsLen = chars.length; if (!length) { length = ~~(Math.random() * charsLen); } for (var i = 0; i < length; i++) { str += chars[~~(Math.random() * charsLen)]; } return str; }; 

    One-liner avec lodash, pour 20 caractères aléatoires (minuscules alphanumériques):

     _.times(20, () => _.random(35).toString(36)).join(''); 

    Utilisation de lodash:

     function createRandomString(length) { var chars = "abcdefghijklmnopqrstufwxyzABCDEFGHIJKLMNOPQRSTUFWXYZ1234567890" var pwd = _.sample(chars, length || 12) return pwd.join("") } 

    Cette fonction devrait donner une chaîne aléatoire en toute longueur.

     function randString(length) { var l = length > 25 ? 25 : length; var str = Math.random().toString(36).substr(2, l); if(str.length >= length){ return str; } return str.concat(this.randString(length - str.length)); } 

    Je l'ai testé avec le test suivant qui a réussi.

     function test(){ for(var x = 0; x < 300000; x++){ if(randString(x).length != x){ throw new Error('invalid result for len ' + x); } } } 

    La raison pour laquelle j'ai choisi 25 est que, en pratique, la longueur de la chaîne est revenue de Math.random().toString(36).substr(2, 25) a une longueur 25. Ce nombre peut être modifié comme vous le souhaitez.

    Cette fonction est récursive et, par conséquent, l'appel de la fonction avec des valeurs très importantes peut résulter en Maximum call stack size exceeded . À partir de mes tests, j'ai pu obtenir une chaîne de 300 000 caractères.

    Cette fonction peut être convertie en récurrence de queue en envoyant la chaîne à la fonction en tant que second paramètre. Je ne sais pas si JS utilise l'optimisation d'appel Tail

    Agréable et simple, et pas limité à un certain nombre de caractères:

     let len = 20, str = ""; while(str.length < len) str += Math.random().toString(36).substr(2); str = str.substr(0, len); 
     function randomString(len) { var p = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; return [...Array(len)].reduce(a=>a+p[~~(Math.random()*p.length)],''); } 

    Résumé:

    1. Créez un tableau de la taille que nous voulons (car il n'y a pas d'équivalent de range(len) en javascript.
    2. Pour chaque élément dans le tableau: choisissez un caractère aléatoire de p et ajoutez-le à une chaîne
    3. Renvoie la chaîne générée.

    Quelques explications:

    [...Array(len)]

    Array (len) ou New Array (len) crée un tableau avec pointeur (s) indéfini (s) . One-Liners va être plus difficile à retirer. La syntaxe Spread définit les pointeurs (maintenant ils indiquent des objets non définis!).

    .reduce(

    Réduisez le tableau dans, dans ce cas, une seule chaîne. La fonctionnalité de réduction est fréquente dans la plupart des langues et vaut la peine d'apprendre.

    a=>a+...

    Nous utilisons une fonction de flèche .

    a est l' accumulateur. Dans ce cas, c'est la chaîne de résultat final que nous allons revenir lorsque nous aurons terminé (vous savez que c'est une chaîne parce que le second argument de la fonction de réduction, le volume initial est une chaîne vide: '' ). Donc, fondamentalement: convertissez chaque élément dans le tableau avec p[~~(Math.random()*p.length)] , ajoutez le résultat à la chaîne et donnez-moi a fois que vous avez terminé.

    p[...]

    p est la chaîne de caractères que nous sélectionnons. Vous pouvez accéder aux caractères dans une chaîne comme un index (par exemple, "abcdefg"[3] nous donne "d" )

    ~~(Math.random()*p.length)

    Math.random() renvoie un point flottant entre [0, 1] Math.floor(Math.random()*max) est le standard de facto pour obtenir un entier aléatoire en javascript . ~ Est l'opérateur NOT de Bitwise en javascript. ~~ est une manière plus courte, peut-être parfois plus rapide, et certainement plus amusante de dire Math.floor( Voici quelques informations

    Quand j'ai vu cette question, j'ai pensé quand je devais générer des UUID. Je ne peux pas accepter le code, car je suis sûr que je l'ai trouvé ici sur stackoverflow. Si vous ne voulez pas les tirets dans votre chaîne, sortez les tirets. Voici la fonction:

     function generateUUID() { var d = new Date().getTime(); var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,function(c) { var r = (d + Math.random()*16)%16 | 0; d = Math.floor(d/16); return (c=='x' ? r : (r&0x7|0x8)).toString(16); }); return uuid.toUpperCase(); } 

    Fiddle: http://jsfiddle.net/nlviands/fNPvf/11227/

    Générateur de clés aléatoires

    L'argument keyLength est la longueur de caractère que vous voulez pour la clé

     function keyGen(keyLength) { var i, key = "", characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; var charactersLength = characters.length; for (i = 0; i < keyLength; i++) { key += characters.substr(Math.floor((Math.random() * charactersLength) + 1), 1); } return key; } keyGen(12) "QEt9mYBiTpYD" 

    Utilisez la bibliothèque md5: https://github.com/blueimp/JavaScript-MD5

    Le chemin le plus court:

    md5(Math.random())

    Si vous souhaitez limiter la taille à 5:

    md5(Math.random()).substr(0, 5)