Nota: str_shuffle() utilizações internasrand(), que não é adequado para fins de criptografia (por exemplo, gerar senhas aleatórias). Você quer um Gerador de números aleatórios seguros em vez disso. Também não permite que os personagens se repitam.

Actualizado (agora isto gera qualquer comprimento de texto):

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

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

Há muitas respostas para esta pergunta, mas nenhuma delas alavancam um gerador de Números Pseudo-aleatórios criptograficamente seguro (CSPRNG).

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

Gerar de forma segura inteiros aleatórios em PHP não é uma tarefa trivial. Você deve sempre verificar com seus especialistas em criptografia StackExchange residentes antes de implantar um algoritmo caseiro na produção.

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

Utilização:

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

Demonstração: https://3v4l.org/b4PST (ignorar as falhas do PHP 5; necessita de random_ compat)

Cria uma cadeia hexdec de 20 caracteres:

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

Em PHP 7 (random_bytes()):

$string = base64_encode(random_bytes(10)); // ~14 chars
// or
$string = bin2hex(random_bytes(10)); // 20 chars

@tasmaniski: a tua resposta funcionou comigo. Eu tinha o mesmo problema, e eu sugeriria-o para aqueles que estão sempre à procura da mesma resposta. Aqui está de @tasmaniski:

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

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

$string = base64_encode(openssl_random_pseudo_bytes(30));

Sendo base64, podem conter = ou -, bem como os caracteres solicitados. Você poderia gerar um fio mais longo, em seguida, filtrar e apará-lo para remover esses.

openssl_random_pseudo_bytes parece ser a maneira recomendada para gerar um número aleatório apropriado em php. Porque rand não usa /dev/random não sei.

Eu sei que isto pode ser um pouco tarde para o jogo, mas aqui está um simples liner que gera uma verdadeira cadeia aleatória sem qualquer looping de nível de script ou uso de bibliotecas openssl.

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

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

Este método funciona repetindo aleatoriamente a lista de caracteres, em seguida, baralha o texto combinado, e retorna o número de caracteres especificados.

Você pode ainda randomizar isto, ao randomizar o comprimento do retornado string, substituindo $chrRandomLength por mt_rand(8, 15) (para uma string aleatória entre 8 e 15 caracteres).

Uma melhor maneira de implementar esta 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 Este e Este em php7. rand a função é um nome falso de mt_rand.

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

$randstring no escopo da função não é o mesmo que o escopo onde você o chama. Você tem que atribuir o valor de retorno a uma variável.

$randstring = RandomString();
echo $randstring;

Ou apenas ecoar directamente o valor de retorno:

echo RandomString();

Também, na tua função tens um pequeno erro. Dentro do laço for, você precisa usar .= para que cada personagem seja adicionado ao texto. Ao usar = Você está sobrepondo-o com cada novo personagem em vez de adicionar.

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

Primeiro, você define o alfabeto que deseja usar:

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

openssl_random_pseudo_bytes() para gerar dados aleatórios adequados:

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

Finalmente, você usa estes dados aleatórios para criar a senha. Porque cada caractere em $random pode ser chr(0) até chr(255), o código usa o restante após a divisão de seu valor ordinal com $alphabet_length para garantir que apenas os caracteres do alfabeto são escolhidos (observe que isso polariza a aleatoriedade):

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

Em 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á um método mais curto para gerar o texto aleatório

<?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 que é 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);

Por favor, note que não é importante quanto tempo realmente foi, mas qual é mais lento e qual é mais rápido para que você possa selecionar de acordo com seus requisitos, incluindo criptografia-preparação, etc.

Substr () em torno de MD5 foi adicionado por uma questão de precisão, se você precisar de cadeia de caracteres que é mais curto do que 32 símbolos.

Para o bem de resposta: a string não foi concatenada, mas substituída e o resultado da função não foi armazenado.

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

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

Adminer , Ferramenta de gestão de bases de dados escrita em PHP.

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

Isto irá gerar um texto aleatório com o comprimento de 10 caracteres. Claro, alguns podem dizer que é um pouco mais pesado no lado computacional, mas hoje em dia os processadores são otimizados para executar o algoritmo md5 ou sha256 muito rapidamente. E, claro, se a função rand() retorna o mesmo valor, o resultado será o mesmo, tendo uma chance de 1 / 32767 de ser o mesmo. Se a segurança é o problema, então muda para mt_rand()

Função Auxiliar do Laravel 5 framework

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

A versão editada da função funciona bem, apenas uma questão que eu encontrei: você usou o personagem errado para incluir caracteres$, de modo que o personagem ' às vezes faz parte da cadeia aleatória que é gerada.

Para corrigir isto, muda:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

To:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

Desta forma, apenas os caracteres fechados são usados, e o carácter ' nunca fará parte da cadeia aleatória que é gerada.

Outra linha única, que gera uma cadeia aleatória de 10 caracteres com letras e números. Ele irá criar um array com range (ajustar o segundo parâmetro para definir o tamanho), loops sobre este array e atribui um ASCII-char Aleatório (intervalo 0-9 ou a-z), então implode o array para obter uma string.

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

Nota: só funciona em PHP 5.3+

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

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

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

Gostei do último comentário que usou openssl_random_pseudo_bytes, mas não foi uma solução para mim, pois ainda tinha de remover os caracteres que não queria, e não fui capaz de obter uma cadeia de comprimento definida. Eis 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);
}

Outra forma de gerar um texto aleatório em 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);

Existe um código simples:

echo implode("",array_map(create_function('$s','return substr($s,mt_rand(0,strlen($s)),1);'),array_fill(0,16,"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")));

Existe um guia simples:

• para mudar o Comprimento do texto , por favor mude o 16 para outro valor, apenas.
• para seleccionar de caracteres diferentes, por favor altere o texto dos caracteres.

Há melhores alternativas para isso, muitos já foram postados, então eu lhe dou apenas suas coisas de volta com correções

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

<?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 */

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
}

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

Você pode usar o tempo () uma vez que é um timestamp Unix e é sempre único em comparação com outros aleatórios mencionados acima. Você pode então gerar o md5sum desse e tomar o comprimento desejado que você precisa a partir do texto gerado MD5 . Neste caso eu estou usando 10 caracteres, e eu poderia usar um string mais longo se eu quisesse torná-lo mais único.

Fonte: função PHP que gera caracteres aleatórios

Esta função PHP funcionou para mim:

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;

}

Utilização:

echo cvf_ps_generate_random_code(5);