webentwicklung-frage-antwort-db.com.de

php zufällige x-stellige Nummer

Ich muss eine Zufallszahl mit x Ziffernanzahl erstellen.

Also sagen wir mal x ist 5, ich brauche eine Zahl um zB zu sein. 35562 Wenn x 3 ist, würde es etwas wie werfen; 463

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

51
user1022585

Sie können Rand() zusammen mit pow() verwenden, um dies zu ermöglichen:

$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 und dann mit eins subtrahiert werden müssen, um den gewünschten Bereich zu erreichen.

Wenn 005 ebenfalls ein gültiges Beispiel ist, würden Sie den folgenden Code verwenden, um führende Nullen einzugeben:

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

Normalerweise benutze ich nur Rand()http://php.net/manual/de/function.Rand.php

z.B. 

Rand ( 10000 , 99999 );

für Ihre 5-stellige Zufallszahl 

20
Code Magician

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

Um die Werte auf Werte mit x Stellen zu begrenzen, können Sie Folgendes verwenden:

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

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

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

wobei $x die Anzahl der Stellen sein kann

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

Ergebnisse nach einigen Hinrichtungen

98450
79324
23017
04317
26479

Sie können den gleichen Code auch verwenden, um eine zufällige Zeichenfolge zu generieren

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

Ergebnisse mit $x = 11

FgHmqpTR3Ox
O9BsNgcPJDb
1v8Aw5b6H7f
haH40dmAxZf
0EpvHL5lTKr
10
Akshay Khale

Behandeln Sie Ihre Nummer als Liste mit Ziffern und hängen Sie jedes Mal eine zufällige Ziffer an:

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);
}
8
Blender
function random_numbers($digits) {
    $min = pow(10, $digits - 1);
    $max = pow(10, $digits) - 1;
    return mt_Rand($min, $max);
}

Getestet hier .

7
animuson

der einfachste Weg, den ich mir vorstellen kann, ist, Rand function mit str_pad

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

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

Und 5 Ziffern.

5
AMB

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

5
Alex

mach es mit einer Schleife:

function randomWithLength($length){

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

    return (int)$number;

}
3
Rene Pot

Rand oder mt_Rand reicht aus ...

verwendungszweck:

Rand(min, max);

mt_Rand(min, max);
3
easyb
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;  
}
1
philip mudenyo

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

mt_Rand(2000,9000) 
1
Anoop P S
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;
    // -------------------------------------------------------------------

}
0
Srx

Dies ist eine weitere einfache Lösung zum Generieren einer zufälligen Anzahl von N Ziffern:

$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

0
MRodrigues

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

lesen Sie mehr

beispiel: <?php echo mt_Rand(); ?>

0
Himanshu Singh

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

Diese Funktion funktioniert einwandfrei ohne Wiederholungen und 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 beispielsweise die Anzahl der Ziffern übergeben: 

randomDigits(4);

beispielergebnisse:

4957 8710 6730 6082 2987 2041 6721

Ursprüngliches Skript von dieser Gist

0
Reegan Ochora

Bitte beachten Sie nicht, dass Rand() keinen kryptografisch sicheren Wert gemäß den Dokumenten generiert:

http://php.net/manual/de/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.

Verwenden Sie stattdessen random_int(), das auf PHP 7 verfügbar ist (siehe: http://php.net/manual/de/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 von Rand() in Ordnung ist, wenn Sie keine sichere Zufallszahl benötigen.

0
Yahya Uddin