Ich möchte eine 5-stellige Zeichenfolge, die aus zufällig aus dem Satz ausgewählten Zeichen besteht [a-zA-Z0-9].

Was ist der beste Weg, dies mit JavaScript zu tun?

Ich denke, das wird für Sie funktionieren:

function makeid(length) {
   var result           = '';
   var characters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
   var charactersLength = characters.length;
   for ( var i = 0; i < length; i++ ) {
      result += characters.charAt(Math.floor(Math.random() * charactersLength));
   }
   return result;
}

console.log(makeid(5));

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

Hinweis: Der obige Algorithmus weist die folgenden Schwächen auf:

• Es werden zwischen 0 und 6 Zeichen generiert, da beim Stringisieren von Gleitkommazahlen nachgestellte Nullen entfernt werden.
• Dies hängt stark von dem Algorithmus ab, der zum Stringifizieren von Gleitkommazahlen verwendet wird, was fürchterlich komplex ist. (Siehe das Dokument "So drucken Sie Gleitkommazahlen genau" .)
• Math.random()Abhängig von der Implementierung kann eine vorhersagbare ("zufällig aussehende", aber nicht wirklich zufällige) Ausgabe erzeugt werden. Die resultierende Zeichenfolge ist nicht geeignet, wenn Sie die Eindeutigkeit oder Unvorhersehbarkeit garantieren müssen.
• Selbst wenn 6 gleichmäßig zufällige, unvorhersehbare Zeichen erzeugt wurden, können Sie aufgrund des Geburtstagsparadoxons erwarten, dass nach dem Generieren von nur etwa 50.000 Zeichenfolgen ein Duplikat angezeigt wird . (sqrt (36 ^ 6) = 46656)

Math.random ist schlecht für so etwas

Option 1

Wenn Sie dies serverseitig tun können , verwenden Sie einfach das Kryptomodul -

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

// "bb5dc8842ca31d4603d6aa11448d1654"

Die resultierende Zeichenfolge ist doppelt so lang wie die von Ihnen generierten zufälligen Bytes. Jedes hexadezimal codierte Byte besteht aus 2 Zeichen. 20 Bytes sind 40 hexadezimale Zeichen.

Option 2

Wenn Sie dies clientseitig tun müssen , versuchen Sie es vielleicht mit dem uuid-Modul -

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

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

Option 3

Wenn Sie dies clientseitig tun müssen und keine alten Browser unterstützen müssen, können Sie dies ohne Abhängigkeiten tun -

// dec2hex :: Integer -> String
// i.e. 0-255 -> '00'-'ff'
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"

Weitere Informationen zu crypto.getRandomValues-

Mit dieser crypto.getRandomValues()Methode können Sie kryptografisch starke Zufallswerte erhalten. Das als Parameter angegebene Array ist mit Zufallszahlen gefüllt (zufällig in seiner kryptografischen Bedeutung).

Hier ist ein kleines Konsolenbeispiel -

> var arr = new Uint8Array(4) # make array of 4 bytes (values 0-255)
> arr
Uint8Array(4) [ 0, 0, 0, 0 ]

> window.crypto
Crypto { subtle: SubtleCrypto }

> window.crypto.getRandomValues()
TypeError: Crypto.getRandomValues requires at least 1 argument, but only 0 were passed

> window.crypto.getRandomValues(arr)
Uint8Array(4) [ 235, 229, 94, 228 ]

Für die IE11-Unterstützung können Sie Folgendes verwenden:

(window.crypto || window.msCrypto).getRandomValues(arr)

Informationen zur Browserabdeckung finden Sie unter https://caniuse.com/#feat=getrandomvalues

Kurz, einfach und zuverlässig

Gibt genau 5 zufällige Zeichen zurück, im Gegensatz zu einigen der am besten bewerteten Antworten, die hier zu finden sind.

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

Hier ist eine Verbesserung gegenüber der hervorragenden Antwort von doubletap . Das Original hat zwei Nachteile, die hier angesprochen werden:

Erstens, wie andere bereits erwähnt haben, besteht eine geringe Wahrscheinlichkeit, dass kurze Zeichenfolgen oder sogar eine leere Zeichenfolge (wenn die Zufallszahl 0 ist) erzeugt werden, wodurch Ihre Anwendung möglicherweise beschädigt wird. Hier ist eine Lösung:

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

Zweitens begrenzen sowohl das Original als auch die obige Lösung die Zeichenfolgengröße N auf 16 Zeichen. Im Folgenden wird eine Zeichenfolge der Größe N für jedes N zurückgegeben (beachten Sie jedoch, dass die Verwendung von N> 16 die Zufälligkeit nicht erhöht oder die Wahrscheinlichkeit von Kollisionen verringert):

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

Erläuterung:

1. Wählen Sie eine Zufallszahl im Bereich [0,1), dh zwischen 0 (einschließlich) und 1 (exklusiv).
2. Konvertieren Sie die Zahl in eine Basis-36-Zeichenfolge, dh verwenden Sie die Zeichen 0-9 und az.
3. Pad mit Nullen (löst das erste Problem).
4. Schneiden Sie die führende '0' ab. Präfix und zusätzliche Auffüllnullen.
5. Wiederholen Sie die Zeichenfolge so oft, bis mindestens N Zeichen enthalten sind (indem Sie leere Zeichenfolgen mit der kürzeren zufälligen Zeichenfolge als Trennzeichen verbinden).
6. Schneiden Sie genau N Zeichen aus der Zeichenfolge.

Weitere Gedanken:

• Diese Lösung verwendet keine Großbuchstaben, aber in fast allen Fällen (kein Wortspiel beabsichtigt) spielt es keine Rolle.
• Die maximale Zeichenfolgenlänge bei N = 16 in der ursprünglichen Antwort wird in Chrome gemessen. In Firefox ist es N = 11. Wie bereits erläutert, besteht die zweite Lösung darin, die angeforderte Zeichenfolgenlänge zu unterstützen und nicht die Zufälligkeit hinzuzufügen, sodass es keinen großen Unterschied macht.
• Alle zurückgegebenen Zeichenfolgen haben die gleiche Wahrscheinlichkeit, zurückgegeben zu werden, zumindest soweit die von Math.random () zurückgegebenen Ergebnisse gleichmäßig verteilt sind (dies ist in keinem Fall eine Zufälligkeit mit kryptografischer Stärke).
• Möglicherweise werden nicht alle möglichen Zeichenfolgen der Größe N zurückgegeben. In der zweiten Lösung ist dies offensichtlich (da die kleinere Zeichenfolge einfach dupliziert wird), aber auch in der ursprünglichen Antwort gilt dies, da bei der Konvertierung in Basis-36 die letzten paar Bits möglicherweise nicht Teil der ursprünglichen zufälligen Bits sind. Wenn Sie sich das Ergebnis von Math.random (). ToString (36) ansehen, werden Sie feststellen, dass das letzte Zeichen nicht gleichmäßig verteilt ist. Auch hier spielt es in fast allen Fällen keine Rolle, aber wir schneiden die letzte Zeichenfolge eher vom Anfang als vom Ende der zufälligen Zeichenfolge ab, damit kurze Zeichenfolgen (z. B. N = 1) nicht betroffen sind.

Aktualisieren:

Hier sind ein paar andere funktionale Einzeiler, die ich mir ausgedacht habe. Sie unterscheiden sich von der obigen Lösung darin, dass:

• Sie verwenden ein explizites beliebiges Alphabet (allgemeiner und für die ursprüngliche Frage geeignet, bei der sowohl Groß- als auch Kleinbuchstaben angefordert wurden).
• Alle Zeichenfolgen der Länge N haben die gleiche Wahrscheinlichkeit, zurückgegeben zu werden (dh Zeichenfolgen enthalten keine Wiederholungen).
• Sie basieren auf einer Kartenfunktion und nicht auf dem Trick toString (36), wodurch sie einfacher und verständlicher werden.

Angenommen, Sie haben das Alphabet Ihrer Wahl

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Dann sind diese beiden gleichwertig, sodass Sie auswählen können, was für Sie intuitiver ist:

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

und

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

Bearbeiten:

Ich scheine qubyte zu sein und Martijn de Milliano hat ähnliche Lösungen gefunden (Lob!), Die ich irgendwie vermisst habe. Da sie auf einen Blick nicht so kurz aussehen, lasse ich es trotzdem hier, falls jemand wirklich einen Einzeiler will :-)

Außerdem wurde in allen Lösungen 'neues Array' durch 'Array' ersetzt, um ein paar weitere Bytes zu sparen.

Die kompakteste Lösung, weil sie slicekürzer ist als substring. Durch Subtrahieren vom Ende der Zeichenfolge kann das von der randomFunktion erzeugte Gleitkommasymbol vermieden werden :

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

oder auch

(+new Date).toString(36).slice(-5);

Update: Ein weiterer Ansatz mit der btoaMethode wurde hinzugefügt :

btoa(Math.random()).slice(0, 5);
btoa(+new Date).slice(-7, -2);
btoa(+new Date).substr(-7, 5);

// Using Math.random and Base 36:
console.log(Math.random().toString(36).slice(-5));

// Using new Date and Base 36:
console.log((+new Date).toString(36).slice(-5));

// Using Math.random and Base 64 (btoa):
console.log(btoa(Math.random()).slice(0, 5));

// Using new Date and Base 64 (btoa):
console.log(btoa(+new Date).slice(-7, -2));
console.log(btoa(+new Date).substr(-7, 5));

So etwas sollte funktionieren

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

Rufen Sie mit dem Standardzeichensatz [a-zA-Z0-9] an oder senden Sie Ihren eigenen:

var randomValue = randomString(5);

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

Eine neuere Version mit dem es6- Spread-Operator :

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

• Das 30ist willkürliche Zahl, können Sie eine beliebige Token Länge holen Sie wollen
• Das 36ist die maximale radix Nummer , die Sie weitergeben können numeric.toString () , was bedeutet , alle Zahlen und az Kleinbuchstaben
• Das 2wird verwendet, um den 3. Index aus der zufälligen Zeichenfolge auszuwählen, die so aussieht: "0.mfbiohx64i"Wir könnten jeden Index danach nehmen0.

Zufälliger String-Generator (Alpha-Numerisch | Alpha | Numerisch)

/**
 * Pseudo-random string generator
 * http://stackoverflow.com/a/27872144/383904
 * Default: return a random alpha-numeric string
 * 
 * @param {Integer} len Desired length
 * @param {String} an Optional (alphanumeric), "a" (alpha), "n" (numeric)
 * @return {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;
}

console.log(randomString(10));      // i.e: "4Z8iNQag9v"
console.log(randomString(10, "a")); // i.e: "aUkZuHNcWw"
console.log(randomString(10, "n")); // i.e: "9055739230"

Während in den obigen Abschnitten zusätzliche Überprüfungen für die gewünschte A / N-, A-, N- Ausgabe verwendet werden, teilen wir sie zum besseren Verständnis auf das Wesentliche (nur alphanumerisch) auf:

• Erstellen Sie eine Funktion, die ein Argument akzeptiert (gewünschte Länge des zufälligen String-Ergebnisses).
• Erstellen Sie eine leere Zeichenfolge, var str = "";um zufällige Zeichen zu verketten
• Erstellen Sierand innerhalb einer Schleife eine Indexnummer von 0 bis 61 (0..9 + A..Z + a..z = 62).
• Erstellen Sie eine bedingte Logik zum Anpassen /rand Korrigieren (da es 0..61 ist), indem Sie sie um eine Zahl erhöhen (siehe Beispiele unten), um die richtige CharCodeZahl und das zugehörige Zeichen zurückzugewinnen.
• Innerhalb der Schleife verketten zu straString.fromCharCode( incremented rand )

Stellen wir uns die Bereiche der ASCII-Zeichentabelle vor:

_____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 )gibt einen Bereich von 0..61(was wir brauchen).
Korrigieren wir den Zufall, um die richtigen charCode-Bereiche zu erhalten :

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

Die bedingte Operation Logik aus der obigen Tabelle:

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

Aus der obigen Erklärung ergibt sich das resultierende alphanumerische Snippet :

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)); // i.e: "7GL9F0ne6t"

Oder wenn Sie so wollen:

const randomString = (n, r='') => {
  while (n--) r += String.fromCharCode((r=Math.random()*62|0, r+=r>9?(r<36?55:61):48));
  return r;
};

console.log(randomString(10))

Der einfachste Weg ist:

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

Dadurch werden zufällige Zeichenfolgen mit 5 Zeichen basierend auf der aktuellen Zeit generiert. Beispielausgabe ist 4mtxjoder 4mv90oder4mwp1

Das Problem dabei ist, dass, wenn Sie es zweimal in derselben Sekunde aufrufen, dieselbe Zeichenfolge generiert wird.

Der sicherere Weg ist:

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

Dadurch wird eine zufällige Zeichenfolge mit 4 oder 5 Zeichen generiert, die immer unterschiedlich ist. Beispielausgabe ist wie 30jzmoder 1r591oder4su1a

In beiden Fällen generiert der erste Teil eine Zufallszahl. Der .toString(36)Teil wandelte die Zahl in eine Base36-Darstellung (alphadezimal) um.

Hier sind einige einfache Einzeiler. Ändern Sie new Array(5), um die Länge festzulegen.

Einschließlich 0-9a-z

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

Einschließlich 0-9a-zA-Z

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

Ich weiß, dass jeder es bereits richtig gemacht hat, aber ich hatte das Gefühl, dass ich es auf die leichteste Art und Weise ausprobieren sollte (leichter Code, keine 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));

Es braucht ein bisschen Zeit, um den Kopf herumzureißen, aber ich denke, es zeigt wirklich, wie großartig die Syntax von Javascript ist.

Wenn Sie Lodash oder Underscore verwenden , ist das ganz einfach:

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

Um die Anforderung [a-zA-Z0-9] und die Länge = 5 zu erfüllen, verwenden Sie

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

Kleinbuchstaben, Großbuchstaben und Zahlen werden angezeigt.

Falls jemand an einem Einzeiler interessiert ist (obwohl er für Ihre Bequemlichkeit nicht als solcher formatiert ist), der den Speicher sofort zuweist (beachten Sie jedoch, dass es für kleine Zeichenfolgen wirklich keine Rolle spielt), gehen Sie wie folgt vor:

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

Sie können 5durch die Länge der gewünschten Zeichenfolge ersetzen . Vielen Dank an @AriyaHidayat in diesem Beitrag für die Lösung der mapFunktion, die nicht mit dem von erstellt wurde Array(5).

Hier ist die Methode, die ich erstellt habe.
Es wird eine Zeichenfolge erstellt, die sowohl Groß- als auch Kleinbuchstaben enthält.
Außerdem habe ich die Funktion eingefügt, mit der auch eine alphanumerische Zeichenfolge erstellt wird.

Arbeitsbeispiele:
http://jsfiddle.net/greatbigmassive/vhsxs/ (nur Alpha)
http://jsfiddle.net/greatbigmassive/PJwg8/ (alphanumerisch)

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

Upgrade Juli 2015
Dies macht dasselbe, ist aber sinnvoller und enthält alle Buchstaben.

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

Angenommen, Sie verwenden Unterstriche, können Sie elegant zufällige Zeichenfolgen in nur zwei Zeilen generieren:

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

const c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
const s = [...Array(5)].map(_ => c[~~(Math.random()*c.length)]).join('')

Schneller und verbesserter Algorithmus. Garantiert keine Uniform (siehe Kommentare).

function getRandomId(length) {
    if (!length) {
        return '';
    }

    const possible =
        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    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);
        }
    }

    let result = '';

    for (let i = 0; i < length; i++) {
        result += possible.charAt(array[i] % 62);
    }

    return result;
}

Das Problem bei der Beantwortung von Fragen zu "Ich brauche zufällige Zeichenfolgen" (in welcher Sprache auch immer) ist, dass praktisch jede Lösung eine fehlerhafte primäre Spezifikation der Zeichenfolgenlänge verwendet . Die Fragen selbst zeigen selten, warum die zufälligen Zeichenfolgen benötigt werden, aber ich würde Sie herausfordern, dass Sie selten zufällige Zeichenfolgen mit einer Länge von beispielsweise 8 benötigen. Sie benötigen ausnahmslos eine Reihe eindeutiger Zeichenfolgen , die beispielsweise als Bezeichner für einen bestimmten Zweck verwendet werden sollen.

Es gibt zwei Möglichkeiten, streng eindeutige Zeichenfolgen zu erhalten: deterministisch (was nicht zufällig ist) und Speichern / Vergleichen (was belastend ist). Was machen wir? Wir geben den Geist auf. Wir gehen stattdessen mit probabilistischer Einzigartigkeit . Das heißt, wir akzeptieren, dass ein gewisses (jedoch geringes) Risiko besteht, dass unsere Saiten nicht eindeutig sind. Hier ist das Verständnis von Kollisionswahrscheinlichkeit und Entropie hilfreich.

Daher werde ich das unveränderliche Bedürfnis so umformulieren, dass einige Zeichenfolgen mit einem geringen Wiederholungsrisiko benötigt werden. Nehmen wir als konkretes Beispiel an, Sie möchten ein Potenzial von 5 Millionen IDs generieren. Sie möchten nicht jede neue Zeichenfolge speichern und vergleichen, und Sie möchten, dass sie zufällig ist, sodass Sie ein gewisses Wiederholungsrisiko akzeptieren. Nehmen wir zum Beispiel ein Risiko von weniger als 1 in einer Billion Wiederholungswahrscheinlichkeit. Also, welche Länge der Saite brauchst du? Nun, diese Frage ist nicht genau spezifiziert, da sie von den verwendeten Zeichen abhängt. Aber was noch wichtiger ist, es ist falsch. Was Sie brauchen, ist eine Angabe der Entropie der Saiten, nicht ihrer Länge. Die Entropie kann in direktem Zusammenhang mit der Wahrscheinlichkeit einer Wiederholung in einer bestimmten Anzahl von Zeichenfolgen stehen. Stringlänge kann nicht.

Und hier kann eine Bibliothek wie EntropyString helfen. So generieren Sie zufällige IDs mit einer Wahrscheinlichkeit von weniger als 1 in einer Billion Wiederholungen in 5 Millionen Zeichenfolgen mit 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-stringVerwendet standardmäßig einen Zeichensatz mit 32 Zeichen. Es gibt andere vordefinierte Zeichensätze, und Sie können auch Ihre eigenen Zeichen angeben. Beispiel: Generieren von IDs mit derselben Entropie wie oben, jedoch unter Verwendung von Hex-Zeichen:

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

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

const string = random.string(bits)

27b33372ade513715481f

Beachten Sie den Unterschied in der Zeichenfolgenlänge aufgrund des Unterschieds in der Gesamtzahl der Zeichen im verwendeten Zeichensatz. Das Risiko einer Wiederholung in der angegebenen Anzahl potenzieller Zeichenfolgen ist gleich. Die Stringlängen sind nicht. Und das Beste ist, dass das Wiederholungsrisiko und die potenzielle Anzahl von Zeichenfolgen explizit sind. Kein Raten mehr mit Stringlänge.

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

Dies ist so sauber wie es nur geht. Es ist auch schnell, http://jsperf.com/ay-random-string .

Sie können ein Array von Elementen durchlaufen und diese rekursiv zu einer Zeichenfolgenvariablen hinzufügen, z. B. wenn Sie eine zufällige DNA-Sequenz wünschen:

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

Ich habe keine saubere Lösung gefunden, um sowohl Klein- als auch Großbuchstaben zu unterstützen.

Unterstützung nur für Kleinbuchstaben:

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

Aufbauend auf dieser Lösung zur Unterstützung von Klein- und Großbuchstaben:

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

Ändern Sie die 5insubstr(2, 5) der Länge einstellen Sie benötigen.

Einzeiler:

Array(15).fill(null).map(() => Math.random().toString(36).substr(2)).join('')
// Outputs: 0h61cbpw96y83qtnunwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil

Das funktioniert sicher

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

Wie wäre es mit so etwas: Date.now().toString(36) Nicht sehr zufällig, aber kurz und jedes Mal, wenn Sie es anrufen, ziemlich einzigartig.

Groß- und Kleinschreibung wird nicht berücksichtigt. Alphanumerische Zeichen:

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

Der Vorteil dieser Funktion besteht darin, dass Sie zufällige Zeichenfolgen unterschiedlicher Länge erhalten können und die Länge der Zeichenfolge sichergestellt wird.

Groß- und Kleinschreibung beachten Alle Zeichen:

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

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

Benutzerdefinierte Zeichen

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

Generieren Sie eine 10 Zeichen lange Zeichenfolge. Die Länge wird durch einen Parameter eingestellt (Standard 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;
}

Sie können Coderain verwenden . Es ist eine Bibliothek, um zufällige Codes nach einem bestimmten Muster zu generieren. Verwendung #als Platzhalter für Groß- und Kleinbuchstaben sowie Ziffern:

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

Es gibt andere Platzhalter wie Afür Großbuchstaben oder 9für Ziffern.

Was nützlich sein kann, ist, dass ein Anruf .next()immer ein eindeutiges Ergebnis liefert, sodass Sie sich nicht um Duplikate kümmern müssen.

Hier ist eine Demo-Anwendung, die eine Liste eindeutiger Zufallscodes generiert .

Vollständige Offenlegung: Ich bin der Autor von Coderain.