Génération de chaînes alphanumériques (pseudo) aléatoires

Comment puis-je générer une chaîne alphanumérique (pseudo) aléatoire, quelque chose comme: 'd79jd8c' en PHP?

Créez d'abord une chaîne avec tous vos caractères possibles:

 $characters = 'abcdefghijklmnopqrstuvwxyz0123456789';

Vous pouvez également utiliser range () pour le faire plus rapidement.

Ensuite, dans une boucle, choisissez un nombre aléatoire et utilisez-le comme index de la $characterschaîne pour obtenir un caractère aléatoire, et ajoutez-le à votre chaîne:

 $string = '';
 $max = strlen($characters) - 1;
 for ($i = 0; $i < $random_string_length; $i++) {
      $string .= $characters[mt_rand(0, $max)];
 }

$random_string_length est la longueur de la chaîne aléatoire.

J'aime cette fonction pour le travail

function randomKey($length) {
    $pool = array_merge(range(0,9), range('a', 'z'),range('A', 'Z'));

    for($i=0; $i < $length; $i++) {
        $key .= $pool[mt_rand(0, count($pool) - 1)];
    }
    return $key;
}

echo randomKey(20);

Générez une chaîne de 8 caractères aléatoire (potentiellement) forte d'un point de vue cryptographique à l'aide de la fonction openssl_random_pseudo_bytes :

echo bin2hex(openssl_random_pseudo_bytes(4));

Voie procédurale:

function randomString(int $length): string
{
    return bin2hex(openssl_random_pseudo_bytes($length));
}

Mise à jour:

PHP7 a introduit les random_x()fonctions qui devraient être encore meilleures. Si vous venez de PHP 5.X, utilisez l'excellente bibliothèque paragonie / random_compat qui est un polyfill pour random_bytes () et random_int () de PHP 7.

function randomString($length)
{
    return bin2hex(random_bytes($length));
}

Solution une ligne:

echo substr( str_shuffle( str_repeat( 'abcdefghijklmnopqrstuvwxyz0123456789', 10 ) ), 0, 7 );

Vous pouvez modifier le paramètre substr afin de définir une longueur différente pour votre chaîne.

Utilisez la table ASCII pour sélectionner une plage de lettres, où: $ range_start, $ range_end est une valeur de la colonne décimale dans la table ASCII.

Je trouve que cette méthode est plus agréable par rapport à la méthode décrite où la plage de caractères est spécifiquement définie dans une autre chaîne.

// range is numbers (48) through capital and lower case letters (122)
$range_start = 48;
$range_end   = 122;
$random_string = "";
$random_string_length = 10;

for ($i = 0; $i < $random_string_length; $i++) {
  $ascii_no = round( mt_rand( $range_start , $range_end ) ); // generates a number within the range
  // finds the character represented by $ascii_no and adds it to the random string
  // study **chr** function for a better understanding
  $random_string .= chr( $ascii_no );
}

echo $random_string;

En savoir plus:

• chrfonction
• fonction mt_rand

Je sais que c'est un ancien article, mais j'aimerais contribuer avec une classe que j'ai créée sur la base de la réponse de Jeremy Ruten et améliorée avec des suggestions dans les commentaires:

    class RandomString
    {
      private static $characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
      private static $string;
      private static $length = 8; //default random string length

      public static function generate($length = null)
      {

        if($length){
          self::$length = $length;
        }

        $characters_length = strlen(self::$characters) - 1;

        for ($i = 0; $i < self::$length; $i++) {
          self::$string .= self::$characters[mt_rand(0, $characters_length)];
        }

        return self::$string;

      }

    }

Les gars simples ... mais rappelez-vous que chaque octet est aléatoire entre 0 et 255 ce qui pour une chaîne aléatoire sera très bien. N'oubliez pas que vous aurez deux caractères pour représenter chaque octet.

$str = bin2hex(random_bytes(32));  // 64 character string returned

J'ai peut-être manqué quelque chose ici, mais voici un moyen d'utiliser la fonction uniqid () .

J'ai créé la fonction rapide suivante juste pour jouer avec la range()fonction. Cela pourrait simplement aider quelqu'un à un moment donné.

Function pseudostring($length = 50) {

    // Generate arrays with characters and numbers
    $lowerAlpha = range('a', 'z');
    $upperAlpha = range('A', 'Z');
    $numeric = range('0', '9');

    // Merge the arrays
    $workArray = array_merge($numeric, array_merge($lowerAlpha, $upperAlpha));
    $returnString = "";

    // Add random characters from the created array to a string
    for ($i = 0; $i < $length; $i++) {
        $character = $workArray[rand(0, 61)];
        $returnString .= $character;
    }

    return $returnString;
}

Vous pouvez utiliser le code suivant. Il est similaire aux fonctions existantes sauf que vous pouvez forcer le décompte de caractères spéciaux:

function random_string() {
    // 8 characters: 7 lower-case alphabets and 1 digit
    $character_sets = [
        ["count" => 7, "characters" => "abcdefghijklmnopqrstuvwxyz"],
        ["count" => 1, "characters" => "0123456789"]
    ];
    $temp_array = array();
    foreach ($character_sets as $character_set) {
        for ($i = 0; $i < $character_set["count"]; $i++) {
            $random = random_int(0, strlen($character_set["characters"]) - 1);
            $temp_array[] = $character_set["characters"][$random];
        }
    }
    shuffle($temp_array);
    return implode("", $temp_array);
}

function generateRandomString($length = 10) {
    $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
    $charactersLength = strlen($characters);
    $randomString = '';
    for ($i = 0; $i < $length; $i++) {
        $randomString .= $characters[rand(0, $charactersLength - 1)];
    }
    return $randomString;
}
echo generateRandomString();

Si vous voulez un moyen très simple de le faire, vous pouvez vous appuyer sur les fonctions PHP existantes. Voici le code que j'utilise:

substr( sha1( time() ), 0, 15 )

time()vous donne l'heure actuelle en secondes depuis l'époque, la sha1()chiffre en une chaîne de 0-9a-f et substr()vous permet de choisir une longueur. Vous n'êtes pas obligé de commencer au caractère 0, et quelle que soit la différence entre les deux nombres, la longueur de la chaîne sera la longueur de la chaîne.

C'est quelque chose que j'utilise:

$cryptoStrong = true; // can be false
$length = 16; // Any length you want
$bytes = openssl_random_pseudo_bytes($length, $cryptoStrong);
$randomString = bin2hex($bytes);

Vous pouvez voir les documents pour openssl_random_pseudo_bytes ici , et les documents pour bin2hex ici

La réponse de Jeremy est excellente. Si, comme moi, vous ne savez pas comment implémenter range (), vous pouvez voir ma version en utilisant range ().

<?php
$character_array = array_merge(range('a', 'z'), range(0, 9));
$string = "";
    for($i = 0; $i < 6; $i++) {
        $string .= $character_array[rand(0, (count($character_array) - 1))];
    }
echo $string;
?>

Cela fait exactement la même chose que Jeremy, mais utilise des tableaux fusionnés où il utilise une chaîne et utilise count () où il utilise strlen ().

1 ligne:

$FROM = 0; $TO = 'zzzz';
$code = base_convert(rand( $FROM ,base_convert( $TO , 36,10)),10,36);
echo $code;

La façon moderne de le faire avec le type hint / rand_int pour de vraies aléas

function random_string(int $size): string
{
    $characters = array_merge(
        range(0, 9),
        range('A', 'Z')
    );

    $string = '';
    $max = count($characters) - 1;
    for ($i = 0; $i < $size; $i++) {
        $string .= $characters[random_int(0, $max)];
    }

    return $string;
}

Commencez par lister les caractères souhaités

$chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

Utilisez la fonction str_shuffle ($ string). Cette fonction vous fournira une chaîne aléatoire.

$alpha=substr(str_shuffle($chars), 0, 50);

50 est la longueur de la chaîne.

public function randomString($length = 8)
{
    $characters = implode([
        'ABCDEFGHIJKLMNOPORRQSTUWVXYZ',
        'abcdefghijklmnoprqstuwvxyz',
        '0123456789',
        //'!@#$%^&*?'
    ]);

    $charactersLength = strlen($characters) - 1;
    $string           = '';

    while ($length) {
        $string .= $characters[mt_rand(0, $charactersLength)];
        --$length;
    }

    return $string;
}