str_shuffle - Generador de cadenas aleatorias de PHP
sacar numeros aleatorios en php (30)
Nota:
str_shuffle()utiliza internamenterand(), que no es adecuado para fines de criptografía (p. Ej., Generar contraseñas aleatorias). Usted quiere un generador seguro de números aleatorios en su lugar. Tampoco permite que los personajes se repitan.
Una forma más.
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. :)
Estoy tratando de crear una cadena aleatoria en PHP, y no obtengo 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?
Métodos cortos ..
Aquí hay un método más corto 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()));
?>
@tasmaniski: tu respuesta funcionó para mí. Tuve el mismo problema, y lo sugeriría para aquellos que alguna vez buscan la misma respuesta. Aquí está de @tasmaniski:
<?php
$random = substr(md5(mt_rand()), 0, 7);
echo $random;
?>
Aquí es cómo 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 de Unix y siempre es único en comparación con otro aleatorio mencionado anteriormente. Luego, puede generar el md5sum de eso y tomar la longitud deseada que necesita de la cadena MD5 generada. 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.
Crea una cadena hexdec larga de 20 caracteres:
$string = bin2hex(openssl_random_pseudo_bytes(10)); // 20 chars
En PHP 7 ( random_bytes() ):
$string = base64_encode(random_bytes(10)); // ~14 chars
// or
$string = bin2hex(random_bytes(10)); // 20 chars
Dependiendo de tu aplicación (quería generar contraseñas), podrías usar
$string = base64_encode(openssl_random_pseudo_bytes(30));
Al ser base64, pueden contener = o - así como los caracteres solicitados. Podría generar una cadena más larga, luego filtrarla y recortarla para eliminarla.
openssl_random_pseudo_bytes parece ser la forma recomendada de generar un número aleatorio adecuado en php. ¿Por qué rand no usa /dev/random ? No lo sé.
Este fue tomado de fuentes de administrador :
/** Get a random string
* @return string 32 hexadecimal characters
*/
function rand_string() {
return md5(uniqid(mt_rand(), true));
}
Adminer , herramienta de gestión de base de datos escrita en PHP.
Fuente: Función PHP que genera caracteres aleatorios.
Esta función de PHP funcionó para mí:
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;
}
Uso:
echo cvf_ps_generate_random_code(5);
Función auxiliar desde el 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);
}
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 aún está en PHP 5.x, escribimos un polyfill de PHP 5 para random_int() para 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 de producción propia.
Con un generador de enteros seguro en su lugar, generar una cadena aleatoria con un CSPRNG es un paseo por el parque.
Creando una cadena segura y aleatoria
/**
* 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);
}
Uso :
$a = random_str(32);
$b = random_str(8, ''abcdefghijklmnopqrstuvwxyz'');
Demostración : https://3v4l.org/b4PST (Ignore las fallas de PHP 5; necesita random_compat)
Hay un código simple:
echo implode("",array_map(create_function(''$s'',''return substr($s,mt_rand(0,strlen($s)),1);''),array_fill(0,16,"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")));
Hay una guía simple:
- Para cambiar la longitud de la cadena , cambie el
16a otro valor, solo. - Para seleccionar entre diferentes caracteres, cambie la cadena de caracteres.
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 realmente duró, sino que es más lento y cuál es más rápido para que pueda seleccionar de acuerdo con sus requisitos, incluida la preparación de la criptografía, etc.
substr () alrededor de MD5 se agregó para mayor precisión si necesita una cadena que sea más corta que 32 símbolos.
Por el bien de la respuesta: la cadena no fue concatenada sino sobrescrita y el resultado de la función no fue almacenado.
La versión editada de la función funciona bien, solo un problema que encontré: usaste el carácter incorrecto para incluir $ 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 manera solo se utilizan los caracteres encerrados, y el carácter ''nunca será parte de la cadena aleatoria que se genera.
Me gustó el último comentario que usó openssl_random_pseudo_bytes, pero no fue una solución para mí ya que aún tenía que eliminar los caracteres que no quería, y no pude obtener una cadena de longitud determinada. 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;
}
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);
Otro de una sola línea, que genera una cadena aleatoria de 10 caracteres con letras y números. Creará una matriz con range (ajustará el segundo parámetro para establecer el tamaño), pasará por encima de esta matriz y asignará un ascii-char aleatorio (rango 0-9 o az), luego implosionará 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: solo funciona en PHP 5.3+
Para responder a esta pregunta específicamente, dos problemas:
-
$randstringno está dentro del alcance cuando lo haces eco. - 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 llamada a continuación:
// 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 .
Primero, define el alfabeto que quiere usar:
$alphanum = ''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'';
$special = ''~!@#$%^&*(){}[],./?'';
$alphabet = $alphanum . $special;
Luego, use openssl_random_pseudo_bytes() para generar datos aleatorios apropiados:
$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 en $random puede ser chr(0) hasta chr(255) , el código usa el resto después de la división de su valor ordinal con $alphabet_length para asegurarse de que solo se seleccionen los caracteres del alfabeto (tenga en cuenta que al hacerlo es parcial al azar) ):
$alphabet_length = strlen($alphabet);
$password = '''';
for ($i = 0; $i < $len; ++$i) {
$password .= $alphabet[ord($random[$i]) % $alphabet_length];
}
Alternativamente, y generalmente 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);
Sé que esto puede ser un poco tarde para el juego, pero aquí hay un sencillo de una sola línea que genera una verdadera cadena aleatoria sin ningún bucle a nivel de script o el uso de bibliotecas de openssl.
echo substr(str_shuffle(str_repeat(''0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'', mt_rand(1,10))),1,10);
Desglosarlo para que los parámetros sean 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 especificados.
Puede aleatorizar aún más esto, aleatorizando la longitud de la cadena devuelta, reemplazando $chrRandomLength con mt_rand(8, 15) (para una cadena aleatoria entre 8 y 15 caracteres).
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 computacional, 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 función rand() 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 cambia rand() a mt_rand()
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_rand es más aleatorio según this y this en php7. rand función rand es un alias de mt_rand .
hay mejores alternativas a esto, ya se han publicado muchas, así que solo te devuelvo tus cosas con correcciones
<?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;
?>
También te puede interesar:
<?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());
?>
u otro:
<?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);
?>
una línea.
Rápido para cuerdas enormes con alguna singularidad.
function random_string($length){
return substr(str_repeat(md5(rand()), ceil($length/32)), 0, $length);
}
$randstring en el ámbito de la función no es el mismo que el ámbito en el que se llama. Tienes que asignar el valor de retorno a una variable.
$randstring = RandomString();
echo $randstring;
O simplemente repetir directamente el valor de retorno:
echo RandomString();
Además, en tu función tienes un pequeño error. Dentro del bucle for, debe usar .= que cada carácter se agregue a la cadena. Al utilizar = se está sobrescribiendo con cada nuevo carácter en lugar de agregar.
$randstring .= $characters[rand(0, strlen($characters))];
<?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 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-a-z-0-9-in-php/
function generateRandomString($length = 15)
{
return substr(sha1(rand()), 0, $length);
}
Tada!
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
}
function randomString($length = 5) {
return substr(str_shuffle(implode(array_merge(range(''A'',''Z''), range(''a'',''z''), range(0,9)))), 0, $length);
}
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;
}