要具体回答这个问题，有两个问题：

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

请注意，这会生成可预测的随机字符串。如果您想创建安全令牌，请参阅此答案

函数作用域中的$randstring与调用它的作用域不同。您必须将返回值分配给变量。

$randstring = RandomString();echo $randstring;

或者直接回显返回值：

echo RandomString();

此外，在您的函数中，您有一个小错误。在for循环中，您需要使用.=，以便每个字符都附加到字符串中。通过使用=，您可以用每个新字符覆盖它，而不是附加。

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

该函数的编辑版本运行良好，但我发现只有一个问题：您使用了错误的字符来包围$字符，因此'字符有时是生成的随机字符串的一部分。

要解决此问题，请更改：

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

到：

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

这样，只使用封闭字符，'字符永远不会成为生成的随机字符串的一部分。

实现此功能的更好方法是：

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中的这个和这个更随机。rand函数是mt_rand的别名。

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

注意：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)

就是这样：）

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

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

多田！

根据您的应用程序（我想生成密码），您可以使用

$string = base64_encode(openssl_random_pseudo_bytes(30));

作为bas64，它们可能包含=或-以及请求的字符。您可以生成一个更长的字符串，然后过滤和修剪它以删除这些字符串。

openssl_random_pseudo_bytes似乎是在php中生成适当随机数的推荐方法。为什么rand不使用/dev/random我不知道。

@tasmaniski：你的回答对我很有效。我也有同样的问题，我会建议那些一直在寻找同样答案的人。以下是来自@tasmaniski的：

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

这里有一个YouTube视频向我们展示了如何创建随机数

我喜欢使用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;}

以下是我如何获得真正唯一的随机密钥：

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

你可以使用time（），因为它是一个Unix时间戳，与上面提到的其他随机时间戳相比总是唯一的。然后，你可以生成它的md5sum，并从生成的MD5字符串中获取所需的长度。在这种情况下，我使用了10个字符，如果我想让它更独特，我可以使用更长的字符串。

我希望这能有所帮助。

function randomName($length = 8) {$values = array_merge(range(65, 90), range(97, 122), range(48, 57));$max = count($values) - 1;$str = chr(mt_rand(97, 122));for ($i = 1; $i < $length; $i++) {$str .= chr($values[mt_rand(0, $max)]);}return $str;}

function randomString() {return md5(rand(100, 200));}

如果您在用户可能会看到或使用它的地方使用此随机字符串（例如作为密码生成器，您可能希望限制用于排除元音的字符集。这样您就不会意外生成坏话并冒犯某人。不要笑它会发生。

我说把最好的几个答案放在一起-str_suffle和范围对我来说是新的：

echo generateRandomString(25); // Example of calling it
function generateRandomString($length = 10) {return substr(str_shuffle(implode(array_merge(range(0,9), range('A', 'Z'), range('a', 'z')))), 0, $length);}

如果你需要大量没有重复的随机字符串，这是一个经过小修改的递归代码：

function generateRandomString($length = 10){global $generatedStrings;$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';$randomString = '';for ($i = 0; $i < $length; $i++) {$randomString .= $characters[rand(0, strlen($characters) - 1)];}if (isset($generatedStrings[$randomString])) {$randomString = generateRandomString($length);}$generatedStrings[$randomString] = $randomString;return $randomString;}
$generatedStrings = array();
foreach(range(1, 100000) as $num) {echo "\n".$num."\t : ".generateRandomString();}

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}

一个快速的方法是这样做：

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

这将生成一个长度为10个字符的随机字符串。当然，有些人可能会说它在计算方面有点重，但现在的处理器已经优化为快速运行md5或sha256算法。当然，如果rand()函数返回相同的值，结果将是相同的，有1/32767的几率是相同的。如果安全是问题，那么只需将rand()更改为mt_rand()

试试这个：

function generate_name ($length = LENGTH_IMG_PATH) {$image_name = "";$possible = "0123456789abcdefghijklmnopqrstuvwxyz";
$i = 0;
while ($i < $length) {
$char = substr($possible, mt_rand(0, strlen($possible)-1), 1);
if (!strstr($image_name, $char)) {$image_name .= $char;$i++;}}return $image_name;}

$pass = "";for ($i=0;$i<12;++$i)$pass.= ($r=mt_rand(0,35))<26?chr(ord('a')+$r):chr(ord('0')+$r-26);

首先，定义要使用的字母表：

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

然后，使用openssl_random_pseudo_bytes()生成适当的随机数据：

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

最后，你使用这个随机数据来创建密码。因为$random中的每个字符在chr(255)之前都可以是chr(0)，所以代码使用其序数值与$alphabet_length相除后的余数来确保只选择字母表中的字符（请注意这样做会影响随机性）：

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

或者，通常更好，是使用随机库和安全库名称：

use SecurityLib\Strength;
$factory = new RandomLib\Factory;$generator = $factory->getGenerator(new Strength(Strength::MEDIUM));
$password = $generator->generateString(12, $alphabet);

这是一个简单的一行代码，它生成一个真正的随机字符串，无需任何脚本级别的循环或使用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个字符之间的随机字符串）。

另一个单行程序生成一个包含10个字母和数字的随机字符串。它将创建一个带有range的数组（调整第二个参数以设置大小），循环该数组并分配一个随机ASCII字符（范围0-9或a-z），然后内爆数组以获得一个字符串。

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

注意：这仅适用于PHP 5.3及更高版本

这将创建一个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

$t = array_merge(range('0', '9'), range('a', 'z'), range('A', 'Z'));echo join('', array_map(function() use($t) { return $t[array_rand($t)]; }, range(1, 15)));

或单行

echo join('', array_map(function() { return substr('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', rand(0, 61), 1); }, range(1, 15)));

我一直喜欢使用base 64来生成随机密码或其他随机（可打印）字符串。Base64的使用确保了大量可打印字符可用。

在shell上，我通常会这样做：

base64 < /dev/urandom |head -c10

在PHP中也可以做类似的事情。然而，open_basedir限制可能会禁止直接从 /dev/urandom读取。所以这就是我的结论：

base64_encode(join('',array_map(function($x){ return chr(mt_rand(1,255));},range(1,15))));

为了得到一个真正随机的字符串，我们也需要随机输入。这就是join/array_map所做的。使用像uniqid这样的东西是不够的，因为它总是有一个类似的前缀，因为它基本上是一个美化的时间戳。

如果您安装了openssl扩展，当然可以使用openssl_random_pseudo_bytes()代替，这会更好。

来源：生成随机字符的PHP函数

这个PHP函数为我工作：

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

用法：

echo cvf_ps_generate_random_code(5);

Laravel 5框架中的Helper函数

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

一个衬里。

对于具有一些独特性的巨大字符串来说，它是快速的。

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

这个问题有很多答案，但没有一个利用加密安全的伪随机数生成器（CSPRNG）。

简单、安全和正确的答案是使用随机库，不要重新发明轮子。

对于那些坚持发明自己的解决方案的人，PHP 7.0.0将为此提供random_int()；如果你还在使用PHP 5. x，我们编写了PHP 5的多边形#0，这样你甚至可以在升级到PHP 7之前使用新的API。

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

Demo：https://3v4l.org/IMJGF（忽略PHP 5失败；它需要random_compat）

要在单行中获取它，请尝试以下操作：

$str = substr(str_shuffle(str_repeat("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 5)), 0, $length);

以下函数生成长度为任何的伪字符串。

/*** Returns random string of a given length.*/function get_random_string($length) {$pull = [];while (count($pull) < $length) {$pull = array_merge($pull, range(0, 9), range('a', 'z'), range('A', 'Z'));}shuffle($pull);return substr(implode($pull), 0, $length);}

以前的答案生成不安全或难以键入的密码。

这个是安全的，并提供了一个用户更有可能实际使用的密码，而不是因为一些弱的东西而被丢弃。

// NOTE: On PHP 5.x you will need to install https://github.com/paragonie/random_compat
/*** Generate a password that can easily be typed by users.** By default, this will sacrifice strength by skipping characters that can cause* confusion. Set $allowAmbiguous to allow these characters.*/static public function generatePassword($length=12, $mixedCase=true, $numericCount=2, $symbolCount=1, $allowAmbiguous=false, $allowRepeatingCharacters=false){// sanity check to prevent endless loopif ($numericCount + $symbolCount > $length) {throw new \Exception('generatePassword(): $numericCount + $symbolCount are too high');}
// generate a basic password with just alphabetic characters$chars  = 'qwertyupasdfghjkzxcvbnm';if ($mixedCase) {$chars .= 'QWERTYUPASDFGHJKZXCVBNML';}if ($allowAmbiguous) {$chars .= 'iol';if ($mixedCase) {$chars .= 'IO';}}
$password = '';foreach (range(1, $length) as $index) {$char = $chars[random_int(0, strlen($chars) - 1)];
if (!$allowRepeatingCharacters) {while ($char == substr($password, -1)) {$char = $chars[random_int(0, strlen($chars) - 1)];}}
$password .= $char;}

// add numeric characters$takenSubstitutionIndexes = [];
if ($numericCount > 0) {$chars = '23456789';if ($allowAmbiguous) {$chars .= '10';}
foreach (range(1, $numericCount) as $_) {$index = random_int(0, strlen($password) - 1);while (in_array($index, $takenSubstitutionIndexes)) {$index = random_int(0, strlen($password) - 1);}
$char = $chars[random_int(0, strlen($chars) - 1)];if (!$allowRepeatingCharacters) {while (substr($password, $index - 1, 1) == $char || substr($password, $index + 1, 1) == $char) {$char = $chars[random_int(0, strlen($chars) - 1)];}}
$password[$index] = $char;$takenSubstitutionIndexes[] = $index;}}
// add symbols$chars = '!@#$%&*=+?';if ($allowAmbiguous) {$chars .= '^~-_()[{]};:|\\/,.\'"`<>';}
if ($symbolCount > 0) {foreach (range(1, $symbolCount) as $_) {$index = random_int(0, strlen($password) - 1);while (in_array($index, $takenSubstitutionIndexes)) {$index = random_int(0, strlen($password) - 1);}
$char = $chars[random_int(0, strlen($chars) - 1)];if (!$allowRepeatingCharacters) {while (substr($password, $index - 1, 1) == $char || substr($password, $index + 1, 1) == $char) {$char = $chars[random_int(0, strlen($chars) - 1)];}}
$password[$index] = $char;$takenSubstitutionIndexes[] = $index;}}
return $password;}

这是取自管理员来源的：

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

管理员，用PHP编写的数据库管理工具。

有一个简单的代码：

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

有一个简单的指南：

• 要更改弦长，请仅将16更改为另一个值。
• 要从不同字符中进行选择，请更改字符串。

function randomString($length = 5) {return substr(str_shuffle(implode(array_merge(range('A','Z'), range('a','z'), range(0,9)))), 0, $length);}

短方法…

这里有一些最短的方法来生成随机字符串

<?phpecho $my_rand_strng = substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), -15);
echo substr(md5(rand()), 0, 7);
echo str_shuffle(MD5(microtime()));?>

你完全错了，因为你依赖于数字，而不是字符，我不确定你是否希望随机输出只是数字，如果是这样，为什么需要获取所有字母和所有数字并提取它们的长度？为什么不使用rand(0, 62)？，即使你在声明函数之前忘记初始化变量$randstring。

无论如何，PHP为此提供了一个非常方便的函数。它是str_shuffle()。这是一个适合您需要的示例。

<?php
function randomString() {$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';return str_shuffle($characters);}echo randomString();

最后，我找到了一个解决方案，以获得随机和唯一的值。

我的解决方案是：

substr(md5(time()), 0, 12)

time总是返回一个时间戳，它总是唯一的。您可以将它与MD5一起使用以使其更好。

具有上面讨论中的一些功能的类。

$options['numeric'] = true;$options['uppercase'] = true;$options['lowercase'] = true;$new = new RandomString($options);
class RandomString{/*** @var array*/private $default = ['numeric' => true, 'uppercase' => true, 'lowercase' => true];
/*** @var array*/private $options;
/*** array*/private $whitelist = ['numeric', 'uppercase', 'lowercase'];
/*** RandomString constructor.** @param array $options*/public function __construct(array $options = []){$this->options = $this->default;if(!empty($options)){$options = array_intersect_key($options, array_flip($this->whitelist));if(empty($options)){$this->options = $this->default;}else{$this->options = $options;}}}
/*** @return string*/private function returnCharacters(){
$options = $this->options;
$numbers = '0123456789';$uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';$lowercase = "abcdefghijklmnopqrstuvwxyz";
$characters = '';if(isset($options['numeric']) && $options['numeric'] === true){$characters .= $numbers;}
if(isset($options['uppercase']) && $options['uppercase'] === true){$characters .= $uppercase;}
if(isset($options['lowercase']) && $options['lowercase'] === true){$characters .= $lowercase;}return $characters;}
/*** @param $length* @param $quantity* @return string*/public function randomString($length, $quantity) {
$string = '';$characters = $this->returnCharacters();
for ($j = 0; $j < $quantity; $j++) {for($i = 0; $i < $length; $i++){$string .= $characters[mt_rand(0, strlen($characters) - 1)];}$string .= "\n";}return $string;}
/*** @return array*/public function getOptions(){return $this->options;}
/*** @return mixed*/public function getWhitelist(){return $this->whitelist;}

你可以试试这个：

<?phpfunction random($len){
$char = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
// ----------------------------------------------// Number of possible combinations// ----------------------------------------------$pos = strlen($char);$pos = pow($pos, $len);echo $pos.'<br>';// ----------------------------------------------
$total = strlen($char)-1;$text = "";
for ($i=0; $i<$len; $i++){$text = $text.$char[rand(0, $total)];}return $text;}
$string = random(15);echo $string;?>

您也可以按时使用md5，但要小心。

您需要使用microtime()而不是time()函数，因为如果多个线程在同一秒内运行，您需要为所有线程获取不同的字符串。

<?php
$string = md5(microtime());echo $string;?>

我已经测试了那里最流行的函数的性能，在我的盒子上生成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);

请注意，它实际上是多长时间并不重要，而是哪个更慢，哪个更快，因此您可以根据您的要求进行选择，包括加密准备等。

如果您需要短于32个符号的字符串，为了准确起见，在MD5周围添加了substr（）。

为了回答：字符串没有连接，而是被覆盖，函数的结果没有存储。

仅使用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))))))

/*** @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-a-z-0-9-in-php/

单线解决方案将是

str_shuffle(base64_encode(date('mdyhis').date('mdyhis')));

在此方法中，您可以在创建时选择字符长度。

<?php$random_string = "";$character_count = 12;for($i=1; $i <= $character_count; $i++){$random_string .= chr(rand(97, 122));}echo $random_string;?>

这是一行代码。您将获得至少一个小写、一个大写、一个数字和一个符号。使用random_int，它应该是密码学安全的。不过，我并不声称这是安全的。我不是安全专家。

复制+粘贴：（只需将$len更改为所需的长度。）

$len=26;for ($chars = array('0123456789','abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ','!@#$%^&*()_+-='),$randomString="",$i=0;$i<$len;$i++)$randomString .= substr($chars[$i%4], random_int(0,strlen($chars[$i%4])), 1);echo $randomString;

再稍微分解一下：

for ($chars = array('0123456789','abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ','!@#$%^&*()_+-='),$randomString="",$i=0;$i<12;$i++)$randomString .=substr($chars[$i%4],random_int(0, strlen($chars[$i%4])), 1);

我在循环中使用$chars[$i%4]来选择从哪一组字符中获得随机字符。它保证数组中的每一组字符都有多个字符。

它肯定可以改进（随机化每个char集的数量），但对于我的目的来说已经足够好了。

请尝试这个我的函数来生成一个自定义的随机字母数字字符串：

<?phpfunction random_alphanumeric($length) {$chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345689';$my_string = '';for ($i = 0; $i < $length; $i++) {$pos = mt_rand(0, strlen($chars) -1);$my_string .= substr($chars, $pos, 1);}return $my_string;}?>

你可以通过将字符串的长度传递给函数来调整结果，如下所示：

  $test_with_50_items = random_alphanumeric(50); // 50 charactersecho $test_with_50_items;

示例（test_with_50_items）：Y1FypdjVbFCFK6Gh9FDJpe6dciwJEfV6MQGpJqAfuijaYSZ86

如果您需要超过50个字符或更少，只需按照自己的喜好调用函数：

  $test_with_27_items = random_alphanumeric(27); // 27 charactersecho $test_with_27_items;

如果你需要两个或多个唯一的字符串，你可以使用while循环，这样你就可以得到两个唯一的字符串……你可以用更多的字符串做同样的事情，唯一的限制是你的幻想……

  $string_1 = random_alphanumeric(50);$string_2 = random_alphanumeric(50);while ($string_1 == $string_2) {$string_1 = random_alphanumeric(50);$string_2 = random_alphanumeric(50);if ($string_1 != $string_2) {break;}}echo $string_1;echo "<br>\n";echo $string_2;

$string_1：KkvUwia8rbDEV2aChWqm3AgeUZqyrRbUx2AxVhx5s4TSJ2VwA4

$string_2：XraO85YfxBBCInafvwipSOJwLmk6JMWiuWOxYQDnXohcn2D8K6

function strgen($len) {$buf = '';for ($i = 0; $i < $len; $i++) {$j = mt_rand(0, 61);if ($j >= 36) {$j += 13;} else if ($j >= 10) {$j += 7;}$buf .= chr(48 + $j);}return $buf;}

简单而优雅。

你的代码有3个错误：

1. $randstring没有分配给任何东西（仅在超出范围的函数内部）。
2. 随机字符串只返回最后一个随机字符。将=替换为.=。
3. Rand不会生成加密安全的伪随机数。请改用random_int。

见下图：

<?phpfunction RandomString(){$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';$randstring = '';for ($i = 0; $i < 10; $i++) {$randstring .= $characters[random_int(0, strlen($characters))];}return $randstring;}$randstring = RandomString();echo $randstring;

从php7开始，有random_bytes函数。https://www.php.net/manual/ru/function.random-bytes.php所以你可以生成这样的随机字符串

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

这是我简单的一行解决方案，以生成一个使用友好的随机密码，不包括类似的字符，如“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。我在Ubuntu上使用PHP 7.2。

php7+使用random_bytes函数生成加密安全的随机字节。

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

可能的产出

da 821217 e 61 e 33 ed 4 b 2 dd 96 f 8439056 c

php5.3+使用openssl_random_pseudo_bytes函数生成伪随机字节。

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

可能的产出

e 2 d 1254506 fb b 6 cd 842 cd 640333214 ad

最佳用例可以是

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

如果您使用的是PHP 7+

public function generateRandom(){
$string = bin2hex(openssl_random_pseudo_bytes(10)); // 20 chars
// OR
$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
}

试试这个，它可以生成到主长度。但它很简单，适合小字符串。

$master="ABCDEFGHIJKLMNOPQRSTUVWXYZ";$master_array = str_split($master);shuffle($master_array);print_r(implode("",array_slice($master_array,0,10)));

此代码将帮助：

此函数将返回长度在$maxLength和$minLength之间的随机字符串。

注：函数random_bytes从PHP 7开始工作。

如果你需要特定的长度，那么$maxLength和$minLength必须相同。

function getRandomString($maxLength = 20, $minLength = 10){$minLength = $maxLength < $minLength ? $maxLength : $minLength;$halfMin = ceil($minLength / 2);$halfMax = ceil($maxLength / 2);$bytes = random_bytes(rand($halfMin, $halfMax));$randomString = bin2hex($bytes);$randomString = strlen($randomString) > $maxLength ? substr($randomString, 0, -1) : $randomString;return $randomString;}

从yii2框架

/*** Generates a random string of specified length.* The string generated matches [A-Za-z0-9_-]+ and is transparent to URL-encoding.** @param int $length the length of the key in characters* @return string the generated random key*/
function generateRandomString($length = 10) {$bytes = random_bytes($length);return substr(strtr(base64_encode($bytes), '+/', '-_'), 0, $length);}

function generateRandomString($length = 10, $hasNumber = true, $hasLowercase = true, $hasUppercase = true): string{$string = '';if ($hasNumber)$string .= '0123456789';if ($hasLowercase)$string .= 'abcdefghijklmnopqrstuvwxyz';if ($hasUppercase)$string .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';return substr(str_shuffle(str_repeat($x = $string, ceil($length / strlen($x)))), 1, $length);}

和使用：

echo generateRandomString(32);

//generateRandomString http://stackoverflow.com/questions/4356289/php-random-string-generatorfunction randomString($length = 32, $string= "0123456789abcdefghijklmnopqrstuvwxyz" ) {//$string can be://0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ//0123456789abcdefghijklmnopqrstuvwxyzreturn substr(str_shuffle( $string), 0, $length);}

完整的解决方案（类加测试），部分基于上面的一些建议…

class TokenFactory{private const LENGTH = 12;private const ALLOWED = '123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNPQRSTUVWXYZ~!@#$%^&*{}';private const MIN_NUMBER_OF_DIGITS = 1;private const MIN_NUMBER_OF_CAPS = 1;private const MIN_NUMBER_OF_SPECIALS = 1;private const MIN_NUMBER_OF_LETTERS = 1;
/*** @return string* @throws \Exception*/public function make(): string{$pass = $this->generateToken();
if ($this->isTokenValid($pass)) {return $pass;} else {return $this->make();}}
/*** @return string* @throws \Exception*/private function generateToken(): string{$allowedCharacters = self::ALLOWED;$token              = '';$max               = mb_strlen($allowedCharacters, '8bit') - 1;for ($i = 0; $i < self::LENGTH; ++$i) {$token .= $allowedCharacters[random_int(0, $max)];}return $token;}
/*** @param $token* @return bool*/private function isTokenValid($token): bool{$numberOfDigits   = preg_match_all("/[0-9]/", $token);$numberOfCaps     = preg_match_all("/[A-Z]/", $token);$numberOfSpecials = preg_match_all("/[~!@#\$%^&*{}]/", $token);$numberOfLetters  = preg_match_all("/[a-z]/", $token);
return$numberOfDigits > self::MIN_NUMBER_OF_DIGITS&& $numberOfCaps > self::MIN_NUMBER_OF_CAPS&& $numberOfSpecials > self::MIN_NUMBER_OF_SPECIALS&& $numberOfLetters > self::MIN_NUMBER_OF_LETTERS;}}
class TokenFactoryTest{public function test_correct_syntax(){/*** Arrange*/$length = 12;$numberOfChecks = 1000;
/*** Act & Assert*/$class = new TokenFactory();
$i = 0;while ($i < $numberOfChecks) {$generatedToken = $class->make();
$numberOfDigits = preg_match_all( "/[0-9]/", $generatedToken );$numberOfCaps = preg_match_all( "/[A-Z]/", $generatedToken );$numberOfSpecials   = preg_match_all("/[~!@#\$%^&*{}]/", $generatedToken);$numberOfLetters   = preg_match_all("/[a-z]/", $generatedToken);
Assert::assertEquals($length, strlen($generatedToken));Assert::assertTrue($numberOfDigits >= 1, 'Digit error: ' . $generatedToken);Assert::assertTrue($numberOfCaps >= 1, 'Caps error: ' . $generatedToken);Assert::assertTrue($numberOfSpecials >= 1, 'Specials error: ' . $generatedToken);Assert::assertTrue($numberOfLetters >= 1, 'Letters error: ' . $generatedToken);
$i++;}}}

顺便说一句，确保在适合您需求的地方捕获该异常！

function gen_uid($l=5){return substr(str_shuffle("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"), 10, $l);}echo gen_uid();

默认值[5]：WvPJz

echo gen_uid(30);

值[30]：cAiGgtf1lDpFWoVwjykNKXxv6SC4Q2

如果你病态地害怕输入字母表中的字母，不关心字符串安全性，只对字母表感兴趣，这里有一个整洁的解决方案

$alphabets = range ("a", "z");shuffle ($alphabets);$randomString = substr(implode ("", $alphabets), 3, 17); // adjust according to desired length

Laravel解决方案：如果您使用的是Laravel Framework，您可以像这样使用它的StringHelper。

use Illuminate\Support\Str;

Str::random($strlentgh = 16)

递归解决方案：

public static function _random(string $set , int $length): string{$setLength = strlen($set);$randomKey = random_int(0, $setLength - 1);
$firstPiece = substr($set, 0, $randomKey);$secondPiece = substr($set, $randomKey, $setLength - $randomKey);
$removedCharacter = $firstPiece[strlen($firstPiece) - 1] ?? null;if(null === $removedCharacter || $length === 0) {return '';}$firstPieceWithoutTheLastChar = substr($firstPiece, 0, -1);
return $removedCharacter . self::_random($firstPieceWithoutTheLastChar . $secondPiece, $length - 1);}

不错的表现https://3v4l.org/aXaJ6/perf