Short unique id in php

Question

I want to create a unique id but uniqid() is giving something like '492607b0ee414'. What i would like is something similar to what tinyurl gives: '64k8ra'. The shorter, the better. The only requirements are that it should not have an obvious order and that it should look prettier than a seemingly random sequence of numbers. Letters are preferred over numbers and ideally it would not be mixed case. As the number of entries will not be that many (up to 10000 or so) the risk of collision isn't a huge factor.

Any suggestions appreciated.

Amorphous

As uniqid is based on timestamp the first 6 characters will be the same for quite a long time ;) Even if i took the last x characters or combined this some way i think there still is a cleaner approach. Something like 'x1f' would be nice. – Amorphous

Did you find a solution? If so, share it or award an answer. – Tera

Yeah i went with what lpfavreau suggested, although a bit modified. As the list of items is pretty small i can do a in memory check for collisions – Amorphous

If you want random, short, unordered, letter-only, lowercase strings you could get those with Random::alphaLowercaseString(6), or a length of 8 or 10, as you wish. – Hyacinthe

Answer 1

Make a small function that returns random letters for a given length:

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

Then you'll want to call that until it's unique, in pseudo-code depending on where you'd store that information:

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

You might also want to make sure the letters do not form a word in a dictionnary. May it be the whole english dictionnary or just a bad-word dictionnary to avoid things a customer would find of bad-taste.

EDIT: I would also add this only make sense if, as you intend to use it, it's not for a big amount of items because this could get pretty slow the more collisions you get (getting an ID already in the table). Of course, you'll want an indexed table and you'll want to tweak the number of letters in the ID to avoid collision. In this case, with 6 letters, you'd have 26^6 = 308915776 possible unique IDs (minus bad words) which should be enough for your need of 10000.

EDIT: If you want a combinations of letters and numbers you can use the following code:

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

Siqueiros

You should put ord('a')and ord('z') outside of the loop, to avoid calling the function on each pass. – Anetta

For combinations of letters and numbers, you're weighting 10 numbers equally with 26 letters. So you'll have way more numbers than you would randomly. To give each digit and letter identical probability, you could do $random .= rand(0,35) < 10 ? rand(0,9) : chr(rand(ord('a'), ord('z'))); – Muth

Answer 2

@gen_uuid() by gord.

preg_replace got some nasty utf-8 problems, which causes the uid somtimes to contain "+" or "/". To get around this, you have to explicitly make the pattern utf-8

function gen_uuid($len=8) {

    $hex = md5("yourSaltHere" . uniqid("", true));

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

    $uid = preg_replace("#(*UTF8)[^A-Za-z0-9]#", "", $tmp);

    $len = max(4, min(128, $len));

    while (strlen($uid) < $len)
        $uid .= gen_uuid(22);

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

Took me quite a while to find that, perhaps it's saves somebody else a headache

Ethelind

Answer 3

You can achieve that with less code:

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

Result (examples):

• cjnp56brdy
• 9d5uv84zfa
• ih162lryez
• ri4ocf6tkj
• xj04s83egi

Scheers

Great solution, but it can only return 1 occurrence of each letter, which limits the possibilities. I rewrote it slightly: function gen_uid($l=10){ $str = ""; for ($x=0;$x<$l;$x++) $str .= substr(str_shuffle("0123456789abcdefghijklmnopqrstuvwxyz"), 0, 1); return $str; } – Uhf

@Uhf Your solution is much more random, which is good. But it's completely unnecessary to shuffle the string every time for your solution. Whatever your $character_list is (alnum, etc), you just need to take a random single-letter substring: $str .= substr($character_list,rand(0,61),1); (I tested with [0-9A-Za-z], 62 characters) If speed is important, I ran this version 1 million times in 4.57-4.93s vs 9.96-10.34s for yours. – Muth

Answer 4

There are two ways to obtain a reliably unique ID: Make it so long and variable that the chances of a collision are spectacularly small (as with a GUID) or store all generated IDs in a table for lookup (either in memory or in a DB or a file) to verify uniqueness upon generation.

If you're really asking how you can generate such a short key and guarantee its uniqueness without some kind of duplicate check, the answer is, you can't.

Faithfaithful

Answer 5

Here's the routine I use for random base62s of any length...

Calling gen_uuid() returns strings like WJX0u0jV, E9EMaZ3P etc.

By default this returns 8 digits, hence a space of 64^8 or roughly 10^14, this is often enough to make collisions quite rare.

For a larger or smaller string, pass in $len as desired. No limit in length, as I append until satisfied [up to safety limit of 128 chars, which can be removed].

Note, use a random salt inside the md5 [or sha1 if you prefer], so it cant easily be reverse-engineered.

I didn't find any reliable base62 conversions on the web, hence this approach of stripping chars from the base64 result.

Use freely under BSD licence, enjoy,

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

Blinders

for uppercase version, use this line instead - $uid = ereg_replace("["A-Z0-9]","",strtoupper($uid)); – Blinders

Random but if the salt was a variable, is there a way to reverse this to find the salt variable? – Olwen

Answer 6

Really simple solution:

Make the unique ID with:

$id = 100;
base_convert($id, 10, 36);

Get the original value again:

intval($str,36);

Can't take credit for this as it's from another stack overflow page, but I thought the solution was so elegant and awesome that it was worth copying over to this thread for people referencing this.

Huckster

This totally fails "The only requirements are that it should not have an obvious order" – Watchword

Answer 7

You could use the Id and just convert it to base-36 number if you want to convert it back and forth. Can be used for any table with an integer id.

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

Smart people can probably figure it out with enough id examples. Dont let this obscurity replace security.

Oppose

Is there any way to use base_convert() to include upper and lower case letters and 0-9? Does base_convert($uid, 62, 10) work? – Sitdown

JoshFinnie: you'll have to make your own case sensitive function for higher base values then 36. – Oppose

Answer 8

I came up with what I think is a pretty cool solution doing this without a uniqueness check. I thought I'd share for any future visitors.

A counter is a really easy way to guarantee uniqueness or if you're using a database a primary key also guarantees uniqueness. The problem is it looks bad and and might be vulnerable. So I took the sequence and jumbled it up with a cipher. Since the cipher can be reversed, I know each id is unique while still appearing random.

It's python not php, but I uploaded the code here: https://github.com/adecker89/Tiny-Unique-Identifiers

Annalisaannalise

Answer 9

Letters are pretty, digits are ugly. You want random strings, but don't want "ugly" random strings?

Create a random number and print it in alpha-style (base-26), like the reservation "numbers" that airlines give.

There's no general-purpose base conversion functions built into PHP, as far as I know, so you'd need to code that bit yourself.

Another alternative: use uniqid() and get rid of the digits.

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

Or replace them with letters:

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

Choke

This is pretty close to what i want. Airline ticket id's are a good example of this as well. Basically what i want is a good way to create this random ~3-5 character/digit code, which i can then convert to a string. Uniqid is otherwise fine, just too long. – Amorphous

Answer 10

You can also do it like tihs:

public static function generateCode($length = 6)
    {
        $az = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        $azr = rand(0, 51);
        $azs = substr($az, $azr, 10);
        $stamp = hash('sha256', time());
        $mt = hash('sha256', mt_rand(5, 20));
        $alpha = hash('sha256', $azs);
        $hash = str_shuffle($stamp . $mt . $alpha);
        $code = ucfirst(substr($hash, $azr, $length));
        return $code;
    }

His

Answer 11

You can do that without unclean/costy stuff like loops, String concatenations or multiple calls to rand(), in a clean and easy to read way. Also, it is better to use mt_rand():

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

If you need the String to have the exact length in any case, just pad the hex number with zeros:

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

The "theoretical backdraw" is, that you are limited to PHPs capabilities - but this is more a philosophical issue in that case ;) Let's go through it anyways:

• PHP is limited in what it can represent as a hex number doing it like this. This would be $length <= 8 at least on a 32bit system, where PHPs limitation for this should be 4.294.967.295 .
• PHPs random number generator also has a maximum. For mt_rand() at least on a 32bit system, it should be 2.147.483.647
• So you are theoretically limited to 2.147.483.647 IDs.

Coming back to the topic - the intuitive do { (generate ID) } while { (id is not uniqe) } (insert id) has one drawback and one possible flaw that might drive you straight to darkness...

Drawback: The validation is pessimistic. Doing it like this always requires a check at the database. Having enough keyspace (for example length of 5 for your 10k entries) will quite unlikely cause collisions as often, as it might be comparably less resource consuming to just try to store the data and retry only in case of a UNIQUE KEY error.

Flaw: User A retrieves an ID that gets verified as not taken yet. Then the code will try to insert the data. But in the meantime, User B entered the same loop and unfortunately retrieves the same random number, because User A is not stored yet and this ID was still free. Now the system stores either User B or User A, and when attempting to store the second User, there already is the other one in the meantime - having the same ID.

You would need to handle that exception in any case and need to re-try the insertion with a newly created ID. Adding this whilst keeping the pessimistic checking loop (that you would need to re-enter) will result in quite ugly and hard to follow code. Fortunately the solution to this is the same like the one to the drawback: Just go for it in the first place and try to store the data. In case of a UNIQUE KEY error just retry with a new ID.

Binetta

No need to check database, but blindly insert / catch / regenerate. – Rodriquez

This is very fast! But only outputs HEX values. Only 16 values per character. I benchmarked 1 million iterations of your first version at 1.301-1.331s, second at 1.834-1.928s. I tested other answers at 5-10s for 1 million. For my own purposes, I care about packing in the most unique values into the shortest strings, not speed, so I'll use the second fastest solution. – Muth

Answer 12

Take a lookt at this article

• Create short IDs with PHP - Like Youtube or TinyURL

It explains how to generate short unique ids from your bdd ids, like youtube does.

Actually, the function in the article is very related to php function base_convert which converts a number from a base to another (but is only up to base 36).

Mudra

Answer 13

10 chars:

substr(uniqid(),-10);

5 binary chars:

hex2bin( substr(uniqid(),-10) );

8 base64 chars:

base64_encode( hex2bin( substr(uniqid(),-10) ) );

Deme

Answer 14

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

Sassan

Answer 15

If you do like a longer version of unique Id use this:
$uniqueid = sha1(md5(time()));

Olsson

Answer 16

Best Answer Yet: Smallest Unique "Hash Like" String Given Unique Database ID - PHP Solution, No Third Party Libraries Required.

Here's the 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;

}

?>

Seriate

Main reason to have uniqid is to avoid request to database at first palce. – Irkutsk