Saya mencoba membuat string acak dalam PHP, dan saya sama sekali tidak mendapatkan output dengan ini:

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

    RandomString();
    echo $randstring;

Apa yang saya lakukan salah?

Untuk menjawab pertanyaan ini secara khusus, dua masalah:

1. $randstring tidak ada dalam ruang lingkup saat Anda menggemakannya.
2. Karakter tidak disatukan dalam satu lingkaran.

Berikut cuplikan kode dengan koreksi:

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

Keluarkan string acak dengan panggilan di bawah ini:

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

Harap dicatat bahwa ini menghasilkan string acak yang dapat diprediksi. Jika Anda ingin membuat token aman, lihat jawaban ini .

Catatan: str_shuffle()penggunaan internal rand(), yang tidak cocok untuk keperluan kriptografi (misalnya menghasilkan kata sandi acak). Anda menginginkan generator nomor acak yang aman sebagai gantinya. Itu juga tidak memungkinkan karakter untuk mengulang.

Satu lagi jalan.

DIPERBARUI (sekarang ini menghasilkan string apa pun):

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

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

Itu dia. :)

Ada banyak jawaban untuk pertanyaan ini, tetapi tidak satupun dari mereka yang memanfaatkan Pseudo-Random Number Generator (CSPRNG) Cryptographically Secure .

Jawaban sederhana, aman, dan benar adalah dengan menggunakan RandomLib dan jangan menemukan kembali kemudi.

Bagi Anda yang bersikeras menciptakan solusi Anda sendiri, PHP 7.0.0 akan menyediakan random_int()untuk tujuan ini; jika Anda masih menggunakan PHP 5.x, kami menulis polyfill PHP 5 untukrandom_int() sehingga Anda dapat menggunakan API baru bahkan sebelum Anda meningkatkan ke PHP 7.

Menghasilkan bilangan bulat acak dengan aman di PHP bukanlah tugas yang sepele. Anda harus selalu berkonsultasi dengan pakar kriptografi StackExchange tempat tinggal Anda sebelum menerapkan algoritme buatan sendiri dalam produksi.

Dengan generator integer yang aman, menghasilkan string acak dengan CSPRNG adalah jalan-jalan di taman.

Membuat String yang Aman dan Acak

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

Penggunaan :

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

Demo : https://3v4l.org/IMJGF (Abaikan kegagalan PHP 5; perlu random_compat)

Ini menciptakan string heksadesimal sepanjang 20 karakter:

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

Dalam 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: jawaban Anda berhasil untuk saya. Saya memiliki masalah yang sama, dan saya akan menyarankannya untuk mereka yang pernah mencari jawaban yang sama. Ini dia dari @tasmaniski:

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

Ini adalah video youtube yang menunjukkan kepada kita cara membuat angka acak

Bergantung pada aplikasi Anda (saya ingin menghasilkan kata sandi), Anda dapat menggunakannya

$string = base64_encode(openssl_random_pseudo_bytes(30));

Menjadi base64, mereka dapat berisi =atau -juga karakter yang diminta. Anda dapat membuat string yang lebih panjang, lalu filter dan potong untuk menghilangkannya.

openssl_random_pseudo_bytestampaknya menjadi cara yang disarankan untuk menghasilkan angka acak yang tepat di php. Kenapa randtidak pakai /dev/randomsaya tidak tahu.

Berikut ini adalah satu-liner sederhana yang menghasilkan string acak yang benar tanpa perulangan level script atau penggunaan pustaka OpenSSL.

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

Untuk memecahnya sehingga parameternya jelas

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

Metode ini bekerja dengan mengulangi daftar karakter secara acak, kemudian mengocok string gabungan, dan mengembalikan jumlah karakter yang ditentukan.

Anda selanjutnya dapat mengacak ini, dengan mengacak panjang string yang dikembalikan, menggantikannya $chrRandomLengthdengan mt_rand(8, 15)(untuk string acak antara 8 dan 15 karakter).

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

Tada!

Cara yang lebih baik untuk mengimplementasikan fungsi ini adalah:

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_randlebih acak menurut ini dan ini di PHP 7. randFungsi ini adalah alias mt_rand.

$randstringdalam lingkup fungsi tidak sama dengan ruang lingkup tempat Anda memanggilnya. Anda harus menetapkan nilai kembali ke variabel.

$randstring = RandomString();
echo $randstring;

Atau langsung gandakan nilai kembali:

echo RandomString();

Juga, dalam fungsi Anda, Anda memiliki sedikit kesalahan. Di dalam for loop, Anda perlu menggunakan .=agar setiap karakter ditambahkan ke string. Dengan menggunakan =Anda menimpanya dengan setiap karakter baru alih-alih menambahkan.

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

Pertama, Anda mendefinisikan alfabet yang ingin Anda gunakan:

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

Kemudian, gunakan openssl_random_pseudo_bytes()untuk menghasilkan data acak yang tepat:

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

Akhirnya, Anda menggunakan data acak ini untuk membuat kata sandi. Karena setiap karakter di $randomdapat chr(0)sampai chr(255), kode menggunakan sisa setelah pembagian nilai ordinalnya dengan $alphabet_lengthuntuk memastikan hanya karakter dari alfabet yang dipilih (perhatikan bahwa melakukan hal itu bias keacakan):

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

Atau, dan umumnya lebih baik, adalah dengan menggunakan RandomLib dan SecurityLib :

use SecurityLib\Strength;

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

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

Metode Pendek ..

Berikut adalah beberapa metode terpendek untuk menghasilkan string acak

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

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

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

Saya telah menguji kinerja fungsi paling populer di sana, waktu yang diperlukan untuk menghasilkan 1'000'000 string 32 simbol pada kotak saya adalah:

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

Harap dicatat, tidak penting berapa lama itu sebenarnya tetapi mana yang lebih lambat dan mana yang lebih cepat sehingga Anda dapat memilih sesuai dengan kebutuhan Anda termasuk kesiapan kriptografi, dll.

substr () sekitar MD5 ditambahkan demi akurasi jika Anda membutuhkan string yang lebih pendek dari 32 simbol.

Demi jawaban: string tidak disatukan tetapi ditimpa dan hasil fungsi tidak disimpan.

PHP 7+ Hasilkan byte acak yang aman secara kriptografis menggunakan fungsi random_bytes .

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

Output yang mungkin

da821217e61e33ed4b2dd96f8439056c

PHP 5.3+ Hasilkan byte pseudo-acak menggunakan fungsi openssl_random_pseudo_bytes .

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

Output yang mungkin

e2d1254506fbb6cd842cd640333214ad

The Kasus penggunaan terbaik bisa

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

Output yang mungkin

ba8cc342bdf91143

Salah satu cara yang sangat cepat adalah melakukan sesuatu seperti:

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

Ini akan menghasilkan string acak dengan panjang 10 karakter. Tentu saja, beberapa orang mungkin mengatakan itu sedikit lebih berat di sisi perhitungan, tetapi saat ini prosesor dioptimalkan untuk menjalankan algoritma md5 atau sha256 dengan sangat cepat. Dan tentu saja, jika rand()fungsi mengembalikan nilai yang sama, hasilnya akan sama, memiliki peluang 1/32767 menjadi sama. Jika keamanan adalah masalah, maka ubah saja rand()kemt_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;
}

Yang ini diambil dari sumber admin :

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

Adminer , alat manajemen basis data yang ditulis dalam PHP.

Fungsi pembantu dari kerangka 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);
}

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

Versi fungsi yang diedit berfungsi dengan baik, tetapi hanya ada satu masalah yang saya temukan: Anda menggunakan karakter yang salah untuk menyertakan $ karakter, jadi karakter 'kadang-kadang bagian dari string acak yang dihasilkan.

Untuk memperbaiki ini, ubah:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

untuk:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

Dengan cara ini hanya karakter tertutup yang digunakan, dan karakter 'tidak akan pernah menjadi bagian dari string acak yang dihasilkan.

Satu garis lainnya, yang menghasilkan string acak 10 karakter dengan huruf dan angka. Ini akan membuat array dengan range(sesuaikan parameter kedua untuk mengatur ukuran), lompati array ini dan berikan karakter ASCII acak (rentang 0-9 atau az), kemudian implode array untuk mendapatkan string.

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

Catatan: ini hanya berfungsi di PHP 5.3 dan yang lebih baru

Satu liner

Cepat untuk string besar dengan beberapa keunikan.

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

Sejak php7, ada fungsi random_bytes. https://www.php.net/manual/ru/function.random-bytes.php Jadi Anda dapat menghasilkan string acak seperti itu

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

Saya menyukai komentar terakhir yang menggunakan openssl_random_pseudo_bytes, tapi itu bukan solusi bagi saya karena saya masih harus menghapus karakter yang tidak saya inginkan, dan saya tidak bisa mendapatkan string set panjang. Inilah solusi saya ...

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

Inilah solusi satu baris sederhana saya untuk menghasilkan kata sandi acak ramah yang digunakan, tidak termasuk karakter yang mirip seperti "1" dan "l", "O" dan "0", dll ... di sini adalah 5 karakter tetapi Anda dapat dengan mudah ubah saja:

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

Ini solusi lain.

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. Saya menggunakan PHP 7.2 di Ubuntu.

Cara lain untuk menghasilkan string acak di PHP adalah:

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

Inilah cara saya melakukannya untuk mendapatkan kunci acak unik unik:

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

Anda dapat menggunakan waktu () karena ini adalah cap waktu Unix dan selalu unik dibandingkan dengan acak lainnya yang disebutkan di atas. Anda kemudian dapat menghasilkan md5sum itu dan mengambil panjang yang Anda inginkan dari MD5 yang dihasilkan string . Dalam hal ini saya menggunakan 10 karakter, dan saya bisa menggunakan string yang lebih panjang jika saya ingin membuatnya lebih unik.

Saya harap ini membantu.

Parametrised one-liner hanya menggunakan fungsi asli PHP , bekerja sejak 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))))))