[AS3]as3的一下随机函数工具类（很好用的随机）(2)

import index.base.func.random; 
 
trace(random.boolean+"（随机一个布尔值）"); 
trace(random.color()+"（随机一个rgb颜色值）"); 
trace(random.color("153-255","0-100","0-100")+"（随机一个偏红的rgb颜色值）"); 
trace(random.wave+"（随机一个波动值）"); 
trace(random.string()+"（随机一个字符）"); 
trace(random.integer(4)+"（随机一个int值）"); 
trace(random.number(4)+"（随机一个number值）"); 
trace(random.string("a-z,a-z")+"（在一个范围随机字符）"); 
trace(random.string("我,你,他")+"（在一个范围随机中文字符）"); 
trace(random.ranges(5,4,3,-1,-10,-14,true)+"（在多个指定范围随机数值）"); 
trace(random.range(4,9)+"（在一个指定范围随机数值）"); 
trace(random.bit(8)+"（随机一个八位的字符串）"); 
trace(random.bit(16,"0-1")+"（随机一个十六位的二进制）"); 
trace("…………") 
 
//生成一个偏红的颜色色块 
var sh:shape = new shape(); 
var rgb:uint = random.color("204-255","0-153","0-153"); 
trace(rgb1.tostring(16)); 
sh.graphics.beginfill(rgb); 
sh.graphics.drawrect(100,100,100,100); 
addchild(sh); 
 
//生成一个颜色偏深或者偏淡的颜色色块 
var sh1:shape = new shape(); 
var rgb1:uint = random.color("0-20,240-255","0-20,240-255","0-20,240-255"); 
trace(rgb1.tostring(16)); 
sh1.graphics.beginfill(rgb1); 
sh1.graphics.drawrect(200,100,100,100); 
addchild(sh1); 
 
/** 
* 输出： 
* false（随机一个布尔值） 
* 8370486（随机一个rgb颜色值） 
* 12322387（随机一个偏红的rgb颜色值） 
* -1（随机一个波动值） 
* e（随机一个字符） 
* 3（随机一个int值） 
* 1.0007172282785177（随机一个number值） 
* m（在一个范围随机字符） 
* 我（在一个范围随机中文字符） 
* -14（在多个指定范围随机数值） 
* 5（在一个指定范围随机数值） 
* idpjav1l（随机一个八位的字符串） 
* 1010100101010100（随机一个十六位的二进制） 
* ………… 
* dd5506 
* fef003 
*/ 

类文件：

package index.base.func{ 
        
        public final class random{ 
                
                public function random(){ 
                        throw new error("随机函数工具包无法实例化！"); 
                } 
                
                //获取一个随机的布尔值 
                public static function get boolean():boolean{ 
                        return boolean(integer(2)); 
                } 
                
                //获取一个正负波动值 
                public static function get wave():int{ 
                        return integer(2) * 2 - 1; 
                } 
                
                //获取一个随机的范围整数值 
                public static function integer(num:number):int{ 
                        return math.floor(number(num)); 
                } 
                
                //获取一个随机的范围number值 
                public static function number(num:number):number{ 
                        return math.random() * num; 
                } 
                
                //在一个范围内获取一个随机值，返回结果范围：num1 >= num > num2 
                public static function range(num1:number,num2:number,isint:boolean = true):number{ 
                        var num:number = number(num2 - num1) + num1; 
                        if(isint) num = math.floor(num); 
                        return num; 
                } 
                
                //在多个范围获取随机值 
                public static function ranges(...args):number{ 
                        var isint:boolean = args[args.length - 1] is boolean ? args.pop() : true; 
                        var num:number = randomrange(args); 
                        if(!isint) num += math.random(); 
                        return num; 
                } 
                
                //获取一个随机字符，默认随机范围为数字+大小写字母，也可以指定范围，格式：a-z,a-h,5-9 
                public static function string(str:string = "0-9,a-z,a-z"):string{ 
                        return string.fromcharcode(randomrange(explain(str))); 
                } 
                
                //生成指定位数的随机字符串 
                public static function bit(num:int,str:string = "0-9,a-z,a-z"):string{ 
                        var restr:string = ""; 
                        for(var i:int = 0; i < num; i ++) restr += string(str); 
                        return restr; 
                } 
                
                //获取一个随机的颜色值 
                public static function color(red:string = "0-255",green:string = "0-255",blue:string = "0-255"):uint{ 
                        return number("0x" + transform(randomrange(explain(red,false))) + 
                                                                 transform(randomrange(explain(green,false))) + 
                                                                 transform(randomrange(explain(blue,false)))); 
                } 
                
                //将10进制的rgb色转换为2位的16进制 
                private static function transform(num:uint):string{ 
                        var restr:string = num.tostring(16); 
                        if(restr.length != 2) restr = "0" + restr; 
                        return restr; 
                } 
                
                //字符串解析 
                private static function explain(str:string,iscodeat:boolean = true):array{ 
                        var argar:array = new array; 
                        var tmpar:array = str.split(","); 
                        for(var i:int = 0; i < tmpar.length; i ++){ 
                                var ar:array = tmpar[i].split("-"); 
                                if(ar.length == 2){ 
                                        var ararpush0:string = ar[0]; 
                                        var ararpush1:string = ar[1]; 
                                        if(iscodeat){ 
                                                arpush0arpush0 = arpush0.charcodeat().tostring(); 
                                                arpush1arpush1 = arpush1.charcodeat().tostring(); 
                                        } 
                                        //此处如果不加1，将不会随机ar[1]所表示字符，因此需要加上1，随机范围才是对的 
                                        argar.push(number(arpush0),number(arpush1) + 1); 
                                }else if(ar.length == 1){ 
                                        var ararpush:string = ar[0]; 
                                        if(iscodeat) arpusharpush = arpush.charcodeat().tostring(); 
                                        //如果范围是1-2，那么整型随机必定是1，因此拿出第一个参数后，把范围定在参数+1，则就是让该参数参加随机 
                                        argar.push(number(arpush),number(arpush) + 1); 
                                } 
                                ar = null; 
                        } 
                        tmpar = null; 
                        return argar; 
                } 
                
                //获取随机范围 
                private static function randomrange(ar:array):number{ 
                        var tmpar:array = new array; 
                        var length:int = ar.length; 
                        if(length % 2 != 0 || length == 0) throw new error("参数错误！无法获取指定范围！"); 
                        //将所有可能出现的随机数存入数组，然后进行随机 
                        for(var i:int = 0; i < length / 2; i ++){ 
                                var i1:int = ar[i * 2]; 
                                var i2:int = ar[i * 2 + 1]; 
                                if(i1 > i2){ 
                                        var tmp:number = i1; 
                                        i1 = i2; 
                                        i2 = tmp; 
                                } 
                                for(i1; i1 < i2; i1 ++) tmpar.push(i1); 
                        } 
                        var num:number = tmpar[integer(tmpar.length)]; 
                        tmpar = null; 
                        ar = null; 
                        return num; 
                } 
                
        } 
        
}