À court d'id unique en php

Faire une petite fonction qui retourne des lettres aléatoires pour une longueur donnée:

<?php
function generate_random_letters($length) {
    $random = '';
    for ($i = 0; $i < $length; $i++) {
        $random .= chr(rand(ord('a'), ord('z')));
    }
    return $random;
}

Ensuite, vous aurez envie d'appeler jusqu'à ce que celui-ci est unique, en pseudo-code, selon l'endroit où vous vous souhaitez stocker de l'information:

do {
    $unique = generate_random_letters(6);
} while (is_in_table($unique));
add_to_table($unique);

Vous pourriez aussi vous voulez vous assurer que les lettres ne forment pas un mot dans un dictionnaire. Peut-il être l'ensemble de l'anglais dictionnaire ou juste un mauvais mot dictionnaire pour éviter de choses qu'un client pourrait trouver de mauvais goût.

EDIT: je tiens à ajouter ceci n'a de sens que si, comme vous avez l'intention de les utiliser, ce n'est pas pour un grand nombre d'éléments, car cela pourrait être assez lent le plus de collisions que vous obtenez (obtention d'un IDENTIFIANT déjà dans la table). Bien sûr, vous aurez envie d'un tableau indexé, et vous aurez envie de régler le nombre de lettres dans l'ID pour éviter la collision. Dans ce cas, avec 6 lettres, vous auriez 26^6 = 308915776 possible Identifiants uniques (moins de gros mots) qui devrait être suffisant pour votre besoin de 10000.

EDIT:
Si vous voulez une combinaison de lettres et de nombres, vous pouvez utiliser le code suivant:

$random .= rand(0, 1) ? rand(0, 9) : chr(rand(ord('a'), ord('z')));

Vous pouvez le faire avec moins de code:

function gen_uid($l=10){
    return substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyz"), 0, $l);
}

Résultat (exemples):

• cjnp56brdy
• 9d5uv84zfa
• ih162lryez
• ri4ocf6tkj
• xj04s83egi

Voici la routine que j'utilise pour aléatoire base62s de n'importe quelle longueur...

Appel gen_uuid() renvoie des chaînes comme WJX0u0jV, E9EMaZ3P etc.

Par défaut ceci renvoie à 8 chiffres, donc un espace de 64^8 soit environ 10^14,
c'est assez souvent de faire des collisions assez rare.

Pour une plus grande ou plus petite chaîne, de passer en $len comme souhaité. Pas de limite en longueur, comme je l'ai ajouter jusqu'à satisfaction [jusqu'à la limite de sécurité de 128 caractères, qui peut être retiré].

Note, utiliser un hasard sel à l'intérieur de le md5 [ou sha1 si vous préférez], de sorte qu'il ne peut pas facilement être de la rétro-ingénierie.

Je n'ai pas trouvé fiable base62 conversions sur le web, d'où cette approche pour le décapage de caractères à partir de la base64 résultat.

Utiliser librement sous la licence BSD,
profiter,

gord

function gen_uuid($len=8)
{
    $hex = md5("your_random_salt_here_31415" . uniqid("", true));

    $pack = pack('H*', $hex);

    $uid = base64_encode($pack);        //max 22 chars

    $uid = ereg_replace("[^A-Za-z0-9]", "", $uid);    //mixed case
    //$uid = ereg_replace("[^A-Z0-9]", "", strtoupper($uid));    //uppercase only

    if ($len<4)
        $len=4;
    if ($len>128)
        $len=128;                       //prevent silliness, can remove

    while (strlen($uid)<$len)
        $uid = $uid . gen_uuid(22);     //append until length achieved

    return substr($uid, 0, $len);
}

Vous pouvez utiliser l'Identifiant et le juste de le convertir à la base de 36 nombre si vous voulez à convertir et de l'autre. Peut être utilisé pour n'importe quelle table avec un id de type entier.

function toUId($baseId, $multiplier = 1) {
    return base_convert($baseId * $multiplier, 10, 36);
}
function fromUId($uid, $multiplier = 1) {
    return (int) base_convert($uid, 36, 10) / $multiplier;
}

echo toUId(10000, 11111);
1u5h0w
echo fromUId('1u5h0w', 11111);
10000

Gens intelligents pouvez probablement comprendre avec suffisamment d'id d'exemples. Ne laissez pas cette obscurité remplacer sécurité.

Lettres sont jolies, les chiffres sont moches.
Vous voulez des chaînes aléatoires, mais ne veulent pas "moche" des chaînes aléatoires?

Créer un nombre aléatoire et l'imprimer dans alpha-style (de base-26), à l'instar de la réserve "chiffres" que de compagnies aériennes.

Il n'y a pas d'usage général de la base de fonctions de conversion intégré dans PHP, autant que je sache, de sorte que vous aurez besoin de code qui peu vous-même.

Une autre alternative: utiliser uniqid() et de se débarrasser des chiffres.

function strip_digits_from_string($string) {
    return preg_replace('/[0-9]/', '', $string);
}

Ou de les remplacer par des lettres:

function replace_digits_with_letters($string) {
    return strtr($string, '0123456789', 'abcdefghij');
}

Vous pouvez le faire sans impur/costy des trucs comme des boucles, des concaténations de Chaîne ou plusieurs appels à rand(), dans un endroit propre et facile à lire. Aussi, il est préférable d'utiliser mt_rand():

function createRandomString($length)
{
    $random = mt_rand(0, (1 << ($length << 2)) - 1);
    return dechex($random);
}

Si vous avez besoin de la Chaîne pour avoir la longueur exacte dans tous les cas, il suffit de compléter le nombre hexadécimal avec des zéros:

function createRandomString($length)
{
    $random = mt_rand(0, (1 << ($length << 2)) - 1);
    $number = dechex($random);
    return str_pad($number, $length, '0', STR_PAD_LEFT);
}

La "théorique backdraw" est, que vous êtes limité à PHPs capacités - mais c'est plus une question philosophique dans ce cas 😉 Let's go à travers elle de toute façon:

• PHP est limité dans ce qu'il peut représenter comme un nombre hexadécimal de le faire comme ça. Ce serait $length <= 8 au moins sur un système 32 bits, où PHPs limitation pour ce qui devrait être 4.294.967.295 .
• PHPs générateur de nombre aléatoire a aussi un maximum. Pour mt_rand() au moins sur un système 32 bits, il devrait être 2.147.483.647
• Vous êtes donc théoriquement limité à 2.147.483.647 Id.

Revenir au sujet - l'intuitif do { (generate ID) } while { (id is not uniqe) } (insert id) a un inconvénient et un possible défaut qui pourrait vous conduire directement à l'obscurité...

Inconvénient: La validation est pessimiste. Le faire comme ceci toujours nécessite un chèque à la base de données. Avoir assez d'espace de clé (par exemple la longueur de 5 pour votre 10k entrées) aura très peu de chances de provoquer des collisions comme souvent, il pourrait être comparable moins coûteuse en termes de ressources à essayer juste pour stocker les données et recommencez seulement dans le cas d'une CLÉ UNIQUE d'erreur.

Défaut: Utilisateur Un récupère un ID qui obtient vérifié que pas encore pris. Puis le code d'essayer d'insérer les données. Mais en attendant, l'Utilisateur B saisi de la même boucle et, malheureusement, récupère le même nombre aléatoire, parce que Utilisateur Un n'est pas sauvegardé et cet ID est toujours libre. Maintenant, le système stocke l'Utilisateur B ou Utilisateur Un, et lorsque vous tentez de stocker le deuxième Utilisateur, il existe déjà de l'autre, dans l'intervalle, - ayant le même ID.

Vous auriez besoin pour gérer cette exception dans tous les cas et de la nécessité de re-tenter l'insertion avec un nouvel ID. L'ajout de cette tout en gardant le pessimiste vérification de la boucle (que vous auriez besoin de re-entrée) aura pour résultat assez moche et difficile à suivre code. Heureusement, la solution à ce problème est le même que celui de l'inconvénient: aller Juste pour elle, en premier lieu, et d'essayer de stocker les données. Dans le cas d'une CLÉ UNIQUE erreur viens de réessayer avec un nouvel ID.

function rand_str($len = 12, $type = '111', $add = null) {
    $rand = ($type[0] == '1'  ? 'abcdefghijklmnpqrstuvwxyz' : '') .
            ($type[1] == '1'  ? 'ABCDEFGHIJKLMNPQRSTUVWXYZ' : '') .
            ($type[2] == '1'  ? '123456789'                 : '') .
            (strlen($add) > 0 ? $add                        : '');

    if(empty($rand)) $rand = sha1( uniqid(mt_rand(), true) . uniqid( uniqid(mt_rand(), true), true) );

    return substr(str_shuffle( str_repeat($rand, 2) ), 0, $len);
}

Mieux Encore De Réponse: Plus petit Unique "de Hachage Comme" Chaîne de caractères Donnée Unique ID de Base de données - PHP Solution, Aucun Tiers les Bibliothèques Nécessaires.

Voici le code:

<?php
/*
THE FOLLOWING CODE WILL PRINT:
A database_id value of 200 maps to 5K
A database_id value of 1 maps to 1
A database_id value of 1987645 maps to 16LOD
*/
$database_id = 200;
$base36value = dec2string($database_id, 36);
echo "A database_id value of 200 maps to $base36value\n";
$database_id = 1;
$base36value = dec2string($database_id, 36);
echo "A database_id value of 1 maps to $base36value\n";
$database_id = 1987645;
$base36value = dec2string($database_id, 36);
echo "A database_id value of 1987645 maps to $base36value\n";

//HERE'S THE FUNCTION THAT DOES THE HEAVY LIFTING...
function dec2string ($decimal, $base)
//convert a decimal number into a string using $base
{
    //DebugBreak();
   global $error;
   $string = null;

   $base = (int)$base;
   if ($base < 2 | $base > 36 | $base == 10) {
      echo 'BASE must be in the range 2-9 or 11-36';
      exit;
   } //if

   //maximum character string is 36 characters
   $charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';

   //strip off excess characters (anything beyond $base)
   $charset = substr($charset, 0, $base);

   if (!ereg('(^[0-9]{1,50}$)', trim($decimal))) {
      $error['dec_input'] = 'Value must be a positive integer with < 50 digits';
      return false;
   } //if

   do {
      //get remainder after dividing by BASE
      $remainder = bcmod($decimal, $base);

      $char      = substr($charset, $remainder, 1);   //get CHAR from array
      $string    = "$char$string";                    //prepend to output

      //$decimal   = ($decimal - $remainder) /$base;
      $decimal   = bcdiv(bcsub($decimal, $remainder), $base);

   } while ($decimal > 0);

   return $string;

}

?>