Wie wäre es möglich, eine zufällige, eindeutige Zeichenfolge mit Zahlen und Buchstaben zur Verwendung in einem Überprüfungslink zu generieren? Zum Beispiel, wenn Sie ein Konto auf einer Website erstellen und eine E-Mail mit einem Link erhalten und auf diesen Link klicken müssen, um Ihr Konto zu verifizieren ... ja ... eines davon.

Wie kann ich eine davon mit PHP generieren?

Update: Gerade erinnert uniqid(). Es ist eine PHP-Funktion, die basierend auf der aktuellen Zeit in Mikrosekunden eine eindeutige Kennung generiert. Ich denke, ich werde das nutzen.

Sicherheitshinweis : Diese Lösung sollte nicht in Situationen verwendet werden, in denen die Qualität Ihrer Zufälligkeit die Sicherheit einer Anwendung beeinträchtigen kann. Insbesondere rand()und uniqid()sind keine kryptografisch sicheren Zufallszahlengeneratoren . Siehe Scotts Antwort für eine sichere Alternative.

Wenn Sie es nicht brauchen, um im Laufe der Zeit absolut einzigartig zu sein:

md5(uniqid(rand(), true))

Andernfalls (vorausgesetzt, Sie haben bereits ein eindeutiges Login für Ihren Benutzer festgelegt):

md5(uniqid($your_user_login, true))

Ich habe nur untersucht, wie ich das gleiche Problem lösen kann, aber ich möchte auch, dass meine Funktion ein Token erstellt, das auch zum Abrufen von Passwörtern verwendet werden kann. Dies bedeutet, dass ich die Fähigkeit des zu erratenden Tokens einschränken muss. Da uniqidbasierend auf der Zeit und laut php.net "der Rückgabewert sich kaum von microtime () unterscheidet", uniqiderfüllt er die Kriterien nicht. PHP empfiehlt, openssl_random_pseudo_bytes()stattdessen kryptografisch sichere Token zu generieren.

Eine schnelle, kurze und präzise Antwort lautet:

bin2hex(openssl_random_pseudo_bytes($bytes))

Dadurch wird eine zufällige Zeichenfolge mit alphanumerischen Zeichen der Länge = $ bytes * 2 generiert. Leider hat dies nur ein Alphabet von [a-f][0-9], aber es funktioniert.

function crypto_rand_secure($min, $max)
{
    $range = $max - $min;
    if ($range < 1) return $min; // not so random...
    $log = ceil(log($range, 2));
    $bytes = (int) ($log / 8) + 1; // length in bytes
    $bits = (int) $log + 1; // length in bits
    $filter = (int) (1 << $bits) - 1; // set all lower bits to 1
    do {
        $rnd = hexdec(bin2hex(openssl_random_pseudo_bytes($bytes)));
        $rnd = $rnd & $filter; // discard irrelevant bits
    } while ($rnd > $range);
    return $min + $rnd;
}

function getToken($length)
{
    $token = "";
    $codeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    $codeAlphabet.= "abcdefghijklmnopqrstuvwxyz";
    $codeAlphabet.= "0123456789";
    $max = strlen($codeAlphabet); // edited

    for ($i=0; $i < $length; $i++) {
        $token .= $codeAlphabet[crypto_rand_secure(0, $max-1)];
    }

    return $token;
}

crypto_rand_secure($min, $max)funktioniert als Ersatz für rand()oder mt_rand. Es verwendet openssl_random_pseudo_bytes, um eine Zufallszahl zwischen $ min und $ max zu erstellen.

getToken($length)Erstellt ein Alphabet zur Verwendung innerhalb des Tokens und erstellt dann eine Zeichenfolge mit der Länge $length.

EDIT: Ich habe es versäumt, die Quelle zu zitieren - http://us1.php.net/manual/en/function.openssl-random-pseudo-bytes.php#104322

EDIT (PHP7): Mit der Veröffentlichung von PHP7 verfügt die Standardbibliothek nun über zwei neue Funktionen, die die oben genannte Funktion crypto_rand_secure ersetzen / verbessern / vereinfachen können. random_bytes($length)undrandom_int($min, $max)

http://php.net/manual/en/function.random-bytes.php

http://php.net/manual/en/function.random-int.php

Beispiel:

function getToken($length){
    $token = "";
    $codeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    $codeAlphabet.= "abcdefghijklmnopqrstuvwxyz";
    $codeAlphabet.= "0123456789";
    $max = strlen($codeAlphabet);

    for ($i=0; $i < $length; $i++) {
        $token .= $codeAlphabet[random_int(0, $max-1)];
    }

    return $token;
}

Objektorientierte Version der am besten bewerteten Lösung

Ich habe eine objektorientierte Lösung basierend auf Scotts Antwort erstellt:

<?php

namespace Utils;

/**
 * Class RandomStringGenerator
 * @package Utils
 *
 * Solution taken from here:
 * http://stackoverflow.com/a/13733588/1056679
 */
class RandomStringGenerator
{
    /** @var string */
    protected $alphabet;

    /** @var int */
    protected $alphabetLength;


    /**
     * @param string $alphabet
     */
    public function __construct($alphabet = '')
    {
        if ('' !== $alphabet) {
            $this->setAlphabet($alphabet);
        } else {
            $this->setAlphabet(
                  implode(range('a', 'z'))
                . implode(range('A', 'Z'))
                . implode(range(0, 9))
            );
        }
    }

    /**
     * @param string $alphabet
     */
    public function setAlphabet($alphabet)
    {
        $this->alphabet = $alphabet;
        $this->alphabetLength = strlen($alphabet);
    }

    /**
     * @param int $length
     * @return string
     */
    public function generate($length)
    {
        $token = '';

        for ($i = 0; $i < $length; $i++) {
            $randomKey = $this->getRandomInteger(0, $this->alphabetLength);
            $token .= $this->alphabet[$randomKey];
        }

        return $token;
    }

    /**
     * @param int $min
     * @param int $max
     * @return int
     */
    protected function getRandomInteger($min, $max)
    {
        $range = ($max - $min);

        if ($range < 0) {
            // Not so random...
            return $min;
        }

        $log = log($range, 2);

        // Length in bytes.
        $bytes = (int) ($log / 8) + 1;

        // Length in bits.
        $bits = (int) $log + 1;

        // Set all lower bits to 1.
        $filter = (int) (1 << $bits) - 1;

        do {
            $rnd = hexdec(bin2hex(openssl_random_pseudo_bytes($bytes)));

            // Discard irrelevant bits.
            $rnd = $rnd & $filter;

        } while ($rnd >= $range);

        return ($min + $rnd);
    }
}

Verwendungszweck

<?php

use Utils\RandomStringGenerator;

// Create new instance of generator class.
$generator = new RandomStringGenerator;

// Set token length.
$tokenLength = 32;

// Call method to generate random string.
$token = $generator->generate($tokenLength);

Benutzerdefiniertes Alphabet

Bei Bedarf können Sie ein benutzerdefiniertes Alphabet verwenden. Übergeben Sie einfach eine Zeichenfolge mit unterstützten Zeichen an den Konstruktor oder Setter:

<?php

$customAlphabet = '0123456789ABCDEF';

// Set initial alphabet.
$generator = new RandomStringGenerator($customAlphabet);

// Change alphabet whenever needed.
$generator->setAlphabet($customAlphabet);

Hier sind die Ausgabebeispiele

SRniGU2sRQb2K1ylXKnWwZr4HrtdRgrM
q1sRUjNq1K9rG905aneFzyD5IcqD4dlC
I0euIWffrURLKCCJZ5PQFcNUCto6cQfD
AKwPJMEM5ytgJyJyGqoD5FQwxv82YvMr
duoRF6gAawNOEQRICnOUNYmStWmOpEgS
sdHUkEn4565AJoTtkc8EqJ6cC4MLEHUx
eVywMdYXczuZmHaJ50nIVQjOidEVkVna
baJGt7cdLDbIxMctLsEBWgAw5BByP5V0
iqT0B2obq3oerbeXkDVLjZrrLheW4d8f
OUQYCny6tj2TYDlTuu1KsnUyaLkeObwa

Ich hoffe es wird jemandem helfen. Prost!

Ich bin spät dran, aber ich bin hier mit einigen guten Forschungsdaten, die auf den Funktionen von Scotts Antwort basieren . Deshalb habe ich ein Digital Ocean-Tröpfchen nur für diesen 5-tägigen automatisierten Test eingerichtet und die generierten eindeutigen Zeichenfolgen in einer MySQL-Datenbank gespeichert.

Während dieses Testzeitraums habe ich 5 verschiedene Längen (5, 10, 15, 20, 50) verwendet und für jede Länge wurden +/- 0,5 Millionen Datensätze eingefügt. Während meines Tests erzeugte nur die Länge 5 +/- 3K-Duplikate von 0,5 Millionen und die verbleibenden Längen erzeugten keine Duplikate. Wir können also sagen, dass wir, wenn wir mit Scotts Funktionen eine Länge von 15 oder mehr verwenden, hochzuverlässige eindeutige Zeichenfolgen generieren können. Hier ist die Tabelle mit meinen Forschungsdaten:

Update: Ich habe mit diesen Funktionen eine einfache Heroku-App erstellt, die das Token als JSON-Antwort zurückgibt. Auf die App kann unter https://uniquestrings.herokuapp.com/api/token?length=15 zugegriffen werden

Ich hoffe das hilft.

Sie können die UUID (Universally Unique Identifier) ​​verwenden. Sie kann für jeden Zweck verwendet werden, von der Benutzerauthentifizierungszeichenfolge bis zur Zahlungsvorgangs-ID.

Eine UUID ist eine 128-Bit-Zahl mit 16 Oktetten. In seiner kanonischen Form wird eine UUID durch 32 hexadezimale Ziffern dargestellt, die in fünf durch Bindestriche getrennten Gruppen in der Form 8-4-4-4-12 für insgesamt 36 Zeichen (32 alphanumerische Zeichen und vier Bindestriche) angezeigt werden.

function generate_uuid() {
    return sprintf( '%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ),
        mt_rand( 0, 0xffff ),
        mt_rand( 0, 0x0C2f ) | 0x4000,
        mt_rand( 0, 0x3fff ) | 0x8000,
        mt_rand( 0, 0x2Aff ), mt_rand( 0, 0xffD3 ), mt_rand( 0, 0xff4B )
    );

}

// Funktion aufrufen

$transationID = generate_uuid();

Einige Beispielausgaben sind wie folgt:

E302D66D-87E3-4450-8CB6-17531895BF14
22D288BC-7289-442B-BEEA-286777D559F2
51B4DE29-3B71-4FD2-9E6C-071703E1FF31
3777C8C6-9FF5-4C78-AAA2-08A47F555E81
54B91C72-2CF4-4501-A6E9-02A60DCBAE4C
60F75C7C-1AE3-417B-82C8-14D456542CD7
8DE0168D-01D3-4502-9E59-10D665CEBCB2

hoffe es hilft jemandem in der Zukunft :)

Diese Funktion generiert einen Zufallsschlüssel mit Zahlen und Buchstaben:

function random_string($length) {
    $key = '';
    $keys = array_merge(range(0, 9), range('a', 'z'));

    for ($i = 0; $i < $length; $i++) {
        $key .= $keys[array_rand($keys)];
    }

    return $key;
}

echo random_string(50);

Beispielausgabe:

zsd16xzv3jsytnp87tk7ygv73k8zmr0ekh6ly7mxaeyeh46oe8

Ich benutze diesen Einzeiler:

base64_encode(openssl_random_pseudo_bytes(3 * ($length >> 2)));

Dabei ist Länge die Länge der gewünschten Zeichenfolge (teilbar durch 4, andernfalls wird sie auf die nächste durch 4 teilbare Zahl abgerundet.)

Verwenden Sie den folgenden Code, um die Zufallszahl von 11 Zeichen zu generieren oder die Zahl gemäß Ihren Anforderungen zu ändern.

$randomNum=substr(str_shuffle("0123456789abcdefghijklmnopqrstvwxyz"), 0, 11);

oder wir können eine benutzerdefinierte Funktion verwenden, um die Zufallszahl zu generieren

 function randomNumber($length){
     $numbers = range(0,9);
     shuffle($numbers);
     for($i = 0;$i < $length;$i++)
        $digits .= $numbers[$i];
     return $digits;
 }

 //generate random number
 $randomNum=randomNumber(11);

1. Generieren Sie eine Zufallszahl mit Ihrem bevorzugten Zufallszahlengenerator
2. Multiplizieren und dividieren Sie es, um eine Zahl zu erhalten, die der Anzahl der Zeichen in Ihrem Code-Alphabet entspricht
3. Holen Sie sich das Element an diesem Index in Ihr Code-Alphabet.
4. Wiederholen Sie ab 1), bis Sie die gewünschte Länge haben

zB (im Pseudocode)

int myInt = random(0, numcharacters)
char[] codealphabet = 'ABCDEF12345'
char random = codealphabet[i]
repeat until long enough

Hier ist der ultimative einzigartige ID-Generator für Sie. von mir gemacht.

<?php
$d=date ("d");
$m=date ("m");
$y=date ("Y");
$t=time();
$dmt=$d+$m+$y+$t;    
$ran= rand(0,10000000);
$dmtran= $dmt+$ran;
$un=  uniqid();
$dmtun = $dmt.$un;
$mdun = md5($dmtran.$un);
$sort=substr($mdun, 16); // if you want sort length code.

echo $mdun;
?>

Sie können jede 'var' für Ihre ID nach Belieben wiedergeben. aber $ mdun ist besser, Sie können md5 durch sha1 ersetzen, um besseren Code zu erhalten, aber das wird sehr lang sein, was Sie vielleicht nicht brauchen.

Vielen Dank.

Für wirklich zufällige Zeichenfolgen können Sie verwenden

<?php

echo md5(microtime(true).mt_Rand());

Ausgänge:

40a29479ec808ad4bcff288a48a25d5c

Selbst wenn Sie versuchen, einen String mehrmals genau zur gleichen Zeit zu generieren, erhalten Sie unterschiedliche Ausgaben.

Wenn Sie versuchen, ein zufälliges Passwort zu generieren, versuchen Sie:

• Generieren Sie zunächst einen kryptografisch sicheren Satz zufälliger Bytes

• Zweitens werden diese zufälligen Bytes in eine druckbare Zeichenfolge umgewandelt

Jetzt gibt es mehrere Möglichkeiten, zufällige Bytes in PHP zu generieren, wie:

$length = 32;

//PHP 7+
$bytes= random_bytes($length);

//PHP < 7
$bytes= openssl_random_pseudo_bytes($length);

Dann möchten Sie diese zufälligen Bytes in eine druckbare Zeichenfolge umwandeln:

Sie können bin2hex verwenden :

$string = bin2hex($bytes);

oder base64_encode :

$string = base64_encode($bytes);

Beachten Sie jedoch, dass Sie die Länge der Zeichenfolge nicht steuern, wenn Sie base64 verwenden. Sie können dazu bin2hex verwenden. Die Verwendung von 32 Bytes wird zu einer Zeichenfolge mit 64 Zeichen . Aber es wird nur so in einer EVEN- Zeichenfolge funktionieren .

Im Grunde können Sie also einfach Folgendes tun :

$length = 32;

if(PHP_VERSION>=7){
    $bytes= random_bytes($length);
}else{
    $bytes= openssl_random_pseudo_bytes($length);
} 

$string = bin2hex($bytes);

Folgendes benutze ich:

md5(time() . rand());    
// Creates something like 0c947c3b1047334f5bb8a3b7adc1d97b

function random_string($length = 8) {
    $alphabets = range('A','Z');
    $numbers = range('0','9');
    $additional_characters = array('_','=');
    $final_array = array_merge($alphabets,$numbers,$additional_characters);
       while($length--) {
      $key = array_rand($final_array);

      $password .= $final_array[$key];
                        }
  if (preg_match('/[A-Za-z0-9]/', $password))
    {
     return $password;
    }else{
    return  random_string();
    }

 }

Dies ist eine einfache Funktion, mit der Sie zufällige Zeichenfolgen mit Buchstaben und Zahlen (alphanumerisch) generieren können. Sie können auch die Zeichenfolgenlänge begrenzen. Diese zufälligen Zeichenfolgen können für verschiedene Zwecke verwendet werden, einschließlich: Empfehlungscode, Aktionscode, Gutscheincode. Die Funktion basiert auf folgenden PHP-Funktionen: base_convert, sha1, uniqid, mt_rand

function random_code($length)
{
  return substr(base_convert(sha1(uniqid(mt_rand())), 16, 36), 0, $length);
}

echo random_code(6);

/*sample output
* a7d9e8
* 3klo93
*/

Nachdem ich die vorherigen Beispiele gelesen hatte, kam ich auf Folgendes:

protected static $nonce_length = 32;

public static function getNonce()
{
    $chars = array();
    for ($i = 0; $i < 10; $i++)
        $chars = array_merge($chars, range(0, 9), range('A', 'Z'));
    shuffle($chars);
    $start = mt_rand(0, count($chars) - self::$nonce_length);
    return substr(join('', $chars), $start, self::$nonce_length);
}

Ich dupliziere das Array 10-mal [0-9, AZ] und mische die Elemente, nachdem ich einen zufälligen Startpunkt für substr () erhalten habe, um kreativer zu sein :) Sie können dem Array [az] und andere Elemente hinzufügen, duplizieren Sei mehr oder weniger kreativer als ich

Ich verwende gerne Hash-Schlüssel, wenn ich Verifizierungslinks verarbeite. Ich würde empfehlen, die Mikrozeit zu verwenden und MD5 zu verwenden, da es keinen Grund geben sollte, warum die Schlüssel gleich sein sollten, da sie auf der Mikrozeit basieren.

1. $key = md5(rand());
2. $key = md5(microtime());

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

}

?>

Die obige Funktion generiert eine zufällige Zeichenfolge mit einer Länge von 11 Zeichen.

Wenn Sie eine eindeutige Zeichenfolge in PHP generieren möchten, versuchen Sie Folgendes.

md5(uniqid().mt_rand());

In diesem,

uniqid()- Es wird eine eindeutige Zeichenfolge generiert. Diese Funktion gibt einen auf einem Zeitstempel basierenden eindeutigen Bezeichner als Zeichenfolge zurück.

mt_rand() - Zufallszahl generieren.

md5() - Es wird die Hash-Zeichenfolge generiert.

Scott, ja du bist sehr schreibend und gute Lösung! Vielen Dank.

Ich muss außerdem für jeden Benutzer ein eindeutiges API-Token generieren. Im Folgenden ist mein Ansatz, ich habe Benutzerinformationen (Benutzer-ID und Benutzername) verwendet:

public function generateUniqueToken($userid, $username){

        $rand = mt_rand(100,999);
    $md5 = md5($userid.'!(&^ 532567_465 ///'.$username);

    $md53 = substr($md5,0,3);
    $md5_remaining = substr($md5,3);

    $md5 = $md53. $rand. $userid. $md5_remaining;

    return $md5;
}

Bitte schauen Sie und lassen Sie mich wissen, ob ich Verbesserungen vornehmen kann. Vielen Dank

Folgendes verwende ich für eines meiner Projekte: Es funktioniert hervorragend und generiert ein EINZIGARTIGES ZUFÄLLIGES TOKEN :

$timestampz=time();

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


$tokenparta = generateRandomString();


$token = $timestampz*3 . $tokenparta;

echo $token;

Bitte beachten Sie, dass ich den Zeitstempel mit drei multipliziert habe, um Verwirrung zu stiften für jeden Benutzer, der sich fragt, wie dieses Token generiert wird;)

Ich hoffe, es hilft :)

Ich denke, dies ist die beste Methode.

str_shuffle(md5(rand(0,100000)))

Wir können diese beiden Codezeilen verwenden, um eine eindeutige Zeichenfolge zu generieren, die etwa 10000000 Mal iteriert wurde

  $sffledStr= str_shuffle('abscdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_-+');
    $uniqueString = md5(time().$sffledStr);

Ich benutze diese Funktion immer, um eine benutzerdefinierte zufällige alphanumerische Zeichenfolge zu generieren ... Hoffe diese Hilfe.

<?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;
  }
  echo random_alphanumeric(50); // 50 characters
?>

Es generiert zum Beispiel: Y1FypdjVbFCFK6Gh9FDJpe6dciwJEfV6MQGpJqAfuijaYSZ86g

Wenn Sie mit einer anderen Zeichenfolge vergleichen möchten, um sicherzustellen, dass es sich um eine eindeutige Sequenz handelt, können Sie diesen Trick verwenden ...

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

Es werden zwei eindeutige Zeichenfolgen generiert:

qsBDs4JOoVRfFxyLAOGECYIsWvpcpMzAO9pypwxsqPKeAmYLOi

Ti3kE1WfGgTNxQVXtbNNbhhvvapnaUfGMVJecHkUjHbuCb85pF

Hoffe das ist was du suchst ...

Eine einfache Lösung besteht darin, die Basis 64 in alphanumerische Zeichen umzuwandeln, indem die nicht alphanumerischen Zeichen verworfen werden.

Dieser verwendet random_bytes () für ein kryptografisch sicheres Ergebnis.

function random_alphanumeric(int $length): string
{
    $result='';
    do
    {
        //Base 64 produces 4 characters for each 3 bytes, so most times this will give enough bytes in a single pass
        $bytes=random_bytes(($length+3-strlen($result))*2);
        //Discard non-alhpanumeric characters
        $result.=str_replace(['/','+','='],['','',''],base64_encode($bytes));
        //Keep adding characters until the string is long enough
        //Add a few extra because the last 2 or 3 characters of a base 64 string tend to be less diverse
    }while(strlen($result)<$length+3);
    return substr($result,0,$length);
}

Ich denke, das ist eine bessere Lösung

Str::uuid()->toString()

Ich glaube, das Problem bei allen vorhandenen Ideen ist, dass sie wahrscheinlich einzigartig, aber nicht definitiv einzigartig sind (wie in Dariusz Walczaks Antwort auf Loletech ausgeführt). Ich habe eine Lösung, die eigentlich einzigartig ist. Es erfordert, dass Ihr Skript über eine Art Speicher verfügt. Für mich ist dies eine SQL-Datenbank. Sie können auch einfach irgendwo in eine Datei schreiben. Es gibt zwei Implementierungen:

Erste Methode: Haben Sie ZWEI Felder anstelle von 1, die die Eindeutigkeit gewährleisten. Das erste Feld ist eine ID-Nummer, die nicht zufällig, sondern eindeutig ist (Die erste ID ist 1, die zweite 2 ...). Wenn Sie SQL verwenden, definieren Sie einfach das ID-Feld mit der Eigenschaft AUTO_INCREMENT. Das zweite Feld ist nicht eindeutig, sondern zufällig. Dies kann mit jeder anderen Technik erzeugt werden, die bereits erwähnt wurde. Scotts Idee war gut, aber md5 ist praktisch und wahrscheinlich für die meisten Zwecke gut genug:

$random_token = md5($_SERVER['HTTP_USER_AGENT'] . time());

Zweite Methode: Grundsätzlich die gleiche Idee, aber zunächst eine maximale Anzahl von Zeichenfolgen auswählen, die jemals generiert werden. Dies könnte nur eine wirklich große Zahl wie eine Billion sein. Machen Sie dann dasselbe, generieren Sie eine ID, aber füllen Sie sie mit Null auf, sodass alle IDs die gleiche Anzahl von Ziffern haben. Dann verketten Sie einfach die ID mit der zufälligen Zeichenfolge. Für die meisten Zwecke ist es zufällig genug, aber der ID-Abschnitt stellt sicher, dass es auch eindeutig ist.

Sie können diesen Code verwenden, ich hoffe, er wird für Sie hilfreich sein.

function rand_code($len)
{
 $min_lenght= 0;
 $max_lenght = 100;
 $bigL = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 $smallL = "abcdefghijklmnopqrstuvwxyz";
 $number = "0123456789";
 $bigB = str_shuffle($bigL);
 $smallS = str_shuffle($smallL);
 $numberS = str_shuffle($number);
 $subA = substr($bigB,0,5);
 $subB = substr($bigB,6,5);
 $subC = substr($bigB,10,5);
 $subD = substr($smallS,0,5);
 $subE = substr($smallS,6,5);
 $subF = substr($smallS,10,5);
 $subG = substr($numberS,0,5);
 $subH = substr($numberS,6,5);
 $subI = substr($numberS,10,5);
 $RandCode1 = str_shuffle($subA.$subD.$subB.$subF.$subC.$subE);
 $RandCode2 = str_shuffle($RandCode1);
 $RandCode = $RandCode1.$RandCode2;
 if ($len>$min_lenght && $len<$max_lenght)
 {
 $CodeEX = substr($RandCode,0,$len);
 }
 else
 {
 $CodeEX = $RandCode;
 }
 return $CodeEX;
}

Details zum Zufallscodegenerator in PHP

Vereinfachung des obigen Scotts-Codes durch Entfernen unnötiger Schleifen, die sich stark verlangsamen und nicht sicherer machen als das einmalige Aufrufen von openssl_random_pseudo_bytes

function crypto_rand_secure($min, $max)
{
 $range = $max - $min;
 if ($range < 1) return $min; // not so random...
 $log = ceil(log($range, 2));
 $bytes = (int) ($log / 8) + 1; // length in bytes
 $rnd = hexdec(bin2hex(openssl_random_pseudo_bytes($bytes)));
 return $min + $rnd%$range;
}

function getToken($length)
{
 return bin2hex(openssl_random_pseudo_bytes($length)
}