PHP Random Url Names (Short Url)

PHP random URL names (short URL)

This is not random, there based of the ID of your database record.

How it works:

basically you have a string that is unique but it can be decrypted to represent a number, you should look at it as a short encryption / decryption.

You have a function that would take an unique ID and then it creates a Unique 'short string' from that id, and then you can reverse the process to get the unique id from the short string.

Here's a snipped I have found of a website:

function alphaID($in, $to_num = false, $pad_up = false, $passKey = null)
{
    $index = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    if ($passKey !== null)
    {
        /* Although this function's purpose is to just make the
        * ID short - and not so much secure,
        * with this patch by Simon Franz (http://blog.snaky.org/)
        * you can optionally supply a password to make it harder
        * to calculate the corresponding numeric ID */

        for ($n = 0; $n<strlen($index); $n++)
        {
            $i[] = substr( $index,$n ,1);
        }

        $passhash = hash('sha256',$passKey);

        $passhash = (strlen($passhash) < strlen($index)) ? hash('sha512',$passKey) : $passhash;

        for ($n=0; $n < strlen($index); $n++)
        {
            $p[] =  substr($passhash, $n ,1);
        }

        array_multisort($p,  SORT_DESC, $i);
        $index = implode($i);
    }

    $base  = strlen($index);

    if ($to_num)
    {
        // Digital number  <<--  alphabet letter code
        $in  = strrev($in);
        $out = 0;
        $len = strlen($in) - 1;

        for ($t = 0; $t <= $len; $t++)
        {
            $bcpow = bcpow($base, $len - $t);
            $out   = $out + strpos($index, substr($in, $t, 1)) * $bcpow;
        }

        if (is_numeric($pad_up))
        {
            $pad_up--;
            if ($pad_up > 0)
            {
                $out -= pow($base, $pad_up);
            }
        }
        $out = sprintf('%F', $out);
        $out = substr($out, 0, strpos($out, '.'));
    }
    else
    {
        // Digital number  -->>  alphabet letter code
        if (is_numeric($pad_up))
        {
            $pad_up--;
            if ($pad_up > 0)
            {
                $in += pow($base, $pad_up);
            }
        }

        $out = "";
        for ($t = floor(log($in, $base)); $t >= 0; $t--)
        {
            $bcp = bcpow($base, $t);
            $a   = floor($in / $bcp) % $base;
            $out = $out . substr($index, $a, 1);
            $in  = $in - ($a * $bcp);
        }
        $out = strrev($out); // reverse
    }
    return $out;
}

Example

alphaID(9007199254740989);   //-> PpQXn7COf
alphaID('PpQXn7COf', true);  //-> 9007199254740989

there's a link to the script here: https://github.com/kvz/deprecated/blob/kvzlib/php/functions/alphaID.inc.php

PHP short hash like URL-shortening websites

URL shortening services rather use a auto incremented integer value (like a supplementary database ID) and encode that with Base64 or other encodings to have more information per character (64 instead of just 10 like digits).

Is the str::random() function in Laravel reliable for short URL?

Should you trust Str::random() to always return an alpha-numeric string? Yes.

The function normalizes its output by encoding to base 64 number. The 64 symbols that represent a base 64 number are ABCDEFGHIJKLMNOPQRSTUVWXYVabcdefghijklmnopqrstuvwxyz0123456789+\ and = for padding.

The function also replaces \+= to empty (white spaces), meaning that the only possible output for Str::random() are amongst ABCDEFGHIJKLMNOPQRSTUVWXYVabcdefghijklmnopqrstuvwxyz0123456789.

---

Laravel 5+'s Illuminate\Support\Str@random

public static function random($length = 16)
{
    $string = '';

    while (($len = strlen($string)) < $length) {
        $size = $length - $len;
        
        $bytes = random_bytes($size);
        
        $string .= substr(str_replace(['/', '+', '='], '', base64_encode($bytes)), 0, $size);
    }

    return $string;
}

---

Related Topics