ฉันกำลังพยายามสร้างสตริงแบบสุ่มใน PHP และฉันก็ไม่ได้รับผลลัพธ์ใด ๆ จากสิ่งนี้:

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

    RandomString();
    echo $randstring;

ผมทำอะไรผิดหรือเปล่า?

ในการตอบคำถามนี้โดยเฉพาะมีสองปัญหา:

1. $randstring ไม่ได้อยู่ในขอบเขตเมื่อคุณสะท้อน
2. อักขระไม่ได้ถูกต่อกันเข้าด้วยกันในลูป

นี่คือข้อมูลโค้ดที่มีการแก้ไข:

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

ส่งออกสตริงสุ่มด้วยการโทรด้านล่าง:

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

โปรดทราบว่านี่จะสร้างสตริงสุ่มที่คาดเดาได้ หากคุณต้องการสร้างโทเค็นที่ปลอดภัยดูคำตอบนี้

หมายเหตุ: str_shuffle()ใช้ภายในrand()ซึ่งไม่เหมาะสมสำหรับวัตถุประสงค์การเข้ารหัส (เช่นการสร้างรหัสผ่านแบบสุ่ม) คุณต้องการตัวสร้างตัวเลขสุ่มที่ปลอดภัยแทน นอกจากนี้ยังไม่อนุญาตให้ใช้อักขระซ้ำ

อีกวิธีหนึ่ง

อัพเดท (ตอนนี้สิ่งนี้จะสร้างความยาวของสตริง):

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

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

แค่นั้นแหละ. :)

มีคำตอบมากมายสำหรับคำถามนี้ แต่ไม่มีคำตอบใดที่สร้างCryptographically Secure Pseudo-Random Number Generator (CSPRNG)

คำตอบที่ง่ายปลอดภัยและถูกต้องคือใช้RandomLibและไม่ต้องพลิกโฉมพวงมาลัย

สำหรับบรรดาของคุณที่ยืนยันในการคิดค้นวิธีการแก้ปัญหาของคุณเอง PHP 7.0.0 จะจัดให้มีrandom_int()เพื่อวัตถุประสงค์นี้ หากคุณยังใช้ PHP 5.x อยู่เราเขียนPHP 5 polyfill ไว้random_int()ให้คุณสามารถใช้ API ใหม่ก่อนที่คุณจะอัปเกรดเป็น PHP 7

การสร้างจำนวนเต็มแบบสุ่มอย่างปลอดภัยใน PHPไม่ใช่เรื่องง่าย คุณควรตรวจสอบกับผู้เชี่ยวชาญด้านการเข้ารหัส StackExchange ถิ่นที่อยู่ของคุณก่อนที่จะปรับใช้อัลกอริทึมที่ปลูกเองในการผลิต

ด้วยเครื่องกำเนิดจำนวนเต็มที่ปลอดภัยในสถานที่สร้างสตริงแบบสุ่มด้วย CSPRNG คือการเดินเล่นในสวนสาธารณะ

การสร้างสตริงที่ปลอดภัยและสุ่ม

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

การใช้งาน :

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

การสาธิต : https://3v4l.org/IMJGF (ละเว้นความล้มเหลวของ PHP 5 จำเป็นต้องใช้ random_compat)

สิ่งนี้จะสร้างสตริงเลขฐานสิบหกแบบยาว 20 ตัว:

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

ใน 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: คำตอบของคุณใช้ได้กับฉัน ฉันมีปัญหาเดียวกันและฉันอยากจะแนะนำสำหรับผู้ที่กำลังมองหาคำตอบเดียวกัน นี่คือจาก @tasmaniski:

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

นี่คือวิดีโอ youtube แสดงวิธีสร้างหมายเลขสุ่ม

ขึ้นอยู่กับแอปพลิเคชันของคุณ (ฉันต้องการสร้างรหัสผ่าน) คุณสามารถใช้

$string = base64_encode(openssl_random_pseudo_bytes(30));

เป็น base64 พวกมันอาจมี=หรือ-รวมถึงตัวละครที่ขอ คุณสามารถสร้างสตริงที่ยาวกว่าได้จากนั้นกรองและตัดแต่งเพื่อลบสตริงเหล่านั้น

openssl_random_pseudo_bytesน่าจะเป็นวิธีที่แนะนำในการสร้างตัวเลขสุ่มที่เหมาะสมใน php ทำไมrandไม่ใช้/dev/randomฉันไม่รู้

นี่คือหนึ่งซับง่ายๆที่สร้างสตริงแบบสุ่มที่แท้จริงโดยไม่มีการวนลูประดับสคริปต์หรือใช้ไลบรารี OpenSSL

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

ที่จะทำลายมันลงเพื่อให้พารามิเตอร์มีความชัดเจน

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

วิธีนี้ใช้ได้โดยการสุ่มรายชื่อตัวละครซ้ำจากนั้นจะสับสตริงที่รวมกันแล้วส่งกลับจำนวนอักขระที่ระบุ

คุณสามารถสุ่มเพิ่มเติมโดยสุ่มความยาวของสตริงที่ส่งคืนแทนที่$chrRandomLengthด้วยmt_rand(8, 15)(สำหรับสตริงสุ่มระหว่าง 8 และ 15 ตัวอักษร)

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

Tada!

วิธีที่ดีกว่าในการใช้ฟังก์ชั่นนี้คือ:

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เป็นแบบสุ่มมากขึ้นตามนี้และนี้ใน PHP 7. ฟังก์ชั่นเป็นนามแฝงของrandmt_rand

$randstringในขอบเขตของฟังก์ชั่นไม่เหมือนกับขอบเขตที่คุณเรียกใช้ คุณต้องกำหนดค่าส่งคืนให้กับตัวแปร

$randstring = RandomString();
echo $randstring;

หรือเพียงแค่สะท้อนผลตอบแทนโดยตรง:

echo RandomString();

นอกจากนี้ในการทำงานของคุณคุณมีข้อผิดพลาดเล็กน้อย ภายใน for for loop คุณต้องใช้.=เพื่อให้ตัวละครแต่ละตัวต่อท้ายสตริง โดยการใช้งาน=คุณกำลังเขียนทับมันด้วยตัวละครใหม่แต่ละตัวแทนการต่อท้าย

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

ก่อนอื่นคุณต้องกำหนดตัวอักษรที่คุณต้องการใช้:

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

จากนั้นใช้openssl_random_pseudo_bytes()เพื่อสร้างข้อมูลสุ่มที่เหมาะสม:

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

สุดท้ายคุณใช้ข้อมูลสุ่มนี้เพื่อสร้างรหัสผ่าน เนื่องจากอักขระแต่ละตัว$randomสามารถอยู่ได้chr(0)จนถึงchr(255)รหัสจึงใช้ส่วนที่เหลือหลังจากการหารค่าตามลำดับด้วย$alphabet_lengthเพื่อให้แน่ใจว่ามีการเลือกเฉพาะอักขระจากตัวอักษร (โปรดทราบว่าการทำแบบอคติเป็นการสุ่ม):

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

อีกวิธีหนึ่งและโดยทั่วไปดีกว่าคือใช้RandomLibและSecurityLib :

use SecurityLib\Strength;

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

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

วิธีการสั้น ..

ต่อไปนี้เป็นวิธีที่สั้นที่สุดในการสร้างสตริงแบบสุ่ม

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

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

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

ฉันได้ทดสอบประสิทธิภาพของฟังก์ชั่นยอดนิยมที่นั่นเวลาที่จำเป็นสำหรับการสร้าง 1'000'000 สายอักขระ 32 สัญลักษณ์ในกล่องของฉันคือ:

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

โปรดทราบว่ามันไม่สำคัญว่ามันจะนานแค่ไหน แต่จะช้ากว่ากันและเร็วกว่าเพื่อให้คุณสามารถเลือกได้ตามความต้องการของคุณรวมถึงความพร้อมด้านการเข้ารหัสและอื่น ๆ

substr () รอบ MD5 ถูกเพิ่มเพื่อความถูกต้องถ้าคุณต้องการสายอักขระที่สั้นกว่า 32 สัญลักษณ์

เพื่อประโยชน์ในการตอบ: สตริงไม่ถูกต่อกัน แต่ถูกเขียนทับและผลลัพธ์ของฟังก์ชันไม่ถูกเก็บไว้

PHP 7+สร้างไบต์สุ่มแบบเข้ารหัสที่ปลอดภัยโดยใช้ฟังก์ชันrandom_bytes

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

ผลลัพธ์ที่เป็นไปได้

da821217e61e33ed4b2dd96f8439056c

PHP 5.3+สร้างไบต์สุ่มโดยใช้ฟังก์ชันopenssl_random_pseudo_bytes

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

ผลลัพธ์ที่เป็นไปได้

e2d1254506fbb6cd842cd640333214ad

กรณีการใช้งานที่ดีที่สุดอาจจะเป็น

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

ผลลัพธ์ที่เป็นไปได้

ba8cc342bdf91143

วิธีหนึ่งที่รวดเร็วมากคือการทำสิ่งที่ชอบ:

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

สิ่งนี้จะสร้างสตริงแบบสุ่มที่มีความยาว 10 ตัวอักษร แน่นอนว่าบางคนอาจบอกว่ามันหนักกว่านิดหน่อยในด้านการคำนวณ แต่ทุกวันนี้โปรเซสเซอร์ได้รับการปรับให้เหมาะกับการรันอัลกอริทึม md5 หรือ sha256 อย่างรวดเร็ว และแน่นอนถ้าrand()ฟังก์ชันส่งคืนค่าเดียวกันผลลัพธ์จะเหมือนกันโดยมีโอกาส 1/32767 ในการเป็นแบบเดียวกัน หากความปลอดภัยเป็นปัญหาคุณควรเปลี่ยนrand()เป็นmt_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;
}

สิ่งนี้นำมาจากแหล่งที่มาของผู้ดูแลระบบ :

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

Adminerเครื่องมือการจัดการฐานข้อมูลที่เขียนใน PHP

ฟังก์ชั่นตัวช่วยจากเฟรมเวิร์ก 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);
}

แหล่งที่มาจากhttp://www.xeweb.net/2011/02/11/generate-a-random-string-az-0-9-in-php/

รุ่นที่แก้ไขของฟังก์ชั่นทำงานได้ดี แต่มีเพียงปัญหาเดียวที่ฉันพบ: คุณใช้อักขระที่ไม่ถูกต้องเพื่อใส่ $ อักขระดังนั้นบางครั้งอักขระ 'จึงเป็นส่วนหนึ่งของสตริงสุ่มที่สร้างขึ้น

ในการแก้ไขปัญหานี้ให้เปลี่ยน:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

ถึง:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

วิธีนี้ใช้เฉพาะอักขระที่ล้อมรอบและอักขระ 'จะไม่เป็นส่วนหนึ่งของสตริงแบบสุ่มที่สร้างขึ้น

อีกหนึ่งซับซึ่งสร้างสตริงสุ่ม 10 ตัวอักษรด้วยตัวอักษรและตัวเลข มันจะสร้างอาร์เรย์ด้วยrange(ปรับพารามิเตอร์ที่สองเพื่อกำหนดขนาด) วนรอบอาร์เรย์นี้และกำหนดอักขระ ASCII แบบสุ่ม (ช่วง 0-9 หรือ az) จากนั้นฝังอาร์เรย์เพื่อรับสตริง

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

หมายเหตุ: ใช้งานได้ใน PHP 5.3 และใหม่กว่าเท่านั้น

หนึ่งในสายการบิน.

มันเร็วสำหรับสตริงขนาดใหญ่ที่มีเอกลักษณ์บางอย่าง

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

ตั้งแต่ php7 มีฟังก์ชั่น random_bytes https://www.php.net/manual/ru/function.random-bytes.php ดังนั้นคุณสามารถสร้างสตริงแบบสุ่มได้

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

ฉันชอบความคิดเห็นล่าสุดที่ใช้ openssl_random_pseudo_bytes แต่มันไม่ใช่วิธีแก้ปัญหาสำหรับฉันเพราะฉันยังต้องลบอักขระที่ฉันไม่ต้องการและฉันไม่สามารถรับความยาวของชุดสตริงได้ นี่คือทางออกของฉัน ...

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

นี่คือโซลูชันบรรทัดเดียวที่เรียบง่ายของฉันในการสร้างรหัสผ่านแบบสุ่มที่ใช้งานง่ายยกเว้นตัวละครที่มีลักษณะคล้ายกันเช่น "1" และ "l", "O" และ "0" ฯลฯ ... ที่นี่คือ 5 ตัวอักษร แต่คุณสามารถ เปลี่ยนแน่นอน:

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

นี่คือทางออกอื่น

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 ฉันใช้ PHP 7.2 บน Ubuntu

อีกวิธีในการสร้างสตริงแบบสุ่มใน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);

นี่คือวิธีที่ฉันทำเพื่อรับคีย์สุ่มที่ไม่ซ้ำกันจริง:

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

คุณสามารถใช้ time () เนื่องจากเป็นเวลา Unix และจะไม่ซ้ำกันเสมอเมื่อเทียบกับการสุ่มอื่น ๆ ที่กล่าวถึงข้างต้น จากนั้นคุณสามารถสร้าง md5sum จากนั้นและใช้ความยาวที่ต้องการที่คุณต้องการจากMD5 ที่สร้างขึ้นสตริงในกรณีนี้ฉันใช้อักขระ 10 ตัวและฉันสามารถใช้สตริงที่ยาวกว่านี้ได้ถ้าฉันต้องการทำให้มันมีความพิเศษมากขึ้น

ฉันหวังว่านี่จะช่วยได้.

Parametrised หนึ่งซับใช้ฟังก์ชั่นพื้นเมือง PHPเท่านั้นทำงานตั้งแต่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))))))