PHP générateur de chaîne aléatoire
J'essaie de créer une chaîne aléatoire en PHP, et je n'ai absolument aucune sortie avec ceci:
<?php
function RandomString()
{
$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
$randstring = '';
for ($i = 0; $i < 10; $i++) {
$randstring = $characters[Rand(0, strlen($characters))];
}
return $randstring;
}
RandomString();
echo $randstring;
Qu'est-ce que je fais mal?
Pour répondre spécifiquement à cette question, deux problèmes:
$randstringn'est pas dans la portée lorsque vous y faites écho.- Les caractères ne sont pas concaténés dans la boucle.
Voici un extrait de code avec les corrections:
function generateRandomString($length = 10) {
$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
$charactersLength = strlen($characters);
$randomString = '';
for ($i = 0; $i < $length; $i++) {
$randomString .= $characters[Rand(0, $charactersLength - 1)];
}
return $randomString;
}
Produisez la chaîne aléatoire avec l'appel ci-dessous:
// Echo the random string.
// Optionally, you can give it a desired string length.
echo generateRandomString();
Veuillez noter que cela génère des chaînes aléatoires prévisibles. Si vous voulez créer des jetons sécurisés, voir cette réponse .
Remarque:
str_shuffle()utilise en interneRand(), ce qui ne convient pas à des fins de cryptographie (par exemple, la génération de mots de passe aléatoires). Vous voulez un générateur de nombre aléatoire sécurisé à la place. De plus, il ne permet pas aux personnages de se répéter.
Une autre façon.
MIS &AGRAVE; JOUR _ (maintenant cela génère n'importe quelle longueur de chaîne):
function generateRandomString($length = 10) {
return substr(str_shuffle(str_repeat($x='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', ceil($length/strlen($x)) )),1,$length);
}
echo generateRandomString(); // OR: generateRandomString(24)
C'est tout. :)
Il existe de nombreuses réponses à cette question, mais aucune d’entre elles n’utilise un générateur de nombres pseudo-aléatoires cryptographiquement sûr } _ (CSPRNG).
La réponse simple, sécurisée et correcte consiste à utiliser RandomLib et à ne pas réinventer la roue.
Pour ceux d'entre vous qui insistent pour inventer votre propre solution, PHP 7.0.0 fournira random_int() à cette fin; si vous êtes toujours sur PHP 5.x, nous avons écrit un PHP 5 polyfill pour random_int() afin que vous puissiez utiliser la nouvelle API même avant la mise à niveau vers PHP. 7.
Générer en toute sécurité des entiers aléatoires dans PHP n'est pas une tâche triviale. Vous devez toujours vérifier auprès de vos experts en cryptographie StackExchange résidents } _ avant de déployer un algorithme développé en interne.
Avec un générateur d’entiers sécurisé en place, générer une chaîne aléatoire avec un CSPRNG est une promenade dans le parc.
Création d'une chaîne sécurisée et aléatoire
/**
* Generate a random string, using a cryptographically secure
* pseudorandom number generator (random_int)
*
* For PHP 7, random_int is a PHP core function
* For PHP 5.x, depends on https://github.com/paragonie/random_compat
*
* @param int $length How many characters do we want?
* @param string $keyspace A string of all possible characters
* to select from
* @return string
*/
function random_str($length, $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
{
$pieces = [];
$max = mb_strlen($keyspace, '8bit') - 1;
for ($i = 0; $i < $length; ++$i) {
$pieces []= $keyspace[random_int(0, $max)];
}
return implode('', $pieces);
}
Usage:
$a = random_str(32);
$b = random_str(8, 'abcdefghijklmnopqrstuvwxyz');
Démo: https://3v4l.org/b4PST (ignore les PHP 5 échecs; il a besoin de random_compat)
Crée une chaîne hexdec longue de 20 caractères:
$string = bin2hex(openssl_random_pseudo_bytes(10)); // 20 chars
Dans PHP 7 ( random_bytes () ):
$string = base64_encode(random_bytes(10)); // ~14 chars, includes /=+
// or
$string = substr(str_replace(['+', '/', '='], '', base64_encode(random_bytes(32))), 0, 32); // 32 chars, without /=+
// or
$string = bin2hex(random_bytes(10)); // 20 chars, only 0-9a-f
@tasmaniski: votre réponse a fonctionné pour moi. J'ai eu le même problème et je le suggérerais à ceux qui cherchent toujours la même réponse La voici de @tasmaniski:
<?php
$random = substr(md5(mt_Rand()), 0, 7);
echo $random;
?>
En fonction de votre application (je voulais générer des mots de passe), vous pourriez utiliser
$string = base64_encode(openssl_random_pseudo_bytes(30));
Étant en base64, ils peuvent contenir = ou - ainsi que les caractères demandés. Vous pouvez générer une chaîne plus longue, puis filtrer et couper pour les supprimer.
openssl_random_pseudo_bytes semble être le moyen recommandé pour générer un nombre aléatoire correct en php. Pourquoi Rand n'utilise pas /dev/random Je ne sais pas.
Je sais que cela peut être un peu tard pour le jeu, mais voici une simple ligne qui génère une véritable chaîne aléatoire sans aucune boucle au niveau script ni utilisation de bibliothèques openssl.
echo substr(str_shuffle(str_repeat('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', mt_Rand(1,10))),1,10);
Pour le décomposer afin que les paramètres soient clairs
// Character List to Pick from
$chrList = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
// Minimum/Maximum times to repeat character List to seed from
$chrRepeatMin = 1; // Minimum times to repeat the seed string
$chrRepeatMax = 10; // Maximum times to repeat the seed string
// Length of Random String returned
$chrRandomLength = 10;
// The ONE LINE random command with the above variables.
echo substr(str_shuffle(str_repeat($chrList, mt_Rand($chrRepeatMin,$chrRepeatMax))),1,$chrRandomLength);
Cette méthode fonctionne en répétant de manière aléatoire la liste de caractères, puis en mélangeant la chaîne combinée et en renvoyant le nombre de caractères spécifié.
Vous pouvez continuer à randomiser ceci en randomisant la longueur de la chaîne renvoyée en remplaçant $chrRandomLength par mt_Rand(8, 15) (pour une chaîne aléatoire comprenant entre 8 et 15 caractères).
Un meilleur moyen d'implémenter cette fonction est:
function RandomString($length) {
$keys = array_merge(range(0,9), range('a', 'z'));
$key = "";
for($i=0; $i < $length; $i++) {
$key .= $keys[mt_Rand(0, count($keys) - 1)];
}
return $key;
}
echo RandomString(20);
mt_Rand est plus aléatoire selon ceci et ceci en php7. La fonction Rand est un alias de mt_Rand.
function generateRandomString($length = 15)
{
return substr(sha1(Rand()), 0, $length);
}
Tada!
$randstring dans l'étendue de la fonction n'est pas identique à l'étendue où vous l'appelez. Vous devez affecter la valeur de retour à une variable.
$randstring = RandomString();
echo $randstring;
Ou simplement renvoyer directement la valeur de retour:
echo RandomString();
En outre, dans votre fonction, vous avez une petite erreur. Dans la boucle for, vous devez utiliser .= pour que chaque caractère soit ajouté à la chaîne. En utilisant =, vous écrasez-le avec chaque nouveau caractère au lieu de l'ajouter.
$randstring .= $characters[Rand(0, strlen($characters))];
Tout d’abord, vous définissez l’alphabet que vous souhaitez utiliser:
$alphanum = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$special = '~!@#$%^&*(){}[],./?';
$alphabet = $alphanum . $special;
Ensuite, utilisez openssl_random_pseudo_bytes() pour générer les données aléatoires appropriées:
$len = 12; // length of password
$random = openssl_random_pseudo_bytes($len);
Enfin, vous utilisez ces données aléatoires pour créer le mot de passe. Étant donné que chaque caractère dans $random peut être chr(0) jusqu'à chr(255), le code utilise le reste après la division de sa valeur ordinale avec $alphabet_length pour s'assurer que seuls les caractères de l'alphabet sont sélectionnés (notez que cela biaise l'aléa)
$alphabet_length = strlen($alphabet);
$password = '';
for ($i = 0; $i < $len; ++$i) {
$password .= $alphabet[ord($random[$i]) % $alphabet_length];
}
Alternativement, et généralement mieux, utilisez RandomLib et SecurityLib :
use SecurityLib\Strength;
$factory = new RandomLib\Factory;
$generator = $factory->getGenerator(new Strength(Strength::MEDIUM));
$password = $generator->generateString(12, $alphabet);
J'ai testé les performances des fonctions les plus populaires, le temps nécessaire pour générer 1'000'000 chaînes de 32 symboles sur ma boîte est:
2.5 $s = substr(str_shuffle(str_repeat($x='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', ceil($length/strlen($x)) )),1,32);
1.9 $s = base64_encode(openssl_random_pseudo_bytes(24));
1.68 $s = bin2hex(openssl_random_pseudo_bytes(16));
0.63 $s = base64_encode(random_bytes(24));
0.62 $s = bin2hex(random_bytes(16));
0.37 $s = substr(md5(Rand()), 0, 32);
0.37 $s = substr(md5(mt_Rand()), 0, 32);
Veuillez noter qu'il n'est pas important de savoir combien de temps cela a pris, mais ce qui est le plus lent et lequel est le plus rapide, vous pouvez donc le sélectionner en fonction de vos besoins, y compris l'état de préparation cryptographique, etc.
pour améliorer la précision, substr () autour de MD5 a été ajouté si vous avez besoin d'une chaîne de moins de 32 symboles.
Par souci de réponse: la chaîne n'a pas été concaténée mais écrasée et le résultat de la fonction n'a pas été enregistré.
Méthodes courtes ..
Voici une méthode la plus courte pour générer la chaîne aléatoire
<?php
echo $my_Rand_strng = substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), -15);
echo substr(md5(Rand()), 0, 7);
echo str_shuffle(MD5(microtime()));
?>
function rndStr($len = 64) {
$randomData = file_get_contents('/dev/urandom', false, null, 0, $len) . uniqid(mt_Rand(), true);
$str = substr(str_replace(array('/','=','+'),'', base64_encode($randomData)),0,$len);
return $str;
}
Celui-ci provient de sources de l'administrateur :
/** Get a random string
* @return string 32 hexadecimal characters
*/
function Rand_string() {
return md5(uniqid(mt_Rand(), true));
}
Adminer , outil de gestion de base de données écrit en PHP.
Fonction d'assistance du framework Laravel 5
/**
* Generate a "random" alpha-numeric string.
*
* Should not be considered sufficient for cryptography, etc.
*
* @param int $length
* @return string
*/
function str_random($length = 16)
{
$pool = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
return substr(str_shuffle(str_repeat($pool, $length)), 0, $length);
}
Un moyen très rapide est de faire quelque chose comme:
substr(md5(Rand()),0,10);
Cela générera une chaîne aléatoire de 10 caractères. Bien sûr, certains pourraient dire que le calcul est un peu plus lourd, mais de nos jours les processeurs sont optimisés pour exécuter très rapidement l'algorithme md5 ou sha256. Et bien sûr, si la fonction Rand() renvoie la même valeur, le résultat sera le même, avec une chance sur 1/32767 d'être identique. Si la sécurité est le problème, changez simplement Rand() en mt_Rand()
/**
* @param int $length
* @param string $abc
* @return string
*/
function generateRandomString($length = 10, $abc = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
{
return substr(str_shuffle($abc), 0, $length);
}
Source de http://www.xeweb.net/2011/02/11/generate-a-random-string-a-z-0-9-in-php/
une ligne.
rapide pour les énormes chaînes avec une certaine unicité.
function random_string($length){
return substr(str_repeat(md5(Rand()), ceil($length/32)), 0, $length);
}
La version modifiée de la fonction fonctionne bien, mais j’ai trouvé un problème: vous avez utilisé le caractère incorrect pour insérer des caractères $. Le caractère ’fait donc parfois partie de la chaîne aléatoire générée.
Pour résoudre ce problème, changez:
$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;
à:
$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
De cette façon, seuls les caractères inclus sont utilisés et le caractère ’ne fera jamais partie de la chaîne aléatoire générée.
Une autre ligne, qui génère une chaîne aléatoire de 10 caractères avec des lettres et des chiffres. Il créera un tableau avec range (ajustez le deuxième paramètre pour définir la taille), boucle sur ce tableau et attribue un caractère ascii-char aléatoire (plage de 0 à 9 ou a-z), puis implose le tableau pour obtenir une chaîne.
$str = implode('', array_map(function () { return chr(Rand(0, 1) ? Rand(48, 57) : Rand(97, 122)); }, range(0, 9)));
Note: ne fonctionne que dans PHP 5.3+
J'ai aimé le dernier commentaire qui utilisait openssl_random_pseudo_bytes, mais ce n'était pas une solution pour moi car je devais toujours supprimer les caractères que je ne voulais pas, et je ne pouvais pas obtenir une chaîne de longueur définie. Voici ma solution ...
function rndStr($len = 20) {
$rnd='';
for($i=0;$i<$len;$i++) {
do {
$byte = openssl_random_pseudo_bytes(1);
$asc = chr(base_convert(substr(bin2hex($byte),0,2),16,10));
} while(!ctype_alnum($asc));
$rnd .= $asc;
}
return $rnd;
}
function randomString($length = 5) {
return substr(str_shuffle(implode(array_merge(range('A','Z'), range('a','z'), range(0,9)))), 0, $length);
}
Une autre façon de générer une chaîne aléatoire dans PHP est la suivante:
function RandomString($length) {
$original_string = array_merge(range(0,9), range('a','z'), range('A', 'Z'));
$original_string = implode("", $original_string);
return substr(str_shuffle($original_string), 0, $length);
}
echo RandomString(6);
Il y a un code simple:
echo implode("",array_map(create_function('$s','return substr($s,mt_Rand(0,strlen($s)),1);'),array_fill(0,16,"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")));
Il y a un guide simple:
- Pour changer la longueur de de la chaîne , veuillez changer le
16en une autre valeur uniquement. - Pour sélectionner différents caractères, veuillez modifier la chaîne de caractères.
il y a de meilleures alternatives à cela, beaucoup ont déjà été postées donc je ne vous redonne que vos affaires
<?php
function RandomString()
{
global $randstring ;
$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
$randstring = '';
for ($i = 0; $i < 10; $i++) {
$randstring .= $characters[Rand(0, strlen($characters))];
}
return $randstring;
}
RandomString();
echo $randstring;
?>
aussi vous pouvez être intéressé par:
<?php
function RandomString()
{
global $randstring ;
$characters = str_split('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
array_filter ($characters,function($var)use($characters,&$randstring){
$randstring .= $characters[Rand(0, count($characters)-1)];
});
return $randstring;
}
RandomString();echo $randstring.'<hr>';
//.. OR ..
$randstring='';echo(RandomString());
?>
ou un autre:
<?php
function s($length){
for($i=0;($i<$length)and(($what=Rand(1,3))and( (($what==1)and($t=Rand(48,57) ))or (($what==2)and ($t=Rand(65,90))) or (($what==3)and ($t=Rand(97,122))) ) and (print chr($t)));$i++);
}
s(10);
?>
<?php
/**
* Creates a random string
*
* @param (int) $length
* Length in characters
* @param (array) $ranges
* (optional) Array of ranges to be used
*
* @return
* Random string
*/
function random_string($length, $ranges = array('0-9', 'a-z', 'A-Z')) {
foreach ($ranges as $r) $s .= implode(range(array_shift($r = explode('-', $r)), $r[1]));
while (strlen($s) < $length) $s .= $s;
return substr(str_shuffle($s), 0, $length);
}
// Examples:
$l = 100;
echo '<b>Default:</b> ' . random_string($l) . '<br />';
echo '<b>Lower Case only:</b> ' . random_string($l, array('a-z')) . '<br />';
echo '<b>HEX only:</b> ' . random_string($l, array('0-9', 'A-F')) . '<br />';
echo '<b>BIN only:</b> ' . random_string($l, array('0-1')) . '<br />';
/* End of file */
Paramétré avec une seule ligne utilisant seulement PHP fonctions natives , fonctionnant depuis PHP 5.1.0
str_shuffle(implode('', (array_intersect_key(($map = array_map('chr', array_merge(array_map('mt_Rand', array_fill(0, $length = 25, 48), array_fill(0,$length,57)),array_map('mt_Rand', array_fill(0, $length, 65), array_fill(0,$length,90)),array_map('mt_Rand', array_fill(0, $length, 97), array_fill(0,$length,122))))), array_flip($keys = array_Rand($map, $length))))))
Je sais que c’est une vieille question avec de multiples réponses mais je peux essayer d’envoyer ma solution ... utilisez cette fonction pour générer une chaîne alphanumérique aléatoire personnalisée ...
<?php
function random_alphanumeric($length) {
$chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345689';
$my_string = '';
for ($i = 0; $i < $length; $i++) {
$pos = mt_Rand(0, strlen($chars) -1);
$my_string .= substr($chars, $pos, 1);
}
return $my_string;
}
$test = random_alphanumeric(50); // 50 characters
echo $test;
?>
Exemple (test): Y1FypdjVbFCFK6Gh9FDJpe6dciwJEfV6MQGpJqAfuijaYSZ86
si vous avez besoin de deux chaînes uniques ou plus, vous pouvez le faire ...
$string_1 = random_alphanumeric(50);
$string_2 = random_alphanumeric(50);
while ($string_1 == $string_2) {
$string_1 = random_alphanumeric(50);
$string_2 = random_alphanumeric(50);
if ($string_1 != $string_2) {
break;
}
}
echo $string_1;
echo "<br>\n";
echo $string_2;
$ string_1: KkvUwia8rbDEV2aChWqm3AgeUZqyrRbUx2AxVhx5s4TSJ2VwA4
$ string_2: XraO85YfxBBCInafvwipSOJwLmk6JMWiuWOxYQDnXohcn2D8K6
J'espère que cette aide.
Source: PHP Fonction générant des caractères aléatoires
Cette fonction PHP 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);
Une classe avec certaines des fonctions des discussions ci-dessus.
$options['numeric'] = true;
$options['uppercase'] = true;
$options['lowercase'] = true;
$new = new RandomString($options);
class RandomString
{
/**
* @var array
*/
private $default = ['numeric' => true, 'uppercase' => true, 'lowercase' => true];
/**
* @var array
*/
private $options;
/**
* array
*/
private $whitelist = ['numeric', 'uppercase', 'lowercase'];
/**
* RandomString constructor.
*
* @param array $options
*/
public function __construct(array $options = [])
{
$this->options = $this->default;
if(!empty($options))
{
$options = array_intersect_key($options, array_flip($this->whitelist));
if(empty($options))
{
$this->options = $this->default;
}else
{
$this->options = $options;
}
}
}
/**
* @return string
*/
private function returnCharacters(){
$options = $this->options;
$numbers = '0123456789';
$uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
$lowercase = "abcdefghijklmnopqrstuvwxyz";
$characters = '';
if(isset($options['numeric']) && $options['numeric'] === true){
$characters .= $numbers;
}
if(isset($options['uppercase']) && $options['uppercase'] === true){
$characters .= $uppercase;
}
if(isset($options['lowercase']) && $options['lowercase'] === true){
$characters .= $lowercase;
}
return $characters;
}
/**
* @param $length
* @param $quantity
* @return string
*/
public function randomString($length, $quantity) {
$string = '';
$characters = $this->returnCharacters();
for ($j = 0; $j < $quantity; $j++) {
for($i = 0; $i < $length; $i++){
$string .= $characters[mt_Rand(0, strlen($characters) - 1)];
}
$string .= "\n";
}
return $string;
}
/**
* @return array
*/
public function getOptions()
{
return $this->options;
}
/**
* @return mixed
*/
public function getWhitelist()
{
return $this->whitelist;
}
enfin, j'ai trouvé une solution pour obtenir une valeur aléatoire et unique .__ ma solution est
substr(md5(time()), 0, 12)
time retournent toujours timstamp et il est toujours unique. vous pouvez l'utiliser avec md5 pour l'améliorer.
La fonction suivante génère une pseudo chaîne de any length.
/**
* Returns random string of a given length.
*/
function get_random_string($length) {
$pull = [];
while (count($pull) < $length) {
$pull = array_merge($pull, range(0, 9), range('a', 'z'), range('A', 'Z'));
}
shuffle($pull);
return substr(implode($pull), 0, $length);
}
function getRandomString($length) {
$salt = array_merge(range('a', 'z'), range(0, 9));
$maxIndex = count($salt) - 1;
$result = '';
for ($i = 0; $i < $length; $i++) {
$index = mt_Rand(0, $maxIndex);
$result .= $salt[$index];
}
return $result
}
Vous le faites totalement mal parce que vous dépendez de chiffres et non de caractères et je ne suis pas sûr que vous vouliez que la sortie aléatoire soit uniquement des chiffres. Si c'est le cas, pourquoi faut-il obtenir toutes les lettres alphabétiques et tous les chiffres et en extraire la longueur? pourquoi ne pas simplement utiliser Rand(0, 62) ?, même si vous avez oublié d’initialiser votre variable $randstring avant de déclarer la fonction.
quoiqu'il en soit PHP vous offre une fonction très pratique à cet effet, c'est str_shuffle(), Voici un exemple qui répond à vos besoins.
<?php
function randomString() {
$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
return str_shuffle($characters);
}
echo randomString();Voici comment je le fais pour obtenir une vraie clé aléatoire unique:
$Length = 10;
$RandomString = substr(str_shuffle(md5(time())), 0, $Length);
echo $RandomString;
Vous pouvez utiliser time () puisqu'il s'agit d'un horodatage Unix et qu'il est toujours unique par rapport aux autres variables aléatoires mentionnées ci-dessus. Vous pouvez ensuite générer la somme md5 et prendre la longueur souhaitée à partir de la chaîne MD5 générée. Dans ce cas, j'utilise 10 caractères et je pourrais utiliser une chaîne plus longue si je voulais la rendre plus unique.
J'espère que ça aide.
function randomString() {
return md5(Rand(100, 200));
}
function strgen($len) {
$buf = '';
for ($i = 0; $i < $len; $i++) {
$j = mt_Rand(0, 61);
if ($j >= 36) {
$j += 13;
} else if ($j >= 10) {
$j += 7;
}
$buf .= chr(48 + $j);
}
return $buf;
}
Simple et élégant.
La solution en une ligne sera
str_shuffle(base64_encode(date('mdyhis').date('mdyhis')));
Voici un one-liner. Vous obtiendrez au moins une minuscule, une majuscule, un chiffre et un symbole. Utilise random_int qui est censé être sécurisé par cryptographie. Je ne prétends pas que cela soit sécurisé, cependant. Je ne suis pas un expert en sécurité.
Pour copier + coller:
for ($chars = array('0123456789','abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ','!@#$%^&*()_+-='),$randomString="",$i=0;$i<12;$i++)$randomString .= substr($chars[$i%4], random_int(0,strlen($chars[$i%4])), 1);
Et un peu plus décomposé:
for (
$chars = array('0123456789','abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ','!@#$%^&*()_+-='),
$randomString="",
$i=0;
$i<12;$i++)
$randomString .=
substr($chars[$i%4],
random_int(0, strlen($chars[$i%4])), 1);
J'utilise $chars[$i%4] dans la boucle pour choisir le jeu de caractères à utiliser pour obtenir un caractère aléatoire. Il garantit plusieurs caractères de chaque ensemble de caractères du tableau.
Cela pourrait certainement être amélioré (randomiser le nombre de chaque jeu de caractères), mais cela suffit pour mes besoins.
Il y a 3 problèmes avec votre code:
- $ randstring n'est assigné à rien (seulement à l'intérieur de la fonction qui est en dehors de la portée).
- RandomString ne renvoie que le dernier caractère aléatoire. Remplacez
=par.=. Randne génère pas de nombres pseudo-aléatoires sécurisés de manière cryptographique. Utilisezrandom_intà la place.
Voir ci-dessous:
<?php
function RandomString()
{
$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
$randstring = '';
for ($i = 0; $i < 10; $i++) {
$randstring .= $characters[random_int(0, strlen($characters))];
}
return $randstring;
}
$randstring = RandomString();
echo $randstring;
function randomName($length = 8) {
$values = array_merge(range(65, 90), range(97, 122), range(48, 57));
$max = count($values) - 1;
$str = chr(mt_Rand(97, 122));
for ($i = 1; $i < $length; $i++) {
$str .= chr($values[mt_Rand(0, $max)]);
}
return $str;
}
bonjour tu peux essayer ça
<?php
function random($len){
$char = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
// ----------------------------------------------
// number of possible combinations
// ----------------------------------------------
$pos = strlen($char);
$pos = pow($pos, $len);
echo $pos.'<br>';
// ----------------------------------------------
$total = strlen($char)-1;
$text = "";
for ($i=0; $i<$len; $i++){
$text = $text.$char[Rand(0, $total)];
}
return $text;
}
$string = random(15);
echo $string;
?>
vous pouvez également utiliser md5 à temps, mais soyez prudent. Vous devez utiliser la fonction microtime() et non la fonction time() car, si plusieurs threads s'exécutent dans la même seconde, vous devez obtenir une chaîne différente pour chacun d'eux.
<?php
$string = md5( microtime() );
echo $string;
?>
Dans cette méthode, vous pouvez choisir la longueur du caractère lors de la création.
<?php
$random_string="";
$character_count=12;
for($i=1; $i<=$character_count; $i++)
{
$random_string.=chr(Rand(97,122));
}
echo $random_string;
?>