PHP zufälliger String-Generator

Hinweis: str_shuffle() verwendet intern Rand() , was für Verschlüsselungszwecke ungeeignet ist (z. B. das Generieren zufälliger Passwörter). Sie möchten stattdessen einen sicheren Zufallszahlengenerator . Zeichen dürfen sich auch nicht wiederholen.

Ein weiterer Weg.

AKTUALISIERT _ ​​(Dies erzeugt jetzt eine beliebige Länge der Zeichenfolge):

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

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

Das ist es. :) 

Es gibt viele Antworten auf diese Frage, aber keine von ihnen nutzt einen kryptografisch sicheren Pseudo-Zufallszahlengenerator (CSPRNG).

Die einfache, sichere und korrekte Antwort ist die Verwendung von RandomLib und das Rad nicht neu zu erfinden.

Für diejenigen von Ihnen, die darauf bestehen, Ihre eigene Lösung zu entwickeln, stellt PHP 7.0.0 random_int() für diesen Zweck bereit. Wenn Sie sich noch auf PHP 5.x befinden, haben wir eine PHP 5-Polyfill für random_int() geschrieben, damit Sie die neue API bereits vor dem Upgrade auf PHP 7 verwenden können.

Sicheres Erzeugen zufälliger Ganzzahlen in PHP ist keine triviale Aufgabe. Sie sollten sich immer mit Ihren ortsansässigen StackExchange-Kryptographie-Experten informieren, bevor Sie einen selbst entwickelten Algorithmus in der Produktion bereitstellen.

Mit einem sicheren Integer-Generator ist das Generieren einer zufälligen Zeichenfolge mit einem CSPRNG ein Spaziergang im Park.

Eine sichere zufällige Zeichenfolge erstellen

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

Verwendungszweck:

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

Demo: https://3v4l.org/b4PST (Ignorieren Sie die PHP 5-Fehler; es erfordert random_compat)

Erzeugt eine 20 Zeichen lange Hexdec-Zeichenfolge:

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

In PHP 7 ( random_bytes () ):

$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: Deine Antwort hat bei mir funktioniert. Ich hatte das gleiche Problem, und ich würde es für diejenigen vorschlagen, die jemals nach der gleichen Antwort suchen. Hier ist es von @tasmaniski:

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

Abhängig von Ihrer Anwendung (ich wollte Passwörter generieren) können Sie diese verwenden

$string = base64_encode(openssl_random_pseudo_bytes(30));

Als base64 können sie = oder - sowie die angeforderten Zeichen enthalten. Sie könnten eine längere Zeichenfolge generieren, filtern und zuschneiden, um diese zu entfernen.

openssl_random_pseudo_bytes scheint der empfohlene Weg zu sein, eine richtige Zufallszahl in PHP zu generieren. Warum Rand/dev/random nicht verwendet, weiß ich nicht.

Ich weiß, dass dies ein bisschen zu spät zum Spiel kommt, aber hier ist ein einfacher Einzeiler, der eine echte zufällige Zeichenfolge generiert, ohne dass ein Script-Level-Loop oder die Verwendung von openssl-Bibliotheken verwendet wird.

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

Um es aufzuschlüsseln, damit die Parameter klar sind

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

Bei dieser Methode wird die Zeichenliste zufällig wiederholt, die kombinierte Zeichenfolge wird neu gemischt und die Anzahl der angegebenen Zeichen zurückgegeben.

Sie können dies weiter randomisieren, indem Sie die Länge des zurückgegebenen Strings randomisieren und $chrRandomLength durch mt_Rand(8, 15) ersetzen (für einen zufälligen String zwischen 8 und 15 Zeichen).

Eine bessere Möglichkeit, diese Funktion zu implementieren, ist:

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 ist zufälliger gemäß this und this in php7. Die Funktion Rand ist ein Alias ​​von mt_Rand.

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

Tada!

$randstring im Funktionsbereich stimmt nicht mit dem Bereich überein, in dem Sie ihn aufrufen. Sie müssen den Rückgabewert einer Variablen zuordnen.

$randstring = RandomString();
echo $randstring;

Oder geben Sie einfach den Rückgabewert direkt wieder:

echo RandomString();

Auch in Ihrer Funktion haben Sie einen kleinen Fehler. Innerhalb der for-Schleife müssen Sie .= verwenden, damit jedes Zeichen an die Zeichenfolge angehängt wird. Mit = überschreiben Sie es mit jedem neuen Zeichen, anstatt es anzufügen.

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

Zuerst definieren Sie das Alphabet, das Sie verwenden möchten:

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

Verwenden Sie dann openssl_random_pseudo_bytes() , um korrekte Zufallsdaten zu generieren:

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

Schließlich verwenden Sie diese zufälligen Daten, um das Kennwort zu erstellen. Da jedes Zeichen in $randomchr(0) bis chr(255) sein kann, verwendet der Code den Rest nach der Division seines Ordinalwerts mit $alphabet_length, um sicherzustellen, dass nur Buchstaben aus dem Alphabet ausgewählt werden (beachten Sie, dass dadurch die Zufälligkeit beeinträchtigt wird):

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

Alternativ und im Allgemeinen besser ist es, RandomLib und SecurityLib zu verwenden:

use SecurityLib\Strength;

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

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

Ich habe die Leistung der gängigsten Funktionen getestet. Die Zeit, die erforderlich ist, um 1'000'000 Zeichenfolgen mit 32 Symbolen auf meiner Box zu generieren, ist:

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

Bitte beachten Sie, dass es nicht wichtig ist, wie lange es wirklich war, aber welche langsamer ist und welche schneller ist, sodass Sie entsprechend Ihren Anforderungen auswählen können.

substr () um MD5 wurde aus Gründen der Genauigkeit hinzugefügt, wenn Sie einen String benötigen, der kürzer als 32 Symbole ist.

Der Antwort wegen: Die Zeichenfolge wurde nicht verkettet, aber überschrieben und das Ergebnis der Funktion wurde nicht gespeichert.

Kurze Methoden ..

Hier sind einige kürzeste Methoden zum Generieren der Zufallszeichenfolge

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

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

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

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

Dieses wurde aus adminer sources entnommen :

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

Adminer , Datenbankverwaltungstool in PHP geschrieben.

Hilfsfunktion von Laravel 5 Framework

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

Eine sehr schnelle Möglichkeit ist, etwas zu tun:

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

Dadurch wird eine zufällige Zeichenfolge mit der Länge von 10 Zeichen generiert. Natürlich sagen einige vielleicht, dass es auf der rechnerischen Seite etwas schwerer ist, aber heutzutage werden Prozessoren optimiert, um den md5- oder sha256-Algorithmus sehr schnell auszuführen. Wenn die Funktion Rand() denselben Wert zurückgibt, ist das Ergebnis natürlich dasselbe, mit einer Chance von 1/32767, die gleiche zu sein. Wenn Sicherheit das Problem ist, ändern Sie einfach Rand() in mt_Rand(). 

/**
 * @param int $length
 * @param string $abc
 * @return string
 */
function generateRandomString($length = 10, $abc = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
{
    return substr(str_shuffle($abc), 0, $length);
}

Quelle aus http://www.xeweb.net/2011/02/11/generate-a-random-string-a-z-0-9-in-php/

eine Linie.
schnell für große Saiten mit etwas Einzigartigkeit.

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

Die bearbeitete Version der Funktion funktioniert gut, nur ein Problem, das ich gefunden habe: Sie haben ein falsches Zeichen verwendet, um $ -Zeichen einzuschließen. Das Zeichen ’ist daher manchmal Teil der generierten Zufallszeichenfolge.

Um dies zu beheben, ändern Sie:

$characters = ’0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’;

zu:

$characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

Auf diese Weise werden nur die eingeschlossenen Zeichen verwendet, und das Zeichen ’wird niemals Teil der zufälligen Zeichenfolge sein, die generiert wird.

Ein weiterer Einzeiler, der eine zufällige Zeichenfolge von 10 Zeichen mit Buchstaben und Zahlen generiert. Es erstellt ein Array mit range (passt den zweiten Parameter an, um die Größe festzulegen), durchläuft dieses Array und weist ein zufälliges ASCII-Zeichen (Bereich 0-9 oder a-z) zu.

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

Hinweis: funktioniert nur in PHP 5.3+

Ich mochte den letzten Kommentar, der openssl_random_pseudo_bytes verwendete, aber es war keine Lösung für mich, da ich immer noch die Zeichen entfernen musste, die ich nicht wollte, und ich konnte keine festgelegte Länge erhalten. Hier ist meine Lösung ...

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

Eine andere Möglichkeit zum Erzeugen einer zufälligen Zeichenfolge in PHP ist:

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

Es gibt einen einfachen Code:

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

Es gibt eine einfache Anleitung:

• Um die Länge von Zeichenfolge zu ändern, ändern Sie den 16 nur in einen anderen Wert.
• Um verschiedene Zeichen auszuwählen, ändern Sie bitte die Zeichenfolge.

es gibt bessere Alternativen dazu, viele wurden bereits veröffentlicht, daher gebe ich Ihnen nur Ihr Zeug mit Korrekturen zurück

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

Vielleicht interessieren Sie sich auch für:

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

    ?>

oder eine andere:

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

?>

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

Parametrisierter Einzeiler, der nur PHP native Funktionen verwendet, funktioniert seit 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))))))

Ich weiß, dass dies eine alte Frage mit mehreren Antworten ist, aber ich kann versuchen, meine Lösung zu veröffentlichen. Verwenden Sie diese Funktion, um eine benutzerdefinierte alphanumerische Zufallszeichenfolge zu generieren.

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

Beispiel (Test): Y1FypdjVbFCFK6Gh9FDJpe6dciwJEfV6MQGpJqAfuijaYSZ86

wenn Sie zwei oder mehr eindeutige Zeichenfolgen benötigen, können Sie dies tun ...

  $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

Ich hoffe diese Hilfe.

Source: PHP Funktion, die zufällige Zeichen generiert

Diese PHP Funktion hat für mich funktioniert:

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;

}

Verwendungszweck: 

echo cvf_ps_generate_random_code(5);

Eine Klasse mit einigen Funktionen aus den obigen Diskussionen.

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

endlich habe ich eine Lösung gefunden, um einen zufälligen und einzigartigen Wert zu erhalten. Meine Lösung ist 

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

die Uhrzeit gibt immer den Zeitstempel zurück und ist immer eindeutig. Sie können es mit MD5 verwenden, um es besser zu machen. 

Die folgende Funktion erzeugt einen Pseudo-String mit any 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);
}

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
}

Sie machen es völlig falsch, weil Sie von Zahlen abhängen und nicht von Zeichen. Ich bin mir nicht sicher, ob die Zufallsausgabe nur Zahlen sein soll. Warum verwenden Sie nicht einfach Rand(0, 62)?, obwohl Sie vergessen haben, Ihre Variable $randstring zu initialisieren, bevor Sie die Funktion deklarieren.

anyways PHP bietet Ihnen eine sehr praktische Funktion für diesen Zweck, es ist str_shuffle(). Hier ist ein Beispiel, das Ihren Bedürfnissen entspricht.

<?php

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

So mache ich es, um einen wirklich eindeutigen zufälligen Schlüssel zu erhalten:

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

Sie können time () verwenden, da es sich um einen Unix-Zeitstempel handelt und im Vergleich zu anderen, oben genannten Zufällen immer eindeutig ist. Sie können dann die md5sum davon generieren und die gewünschte Länge aus dem generierten MD5 string entnehmen. In diesem Fall verwende ich 10 Zeichen, und ich könnte eine längere Zeichenfolge verwenden, wenn ich sie eindeutiger machen möchte.

Ich hoffe das hilft.

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

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

Einfach und elegant.

Die einzeilige Lösung wird sein

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

Hier ist ein Einzeiler. Sie erhalten mindestens einen Kleinbuchstaben, einen Großbuchstaben, eine Zahl und ein Symbol. Verwendet random_int, der kyrptographisch sicher sein soll. Ich behaupte jedoch nicht, dass dies sicher ist. Ich bin kein Sicherheitsexperte.

Kopieren + Einfügen: 

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

Und noch ein bisschen mehr:

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

Ich verwende $chars[$i%4] in der Schleife, um auszuwählen, aus welcher Menge von Zeichen eine Zufallszahl ermittelt werden soll. Es garantiert mehrere Zeichen aus jeder Gruppe von Zeichen im Array.

Es könnte definitiv verbessert werden (zufällig bestimmen, wie viele von jedem Zeichensatz dort sind), aber es ist gut genug für meine Zwecke.

Es gibt 3 Dinge, die mit Ihrem Code nicht stimmen:

1. $ randstring ist nichts zugeordnet (nur innerhalb der außerhalb des Gültigkeitsbereichs liegenden Funktion).
2. RandomString gibt nur das letzte zufällige Zeichen zurück. Ersetzen Sie = durch .=.
3. Rand generiert keine kryptografisch sicheren Pseudozufallszahlen. Verwenden Sie stattdessen random_int.

Siehe unten:

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

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

hallo du kannst es versuchen

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



?>

sie können md5 auch rechtzeitig verwenden, aber seien Sie vorsichtig Sie müssen microtime() und nicht time() function verwenden. Wenn mehrere Threads in derselben Sekunde laufen, müssen Sie für alle eine andere Zeichenfolge erhalten.

<?php

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

?>

In dieser Methode können Sie die Zeichenlänge beim Erstellen auswählen.

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