php nombre aléatoire de x chiffres

Vous pouvez utiliser rand($min, $max) dans ce but précis.

afin de limiter les valeurs aux valeurs avec X chiffres, vous pouvez utiliser ce qui suit:

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

j'utilise habituellement RAND()http://php.net/manual/en/function.rand.php

par exemple

rand ( 10000 , 99999 );

pour votre nombre aléatoire de 5 chiffres

traitez votre numéro comme une liste de chiffres et ajoutez juste un chiffre aléatoire à chaque fois:

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

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

  return (int)$temp;
}

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

Voici une solution simple sans boucles ni tracas vous permettent de créer aléatoire chaîne de caractères, de chiffres ou même avec des symboles spéciaux.

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

où $x peut être le nombre de chiffres

par exemple. substr(str_shuffle("0123456789"), 0, 5);

Résultats après quelques exécutions

98450
79324
23017
04317
26479

vous pouvez utiliser le même code pour générer des chaînes aléatoires aussi, comme ceci

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

Résultats $x = 11

FgHmqpTR3Ox
O9BsNgcPJDb
1v8Aw5b6H7f
haH40dmAxZf
0EpvHL5lTKr

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

testé ici.

le moyen le plus simple je pense est de l'aide rand function str_pad

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

dans l'exemple ci-dessus , il générera un nombre aléatoire dans la gamme 0 à 999.

et ayant 5 chiffres.

rand(1000, 9999); fonctionne plus vite que x4 fois rand(0,9);

indice:

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

les deux fonctions fonctionnaient en 100000 itérations pour rendre les résultats plus explicites

le faire avec une boucle:

function randomWithLength($length){

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

    return (int)$number;

}

rand ou mt_rand va faire...

utilisation:

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

ce script simple fera

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

c'est une autre solution simple pour générer un nombre aléatoire de n chiffres:

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

Vérifier ici: 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;
    // -------------------------------------------------------------------

}

cette fonction fonctionne parfaitement avec aucune répétition et le nombre désiré de chiffres.

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

Vous pouvez appeler la fonction et passer le nombre de chiffres par exemple:

randomDigits(4);

4957 8710 6730 6082 2987 2041 6721

scénario Original, obtenu à partir de ce gist

s'il vous Plaît pas que rand() ne génère pas de valeur cryptographique sécurisée selon le docs:

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

cette fonction ne génère pas de valeurs cryptographiques sûres et ne devrait pas être utilisée à des fins cryptographiques. Si vous avez besoin d'une valeur cryptographique sécurisée, pensez à utiliser random_int(), random_bytes(), ou openssl_random_pseudo_bytes() à la place.

au Lieu il est préférable d'utiliser random_int(), disponible sur PHP 7 (Voir:http://php.net/manual/en/function.random-int.php).

donc pour étendre la réponse de @Marcus, vous devez utiliser:

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

notez qu'en utilisant rand() est très bien si vous n'avez pas besoin d'une sécurité de nombre aléatoire.

les gens vous aime vraiment compliquer les choses :)

le vrai problème est que L'OP veut, probablement, ajouter cela à la fin d'un nombre vraiment grand. si non, il n'est pas nécessaire que je pense que ce sera nécessaire. comme les zéros de gauche dans n'importe quel nombre est juste, bien, zéros de gauche.

donc, il suffit d'ajouter la plus grande partie de ce numéro de maths somme, pas de chaîne.

par exemple

$x = "102384129" . complex_3_digit_random_string();

simplement devient

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

terminé.