Uwaga: str_shuffle() używa wewnętrznierand(), który nie nadaje się do celów kryptograficznych (np. generowanie losowych haseł). Zamiast tego potrzebujesz bezpiecznego generatora liczb losowych . Nie pozwala również na powtarzanie się postaci.

Aktualizacja (teraz generuje dowolną długość łańcucha):

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

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

Istnieje wiele odpowiedzi na to pytanie, ale żadna z nich nie wykorzystuje zabezpieczonego kryptograficznie generatora liczb pseudolosowych (CSPRNG).

Prostą, bezpieczną i poprawną odpowiedzią jest użycie RandomLib i nie wymyślanie koła na nowo.

Dla tych z Was, którzy nalegają na wymyślenie własnego rozwiązania, PHP 7.0.0 zapewni random_int() w tym celu; jeśli nadal korzystasz z PHP 5.x, napisaliśmy PHP 5 polyfill dla random_int() możesz więc korzystać z nowego API jeszcze przed uaktualnieniem do PHP 7.

Bezpieczne generowanie losowych liczb całkowitych w PHP nie jest banalnym zadaniem. Przed wdrożeniem domowego algorytmu w produkcji należy zawsze skontaktować się z ekspertami od kryptografii StackExchange .

Z bezpiecznym generatorem liczb całkowitych w miejscu, generowanie losowego ciągu z csprng to spacer po parku.

Tworzenie bezpiecznego, losowego String

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

Użycie :

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

Demo: https://3v4l.org/b4PST (Ignoruj błędy PHP 5; potrzebuje random_compat)

Tworzy łańcuch heksdec o długości 20 znaków:

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

W PHP 7 (random_bytes()):

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

@tasmaniski: Twoja odpowiedź zadziałała na mnie. Miałem ten sam problem i sugerowałbym go tym, którzy kiedykolwiek szukają tej samej odpowiedzi. Tu jest od @tasmaniski:

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

W zależności od aplikacji (chciałem wygenerować hasła), można użyć

$string = base64_encode(openssl_random_pseudo_bytes(30));

Jako base64, mogą zawierać = lub - oraz żądane znaki. Możesz wygenerować dłuższy ciąg, a następnie filtrować i przyciąć go, aby je usunąć.

openssl_random_pseudo_bytes wydaje się być zalecanym sposobem generowania odpowiedniej liczby losowej w php. Dlaczego rand nie używa /dev/random Nie wiem.

Wiem, że to może być trochę za późno na grę, ale tutaj jest prosta jednolinijkowa, która generuje prawdziwy losowy ciąg bez zapętlania poziomu skryptu lub korzystania z bibliotek openssl.

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

Rozbić go tak, aby parametry były jasne

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

Ta metoda działa poprzez losowe powtarzanie listy znaków, następnie tasuje połączony łańcuch i Zwraca określoną liczbę znaków.

Możesz dalej randomizować to, randomizując długość zwracanego ciągu, zastąpienie $chrRandomLength przez mt_rand(8, 15) (dla losowego ciągu od 8 do 15 znaków).

Lepszym sposobem implementacji tej funkcji jest:

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 jest bardziej losowe według to i to w php7. rand funkcja jest aliasem mt_rand.

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

$randstring zakres funkcji nie jest taki sam jak zakres, w którym go wywołujesz. Musisz przypisać wartość zwracaną do zmiennej.

$randstring = RandomString();
echo $randstring;

Lub po prostu bezpośrednio echo zwracanej wartości:

echo RandomString();

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

Najpierw definiujesz alfabet, którego chcesz użyć:

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

Następnie użyj openssl_random_pseudo_bytes() aby wygenerować odpowiednie losowe DANE:

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

Na koniec użyj tych losowych danych, aby utworzyć hasło. Ponieważ każdy znak w $random może być chr(0) aż do chr(255), kod używa reszty po podzieleniu jego wartości Porządkowej z $alphabet_length, aby upewnić się, że wybrano tylko znaki z alfabetu (zauważ, że to wpływa na losowość):

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

Alternatywnie i ogólnie lepiej jest użyć RandomLib i SecurityLib :

use SecurityLib\Strength;

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

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

Krótkie Metody..

Oto kilka najkrótszych metod generowania losowego ciągu

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

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

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

Przetestowałem tam wydajność najpopularniejszych funkcji, Czas potrzebny na wygenerowanie 1'000' 000 ciągów 32 symboli na moim pudełku to:

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

Należy pamiętać, że nie jest ważne, jak długo to było naprawdę, ale który jest wolniejszy, a który szybszy, więc można wybrać zgodnie z wymaganiami, w tym gotowość do kryptografii itp.

Substr () wokół MD5 została dodana dla dokładności, jeśli potrzebujesz ciągu krótszego niż 32 symbole.

Ze względu na odpowiedź: łańcuch nie został skonkatenowany, lecz nadpisany, a wynik funkcji nie został zapisany.

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

Ten został zaczerpnięty z źródeł adminów :

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

Adminer , Narzędzie do zarządzania bazami danych napisane w PHP.

Jednym bardzo szybkim sposobem jest zrobienie czegoś takiego:

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

Wygeneruje losowy ciąg znaków o długości 10 znaków. Oczywiście niektórzy mogą powiedzieć, że jest nieco cięższy od strony obliczeniowej, ale obecnie procesory są zoptymalizowane do bardzo szybkiego uruchamiania algorytmu md5 lub sha256. Oczywiście, jeśli funkcja rand() zwróci tę samą wartość, wynik będzie taki sam, mając 1 / 32767 szansę na to, że będzie taka sama. Jeśli chodzi o bezpieczeństwo, po prostu zmień rand() na mt_rand()

Helper function from 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);
}

Edytowana wersja funkcji działa dobrze, tylko jeden problem znalazłem: użyłeś niewłaściwego znaku do załączenia znaków$, więc znak ' jest czasami częścią losowego łańcucha, który jest generowany.

Aby to naprawić, Zmień:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

Do:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

W ten sposób używane są tylko zamknięte znaki, a znak ' nigdy nie będzie częścią generowanego losowego ciągu znaków.

Kolejny jednowierszowy, który generuje losowy ciąg 10 znaków z literami i cyframi. Utworzy tablicę z range (dostosuje drugi parametr, aby ustawić rozmiar), zapętli tę tablicę i przypisze losowy znak ascii( zakres 0-9 lub a-z), a następnie imploduje tablicę, aby uzyskać ciąg znaków.

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

Uwaga: działa tylko w PHP 5.3+

Jedna linijka.
Szybki dla ogromnych strun z pewną wyjątkowością.

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

Źródło z http://www.xeweb.net/2011/02/11/generate-a-random-string-a-z-0-9-in-php/

Spodobał mi się ostatni komentarz, w którym użyto openssl_random_pseudo_bytes, ale nie było to dla mnie rozwiązaniem, ponieważ nadal musiałem usuwać znaki, których nie chciałem, i nie byłem w stanie uzyskać ciągu o ustawionej długości. Oto moje rozwiązanie...

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

Innym sposobem wygenerowania losowego ciągu w PHP jest:

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

Istnieje prosty kod:

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

Jest prosty przewodnik:

• aby zmienić Długość łańcucha , należy zmienić 16 na inną wartość.
• aby wybrać spośród różnych znaków, Zmień łańcuch znaków.

Są lepsze alternatywy dla tego, wiele było już wysłane, więc daję Ci tylko swoje rzeczy z powrotem z poprawkami

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

Oto Jak to robię, aby uzyskać prawdziwy unikalny losowy klucz:

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

Możesz użyć time (), ponieważ jest to uniksowy znacznik czasu i jest zawsze unikalny w porównaniu do innych random wymienionych powyżej. Następnie możesz wygenerować sumę MD5 i pobrać żądaną długość z wygenerowanego ciągu MD5 . W tym przypadku używam 10 znaków i przydałby mi się dłuższy ciąg znaków, jeśli chciałbym, aby był bardziej unikalny.

Źródło: funkcja PHP generująca losowe znaki

Ta funkcja PHP zadziałała dla mnie:

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;

}

Użycie:

echo cvf_ps_generate_random_code(5);