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:
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é.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"
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:
Autres réflexions:
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:
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));
/**
* 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:
var str = "";
pour concaténer des caractères aléatoiresRand
de 0 à 61 (0..9 + A..Z + a..z = 62)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é.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:
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.
0-9a-z
new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36);})
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.
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.
function randStr(len) {
let s = '';
while (len--) s += String.fromCodePoint(Math.floor(Math.random() * (126 - 33) + 33));
return s;
}
// usage
console.log(randStr(50));
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
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');
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)
toString
my en ajoutant le plus petit float à Math.random()
.toString
a 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)
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:
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))});
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('')
}
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 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
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")
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();