Wie generiere ich eine Zufallszahl fester Länge mit JavaScript?


75

Ich versuche eine Zufallszahl zu generieren, die eine feste Länge von genau 6 Stellen haben muss.

Ich weiß nicht, ob das unten angegebene JavaScript jemals eine Zahl mit weniger als 6 Ziffern erzeugen würde.

Math.floor((Math.random()*1000000)+1);

Ich habe diese Frage und Antwort auf StackOverflow hier gefunden . Aber es ist unklar.

BEARBEITEN: Ich habe den obigen Code einige Male ausgeführt und Ja, es werden häufig Zahlen mit weniger als 6 Ziffern erstellt. Gibt es eine schnelle Möglichkeit, um sicherzustellen, dass es immer genau 6 Stellen sind?


Mögliches Duplikat der Zufallszahl mit fester Länge
Cœur

Hallo Leute, ich möchte dasselbe mit 70-stelliger Länge.
Swapnil Yeole

Antworten:


155

console.log(Math.floor(100000 + Math.random() * 900000));

Werde immer eine Reihe von 6 Stellen schaffen und sichert die erste Ziffer wird nie 0. Der Code in Ihrer Frage sein wird eine Reihe von weniger als 6 Stellen schaffen.


12
Hey, du hast ein gutes Kommentar hinzugefügt. Ich möchte nie, dass die erste Ziffer 0 ist. Guter Punkt.
Hypermiler

1
@ Momomo wie tho
Cilan

2
Sie müssen eine Zufallszahl von 0-9, n-mal generieren. siehe gepostete Antwort von mir
mmm

@Doorhandle Um Ihre Frage zu beantworten, wie, fügen Sie 100000 hinzu. Dies bedeutet, dass nur Zahlen darüber möglich sind. Die einzige Möglichkeit, eine echte feste n-Länge ohne Verlust zu erhalten, besteht darin, jeweils eine Zahl n-mal zu generieren. Daraus folgt auch, dass auch nicht alle Zahlen über 10 ^ n möglich sind. So wäre beispielsweise eine Zufallszahl mit fester Länge 2 10 - 99. Für 3 100 - 999. Für 4 1000 - 9999. Für 5 10000 - 99999 und so weiter. Wie zu sehen ist, deutet dies auf einen Verlust von 10% an Randmns hin. Für wirklich große Zahlen (18, 24, 48) sind 10% immer noch viele Zahlen.
mmm

1
@ Momomo er sagt speziell, es muss 6 Ziffern ohne 0 als erste Zahl sein (siehe obigen Kommentar)
Cilan

27

Nur vollständig zuverlässige Antwort, die vollständige Zufälligkeit ohne Verlust bietet. Die anderen vor dieser Antwort verlieren alle, je nachdem, wie viele Zeichen Sie möchten. Je mehr Sie wollen, desto mehr verlieren sie die Zufälligkeit.

Sie erreichen dies, indem sie die Anzahl der möglichen Zahlen vor der festen Länge begrenzen.

So wäre beispielsweise eine Zufallszahl mit fester Länge 2 10 - 99. Für 3 100 - 999. Für 4 1000 - 9999. Für 5 10000 - 99999 und so weiter. Wie aus dem Muster ersichtlich ist, deutet dies auf einen Zufallsverlust von 10% hin, da Zahlen davor nicht möglich sind. Warum?

Für wirklich große Zahlen (18, 24, 48) sind 10% immer noch eine Menge Zahlen , die man verlieren muss.

function generate(n) {
        var add = 1, max = 12 - add;   // 12 is the min safe number Math.random() can generate without it starting to pad the end with zeros.   

        if ( n > max ) {
                return generate(max) + generate(n - max);
        }

        max        = Math.pow(10, n+add);
        var min    = max/10; // Math.pow(10, n) basically
        var number = Math.floor( Math.random() * (max - min + 1) ) + min;

        return ("" + number).substring(add); 
}

Der Generator ermöglicht eine unendliche Länge ohne Verlust an Präzision und mit minimalen Leistungskosten.

Beispiel:

generate(2)
"03"
generate(2)
"72"
generate(2)
"20"
generate(3)
"301"
generate(3)
"436"
generate(3)
"015"

Wie Sie sehen können, ist anfangs sogar die Null enthalten, was einen zusätzlichen Verlust von 10% darstellt , abgesehen von der Tatsache, dass Zahlen vor 10 ^ n nicht möglich sind.

Das sind jetzt insgesamt 20%.

Außerdem haben die anderen Optionen eine Obergrenze für die Anzahl der Zeichen, die Sie tatsächlich generieren können.

Beispiel mit Kosten:

var start = new Date(); var num = generate(1000); console.log('Time: ', new Date() - start, 'ms for', num)

Protokolle:

Time: 0 ms for 7884381040581542028523049580942716270617684062141718855897876833390671831652069714762698108211737288889182869856548142946579393971303478191296939612816492205372814129483213770914444439430297923875275475120712223308258993696422444618241506074080831777597175223850085606310877065533844577763231043780302367695330451000357920496047212646138908106805663879875404784849990477942580056343258756712280958474020627842245866908290819748829427029211991533809630060693336825924167793796369987750553539230834216505824880709596544701685608502486365633618424746636614437646240783649056696052311741095247677377387232206206230001648953246132624571185908487227730250573902216708727944082363775298758556612347564746106354407311558683595834088577220946790036272364740219788470832285646664462382109714500242379237782088931632873392735450875490295512846026376692233811845787949465417190308589695423418373731970944293954443996348633968914665773009376928939207861596826457540403314327582156399232931348229798533882278769760

Mehr Hardcore:

generate(100000).length === 100000 -> true

"muss eine feste Länge von genau 6 Ziffern haben" ... "Ich möchte nie, dass die erste Ziffer 0 ist. Guter Punkt. - Hypermiler". Ich bewundere Ihre Technik und das Schieben des Umschlags, und ich bin sicher, dass diese Antwort für jemand anderen nützlich sein könnte, aber nur zu sagen. Auf der anderen Seite ist Ihr Algorithmus massiv rekursiv, daher bin ich nicht davon überzeugt, dass er "eine unendliche Länge [...] bei minimalen Leistungskosten zulässt".
Randomsock

@randomsock es ist nur rekursiv, wenn Sie mehr Zahlen als 12 benötigen. In diesem Fall werden 12 Zahlen gleichzeitig generiert. minimale Leistungskosten, ja. Der Zweck ist die Verwendung für Zufallszahlenzeichenfolgen, bei denen es auf Zufälligkeit ankommt oder wie der Inhalt aussieht oder nicht. Nullen am Start waren für uns in Ordnung. Eine gültige zufällige Zeichenfolge ist 0000000123, diese wird jedoch bei keiner anderen Methode als dieser generiert.
mmm

13

Ich würde mit dieser Lösung gehen:

Math.floor(Math.random() * 899999 + 100000)

OK. Ich verstehe es. JA. Das wird es schaffen!
Hypermiler

13

Allgemeiner kann das Erzeugen einer zufälligen Ganzzahl mit fester Länge erfolgen mit Math.pow:

var randomFixedInteger = function (length) {
    return Math.floor(Math.pow(10, length-1) + Math.random() * (Math.pow(10, length) - Math.pow(10, length-1) - 1));
}

Um die Frage zu beantworten: randomFixedInteger(6);


Beste und vielseitigste Antwort.
Ansjovis86

Ich denke, dies würde keine 0-First-Padding-Zahl ergeben, etwa 00382. Das wäre also nicht für alle Bereiche genau zufällig.
Jungwon Jin

4

Basierend auf dem von Ihnen angegebenen Link sollte die richtige Antwort lauten

Math.floor (Math.random () * 899999 + 100000);

Math.random () gibt float zwischen 0 und 1 zurück, daher beträgt die Mindestanzahl 100000, max - 999999. Genau 6 Stellen, wie Sie wollten :)


3
100000 + Math.floor(Math.random() * 900000);

gibt eine Nummer von 100000 bis 999999 (einschließlich).


Nein! Es mag wie ein Eckfall aussehen, aber wenn Math.random()1 zurückgegeben wird, könnte diese Lösung 1000000 ergeben, was eine 7-stellige Zahl ist.
Saeed Ahadian

1
@SaeedAhadian Überprüfen Sie die Dokumente. "im Bereich von 0 bis weniger als 1" developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
sharoz

Guter Punkt! Ich wusste nicht, dass es nicht inklusive 1 ist. Danke dafür.
Saeed Ahadian

2

Hier ist meine Funktion, die ich benutze. n - Stringlänge, die Sie generieren möchten

function generateRandomNumber(n) {
  return Math.floor(Math.random() * (9 * Math.pow(10, n - 1))) + Math.pow(10, n - 1);
}


1

Dies ist ein weiterer Zufallszahlengenerator, den ich oft benutze. Er verhindert auch, dass die erste Ziffer Null (0) ist.

  function randomNumber(length) {
    var text = "";
    var possible = "123456789";
    for (var i = 0; i < length; i++) {
      var sup = Math.floor(Math.random() * possible.length);
      text += i > 0 && sup == i ? "0" : possible.charAt(sup);
    }
    return Number(text);
  }


1
npm install --save randomatic

var randomize = require('randomatic');
randomize(pattern, length, options);

Beispiel:

So generieren Sie eine zufällige Zeichenfolge mit 10 Zeichen unter Verwendung aller verfügbaren Zeichen:

randomize('*', 10);
//=> 'x2_^-5_T[$'

randomize('Aa0!', 10);
//=> 'LV3u~BSGhw'

a: Kleinbuchstaben (abcdefghijklmnopqrstuvwxyz '

A: Alpha in Großbuchstaben (ABCDEFGHIJKLMNOPQRSTUVWXYZ ')

0: Numerische Zeichen (0123456789 ')

!: Sonderzeichen (~! @ # $% ^ & () _ + - = {} []; \ ',.)

*: Alle Zeichen (alle oben genannten kombiniert)

?: Benutzerdefinierte Zeichen (übergeben Sie eine Zeichenfolge mit benutzerdefinierten Zeichen an die Optionen)

NPM Repo


0

Ich habe die folgende Funktion erstellt, um eine zufällige Anzahl von Fixlängen zu generieren:

function getRandomNum(length) {
    var randomNum = 
        (Math.pow(10,length).toString().slice(length-1) + 
        Math.floor((Math.random()*Math.pow(10,length))+1).toString()).slice(-length);
    return randomNum;
}

Dadurch werden am Anfang grundsätzlich Nullen hinzugefügt, um die Länge der Zahl nach Bedarf festzulegen.


0

Ich habe heute darüber nachgedacht und mich dann für die Lösung entschieden.

var generateOTP = function(otpLength=6) {
  let baseNumber = Math.pow(10, otpLength -1 );
  let number = Math.floor(Math.random()*baseNumber);
  /*
  Check if number have 0 as first digit
  */
  if (number < baseNumber) {
    number += baseNumber;
  }
  return number;
};

Lassen Sie mich wissen, wenn es einen Fehler gibt. Vielen Dank.


Dies hat in der Tat einen Fehler: Sie machen es doppelt so wahrscheinlich, dass eine Zahl zwischen 100000 und 199999 generiert wird als jede andere Zahl.
G. Sliepen

0

"Zufallszahlen mit JS generieren"

console.log(
Math.floor(Math.random() * 1000000)
);
<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Math.random()</h2>

<p id="demo"></p>

</body>
</html>


0

Dieser Code bietet nahezu vollständige Zufälligkeit:

function generator() {
    const ran = () => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0].sort((x, z) => {
        ren = Math.random();
        if (ren == 0.5) return 0;
        return ren > 0.5 ? 1 : -1
    })
    return Array(6).fill(null).map(x => ran()[(Math.random() * 9).toFixed()]).join('')
}

console.log(generator())

Dieser Code bietet vollständige Zufälligkeit:

function generator() {

    const ran1 = () => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0].sort((x, z) => {
        ren = Math.random();
        if (ren == 0.5) return 0;
        return ren > 0.5 ? 1 : -1
    })
    const ran2 = () => ran1().sort((x, z) => {
        ren = Math.random();
        if (ren == 0.5) return 0;
        return ren > 0.5 ? 1 : -1
    })

    return Array(6).fill(null).map(x => ran2()[(Math.random() * 9).toFixed()]).join('')
}

console.log(generator())


0

  var number = Math.floor(Math.random() * 9000000000) + 1000000000;
    console.log(number);

Dies kann der einfachste und zuverlässigste Weg sein.


0

Für die Länge von 6 spielt die Rekursivität keine große Rolle.

function random(len) {
  let result = Math.floor(Math.random() * Math.pow(10, len));

  return (result.toString().length < len) ? random(len) : result;
}

console.log(random(6));


0

Wenn Sie auch möchten, dass die erste Ziffer 0 sein kann, ist dies meine Lösung:

const getRange = (size, start = 0) => Array(size).fill(0).map((_, i) => i + start);

const getRandomDigit = () => Math.floor(Math.random() * 10);

const generateVerificationCode = () => getRange(6).map(getRandomDigit).join('');

console.log(generateVerificationCode())


0

Ich benutze Randojs , um die Zufälligkeit einfacher und lesbarer zu machen. Sie können mit randojs ein zufälliges int zwischen 100000 und 999999 auswählen:

console.log(rando(100000, 999999));
<script src="https://randojs.com/1.0.0.js"></script>


0

Generieren Sie eine Zufallszahl, die eine feste Länge von genau 6 Stellen haben muss:

("000000"+Math.floor((Math.random()*1000000)+1)).slice(-6)

2
Hoffe, es wird das Problem lösen, aber bitte fügen Sie eine Erklärung Ihres Codes hinzu, damit der Benutzer ein perfektes Verständnis dafür erhält, was er wirklich will.
Jaimil Patel

-2

parseInt(Math.random().toString().slice(2,Math.min(length+2, 18)), 10); // 18 -> due to max digits in Math.random

Update: Diese Methode weist nur wenige Mängel auf: - Manchmal ist die Anzahl der Ziffern geringer, wenn die linke Seite mit Nullen aufgefüllt ist.


2
Dies ist aus mehreren Gründen falsch. Es gibt keine Garantie dafür, dass das Slice, das Sie aus der Zeichenfolge auswählen, nicht mit Nullen beginnt. Vermeiden Sie es auch, Zahlen in und aus Zeichenfolgen zu konvertieren, wenn es eine perfekte Möglichkeit gibt, das Problem mit normalen mathematischen Funktionen zu lösen.
G. Sliepen

@ G.Sliepen Danke, dass du mich korrigiert hast. Könnten Sie für mein Lernen auch etwas näher darauf eingehen, warum Zahlen nicht von und zu Zeichenfolgen sein sollten? Irgendwelche bekannten Mängel? Vielen Dank
Kushagra Gour

1
Das Konvertieren in und von Zeichenfolgen ist langsam und es ist leicht, Eckfälle zu vergessen, zum Beispiel: Wenn eine Zahl negativ ist, ist Null eine Gleitkommazahl, wird in Exponentialschreibweise konvertiert und so weiter. Zum Beispiel Math.random()könnte 0 oder 1 genau zurückgegeben werden, und diese würden in die Zeichenfolgen '0'oder konvertiert '1'und .slice(2, ...)würden dann eine leere Zeichenfolge zurückgeben und parseInt()würden dann zurückkehren NaN.
G. Sliepen

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.