la manière la plus simple est:

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

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

Le problème avec cela est que si vous l'appelez deux fois sur la même seconde, il va générer la même chaîne.

la manière la plus sûre est:

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

cela générera une chaîne aléatoire de 4 ou 5 des personnages, toujours différents. Exemple de sortie est comme 30jzm ou 1r591 ou 4su1a

dans les deux sens, la première partie génère un nombre aléatoire. La partie .toString(36) donne le nombre à une représentation de base36 (alphadécimale) de celui-ci.

une nouvelle version avec es6 151990920 "spread operator :

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

• le 30 est un nombre arbitraire, vous pouvez choisir la longueur de jeton que vous voulez
• le 36 est le nombre radix maximum que vous pouvez passer à numérique.toString () , qui signifie Tous les nombres et a-z lettres minuscules
• le 3 est utilisé pour choisir le 3ème numéro de la chaîne aléatoire qui ressemble à ceci: "0.mfbiohx64i" , nous pourrions prendre n'importe quel indice après 0.

Voici des doublures simples. Changez new Array(5) pour régler 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"]();});

si vous utilisez Lodash ou Underscore , alors il est si simple:

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

je sais que tout le monde a déjà fait ce qu'il fallait, mais j'ai eu envie d'essayer celui-ci de la manière la plus légère possible(light on code, pas CPU):

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

console.log(rand(5));

il faut un peu de temps pour envelopper votre tête autour, mais je pense qu'il montre vraiment comment la syntaxe JavaScript génial est.

en supposant que vous utilisez sous-titres 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('');

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, je ai inclus la fonction qui créé une chaîne alphanumérique.

exemples de travail:

http://jsfiddle.net/greatbigmassive/vhsxs/ (alpha seulement)

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 En Juillet 2015

Cela fait la même chose mais fait 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)));
}

dans le cas où n'importe qui est intéressé par un one-liner (bien que pas formaté en tant que tel pour votre convenance) qui alloue la mémoire à la fois (mais notez que pour les petites chaînes, il n'a vraiment pas d'importance) voici comment le faire:

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 que vous souhaitez. Merci à @AriyaHidayat dans ce post pour la solution à la fonction map ne fonctionne pas sur le réseau clairsemé créé par Array(5) .

pour répondre À l'exigence [a-zA-Z0-9] et la longueur=5

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

lettres minuscules, lettres majuscules, et les nombres se produiront.

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

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. Il est rapide aussi, http://jsperf.com/ay-random-string .

vous pouvez boucler un tableau d'éléments et les ajouter récursivement à une variable string, 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));

Je n'ai pas trouvé de solution propre pour supporter à la fois les caractères minuscules et les majuscules.

support en minuscules seulement:

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

en S'appuyant sur cette solution pour supporter les minuscules et les majuscules:

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

changez le 5 dans substr(2, 5) pour vous ajuster à la longueur dont vous avez besoin.

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.

Cela fonctionne pour vous

<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 de 10 caractères. La longueur est définie par le paramètre (par défaut 10).

function random_string_generator(len) {
var len = len || 10;
var str = '';
var i = 0;

for(i=0; i<len; i++) {
    switch(Math.floor(Math.random()*3+1)) {
        case 1: // digit
            str += (Math.floor(Math.random()*9)).toString();
        break;

        case 2: // small letter
            str += String.fromCharCode(Math.floor(Math.random()*26) + 97); //'a'.charCodeAt(0));
        break;

        case 3: // big letter
            str += String.fromCharCode(Math.floor(Math.random()*26) + 65); //'A'.charCodeAt(0));
        break;

        default:
        break;
    }
}
return str;
}

voici un script de test pour la réponse #1 (Merci @csharptest.net)

le script exécute makeid() 1 million fois et comme vous pouvez le voir 5 n'est pas un très unique. le lancer avec une longueur de char de 10 est assez fiable. Je l'ai fait environ 50 fois et n'ai pas encore vu de duplicata :-)

note: la limite de taille de la pile de noeuds dépasse environ 4 millions de sorte que vous ne pouvez pas exécuter ces 5 millions de fois qu'il ne sera jamais fini.

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

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

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

il y a d'autres espaces réservés comme A pour les lettres majuscules ou 9 pour les chiffres.

ce qui peut être utile est que l'appel .next() vous donnera toujours un résultat unique afin que vous n'ayez pas à s'inquiéter des doublons.

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

divulgation Complète: je suis l'auteur de coderain.

et 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 là pour piéger le tableau vide en étant un tableau d'undefineds.

si vous codez pour ES2015, alors construire le tableau est un peu plus simple:

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

Le problème avec les réponses à "j'ai besoin de chaînes aléatoires" questions (quelle que soit la langue) est pratiquement chaque solution utilise une mauvaise spécification primaire de longueur de la chaîne . Les questions elles-mêmes rarement révéler pourquoi les chaînes aléatoires sont nécessaires, mais je vous aurez rarement besoin de chaînes aléatoires de longueur, disons 8. Ce que vous invariablement besoin est un certain nombre de chaînes uniques , par exemple, à utiliser comme identificateurs à certaines fins.

il y a deux principales façons d'obtenir strictement unique cordes: déterministe (qui n'est pas aléatoire) et de stocker/comparer (qui est onéreux). Que faisons-nous? Nous donner l'esprit. Nous allons avec probabilistic uniqueness à la place. C'est-à-dire que nous acceptons qu'il y ait un certain risque (même minime) que nos liens ne soient pas uniques. C'est là que la compréhension Probabilité de collision et l'entropie sont utiles.

donc je vais reformuler le besoin invariable comme ayant besoin d'un certain nombre de chaînes avec un petit risque de répétition. À titre d'exemple concret, imaginons que vous souhaitez générer un potentiel de 5 millions d'Identifiants. Vous ne voulez pas stocker et comparer chaque nouvelle chaîne, et vous voulez qu'ils soient aléatoires, donc vous acceptez un certain risque de répéter. Par exemple, disons un risque de moins de 1 sur mille milliards chance de répéter. De quelle longueur de corde avez-vous besoin? Cette question n'est pas précisée car elle dépend des caractères utilisés. Mais plus important encore, c'est une idée fausse. Ce que vous avez besoin est une spécification de l'entropie de cordes, pas de leur longueur. L'entropie peut être directement liée à la probabilité d'une répétition dans un certain nombre de chaînes. La longueur de la corde ne peut pas.

et c'est là qu'une bibliothèque comme EntropyString peut aider. Pour générer de l'aléatoire Id qui ont moins de 1 billion de chance de répéter à 5 millions de chaînes à l'aide de entropy-string :

import {Random, Entropy} from 'entropy-string'

const random = new Random()
const bits = Entropy.bits(5e6, 1e12)

const string = random.string(bits)

"44hTNghjNHGGRHqH9 "

entropy-string utilise un jeu de caractères avec 32 caractères par défaut. Il y a d'autres jeux de caractères prédéfinis, et vous pouvez spécifier vos propres caractères aussi bien. Par exemple, générer des ID avec la même entropie que ci-dessus, mais en utilisant des caractères hexadécimaux:

import {Random, Entropy, charSet16} from './entropy-string'

const random = new Random(charSet16)
const bits = Entropy.bits(5e6, 1e12)

const string = random.string(bits)

"27b33372ade513715481f "

noter la différence de longueur de chaîne due à la différence dans le nombre total de caractères dans le jeu de caractères utilisé. Le risque de répéter dans le nombre de chaînes est le même. Les longueurs de chaîne ne le sont pas. Et surtout, le risque de répétition et le nombre potentiel de cordes est explicite. Plus de devinettes avec la longueur de la corde.

développement sur L'exemple élégant de Doubletap en répondant aux questions Gertas et Dragon soulevées. Il suffit d'ajouter une boucle while pour tester ces rares circonstances nulles, et limiter les 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 avec un résultat: http://jsfiddle.net/pLJJ7 /