PHP的随机字符串生成器


PHP random string generator

我正在尝试用PHP创建一个随机字符串，但我完全没有得到以下输出：

1
2
3
4
5
6
7
8
9
10
11
12
<?php
function RandomString()
{
    $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
    $randstring = '';
    for ($i = 0; $i < 10; $i++) {
        $randstring = $characters[rand(0, strlen($characters))];
    }
    return $randstring;
}
RandomString();
echo $randstring;

我做错什么了？

相关讨论

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

  • 当你回音时，$randstring不在范围内。
  • 循环中的字符不会连接在一起。

    • 下面是一个包含更正的代码段：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    function generateRandomString($length = 10) {
        $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        $charactersLength = strlen($characters);
        $randomString = '';
        for ($i = 0; $i < $length; $i++) {
            $randomString .= $characters[rand(0, $charactersLength - 1)];
        }
        return $randomString;
    }

    使用以下调用输出随机字符串：

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

    Please note that this generates predictable random strings. If you want to create secure tokens, see this answer.

    相关讨论

    Note: str_shuffle() internally uses rand(), which is unsuitable for cryptography purposes (e.g. generating random passwords). You want a secure random number generator instead. It also doesn't allow characters to repeat.

    再走一条路。

    更新(现在这将生成任意长度的字符串)：

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

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

    就是这样。：)

    相关讨论

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

    简单、安全和正确的答案是使用Randomlib，而不是重新发明轮子。

    对于那些坚持自己发明解决方案的人，php 7.0.0将为此提供random_int()；如果您仍然使用php 5.x，我们为random_int()编写了php 5 polyfill，这样您就可以在升级到php 7之前使用新的api。

    在PHP中安全地生成随机整数并不是一项简单的任务。在生产环境中部署自行开发的算法之前，应始终与您的StackExchange加密专家联系。

    有了一个安全的整数生成器，用CSPRNG生成一个随机字符串是一个简单的过程。

    创建安全的随机字符串

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    /**
     * 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);
    }

    用途：

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

    演示：https://3v4l.org/b4pst(忽略php 5失败；它需要随机兼容)

    相关讨论

    创建一个20个字符长的十六进制字符串：

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

    在php 7(random_bytes())中：

    1
    2
    3
    4
    5
    $string = base64_encode(random_bytes(10)); // ~14 chars, includes /=+
    // or
    $string = substr(str_replace(['+', '/', '='], '', base64_encode(random_bytes(32))), 0, 32); // 32 chars, without /=+
    // or
    $string = bin2hex(random_bytes(10)); // 20 chars, only 0-9a-f
    相关讨论

    @塔斯马尼斯基：你的回答对我很有效。我也有同样的问题，我会建议那些一直在寻找同样答案的人去解决。这是来自@tasmaniski的：

    1
    2
    3
    4
    <?php
        $random = substr(md5(mt_rand()), 0, 7);
        echo $random;
    ?>
    相关讨论

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

    1
    $string = base64_encode(openssl_random_pseudo_bytes(30));

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

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

    相关讨论

    我知道这可能有点晚了，但这里有一个简单的一行程序，它生成一个真正的随机字符串，而不需要任何脚本级循环或使用openssl库。

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

    将其分解，使参数清晰

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    // 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个字符之间的随机字符串)。

    相关讨论

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

    塔达！

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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);

    根据这一点和PHP7中的这一点，mt_rand更加随机。rand函数是mt_rand的别名。

    相关讨论

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

    1
    2
    $randstring = RandomString();
    echo $randstring;

    或者直接回显返回值：

    1
    echo RandomString();

    而且，在你的工作中，你也有一个小错误。在for循环中，需要使用.=，以便每个字符都附加到字符串中。通过使用=，您将用每个新字符覆盖它，而不是附加它。

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

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

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

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

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

    最后，使用这些随机数据创建密码。由于$random中的每个字符在chr(255)之前都可以是chr(0)，因此代码使用顺序值与$alphabet_length相除后的余数来确保只选取字母表中的字符(注意这样做会使随机性产生偏差)：

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

    或者，通常更好的方法是使用randomlib和securitylib：

    1
    2
    3
    4
    5
    6
    use SecurityLib\Strength;

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

    $password = $generator->generateString(12, $alphabet);
    相关讨论

    我已经测试了那里最流行的函数的性能，在我的框中生成1000'000串32个符号所需的时间是：

    1
    2
    3
    4
    5
    6
    7
    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()。

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

    短方法…

    下面是一些生成随机字符串的最短方法

    1
    2
    3
    4
    5
    6
    7
    <?php
    echo $my_rand_strng = substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), -15);

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

    echo str_shuffle(MD5(microtime()));
    ?>
    1
    2
    3
    4
    5
    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;
    }
    相关讨论

    这是从管理员处获取的：

    1
    2
    3
    4
    5
    6
    /** Get a random string
    * @return string 32 hexadecimal characters
    */
    function rand_string() {
        return md5(uniqid(mt_rand(), true));
    }

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

    Laravel 5框架中的助手函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
     * 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);
    }
    相关讨论

    一个非常快速的方法是做如下的事情：

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

    这将生成一个长度为10个字符的随机字符串。当然，有些人可能会说它在计算方面有点重，但是现在处理器被优化为可以很快地运行MD5或SHA256算法。当然，如果rand()函数返回相同的值，结果将相同，有1/32767的机会相同。如果是安全问题，那就把rand()改成mt_rand()就行了。

    相关讨论

    1
    2
    3
    4
    5
    6
    7
    8
    9
    /**
     * @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/

    函数的编辑版本工作正常，我发现只有一个问题：您使用了错误的字符来括起$字符，因此'字符有时是生成的随机字符串的一部分。

    要解决此问题，请更改：

    1
    $characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

    到：

    1
    $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

    这样，只使用带括号的字符，'字符将永远不会是生成的随机字符串的一部分。

    另一个一行程序，生成一个随机的10个字符的字母和数字字符串。它将使用range创建一个数组(调整第二个参数以设置大小)，在此数组上循环并分配一个随机的ascii字符(范围0-9或a-z)，然后将数组内部化以获取字符串。

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

    注意：仅适用于php 5.3+

    相关讨论

    一行。
    对于具有某种独特性的大型字符串，速度很快。

    1
    2
    3
    function random_string($length){
        return substr(str_repeat(md5(rand()), ceil($length/32)), 0, $length);
    }
    相关讨论

    我喜欢上一条使用openssl_random_pseudo_字节的评论，但这不是我的解决方案，因为我仍然需要删除我不想要的字符，而且我无法获得一个设置长度的字符串。这是我的解决方案…

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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;
    }

    有更好的选择，很多已经发布了，所以我只给你你的东西和修复。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    <?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;
    ?>

    此外，您可能对以下方面感兴趣：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    <?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.'';

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

        ?>

    或另一个：

    1
    2
    3
    4
    5
    6
    7
    8
    <?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);

    ?>
    相关讨论

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

    在PHP中生成随机字符串的另一种方法是：

    1
    2
    3
    4
    5
    6
    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);

    仅使用php本机函数参数化了一个行程序，从php 5.1.0开始工作

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

    有一个简单的代码：

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

    有简单的指南：

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

    具有上述讨论中的一些函数的类。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    $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 .="
    "    ;
            }
            return $string;
        }

        /**
         * @return array
         */
        public function getOptions()
        {
            return $this->options;
        }

        /**
         * @return mixed
         */
        public function getWhitelist()
        {
            return $this->whitelist;
        }

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

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

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

    我希望这有帮助。

    相关讨论

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    <?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 'Default: ' . random_string($l) . '<br />';
        echo 'Lower Case only: ' . random_string($l, array('a-z')) . '<br />';
        echo 'HEX only: ' . random_string($l, array('0-9', 'A-F')) . '<br />';
        echo 'BIN only: ' . random_string($l, array('0-1')) . '<br />';

    /* End of file */
    相关讨论

    一线解决方案是

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

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

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

    时间总是返回timstamp，它总是独一无二的。您可以将它与MD5一起使用以使其更好。

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <?php
    $random_string="";
    $character_count=12;
    for($i=1; $i<=$character_count; $i++)
    {
    $random_string.=chr(rand(97,122));
    }
    echo $random_string;
    ?>

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

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

    1
    2
    3
    4
    5
    6
    7
    <?php

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

    这是一条单行线。您将得到至少一个小写、一个大写、一个数字和一个符号。使用random_int，这应该是一种在图像上是安全的。不过，我并不认为这是安全的。我不是安全专家。

    复制+粘贴：

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

    更糟糕的是：

    1
    2
    3
    4
    5
    6
    7
    8
    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]来选择要从中随机获得的字符集。它保证数组中每个字符集有多个字符。

    它当然可以改进(随机化每个字符集的数量)，但这对于我的目的来说已经足够好了。

    我知道这是一个有多个答案的老问题，但我可以尝试发布我的解决方案…使用此my函数生成自定义随机字母数字字符串…

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    <?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 = random_alphanumeric(50); // 50 characters
      echo $test;
    ?>

    示例(测试)：y1fypdjvbfcfk6gh9fdjpe6dciwjefv6mqgpjqafuijaysz86

    如果您需要两个或更多的唯一字符串，可以这样做…

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
      $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"
    "    ;
      echo $string_2;

    $string_1:kkvuwia8rbdev2achwqm3ageuzqyrrbux2axvhx5s4tsj2vwa4

    $string_2:xrao85yfxbbcinafvwipsojwlmk6jmwiuwoxyqdnxohcn2d8k6

    希望能帮上忙。

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

    这个PHP函数适用于我：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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;

    }

    用途：

    1
    echo cvf_ps_generate_random_code(5);

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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);
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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
    }
    1
    2
    3
    function randomString() {
           return md5(rand(100, 200));
    }
    相关讨论

    你好，你可以试试这个

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    <?php


    function random($len){

        $char = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

        // ----------------------------------------------
        // number of possible combinations
        // ----------------------------------------------
        $pos = strlen($char);
        $pos = pow($pos, $len);
        echo $pos.'';
        // ----------------------------------------------

        $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()函数，因为如果多个线程在同一秒内运行，您需要为所有线程获取不同的字符串。

    1
    2
    3
    4
    5
    6
    <?php

        $string = md5( microtime() );
        echo $string;

    ?>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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;
    }

    简单而优雅。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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;
    }
    1
    2
    $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)));

    或一个班轮

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

    我说，从几个答案中选出最好的一个，然后把它们放在一起——str-suffle和range对我来说是新的：

    1
    2
    3
    4
    5
    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);
    }
    相关讨论

    你喜欢单线的吗？

    试试这个，

    1
    $str = substr(str_shuffle(str_repeat("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 5)), 0, $length);
    相关讨论

    试试这个：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    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;
    }

    我总是喜欢使用base64生成随机密码或其他随机(可打印)字符串。base64的使用确保了大量可打印字符的可用性。

    在外壳上，我通常这样做：

    1
    base64 < /dev/urandom |head -c10

    在PHP中也可以做类似的事情。但是，open-basedir限制可能禁止直接从/dev/urandom读取。这就是我到达的目的：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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()，这会更好。

    相关讨论

    如果在用户可能看到或使用此随机字符串的地方使用此随机字符串(例如作为密码生成器)，则可能需要限制用于排除元音的字符集。这样你就不会不小心造出坏话来冒犯别人了。别笑，这是真的。

    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    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"
    "    .$num."\t :".generateRandomString();
    }

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    // 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 loop
      if ($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;
    }
    相关讨论

    1
    2
    3
    $pass ="";
    for ($i=0;$i<12;++$i)
      $pass.= ($r=mt_rand(0,35))<26?chr(ord('a')+$r):chr(ord('0')+$r-26);
    相关讨论