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

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?

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.

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

Ich würde mit dieser Lösung gehen:

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

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

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

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

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

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

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

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

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.

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.

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

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

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

Dies kann der einfachste und zuverlässigste Weg sein.

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

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

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>

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

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

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.

Sie können dieses Modul https://www.npmjs.com/package/uid verwenden . Es generiert eine eindeutige ID mit variabler Länge

uid(10) => "hbswt489ts"
 uid() => "rhvtfnt" Defaults to 7

Oder schauen Sie sich dieses Modul an: https://www.npmjs.com/package/shortid

const shortid = require('shortid');

console.log(shortid.generate());
// PPBqWA9

Hoffe es funktioniert bei dir :)