Estou tentando criar uma string aleatória no PHP e não recebo absolutamente nenhuma saída com isso:

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

    RandomString();
    echo $randstring;

O que estou fazendo errado?

Para responder especificamente a essa pergunta, dois problemas:

1. $randstring não está no escopo quando você faz o eco.
2. Os caracteres não estão sendo concatenados juntos no loop.

Aqui está um trecho de código com as correções:

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

Emita a sequência aleatória com a chamada abaixo:

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

Observe que isso gera seqüências aleatórias previsíveis. Se você deseja criar tokens seguros, consulte esta resposta .

Nota: str_shuffle()usa internamente rand(), o que não é adequado para fins de criptografia (por exemplo, gerar senhas aleatórias). Você deseja um gerador de números aleatórios seguro . Também não permite que os caracteres se repitam.

Mais uma maneira.

ATUALIZADO (agora isso gera qualquer comprimento de string):

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

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

É isso aí. :)

Há muitas respostas para essa pergunta, mas nenhuma delas utiliza um gerador de números pseudo-aleatórios criptograficamente seguros (CSPRNG).

A resposta simples, segura e correta é usar o RandomLib e não reinventar a roda.

Para aqueles que insistem em inventar sua própria solução, o PHP 7.0.0 fornecerá random_int()esse propósito; se você ainda usa o PHP 5.x, criamos um polyfill do PHP 5 pararandom_int() que você possa usar a nova API antes de atualizar para o PHP 7.

Gerar números inteiros aleatórios com segurança no PHP não é uma tarefa trivial. Você deve sempre verificar com os especialistas em criptografia StackExchange residentes antes de implantar um algoritmo caseiro na produção.

Com um gerador inteiro seguro no lugar, gerar uma sequência aleatória com um CSPRNG é uma caminhada no parque.

Criando uma seqüência aleatória segura

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

Demo : https://3v4l.org/IMJGF (Ignore as falhas do PHP 5; ele precisa de random_compat)

Isso cria uma cadeia hexadecimal de 20 caracteres:

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

No 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: sua resposta funcionou para mim. Eu tive o mesmo problema, e eu o sugeriria para quem está sempre procurando a mesma resposta. Aqui é de @tasmaniski:

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

Aqui está um vídeo do youtube mostrando como criar um número aleatório

Dependendo da sua aplicação (eu queria gerar senhas), você poderia usar

$string = base64_encode(openssl_random_pseudo_bytes(30));

Sendo base64, eles podem conter =ou -os caracteres solicitados. Você pode gerar uma sequência mais longa, filtrar e aparar para removê-las.

openssl_random_pseudo_bytesparece ser a maneira recomendada de gerar um número aleatório adequado em php. Por randque não usa /dev/randomeu não sei.

Aqui está uma linha única simples que gera uma verdadeira sequência aleatória sem nenhum loop de nível de script ou uso de bibliotecas OpenSSL.

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

Para dividi-lo para que os parâmetros sejam 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);

Esse método funciona repetindo aleatoriamente a lista de caracteres, embaralha a seqüência combinada e retorna o número de caracteres especificado.

Você pode randomizar isso ainda mais, randomizando o comprimento da sequência retornada, substituindo $chrRandomLengthpor mt_rand(8, 15)(para uma sequência aleatória entre 8 e 15 caracteres).

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

Tada!

Uma maneira melhor de implementar essa função é:

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é mais aleatório de acordo com isso e isso no PHP 7. A randfunção é um alias de mt_rand.

$randstringno escopo da função não é igual ao escopo em que você o chama. Você precisa atribuir o valor de retorno a uma variável.

$randstring = RandomString();
echo $randstring;

Ou apenas faça eco diretamente no valor de retorno:

echo RandomString();

Além disso, em sua função, você tem um pequeno erro. Dentro do loop for, você precisa usar .=para que cada caractere seja anexado à string. Ao usá- =lo, você o substituirá com cada novo caractere, em vez de anexá-lo.

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

Primeiro, você define o alfabeto que deseja usar:

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

Em seguida, use openssl_random_pseudo_bytes()para gerar dados aleatórios adequados:

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

Por fim, você usa esses dados aleatórios para criar a senha. Como cada caractere $randompode durar chr(0)até chr(255), o código usa o restante após a divisão de seu valor ordinal com $alphabet_lengthpara garantir que apenas os caracteres do alfabeto sejam escolhidos (observe que isso influencia a aleatoriedade):

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

Como alternativa, e geralmente melhor, é usar RandomLib e SecurityLib :

use SecurityLib\Strength;

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

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

Métodos curtos ..

Aqui estão alguns métodos mais curtos para gerar a string aleatória

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

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

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

Eu testei o desempenho das funções mais populares lá, o tempo necessário para gerar 1'000'000 strings de 32 símbolos na minha caixa é:

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

Observe que não é importante quanto tempo realmente durou, mas qual é mais lento e qual é mais rápido, para que você possa selecionar de acordo com seus requisitos, incluindo prontidão para criptografia etc.

substr () ao redor do MD5 foi adicionado para garantir a precisão, se você precisar de uma string menor que 32 símbolos.

Por uma questão de resposta: a sequência não foi concatenada, mas substituída e o resultado da função não foi armazenado.

PHP 7+ Gere bytes aleatórios criptograficamente seguros usando a função random_bytes .

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

Saída possível

da821217e61e33ed4b2dd96f8439056c

PHP 5.3+ Gere bytes pseudo-aleatórios usando a função openssl_random_pseudo_bytes .

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

Saída possível

e2d1254506fbb6cd842cd640333214ad

O melhor caso de uso pode 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();

Saída possível

ba8cc342bdf91143

Uma maneira muito rápida é fazer algo como:

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

Isso irá gerar uma sequência aleatória com o comprimento de 10 caracteres. Certamente, alguns podem dizer que é um pouco mais pesado no lado da computação, mas hoje em dia os processadores são otimizados para executar o algoritmo md5 ou sha256 muito rapidamente. E, é claro, se a rand()função retornar o mesmo valor, o resultado será o mesmo, com uma chance de 1/32767 de ser o mesmo. Se a segurança é o problema, basta alterar rand()paramt_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 foi retirado de fontes de administrador :

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

Adminer , ferramenta de gerenciamento de banco de dados escrita em PHP.

Função auxiliar do 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);
}

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

A versão editada da função funciona bem, mas encontrei apenas um problema: você usou o caractere errado para incluir $ caracteres; portanto, o caractere 'às vezes faz parte da sequência aleatória gerada.

Para corrigir isso, altere:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

para:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

Dessa forma, apenas os caracteres incluídos são usados ​​e o caractere 'nunca fará parte da sequência aleatória gerada.

Outra linha, que gera uma sequência aleatória de 10 caracteres com letras e números. Ele criará uma matriz com range(ajuste o segundo parâmetro para definir o tamanho), passa por essa matriz e atribui um caractere ASCII aleatório (intervalo de 0 a 9 ou az) e depois implode a matriz para obter uma sequência.

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

Nota: isso funciona apenas no PHP 5.3 e posterior

Um forro.

É rápido para cordas enormes com alguma exclusividade.

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

Desde php7, existem as funções random_bytes. https://www.php.net/manual/ru/function.random-bytes.php Para gerar uma sequência aleatória como essa

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

Gostei do último comentário que usou o openssl_random_pseudo_bytes, mas não foi uma solução para mim, pois ainda tinha que remover os caracteres que não queria e não consegui obter uma string de comprimento definido. Aqui está a minha solução ...

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

Aqui está minha solução simples de uma linha para gerar uma senha aleatória amigável para o uso, excluindo caracteres semelhantes a "1" e "l", "O" e "0", etc ... aqui estão 5 caracteres, mas você pode facilmente mude de curso:

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

Aqui está outra solução.

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

PS. Estou usando o PHP 7.2 no Ubuntu.

Outra maneira de gerar uma string aleatória no PHP é:

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

Aqui está como eu estou fazendo isso para obter uma chave aleatória única e verdadeira:

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

Você pode usar time (), pois é um carimbo de data / hora do Unix e sempre é único em comparação com outros aleatórios mencionados acima. Em seguida, você pode gerar o md5sum e obter o comprimento desejado da cadeia MD5 gerada . Nesse caso, estou usando 10 caracteres e poderia usar uma string mais longa se quiser torná-la mais exclusiva.

Eu espero que isso ajude.

One-liner parametrizado usando apenas funções nativas do PHP , trabalhando desde o 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))))))