[AS3,Color]常用的一些颜色的常量

/**
 * The color white.  
 */
public static const WHITE:uint   = 0xFFFFFFFF;

/**
 * The color light gray.  
 */
public static const LIGHT_GRAY:uint = 0xFFC0C0C0;

/**
 * The color gray.  
 */
public static const GRAY:uint   = 0xFF808080;

/**
 * The color dark gray.  
 */
public static const DARK_GRAY:uint  = 0xFF404040;

/**
 * The color black.  
 */
public static const BLACK:uint   = 0xFF000000;

/**
 * The color red.  
 */
public static const RED:uint   = 0xFFFF0000;

/**
 * The color pink.  
 */
public static const PINK:uint   = 0xFFFFAFAF;

/**
 * The color orange.  
 */
public static const ORANGE:uint  = 0xFFFFC800;

/**
 * The color yellow.  
 */
public static const YELLOW:uint  = 0xFFFFFF00;

/**
 * The color green.  
 */
public static const GREEN:uint   = 0xFF00FF00;

/**
 * The color magenta.  
 */
public static const MAGENTA:uint  = 0xFFFF00FF;

/**
 * The color cyan.  
 */
public static const CYAN:uint   = 0xFF00FFFF;

/**
 * The color blue.  
 */
public static const BLUE:uint   = 0xFF0000FF;

[AS3,Math]立方根

/**
* 立方根
*
* @param v 一个数字。
* @return 数字的立方根。
*/

public static function cbrt(value:Number):Number {
 return Math.pow(value, 1/3);
}

[AS3,I/O]URLVariables 的编码器

/**
* URLVariables 的编码器。
* 把一个对象转换为 URLVariables 的格式的字符串。
* URLVariables 的格式为"a=value1&b=value2"。
* @param o 一个对象。
* @return URLVariables 的格式的字符串。
*/

public static function encode(o:Object):String {
 var varList:XMLList = describeType(o).variable;
 var result:String = "";
 for(var i:String in o) {
  result += encodeURIComponent(i) + "=" + encodeURIComponent(o[i]) + "&";
 }
 for each(var v:XML in varList) {
  result += encodeURIComponent(v.@name) + 
   "=" + encodeURIComponent(o[v.@name]) + "&";
 }
 return result.substring(0, result.length-1);
}

[AS3,I/O]Base85的解码器

需要 Base85CharSet，请参见[AS3,I/O]Base85的字符集。
关联项目：[AS3,I/O]Base85的编码器(Base85Encoder)。

package advancedflex.io.format {
 
 import flash.utils.ByteArray;
 import flash.utils.Endian;
 import flash.utils.IDataOutput;
 
 /**
  * Base85的解码器
  * 
他把5个字节的文本数据4转换为个字节的2进制数据。
  * @see Base85CharSet
  * @see Base85Encoder
  */
 public class Base85Decoder {

  /**
   * 解码为String
   * 
   * @param src 密文
   * @param charSet 逆字符集
   * @return 原文
   * 
   * @see Base85CharSet#RFC_1924
   * @see Base85Encoder#encode
   */
  public static function decode(src:String, charSet:Object = null):String {
   var bytes:ByteArray = new ByteArray();
   bytes.writeUTFBytes(src);
   var mark:int = bytes.length;
   decodeByteArray(src, bytes, charSet ? charSet : Base85CharSet.RFC_1924);
   bytes.position = mark;
   return bytes.readUTFBytes(bytes.bytesAvailable);
  }

  /**
   * 解码为ByteArray
   * 
   * @param data 密文
   * @param output 输出流
   * @param decharSet 逆字符集
   * 
   * @see Base85CharSet#RFC_1924
   * @see Base85Encoder#encodeByteArray
   */
  public static function decodeByteArray(data:String, output:IDataOutput, decharSet:Object = null):void {
   decharSet = decharSet ? decharSet : Base85CharSet.DECODE_RFC_1924;
   var dataLength:int = data.length;
   var endbytes:int = dataLength % 5;
   dataLength -= endbytes;
   //decode normal group of bytes
   for(var i:int = 0; i < dataLength;i++) {
    output.writeUnsignedInt(
     decharSet[data.charAt(i)] + 
     decharSet[data.charAt(++i)]*85 + 
     decharSet[data.charAt(++i)]*(85*85) + 
     decharSet[data.charAt(++i)]*(85*85*85) + 
     decharSet[data.charAt(++i)]*(85*85*85*85)
    );
   }
   //decode last group of bytes
   var buf:int;
   switch(endbytes) {
    case 0:
     break;
    case 4:
     buf = (
      decharSet[data.charAt(i)] + 
      decharSet[data.charAt(++i)]*85 + 
      decharSet[data.charAt(++i)]*(85*85) + 
      decharSet[data.charAt(++i)]*(85*85*85)
     );
     if(output.endian == Endian.BIG_ENDIAN) {
      output.writeByte(
       (buf&0xFF0000) >> 16
      );
      output.writeByte(
       (buf&0x00FF00) >> 8
      );
      output.writeByte(
       (buf&0x0000FF)
      );
     } else {
      output.writeByte(
       (buf&0x0000FF)
      );
      output.writeByte(
       (buf&0x00FF00) >> 8
      );
      output.writeByte(
       (buf&0xFF0000) >> 16
      );
     }
     break;
    case 3:
     output.writeShort(
      decharSet[data.charAt(i)] + 
      decharSet[data.charAt(++i)]*85 + 
      decharSet[data.charAt(++i)]*(85*85)
     );
     break;
    default: //2
     output.writeByte(
      decharSet[data.charAt(i)] + 
      decharSet[data.charAt(++i)]*85
     );
     break;
   }
  }
 }
}

[AS3,I/O]Base85的编码器

需要 Base85CharSet，请参见[AS3,I/O]Base85的字符集

package advancedflex.io.format {
    import flash.utils.ByteArray;
    import flash.utils.IDataInput;
   
    /**
     * Base85的编码器
     * 
他把4个字节的2进制数据转换为5个字节的文本数据。数据的增加度为25%。
     *
     * @see Base85CharSet
     * @see Base85Decoder
     */
    public class Base85Encoder {
        /**
         * 用String来编码
         *
         * @param src 原文
         * @param charSet Base85字符集，默认为 Base85CharSet.RFC_1924
         * @return 密文（原文编码后的数据）
         *
         * @see Base85CharSet#RFC_1924
         */
        public static function encode(src:String, charSet:Array = null):String {
            // Convert string to ByteArray
            var bytes:ByteArray = new ByteArray();
            bytes.writeUTFBytes(src);
            bytes.position = 0;
            return encodeByteArray(bytes, charSet ? charSet : Base85CharSet.RFC_1924);
        }
       
        /**
         * 用ByteArray来编码
         * @param data 原文的输入流
         * @param charSet Base85字符集，默认为 Base85CharSet.RFC_1924
         * @return 密文（原文编码后的数据）
         *
         * @see Base85CharSet#RFC_1924
         */
        public static function encodeByteArray(data:IDataInput, charSet:Array = null):String {
            charSet = charSet ? charSet : Base85CharSet.RFC_1924;
            // Initialise output
            var output:String = "";                        //output
            var srcLength:int = data.bytesAvailable;    //length of normal bytes
            var endbytes:int = srcLength % 4;            //length of extra bytes.
            var buf:uint;                                //encode buffer
           
            //set this var to correct value.(normal = all - extra)
            srcLength -= endbytes;
           
            //encode normal group of bytes
            for(var i:int = 0; i < srcLength; i+=4) {
                buf = data.readUnsignedInt();
                output += charSet[buf % 85];
                buf /= 85;
                output += charSet[buf % 85];
                buf /= 85;
                output += charSet[buf % 85];
                buf /= 85;
                output += charSet[buf % 85];
                buf /= 85;
                output += charSet[buf % 85];
            }
           
            //encode last group of bytes
            buf = 0;
            for(var j:int = 0; j < endbytes; j++) {
                buf = (buf << 8) | data.readByte();
            }
            switch(endbytes) {
                case 0:        //no extra byte
                    break;
                case 3:        //has 3 extra bytes
                    output += charSet[buf % 85];
                    buf /= 85;
                case 2:        //has 2 extra bytes
                    output += charSet[buf % 85];
                    buf /= 85;
                default:    //has 1 extra byte
                    output += charSet[buf % 85];
                    buf /= 85;
                    output += charSet[buf % 85];
            }
            return output;
        }
    }
}

[AS3,I/O]Base85的字符集

package advancedflex.io.format {
    /**
     * Base85的字符集(Character Set)
     *
     * @see http://rfc.net/rfc1924.html RFC-1924
     * @see Base85Decoder
     * @see Base85Encoder
     */
    public final class Base85CharSet {
       
        /**
         * 在RFC-1924里定义的一般的字符集(根据编码算字符)
         */
         //0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~
        public static const RFC_1924:Array =
        [
            "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
            "A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
            "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
            "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d",
            "e", "f", "g", "h", "i", "j", "k", "l", "m", "n",
            "o", "p", "q", "r", "s", "t", "u", "v", "w", "x",
            "y", "z", "!", "#", "$", "%", "&", "(", ")", "*",
            "+", "-", ";", "<", "=", ">", "?", "@", "^", "_",
            "`", "{", "|", "}", "~",
        ];
        /**
         * 在RFC-1924里定义的一般的逆字符集(根据字符算编码)
         */
        public static const DECODE_RFC_1924:Object =
        {
            "0":0,  "1":1,  "2":2,  "3":3,  "4":4,  "5":5,  "6":6,  "7":7,  "8":8, "9":9,
            "A":10, "B":11, "C":12, "D":13, "E":14, "F":15, "G":16, "H":17, "I":18, "J":19,
            "K":20, "L":21, "M":22, "N":23, "O":24, "P":25, "Q":26, "R":27, "S":28, "T":29,
            "U":30, "V":31, "W":32, "X":33, "Y":34, "Z":35, "a":36, "b":37, "c":38, "d":39,
            "e":40, "f":41, "g":42, "h":43, "i":44, "j":45, "k":46, "l":47, "m":48, "n":49,
            "o":50, "p":51, "q":52, "r":53, "s":54, "t":55, "u":56, "v":57, "w":58, "x":59,
            "y":60, "z":61, "!":62, "#":63, "$":64, "%":65, "&":66, "(":67, ")":68, "*":69,
            "+":70, "-":71, ";":72, "<":73, "=":74, ">":75, "?":76, "@":77, "^":78, "_":79,
            "`":80, "{":81, "|":82, "}":83, "~":84
        };
        /**
         * 在ascii85里定义的一般的字符集(根据编码算字符)
         */
         //!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv
        public static const ASCII85:Array =
        [
            "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*",
            "+", ",",  "-", ".", "/", "0", "1", "2", "3", "4",
            "5", "6",  "7", "8", "9", ":", ";", "<", "=", ">",
            "?", "@",  "A", "B", "C", "D", "E", "F", "G", "H",
            "I", "J",  "K", "L", "M", "N", "O", "P", "Q", "R",
            "S", "T",  "U", "V", "W", "X", "Y", "Z", "[", "]",
            "^", "_",  "`", "a", "b", "c", "d", "e", "f", "g",
            "h", "i",  "j", "k", "l", "m", "n", "o", "p", "q",
            "r", "s",  "t", "u", "v",
        ];
        /**
         * 在ascii85里定义的一般的字符集(根据编码算字符)
         */
        public static const DECODE_ASCII85:Object =
        {
            "!":0,  "\"":1, "#":2,  "$":3,  "%":4,  "&":5,  "'":6,  "(":7,  ")":8,  "*":9,
            "+":10, ",":11, "-":12, ".":13, "/":14, "0":15, "1":16, "2":17, "3":18, "4":19,
            "5":20, "6":21, "7":22, "8":23, "9":24, ":":25, ";":26, "<":27, "=":28, ">":29,
            "?":30, "@":31, "A":32, "B":33, "C":34, "D":35, "E":36, "F":37, "G":38, "H":39,
            "I":40, "J":41, "K":42, "L":43, "M":44, "N":45, "O":46, "P":47, "Q":48, "R":49,
            "S":50, "T":51, "U":52, "V":53, "W":54, "X":55, "Y":56, "Z":57, "[":58, "]":59,
            "^":60, "_":61, "`":62, "a":63, "b":64, "c":65, "d":66, "e":67, "f":68, "g":69,
            "h":70, "i":71, "j":72, "k":73, "l":74, "m":75, "n":76, "o":77, "p":78, "q":79,
            "r":80, "s":81, "t":82, "u":83, "v":84
        }
    }
}

[AS3,Event]实现 IEventDispatcher 接口的类模板

package {
    import flash.events.IEventDispatcher;
    import flash.events.Event;
    import flash.events.EventDispatcher;

    /**
     * 抽象的 EventDispatcher。
     * 实现 IEventDispatcher 接口的模板。
     */
    public class AbstractEventDispatcher implements IEventDispatcher {
        protected var _listener:EventDispatcher;
        public function AbstractEventDispatcher() {
            _listener = new EventDispatcher(this);
        }
       
        public function hasEventListener(type:String):Boolean {
            return _listener.hasEventListener(type);
        }
       
        public function willTrigger(type:String):Boolean {
            return _listener.willTrigger(type);
        }
       
        public function addEventListener(
            type:String, listener:Function, useCapture:Boolean=false,
            priority:int=0.0, useWeakReference:Boolean=false):void
        {
            _listener.addEventListener(
                type, listener, useCapture,
                priority, useWeakReference);
        }
       
        public function removeEventListener(
            type:String, listener:Function, useCapture:Boolean=false):void
        {
            _listener.removeEventListener(type, listener, useCapture);
        }
       
        public function dispatchEvent(event:Event):Boolean {
            return _listener.dispatchEvent(event);
        }
    }
}

[AS3,Display]全屏模式

package advancedflex.core {
   import flash.display.DisplayObject;
   import flash.display.Stage;
   import flash.display.StageDisplayState;
   import flash.geom.Rectangle;
 
   /**
    * 全屏模式
    */
   public class FullScreen {
     
       /**
        * 进入全屏模式。
        *
        * @param display 任意一个加入了 displayList 的 DisplayObject。
        */
       public static function go(display:DisplayObject):void {
           var stage:Stage = display.stage;
           stage["fullScreenSourceRect"] = new Rectangle(0, 0, stage.width, stage.height);
           stage.displayState = StageDisplayState.FULL_SCREEN;
       }
     
       /**
        * 退出全屏模式。
        *
        * @param display 任意一个加入了 displayList 的 DisplayObject。
        */
       public static function back(display:DisplayObject):void {
           display.stage.displayState = StageDisplayState.NORMAL;
       }
   }
}

[AS3,Math]微分

/**
* 微分。
*
* @param f 被微分的函数
* @param x x。
* @param delta dx的大小。
* @return f(x)的斜率。
*/

public static function diff(f:Function, x:Number, delta:Number = 1e-8):Number {
    return (f(x+delta) - f(x)) / delta;
}

[AS3]把32位整数转换为8为整数

/**
* 把32位整数转换为8为整数。
*
* @param n 32位整数
* @return 8为整数
*/

public function toByte(n:int):int {
    if(n > 0) {
        return n & 0x8000007F;
    } else {
        return -(-n & 0x8000007F);
    }
}

[AS3]把32位整数转换为16为整数

/**
* 把32位整数转换为16为整数。
*
* @param n 32位整数
* @return 16为整数
*/

public function toShort(n:int):int {
    if(n > 0) {
        return n & 0x80007FFF;
    } else {
        return -(-n & 0x80007FFF);
    }
}

[AS3]拟柱体数值积分

/**
* 在[a, b]间的拟柱体数值积分。

* @param f 积分函数
* @param a 左界限
* @param b 右界限
* @return [a, b]间的定积分
*/

public static function cylinderInte(f:Function, a:Number, b:Number):Number {
   var h:Number = b-a;
   return (h/6)*(f(a) + 4*f( (a+b) / 2 ) + f(b));
}

加入 MXNA

今天我收到了来自 MXNA 的邮件，正式加入了 MXNA。

MXNA 是一个关于 Adobe 产品的 Blog 聚合，包含了大量的 RIA 的内容。

[AS3]辛普森数值积分

/**
* 在[a, b]间的辛普森数值积分
* @param f 积分函数
* @param a 左界限
* @param b 右界限
* @param n 分段数
* @return [a, b]间的定积分
*/

public static function simpsonInte(f:Function, a:Number, b:Number, n:int = 1024):Number {
 n*=2;//2n => n
 var h:Number = (b-a) / (n);
 var x1:Number = 0;
 var x2:Number = 0;
 n--;//2n-1 => n
 for(var i:int = 1; i i++*/) {
  x1 += f(a + i*h);
  i++;//i+1 => i
  x2 += f(a + i*h);
 }
 return (h/3)*(f(a) + f(b) + 4*x1 + 2*x2);
}

[AS3]梯形数值积分

/**
* 在[a, b]间的梯形数值积分
* @param f 被积分函数
* @param a 左界限
* @param b 右界限
* @param n 分段数
* @return [a, b]间的定积分
*/

public static function trapezoidalInte(f:Function, a:Number, b:Number,n:int = 1024):Number {
 var h:Number = (b-a) / n;
 var result:Number = 0;
 n--;//n-1 => n
 for(var i:int = 1; i<n; i++) {
  result += f(a + i*h);
 }
 return (h/2)*(f(a) + f(b) + 2*result);
}

[AS3]忽略符号的四舍五入

/**
* 忽略符号的四舍五入。
*
* AMath.rint(1.2) //-> 1
* AMath.rint(-1.2)//-> -1
* AMath.rint(1.7) //-> 2
* AMath.rint(-1.7)//-> -2
* @param v a Number
* @return Rounded Nuumber.
*/

public static function rint(v:Number):int {
 if(v > 0) {
  return int(v + 0.5);
 }
 if(v < 0) {
  return -int(-v + 0.5);
 }else{
  return 0;
 }
}

[AS3]截取 ByteArray 中某一范围的元素

/**
* 截取原始 ByteArray 中某一范围的元素构成的新 ByteArray。
* 返回的 ByteArray 包括 start 元素以及从其开始到 end 元素（但不包括该元素）的所有元素。
*
* @param bytes 原始 ByteArray
* @param result 返回指针，如果为 null，将会创建新的 ByteArray。
* @param start 开始下标，负数表示从后面开始数。
* @param end 结束下标，负数表示从后面开始数。
* @return result
*/

public static function slice(
 bytes:ByteArray, result:IDataOutput = null, 
 start:int = 0, end:int = -1):IDataOutput
{
 if(!bytes) {
  throw new ArgumentError("Param: must not be null.");
 }
 var totalLength:int = bytes.length;
 if(!result) result = new ByteArray();
 if(start<0) start = totalLength + start;
 if(end<0) end = totalLength + end;
 var length:int = end - start + 1;
 result.writeBytes(bytes, start, length);
 return result;
}

[AS3]颜色反转滤镜

需要 IBitmapFilterFactory。

package advancedflex.graphics.images.filters {
 
 import flash.filters.BitmapFilter;
 import flash.filters.ColorMatrixFilter;

 /**
  * 颜色反转工厂。
  * 
它是AFGL(Advanced Flex Graphics Library)的一部分。
  */
 public class ReversesFilterFactory implements IBitmapFilterFactory {
  
  /* The Reverses Matrix */
  private static const $MATRIX:Array = [
   -1, 0, 0, 0, 255,
    0,-1, 0, 0, 255,
    0, 0,-1, 0, 255,
    0, 0, 0, 1, 0,
  ];
  
  /**
   * 创建滤镜。
   * @return 滤镜。
   */
  public function create():BitmapFilter {
   return new ColorMatrixFilter($MATRIX);
  }
  
  /**
   * 释放滤镜工厂占用的大内存，但实际上什么也不做。
   * 调用后在调用其他方法时也不会发成错误。
   */
  public function dispose():void {
   //Do Nothing.
  }
  
  /**
   * 返回 ReversesFilterFactory 对象，
   * 它是与原始 ReversesFilterFactory 对象完全相同的副本。
   * @return ReversesFilterFactory 对象。
   */
  public function clone():IBitmapFilterFactory {
   return new ReversesFilterFactory();
  }
  
 }
}

[AS3]图像滤镜效果的接口

这个类为今后将会发布的图像滤镜效果的接口。

package advancedflex.graphics.images.filters {
 
 import flash.filters.BitmapFilter;
 
 /**
  * IBitmapFilterFactory 类是所有图像滤镜效果工厂的接口。
  * 他可以创建各种 BitmapFilter。
  * 它是AFGL(Advanced Flex Graphics Library)的一部分。
  */
 public interface IBitmapFilterFactory {
  
  /**
   * 创建滤镜。
   * @return 滤镜。
   */
  function create():BitmapFilter;
  
  /**
   * 返回 IBitmapFilterFactory 对象，
   * 它是与原始 IBitmapFilterFactory 对象完全相同的副本。
   * @return IBitmapFilterFactory 对象。
   */
  function clone():IBitmapFilterFactory;
  
  /**
   * 释放滤镜工厂占用的大内存(如果有的话)。
   * 对 BitmapFilterFactory 调用 dispose() 方法时，
   * 对此 BitmapFilterFactory 实例的方法或属性的所有后续调用都将失败，并引发异常。
   */
  function dispose():void;
 }
}

[AS3]生成呈高斯分布的伪随机数(2)

/**
* 用极坐标法(polar method)生成一个呈高斯分布的伪随机数。
*
* 这使用了 G. E. P. Box、M. E. Muller 和 G. Marsaglia 的极坐标法，
* 该方法在 Donald E. Knuth 的 The Art of Computer Programming,
* Volume 3:Seminumerical Algorithms 的第 3.4.1 节，小节 C，算法 P 中进行了描述。
* 注意，它只需调用一次 Math.log 和调用一次 Math.sqrt 就可以生成两个独立的值
*
* @param mu 平均值μ
* @param sigma 标准差σ^2
*
* @return 伪随机数。
*/

public static function getGaussian2(mu:Number = 0, sigma:Number = 1):Number {
 if (haveNextNextGaussian) {
  haveNextNextGaussian = false;
   return nextNextGaussian;
 } else {
  var v1:Number, v2:Number, s:Number;
  do {
   v1 = 2 * Math.random() - 1; // between -1.0 and 1.0
   v2 = 2 * Math.random() - 1; // between -1.0 and 1.0
    s = v1 * v1 + v2 * v2;
  } while (s >= 1 || s == 0);
  var multiplier:Number = Math.sqrt(-2 * Math.log(s)/s);
  nextNextGaussian = v2 * multiplier;
  haveNextNextGaussian = true;
  return v1*multiplier*sigma + mu;
 }
}

private static var nextNextGaussian:Number;
private static var haveNextNextGaussian:Boolean = false;

[AS3]生成呈高斯分布的伪随机数

/**
* 用雅可比变换生成一个呈高斯分布的伪随机数。
*
* @param mu 平均值μ
* @param sigma 标准差σ^2
* @return 伪随机数。
*/

public static function getGaussian(mu:Number = 0, sigma:Number = 1):Number {
 var r1:Number = Math.random();
 var r2:Number = Math.random();
 return Math.sqrt( -2*Math.log(r1) ) * Math.cos( 2*Math.PI*r2 ) * sigma+mu;
}

[AS3]根据名字得到类

/**
* 根据名字得到类。它包括使用 registerClassAlias 定义的类。
* 它相当于 Java 中的 Class.forName。
* @param name 类的名字。
* @return 类。
* @see flash.utils.getDefinitionByName
* @see flash.net.getClassByAlias
*/

public static function forName(name:String):Class {
 try {
  return getDefinitionByName(name) as Class;
 } catch(e:ReferenceError) {
  try {
   return getClassByAlias(name);
  } catch(e2:ReferenceError) {
   throw new ReferenceError("There is not such a class:<"+name+">.");
  }
 }
 return null;
}

[AS3]使用黄金分割查找法来搜索数组的元素

需要FloatUtil.equals，请参照[AS3]判断两个浮点小数的数组是否相等。

Class : advancedflex.utils.FloatArrayUtil

/**
* 使用黄金分割查找法来搜索数组的元素。
*
* @param sortedArray 排成升序(从小到大)的数组。
* @param value 要查找的值。
* @param tol 浮点小数的计算误差。
* @return 元素的下标。如果没有，则返回 -1。
*/

public static function gsearch(sortedArray:Array, value:Number, tol:Number = 1e-12):int {
 if(!sortedArray) {
  throw new ArgumentError("Param: must not be null.");
 }
 return $gsearch(sortedArray, value, tol, 0, sortedArray.length);
}

/**
 * @private
 */
private static const $LEFT_RATIO:Number = 0.6180339887498949;

/**
 * @private
 */
private static const $RIGHT_RATIO:Number = 1 - $LEFT_RATIO;

 /**
 * @private
 * 使用黄金分割查找法来搜索数组的元素。
 * 
 * @param sortedArray 排成升序(从小到大)的数组。
 * @param value 要查找的值。
 * @param tol 浮点小数的计算误差。
 * @param left 查找的最左边。
 * @param right 查找的最右边。
 * @return 元素的下标。如果没有，则返回 -1。
 */
private static function $gsearch(
 sortedArray:Array, value:Number, tol:Number,
 left:int, right:int):int 
{
 if(right - left <= 1) {
  return FloatUtil.equals(sortedArray[left], value, tol) ? left :
   FloatUtil.equals(sortedArray[right], value, tol) ? left :
   -1;
 }
 var center:int = $RIGHT_RATIO*left + $LEFT_RATIO*right
 switch(FloatUtil.compare(sortedArray[center], value, tol)) {
  case 1 :
   return $gsearch(sortedArray, value, tol, left, center);
  case -1:
   return $gsearch(sortedArray, value, tol, center, right);
  default:
   return center;
 }
}

[AS3]使用二分法查找法来搜索数组的元素

需要FloatUtil.equals，请参照[AS3]判断两个浮点小数的数组是否相等

Class : advancedflex.utils.FloatArrayUtil

/**
* 使用二分查找法来搜索数组的元素。
*
* @param sortedArray 排成升序(从小到大)的数组。
* @param value 要查找的值。
* @param tol 浮点小数的计算误差。
* @return 元素的下标。如果没有，则返回 -1。
* @throws ArgumentError 如果 sortedArray 为 null。
*/


public static function bsearch(sortedArray:Array, value:Number, tol:Number = 1e-12):int {
 if(!sortedArray) {
  throw new ArgumentError("Param: must not be null.");
 }
 return $bsearch(sortedArray, value, tol, 0, sortedArray.length-1);
}
/**
 * @private
 * 使用二分查找法来搜索数组的元素。
 * 
 * @param sortedArray 排成升序(从小到大)的数组。
 * @param value 要查找的值。
 * @param tol 浮点小数的计算误差。
 * @param left 查找的最左边。
 * @param right 查找的最右边。
 * @return 元素的下标。如果没有，则返回 -1。
 */
private static function $bsearch(
 sortedArray:Array, value:Number, tol:Number,
 left:int, right:int):int 
{
 if(right - left <= 1) {
  return FloatUtil.equals(sortedArray[left], value, tol) ? left :
   FloatUtil.equals(sortedArray[right], value, tol) ? left :
   -1;
 }
 var center:int = (left+right)/2;
 switch(FloatUtil.compare(sortedArray[center], value, tol)) {
  case 1 :
   return $bsearch(sortedArray, value, tol, left, center);
  case -1:
   return $bsearch(sortedArray, value, tol, center, right);
  default:
   return center;
 }
}

[AS3]判断两个对象的数据类型是否一样

/**
* 判断两个对象的数据类型是否一样。
*
* @param a 一个对象。
* @param b 另一个对象。
* @return 如果一样，返回 true；否则返回 false。
*/

public static function eqType(a:Object, b:Object):Boolean {
 return  a === b
  || describeType(a).@name == describeType(b).@name;
}

[AS3]两个浮点小数的数组相加

/**
* 两个浮点小数的数组相加。
* @sample addArray([1,2], [3,4]); // -> [4,6]
*
* @param a 一个浮点小数的数组。
* @param b 另一个浮点小数的数组。
* @param result 返回结果的数组，如果为 null，将会创建新的数组返回。
* @return 结果。如果 result 不为 null，将会返回 result；否则将会创建新的数组返回。
*/

public static function addArray(a:Array, b:Array, result:Array = null):Array {
 var length:int = Math.max(a.length, b.length);
 result = result || new Array(length);
 for(var i:int = 0; i < length; i++) {
  result[i] = a[i] + b[i];
 }
 return result;
}

[AS3]判断是否为闰年

/**
* 判断是否为闰年。
*
* @param date 时间。
* @return 如果是闰年返回 true；否则为 false。
*/

public static function isLeapYear(date:Date):Boolean {
 var year:int = date.fullYear;
 return (year%4 == 0 && year%100 != 0) || year%400 == 0;
}

[AS3]得到 Array 指定的元素的个数。

/**
* 得到指定的元素的个数。
*
* @param array 数组。
* @param value 元素。
* @return 个数。
* @throws ArgumentError 当 array 为 null 时。
*/

public static function count(array:Array, value:*):int {
if(!array) {
 throw new ArgumentError("Param: must not be null.");
}
var found:int = 0;
var length:int = array.length;
for(var i:int = 0; i <>

[AS3]打乱数组的排列顺序

需要 swap 函数，请参见[AS3]交换数组中的两个下标的值。

/**
* 打乱数组的排列顺序。
*
* @param array 数组。
* @return 数组本身。
*/

public static function random(array:Array):Array {
 var length:int = array.length/2 + 1;
 var last:int = array.length;
 var idx:int;
 for(var i:int = 0; i < length; i++) {
  idx = i + int(Math.random()*last);
  last--;
  swap(array, i, idx);
 }
 return array;
}

[AS3]交换数组中的两个下标的值

/**
* 交换数组中的两个下标的值。
*
* @param array 数组。
* @param idx1 一个下标。
* @param idx2 另一个下标。
*/

public static function swap(array:Array, idx1:int, idx2:int):void {
 var tmp:* = array[idx1];
 array[idx1] = array[idx2];
 array[idx2] = tmp;
}

[AS3]删除数组中的重复的元素

/**
* 删除数组中的重复的元素。顺序为第一次出现的顺序。
*
* @sample unique([1,1,2,1,3,2,1,1]) // -> [1,2,3]
* @param array 数组。
* @return 删除给与数组中的重复的元素后的新数组。
*/

public static function unique(array:Array):Array {
 var result:Array = [];
 var valueSet:Dictionary = new Dictionary(false);
 var length:int = array.length;
 for(var i:int = 0; i < length; i++) {
  if(!valueSet[array[i]]) {
   result.push(array[i]);
   valueSet[array[i]] = true;
  }
 }
 return result;
}

[AS3]执行给予的 JavaScript

/**
* 执行给予的JavaScript。
* @param src javaScript
*/

public static function evalJS(src:String):void {
 if (src != null) {
  const commentPattern:RegExp = 
   /(\/\*([^*]|[\r\n]|(\*+([^*\/]|[\r\n])))*\*+\/)|((^|[^:\/])(\/\/.*))/g;
  src = src.replace (commentPattern, "");
 }
 var u:URLRequest = new URLRequest ("javascript:eval('" + src + "');");
 navigateToURL(u,"_self");
}

[AS3]得到帧率

使用方法：

package {
 import flash.display.Sprite;
 import advancedflex.core.FPSView;
 public class TestFPS extends Sprite {
  //把FPSView 添加到enterFrame事件里，这样才能查看帧率。
  addEventListener("enterFrame", FPSView.instance.enterFrameHandler);
  //得到帧率，这个属性可以被绑定。
  trace(FPSView.instance.fps);
 }
}

源码：

/////////////////////////////////////////////////////////////////////////////
//Copyright 2007 Advanced Flex Project http://code.google.com/p/advancedflex/. 
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
/////////////////////////////////////////////////////////////////////////////
package advancedflex.core {
 
 import flash.events.Event;
 import flash.utils.getTimer;
 
 /**
  * 查看帧率。
  */
 public class FPSView {
  //instance
  private static const $INSTANCE:FPSView = new FPSView();
  
  /**
   * 得到实例。
   * 
   * @return instance 实例。
   */
  public static function get instance():FPSView {
   return $INSTANCE;
  }
  
  //first time
  private var ft:int;
  把
  //second time
  private var st:int;
  
  [Bindable]
  /**
   * 帧率。
   */
  public var fps:int;
  
  /**
   * EnterFrame Event Handler.你必须把它添加到DisplayObject才能查看帧率。
   */
  public function enterFrameHandler(event:Event):void {
   st = getTimer();
   fps = Math.round(1000 / (st - ft));
   ft = st;
  }
 }
}

[AS3]给字符串加上N个字符使长度达到指定的值

需要repect 函数。请参见[AS3]高速重复字符串

/**
* 在左边加上N个字符，使长度达到length。比如：lpad("abc", 5, "1")//->11abc
*
* @param str 源字符串.
* @param 长度
* @param ch 字符，长度必须为1.
*
* @return 更新后的字符串.
*/

public static function lpad(str:String, length:int, ch:String = " "):String {
 if(str.length >= length) {
  return str;
 }
 if(ch.length != 1) {
  throw new SyntaxError("ch.length must be 1.");
 }
 return  repeat(ch, length - str.length) + str;
}

/**
* 在右边加上N个字符，使长度达到length。比如：rpad("abc", 5, "1")//->abc11
*
* @param str 源字符串.
* @param 长度
* @param ch 字符，长度必须为1.
*
* @return 更新后的字符串.
*/

public static function rpad(str:String, length:int, ch:String = " "):String {
 if(str.length >= length) {
  return str;
 }
 if(ch.length != 1) {
  throw new SyntaxError("ch.length must be 1.");
 }
 return  str + repeat(ch, length - str.length);
}

[AS3]高速重复字符串

/**
* 重复 str times 次。
* @param str 源字符串。
* @param times 重复次数。
* @return 结果
*/

public static function repeat(str:String, times:int):String {
 if(times <= 0) 
  return "";
 return $repeat(str, times);
}

/**
 * @private
 *
 * 重复 str times 次。
 * @param str 源字符串。
 * @param times 重复次数。
 * @return 结果
 */
private static function $repeat(str:String, times:int):String {
 /*
  *        | s       (n     = 1)
  * f(s,n)=| f(s, n/2)*2    (n % 2 = 0)
  *        | s + f[s, (n-1) / 2]*2  (n % 2 = 1)
  */
 var tmp:String;
 if(times == 1)
  return str;
 if(times % 2 == 0) {
  tmp = $repeat(str, times / 2)
  return tmp + tmp;
 } else {
  tmp = $repeat(str, (times - 1) / 2)
  return str + tmp + tmp;
 }
}

[AS3]删除字符串的空白

需要 mx.utils.StringUtil

/**
* 删除左边的空白(空格、\t、\r、\n、\f)。
* @param str 要被删除空白的字符串。
* @return 删除空白后的字符串。
*/

public static function ltrim(str:String):String {
 var startIndex:int = 0;
 while (StringUtil.isWhitespace(str.charAt(startIndex))) {
  startIndex++;
 }
 return str.slice(startIndex, -1);
}

/**
* 去掉右边的空白(空格、\t、\r、\n、\f)。
* @param str 要被删除空白的字符串。
* @return 删除空白后的字符串。
*/

public static function rtrim(str:String):String {
 var endIndex:int = str.length - 1;
 while (StringUtil.isWhitespace(str.charAt(endIndex))) {
  endIndex--;
 }
 return str.slice(0, endIndex + 1);
}

[AS3]把 ByteArray 转换为 16 进制

/**
* 把 ByteArray 转换为 16 进制。
* 格式为 "BB BB BB BB BB BB BB BB|BB BB..."，"BB" 表示一个字节。
*
* @param bytes ByteArray
* @return 把 ByteArray 转换为16进制后的字符串。
*/

public static function toHex(bytes:ByteArray):String {
 var pos:int = bytes.position;
 bytes.position = 0;
 var result:String = "";
 while(bytes.bytesAvailable >= 8) {
  result +=  $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + "|";
 }
 while(bytes.bytesAvailable>1) {
  result += $toHexNum(bytes.readUnsignedByte()) + " "
 }
 if(bytes.bytesAvailable) {
  result += $toHexNum(bytes.readUnsignedByte());
 }
 bytes.position = pos;
 return result;
}

/**
 * @private
 * 
 * 把 1 个字节转换为 16 进制的字符串。
 * 
 * @param n 1 个字节。
 * @return 16 进制的字符串。
 */
private static function $toHexNum(n:uint):String {
 return n <= 0xF ? "0" + n.toString(16) : n.toString(16);
}

[AS3]判断两个对象是否相等

需要 eqByteArray 函数，请参见 [AS3]判断两个 ByteArray 是否相等。

/**
* 判断两个对象是否相等，它使用深层比较。
* @param a 一个对象。
* @param b 另一个对象。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqObject(a:Object, b:Object):Boolean {
 if(a === b) {
  return true;
 }
 var bytesA:ByteArray = new ByteArray()
 bytesA.writeObject(a);
 var bytesB:ByteArray = new ByteArray()
 bytesB.writeObject(b);
 return eqByteArray(bytesA, bytesB);
}

[AS3]判断两个浮点小数的数组是否相等

需要 eqFloat 函数。请参见：[AS3]比较两个浮点小数

/**
* 在考虑计算误差的情况下，判断两个浮点小数的数组是否相等。
*
* @param a 一个浮点小数的数组。
* @param b 另一个浮点小数的数组。
* @param tol 允许的最大浮点小数的计算误差。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqFloatArray(a:Array, b:Array,
    tol:Number = 1e-12):Boolean
{
    if(a.length != b.length) {
        return false;
    }
    var l:int = a.length;
    for(var i:int = 0; i < l; i++) {
        if(!eqFloat(a[i], b[i], tol)) {
            return false;
        }
    }
    return true;
}

[AS3]判断两个 ByteArray 是否相等

/**
* 判断两个 ByteArray 是否相等。
*
* @param a 一个 ByteArray。
* @param b 另一个 ByteArray。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqByteArray(a:ByteArray, b:ByteArray):Boolean {
    if(a.length != b.length) {
        return false;
    }
    var posA:int = a.position;
    var posB:int = b.position;
    var result:Boolean = true;
    a.position = b.position = 0;
    while(a.bytesAvailable >= 4) {
        if(a.readUnsignedInt() != b.readUnsignedInt()) {
            result = false;
            break;
        }
    }
    if(result && a.bytesAvailable != 0) {
        var last:int = a.bytesAvailable;
        result =
            last == 1 ? a.readByte() == b.readByte() :
            last == 2 ? a.readShort() == b.readShort() :
            last == 3 ? a.readShort() == b.readShort()
                && a.readByte() == b.readByte() :
            true;
    }
    a.position = posA;
    b.position = posB;
    return result;
}

[AS3]比较两个浮点小数

/**
* 在考虑计算误差的情况下，判断两个浮点小数是否相等。
*
* @param a 一个浮点小数。
* @param b 另一个浮点小数。
* @param tol 允许的最大浮点小数的计算误差。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqFloat(a:Number, b:Number,
  tol:Number = 1e-12):Boolean
{
  return Math.abs(a - b) < tol;
}

/**
* 在考虑计算误差的情况下，判断两个浮点小数的大小。
*
* @param a 一个浮点小数。
* @param b 另一个浮点小数。
* @param tol 允许的最大浮点小数的计算误差。
* @return 如果相等，返回 0；ab，返回 1。
*/

public static function compareFloat(a:Number, b:Number, 
  tol:Number = 1e-12):int
{
  return eqFloat(a, b, tol) ? 0 :
         a < b ? -1 :
         1;
}

Getting Starts

ActionScript Snippets 是一个收集 Advanced Flex Project 在开发时有用的代码、类的博客。

代码均遵循 Apache License 2.0。希望对大家有所帮助。