沉默的船付出水面，直接贡献开源代码，文章首发AS3天地会与蓝色理想，转载请注明。



参考资料，灵感提供：http://bbs.blueidea.com/thread-2850987-1-2.html



贡献一个工具类，经过多种方案的测试，应该是效率最高，随机性最强的解决方案，当然只是作为自信的程序员自己那么认为，强烈欢迎网友合理拍砖，提供更好方案，讨论把这个类做好，主要用途将体现在游戏开发中，实用性还是比较强的。Xiaos8网友还有很多使用的类发布在他的blog里，有兴趣的朋友可以去支持他一下。

由于开源，既然被拿去用，我相信个性的定义是毫无作用的，所以我这里包定义是空的，我相信就算我定义成cn.hack86.uilts也会瞬间被使用的网友del，呵呵，玩笑。

本来想写个类继承Array来提供最后3个方法，但是将他发在这里也是可行的。如果网友还有什么好的随机方案提出，我可以继续扩展此类，提供相应的解决方案。





public final class Random



    public static function get boolean() : Boolean

    public static function get wave() : int

    public static function get color() : uint



    public static function integet(num : int) : int

    public static function number(num : int) : Number

    public static function char(...args) : String

    public static function string(num : int) : String



    public static function intRange(n1 : uint, n2 : uint) : int

    public static function numRange(n1 : Number, n2 : Number) : Number

    public static function charRange(s1 : String, s2 : String) : String



    public static function intRanges(...args) : int

    public static function numRanges(...args) : Number

    public static function charRanges(...args) : String

    public static function strRanges(num : uint,...args) : String

    public static function colorRanges(r1:uint=0, r2:uint=255, g1:uint=0, g2:uint=255, b1:uint=0, b2:uint=255) : uint



    public static function disorder(arr : Array) : Array

    public static function takeOut(num : uint, arr : Array) : Array

    public static function find(num : uint, arr : Array) : Array





Random.boolean : Boolean

随机获取一个布尔值，true或者false



Random.ware : int

随机获取一个波形值，1或者-1



Random.color : uint

随机获得一个32位色颜色代码



Random.integet(num:int) : int

随机获得0~num的整数，其中不包括num



Random.number(num:int) : Number

随机获得0~num的双精度浮点小数，其中不包括num



Random.char(…args) : String

随机获得所有指定参数中的任何一个字符



Random.string(num:int) : String

随机获得一个指定长度的字符串，范围是26个大小字母和10个数字



Random.intRange(n1:uint, n2:uint) : uint

随机获得一个指定范围内的整数N，并且 较小数 <= N < 较大数



Random.numRange(n1: Number, n2: Number) : uint

随机获得一个指定范围内的双精度浮点小数N，并且 较小数 <= N < 较大数



Random.charRange(n1:Stirng, n2:Stirng) : String

随机获得一个指定范围内的字符N，包括两个范围界线的字符



Random.intRanges(…args) : int

随机获得多个指定范围内的整数，参数成双输入，若出现奇数个参数则报错

如 Random.intRanges(4,8,12,20,45,70); 则返回4~8,12~20,45~70之间的任何一个整数，获得的随机数界限标准可参考 Random.intRange(n1:int, n2:int)



Random.numRanges(…args) : Number

同Random.intRanges(…args),只是返回的类型是双精度浮点



Random.charRanges(…args) : String

随机获得多个指定范围内的字符，参数成双输入，若出现奇数个参数则报错

如 Random.intRanges(4,8,12,20,45,70); 则可能返回4~8,12~20,45~70之间的任何一个整数，获得的随机数界限标准可参考 Random.charRange(n1:Stirng, n2: Stirng)



Random.strRanges(num:uint, …args) : String

随机获得指定长度的多个指定范围内的字符串，参考Random.charRanges(…args)



Random.colorRanges(r1:uint=0, r2:uint=255, g1:uint=0, g2:uint=255, b1:uint=0, b2:uint=255) : uint

随机获得特殊要求的颜色，如随机返回一个偏红的颜色值：

Random.colorRanges (153,255,0,100,0,100);



Random.disorder(arr:Array) : Array

随机打乱数组，并返回(是否使用返回又实际需求决定)



Random.takeOut(num:uint, arr:Array) : Array

随机从原数组中取出指定个数的元素，并且在原数组中删除它们。从表面上看此函数功能与Random.find函数相同，但是Random.find不修改原数组，效率更高，此方法在需要删除随机选中的元素时使用更为妥当。



Random.find(num:uint, arr:Array) : Array

随机从原数组中取出指定个数的元素，在新数组中返回。

复制内容到剪贴板

代码:

package {
    public final class Random {
        public static function get boolean() : Boolean {
            return Math.random() < .5;
        }
        public static function get wave() : int {
            return Math.random() < .5 ? -1 : 1;
        }
        public static function get color() : uint {
            return Math.random() * 16777216;
        }
        public static function integet(num : int) : int {
            return Math.random() * num;
        }
        public static function number(num : int) : Number {
            return Math.random() * num;
        }
        public static function char(...args) : String {
            return args[int(Math.random() * args.length)];
        }
        public static function string(num : int) : String {
            for (var i : uint = 0,src : String = "";i < num;i++) {
                src += charRanges("0", "9", "A", "Z", "a", "z");
            }
            return src;
        }
        public static function intRange(n1 : uint, n2 : uint) : uint {
            return Math.random() * (n2 - n1) + n1;
        }
        public static function numRange(n1 : Number, n2 : Number) : Number {
            if (n1 < 0 || n2 < 0) {
                throw new Error("参数错误：不可为负数。");
            }
            return Math.random() * (n2 - n1) + n1;
        }
        public static function charRange(s1 : String, s2 : String) : String {
            var n1 : uint = s1.charCodeAt(0),n2 : uint = s2.charCodeAt(0);
            return String.fromCharCode(int(Math.random() * (n2 - n1)) + n1);
        }
        public static function intRanges(...args) : int {
            var n1s : Array = new Array();
            var n2s : Array = new Array();
            while (args.length) {
                n1s.push(args.shift());
                n2s.push(args.shift());
            }
            var len : uint = n1s.length;
            var s1 : uint = 0, s2 : uint = 0;
            for (var i : uint = 0;i < len; i++) {
                s1 += n1s[i];
                s2 += n2s[i];
            }
            var r : int = Math.random() * (s2 - s1) + n1s[0];
            i = 0;
            while (r >= n2s[i++]) {
                r += n1s[i] - n2s[i - 1];
            }
            return r;
        }
        public static function numRanges(...args) : Number {
            var n1s : Array = new Array();
            var n2s : Array = new Array();
            while (args.length) {
                n1s.push(args.shift());
                n2s.push(args.shift());
            }
            var len : uint = n1s.length;
            var s1 : uint = 0, s2 : uint = 0;
            for (var i : uint = 0;i < len; i++) {
                s1 += n1s[i];
                s2 += n2s[i];
            }
            do {
                var r : Number = Math.random() * (s2 - s1) + n1s[0];
                i = 0;
                while (r >= n2s[i++]) {
                    r += n1s[i] - n2s[i - 1];
                }
            } while (isNaN(r));
            return r;
        }
        public static function charRanges(...args) : String {
            var n1s : Array = new Array();
            var n2s : Array = new Array();
            while (args.length) {
                n1s.push(args.shift().charCodeAt(0));
                n2s.push(args.shift().charCodeAt(0) + 1);
            }
            var len : uint = n1s.length;
            var s1 : uint = 0, s2 : uint = 0;
            for (var i : uint = 0;i < len; i++) {
                s1 += n1s[i];
                s2 += n2s[i];
            }
            var r : int = Math.random() * (s2 - s1) + n1s[0];
            i = 0;
            while (r >= n2s[i++]) {
                r += n1s[i] - n2s[i - 1];
            }
            return String.fromCharCode(r);
        }
        public static function strRanges(num : uint,...args) : String {
            var n1s : Array = new Array();
            var n2s : Array = new Array();
            while (args.length) {
                n1s.push(args.shift().charCodeAt(0));
                n2s.push(args.shift().charCodeAt(0) + 1);
            }
            var len : uint = n1s.length;
            var s1 : uint = 0, s2 : uint = 0;
            for (var i : uint = 0;i < len; i++) {
                s1 += n1s[i];
                s2 += n2s[i];
            }
            var src : String = "";
            while (num-- > 0) {
                var r : int = Math.random() * (s2 - s1) + n1s[0];
                i = 0;
                while (r >= n2s[i++]) {
                    r += n1s[i] - n2s[i - 1];
                }
                src += String.fromCharCode(r);
            }
            return src;
        }
        public static function colorRanges(...args) : uint {
            return intRange(args[0], args[1] + 1) << 16 + intRange(args[2], args[3] + 1) << 8 + intRange(args[4], args[5] + 1);
        }
        public static function disorder(arr : Array) : Array {
            var len : uint = arr.length;
            var cache : *,ti : uint;
            for (var i : uint = 0;i < len;i++) {
                ti = int(Math.random() * len);
                cache = arr[i];
                arr[i] = arr[ti];
                arr[ti] = cache;
            }
            while (--i >= 0) {    
                ti = int(Math.random() * len);
                cache = arr[i];
                arr[i] = arr[ti];
                arr[ti] = cache;
            }
            return arr;
        }
        public static function takeOut(num : uint,arr : Array) : Array {
            var newArr : Array = new Array(num);
            for (var i : uint = 0;i < num; i++) {
                newArr.push(arr.splice(int(Math.random() * arr.length)), 1);
            }
            return newArr;
        }
        public static function find(num : uint, arr : Array) : Array {
            var newArr : Array = arr.concat();
            var cache : *,ti : uint, len : uint = arr.length;
            for (var i : uint = 0;i < num; i++) {
                ti = int(Math.random() * len);
                cache = newArr[i];
                newArr[i] = newArr[ti];
                newArr[ti] = cache;
            }
            return newArr.splice(0, num);
        }
    }
}

[ 本帖最后由 hack86 于 2008-5-16 20:34 编辑 ]

留个记号，慢慢看。

很牛B，学习了

integet的方法，如果不用Math.floor的话
在计算负数的时候，是直接砍掉小数点，而不是真正的取整
比如-1.6，直接看掉小数点是-1，而取整是-2

floor和int的效率是有差距的,其次你看仔细integet函数的功能是随机获得0~num的整数，其中不包括num。
再算下所有数字出现的概率，在这里用int是最适合的。
在Random这里要的就是把小数点去掉，而不是4舍5入，您仔细理解一下。

支持楼主

不错，很好的东西，，，很方便，收藏了！

不错! 很实用.

修改其中错误，takeout函数有问题，修改如下，其中方案2执行效率略微高些。

复制内容到剪贴板

代码:

public static function takeOut(num : uint,arr : Array) : Array {
    var newArr : Array = new Array();
    for (var i : uint = 0;i < num; i++) {
        newArr.push(arr.splice(int(Math.random() * arr.length), 1));
    }
    return newArr;
}

复制内容到剪贴板

代码:

public static function takeOut(num : uint,arr : Array) : Array {
    var newArr : Array = new Array(num);
    for (var i : uint = 0;i < num; i++) {
        newArr[i] = arr.splice(int(Math.random() * arr.length), 1);
    }
    return newArr;
}

增加代码功能

public static function probable(num:uint) : Boolean
函数有一定的概率返回true,如果参数为2,那么函数有1/2的概率是返回true的

复制内容到剪贴板

代码:

public static function probable(num : uint) : Array {
    return Math.random() < 1/num;
}

[ 本帖最后由 hack86 于 2008-6-24 09:52 编辑 ]

牛!学习了!

占个位先...

有点高深现在丢我来说

增加代码功能

public static function sortition(...args) : Boolean
函数将按概率的比例分配返回相对的索引值,如参数是20,5,25,50就会有20%的概率返回0,5%概率返回1,25%的概率返回2,50%的概率返回3
注意:此函数如果所有参数超过100,后面超过100的部分概率会忽律,相反如果不到100,会自动补上最后一位为剩余的概率

复制内容到剪贴板

代码:

function sortition(...args):uint {
    var num:Number = Math.random();
    var len:uint = args.length;
    for (var i:uint=0, s1:Number=0, s2:Number=0; i < len; i++) {
        s2 = s1+args[i]/100;
        if (num>=s1 && num<s2) {
            return i;
        }
        s1 = s2
    }
    return i;
}

[ 本帖最后由 hack86 于 2008-7-23 12:49 编辑 ]

学习了

colorRanges好像有点问题.. 会经常性的返回0

发现问题，加上括号就可以解决了，忽律了优先级。