PHP zufällige x Ziffernzahl

Ich muss eine Zufallszahl mit x Ziffern erstellen.

Nehmen wir also an, x ist 5, ich brauche eine Zahl, um z. 35562 Wenn x 3 ist, würde es so etwas wie zurückwerfen; 463

Könnte mir jemand zeigen, wie das gemacht wird?

Sie können rand()zusammen mit verwenden pow(), um dies zu erreichen:

$digits = 3;
echo rand(pow(10, $digits-1), pow(10, $digits)-1);

Dies gibt eine Zahl zwischen 100 und 999 aus. Dies liegt daran, dass 10 ^ 2 = 100 und 10 ^ 3 = 1000 ist und Sie sie dann mit einer subtrahieren müssen, um sie in den gewünschten Bereich zu bringen.

Wenn 005 auch ein gültiges Beispiel ist, würden Sie den folgenden Code verwenden, um es mit führenden Nullen aufzufüllen:

$digits = 3;
echo str_pad(rand(0, pow(10, $digits)-1), $digits, '0', STR_PAD_LEFT);

Normalerweise benutze ich nur RAND() http://php.net/manual/en/function.rand.php

z.B

rand ( 10000 , 99999 );

für Ihre 5-stellige Zufallszahl

Hier ist eine einfache Lösung ohne Schleifen oder Probleme, mit der Sie zufällige Zeichenfolgen mit Zeichen, Zahlen oder sogar mit speziellen Symbolen erstellen können.

$randomNum = substr(str_shuffle("0123456789"), 0, $x);

wo $xkann die Anzahl der Ziffern sein

Z.B. substr(str_shuffle("0123456789"), 0, 5);

Ergebnisse nach einigen Hinrichtungen

98450
79324
23017
04317
26479

Sie können denselben Code auch verwenden, um eine zufällige Zeichenfolge wie diese zu generieren

$randomNum=substr(str_shuffle("0123456789abcdefghijklmnopqrstvwxyzABCDEFGHIJKLMNOPQRSTVWXYZ"), 0, $x);

Ergebnisse mit $x = 11

FgHmqpTR3Ox
O9BsNgcPJDb
1v8Aw5b6H7f
haH40dmAxZf
0EpvHL5lTKr

Sie können rand($min, $max)genau für diesen Zweck verwenden.

Um die Werte auf Werte mit x Ziffern zu beschränken, können Sie Folgendes verwenden:

$x = 3; // Amount of digits
$min = pow(10,$x);
$max = pow(10,$x+1)-1);
$value = rand($min, $max);

Behandeln Sie Ihre Nummer als eine Liste von Ziffern und fügen Sie jedes Mal eine zufällige Ziffer hinzu:

function n_digit_random($digits) {
  $temp = "";

  for ($i = 0; $i < $digits; $i++) {
    $temp .= rand(0, 9);
  }

  return (int)$temp;
}

Oder eine rein numerische Lösung:

function n_digit_random($digits)
  return rand(pow(10, $digits - 1) - 1, pow(10, $digits) - 1);
}

function random_numbers($digits) {
    $min = pow(10, $digits - 1);
    $max = pow(10, $digits) - 1;
    return mt_rand($min, $max);
}

Getestet hier .

Der einfachste Weg, den ich mir vorstellen kann, ist die Verwendung von randFunktion mitstr_pad

<?php
echo str_pad(rand(0,999), 5, "0", STR_PAD_LEFT);
?>

Im obigen Beispiel wird eine Zufallszahl im Bereich von 0 bis 999 generiert .

Und mit 5 Ziffern.

rand(1000, 9999); arbeitet schneller als x4 mal rand(0,9);

Benchmark:

rand(1000, 9999)      : 0.147 sec.
rand(0,9)x4 times     : 0.547 sec.

Beide Funktionen wurden in 100000 Iterationen ausgeführt, um die Ergebnisse deutlicher zu machen

mach es mit einer Schleife:

function randomWithLength($length){

    $number = '';
    for ($i = 0; $i < $length; $i++){
        $number .= rand(0,9);
    }

    return (int)$number;

}

randoder mt_randwird tun ...

Verwendung:

rand(min, max);

mt_rand(min, max);

function random_number($size = 5)
{
    $random_number='';
    $count=0;
    while ($count < $size ) 
        {
            $random_digit = mt_rand(0, 9);
            $random_number .= $random_digit;
            $count++;
        }
    return $random_number;  
}

Nun, Sie können als einfache PHP-Funktion mt_rand (2000,9000) verwenden, die eine 4-stellige Zufallszahl erzeugen kann

mt_rand(2000,9000) 

Mit der Funktion mt_rand () können Sie eine beliebige x-stellige Zufallszahl generieren. mt_rand () viel schneller mit der Funktionssyntax rand (): mt_rand()oder mt_rand($min , $max).

Weiterlesen

Beispiel: <?php echo mt_rand(); ?>

Dieses einfache Skript reicht aus

$x = 4;//want number of digits for the random number
$sum = 0;


for($i=0;$i<$x;$i++)
{
    $sum = $sum + rand(0,9)*pow(10,$i);

}

echo $sum;

Dies ist eine weitere einfache Lösung, um eine zufällige Anzahl von N Ziffern zu generieren:

$number_of_digits = 10;
echo substr(number_format(time() * mt_rand(),0,'',''),0,$number_of_digits);

Überprüfen Sie es hier: http://codepad.org/pyVvNiof

function rand_number_available($already_mem_array,$boundary_min,$boundary_max,$digits_num)
{

    $already_mem_array_dim = count($already_mem_array);         // dimension of array, that contain occupied elements

    // --- creating Boundaries and possible Errors
    if( empty($digits_num) ){   
            $boundary_dim = $boundary_max - $boundary_min;
            if($boundary_dim <= 0){
                $error = -1;                                    // Error that might happen. Difference between $boundary_max and $boundary_min must be positive
            }else{
                $error = -2;                                    // Error that might happen. All numbers between, $boundary_min and $boundary_max , are occupied, by $already_mem_array
            }                                   
    }else{
            if($digits_num < 0){                                // Error. If exist, $digits_num must be, 1,2,3 or higher
                $error = -3; 
            }elseif($digits_num == 1){                          // if 'one-figure' number
                $error = -4;                                    // Error that might happen. All 'one-figure' numbers    are occupied, by $already_mem_array
                $boundary_min = 0;
                $boundary_max = 9;
                $boundary_dim = $boundary_max-$boundary_min;
            }elseif($digits_num == 2){                          // if 'two-figure' number
                $error = -5;                                    // Error that might happen. All 'two-figure' numbers    are occupied, by $already_mem_array
                $boundary_min = 10;
                $boundary_max = 99;
                $boundary_dim = $boundary_max-$boundary_min;
            }elseif($digits_num>2){                             // if 'X-figure' number. X>2
                $error = -6;                                    // Error that might happen. All 'X-figure' numbers  are occupied, by $already_mem_array. Unlikely to happen
                $boundary_min = pow(10, $digits_num-1);         // stepenovanje - graduation
                $boundary_max = pow(10, $digits_num)-1;
                $boundary_dim = $boundary_max-$boundary_min;
            }

    }
    // -------------------------------------------------------------------


    // --- creating response ---------------------------------------------
    if( ($already_mem_array_dim <= $boundary_dim)   &&  $boundary_dim>0 ){              // go here only if, there are AVAILABLE numbers to extract, and [difference] $boundary_dim , is positive
        do{
            $num = rand($boundary_min,$boundary_max);
        }while( in_array($num, $already_mem_array) );
        $result = $num;
    }else{
        $result = $error;                                       // Limit that happened  
    }

    return $result;
    // -------------------------------------------------------------------

}

Diese Funktion funktioniert perfekt ohne Wiederholungen und mit der gewünschten Anzahl von Ziffern.

$digits = '';
function randomDigits($length){
    $numbers = range(0,9);
    shuffle($numbers);
    for($i = 0; $i < $length; $i++){
        global $digits;
        $digits .= $numbers[$i];
    }
    return $digits;
}

Sie können die Funktion aufrufen und die Anzahl der Ziffern übergeben, zum Beispiel:

randomDigits(4);

Probenergebnisse:

4957 8710 6730 6082 2987 2041 6721

Das ursprüngliche Drehbuch stammt aus diesem Kern

Bitte nicht, dass rand()dies keinen kryptografisch sicheren Wert gemäß den Dokumenten erzeugt:

http://php.net/manual/en/function.rand.php

Diese Funktion generiert keine kryptografisch sicheren Werte und sollte nicht für kryptografische Zwecke verwendet werden. Wenn Sie einen kryptografisch sicheren Wert benötigen, sollten Sie stattdessen random_int (), random_bytes () oder openssl_random_pseudo_bytes () verwenden.

Stattdessen ist es besser random_int(), PHP 7 zu verwenden (siehe: http://php.net/manual/en/function.random-int.php ).

Um die Antwort von @ Marcus zu erweitern, sollten Sie Folgendes verwenden:

function generateSecureRandomNumber($digits): int {
   return random_int(pow(10, $digits - 1), pow(10, $digits) - 1);
}

function generateSecureRandomNumberWithPadding($digits): string {
   $randomNumber = random_int(0, pow(10, $digits) - 1);
   return str_pad($randomNumber, $digits, '0', STR_PAD_LEFT);
}

Beachten Sie, dass die Verwendung rand()in Ordnung ist, wenn Sie keine sichere Zufallszahl benötigen.

Der folgende Code generiert eine 4-stellige Zufallszahl:

echo sprintf( "%04d", rand(0,9999));

Das Folgende ist eine einfache Methode zum Generieren eines bestimmten Längenüberprüfungscodes. Die Länge kann angegeben werden. Standardmäßig wird ein 4-stelliger Code generiert.

function get_sms_token($length = 4) {

    return rand(
        ((int) str_pad(1, $length, 0, STR_PAD_RIGHT)),
        ((int) str_pad(9, $length, 9, STR_PAD_RIGHT))
    );
}

echo get_sms_token(6);

Ihr Leute macht es wirklich gerne komplizierter :)

Das eigentliche Problem ist, dass das OP dies wahrscheinlich am Ende einer wirklich großen Zahl hinzufügen möchte. Wenn nicht, kann ich mir nicht vorstellen, dass dies erforderlich ist. als linke Nullen in einer beliebigen Zahl sind nur linke Nullen.

Fügen Sie also einfach den größeren Teil dieser Zahl als mathematische Summe und nicht als Zeichenfolge hinzu.

z.B

$x = "102384129" . complex_3_digit_random_string();

wird einfach

$x = 102384129000 + rand(0, 999);

getan.