Estoy tratando de crear una cadena aleatoria en PHP, y no obtengo absolutamente ningún resultado con esto:

<?php
    function RandomString()
    {
        $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        $randstring = '';
        for ($i = 0; $i < 10; $i++) {
            $randstring = $characters[rand(0, strlen($characters))];
        }
        return $randstring;
    }

    RandomString();
    echo $randstring;

¿Qué estoy haciendo mal?

Para responder esta pregunta específicamente, dos problemas:

1. $randstring no está dentro del alcance cuando lo repites.
2. Los personajes no se concatenan juntos en el bucle.

Aquí hay un fragmento de código con las correcciones:

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

Salida de la cadena aleatoria con la siguiente llamada:

// Echo the random string.
// Optionally, you can give it a desired string length.
echo generateRandomString();

Tenga en cuenta que esto genera cadenas aleatorias predecibles. Si desea crear tokens seguros, vea esta respuesta .

Nota: str_shuffle()utiliza internamente rand(), lo que no es adecuado para fines de criptografía (por ejemplo, generar contraseñas aleatorias). Desea un generador de números aleatorios seguro en su lugar. Tampoco permite que los personajes se repitan.

Una forma mas.

ACTUALIZADO (ahora esto genera cualquier longitud de cadena):

function generateRandomString($length = 10) {
    return substr(str_shuffle(str_repeat($x='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', ceil($length/strlen($x)) )),1,$length);
}

echo  generateRandomString();  // OR: generateRandomString(24)

Eso es. :)

Hay muchas respuestas a esta pregunta, pero ninguna de ellas aprovecha un generador de números pseudoaleatorios criptográficamente seguros (CSPRNG).

La respuesta simple, segura y correcta es usar RandomLib y no reinventar la rueda.

Para aquellos de ustedes que insisten en inventar su propia solución, PHP 7.0.0 proporcionará random_int()para este propósito; si todavía está en PHP 5.x, escribimos un polyfill de PHP 5 pararandom_int() que pueda usar la nueva API incluso antes de actualizar a PHP 7.

La generación segura de enteros aleatorios en PHP no es una tarea trivial. Siempre debe consultar con sus expertos en criptografía StackExchange residentes antes de implementar un algoritmo interno en producción.

Con un generador entero seguro en su lugar, generar una cadena aleatoria con un CSPRNG es un paseo por el parque.

Crear una cadena segura y aleatoria

/**
 * Generate a random string, using a cryptographically secure 
 * pseudorandom number generator (random_int)
 *
 * This function uses type hints now (PHP 7+ only), but it was originally
 * written for PHP 5 as well.
 * 
 * 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(
    int $length = 64,
    string $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
): string {
    if ($length < 1) {
        throw new \RangeException("Length must be a positive integer");
    }
    $pieces = [];
    $max = mb_strlen($keyspace, '8bit') - 1;
    for ($i = 0; $i < $length; ++$i) {
        $pieces []= $keyspace[random_int(0, $max)];
    }
    return implode('', $pieces);
}

Uso :

$a = random_str(32);
$b = random_str(8, 'abcdefghijklmnopqrstuvwxyz');
$c = random_str();

Demostración : https://3v4l.org/IMJGF (ignore las fallas de PHP 5; necesita random_compat)

Esto crea una cadena hexadecimal de 20 caracteres de longitud:

$string = bin2hex(openssl_random_pseudo_bytes(10)); // 20 chars

En PHP 7 ( random_bytes () ):

$string = base64_encode(random_bytes(10)); // ~14 characters, includes /=+
// or
$string = substr(str_replace(['+', '/', '='], '', base64_encode(random_bytes(32))), 0, 32); // 32 characters, without /=+
// or
$string = bin2hex(random_bytes(10)); // 20 characters, only 0-9a-f

@tasmaniski: tu respuesta funcionó para mí. Tuve el mismo problema y lo sugeriría para aquellos que alguna vez buscan la misma respuesta. Aquí es de @tasmaniski:

<?php 
    $random = substr(md5(mt_rand()), 0, 7);
    echo $random;
?>

Aquí hay un video de YouTube que nos muestra cómo crear un número aleatorio

Dependiendo de su aplicación (quería generar contraseñas), podría usar

$string = base64_encode(openssl_random_pseudo_bytes(30));

Al ser base64, pueden contener =o -los caracteres solicitados. Puede generar una cadena más larga, luego filtrarla y recortarla para eliminarlas.

openssl_random_pseudo_bytesparece ser la forma recomendada de generar un número aleatorio adecuado en php. ¿ randPor qué no usa /dev/random? No lo sé.

Aquí hay una línea simple que genera una verdadera cadena aleatoria sin ningún ciclo de secuencia de comandos o uso de bibliotecas OpenSSL.

echo substr(str_shuffle(str_repeat('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', mt_rand(1,10))), 1, 10);

Desglosarlo para que los parámetros estén claros

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

Este método funciona repitiendo aleatoriamente la lista de caracteres, luego baraja la cadena combinada y devuelve el número de caracteres especificado.

Puede aleatorizar aún más esto, aleatorizando la longitud de la cadena devuelta, reemplazándola $chrRandomLengthpor mt_rand(8, 15)(para una cadena aleatoria de entre 8 y 15 caracteres).

function generateRandomString($length = 15)
{
    return substr(sha1(rand()), 0, $length);
}

Tada!

Una mejor manera de implementar esta función es:

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_randes más aleatorio de acuerdo con esto y esto en PHP 7. La randfunción es un alias de mt_rand.

$randstringen el ámbito de la función no es lo mismo que el ámbito donde lo llama. Debe asignar el valor de retorno a una variable.

$randstring = RandomString();
echo $randstring;

O simplemente haga eco directamente del valor de retorno:

echo RandomString();

Además, en su función tiene un pequeño error. Dentro del ciclo for, debe usarlo .=para que cada carácter se agregue a la cadena. Al usarlo, =lo sobrescribe con cada nuevo carácter en lugar de agregarlo.

$randstring .= $characters[rand(0, strlen($characters))];

Primero, define el alfabeto que desea usar:

$alphanum = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$special  = '~!@#$%^&*(){}[],./?';
$alphabet = $alphanum . $special;

Luego, use openssl_random_pseudo_bytes()para generar datos aleatorios adecuados:

$len = 12; // length of password
$random = openssl_random_pseudo_bytes($len);

Finalmente, utiliza estos datos aleatorios para crear la contraseña. Debido a que cada carácter $randompuede ser chr(0)hasta chr(255), el código usa el resto después de la división de su valor ordinal $alphabet_lengthpara asegurarse de que solo se seleccionen los caracteres del alfabeto (tenga en cuenta que al hacerlo sesga la aleatoriedad):

$alphabet_length = strlen($alphabet);
$password = '';
for ($i = 0; $i < $len; ++$i) {
    $password .= $alphabet[ord($random[$i]) % $alphabet_length];
}

Alternativamente, y en general mejor, es usar RandomLib y SecurityLib :

use SecurityLib\Strength;

$factory = new RandomLib\Factory;
$generator = $factory->getGenerator(new Strength(Strength::MEDIUM));

$password = $generator->generateString(12, $alphabet);

Métodos cortos.

Estos son algunos de los métodos más cortos para generar la cadena aleatoria.

<?php
echo $my_rand_strng = substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), -15); 

echo substr(md5(rand()), 0, 7);

echo str_shuffle(MD5(microtime()));
?>

He probado el rendimiento de las funciones más populares allí, el tiempo necesario para generar 1'000'000 cadenas de 32 símbolos en mi caja es:

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

Tenga en cuenta que no es importante cuánto tiempo fue realmente, sino cuál es más lento y cuál es más rápido, por lo que puede seleccionar de acuerdo con sus requisitos, incluida la preparación de criptografía, etc.

Se agregó substr () alrededor de MD5 en aras de la precisión si necesita una cadena que sea más corta que 32 símbolos.

En aras de la respuesta: la cadena no se concatenó sino que se sobrescribió y el resultado de la función no se almacenó.

PHP 7+ Genera bytes aleatorios criptográficamente seguros utilizando la función random_bytes .

$bytes = random_bytes(16);
echo bin2hex($bytes);

Salida posible

da821217e61e33ed4b2dd96f8439056c

PHP 5.3+ Genera bytes pseudoaleatorios usando la función openssl_random_pseudo_bytes .

$bytes = openssl_random_pseudo_bytes(16);
echo bin2hex($bytes);

Salida posible

e2d1254506fbb6cd842cd640333214ad

El mejor caso de uso podría ser

function getRandomBytes($length = 16)
{
    if (function_exists('random_bytes')) {
        $bytes = random_bytes($length / 2);
    } else {
        $bytes = openssl_random_pseudo_bytes($length / 2);
    }
    return bin2hex($bytes);
}
echo getRandomBytes();

Salida posible

ba8cc342bdf91143

Una forma muy rápida es hacer algo como:

substr(md5(rand()),0,10);

Esto generará una cadena aleatoria con la longitud de 10 caracteres. Por supuesto, algunos podrían decir que es un poco más pesado en el lado de la computación, pero hoy en día los procesadores están optimizados para ejecutar el algoritmo md5 o sha256 muy rápidamente. Y, por supuesto, si la rand()función devuelve el mismo valor, el resultado será el mismo, con una probabilidad de 1/32767 de ser el mismo. Si la seguridad es el problema, simplemente cambie rand()amt_rand()

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

Este fue tomado de fuentes administrativas :

/** Get a random string
* @return string 32 hexadecimal characters
*/
function rand_string() {
    return md5(uniqid(mt_rand(), true));
}

Adminer , herramienta de gestión de bases de datos escrita en PHP.

Función auxiliar del 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);
}

/**
 * @param int $length
 * @param string $abc
 * @return string
 */
function generateRandomString($length = 10, $abc = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
{
    return substr(str_shuffle($abc), 0, $length);
}

Fuente de http://www.xeweb.net/2011/02/11/generate-a-random-string-az-0-9-in-php/

La versión editada de la función funciona bien, pero solo encontré un problema: usó el carácter incorrecto para encerrar $ caracteres, por lo que el carácter 'a veces es parte de la cadena aleatoria que se genera.

Para arreglar esto, cambie:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

a:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

De esta forma, solo se utilizan los caracteres encerrados, y el carácter 'nunca será parte de la cadena aleatoria que se genera.

Otra línea única, que genera una cadena aleatoria de 10 caracteres con letras y números. Creará una matriz con range(ajuste el segundo parámetro para establecer el tamaño), recorre esta matriz y asigna un carácter ASCII aleatorio (rango 0-9 o az), luego implosiona la matriz para obtener una cadena.

$str = implode('', array_map(function () { return chr(rand(0, 1) ? rand(48, 57) : rand(97, 122)); }, range(0, 9)));

Nota: esto solo funciona en PHP 5.3 y posterior

Un trazador de líneas.

Es rápido para cuerdas enormes con cierta singularidad.

function random_string($length){
    return substr(str_repeat(md5(rand()), ceil($length/32)), 0, $length);
}

Desde php7, existen las funciones random_bytes. https://www.php.net/manual/ru/function.random-bytes.php Para que pueda generar una cadena aleatoria como esa

<?php
$bytes = random_bytes(5);
var_dump(bin2hex($bytes));
?>

Me gustó el último comentario que usó openssl_random_pseudo_bytes, pero no fue una solución para mí, ya que todavía tenía que eliminar los caracteres que no quería, y no pude obtener una cadena de longitud establecida. Aquí está mi solución ...

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

Aquí está mi solución simple de una línea para generar una contraseña aleatoria amigable, excluyendo los caracteres que se parecen, como "1" y "l", "O" y "0", etc. Aquí hay 5 caracteres, pero puede fácilmente cambiarlo por supuesto:

$user_password = substr(str_shuffle('abcdefghjkmnpqrstuvwxyzABCDEFGHJKMNPQRSTUVWXYZ23456789'),0,5);

Aquí hay otra solución.

function genRandomString($length = 10)
{
    if($length < 1)
        $length = 1;
    return substr(preg_replace("/[^A-Za-z0-9]/", '', base64_encode(openssl_random_pseudo_bytes($length * 2))), 0, $length);
}

PD. Estoy usando PHP 7.2 en Ubuntu.

Otra forma de generar una cadena aleatoria en PHP es:

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

Así es como lo estoy haciendo para obtener una verdadera clave aleatoria única:

$Length = 10;
$RandomString = substr(str_shuffle(md5(time())), 0, $Length);
echo $RandomString;

Puede usar time () ya que es una marca de tiempo Unix y siempre es única en comparación con otras aleatorias mencionadas anteriormente. Luego puede generar la suma md5 de eso y tomar la longitud deseada que necesita del MD5 generado cadena . En este caso, estoy usando 10 caracteres, y podría usar una cadena más larga si quisiera hacerla más única.

Espero que esto ayude.

One-liner parametrizado usando solo funciones nativas de PHP , trabajando desde 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))))))