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?
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());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)
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"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);
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:
- Choisissez un nombre aléatoire compris dans l’intervalle [0,1), c’est-à-dire entre 0 (inclus) et 1 (exclusif).
- Convertissez le nombre en chaîne base 36, c’est-à-dire en utilisant les caractères 0 à 9 et a-z.
- Pad avec zéros (résout le premier problème).
- Couper le «0» en tête préfixes et zéros de remplissage supplémentaires.
- 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).
- 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.
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');
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 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));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
Randde 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 correctCharCodeet le caractère associé. - À l’intérieur de la boucle, concaténez-vous à
struneString.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:
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"
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;
}
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).
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"]();});
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.
Si vous utilisez Lodash ou Underscore , alors c'est si simple:
var randomVal = _.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5).join('');
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)));
}
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('');
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).
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.
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;
}
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));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 .
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>
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;
}
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.
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.
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 bVoici 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');
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('');
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.
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, '');
Si une bibliothèque est une possibilité, Chance.js pourrait vous aider: http://chancejs.com/#string
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/
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).
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('');
}
É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);
}
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);
"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
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)
- Cela évite que zéro soit passé à
toStringmy en ajoutant le plus petit float àMath.random(). - Cela garantit que le nombre passé à
toStringa assez de chiffres en divisant par un nombre presque irrationnel.
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)
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?
",,,,,".replace(/,/g,function (){return "AzByC0xDwEv9FuGt8HsIrJ7qKpLo6MnNmO5lPkQj4RiShT3gUfVe2WdXcY1bZa".charAt(Math.floor(Math.random()*62))});
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.
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"
J'utilise var randId = 'Rand' + new Date().getTime();
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 )
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;
}
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.
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.
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);
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 ^ _ ^
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 wantou
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 stringsolution 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")
très simple
function getRandomColor(){
var color='';
while(color.length<6){
color=Math.floor(Math.random()*16777215).toString(16);
}
return '#'+color;
}
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('');
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;
}
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('')
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
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
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);
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();