it-swarm.com.de

Erzeugen Sie zufällige Zeichenfolgen/Zeichen in JavaScript

Ich möchte eine Zeichenfolge mit 5 Zeichen, bestehend aus Zeichen, die aus dem Satz [a-zA-Z0-9] zufällig ausgewählt wurden.

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

1348
Tom Lehman

Ich denke, das wird für Sie funktionieren:

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

1873
csharptest.net

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 nachfolgende Nullen beim Festlegen von Gleitkommazahlen entfernt werden.
  • Dies hängt stark von dem Algorithmus ab, der zum Festlegen von Fließkommazahlen verwendet wird, was äußerst kompliziert ist. (Siehe den Artikel "So drucken Sie Fließkommazahlen genau" .)
  • Math.random() kann abhängig von der Implementierung eine vorhersagbare ("zufällig aussehende", aber nicht wirklich zufällige) Ausgabe erzeugen. Die resultierende Zeichenfolge ist nicht geeignet, wenn Sie Eindeutigkeit oder Unvorhersehbarkeit garantieren müssen.
  • Selbst wenn 6 unregelmäßig zufällige, unvorhersehbare Zeichen erzeugt wurden, können Sie aufgrund des Geburtstags-Paradoxons ein Duplikat nach dem Erzeugen von nur etwa 50.000 Zeichenfolgen erwarten. (Quadrat (36 ^ 6) = 46656)
1969
doubletap

Math.random ist schlecht für diese Art von Dingen

Option 1

Wenn Sie diese Server- Seite ausführen können, verwenden Sie einfach das Modul crypto

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 in hexadezimal kodierte Byte besteht aus 2 Zeichen. 20 Bytes bestehen aus 40 Zeichen Hex.


Option 2

Wenn Sie diese Seite Client- ausführen müssen, versuchen Sie es vielleicht mit dem Modul uuid

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

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

Option 3

Wenn Sie diese Client- Seite ausführen und keine alten Browser unterstützen müssen, können Sie dies ohne Abhängigkeiten tun

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

302
user633183

Kurz, einfach und zuverlässig

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

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

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

Erstens, wie andere bereits erwähnt haben, hat es eine geringe Wahrscheinlichkeit, kurze oder sogar eine leere Zeichenfolge (wenn die Zufallszahl 0 ist) zu erzeugen, wodurch Ihre Anwendung beschädigt werden kann. Hier ist eine Lösung:

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

Zweitens beschränken sowohl das Original als auch die Lösung die Zeichenfolge 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 von [0,1], d. H. Zwischen 0 (einschließlich) und 1 (exklusiv).
  2. Wandeln Sie die Zahl in eine Basis-36-Zeichenfolge um, d. H. Mit den Zeichen 0-9 und a-z.
  3. Mit Nullen auffüllen (löst die erste Ausgabe).
  4. Schneiden Sie die führende "0" ab. Präfix und zusätzliche Padding-Nullen.
  5. Wiederholen Sie die Zeichenfolge so oft, dass sie mindestens N Zeichen enthält (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 Stringlänge bei N = 16 in der ursprünglichen Antwort wird in Chrome gemessen. In Firefox ist es N = 11. Wie bereits erwähnt, handelt es sich bei der zweiten Lösung um die Unterstützung der angeforderten Stringlänge und nicht um das Hinzufügen von Zufälligkeiten, sodass es keinen großen Unterschied macht.
  • Alle zurückgegebenen Zeichenfolgen haben eine gleiche Wahrscheinlichkeit, dass sie zurückgegeben werden, zumindest soweit die von Math.random () zurückgegebenen Ergebnisse gleichmäßig verteilt sind (dies ist in keinem Fall eine zufällige kryptographische Stärke).
  • Es können nicht alle möglichen Zeichenfolgen der Größe N zurückgegeben werden. In der zweiten Lösung ist dies offensichtlich (da der kleinere String einfach dupliziert wird), aber auch in der ursprünglichen Antwort trifft dies zu, da bei der Umwandlung in die Basis-36 die letzten Bits möglicherweise nicht Teil der ursprünglichen Zufallsbits sind. Wenn Sie insbesondere das Ergebnis von Math.random (). ToString (36) betrachten, werden Sie feststellen, dass das letzte Zeichen nicht gleichmäßig verteilt ist. In fast allen Fällen spielt es keine Rolle, aber wir schneiden die letzte Zeichenfolge vom Anfang statt vom Ende der zufälligen Zeichenfolge, so dass kurze Zeichenfolgen (z. B. N = 1) nicht betroffen sind.

Update:

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

  • Sie verwenden ein explizites willkürliches Alphabet (allgemeiner und passend zur ursprünglichen Frage, die Groß- und Kleinbuchstaben verlangt).
  • Alle Zeichenfolgen der Länge N haben eine gleiche Wahrscheinlichkeit der Rückgabe (d. H. Zeichenfolgen enthalten keine Wiederholungen).
  • Sie basieren auf einer Map-Funktion und nicht auf dem toString-Trick (36), wodurch sie einfacher und verständlicher werden.

Also, sagen Sie, Ihr Alphabet der Wahl ist

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Dann sind diese beiden gleichwertig, sodass Sie auswählen können, welcher 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:

Mir scheint, als habe ich qubyte und Martijn de Milliano ähnliche Lösungen gefunden (kudos!), Die ich irgendwie vermisst habe. Da sie auf einen Blick nicht so kurz aussehen, lasse ich sie trotzdem hier, falls jemand wirklich einen One-Liner will :-)

Außerdem wurde in allen Lösungen das 'neue Array' durch 'Array' ersetzt, um einige weitere Bytes zu vermeiden.

139
amichair

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 einen eigenen:

var randomValue = randomString(5);

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

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

67
kennebec

Die kompakteste Lösung, da slice kürzer als substring ist. Durch das Subtrahieren vom Ende der Zeichenfolge können Sie das von der random - Funktion erzeugte Gleitkommasymbol vermeiden:

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

oder auch

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

59
Valentin

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

/**
 * 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"

Habe Spaß. jsBin demo


Während das Obige zusätzliche Überprüfungen für die gewünschte (A/N, A, N) -Ausgabe verwendet, lassen sich zum besseren Verständnis auf das Wesentliche (nur Alpha-Numerisch) aufteilen:

  • Eine Funktion erstellen, die ein Argument akzeptiert (gewünschte Länge des zufälligen String-Ergebnisses)
  • Erstellen Sie eine leere Zeichenfolge wie var str = "";, um zufällige Zeichen zu verketten
  • Innerhalb einer Schleife eine Rand Indexnummer von 0 bis 61 erstellen (0..9 + A..Z + a..z = 62)
  • Erstellen Sie eine conditional logic zu Adjust/fix Rand (da es 0..61 ist), erhöhen Sie sie um eine bestimmte Zahl (siehe Beispiele unten), um die richtige CharCode-Nummer und das zugehörige Zeichen zu erhalten.
  • Innerhalb der Schleife verketten Sie zu str eine String.fromCharCode( incremented Rand )

Stellen wir uns die Character-Tabelle und ihre Bereiche 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) an. Wie kann man die Zufallszahlen korrigieren (erhöhen), um die korrekten 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 logic aus der Tabelle oben:

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

Wenn Sie der obigen Erklärung gefolgt sind, sollten Sie in der Lage sein, dieses alphanumerische Snippet zu erstellen:

jsBin demo

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"

Oder wenn Sie wollen:

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;
}
45
Roko C. Buljan

Eine neuere Version mit es6 Spread Operator :

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

  • Der 30 Ist eine beliebige Zahl. Sie können eine beliebige Token-Länge auswählen
  • Der 36 Ist die maximale Radixzahl, die Sie an numeric.toString () übergeben können, dh alle Zahlen und a-z Kleinbuchstaben
  • Der 2 Wird verwendet, um die 2. Zahl aus der Zufallszeichenfolge auszuwählen, die so aussieht: "0.mfbiohx64i", Wir könnten jeden Index nach 0. Nehmen
41
Or Duan

Der einfachste Weg ist: 

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

Dies generiert zufällige Zeichenfolgen mit 5 Zeichen basierend auf der aktuellen Uhrzeit. Beispielausgabe ist 4mtxj oder 4mv90 oder 4mwp1

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 30jzm oder 1r591 oder 4su1a

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

29

Hier sind einige einfache Liner. Ä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"]();});
20
bendytree

Ich weiß, dass jeder es schon richtig gemacht hat, aber ich hatte das Gefühl, es auf die leichteste Weise zu versuchen (Licht auf Code, nicht auf 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 dauert etwas Zeit, den Kopf zu wickeln, aber ich denke, es zeigt wirklich, wie großartig die Javascript-Syntax ist.

17
Roderick

Wenn Sie Lodash oder Underscore verwenden, dann ist es so einfach:

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

Hier ist die Methode, die ich erstellt habe.
Es wird eine Zeichenfolge erstellt, die Groß- und Kleinbuchstaben enthält.
Außerdem habe ich die Funktion hinzugefügt, die auch eine alphanumerische Zeichenfolge erstellt.

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
.__ Das macht das gleiche, macht aber mehr Sinn und schließt alle Buchstaben ein.

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

Angenommen, Sie verwenden underscorejs , und Sie können zufällig einen String in nur zwei Zeilen erzeugen:

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

Falls sich jemand für einen One-Liner interessiert (obwohl er nicht für Sie so formatiert ist), dass er den Speicher auf einmal zuweist (beachten Sie jedoch, dass es für kleine Zeichenfolgen wirklich nicht von Bedeutung ist), gehen Sie folgendermaßen 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 5 durch die Länge der gewünschten Zeichenfolge ersetzen. Danke an @AriyaHidayat in this post für die Lösung der map-Funktion, die nicht in dem von Array(5) erstellten spärlichen Array funktioniert.

11

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

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

Kleinbuchstaben, Großbuchstaben und Zahlen werden vorkommen.

11
Sergio Cabral

Schneller und verbesserter Algorithmus. Garantiert nicht einheitlich (siehe Kommentare).

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

Sie können eine Reihe von Elementen durchlaufen und rekursiv einer String-Variablen hinzufügen, wenn Sie beispielsweise 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));

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

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

6
Gajus

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)

Auf dieser Lösung aufbauen, um Klein- und Großbuchstaben zu unterstützen:

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

Ändern Sie den 5 In substr(2, 5), um ihn an die gewünschte Länge anzupassen.

6
ravishi

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

Generieren Sie eine 10 Zeichen lange Zeichenfolge. Die Länge wird über Parameter festgelegt (Standardeinstellung 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;
}
4
ropsiU

Sie können coderain verwenden. Es ist eine Bibliothek zum Erzeugen von Zufallscodes gemäß dem angegebenen Muster. Verwenden Sie # als Platzhalter für Groß- und Kleinbuchstaben sowie Ziffern:

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

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

Es kann nützlich sein, dass der Aufruf von .next() immer ein eindeutiges Ergebnis liefert, so dass Sie sich nicht um Doppeleinträge kümmern müssen.

Hier ist eine Demoanwendung, die eine Liste eindeutiger Zufallscodes generiert .

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

4
Lukasz Wiktor

Das Problem mit den Antworten auf "Ich benötige zufällige Zeichenfolgen" - Fragen (in welcher Sprache auch immer) ist, dass praktisch jede Lösung eine fehlerhafte Primärspezifikation von string length verwendet. Die Fragen selbst verraten selten, warum die zufälligen Zeichenfolgen benötigt werden, aber ich würde Sie herausfordern, benötigen selten zufällige Längenfolgen, z. B. 8. Was Sie immer benötigen, ist eine Anzahl von unique-Zeichenfolgen, zum Beispiel als Bezeichner für einen bestimmten Zweck.

Es gibt zwei Hauptmethoden, um Strings eindeutig -Strings zu erhalten: deterministisch (was nicht zufällig ist) und store/compare (was anstrengend ist). Was machen wir? Wir geben den Geist auf. Wir gehen stattdessen mit probabilistischer Einzigartigkeit. Das heißt, wir akzeptieren, dass es ein (wenn auch geringes) Risiko gibt, dass unsere Saiten nicht einzigartig sind. Hier ist das Verstehen von Kollisionswahrscheinlichkeit und Entropie hilfreich.

Ich formuliere also das unveränderliche Bedürfnis so, dass es einige Strings mit einem geringen Wiederholungsrisiko benötigt. Angenommen, 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 sind, so dass Sie das Risiko einer Wiederholung in Kauf nehmen. Nehmen wir als Beispiel an, dass bei einer Billion Wiederholungsmöglichkeit eine Gefahr von weniger als 1 besteht. Welche Länge brauchen Sie also? Nun, diese Frage ist nicht genau festgelegt, da sie von den verwendeten Zeichen abhängt. Aber noch wichtiger ist, dass es falsch ist. Was Sie brauchen, ist eine Angabe der Entropie der Strings, nicht deren Länge. Entropie kann direkt mit der Wahrscheinlichkeit einer Wiederholung in einigen Strings zusammenhängen. Stringlänge kann nicht.

Und hier kann eine Bibliothek wie EntropyString helfen. So generieren Sie Zufalls-IDs, bei denen die Wahrscheinlichkeit einer Wiederholung in 5 Millionen Zeichenfolgen mit entropy-string geringer als 1 einer Billion ist:

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

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

const string = random.string(bits)

"44hTNghjNHGGRHqH9"

entropy-string verwendet standardmäßig einen Zeichensatz mit 32 Zeichen. Es gibt andere vordefinierte Zeichensätze, und Sie können auch Ihre eigenen Zeichen angeben. B. IDs mit der gleichen Entropie wie oben erzeugen, jedoch Hex-Zeichen verwenden:

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 Stringlänge aufgrund des Unterschieds in der Gesamtanzahl der Zeichen im verwendeten Zeichensatz. Das Wiederholungsrisiko in der angegebenen Anzahl möglicher Zeichenfolgen ist gleich. Die Stringlängen sind nicht. Und das Beste ist, dass das Wiederholungsrisiko und die mögliche Anzahl von Zeichenfolgen explizit sind. Kein Erraten mehr mit der Stringlänge.

4
dingo sky

Wie wäre es mit so etwas: Date.now().toString(36) Nicht sehr zufällig, aber kurz und bei jedem Aufruf recht einzigartig.

4
Swergas

Alphanumerische Zeichen ohne Berücksichtigung der Groß- und Kleinschreibung:

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 ist, dass Sie eine zufällige Zeichenfolge mit unterschiedlicher Länge erhalten können und die Länge der Zeichenfolge sicherstellt.

Groß-/Kleinschreibung 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

3
Ali

Hier ist ein Testskript für die Antwort # 1 (danke @ csharptest.net)

das Skript führt makeid()1 million-mal aus und wie Sie sehen, ist 5 nicht sehr einzigartig. Mit einer Zeichenlänge von 10 zu laufen, ist ziemlich zuverlässig. Ich habe es ungefähr 50 Mal ausgeführt und habe noch kein Duplikat gesehen. :-) 

hinweis: Das Limit der Knotenstapelgröße überschreitet etwa 4 Millionen, sodass Sie diese 5 Millionen Mal nicht ausführen können.

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

Wie wäre es mit diesem kompakten kleinen Trick?

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

Sie benötigen dort den Array.apply, um das leere Array zu einem Array von undefinierten zu machen.

Wenn Sie für ES2015 programmieren, ist das Erstellen des Arrays etwas einfacher:

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

Dieser vereint viele Antworten.

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

Ich habe es seit 1 Monat mit tollen Ergebnissen verwendet.

2
miodus

Das habe ich benutzt. Eine Kombination aus einem Paar hier. Ich verwende es in einer Schleife, und jede ID, die es erzeugt, ist eindeutig. Es kann nicht aus 5 Zeichen bestehen, aber es ist garantiert einzigartig.

var newId =
    "randomid_" +
    (Math.random() / +new Date()).toString(36).replace(/[^a-z]+/g, '');
2
Andrew Plank

Wenn eine Bibliothek möglich ist, könnte Chance.js helfen: http://chancejs.com/#string

2
Luca Bonavita

Erwähnung des eleganten Beispiels von Doubletap durch Beantwortung der von Gertas und Dragon aufgeworfenen Fragen. Fügen Sie einfach eine while-Schleife hinzu, um die seltenen Nullbedingungen zu testen, und beschränken Sie die Zeichen auf fünf. 

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

Hier ist ein jsfiddle, das Sie mit einem Ergebnis benachrichtigt: http://jsfiddle.net/pLJJ7/

2
Steven DAmico

Für eine Zeichenfolge mit Groß- und Kleinbuchstaben und Ziffern (0-9a-zA-Z) kann dies die Version sein, die sich am besten verringert:

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

Der Inhalt dieser Funktion wird auf 97 Bytes reduziert, während die oberste Antwort 149 Bytes (aufgrund der Zeichenliste) benötigt.

1
Waruyama

Hier ist ein anderer Ansatz mit fester Länge nach Basis, ohne dass RegExp den Mangel ersetzt (basierend auf der Antwort von @ 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('');
}
1
K-Gun

Auf der Grundlage der Antwort von doubletap werden auch beliebige zufällige Zeichen (nur niedrigere Zeichen) verarbeitet, und es werden so lange Zufallszahlen generiert, bis genügend Zeichen gesammelt wurden.

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

Ich liebte die Schönheit von doubletaps Math.random (). ToString (36) .Substring (7) antwortete, aber nicht, dass es so viele Kollisionen gab, als Hacklikecrack richtig darauf hingewiesen hat. Es erzeugte 11 Zeichenketten, hat jedoch eine Duplikatrate von 11% bei einer Stichprobe von 1 Million.

Hier ist eine längere (aber immer noch kurze) und langsamere Alternative mit nur 133 Duplikaten in einem Stichprobenraum von 1 Million. In seltenen Fällen ist die Zeichenfolge noch kürzer als 11 Zeichen:

Math.abs(Math.random().toString().split('')
    .reduce(function(p,c){return (p<<5)-p+c})).toString(36).substr(0,11);
1
Dwayne
"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('');};

generiert eine zufällige alphanumerische Zeichenfolge mit der Länge der ersten/aufrufenden Zeichenfolge

1
nclu

Dies ist eine etwas verbesserte Version von doubletap 's answer . Es berücksichtigt den Kommentar von gertas über den Fall, wenn Math.random() 0, 0,5, 0,25, 0,125 usw. zurückgibt.

((Math.random()+3*Number.MIN_VALUE)/Math.PI).toString(36).slice(-5)
  1. Dadurch wird verhindert, dass Null an toString übergeben wird, wobei der kleinste Float zu Math.random() hinzugefügt wird.
  2. Es stellt sicher, dass die an toString übergebene Nummer durch die Division durch eine nahezu irrationale Zahl genügend Ziffern enthält.
1
ceving

Dies speichert 5 alphanumerische Zeichen in Variable c.

for(var c = ''; c.length < 5;) c += Math.random().toString(36).substr(2, 1)
1
Collin Anderson

Lehre einen Mann das Fischen:

Programmierer schneiden Papier mit Lasern, nicht mit Kettensägen. Die Verwendung fringe, sprachspezifischer Methoden zur Erzeugung des kleinsten, am meisten verschleierten Codes ist niedlich und alles, bietet aber niemals eine vollständige Lösung. Sie müssen das richtige Werkzeug für den Job verwenden. 

Was Sie wollen, ist eine Zeichenfolge, und die Zeichen werden in Bytes dargestellt. Und wir können ein Byte in JavaScript mit einer Zahl darstellen. Wir sollten also eine Liste dieser Zahlen generieren und als Zeichenketten umwandeln. Sie brauchen kein Date oder base64; Math.random () erhält eine Zahl, und String.fromCharCode () macht daraus eine Zeichenfolge. Einfach.

Aber welche Zahl entspricht welchem ​​Zeichen? UTF-8 ist der primäre Standard, der im Web verwendet wird, um Bytes als Zeichen zu interpretieren (obwohl JavaScript intern UTF-16 verwendet, überlappen sie sich). Der Programmierer kann dieses Problem lösen, indem er sich die Dokumentation anschaut. 

UTF-8 listet alle Tasten auf der Tastatur in den Zahlen zwischen 0 und 128 auf. Einige werden nicht gedruckt. Wählen Sie einfach die gewünschten Zeichen in Ihren zufälligen Zeichenfolgen aus und suchen Sie sie mithilfe von zufällig generierten Zahlen.

Balg ist eine Funktion, die eine praktisch unendliche Länge hat, eine Zufallszahl in einer Schleife generiert und nach allen Druckzeichen in den unteren 128 UTF-8-Codes sucht. Entropie ist inhärent, da nicht jedes Mal alle Zufallszahlen getroffen werden (nicht druckbare Zeichen, Leerzeichen usw.). Es wird auch schneller arbeiten, wenn Sie weitere Zeichen hinzufügen.

Ich habe die meisten Optimierungen in den Thread aufgenommen:

  • Die doppelte Tilde ist schneller als Math.floor
  • "if" -Anweisungen sind schneller als reguläre Ausdrücke
  • ein Push auf ein Array ist schneller als die Verkettung von Zeichenfolgen

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) // <=>[email protected]
        // || (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>

Warum so langweilig? Weil du es kannst. Du bist ein Programmierer. Sie können einen Computer dazu bringen, alles zu tun! Was ist, wenn Sie eine Reihe hebräischer Zeichen wünschen? Es ist nicht schwer. Suchen Sie diese Zeichen im UTF-8-Standard und suchen Sie danach. Befreien Sie sich von diesen McDonald-Methoden wie toString (36).

Manchmal ist es notwendig, auf eine niedrigere Abstraktionsebene zu springen, um eine echte Lösung zu erstellen. Wenn Sie die grundlegenden Prinzipien kennen, die zur Verfügung stehen, können Sie Ihren Code nach Ihren Wünschen anpassen. Vielleicht möchten Sie, dass eine unendlich generierte Zeichenfolge einen Ringspeicher füllt? Vielleicht möchten Sie, dass alle generierten Zeichenfolgen Palindrome sind? Warum sich zurückhalten?

1
Duco
",,,,,".replace(/,/g,function (){return "AzByC0xDwEv9FuGt8HsIrJ7qKpLo6MnNmO5lPkQj4RiShT3gUfVe2WdXcY1bZa".charAt(Math.floor(Math.random()*62))});
1
guest271314

Zufälliger Unicode-String

Diese Methode gibt eine zufällige Zeichenfolge mit einem der unterstützten Unicode-Zeichen zurück. Dies ist nicht zu 100% das, was OP verlangt, sondern das, wonach ich gesucht habe:

function randomUnicodeString(length){
    return Array.from({length: length}, ()=>{
        return String.fromCharCode(Math.floor(Math.random() * (65536)))
    }).join('')
}

Begründung

Dies ist das beste Ergebnis von Google bei der Suche nach "Random-String-Javascript", aber OP fragt nur nach a-zA-Z0-9. 

1
Automatico

Zufälliger numerischer Wert (bis zu 16 Ziffern)

/**
 * Random numeric value (up to 16 digits)
 * @returns {String}
 */
function randomUid () {
  return String(Math.floor(Math.random() * 9e15))
}

// randomUid() -> "3676724552601324"
1
artnikpro

Ich benutze var randId = 'Rand' + new Date().getTime();

1
CMS

Dies ist für Firefox-Chromcode (Addons und dergleichen)

Es kann Ihnen einige Stunden Forschung ersparen.

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

Verwenden Sie es als:

let   strlen   = 5
    , radix    = 36
    , filename = randomBytes( strlen ).toString( radix ).splice( - strlen )
0
user1115652

Eine weitere nette Möglichkeit, eine Zeichenfolge aus den Zeichen A-Za-z0-9 zu randomisieren

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;
}
0
Slavik Meltser

Ich habe einen String-Prototyp erstellt, der einen zufälligen String mit einer bestimmten Länge erzeugen kann.

Sie können auch festlegen, ob Sie Sonderzeichen wünschen, und Sie können einige vermeiden.

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

Sie können wie folgt verwenden:

// Generate password with specialChars which contains 10 chars and avoid iIlL chars
var password = String().randomGenerator(true, 10, 'iIlL');

Ich hoffe es hilft.

0
Sparw

Wie mehrere Personen hier bereits darauf hingewiesen haben, hat die Weitergabe des Ergebnisses von Math.random() direkt an .string(36) mehrere Probleme.

Es hat schlechte Zufälligkeit. Die Anzahl der generierten Zeichen variiert und hängt im Durchschnitt von den kniffligen Details ab, wie Gleitkommazahlen in Javascript funktionieren. Es scheint zu funktionieren, wenn ich versuche, 11 Zeichen oder weniger zu erzeugen, aber nicht mit mehr als 11 Zeichen. Und es ist nicht flexibel. Es gibt keine einfache Möglichkeit, bestimmte Zeichen zuzulassen oder zu verbieten.

Ich habe eine kompakte Lösung, die diese Probleme nicht hat, für alle, die lodash verwenden:

_.range(11).map(i => _.sample("abcdefghijklmnopqrstuvwxyz0123456789")).join('')

Wenn Sie bestimmte Zeichen zulassen möchten (z. B. Großbuchstaben) oder bestimmte Zeichen verbieten möchten (z. B. mehrdeutige Zeichen wie l und 1), ändern Sie die obige Zeichenfolge.

0
Elias Zamaria

im folgenden Code generiere ich zufälligen Code für 8 Zeichen

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

Ein funktionaler Ansatz. Diese Antwort ist nur praktisch wenn die funktionalen Voraussetzungen in anderen Teilen Ihrer App genutzt werden können. Die Performance ist wahrscheinlich Müll, aber das Schreiben hat super Spaß gemacht.

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

Meiner Meinung nach ist es schwierig, die Klarheit von idGenerator zu übertreffen, ohne magische Funktionen für viele Dinge zu verwenden.

Eine leichte Verbesserung könnte sein

// 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'))
])

Viel Spass damit. Lass mich wissen, was dir gefällt/lernt ^ _ ^

0
user633183

Alle Antworten sind perfekt. aber ich füge hinzu, was sehr gut und schnell ist, um irgendeinen zufälligen Zeichenkettenwert zu erzeugen

function randomStringGenerator(stringLength) {
  var randomString = ""; // Empty value of the selective variable
  const allCharacters = "'`[email protected]#$%^&*()_+-={}[]:;\'<>?,./|\\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

oder

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
0
Parth Raval

rekursive Lösung:

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)

}

sie können mit dem Samen, den Sie wollen, verwenden. Beispiel 

generateRandomId("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") 
0
Pascual Muñoz

sehr einfach

function getRandomColor(){
  var color='';
  while(color.length<6){
    color=Math.floor(Math.random()*16777215).toString(16);
  }
  return '#'+color;
}
0

Setzen Sie die Zeichen als thisArg in die Kartenfunktion, um einen "Einzeiler" zu erstellen:

Array.apply(null, Array(5))
.map(function(){ 
    return this[Math.floor(Math.random()*this.length)];
}, "abcdefghijklmnopqrstuvwxyz")
.join('');
0
user1506145

Sie könnten base64 verwenden:

function randomString(length)
{
    var rtn = "";

    do {
        rtn += btoa("" + Math.floor(Math.random() * 100000)).substring(0, length);
    }
    while(rtn.length < length);

    return rtn;
}
0
Antinous

Probieren Sie das aus, was ich jedes Mal benutze:

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('')
0
Nahuel Greco

Hier ist mein Ansatz (mit TypeScript).

Ich habe beschlossen, noch eine Antwort zu schreiben, weil ich keine einfache Lösung mit modernen Js und sauberem Code gefunden habe.

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

Ich schreibe einfach ein einfaches Paket, um ein zufälliges Token mit gegebener Größe, Samen und Maske zu generieren. Zu Ihrer Information.

@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
0
Sibevin Wang

Wie wäre es mit dem unten ... das wird die wirklich zufälligen Werte erzeugen:

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

Wenn Sie jedoch nach einer kürzeren Syntax in ES6 suchen:

const getRandomStrings = length => Math.random().toString(36).substr(-length);
0
Alireza

Das npm-Modul anyid bietet eine flexible API zum Generieren verschiedener Arten von String-ID/Code.

const id = anyid().encode('Aa0').length(5).random().id();
0
aleung