PHP 随机字符串生成器答案

【问题标题】：PHP random string generatorPHP 随机字符串生成器
【发布时间】：2011-05-20 08:51:22
【问题描述】：

我正在尝试在 PHP 中创建一个随机字符串，但我绝对没有输出：

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

    RandomString();
    echo $randstring;

我做错了什么？

【问题讨论】：

我生成短字符串的单行解决方案是 substr(md5(rand()), 0, 7);祝你好运......
@tasmaniski .. 你的解决方案没问题.. 但它的随机性较低！在您的示例中，可以生成的随机字符串的数量受整数大小的限制。 ( 2^32 ) 最大.. 如果是其他解决方案，您可以生成 ( 62^8 ).. 如果我想要更大的字符串，那么不同字符串的数量保持在最大 2^32，但在其他解决方案它增加到（ 62^n ）..
您忘记将每个新生成的字符添加到字符串中。您只是按原样覆盖它。应该是 $randstring .= $characters..
@CaptainLightning 您能否将接受的答案换成更安全的答案之一？ :)
strlen($characters) => strlen($characters) - 1 - 字符串长度从 1 开始

标签： php string random

【解决方案1】：

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

【讨论】：

【解决方案2】：

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

【讨论】：

【解决方案3】：

有简单的代码：

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

有一个简单的指南：

要更改字符串的长度，请将16 更改为其他值，仅此而已。
要从不同的字符中选择，请更改字符串。

【讨论】：

这真的优于这里的其他答案吗？

【解决方案4】：

你可以试试这个：

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

【讨论】：

【解决方案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。

【讨论】：

【解决方案6】：

这里是单线。您将至少获得一个小写字母、一个大写字母、一个数字和一个符号。使用 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] 来选择从哪组字符中随机获取。它保证数组中每组字符中有多个字符。

绝对可以改进（随机化每个字符集的数量），但对于我的目的来说已经足够了。

【讨论】：

【解决方案7】：

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

【讨论】：

【解决方案8】：

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

默认值[5]：WvPJz

echo gen_uid(30);

值[30]：cAiGgtf1lDpFWoVwjykNKXxv6SC4Q2

【讨论】：

【解决方案9】：

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
}

【讨论】：

【解决方案10】：

来源：PHP Function that Generates Random Characters

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

【讨论】：

【解决方案11】：

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

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

【讨论】：

【解决方案12】：

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

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

<?php

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

【讨论】：

【解决方案13】：

我终于找到了一种获取随机和唯一值的解决方案。

我的解决办法是：

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

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

【讨论】：

时间戳不是始终是唯一的，md5 并不能让它变得更好。如果多个线程在同一秒内运行，此代码将为所有线程生成相同的字符串。

【解决方案14】：

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

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

【讨论】：

【解决方案15】：

对此有更好的选择。许多已经发布，所以我只给你修复你的东西：

<?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
    function RandomString()
    {
        global $randstring;
        $characters = str_split('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
           array_filter ($characters,function($var)use($characters,&$randstring){
                $randstring .= $characters[rand(0, count($characters)-1)];
        });
        return $randstring;
    }

    RandomString();
    echo $randstring.'<hr>';

    //.. OR  ..
    $randstring = '';
    echo(RandomString());
?>

或者另一个：

<?php
    function s($length){
      for($i=0;
          ($i<$length) and
          (
              ($what=rand(1,3))

              and

              (
                  (
                      ($what==1) and
                      ($t=rand(48, 57)
                  )
                  ) or

                  (
                      ($what==2) and
                      ($t=rand(65, 90))
                  ) or

                  (
                      ($what==3) and
                      ($t=rand(97, 122)
                  )
                  )
              ) and
              (print chr($t))
          );

          $i++)

              ;
    }
    s(10);
?>

【讨论】：

为什么要把$randstring设为全局，每次清空还要返回？
@Christian '因为有时你可以在其他脚本中稍微修改结构以获得新的东西。也有范围以多种方式获得相同的结果 -> 这是开发的动态

【解决方案16】：

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

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

【讨论】：

【解决方案17】：

此代码将有所帮助：

此函数将返回长度在$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;
}

【讨论】：

【解决方案18】：

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

【讨论】：

【解决方案19】：

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

【讨论】：

如果您想使用正确的 PHP，请将函数的第一行替换为 foreach ($ranges as $r) $s .= implode('', range(array_shift($r = explode('-', $r)), $r[1]));

【解决方案20】：

单行解决方案将是

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

【讨论】：

这甚至是随机的。请不要使用它。

【解决方案21】：

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

简洁优雅。

【讨论】：

【解决方案22】：

您的代码有 3 个问题：

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

见下文：

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

【讨论】：

这与其他答案有何不同？

【解决方案23】：

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

<?php
  function 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 characters
  echo $test_with_50_items;

示例（test_with_50_items）：Y1FypdjVbFCFK6Gh9FDJpe6dciwJEfV6MQGpJqAfuijaYSZ86

如果您需要超过 50 个字符或更少，只需按您喜欢的方式调用函数：

  $test_with_27_items = random_alphanumeric(27); // 27 characters
  echo $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

【讨论】：

【解决方案24】：

如果您使用的是 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

}

【讨论】：

【解决方案25】：

试试这个，它可以生成最多长度的master。但它简单，适合小字符串。

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

【讨论】：

【解决方案26】：

一个完整的解决方案（课程加测试），部分基于上面的一些建议......

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

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

【讨论】：

【解决方案27】：

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

【讨论】：

这只是部分随机，因为您将其限制为 100 个独特的组合。此外，md5 将始终返回一个长度为 32 个字符的字符串。适合一般用途，但如果您需要大量真正独特的字符串，则不适合。有关使用当前时间 md5() 和 base64_decode() 具有更好随机性的示例，请参阅我的答案。

【解决方案28】：

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

【讨论】：

另外，我要补充一点，你不应该包含视觉上相似的字符，例如1=>l (lowercase L), 0 (digit)=>O (letter)。这些可能会让用户感到困惑，因为它们乍一看很相似，所以只坚持不同的。

【解决方案29】：

我说从几个答案中提取最好的一个并将它们放在一起 - str_suffle 和 range 对我来说是新的：

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

【讨论】：

这限制为 62 个字符，因为您只是将 3 个范围（0-9、az、AZ）连接到一个 62 长字符串中，然后将字符改组并获得第一个N 个字符（因此 N 最多为 62 个）。当请求长度超过 62 个字符时，可以重新设计该函数以对自身进行递归调用，但只是想指出当前阅读此限制的任何人。
为了小熵付出了很多努力...你可以做得更好。

【解决方案30】：

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

【讨论】：