Générer une chaîne aléatoire de 5 caractères

Je veux créer une chaîne exacte de 5 caractères aléatoires avec le moins de possibilité de duplication. Quelle serait la meilleure façon de procéder? Merci.

$rand = substr(md5(microtime()),rand(0,26),5);

Ce serait ma meilleure supposition - À moins que vous ne recherchiez également des caractères spéciaux:

$seed = str_split('abcdefghijklmnopqrstuvwxyz'
                 .'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                 .'0123456789!@#$%^&*()'); // and any other characters
shuffle($seed); // probably optional since array_is randomized; this may be redundant
$rand = '';
foreach (array_rand($seed, 5) as $k) $rand .= $seed[$k];

Exemple

Et, pour celui basé sur l'horloge (moins de collisions puisque c'est incrémental):

function incrementalHash($len = 5){
  $charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  $base = strlen($charset);
  $result = '';

  $now = explode(' ', microtime())[1];
  while ($now >= $base){
    $i = $now % $base;
    $result = $charset[$i] . $result;
    $now /= $base;
  }
  return substr($result, -5);
}

Remarque: incrémentiel signifie plus facile à deviner; Si vous l'utilisez comme un sel ou un jeton de vérification, ne le faites pas. Un sel (maintenant) de "WCWyb" signifie que dans 5 secondes c'est "WCWyg")

Si les forboucles sont rares, voici ce que j'aime utiliser:

$s = substr(str_shuffle(str_repeat("0123456789abcdefghijklmnopqrstuvwxyz", 5)), 0, 5);

Un moyen rapide consiste à utiliser les caractères les plus volatils de la fonction uniqid .

Par exemple:

$rand = substr(uniqid('', true), -5);

Vous pouvez l'essayer simplement comme ceci:

$length = 5;

$randomletter = substr(str_shuffle("abcdefghijklmnopqrstuvwxyz"), 0, $length);

plus de détails: http://forum.arnlweb.com/viewtopic.php?f=7&t=25

Ce qui suit devrait fournir le moins de chances de duplication (vous voudrez peut-être remplacer mt_rand()par une meilleure source de nombres aléatoires, par exemple à partir /dev/*randomou à partir de GUID):

<?php
    $characters = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    $result = '';
    for ($i = 0; $i < 5; $i++)
        $result .= $characters[mt_rand(0, 61)];
?>

EDIT:
Si vous êtes préoccupé par la sécurité, vraiment, ne pas utiliser rand()ou mt_rand(), et vérifiez que votre appareil de données aléatoires est en fait un dispositif de génération aléatoire de données, pas un fichier régulier ou quelque chose comme prévisible /dev/zero. mt_rand()considéré comme dangereux:
https://spideroak.com/blog/20121205114003-exploit-information-leaks-in-random-numbers-from-python-ruby-and-php

EDIT: Si vous avez le support OpenSSL en PHP, vous pouvez utiliser openssl_random_pseudo_bytes():

<?php
    $length = 5;
    $randomBytes = openssl_random_pseudo_bytes($length);
    $characters = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    $charactersLength = strlen($characters);
    $result = '';
    for ($i = 0; $i < $length; $i++)
        $result .= $characters[ord($randomBytes[$i]) % $charactersLength];
?>

J'utilise toujours la même fonction pour cela, généralement pour générer des mots de passe. C'est facile à utiliser et utile.

function randPass($length, $strength=8) {
    $vowels = 'aeuy';
    $consonants = 'bdghjmnpqrstvz';
    if ($strength >= 1) {
        $consonants .= 'BDGHJLMNPQRSTVWXZ';
    }
    if ($strength >= 2) {
        $vowels .= "AEUY";
    }
    if ($strength >= 4) {
        $consonants .= '23456789';
    }
    if ($strength >= 8) {
        $consonants .= '@#$%';
    }

    $password = '';
    $alt = time() % 2;
    for ($i = 0; $i < $length; $i++) {
        if ($alt == 1) {
            $password .= $consonants[(rand() % strlen($consonants))];
            $alt = 0;
        } else {
            $password .= $vowels[(rand() % strlen($vowels))];
            $alt = 1;
        }
    }
    return $password;
}

Il semble que str_shuffle serait une bonne utilisation pour cela. Amorcez le mélange avec les caractères de votre choix.

$my_rand_strng = substr(str_shuffle("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), -5);

$str = '';
$str_len = 8;
for($i = 0, $i < $str_len; $i++){
    //97 is ascii code for 'a' and 122 is ascii code for z
    $str .= chr(rand(97, 122));
}
return $str

Si c'est bien que vous n'obteniez que des lettres AF, alors voici ma solution:

str_pad(dechex(mt_rand(0, 0xFFFFF)), 5, '0', STR_PAD_LEFT);

Je pense que l'utilisation des fonctions de hachage est excessive pour une tâche aussi simple que la génération d'une séquence de chiffres hexadécimaux aléatoires. dechex+ mt_randfera le même travail, mais sans travail cryptographique inutile.str_padgarantit la longueur de 5 caractères de la chaîne de sortie (si le nombre aléatoire est inférieur à 0x10000).

La probabilité de duplication dépend de mt_randla fiabilité de. Mersenne Twister est connu pour son caractère aléatoire de haute qualité, il devrait donc bien s'adapter à la tâche.

Je ne savais pas non plus comment faire cela avant de penser à utiliser PHP array. Et je suis presque sûr que c'est le moyen le plus simple de générer une chaîne ou un nombre aléatoire avec des tableaux. Le code:

function randstr ($len=10, $abc="aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789") {
    $letters = str_split($abc);
    $str = "";
    for ($i=0; $i<=$len; $i++) {
        $str .= $letters[rand(0, count($letters)-1)];
    };
    return $str;
};

Vous pouvez utiliser cette fonction comme ceci

randstr(20)     // returns a random 20 letter string
                // Or like this
randstr(5, abc) // returns a random 5 letter string using the letters "abc"

Similaire à la réponse de Brad Christie , mais utilisant l' sha1alrorithme pour les caractères 0-9a-zA-Zet précédé d'une valeur aléatoire:

$str = substr(sha1(mt_rand() . microtime()), mt_rand(0,35), 5);

Mais si vous avez défini des caractères définis (autorisés):

$validChars = array('0','1','2' /*...*/,'?','-','_','a','b','c' /*...*/);
$validCharsCount = count($validChars);

$str = '';
for ($i=0; $i<5; $i++) {
    $str .= $validChars[rand(0,$validCharsCount - 1)];
}

** MISE À JOUR **

Comme l'a souligné Archimedix , cela ne garantira pas de renvoyer une "moindre possibilité de duplication" car le nombre de combinaisons est faible pour la plage de caractères donnée. Vous devrez soit augmenter le nombre de caractères, soit autoriser des caractères supplémentaires (spéciaux) dans la chaîne. La première solution serait préférable, je pense, dans votre cas.

fonctionne bien en PHP (php 5.4.4)

$seed = str_split('abcdefghijklmnopqrstuvwxyz');
$rand = array_rand($seed, 5);
$convert = array_map(function($n){
    global $seed;
    return $seed[$n];
},$rand);

$var = implode('',$convert);
echo $var;

Démo en direct

Source: Fonction PHP qui génère des caractères aléatoires

Cette fonction PHP simple a fonctionné pour moi:

function cvf_ps_generate_random_code($length=10) {

   $string = '';
   // You can define your own characters here.
   $characters = "23456789ABCDEFHJKLMNPRTVWXYZabcdefghijklmnopqrstuvwxyz";

   for ($p = 0; $p < $length; $p++) {
       $string .= $characters[mt_rand(0, strlen($characters)-1)];
   }

   return $string;

}

Usage:

echo cvf_ps_generate_random_code(5);

Voici mes random 5 cents...

$random=function($a, $b) {
    return(
        substr(str_shuffle(('\\`)/|@'.
        password_hash(mt_rand(0,999999),
        PASSWORD_DEFAULT).'!*^&~(')),
        $a, $b)
    );
};

echo($random(0,5));

La nouvelle fonction de PHP password_hash()(*> = PHP 5.5) fait le travail pour la génération d'un ensemble décemment long de caractères et de nombres majuscules et minuscules.

Deux concat. les chaînes avant et après password_hashdans la fonction $ random peuvent être modifiées.

Les paramètres pour $random()* ($ a, $ b) sont en fait des substr()paramètres. :)

REMARQUE: cela n'a pas besoin d'être une fonction, cela peut aussi être une variable normale ... comme un méchant singleliner, comme ceci:

$random=(substr(str_shuffle(('\\`)/|@'.password_hash(mt_rand(0,999999), PASSWORD_DEFAULT).'!*^&~(')), 0, 5));

echo($random);

function CaracteresAleatorios( $Tamanno, $Opciones) {
    $Opciones = empty($Opciones) ? array(0, 1, 2) : $Opciones;
    $Tamanno = empty($Tamanno) ? 16 : $Tamanno;
    $Caracteres=array("0123456789","abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ");
    $Caracteres= implode("",array_intersect_key($Caracteres, array_flip($Opciones)));
    $CantidadCaracteres=strlen($Caracteres)-1;
    $CaracteresAleatorios='';
    for ($k = 0; $k < $Tamanno; $k++) {
        $CaracteresAleatorios.=$Caracteres[rand(0, $CantidadCaracteres)];
    }
    return $CaracteresAleatorios;
}

J'utilise toujours ceci:

<?php function fRand($len) {
    $str = '';
    $a = "abcdefghijklmnopqrstuvwxyz0123456789";
    $b = str_split($a);
    for ($i=1; $i <= $len ; $i++) { 
        $str .= $b[rand(0,strlen($a)-1)];
    }
    return $str;
} ?>

Lorsque vous l'appelez, définit la longueur de la chaîne.

<?php echo fRand([LENGHT]); ?>

Vous pouvez également modifier les caractères possibles dans la chaîne $a.