Random uniek id genereren

Post hier de source-code van je script. Alle informatie tussen <? ... ?> en <?php ... ?> zal automatisch worden getoond in color-coding. 

Let op! Het is niet de bedoeling om hier een link naar je website te plaatsen. Post hier gewoon de code, veel simpeler, sneller en meer kans dat het blijft staan.

<?php
class Uniqid {
    
    const index = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
    public static function encode($number){
        
        if(!isset($number)){
            return null;
        }
 
        $base = strlen(self::index);
        $out = "";
        
        for ($t = floor(log($number, $base)); $t >= 0; $t--) {
        
            $bcp = bcpow($base, $t);
            $a   = floor($number / $bcp) % $base;
            $out = $out . substr(self::index, $a, 1);
            $number  = $number - ($a * $bcp);
        }
      
        $out = strrev($out);
        
        return $out;
    }
 
    public static function decode($string){

        $base = strlen(self::index);
        $string  = strrev($string);
        $out = 0;
        $len = strlen($string) - 1;
 
        for ($t = 0; $t <= $len; $t++){
            
            $bcpow = bcpow($base, $len - $t);
            $out = $out + strpos(self::index, substr($string, $t, 1)) * $bcpow;
        }
 
        $out = sprintf('%F', $out);
        $out = substr($out, 0, strpos($out, '.'));
      
        return $out;
    }
}
?>

<?php
/**
 *  Javascript randUniqID class
 *  Description: Translates a numeric identifier into a short string and backwards.
 *
 *  Usage:
 *    var str = randUniqID.encode(9007199254740989); // str = 'fE2XnNGpF'
 *    var id = randUniqID.decode('fE2XnNGpF'); // id = 9007199254740989;
 **/

var randUniqID = {
  index:'abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
 
  /**
   *  @function randUniqID.encode
   *  @description Encode a number into short string
   *  @param integer
   *  @return string
   **/
  encode:function(_number){
    if('undefined' == typeof _number){
      return null;
    }
    else if('number' != typeof(_number)){
      throw new Error('Wrong parameter type');
    }
 
    var ret = '';
 
    for(var i=Math.floor(Math.log(parseInt(_number))/Math.log(randUniqID.index.length));i>=0;i--){
      ret = ret + randUniqID.index.substr((Math.floor(parseInt(_number) / randUniqID.bcpow(randUniqID.index.length, i)) % randUniqID.index.length),1);
    }
 
    return ret.reverse();
  },
 
  /**
   *  @function randUniqID.decode
   *  @description Decode a short string and return number
   *  @param string
   *  @return integer
   **/
  decode:function(_string){
    if('undefined' == typeof _string){
      return null;
    }
    else if('string' != typeof _string){
      throw new Error('Wrong parameter type');
    }
 
    var str = _string.reverse();
    var ret = 0;
 
    for(var i=0;i<=(str.length - 1);i++){
      ret = ret + randUniqID.index.indexOf(str.substr(i,1)) * (randUniqID.bcpow(randUniqID.index.length, (str.length - 1) - i));
    }
 
    return ret;
  },
 
  /**
   *  @function randUniqID.bcpow
   *  @description Raise _a to the power _b
   *  @param float _a
   *  @param integer _b
   *  @return string
   **/
  bcpow:function(_a, _b){
    return Math.floor(Math.pow(parseFloat(_a), parseInt(_b)));
  }
};
 
/**
 *  @function String.reverse
 *  @description Reverse a string
 *  @return string
 **/
String.prototype.reverse = function(){
  return this.split('').reverse().join('');
};
?>

<?sql
CREATE FUNCTION rand_uniqid(IN sequence_name text, OUT uniek_id text) AS $$
BEGIN
/* functie  */
END
$$ LANGUAGE plpgsql; 

CREATE SEQUENCE test START 101;

CREATE TABLE test (
 id text DEFAULT rand_uniqid('test') PRIMARY KEY,
 kolom2 text,
 kolom3 text
);

N.V.T.

<?php
echo 'Hello world!';
?>

<?php 

CREATE OR REPLACE FUNCTION string_to_bits(input_text TEXT) 
RETURNS TEXT AS $$
DECLARE
    output_text TEXT;
    i INTEGER;
BEGIN
    output_text := '';


    FOR i IN 1..char_length(input_text) LOOP
        output_text := output_text || ascii(substring(input_text FROM i FOR 1))::bit(8);
    END LOOP;


    return output_text;
END;
$$ LANGUAGE plpgsql; 


CREATE OR REPLACE FUNCTION id_to_sid(id INTEGER) 
RETURNS TEXT AS $$
DECLARE
    output_text TEXT;
    i INTEGER;
    index TEXT[];
    bits TEXT;
    bit_array TEXT[];
    input_text TEXT;
BEGIN
    input_text := id::TEXT;
    output_text := '';
    index := string_to_array('0,d,A,3,E,z,W,m,D,S,Q,l,K,s,P,b,N,c,f,j,5,I,t,C,i,y,o,G,2,r,x,h,V,J,k,-,T,w,H,L,9,e,u,X,p,U,a,O,v,4,R,B,q,M,n,g,1,F,6,Y,_,8,7,Z', ',');
    
    bits := string_to_bits(input_text);
    
    IF length(bits) % 6 <> 0 THEN
        bits := rpad(bits, length(bits) + 6 - (length(bits) % 6), '0');
    END IF;

    FOR i IN 1..((length(bits) / 6)) LOOP
        IF i = 1 THEN
            bit_array[i] := substring(bits FROM 1 FOR 6);
        ELSE
            bit_array[i] := substring(bits FROM 1 + (i - 1) * 6 FOR 6);
        END IF;

        output_text := output_text || index[bit_array[i]::bit(6)::integer + 1];
    END LOOP;


    return output_text;
END;
$$ LANGUAGE plpgsql; 

 ?>

<script>
/*jslint white: true, browser: true, onevar: true, undef: true, nomen: true, eqeqeq: true, newcap: true, immed: true */

/*global Crypto:true */

if (typeof Crypto === 'undefined') {
    Crypto = {};
}

Crypto.random = (function () {
    var index = [
        'b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm',
        'n', 'p', 'q', 'r', 't', 'v', 'w', 'x', 'y', 'z',
        '_', '-', '0', '1', '2', '3', '4', '5', '6', '7',
        '8', '9', 'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K',
        'L', 'M', 'N', 'P', 'Q', 'R', 'T', 'V', 'W', 'X',
        'Y', 'Z'
    ], base = index.length;

    return {
        encode: function (i) {
            var out = [],
                t = Math.floor(Math.log(i) / Math.log(base)),
                bcp,
                a;

            while (t >= 0) {
                bcp = Math.pow(base, t);
                a = Math.floor(i / bcp) % base;
                out[out.length] = index[a];
                i -= a * bcp;

                t -= 1;
            }

            return out.reverse().join('');
        },
        decode: function (i) {
            var chars = i.split(''),
                out = 0,
                el;

            while (typeof (el = chars.pop()) !== 'undefined') {
                out += index.indexOf(el) * Math.pow(base, chars.length);
            }

            return out;
        }
    };
}());
</script>

Voorbeeld:

<script>
alert(Crypto.random.encode(101010101));
alert(Crypto.random.decode('XMzNr'));
</script>