Flex3 experience collection
1. release版本发布时去掉所有trace信息和logger信息
2. 如果报无法访问本地文件或swf 在compile里面写 -use-network=false
3. 实现component真正隐藏除了设置visible=false 外还需要设 includeInLayout = false
4. 设手型有时出来设buttonMode="true" useHandCursor="true" 还要设mouseChildren="false"
5. for循环时要用
var len:int = array.length;
for(var i:int = 0; i<len; i++)
{
//i 不要用number， len变量外提
}
以相反顺序进行 while 循环的速度比正向循环快：
var i:int = myArray.length;
while (--i > -1)
{
}
6. IE中FLASH链接区域鼠标闪, 在FLASH的属性参数中加上以下两句中任意一句都可以解决
<param name="wmode" value="opaque">
<param name="wmode" value="transparent">
7. 用i>>1 替代 i/2
8. 创建Object 用 var obj:Object = {} 代替 var obj:Object = new Object(); 速度提升1.5倍
创建Array 用 var arr:Array = [] 代替 var arr:Array = new Array(); 速度提升3.5倍
ArrayCollection的创建非常的慢，耗时大概是var arr:Array = []的100倍
9. 循环中，常量要提出来，例如：
var constant:String= MouseEvent.CLICK
for(var i:Number=0; i<100000; i++)
{
tmpVar = constant；
}
10. flex加载完module后，module里面的东西如果是用flash的组件，有时会出现flash组件不显示，需要调用validateNow()
11. air工程中，自定义alert跟flex工程不一样，flex可以Application.application.addChild(alert)，air在开多窗体时要Window.getWindow(obj).addChild(alert)， obj是传进来的当前对象
12. 外部读取文本要考虑转义字符的问题（比如 换行\n会变成\\n 要替换下）
13. Container的borderStyle属性设为solid，cornerRadius才会有效果了。
14. .actionScriptProperties 这个文件用来配置编译的属性，出现莫名其妙的问题的话 不妨看看这个文件
15.尽可能避免使用中括号运算符。
currentSprite = arraySprite[i];
currentSprite.x = Math.random()*stage.stageWidth;
currentSprite.y = Math.random()*stage.stageHeight;
16.请尽可能更新循环外的文本字段。
for (var i:int = 0; i< 1500; i++ )
{
content += "ActionScript 3";
}
myTextField.text = content;
17.不使用alpha属性
【改变输出swf的尺度,背景颜色或帧频】
在"Navigator"窗框里右键你的项目>选中"Properties">选中"ActionScript Compiler">在"Additional
compiler arguments"里输入你所需要的命令
如想改变背景颜色,请输入: -default-background-color 0xffffff
【鼠标坐标】
mouseX mouseY
【检查变量类型并返回布尔值】 is
【检查变量类型并返回类型】 typeof
【检查对象类型并返回该对象】 as
【是数字但不是有效数字问题】
var quantity:Number=15-"rabbits"; trace(typeof quantity);//显示: "number" , 但它是NaN (not a number) trace(quantity isNumber);//true trace(quantity !=NaN);//false //使用isNaN()函数检测: isNaN(quantity);//true //检测变量是否内含有效数字: !isNaN(quantity);//false
【取消默认的严格编译模式】
在"Navigator"窗框里右键你的项目>选中"Properties">选中"ActionScript Compiler">取消"Enabel
compile-time type checking"选项
【基元数据类型和复杂数据类型好比"值类型"和"引用类型"】
基元数据类型类似按值传递:
var intOne:int = 1;
var intTwo:int = 1;
trace(intOne == intTwo); //true
【复杂数据类型类似按引用传递】
var arrayOne:Array = new Array("a", "b");
var arrayTwo:Array = arrayOne;
trace(arrayOne == arrayTwo); //true
//-----------------------------------
var arrayOne:Array = new Array("a", "b");
var arrayTwo:Array = new Array("a", "b");
trace(arrayOne == arrayTwo); //false
【优化逻辑AND(&&)和OR(||)的小知识】
对于逻辑And(&&):
除非条件表达式的前半部分为真,否则,ActionScript不会再去求算逻辑AND运算符的后半部.如果前半部为假,整个条件表达式一定为假,所以再去求算后半部就没效率了.
对于逻辑OR(||):
除非条件表达式前半部为假,否则,ActionScript不会再去求算逻辑OR运算符的后半部,如果前半部为真,整个条件表达式一定为真.
总结:使用逻辑AND(&&)时,把结果最可能为false的表达式放到前面;使用逻辑OR(||)时,把结果最可能为true的表达式放到前面.
【Timer类注意事项】
不要认为Timer可以极其准确;使用Timer时间间隔不要低于10毫秒.
【private,protected,internal,public访问权限】
private:只能在类本身内部访问,按惯例,命名私有成员时以下划线"_"开头;
protected:可以由类本身或任何子类访问.但这是以实例为基础的.换言之,类实例可以访问自己的保护成员或者父类的保护成员,但不能访问相同类的其它实例的保护成员,按惯例,命名保护成员时以下划线"_"开头;
internal:可以由类本身或者相同包内的任何类访问;
public:可以在类内部访问,也可以由类实例访问,或者声明为static时,可以直接从类访问.
【一个函数具有未知个数的参数,用arguments对象或"...(rest)"符号访问它的参数】
注意:使用"...(rest)"参数会使 arguments 对象不可用;
private funciton average():void{
trace(arguments.length); //输出参数的个数
// arguments的类型是:object,但可以像访问数组一样去访问它
trace(arguments[1]); //输出第二个参数
}
private function average(...argu):void{
trace(argu[1]); //输出第二个参数,argu参数名是自定义的.
}
【错误处理try,catch,finally】
private function tryError():void{
try {
trace("测试开始-try");
throwError();
}catch(errObject:Error) {
trace("错误信息:" + errObject.message);
trace("测试结束-catch");
return;
}finally{
trace("虽然catch里已经有return方法,但位于return方法后面的finally里的代码依然会被执行.其实无论return方法是在try里,还是catch里,finally里的代码始终会被执行");
}
trace("前面已经有return了,此处是不会再执行的.除非没有抛出错误,以使catch里的代码没有被执行");
}
private function throwError():void{
throw new Error("抛出错误");
}
【for...in与for each...in的区别】
与for...in循环不同的是,for each...in循环中的迭代变量包含属性所保存的值,而不包含属性的名称(或主键,索引).
【命名包路径的小技巧】
使用相应于拥有者和相关项目的包名称会比较好.按惯例来讲,包名称的开头应该是逆向的网址名称.例如,如果Example
Corp(examplecorp.com)写了一些ActionScript3.0类,就会把所有类放在com.examplecorp包内(或者
com.examplecorp的子包内).如此一来,如果英国有另一家Example
Corp(examplecorp.co.uk)也写了一些ActionScript3.0类,只要使用包uk.co.examplecorp,就可确保
唯一性.
当类属于特定应用程序的一部分时,就应该放在该应用程序特定的子包内.例如,Example
Corp可能有个应用程序名叫WidgetStore.如果WidgetStore应用程序使用一个名为ApplicationManager的类,则此
类就应该放在com.examplecorp.widgetstore包内,或者位于该包的子包内.
按惯例来说,包名称的开头是小写字母.
【隐式的取出方法(getter)和设定方法(setter)】
public function get count():uint {
return _count;
}
public function set count(value:uint):uint {
if(value < 100){
_count = value;
}else {
throw Error();
}
}
【确保类是绝不会有子类,使用final】
final public class Example{}
【super关键字的使用】
super(); //父类的构造函数,只能在类实例构造函数内部使用
super.propertyName; //调用父类的属性,属性需要声明为public或protected
super.methodName(); //调用父类的方法,方法需要声明为public或protected
【建立常数,使用关键字const而不是var】
static public const EXAMPLE:String = "example";
【检测播放器版本】
flash.system.Capabilities.version
对于8.5版以前的任何Flash Player版本,这种方法都不适用.
【判断客户端系统】
flash.system.Capabilities.os
【检测播放器类型】
flash.system.Capabilities.playerType
可能的值有:
"StandAlone"，用于独立的 Flash Player
"External"，用于外部的 Flash Player 或处于测试模式下
"PlugIn"，用于 Flash Player 浏览器插件
"ActiveX"，用于 Microsoft Internet Explorer 使用的 Flash Player ActiveX 控件
【检测系统语言】
flash.system.Capabilities.language
【判断用户是否启用了IME(输入法编辑器)】
flash.system.IME.enabled
【检测屏幕的分辨率】
flash.system.Capabilities.screenResolutionX
flash.system.Capabilities.screenResolutionY
【把弹出窗口居中的算法】
X = (舞台宽/2)-(窗口宽/2)
Y = (舞台高/2)-(窗口高/2)
【控制影片配合Player的方式,包括缩放问题】
stage.scaleMode
可供选择值:flash.display.StageScaleMode
【舞台的对齐方式】
stage.align
可供选择值:flash.display.StageAlign
【隐藏Flash Player的右键菜单】
stage.showDefaultContextMenu = false;
【检测系统是否具有音频功能】
flash.system.Capabilities.hasAudio
【检测播放器是在具有MP3解码器的系统上运行,还是在没有MP3解码器的系统上运行】
flash.system.Capabilities.hasMP3
【检测播放器能 (true) 还是不能 (false) 播放流式视频】
flash.system.Capabilities.hasStreamingVideo
【检测播放器是在支持 (true) 嵌入视频的系统上运行，还是在不支持 (false) 嵌入视频的系统上运行】
flash.system.Capabilities.hasEmbeddedVideo
【检测播放器能 (true) 还是不能 (false) 对视频流（如来自 Web 摄像头的视频流）进行编码】
flash.system.Capabilities.hasVideoEncoder
【显示 Flash Player 中的"安全设置"面板】
flash.system.Security.showSettings();
可供选择项:flash.system.SecurityPanel
【让其它域的.swf访问本域的.swf】
在本域的.swf文件里加上:flash.system.Security.allowDomain()
或者使用安全策略文件"crossdomain.xml".在Flash
8以前,这个文件必须放在.swf所在域的根目录,现在,你可以使用flash.system.Security.loadPolicyFile(),指
定安全策略文件所在的位置.拒绝任何域的做法是在<cross-domain-policy>标签内什么也不填,安全策略文件也支持通用字
符"*":
<?xml version="1.0"?>
<!-- http://www.mydomain.com/crossdomain.xml -->
<cross-domain-policy>
<allow-access-from domain="www.riahome.cn" />
<allow-access-from domain="*.Y-boy.cn" />
<allow-access-from domain="210.38.196.48" />
<allow-access-from domain="*" />
</cross-domain-policy>
【数字的不同进制之间的转换】
parseInt(str:String, radix:uint = 0):Number 返回十进制的数,参数radix表示要分析的数字的基数.如果省略radix,就默认为10,除非字符串的开头是"0x","0X"或"0":
trace(parseInt("0x12")); //设定radix为16,输出:18
trace(parseInt("017")); //设定radix为8,输出:15
或者使用Number,uint和int对象的toString(radix)方法.
【使用Math.round()对一个数取整,四舍五入】
Math.round()
trace(Math.round(204.499)); //输出:204
trace(Math.round(401.5)); //输出:402
【使用Math.floor()对一个数向下取整,就是只要整数部分而不理会小数分】
trace(Math.floor(204.99)); //输出:204
【使用Math.ceil()对一个数向上取整,只要小数部分不为零,整数部分就加1】
trace(Math.ceil(401.01)); //输出:402
【产生一个随机数】
使用Math.random()产生一个伪随机数n,其中 0 <= n < 1
【把数字取至最近的小数点位,即指定精确度】
1. 决定你要取的数字的小数点位数:例如,如果你想把90.337取成90.34,就表示你要取到两位小数点位,也就是说你想取至最近的0.01;
2. 让输入值除以步骤1所选的数字(此例为0.01);
3. 使用Math.round()把步骤2所计得的值取成最近的整数;
4. 把步骤3所得的结果乘以步骤2用于除法的那个值.
例如,要把90.337取成两个小数点位数,可以使用:
trace(Math.round(90.337/0.01)*0.01); //输出:90.34
【把数字取成一个整数的最接近倍数值】
例1,这样会把92.5取成5的最近倍数值:
trace(Math.round(92.5/5)*5); //输出:95
例2,这样会把92.5取成10的最近倍数值:
trace(Math.round(92.5/10)*10); //输出:90
【在指定数值范围内获得随机数】
//可取范围:[min, max]
private function randRange(min:Number, max:Number):Number {
var randomNum:Number = Math.floor(Math.random() * (max - min + 1)) + min;
return randomNum;
}
应用例子:
模拟投银币,即希望得到随机布尔值(true 或 false): randRange(0, 1);
模拟投骰子,即希望得到随机六个值: randRange(1, 6);
为避免被缓存而需要产生一个独一无二的数字追加在URL尾端,通常最佳方法是取得当前毫秒数.
【弧度(radian)与度数(degree)之间的转换】
从弧度转为度数: degrees = radians * 180 / Math.PI
从度数转为弧度: radians = degrees * Math.PI / 180
【计算两点之间的距离】
勾股定理: c2 = a2 + b2
假设有两个影片剪辑mc1和mc2,则它们两点间的距离c为:
var c:Number = Math.sqrt(Math.pow(mc1.x - mc2.x, 2) + Math.pow(mc1.y - mc2.y, 2));
【模拟圆周运动】
已知圆心o(x0, y0),半径r和弧度angle,求圆上任意一点P(x, y)的坐标:
x = x0 + (Math.cos(angle) * r);
y = y0 + (Math.sin(angle) * r);
注意:舞台的x轴正方向水平向右,y轴正方向垂直向下.
【模拟椭圆运动】
已知圆心o(x0, y0),长轴a,短轴b以及弧度angle,求圆上任意一点P(x, y)的坐标:
x = x0 + (Math.cos(angle) * a);
y = y0 + (Math.sin(angle) * b);
【华氏温度和摄氏温度之间的转换】
华氏温度 = 摄氏度数 * 9 / 5 + 32
摄氏温度 = (华氏度数 - 32) * 5 /9
【公斤与磅之间的转换】
公斤 = 磅 * 2.2
磅 = 公斤 / 2.2
【向数组尾端添加元素】
var array:Array = new Array();
array.push("a", "b");
//向数组尾端添加单一元素也可以这样:
array[array.length] = "c";
//如果以索引设定的元素不存在,数组本身会自动扩展以包含足够的元素数目.介于中间的元素会被设为undefined:
array[5] = "e";
trace(array[4]); //输出: undefined
【向数组开端添加元素】
var array:Array = ["a", "b"];
array.unshift("c", "d");
trace(array); //输出: c,d,a,b
【删除数组中第一个元素并返回该元素,使用shift()方法】
var letters:Array = new Array("a", "b", "c");
var firstLetter:String = letters.shift();
trace(letters); //输出: b,c
trace(firstLetter); //输出: a
【删除数组中最后一个元素并返回该元素的值,使用pop()方法】
var letters:Array = new Array("a", "b", "c");
trace(letters); //输出: a,b,c
var letter:String = letters.pop();
trace(letters); //输出: a,b
trace(letter); //输出: c
【删除数组中的元素,给数组添加新元素并返回删除的元素,使用splice()方法】
splice(startIndex:int, deleteCount:uint, ... values):Array
startIndex: 一个整数，它指定数组中开始进行插入或删除的位置处的元素的索引;
deleteCount: 一个整数，它指定要删除的元素数量;
... values: 用逗号分隔的一个或多个值的可选列表或数组，此列表或数组将插入到此数组中由 startIndex 参数指定的位置.
【查找数组中第一个相匹配的元素】
var array:Array = ["a", "b", "c", "d", "a", "b", "c", "d"];
var match:String = "b";
for(var i:int = 0; i < array.length; i++) {
if(array[i] == match) {
trace("Element with index " + i + " found to match " + match);
//输出: Element with index 1 found to match b
break;
}
}
【查找数组中最后一个相匹配的元素】
var array:Array = ["a", "b", "c", "d", "a", "b", "c", "d"];
var match:String = "b";
for(var i:int = array.length - 1; i >= 0; i--) {
if(array[i] == match) {
trace("Element with index " + i + " found to match " + match);
//输出: Element with index 5 found to match b
break;
}
}
【把字符串转成数组】
使用String.split()方法:
var list:String = "I am YoungBoy.";
var words:Array = list.split(" "); //以空格作为分隔符将字符串切割
trace(words); //输出: I,am,YoungBoy.
【把数组转成字符串】
使用String.join()方法:
var myArr:Array = new Array("one", "two", "three");
var myStr:String = myArr.join(" and ");
trace(myArr); //输出: one,two,three
trace(myStr); //输出: one and two and three
【使用对象数组处理相关数据】
var cars:Array = new Array();
cars.push({make:"Mike", year:1997, color:"blue"});
cars.push({make:"Kelly", year:1986, color:"red"});
for(var i:int = 0; i < cars.length; i++) {
trace(cars[i].make + " - " + cars[i].year + " - " + cars[i].color);
}
//输出:
// Mike - 1997 - blue
// Kelly - 1986 - red
【在数组中获取最小或最大值】
var scores:Array = [10, 4, 15, 8];
scores.sort(Array.NUMERIC);
trace("Minimum: " + scores[0]);
trace("Maximum: " + scores[scores.length - 1]);
【使用for ... in语句读取关联数组元素】
var myObject:Object = new Object();
myObject.name = "YoungBoy";
myObject.age = 20;
for(var i:String in myObject) {
trace(i + ": " + myObject[i]);
}
//输出: name: YoungBoy
// age: 20
注意: for ... in循环不会显示对象所有的内建属性.例如,循环会显示执行期间新增的特殊属性,但是,不会列出内建对象的方法,即使都是储存在对象属性内.
【AVM(ActionScript Virtual Machine,虚拟机)和渲染引擎(Rendering Engine)】
AVM负责执行ActionScript程序,而渲染引擎则是把对象绘制在显示器上.
【指出容器的显示清单中有多少显示对象】
每个容器都有numChildren属性.
【把项目新增至显示清单】
addChild(child:DisplayObject)
addChildAt(child:DisplayObject, index:int)
index: 添加该子项的索引位置.如果指定当前占用的索引位置,则该位置以及所有更高位置上的子对象会在子级列表中上移一个位置.
【从显示清单中移除项目】
removeChild(child:DisplayObject)
removeChildAt(index:int)
index: 要删除的 DisplayObject 的子索引,该子项之上的任何显示对象的索引位置都减去1.
如果想移除窗口所有子元件,可以结合removeChildAt(),numChildren属性以及for循环.因为每次一个子元件被移除时,索引位置都会变化,所以,有两种方法可以处理所有子元件的移除:
1. 总是移除位置0的子元件;
2. 倒过来移除子元件,也就是从尾端开始.
【更改现有子项在显示对象容器中的位置】
setChildIndex(child:DisplayObject, index:int):void
可能用到的方法:
返回 DisplayObject 的 child 实例的索引位置: getChildIndex(child:DisplayObject):int
返回位于指定索引处的子显示对象实例: getChildAt(index:int):DisplayObject
注意:
当子元件移到低于它现在所在位置的索引时,那么,从标的索引起,直到子元件索引前面的那个索引的所有子元件都会令其索引增加1,而该子元件就会指定至标的
索引.当子元件移到较高索引时,从该子元件索引之上的那个索引起,直到标的索引的所有子元件都会令其索引往下减1,而该子元件就会指定至标的索引值.
【关于TextField以垂直方式把文字摆在按钮表面中心点的小技巧】
textField.y = (_height - textField.textHeight) / 2;
textField.y -= 2; //减2个像素以调整偏移量
【外部.swf影片载入和互动】
1. 监听init事件;
2. 透过content属性存取所载入的影片.
当所载入的影片做好足够的初始化工作,使其方法和属性可以接受互动时,init事件就会被发起.只有在载入器发起init事件后,才能控制影片.所载入的影片还没初始化就试着与它互动,是会产生执行期间错误的.
_loader.contentLoaderInfo.addEventListener(Event.INIT, handleInit); //当载入的.swf的属性和方法可用时
_loader.load(new URLRequest("ExternalMovie.swf"));
private function handleInit(event:Event):void {
var movie:* = _loader.content;
trace(movie.getColor());
movie.setColor(0xFF0000);
}
【TextField有两种类型:动态(dynamic)和输入(input),默认值为动态.改变TextField类型方法】
field.type = TextFieldType.INPUT; //selectable属性默认值为true
flash.text.TextFieldType.INPUT和flash.text.TextFieldType.DYNAMIC
【过滤文字输入】
TextField.restrict = "此处为可输入的内容";
field.restrict = "^此处为禁止输入的内容";
restrict属性支持一些类似正则表达式的样式:
field.restrict = "a-zA-z"; //只允许大小字母
field.restrict = "a-zA-z "; //只允许字母和空格
field.restrict = "0-9"; //只允许数字
field.restrict = "^abcdefg"; //除了小写字母abcdefg不允许外,其它都允许
field.restrict = "^a-z"; //所有小写字母都不允许,但是,其它内容都允许,包括大写字母
field.restrict = "0-9^5"; //只允许数字,但5例外
让restrict字符包含具有特殊意义的字母(例如-和^):
field.restrict = "0-9\\-"; //允许数字和破折号
field.restrict = "0-9\\^"; //允许数字和^
field.restrict = "0-9\\\\"; //允许数字和反斜杠
你也可以使用Unicode转义序列,指定允许的内容.例如:
field.restrict = "^\u001A";
注意:ActionScript有区分大小写的,如果restrict属性设为abc,允许字母的大写形式(A,B和C)输入时会变成小写对待形式(a,b和c),反之亦然.restrict属性只影响用户可以输入的内容,脚本可将任何文本放入文本字段中.
【设定输入框的最大长度】
TextField.maxChars:int
【向TextField追加内容】
TextField.appendText(text:String):void
与通过对 text 属性使用加法赋值来连接两个字符串(例如 field.text += moreText)相比,此方法的效率更高.
【显示HTML格式的文字】
TextField.htmlText = "<b>Html text</b>";
支持的HTML标签集有:
<b>,<i>,<u>,<font>(有face,size以及color属
性),<p>,<br>,<a>,<li>,<img>以
及<textformat>(有leftmargin,rightmargin,blockindent,indent,leading以及
tabstops属性,相应于TextFormat类的同名属性)
【缩减空白】
TextField.condenseWhite = true;
删除具有HTML文本的文本字段中的额外空白(空格,换行符等),如同多数HTML浏览器所做的那样.
注意: 在设置 htmlText 属性之前设置 condenseWhite 属性
【自动大小调整和对齐】
TextField.autoSize = TextFieldAutoSize.LEFT;
可选之值:
flash.text.TextFieldAutoSize.CENTER
flash.text.TextFieldAutoSize.LEFT
flash.text.TextFieldAutoSize.NONE
flash.text.TextFieldAutoSize.RIGHT
【指示文本字段是否自动换行】
TextField.wordWrap = true; //自动换行
【用程序手段滚动文字】
水平方向以像素为单位,而垂直方向以行做单位:
scrollV: 指出文字框可见区域的最顶行,可读写;
bottomScrollV: 指出文字框内最底端可见行,只读;
maxScrollV: scrollV的最大值,只读;
numLines: 定义多行文本字段中的文本行数,只读;
TextField.scrollV = field.maxScrollV; //滚动到最后一页
【响应滚动事件】
field.addEventListener(Event.SCROLL, onTextScroll);
【样式化文字的方法】
1. 使用HTML标签进行样式化;
2. 使用TextFormat对象;
3. 使用CSS.
例如: HTML是用<font>标签,TextFormat对象是设定font属性,而CSS是使用font-family属性的.
受支持的层叠样式表(CSS)属性和值,及其相应的ActionScript属性名称(小括号内):
color(color),display(display),font-family(fontFamily),font-size(fontSize),font-style(fontStyle),font-weight(fontWeight),kerning(kerning),leading(leading),letter-spacing(letterSpacing),margin-left(marginLeft),margin-right(marginRight),text-align(textAlign),text-decoration(textDecoration),text-indent(textIndent)
受支持的HTML实体: <(小于号: <), >(大于号: >), &(和: &), "(双引号:
"), '(撇号,单引号: ')
其中样式对象的两种写法:
写法一:
var sampleStyle:Object = new Object();
sampleStyle.color = "#FFFFFF";
sampleStyle.textAlign = "center";
css.setStyle(".sample", sampleStyle);
写法二:
var sampleStyle:Object = {color: "#FFFFFF", textAlign: "center"};
css.setStyle(".sample", sampleStyle);
【对用户输入的文字进行样式化】
使用defaultTextFormat属性,样式会施加至用户键入输入框的文字身上:
var formatter:TextFormat = new TextFormat();
formatter.color = 0x0000FF; //把文字变成蓝色
field.defaultTextFormat = formatter;
【对现有文字的一部分进行样式化】
TextFormat.setTextFormat(format:TextFormat, beginIndex:int = -1, endIndex:int =
-1):void
【设定文字框的字体】
例子:
HTML: field.htmlText = "<font face='Arial'>Formatted text</font>";
TextFormat: formatter.font = "Arial";
CSS: P{ font-family: Arial; }
也可以使用以逗号隔开的字体清单: formatter.font = "Arial, Verdana, Helvetica";
注意:
字体和字体群组不同.字体群组有三种: _sans,_serif以及_typewriter.
_sans群组一般就是指Arial或Helvetica这种字体;
_serif群组一般就是指Times或Times New Roman这种字体;
_typewriter群组一般就是指Courier或Courier New这种字体.
【嵌入字体】
使用[Embed]后设标签.[Embed]后设标签应该出现在ActionScript文件中,处于类宣告之外.你可以内嵌TrueType字体或系统字体.内嵌TrueType字体时的语法:
[Embed(source="pathToTtfFile", fontName="FontName", mimeType="application/x-font-truetype")]
pathToTtfFile: ttf文件的路径,TrueType字体的路径可以是相对的,也可以是绝对的;
FontName: 字体名称;
内嵌系统字体的语法:
[Embed(systemFont="Times New Roman", fontName="Times New Roman", mimeType="application/x-font-truetype")]
fontName: 以相同名称作为实际系统字体名称.
注意:
在使用嵌入字体时,要把TextField的embedFonts属性设为true,这样TextField只能用内嵌字体了.如果你试着替
embedFonts设为true的TextField使用设备字体,什么都不会显示.如果embedFonts设为true,就无法指定以逗号相隔的字
体清单.
【建立可以旋转的文字】
使用内嵌字体.当你旋转文字框时,设备字体就会消失.
【显示Unicode文字】
1. 从外部来源载入Unicode文字;
2. 假如你的编辑器支持Unicode(如 Flex Builder),则可以直接在ActionScript程序中使用该字符;
3. 使用Unicode转义字符,ActionScript里所有Unicode转义字符都以\u开头,后面再跟四位十六进制数字.
注意: 如果你想取得Unicode字符,在Windows下使用: 开始>所有程序>附件>系统工具>字符映射表.
【把Flash Player的焦点带给文字框】
stage.focus = field;
把焦点移除:
stage.focus = null;
注意: 当.swf文件首次载入至网页浏览器时,并没有焦点.因此,以程序的方式把焦点指定给Flash应用程序的一个元素前,必须先把焦点移至Flash Player.
【以ActionScript选取文字】
使用TextField.setSelection(beginIndex:int, endIndex:int):void
为了可以正常选取文字,文字框必须具有焦点:
stage.focus = field; //把焦点设给文字框
field.text = "This is example text"; //设定文字
field.setSelection(0, 4); //把"This"这个单词以高亮显示
使用只读的selectionBeginIndex和selectionEndIndex属性访问所选取的字符范围的索引.
【在文字内设定安插点(游标位置)并访问游标位置的索引值】
可以使用TextField.setSelection()把起始和结尾的索引参数都设成相同值,在文字内设定游标位置(假设具有焦点):
field.setSelection(0, 0); //在第一个字符前摆放安插点
trace(field.caretIndex); //输出游标位置的索引值
【当文本字段受到选取或取消选取时给予响应】
获得焦点时: FocusEvent.FOCUS_IN
失去焦点时: FocusEvent.FOCUS_OUT
通过键盘(Tab键)把焦点移除时: FocusEvent.KEY_FOCUS_CHANGE
通过鼠标把焦点移除时: FocusEvent.MOUSE_FOCUS_CHANGE
FocusEvent类有一个relatedObject属性.就FOCUS_IN事件而言,relatedObject属性是刚才拥有焦点的对象的引用
地址;对于FOCUS_OUT,KEY_FOCUS_CHANGE以及MOUSE_FOCUS_CHANGE事件,relatedObject属性是刚接
收到焦点的对象的引用地址.
FOCUS_IN和FOCUS_OUT事件都是在焦点改变后发生的,所以两者都是不可取消的事件.对于KEY_FOCUS_CHANGE和MOUSE_FOCUS_CHANGE事件,可以使用FocusEvent.preventDefault()方法取消默认行为:
field.addEventListener(FocusEvent.KEY_FOCUS_CHANGE, onKeyFocus);
private function onKeyFocus(event:FocusEvent):void {
if(field.text == "") {
event.preventDefault(); //当field没有任何文字前,不允许使用Tab键把焦点移除
}
//event.relatedObject就是刚才拥有焦点的对象的引用地址,即下一个获得焦点的对象的引用地址
}
【响应用户的输入行为】
field.addEventListener(TextEvent.TEXT_INPUT, onTextInput);
private function onTextInput(event:TextEvent):void {
if(event.text == "a" && field.length == 0) {
event.preventDefault(); //TEXT_INPUT是可以取消的事件.TextEvent有一个text属性,内含用户所输入的的字符.此例子确保用户输入的第一个字母不是"a"
}
}
【把超链接加入文字】
打开网页:
例子1:
var css:StyleSheet = new StyleSheet();
css.parseCSS("a{color:#0000FF;} a:hover{text-decoration:underline;}");
field.styleSheet = css;
field.htmlText = "<a href='http://www.riahome.cn' target='_blank'>Link text</a>";
例子2:
field.text = "Link text";
var formatter:TextFormat = new TextFormat();
formatter.url = "http://www.riahome.cn";
formatter.target = "_blank";
field.setTextFormat(formatter);
打开Email:
field.text = "Link text";
var formatter:TextFormat = new TextFormat();
formatter.url = "mailto:y_boy@126.com";
field.setTextFormat(formatter);
使用event协议,打开ActionScript方法:
field.htmlText = "<a href='event:http://www.riahome.cn'>www.RIAHome.cn</a>";
field.addEventListener(TextEvent.LINK, onClickHyperlink);
private function onClickHyperlink(event:TextEvent):void {
trace(event.text); //输出: http://www.riahome.cn
}
【精确获取某字符的索引值】
在 x 和 y 参数指定的位置返回从零开始的字符索引值
TextField.getCharIndexAtPoint(x:Number, y:Number):int
例子:
field.getCharIndexAtPoint(mouseX, mouseY); //返回鼠标位置上的该字符的索引值
【精确获取某字符的边框区域】
TextField.getCharBoundaries(charIndex:int):Rectangle
通过读取Rectangle的x,y,width以及height等属性来确定该字符的边框区域范围.
【精确获取某行的索引值】
在 x 和 y 参数指定的位置返回从零开始的行索引值
TextField.getLineIndexAtPoint(x:Number, y:Number):int
field.getLineIndexAtPoint(mouseX, mouseY); //返回鼠标位置上的该行的索引值
【获取指定索引值处的字符所在行的行索引值】
TextField.getLineIndexOfChar(charIndex:int):int
【获取指定行的字符数】
TextField.getLineLength(lineIndex:int):int
【获取指定索引值处的行所包含的字符】
TextField.getLineText(lineIndex:int):String
【获取指定行索引所在行的第一个字符的索引值】
TextField.getLineOffset(lineIndex:int):int
【获取指定文本行的度量信息】
TextField.getLineMetrics(lineIndex:int):TextLineMetrics
TextLineMetrics类包含文本字段中某行文本的文本位置和度量值的相关信息,帮助文档里有深入的图解.
【获取指定索引处的字符所在段落内的第一个字符索引值】
如果给定一个字符索引，则返回同一段落中第一个字符的索引
TextField.getFirstCharInParagraph(charIndex:int):int
【获取指定索引处的字符所在段落内的字符数】
TextField.getParagraphLength(charIndex:int):int
【替换所选文字】
TextField.replaceSelectedText(value:String):void
可以使用此方法插入和删除文本而不破坏其余文本的字符和段落格式.
【替换指定范围的文本】
TextField.replaceText(beginIndex:int, endIndex:int, newText:String):void
注意: 如果对文本字段应用了样式表,则该方法不起作用
【Timer计时器的使用】
var timer:Timer = new Timer(delay:Number, repeatCount:int = 0);
timer.addEventListener(TimerEvent.TIMER, onTimer);
timer.start();
private function onTimer(event:TimerEvent):void {
//code
}
【以指定方向和速度移动元件】
speed: 目标速度
radians: speed与x轴的夹角,弧度
vx = Math.cos(radians) * speed;
vy = Math.sin(radians) * speed;
【缓动动画算法】
targetX,targetY: 目标坐标;
easingSpeed: 每次移动分数,范围0到1;
var vx:Number = (targetX - sprite.x) * easingSpeed;
var vy:Number = (targetY - sprite.y) * easingSpeed;
sprite.x += vx;
sprite.y += vy;
注意: 在非常逼近目标点时,往往找出通往目标点的距离,如果其值少于特定值,就应该停止该缓动.
【模拟弹簧往复运动算法】
五个变量: targetX(目标点的x坐标),sprite.X(物体的x坐标),vx(水平速度),ax(水平加速度),k(弹簧强度)
已知: targetX(目标点的x坐标),k(弹簧强度)
var ax:Number = (targetX - sprite.x) * k;
vx += ax;
sprite.x += vx;
注意: 这里只是水平方向的情形,也可以推广到垂直方向以及水平垂直一起来的情形
【模拟单摆运动】
四个变量: sprite.x(物体的x坐标),centerX(中心位置的x坐标),angle(弧度),radius(摆动的振幅,也就是摆动的范围)
sprite.x = centerX + Math.sin(angle) * radius;
angle += 0.05;
【模拟阻尼运动】
六个变量: targetX(目标点的x坐标),sprite.X(物体的x坐标),vx(水平速度),ax(水平加速度),k(弹簧强度),damp(阻尼系数)
已知: targetX(目标点的x坐标),k(弹簧强度)
var ax:Number = (targetX - sprite.x) * k;
vx += ax;
sprite.x += vx;
vx *= damp; //无阻力情况下的弹簧往复运动只缺少此句
注意: 这里只是水平方向的情形,也可以推广到垂直方向以及水平垂直一起来的情形.
这种原理可以推广到其它属性,如scaleX:
scaleVel += (targetScale - sprite.scaleX) * k;
sprite.scaleX += scaleVel;
scaleVel *= damp;
【计算两点间的角度】
Math.atan2(y:Number, x:Number):Number
y: 两点间的垂直距离
x: 两点间的水平距离
返回一个以弧度为单位的角度,返回值介于正PI和负PI之间.
【让物体指着鼠标(跟随眼睛)】
var dx:Number = mouseX - sprite.x;
var dy:Number = mouseY - sprite.y;
var radians:Number = Math.atan2(dy, dx);
sprite.rotation = radians * 180 / Math.PI;
【联结字符串时需要注意的地方】
var result:String = 2 + 6 + "a";
trace(result); //输出: 8a
var result:String = "a" + 2 + 6;
trace(result); //输出: a26
var result:String = "a" + (2 + 6);
trace(result); //输出: a8
【查找匹配的字符串】
使用String.indexOf(val:String, startIndex:Number = 0):int
返回指定子字符串的第一个匹配项的索引,没有匹配就返回-1
查找所有匹配的字符串:
var index:int = -1;
while((index = myString.indexOf("val", index + 1)) != -1) {
trace("结果：" + index);
}
使用String.lastIndexOf(val:String, startIndex:Number = 0x7FFFFFFF):int
返回指定子字符串的最后一个匹配项的位置,没有匹配就返回-1
var index:int = myString.length;
while((index = myString.lastIndexOf("val", index - 1)) != -1) {
trace("结果：" + index);
}
注意: indexOf()和lastIndexOf()方法都是区分大小写的.想把大小写都查找出来的话,可以结合String.toLowerCase()和String.toUpperCase()方法先把字符串一起转为小写或大写再进行查找.
【提取子字符串】
String.substr(startIndex:Number = 0, len:Number = 0x7fffffff):String
String.substring(startIndex:Number = 0, endIndex:Number = 0x7fffffff):String
String.slice(startIndex:Number = 0, endIndex:Number = 0x7fffffff):String
substr()第一个参数可以是负值,表示索引值是从字符串尾端算过来,-1是最后一个字符;
substring()和slice()差别在于substring()只接受正索引值,而把负值作为0处理.另外,如果endIndex小于startIndex,substring()方法在执行前,会自动将其调换过来,总是使用两个参数中较小的值作为起始索引.
slice()方法可接受startIndex和endIndex为负值,而把负值表示为从字符串的尾端算回来,如果endIndex小于startIndex,slice()方法会返回空字符串.
【以指定模式拆分字符串】
String.split(delimiter:*, limit:Number = 0x7fffffff):Array
【替换指定的字符串】
使用String.replace(pattern:*, repl:Object):String
可以这样来替换所有指定的字符串: myString.split("a").join("b");
【按单词或单个字母逆转字符串】
1. 把字符串切割使用String.split()方法成一个数组:对单词而言,以空格作为分界符,对字母而言,以空字符("")作为分界符;
2. 使用Array.reverse()方法对数组进行逆转;
3. 使用Array.join()方法重新组合为字符串:对单词而言,以空格(" ")作为联结符,对字母而言,以空字符("")作为联结符;
【使用SharedObject及捕获异常】
var so:SharedObject = SharedObject.getLocal("so");
so.data.userName = "Youthoy";
try {
var flushResult:String = so.flush(500 * 1024); //请求500KB容量
//如果flush()没成功执行,就替netStatus加个事件处理函数以确认用户是同意还是拒绝,否则只检验结果.
if(flushResult == SharedObjectFlushStatus.PENDING) {
//替netStatus加个事件处理函数,使得我们可以检验用户是否同意以足够磁盘容量储存共享对象.当netStatus事件发生时,执行onStatus函数.
so.addEventListener(NetStatusEvent.NET_STATUS, onStatus);
}else if(flushResult == SharedObjectFlushStatus.FLUSHED) {
//成功储存.把数据成功储存后你想执行的程序放在这里.
}
}catch(e:Error) {
//这里表示用户把本地储存设置为"拒绝".如果储存数据很重要,你会想在此警告用户.
//此外,如果你想让用户可修改其设定值,可以用下面语句打开Player的"设置"对话框的本地储存页面.
Security.showSettings(SecurityPanel.LOCAL_STORAGE);
}
//定义onStatus函数以处理共享对象的状态事件.flush()返回"pending"时,引发提示,而用户做了选择后所引发的事件.
function onStatus(event:NetStatusEvent):void {
if(event.info.code == "SharedObject.Flush.Success"){
//如果event.info.code内容是"SharedObject.Flush.Success",表示用户同意.把用户同意后你想执行的程序放在这里.
}else if(event.info.code == "SharedObject.Flush.Failed"){
//如果event.info.code内容是"SharedObject.Flush.Failed",表示用户同意.把用户拒绝后你想执行的程序放在这里.
}
//现在,移除事件监听器,因为我们只需监听一次.
so.removeEventListener(NetStatusEvent.NET_STATUS, onStatus);
}
【向LSO储存对象时需要注意】
LSO使用二进制的AMF(Action Message
Format)对一个对象进行编码.当你在LSO储存类对象时,该对象会编码成包含内容属性的普通对象.于是,当你试着从共享对象里读取该对象时,无法被
读成某类的对象,因为没有类型数据.要克服这个限制,使用flash.net.registerClassAlias()方法.
任何影片中,只要从共享对象读取出自定义对象数据,自定义类就必须注册别名,而且调用registerClassAlias()方法时必须在SharedObject.getLocal()方法被调用之前.
【要相同域名内的两个影片可以存取相同LSO】
首先LSO是储存在以下目录下:
C:\Documents and Settings\[user name]\Application Data\Macromedia\Flash Player\#SharedObjects
例如,如果来自于http://www.riahome.cn/youthoy的影片movie.swf写入名为example的LSO,则数据会储存在以下位置:
C:\Documents and Settings\[user name]\Application Data\Macromedia\Flash Player\#SharedObjects\[random
directory name]\riahome.cn\youthoy\movie.swf\example.sol
如果在这个movie.swf里的代码是这样的: var example:SharedObject = SharedObject.getLocal("example",
"/"); 也就是使用了选用的本地路径参数,则LSO会储存在以下路径,注意到与以上路径少了"youthoy\movie.swf":
C:\Documents and Settings\[user name]\Application Data\Macromedia\Flash Player\#SharedObjects\[random
directory name]\riahome.cn\example.sol
以此方法建立的LSO,可以由相同域的其它Flash影片用以下程序来读取:
var example:SharedObject = SharedObject.getLocal("example", "/");
再看一个例子:
有两个Flash影片movieOne.swf和movieTwo.swf都位于同一域(http://www.riahome.cn)内,但
是,movieOne.swf位于http://www.riahome.cn/youthoy/firstGroup,而movieTwo.swf位于
http://www.riahome.cn/youthoy/secondGroup.在这情况里,movieOne.swf可以用下列任何本地路径建
立和读取LSO:
/
/youthoy
/youthoy/firstGroup
而movieTwo.swf可以用下列任何本地路径建立和读取LSO:
/
/youthoy
/youthoy/secondGroup
因此,如果你想要两个影片都可以读取相同LSO,当你调用getLocal()方法时,必须指定影片共享的两个本地路径之一(/或/youthoy).
【URLLoader.dataFormat的三种类型】
URLLoader.dataFormat的可选值是:
flash.net.URLLoaderDataFormat.BINARY
flash.net.URLLoaderDataFormat.TEXT
flash.net.URLLoaderDataFormat.VARIABLES
当dataFormat是BINARY时,URLLoader.data属性就是flash.utils.ByteArray类型;
当dataFormat是TEXT时,URLLoader.data属性就是String类型;
当dataFormat是VARIABLES时,uRLLoader.data属性就是Object类型.
【在XML内使用动态数据】
把变量放在大括号({和})内:
var userName:String = "Youthoy";
var myXML:XML = <person><userName>{userName}</userName></person>;
【新增一个节点元素】
//例子一:
var example:XML = <person/>;
example.father = <father/>; //内容属性和元素名称不一定要相同,也可以: example.abc = <father/>,但会以元素名称为准,即会建立一个<father/>元素
trace(example);
/*
输出:
<person>
<father/>
</person>
*/
//例子二:
var example:XML = <person/>;
example.father = ""; //建立一个<father/>元素
trace(example.toString());
/*
输出:
<person>
<father/>
</person>
*/
//例子三:
var example:XML = <person/>;
var id:int = 10;
example["user" + id] = "";
trace(example);
/*
输出:
<person>
<user10/>
</person>
注意: 有些情况必须使用第三种情况.例如,元素节点名称内含连字符("-")是完全合法的,但在ActionScript里会得到编译器错误:
example.some-element = ""; //产生编译器错误
正确的写法是:
example["some-element"] = "";
*/
【新增属性】
var example:XML = <person/>;
example.element = "";
example.element.@name = "Youthoy";
example.element.@["bad-variable-name"] = "yes";
example.element.@other = ["riahome.cn", undefined, true, 44, null];
var id:int = 44;
example.element.@["user" + id] = "love";
trace(example);
/*
输出:
<person>
<element name="Youthoy" bad-variable-name="yes" other="riahome.cn,,true,44,"
user44="love"/>
</person>
*/
【向XML插入文字元素和节点元素】
//在指定元素前和后插入,在最前端和尾端插入
var example:XML = <person/>;
example.two = "";
example.insertChildBefore(example.two, <one/>); //在two节点前插入one节点
example.insertChildBefore(example.two, "在two节点前插入文字");
example.insertChildAfter(example.two, <three/>); //在two节点后插入three节点
example.prependChild(<start/>); //在最顶端插入start节点
example.appendChild(<end/>); //在尾端插入end节点
example.start = "start内容"; //向节点增加内容
trace(example);
/*
输出:
<person>
<start>start内容</start>
<one/>
在two节点前插入文字
<two/>
<three/>
<end/>
</person>
*/
【把XML实例的内容属性转换为任何可以转换成字符串的内容】
//先把等号右边转为可以转换的字符串
var example:XML = <person/>;
example.one = "one";
example.two = new URLLoader();
example.three = new Sprite();
example.four = new Boolean; //Boolean对象的值初始化为false
example.five = new Number();
example.six = new String();
example.seven = {a:"Youthoy", b:true, c:undefined};
example.eight = ["three", undefined, true, 44, null];
/*
输出:
<person>
<one>one</one>
<two>[object URLLoader]</two>
<three>[object Sprite]</three>
<four>false</four>
<five>0</five>
<six/>
<seven>[object Object]</seven>
<eight>three,,true,44,</eight>
</person>
*/
【对XML属性层层递归的算法】
var example:XML = <menu>
<menuitem label="File">
<menuitem label="New"/>
<menuitem label="Save"/>
</menuitem>
<menuitem label="Help">
<menuitem label="About"/>
</menuitem>
</menu>;
walk(example);
function walk(node:XML):void {
for each(var element:XML in node.elements()) {
trace(element.@label);
walk(element);
}
【读取文字节点及其值】
var example:XML = <menu>
My name is Youthoy.
<myName>Youthoy</myName>
</menu>;
example.text(); //输出: My name is Youthoy.
example.myName.toXMLString(); //输出: <myName>Youthoy</myName>
//以下三行都输出: Youthoy
example.myName.toString();
example.myName.text();
example.myName;
【递归元素属性时读取属性名与其值】
var example:XML = <person name="Youthoy" age="21"/>;
for each(var i:XML in example.attributes()) {
trace(i.name() + "=" + i);
}
/*
输出:
name=Youthoy
age=21
*/
另类方法:
var example:XML = <person name="Youthoy" age="21"/>;
trace(example.@*[1]); //输出: 21
【不论层级地访问整个XML中指定的节点或属性】
使用后代存取器运算符..
例子1(对于节点元素):
var example:XML = <a>
<z>I am z.</z>
<b>
<c></c>
<z>I am z.</z>
</b>
</a>;
trace(example..z.text()); //输出: I am z.I am z.
例子2(对于属性):
var example:XML = <person>
<a>
<item name="Youthoy" age="21"/>
</a>
<item name="Jimpa" age="21"/>
</person>
trace(example..@name); //输出: YouthoyJimpa
【删除节点元素,文字节点以及属性】
使用delete对单一项进行删除,要删除整个XMLList可以使用for循环以倒序形式进行删除,以避免迭代时需要改变数组索引问题.
【搜索XML的高级应用】
使用术语过滤.(condition),可结合正则表达式来使用.
例子:
var example:XML = <foodgroup>
<fruits>
<fruit color="red">Apple</fruit>
<fruit color="orange">Orange</fruit>
<fruit color="green">Pear</fruit>
<fruit color="red">Watermelon</fruit>
</fruits>
<vegetables>
<vegetable color="red">Tomato</vegetable>
<vegetable color="brown">Potato</vegetable>
<vegetable color="green">Broccoli</vegetable>
</vegetables>
</foodgroup>;
trace(example..*.(hasOwnProperty("@color") && @color == "red"));
/*
hasOwnProperty所做的检测是确保元素具有color属性,然后,有的话,就测试color属性之值是否为red.只有当条件的计算结果为true时,该元素才会加入EX4运算式所返回的XMLList.
输出
<fruit color="red">Apple</fruit>
<fruit color="red">Watermelon</fruit>
<vegetable color="red">Tomato</vegetable>
*/
【复制内容到系统剪贴板】System.setClipboard(strContent);
【复制一个ArrayCollection】
//dummy solution( well, it works )
var bar:ArrayCollection = new ArrayCollection();
for each ( var i:Object in ac ){
bar.addItem( i );
}
// fantastic ! //
var bar:ListCollectionView = new ListCollectionView( ListCollectionView( ac ).list );
【打开一个新浏览器窗口】navigateToURL(new URLRequest('http://ntt.cc'), '_blank');
【刷新浏览器】navigateToURL(new URLRequest("javascript:location.reload();"),"_self");
【关闭浏览器】navigateToURL(new URLRequest("javascript:window.close()"),"_self");
【设置Alert 窗口的背景为透明】
Alert
{
modalTransparency:0.0;
modalTransparencyBlur:0;
}
【取随机颜色】xx.setStyle('color', 0xffffff*Math.random());
【清除子串左侧空格】
public function LTrim(s : String):String
{
var i : Number = 0;
while(s.charCodeAt(i) == 32 || s.charCodeAt(i) == 13 || s.charCodeAt(i) == 10 || s.charCodeAt(i) == 9)
{
i++;
}
return s.substring(i,s.length);
}
【清除字串右侧空格】
public function RTrim(s : String):String
{
var i : Number = s.length - 1;
while(s.charCodeAt(i) == 32 || s.charCodeAt(i) == 13 || s.charCodeAt(i) == 10 ||s.charCodeAt(i) == 9)
{
i--;
}
return s.substring(0,i+1);
}
【清除字串左右的空格】
public function Trim(s : String):String
{
return LTrim(RTrim(s));
}
【获取数据类型】getQualifiedClassName(data);
【生成随机字符串】
private function GenerateCheckCode():String
{
//init
var ran:Number;
var number:Number;
var code:String;
var checkCode:String ="";
//get 4 radom
for(var i:int=0; i<4; i++)
{
ran=Math.random();
number =Math.round(ran*10000); //get result like 0.1234
if(number % 2 == 0)
code = String.fromCharCode(48+(number % 10)); //0's ASCII code is 48
else
code = String.fromCharCode(65+(number % 26)) ; // A's ASCII code is 65
checkCode += code;
}
return checkCode;
}
属性的作用在于直接访问的属性的方法来更新值,却可以同时增加方法进行验证
要发送事件.需要继承EventDispatcher,然后调用dispatchEvent()方法
检查客户端系统,可以使用flash.system.Capabilities来做判断其中包括了客户端Flash Player版本以及操作系统,分辨率
flash.system.Security.showSettings(); 用于打开本地设置界面
使用 flash.system.Security.allowDomain( ) , flash.system.Security.allowInsecureDomain( ) ， 或 一个 策略文件。
第一种用于http的访问, 第二种用于基于https://的访问,其中都可以使用参数url来设置允许访问的url
也可以直接使用策略文件
<?xml version="1.0"?>
<!-- http://www.mydomain.com/crossdomain.xml -->
<cross-domain-policy>
<allow-access-from domain="www.otherdomain.com" />
<allow-access-from domain="*.adobe.com" />
<allow-access-from domain="123.45.67.89" />
</cross-domain-policy>
该文件被命名为 crossdomain.xml 。 通过 flash.system.Security.loadPolicyFile( ) 读取文件
ActionScript 3.0 有三种基本数字类型： number , int , 和 uint 。 number 对应浮点数， int 和 u int
对应整数。 int 和 uint 的区别就是 uint 代表无符号整数
十六进制以 0x 开头，八进制以 0 开头，二进制不能直接表示，可以用等价的八进制或十六进制 或用 parseInt( ) 函数转换字符为数字。
在 ActionScript 中不管你怎么设置数字，它的内部结果总是以十进制存贮,可以使用toString("类型")进行指定进制的转换输出
同样颜色的rgb值也可以使用toString("类型")来用于输出
也可以使用parseInt("值","进制类型") 进行指定类型的格式转换
以上两种默认均为10进制
用Math.round( )进行四舍五入,Math.floor( )和Math.ceil( )进行上下近似值.NumberUtilities.round( ) 方法可自定义取值。
计算两点之间的距离
通过勾股定理可以计算出两点之间的距离（直线）。一个三角形，最长边的平方等于其他两边 的
平方和：
var c:Number = Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));
数组的排序,主要使用sort方法.其中重要的是传递进去的参数,均为Array的常量
两个常量 Array.UNIQUESORT 和 Array.RETURNINDEXEDARRAY .
，如果你只是对含有唯一元素的数组排序就可以用 Array.UNIQUESORT ， Flash 只会对这样的数组排序，不满足条件sort( )
返回 0 ，且不进行排序：
Array.RETURNINDEXEDARRAY 得到排序后数组元素的下标顺序，但不改变原始数组：
使用 Array.NUMERIC 常量才能正常对数字排序：
如果对数字内容的数组排序，则根据第一个数字的 ASCII 排序
使用 Array.CASEINSENSITIVE 常量忽略大小写进行排序：
如果要进行降序排序，需要传递参数 Array.DESCENDING 常量
可以使用|连接这些常量
用 reverse( ) 方法反转数组
对于复杂的对象数组,可以使用sortOn()方法,其中传递的参数为字符串指定名称属性cars.sortOn(["year", "make"]);
其中的两个均为属性,表示先对year排序,再对make排序
自定义排序传递一个2个参数的并且返回一个int值的function名
画一条直线
lineTo( ) 把笔刷当前位置作为起点，类似的还有 curveTo( ) , 或 moveTo( ) 方法。默认笔刷的起始 坐
标为 (0,0) 。 moveTo( ) 方法不会画出东西，它直接把笔刷移动到目标位置
curveTo( ) 用于绘制曲线
Loader的加载事件监听需要放置在contentLoaderInfo属性内,而且返回的结果放置在urlloader.content内
使用 BitmapData 类的 getPixel( ) , setPixel( ) , getPixel32( ) , 和 setPixel32( ) 方法可以改变像素的颜色
其中带32的包括了透明度的修改
_bitmap.fillRect(new Rectangle(25, 25, 50, 50), 0xffff0000); 用于填充矩形
copyPixels( ) 方法的实现也很简单，只要得到象素值然后画到其他地方，非常类似于 draw( ) 方 法 。
但是 copyPixels( ) 可控制拷贝象素的数量和目标。只要指定一个矩形区域和目标点即可：
Bitmapdata.copyPixels(sourceBmp, srcRect, destPoint);
copyChannel( ) 方法是另一个在两个位图之间交换数据的方法。它的前三个参数和 copyPixels( )
方法一样，另外还有源通道和目标通道：
bitmap.copyChannel(sourceBmp, srcRect, destPoint,
srcChannel, destChannel);
直接通过 BitmapData 调用 noise( ) 方法，参数有：
bitmap.noise(seed, low, high, channel, grayscale);
用于生成随机噪波图案
使用 BitmapData 类的 perlinNoise( ) 方法 产生特别的混合图,可以使用随机数生成多彩的效果
使用 BitmapData 类的 threshold( ) 方法,使用在像素级的比较
我要在 BitmapData 上加上滤镜效果使用 BitmapData 类的 applyFilter( ) 方法
设置文本框的 restrict 属性用于设置文本过滤
包括些特殊字符 \t 表示制表符， \n 表示换新行都可以用。
设置 condenseWhite 属性为 true用于压缩空格,只对htmlText有效
使用 autoSize 属性用于表示文本框自动适应,可用值为RIGHT,LEFT,CENTER
控制文本栏滚动条
使用 scrollV, maxScrollV, bottomScrollV, scrollH , 和 maxScrollH 属性和设置鼠标滚轮相关的WheelEnabled 属性
创建 TextFormat 对象的 setTextFormat( ) 方法对部分文本进行格式化
使用 Stage.focus 属性可在程序里赋值焦点到一个文本框上
使用 TextField.setSelection( ) 方法 ,设置文件的部分选中效果
通过 TextField.setSelection( ) 设置文本框的光标位置，只要指定两个参数为同一个值即可，看下面的例子，记得首先要让文本框获得焦点： 用于将光标移动到指定的位置
(field.caretIndex); 用于输入当前光标所在位置
利用 HTML <a href> 标签设置文本框的 htmlText 属性,可以用于添加超链接,记得设置field.html = true;target='blank同HTML
var css:StyleSheet = new StyleSheet( );
css.parseCSS("a {color: #0000FF;} a:hover {text-decoration: underline;}");
field.styleSheet = css;
用于指定样式
监听 TextE vent .LINK 事件,可以捕获到用户点击了超链接
TextField 类也定义了一个属性和方法获取多行文本的信息。 numLines 属性表示文本框所包含的
文本行数， getLineIndexAtPoint( ) 方法返回当前坐标所在的行数， getLineIndexOfChar( ) 返回指
定字符所在的行数， getLineLength( ) 方法返回指定行所包含的字符数， getLineText( ) 方法返回 指
定行所包含的文本， getLineOffset( ) 方法返回指定行第一个字符的位置， getLineMetrics( ) 方法 关
于指定行数的 flash.text.TextLineMetrics 对象。 TextLineMetrics 类定义了该行文本的上位，下位，
高度，宽度等等信息。
对文字进行抗锯齿设置
对于嵌入字体可通过设置文本框的 antiAliasType 属性为 flash.text.AntiAliasType.ADVANCED ，然 后
设置 gridTypeFit 和 sharpness 属性 ;
默认下文本以正常抗锯齿设置显示，对于字体大小大于10,表现正常,但是对于小于 10
的字体正常抗锯齿就能难表现出好效果了，这时我们可通过文本框的 anti-aliasype 设为 advanced 并且使用
gridFitType 和 sharpness 属性进行精确控制。
替换文字
使用 replaceSelectedText( ) 方法替换选中的文字或用 replaceText( ) 方法替换某一范围的文字
获取系统字体列表
使用 TextField.fontList 静态属性
每 个 可 视 化 对 象 都 有 一 个 transform.colorTransform 属 性 ， colorTransform 属 性 是 一 个
flash.geom.ColorTransform 对象实例，它决定对象的颜色。 colorTransform 属性总是返回
ColorTransform 对象的一个拷贝，也就说不能直接改变 colorTransform 属性，而是要先获取
colorTransform 属性，修改，然后再重新赋值给 colorTransform 属性，
var color:ColorTransform = sampleSprite.transform.colorTransform;
color.rgb = 0xFFFFFF;
sampleSprite.transform.colorTransform = color;
multiplier 属性 ( redMultiplier, greenMultiplier, blueMultiplier , 和 alphaMultiplier ) 范围都在 0 到 1 。
multiplier 值决定原始像素颜色的倍增值，默认值 1 ，表示增强 1 倍。下面的例子中绿色被增强 1
其他用法和上面一样
要恢复原来颜色
使用新建一个 ColorTransform 对象赋值给可视化对象的 transform.colorTransform 属性
用默认值创建一个 Matrix 对象，其中的 b 和 c 属性控制 Y 方向和 X 方向的倾斜，然后把 Matrix 对象
赋值给可视化对象的 transform.matrix 属性
该对象用于控制缩放
box.transform.matrix = new Matrix(1, 1, 0, 1, 0, 0);
第1个参数和第4个参数为 x轴和Y轴的高度 1表示原比例
第二个参数上下的倾斜角度 第三个表示左右的倾斜角度 0为默认值表示不倾斜
最后两个参数表示修改后组件x,y坐标
可以用于较复杂的动画效果,不过文字可能会消失,需要嵌入字体
应用简单的滤镜
使用组件的filter属性可以用于设置一个滤镜数组,添加一部分的滤镜效果
对滤镜对象的修改并不会马上影响到已经设置过filter属性,需要重新赋值一次才可以,而且读取filters属性时候,
放回滤镜数组的拷贝,并不能直接对对象的filters属性进行操作修改
总结下:操作的是对应的数组,需要重新赋值回去才可以进行修改
要清除的时候,只要赋值给[]空对象即可,或者使用null
knockout 属性用于隐藏原始图形，例如，设置阴影滤镜的 knockout 属性后显示出来只有阴影本
身，这一点非常有用，这样我们就能产生不叠加的滤镜组合了。
使用高级的滤镜
使用 ConvolutionFilter 对象
该类的构造函数的第一个参数表示 第三个参数的的列数, 第二个参数表示第三个参数的行数
sampleSprite.filteres = [ConvolutionFilter(3, 3, [0, 0, 0, 0, 1, 0, 0, 0, 0])];
所有以1为中心,周围是0的表示无效果,第四个参数用于消除亮度的问题
全部赋值用提高模糊度,记得同时修改第四个参数用于调整亮度
用浮雕矩阵创建联合矩阵,可以出去第四个参数(除数)
sampleSprite.filters = [new ConvolutionFilter(3, 3, [-2, -1, 0, -1, 1, 1, 0, 1, 2])];
使用边检测矩阵创建联合滤镜效果
sampleSprite.filters = [new ConvolutionFilter(3, 3, [0, 1, 0, 1, -3, 1, 0, 1, 0])];
中心数越大，检测到的边越少
应用锐化效果
锐化矩阵和边检测矩阵很类似，只不过边检测矩阵中心是个负数，而锐化矩阵中心是正数，中
心周围是负数，下面的例子应用了锐化效果：
sampleSprite.filter = [new ConvolutionFilter(3, 3, [0, -1, 0, -1, 5, -1, 0, -1, 0])];
提高中心值和除数降低锐化效果
降低中心值和除数提高锐化效果：
制作胶片效果----(反色) 使用ColorMatrixFilter
下面的例子应用了胶片效果：
sampleSprite.filters = [new ColorMatrixFilter([-1, 0, 0, 0, 255, 0, -1, 0, 0, 255, 0, 0, -1, 0, 255, 0, 0, 0, 1,
0])];
应用灰度效果--------把所有颜色变成黑白色
使用灰度矩阵创建 ColorMatrixFilter 对象
下面的例子应用了灰度效果：
sampleSprite.filters = [new ColorMatrixFilter([0.3086, 0.6094, 0.0820, 0, 0, 0.3086, 0.6094, 0.0820, 0,
0, 0.3086, 0.6094, 0.0820, 0, 0, 0, 0, 0, 1, 0])];
改变饱和度
使用饱和度矩阵创建 ColorMatrixFilter 对象
需要涉及到公式计算
改变对象的亮度
使用矩阵创建 ColorMatrixFilter 对象，也可用 ConvolutionFilter 对象改变亮度
下面的例子通过增加两倍的颜色来增强亮度：
sampleSprite.filters = [new ColorMatrixFilter([2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0])];
改变对比度 5x4的矩阵
使用对比度矩阵创建 ColorMatrixFilter 对象
动画编程..而不是简单的效果
速率和速度不是同一个概念，速率还包含方向因素，比如说： "10 米每小时 " 是速度，但是 "1 0
米每小时正北方向 " 是速率。在 x 或 y 轴上肯定是考虑方向的，一个正的速率代表 x 轴的右边，负
的为左边。
我想让物体以一定的速度在指定的方向上移动
转换速度和角度为 x 和 y 速率，进而改变对象的 x 和 y 轴位置
这个时候我们可利用基本的数学知识把角度和速度转换为 x 和 y 速率。首先，我们要确定角度，
如果需要弧度，需要下面的公式转换：
radians = degrees * Math.PI / 180;
如果需要度数，这用这个公式：
degrees = radians * 180 / Math.PI;
得到弧度后，即可用 Math.sin 和 Math.cos 函数结合速度算出 x 和 y 速率了：
vx = Math.cos(angle) * speed;
vy = Math.sin(angle) * speed;
angle表示弧度,speed表示速度,进行位置变更的时候,需要同时调整x,y的位置
减速运动---物体平滑的移动到指定的位置,慢慢减速
使用抛物线公式
目标位置保存在 _targetX 和 _targetY 变量.每次移动比例保存在 _easingSpeed 变量中,这里设置为 0.1,表示总距离的1/10
关键的移动代码:
var vx:Number = (_targetX - _sprite.x) * _easingSpeed;
var vy:Number = (_targetY - _sprite.y) * _easingSpeed;
_sprite.x += vx;
_sprite.y += vy;
可以使用MouseX和Y来代替_targetX,来实现动态的变更位置
加速运动
应用加速方法 速率的变化称为加速
关键在于移动位置的同时,增加每次移动的距离(速度)
弹跳效果
使用 Hooke's 定律 --- 弹簧算法
Hooke's 定律描述了弹簧的运动规律，一般弹簧都有不同的弹力即弹簧所拥有的能量，或大或 小 ，
我们用 _k 变量表示弹簧能量的大小，设为 0.1 或 0.2 较好。
设置能量属性为 0.95 表示每次弹跳丢失 5% 的能量，
var ax:Number = (_targetX - _sprite.x) * _k;
var ay:Number = (_targetY - _sprite.y) * _k;
_vx += ax;
_vy += ay;
_sprite.x += _vx;
_sprite.y += _vy;
_vx *= _damp;
_vy *= _damp;
高级动画，如旋转，循环运动或摆动
使用内建的函数： Math.sin( ) ， Math.cos( ) ，和 Math.atan2( ).
字符串等操作:
空格放在前面,后面的数字都会被转换成字符串
' "" ' 和" '' "的效果相同 也可以使用\进行转义
每次只读取一个字符
在 for 语句中使用 String.charAt( ) 方法，也可以用 String.split( ) 方法，以空字符串作为分隔符把所
有的字符分离出来作为数组，然后再用 for 语句遍历数组。
split更方便操作一些
StringUtil.trim()用于去除空格
使用 String.charCodeAt( ) 和 String.fromCharCode( ) 方法得到字符的 Unicode 码或 ASCII 码。
日期的使用
ActionScript 自动把日期转换为毫秒值，要获取这个值需要调用 Date 对象的 time 属性：
时间控件Timer有2个参数的构造函数,第一个是间隔时间,第二个是重复次数,默认为0,表示无限
会触发个 flash.event.TimerEvent中的Timer事件, 注意需要调用.start()方法开始播放
字符串转换成时间,使用 DateFormat 对象的 parse( ) 方法
声音编程
这些类都在 flash.media 包中，因此在写例子之前别忘了先引入 flash.media.Sound 包。
Var _sound :Sound = new Sound( );
soundFile = new URLRequest("song.mp3");
_sound.load(soundFile);
用于加载声音文件
调用play()方法开始播放
通过 SoundLoaderContext 类设置缓冲时间,默认缓冲事件为1秒
var request:URLRequest = new URLRequest("song.mp3");
var buffer:SoundLoaderContext = new SoundLoaderContext(5000);
_sound = new Sound(request, buffer);
_sound.play( );
play方法第一个参数设置开始播放时间,以毫秒为单位
第二个参数设置重复播放的次数
通过 Sound 对象的 bytesTotal 和 bytesLoaded 属性 可以获取到文件的大小
_sound.addEventListener(Event.ID3, onID3);用于监听ID3即mp3信息下载情况
下面代码用于监听音频播放完成
private var _channel:SoundChannel;
_channel = _sound.play( );
_channel.addEventListener(Event.SOUND_COMPLETE,function)
跟踪播放进度
使用 Sound.length 得到歌曲的总长度， SoundChannel.position 得到当前的播放位置
其中length属性并不确定,需要文件下载完成后,才会进行最后的确认
.close()方法会停止声音文件的所有处理,需要重新调用load();
还好， SoundChannel 类提供了一个 stop( ) 方法，它可以让音乐暂停而不影响声音流中断，要想 重
新播放 , 调用 play( ) 方法即可。
其中play参数可以传入 SoundChannel 类的 position 属性,用于从指定位置开始播放
获取声音的音量
通过 SoundChannel.leftPeak 和 SoundChannel.rightPeak 属性可以获取到只读的音量, 0到1
具体的控制是通过 SoundTransorm 对象
使用 SoundMixer 的 stopAll ( ) 方法 用于关闭所有的声音,静态方法
使用 SoundMixer.computeSpectrum( ) 填充一个字节数组，读取这个数组得到具体数据。
ByteArray 再作为 SoundMixer.computeSpectrum( ) 方法的参数，这个方法获得声音的快照并计算 出
左右声道的波形，每个通道取 256 个值，范围在 -1.0 到 1.0 。再把数据存到 ByteArray 中。
数据是准备好了，我们该怎么使用呢，我们需要循环遍历 ByteArray 512 次，调用 getFloat( ) 方法 ，
前面 256 个值代表左声道，后 256 为右声道。
改变声音的音量和平衡度
创建 SoundTransform 对象，改变音量及平衡度，把该对象赋值给 SoundChannel 对象的
soundTransform 属性。
var transform:SoundTransform = new SoundTransform( );
transform.volume = .5;
channel.soundTransform = transform;
其中可以用构造函数出入预定音量和平衡度
视频播放部分
var videoConnection:NetConnection = new NetConnection( );
videoConnection.connect(null);
一旦创建了 NetConnection 对象并调用了 connect( ) 方法，再构造 NetStream 对象，把 NetConnectio n
对象引用传给 NetStream 构造器作为参数。下面的代码构造了个 NetStream 对象 ( 先引入 imported
flash.net.NetStream ) ：
var videoStream:NetStream = new NetStream(videoConnection);
注意这里可以使用connect(null); 来方便建立连接,而不马上确认真实的地址
var video:Video = new Video( );
addChild(video);
接着调用 Video 对象的 attachNetStream( ) 方法，和 NetStream 对象关联起来：
video.attachNetStream(videoStream);
下面的代码表示载入并播放名为 example.flv 的视频：
videoStream.play("example.flv");
如果 .flv 文件和 swf 文件在同一个域里， play( ) 调用不会被 Flash Player 安全机制拒绝，但是如果 在
不同的域时就需要一个安全策略文件。
使用 NetStream 对象的 soundTransform 属性,可以用于控制音量
flv 文件可以包含元数据，大多数视频编码器都包含长度元数据，单位为秒，我们可通过
ActionScript 读取它。
方式比较特别一些
把函数引用赋值给 NetStream 对象的 onMetaData 属性上
var client:Object = new Object( );
client.onMetaData = onMetaData;
_stream.client = client;
private function onMetaData(data:Object):void {
_duration = data.duration;
}
videoStream.seek(5); 用于在指定地方开始播放
改变视频的尺寸
设置 Video 对象的 width 和 height 属性，如果要根据视频编码时的尺寸播放，可使用 videoWidth 和videoHeight 值
需要注意的是， flv 还没下载之前这两个属性是不可用的，因此必须等两个属性可用,通过监听netStatus事件
管理缓冲和查看下载进度
使用 bufferTime 属性设置缓冲区大小，使用 bytesLoaded 和 bytesTotal 来监视下载进度
默认情况下视频只缓冲0.1秒,可通过NetStream的buffTime属性进行设置,单位是秒
监听flv格式原有的提示点
使用 onCuePoint( ) 回调函数
使用的具体方式和onMetaData( )一样
var client:Object = new Object( );
client.onCuePoint = onCuePoint;
videoStream.client = client;
Then define the method appropriately:
private function onCuePoint(cuePoint:Object):void {
trace(cuePoint.name + " " + cuePoint.time);
}
给视频添加滤镜,把过滤数组赋值给Video对象的filter属性
控制视频的播放和暂停
使用 NetStream 对象的 pause( ) 方法
其中该方法可以接受一个boolean参数,用于判断当前状态,进行不同的处理
true表示,如果暂停,则继续播放. false表示如果播放,就暂停, 其他无效果
如果要停止播放视频,需要使用NetStream类的close方法
如果要想每次都是播放最新的数据，可以在 url 上加个唯一字符串，如下面的代码：
videoStream.play("video.flv?uniqueIndex=" + (new Date( )).getTime( ));
视频播放完后,使用下面方法清理最后一帧的画面
video.clear( );
检查用于带宽--使用下载一个文件,然后计算时间来计算出下载的速度
本地化存储数据---SharedObject
Flash 的 LSOs 就如同 Web 浏览器中的 cookies
创建或打开共享对象
var example:SharedObject = SharedObject.getLocal( "example" );
写入数据到LSO上
example.data.exampleArray = new Array( "a", "b", "c" );
其中exampleArray为以后访问使用的key,不能存储可视化对象
保存lso到客户机
使用 SharedObject.flush( ) 方法,该方法返回一个字符串,用于判断是否保存成功
如果确切知道存储数据的大小，可直接给 flush( ) 传参数：
从共享对象中读取数据
就是读取共享对象的data属性中的值
trace( example.data.exampleProperty );
删除共享对象中保存的数据
使用 delete 删除共享对象的 data 属性中的值，或使用 clear( ) 方法清除整个共享对象
不能直接设置成null或者undefined,因为他们都是有效的值
delete example.data.someVariable;
序列化自定义类
使用 flash.net.registerClassAlias( ) 方法保留类型信息并把类实例添加到共享对象的 data 属性上。
LSOs 使用特殊的二进制格式， Action Message Format (AMF)
registerClassAlias( ) 方法需要两个参数，第一个参数表示类的别名，可以用任意字符串表示别 名 ，
比如 modal 包中有个 Person 类，别名可以是 modal.Person ，第二个参数类引用。
registerClassAlias( "somePackage.ExampleClass", ExampleClass );
这里需要注意的是 registerClassAlias( ) 必须在 SharedObject.getLocal( ) 方法之前调用才有效。否 则
的话共享对象会把 Person 解释为普通的 object 类型进行存储。
本地路径参数（ getLocal( ) 第二个参数）为绝对或相对路径字符串，指定 LSO 的存储位置，例 如 ：
var example:SharedObject = SharedObject.getLocal( "example", "/" );
这个目录的不同点是缺少电影剪辑的信息，这样创建的 LSO 可以被同一个域的其他 flash 电影所共享访问：
var example:SharedObject = SharedObject.getLocal( "example", "/" );
控制lso容量的大小
使用 Security.showSettings( ) 方法或者访问 Web 站点的 Flash Player Settings Manager.
通过 LocalConnection 实现互Flash之间的相互通信
让同一台电脑上的两个flash进行通信
创建本地连接
使用 flash.net 包中的 LocalConnection 类来收发数据。在接收端使用 LocalConnection.connect( ) 方 法
监听信息，定义一个函数触发 LocalConnection.send( ) 发送数据，两个 Flash 必须指定相同通信信道。
而不必当心flash是从什么服务器上下载来的
多个 Flash 要想进行通信必须做三件事：
1. 设置接收端 Flash 的监听处理函数
2. 告诉接收端收到数据后做什么
3. 从发送端 Flash 发送数据给接收端
var receiver:LocalConnection = new LocalConnection( );
// 通知本地连接实例监听来自于 " _exampleChannel " 通道的信息
receiver.connect( "_exampleChannel" );
正如上面的代码例子那样，最好取一个以下划线开头的通信信道名称，这样 Flash 播放器不会 加
入域信息 ，如 果不 是以 下划 线开 头， 则通 信信 道名 称字 符串 将被 自动 转换成
domain:connectionName ，而不管是本地域还是远程域。
连接的方法
1. 创建动态的 LocalConnection 子类，使用这个实例作为所有接收端本地连接
2. 创建 LocalConnection 子类重写发送数据的方法
3. 重定向客户对象的请求
三种不同的方法,下面进行每种的测试
1:
要想在运行时修改类的方法，该类必须申明为 dynamic 。在 ActionScript3.0 中最简单的方法就是
继承 LocalConnection 类并申明为 dynamic 类，使用这个类作为接收端：
dynamic public class DynamicLocalConnection extends LocalConnection {}
这样就可以直接使用该实例,灵活性很高,不过无法定义接口,不符合面向对象设计原则
2:
继承LocalConnection,将example方法写在类的内部.
3:使用LocalConnection的属性client来重定向请求,client对象必须是public的方法
_localConnection = new LocalConnection( );
_localConnection.connect( "_exampleChannel" );
_localConnection.client = this;
同时在这个类内部写出public的example()方法
发送信息的方式,后面可以带不定量的参数
var sender:LocalConnection = new LocalConnection( );
sender.send( "_exampleChannel", "example" );
如果试图connect一个已经被监听的端口,就会发生异常,所以需要进行try catch监听,通信的过程是多对一的
基于本地通信的有效性验证---即确认数据是否被接收端接受到
就是分别建立一个通道,然后在接受到数据的方法内部,再发送一次数据回去,比较好的设计可以把自己的通道名和方法发送给接收端..
接受来自其他域中的flash的本地连接请求
默认情况下,接收端只接受来自同一个域的本地连接请求,不过可以使用allowDomain()方法允许或者禁止来自其他域的请求连接
使用LocalConnection实例来进行设置
receiver.allowDomain( "macromedia.com", "adobe.com", "google.com" );
~ 表示所有的域都允许， localhost 表示只有本机的允许。
还有个与 allowDomain( ) 类似的方法 allowInsecureDomain( ) 方法，用于设置Https的请求
在 ActionScript 3.0 里发送和读取的数据都会被改变。 LoadVars 类已经被 flash.net 的 URLLoader 所 代
替。 URLLoader 支持新的字符集映射，他们是 URLRequest , URLVariables , 和 URLStream 。这
些类提供了比以前更强大更灵活的处理能力。
读取 URL- 编码数据时应该使用 URLLoader.load( ) 方法
load( ) 方法需要一个 URLRequest 实例作为参数，该参数指向文本文件的 URL
如果读取成功， Flash 播放器把数据存在 URLLoader 实例的 data 属性上,并发出complete事件
// 设置读取的是 URL- 编码 变量 --就是key和value的键值对格式
loader.dataFormat = DataFormat.VARIABLES;
如果事先不知道变量名可以使用for in
for ( var property property property :String in loader.data ) {
// property 就是 data 里的变量名
trace( property + " = " + loader.data[property] );
}
读取文本块(包括了HTML和XML)
使用 URLLoader.load( ) 和 DataFormat.TEXT
dataFormat 属性如果为 DataFormat.TEXT ，则会把数据解释为普通的文本内容,默认就是这个
var loader:URLLoader = URLLoader( event.target );
方式进行事件完成对象的包转,可以减少全局变量的好似用,然后访问实例的data对象
如果设置为 DataFormat.BINARY ，则 data 的数据类型为 flash.util.ByteArray 。
监听加载进度
使用loader.addEventListener( ProgressEvent.PROGRESS, handleProgress ); 事件类型为ProgressEvent
注意UrlLoder不能边下载,边处理数据,那需要使用到URLStream
URLStream 中的 progress 事件允许使用 bytesAvailable 属性和下列方法如 readInt( ) , readByte( ) ,
readBoolean( ) 检查下载的数据。访问的是二进制数据
同样使用相同的模式进行数据的边加载 边处理
var streamer:URLStream = URLStream( event.target );
// 遍历所有已读取得字节数据
while ( streamer.bytesAvailable > 0 ) {
// Read a byte value and output it to the console window
trace( "Read byte: " + streamer.readByte( ) );
}
读之前最好检测下 bytesAvailable 属性,防止越界
简单的发送数据给服务端脚本
创建一个包含数据的 URLRequest 实例，并用 flash.net.sendToURL( ) 方法传递给服务端脚本 , 如果 想
在新的浏览器窗口中打开可使用 flash.net.navigateToURL( ) 方法，如果想知道执行结果，可使用
URLLoader.load( ) 方法。
sendToURL( ) 方法也就不会返回数据是否发送到.
navigateToURL( request, "_blank" ); 可以用于在新窗口中发送数据
如果想接收服务器返回的结果，可使用 URLLoader.load( ) 方法
默认情况下使用sendToURL()或navigateToUrl()方法,数据都是通过HTTP POST方法传输的
创建发送的变量的方式
var variables:URLVariables = new URLVariables( );
variables.someText = "Post me!";
request.data = variables;
下面是用于指定发送的方式
request.method = URLRequestMethod.POST;
使用loader.load(request)来发送请求
xml使用
创建XML对象,使用As内置的xml类型
直接声明
var example:XML = <abc><a>eh</a><b>bee</b><c>see</c></abc>;
也可以直接将字符串转换成XML
var example:XML = new XML( str );
添加xml元素
使用 E4X 语法创建子元素并添加到 XML 树中。另外用 insertChildBefore( ) 和 insertChildAfter( ) 方法更容易控制元素的添加。
var example:XML = <example />;
example.newElement = <newElement />;
那样就可以显示如下效果
<example>
<newElement/>
</example>
也可以直接添加一个节点
var example:XML = <example />;
example.emptyElement = "";
/* 显示 :
<example>
<emptyElement/>
</example>
*/
也可以使用数组的方式进行添加
var example:XML = <example />;
var id:int = 10;
example[ "user" + id ] = "";
/* 显示 :
<example>
<user10/>
</example>
*/
有可能包含特殊符号的时候会报错,那时候就要使用[]方式来添加
需要注意,这种方式添加的节点都是放置xml树的尾部,可以用insertChildBefore( ) 和
insertChildAfter( ) 方法来控制插入的位置。 insertChildBefore( ) 方法在当 前元素位置前插入新元素，而
insertChildAfter( ) 在当前元素的后面插入，看下面的例子：
example = example.insertChildBefore( example.two, <one /> );
表示在example实例的<two>节点前介入<one>节点
注意这两个方法不会修改原先的xml,只会返回新的xml
添加文字节点
即可使用 E4X 语法创建文本节点并插入到 XML 树中，也可用 appendChild( ) , prependChild( ) ,
insertChildAfter( ) , 和 insertChildBefore( ) 方法进行更多控制，灵活插入。
// 创建 XML 实例
var example:XML = <example/>;
example.firstname = "Darron";
example.number = 24.9;
example.boolean = true;
example.abc = ["a", undefined, "b", "c", null, 7, false];
/* 显示 :
<example>
<firstname>Darron</firstname>
<number>24.9</number>
<boolean>true</boolean>
<abc>a,,b,c,,7,false</abc>
</example>
这样会同时增加文本和元素节点
在xml中添加属性,使用@属性名进行操作,其他等同于增加元素节点
elementNode.@attributeName = "value";
读取xml树中的元素
使用 elements( ) 方法返回 XMLList 类型的所有元素，并用 for each 循环遍历
for each ( var element:XML in node.elements( ) ) {
{trace( element.@label );}
通过名字查找元素节点
就是通过节点的实例名.节点名.@属性名就可以进行所有的查询
可以用..来跳过一级访问
多个同类型节点的时候,使用类似数组的方式访问,下标有0开始
当节点同时包了节点也包含了文本,可以使用.text()方法输出文本内容
读取元素的属性
使用 attributes( ) 方法返回指定元素的属性列表,返回一个xmlList类型,使用数组的方式进行访问
使用.name()方法可以显示属性名
trace( fruit.attributes( )[1].name( ) );
还有种方法，可使用 attribute( ) 方法并传入属性名作为参数，得到属性值：
trace( fruit.attribute("color") );
用 (*) 和 @ 操作符可访问所有属性值，有些类似于 attributes( ) 方法：
trace( fruit.@*[0] );
trace( fruit.@*.length( ) ); 用于判断节点下属性的数量
如果属性有包含特殊字符,可以使用[]进行访问,其中可以用于组合条件进行查询
trace( example.@["color" + num] );
删除节点,文本和属性
使用delete关键字
delete example.fruit.@color; 删除属性
delete example.vegetable.text( )[0] 删除文本节点
delete example.dairy; 删除属性
载入xml
使用 URLLoader.load( ) 方法且设置 dataFormat 属性为 DataFormat.TEXT 读取数据，通过 complete事件处理函数转换载入的数据为 XML 实例
下面代码用于在事件中加载返回结果
var example:XML = new XML( event.target.data );
最好使用异常进行包装
从不同域中加载xml文件,需要设置crossdomain.xml策略文件,允许可访问的远程域,也许只是.xml扩展的文件
发送xml
通过 URLRequest 实例把 XML 数据包装起来，用 flash.net.sendToURL( ) 发送数据并忽略服务器的
响应，用 flash.net.navigateToURL( ) 发送数据并把服务器的响应显示在指定窗口，或者用
URLLoader.load( ) 发送数据并处理服务器响应。
远程过程调用 (RPC) ，
URLRequest 对象的 contentType 属性默认设置为 application/x-www-form-urlencoded ，当发送
XML 数据时必须设置为 text/xml ，而且设置 method 属性为 URLRequestMethod.POST ，表示 通
过 HTTP POST. 发送数据。
搜索xml,根据某种规则搜索出xml对象的节点和属性
返回所有对应的节点集合
var fruitList:XMLList = foodgroup.fruits.fruit;
比较常见的格式
trace( fruits.fruit.(name == "Apple").@color );
也可以使用正则表达式进行比较
trace( fruits.fruit.( /^[aeiouAEIOU].*/.test( name ) ) );
()内用于进行筛选的条件
在xml中使用html和特殊字符
使用CDATA标签
<example><![CDATA[a < b]]></example>
当时不能同时包含]]>
远程过程调用 (RPCs) 是一种建立分布式应用程序技术,
不过有两种方式最普遍： web services 和 Flash Remoting 。
Flash Remoting 通过 HTTP 通讯，不过采用的协议不是 SOAP ，而是一种二进制数据协议，称 之
为 Active Messaging Format (AMF) 。因为 AMF 数据报是二进制的，这样可以传输更多的数 据 ，
效率更高，因此 Flash Remoting 速度要比其他 web services 快。
处理WebService,需要先加载wsdl文件,设置wsdl文件后 调用loadWSDL()方法
处理WebService的返回结果
webService.getAverages.addEventListener(ResultEvent.RESULT, onGetAverages);
其中getAverages是WebService中的方法名
监听WebService发出的异常
webService.addEventListener(FaultEvent.FAULT, onWebServiceFault);
事件类型为mx.rpc.Fault.Fault
与JavaScript通信
使用ActionScript调用JavaScript
使用 ExternalInterface.call( ) 函数,至少需要一个参数表示函数名,后面其他参数表示JavaScript的参数
var title:String = ExternalInterface.call("getTitle");
也可以使用flash.net.navigateToURL( ) 函数。
var request:URLRequest = new URLRequest("javascript:alert('example');");
navigateToURL(request);
不过这个方法本身不提供返回值
JavaScript调用ActionScript.
使用 ExternalInterface.addCallback( ) 注册 ActionScript 函数，然后在 JavaScript 端进行调用
addCallback( ) 方法接收两个参数：第一个参数为 String类型的函数名，浏览器将借此名称得知要调用的函数，第二参数为浏览器调用定义的函数名时要执行的实际 ActionScript 函数。
ExternalInterface.addCallback("showMessage", displayMessage);
在 JavaScript 端需要得到 Flash 播放器对象引用
ActiveX 版本播放器由 HTML 页中的 <object> 标签控制,flash的引用通过window.id 其中id是Object标签的id
plug-in 版本播放器由 HTML 页中的 <embed> 标签控制，flash的引用通过window.document.id 其中id是Embed的标签
可以通过navigator.appName来判断用户浏览器的类型,方便于选择合适的引用
然后通过 flashPlayer 变量来调用注册的 ActionScript 函数
flashPlayer.showMessage( ); ,也可以用于传递参数,关键在于ActionScript中function定义的参数列表
将Html中的变量传递给SWF,可以使用flashVars
在Object标签中,使用 <param name="FlashVars">标签,定义键值对格式字符串
url1=http://www.example.com&url2=http://www.sample.com
在ActionScript中可以使用root.loaderInfo.parameters来获取其中的值,
文件的上传下载部分,使用FileReference 和 FileReferenceList 类,以及浏览本地文件
var fileReference:FileReference = new FileReference( );
var urlRequest:URLRequest = new URLRequest("example.txt");
fileReference.download(urlRequest);
用于下载指定URL下的文件,也可以使用绝对路径,download方法的第二个参数用于设置下载的默认文件名,
且最好放置在try..catch中
fileReference.addEventListener(Event.SELECT, onSelectFile); 用于监听用户是否开始下载
fileReference.addEventListener(Event.CANCEL, onCancelDialog);用于监听用户是否取消下载
fileReference.addEventListener(ProgressEvent.PROGRESS, onFileProgress);用于监听下载进度
fileReference.addEventListener(Event.COMPLETE, onFileComplete);用于监听下载完成
浏览本地文件用于上传
使用 FileReference 或 FileReferenceList 对象的 browse( ) 方法
记得使用try--catch检测异常
过滤浏览对话框显示的文件
传递一个 FileFilter 对象数组 作为 browse( ) 方法参数
FileFilter 构造器至少需要两个参数：
第一个参数决定在下拉列表中显示什么文件类型：
第二个参数决定显示的文件扩展名。
var fileFilter:FileFilter = new FileFilter("Images", "*.png;*.gif;*.jpg");
fileReference.browse([fileFilter]);
监测用户是否选择了文件准备上传
fileReference.addEventListener(Event.SELECT, onSelectFile),用于监听用户选择了文件
选中后,文件的信息都保存在fileReference之上
selectedFileTextField.text = fileReference.name;
同样也可以通过监听Event.CANCEL来监测用户取消了上传
var urlRequest:URLRequest = new URLRequest("uploadScript.cgi");
fileReference.upload(urlRequest);
所有上传使用 POST 传输方式， Content-Type 为 multipart/form-data 。
如果是调用 FileReferenceList 对象，那根据 fileList 属性必须为每个文件调用一次 upload( ) 方法，
FileReferenceList 对象的 fileList 属性就是 FileReference 对象数组。
监听文件上传进度,可以使用Progress事件,
其中多文件上传,可以通过判断上传的文件数量,和当前文件上传的速度来做判读.
也可以通过计算全部文件的总大小和当前上传的数量进行汇总计算.
使用Socket进行连接
与其他的通信技术最大的不同是Socket连接在数据传输完成后不会自动关闭,因此服务器可以在任何时间主动发送数据给客户端
Flash下主要包括了二进制的Socket连接和XML Socket连接,其中后者使用xml格式传输数据.
这两种均使用了事件的方式读取数据
如 果 Socket 或 XMLSocket 对 象 要 使 用 cross-domain 策 略 文 件 ， 可 通 过 方 法
flash.system.Security.loadPolicyFile( ) 读取：
Security.loadPolicyFile("http://www.rightactionscript.com/crossdomain.xml");
创建连接的例子
socket = new Socket( );
socket.addEventListener( Event.CONNECT, onConnect ); 监听是否连接成功
socket.connect( "localhost", 2900 ); 发起连接请求
cross-domain 策略文件例子：
<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-
policy.dtd">
<cross-domain-policy>
<allow-access-from domain="*" to-ports="80,110" />
</cross-domain-policy>
发送数据给Socket服务器
对于 Socket 对象，是使用 write 方法 ( writeByte( ) , writeUTFBytes( ) , 等等 ) 把数据写入到缓冲区，
再通过 flush( ) 方法发送数据，对于 XMLSocket 对象使用 send( ) 方法 。
writeUTF( ) 和 writeUTFBytes( ) 方法写入字符串，每个方法接受一个字符串参数， writeUTFBytes ( )
方法写入字节形式的字符串， writeUTF( ) 方法写入字节数字。
writeMultiByte( ) 方法也是写入字符串数据，但可以不使用默认字符集，该方法接受两个参数：
字符串和指定字符集编码，下面的例子写入 Unicode 编码的字符串：
socket.writeMultiByte("example", "unicode");
XMLSocket 类发送数据就比较简单了，发送数据的方法为 send( ) ， send( ) 方法接受任意类型的数
据类型，它会把参数转换为字符串并发送给服务器，一般这个参数是一个 XML 对象：
注意:处理flex发送给Java服务端时,需要单独的加上+"\n"用于发送数据,防止读取的过程产生阻塞 不能在内容内加入\n
接受来自服务端的数据
对于 Socket 实例可通过 ProgressEvent.SOCKET_DATA 事件处理函数中读取数据，可用 readByte( )或 readInt( ) 方法
对于 XMLSocket 实例可通 data 事件处理函数中读取 XML 数据
socket.addEventListener( ProgressEvent.SOCKET_DATA, onSocketData );
然后在事件内部通过下面的代码进行字符串的读取
var string:String = socket.readUTFBytes(socket.bytesAvailable);
XmlList下面事件有点不同
xmlSocket.addEventListener( DataEvent.DATA, onData );
处理事件的函数中,使用如下进行处理接受的数据,数据存放在event.data中,事件类型为vent:DataEvent
var response:XML = new XML( event.data );
断开与Socket服务器的连接
调用 Socket.close( ) 或 XMLSocket.close( ) 方法关闭连接，或者监听 close 事件
监听事件主要用于判断是否已经断开,或者网络中断
socket.addEventListener( Event.CLOSE, onClose );
端口号不能高于 655535.
通过 socket 对象的 connected 属性是否为 true,判断是否已经连接服务器
定义数组和对象
可以通过ActionScript或者在Mxml中定义
<mx:Array>
<mx:String>flex</mx:String>
<mx:String>flex</mx:String>
</mx:Array>
也可以定义多维数组
<mx:Array>
<mx:Array>
<mx:String>flex</mx:String>
<mx:String>flex</mx:String>
</mx:Array>
</mx:Array>
使用mxml创建Object对象<mx:Object id="xx" first="John"/> 创建一个对象,当时不能创建嵌套对象,需要使用在Script中
var object:Object=new Object();
var otherObject:object=new Object();
objec.other=otherObject;
也可以通过大括号来创建对象
var person:Object={name:"xxx",age:xxx}等用来创建一个对象
在ActionScript中创建数组
var arr:Array=new Array("red","blue"); 是通过构造函数来创建 也可以通过中括号来创建var noConstructorArray:Array=[2,3,4,5];
重写父类的方法 需要使用override关键字 在修饰符前面
override public function set date(....)...
调用类的方法 在ActionScript中使用 new 创建一个
在MXML中 使用<位置名:类名 id="xxx"> 去创建一个对象
其中的位置名为在mx:Application中配置的xmlns:cookbook="or..类名" 其中的cookbook
使用ActionScript创建的类也可以使用<cook:COdeBehind xmlns:mx="http://www.adobe.com/2006/mxml" width="200" xmlns:cookbook=
"ore.xx.*">。。。。。。。。。</cook:CO...>
其中的其他控件也可以直接调用类内部的方法 可以用于完善类的作用域,以及之间的传递参数
自定义事件 需要继承flash.events.Event类 需要重写clone()方法,以便复制本身 覆盖的方法就是new一个自己对象
创建与事件数据相关的属性 然后在实现类中使用
请注意这个类，只有当 button 被激活时才会监听到它发出的事件。如果你删除了 button ，那
么就没有东西可以激活了， keyHandler 函数也永远不会被调用。要想在程序中捕获所有的
KeyEvents 事件而不管有没有组件被激活，请添加下面的句子：
Code View:
addedToStage="stage.addEventListener(KeyboardEvent.KEY_DOWN, keyHandler)"
flex下方法参数类型的定义
可以使用参数 count:int=0 的方式 或者otherValue:Object=null 的方式进行参数的初始化
然后在方法内判断参数是否和初始化有修改,决定是否进行变更,执行不同的操作
也可以使用参数(...arguments) 来定义参数列表
然后使用 for each(var arg:Object in arguments) 来遍历参数列表
常见的类型判断,在鼠标mouseEvent中使用event.target is 控件类型...来判断类型
在mxml中实现一个接口.在顶层的组件中使用implements属性
控件的样式不同于属性,需要使用id.setStyle("样式名",值)来动态变更样式
SwfLoader用于加载swf到flash中,只要设置source属性,可能需要注意沙箱问题,也可以在source属性中属性@Embed进行嵌入
使用lablefunction可以直接访问作为dataProvider数据源中的单个记录的属性,这样就可以用于合成指定的值,便于自定义显示
Flex控件的数据源dataProvider一般使用Collection集合对象作为数据源,如ArrayCollection和
XMLListCollection,确保数据的任意变化会触发控件相应的显示,在设置数据源格式的时候,可以使用预先定义的数据源的属性,来作为数据源
本身Object对象的属性,也可以通过Json的key来表示.
List类型的控件列表中,通过对应事件的item属性获取单项的完整引用,使用@属性名来访问和修改
使用Alert触发事件的detail属性来决定Alert中的哪个按钮被点击
对于控件skin皮肤的设置,先要定义一个类extends PanelSkin类 然后重写对应的方法来实现自定义样式,然后指定控件中的skin属性
来进行变更
容器部分
Box类型控件,可以定义控件之间的距离,也分为了H和V两种布局,类似Css中的盒概念来控制布局,如paddingTop等。如果要更自由的控制
布局,可以在box内部再放入容器
使用不同的坐标系统跟踪鼠标位置
1:使用MouseEvent的四个属性,用于获取鼠标的位置,LocalX和LocalY属性提供抛出mouse事件相关的组件位置,而stageX和stageY提供
与Stage相关的位置.
2:使用DisplayObject的mouseX和mouseY返回相对于容易或组件的0,0坐标的位置
3:Container类定义了contentMouseX和contentMouseY位置,描述相对于整个容易内容的位置.
使用maxWidth和MaxHeight样式属性定义组件,用于防止组件超出界面显示,会使用一个新的容器进行保存超出范围的新组件.
在使用top,left等基于约束的布局设置时候,可以在值里面使用id:值来设置相对控件id位置 如 right="leftID:0"
组件的滚动条设置,通过horizontalScrollPolicy和verticalScrollPolicy属性来控制,如果要全部显示,
使用on值,反之使用off,设置auto为自动显示使用horizontalScrollPosition和对应的
verticalScrollPosition属性用于动态的控制滚动条,int类型操作
使用容器的creationPolicy属性来决定什么时候创建组件
flex可以直接使用组件的explicitHeight和explicitWidth属性指定组件的像素尺寸.
容器内包含组件的数量使用numChildren来访问,使用enabled来控制是否选中可用
使用UIComponent.getBounds(this.stage)可以获取组件的大小,以及x,y等属性
PopUpManager.createPopUp方法返回一个被创建对象的引用,可以用于升级成centerpop或者用于移除,可以添加到一个数组内,便于全局访问
控制组件的可见性和布局,includeInlayout属性用于表明是否保存子组件原有的空间,false为不保留 visibility设置为false用于显示与否
Graphics.beginBitmapFill(,,,)方法用于填充图片到指定区域 使用endFill()结束
Flex中正则的使用 var regexp:RegExp=/<.../ if(regexp.test(str)) 其中str为需要测试的内容是否包含正则
定义另外一种正则的方式使用regexp=new RegExp("字符串")来定义一个正则表达式
Array数组的filter方法需要一个function作为参数,用于过滤指定的字符内容,function函数带3个参数,返回Boolean
enter事件用于处理回车按钮事件
可以使用TextField来自定义一个文本控件,不过需要将TextField添加到一个UIComponent里面,可以设置完整的属性定制.
textInput = new TextField();
textInput.multiline = true ;
textInput.wordWrap = true ;
textInput.type = flash.text.TextFieldType.INPUT;
textInput.addEventListener(TextEvent. TEXT_INPUT,checkInput);
addChild(textInput);
TextRange类接受一个用于TextField的组件,用一个参数指明是否通过TextRange中的属性设置来对组件进行修改.然后用两
个整数决定TextField中的起始字符和结束字符.
其中TextArea的selectionBeginIndex,以及selectionEndIndex用于显示选中的内容范围int
使用loader加载的数据 只能作为数据源赋值给组件,不能直接展示在页面之上
在TextArea中可以使用CDATA包装好的mx:HtmlText属性用于加载图片或者swf 其中使用<img>为主 他的src属性用于指定路径
如果需要调用TextField的setSelection方法 需要直接继承TextField类来实现选中效果
使用@font-face用于嵌入字体
@font-face{
src:url(".....");
fontFamily:DIN;
advancedAntiAliasing:true;
} 其中DIN为引用的字体名称
组件中的iconFunction以及Lablefunction属性用于指定一个函数,分别返回class类(图片)以及String 用于自定义图片或者文字标签
始终httpService请求数据时,使用id.lastResult获取到返回结果
在Tree控件中 要自定义渲染器,需要继承TreeItemRenderer来实现
对List组件内容进行编辑时,会触发三个事情,其中最后一个事件itemEdiEnd事件的触发函数里面包含了一个ListEvent的事件类型,其中包含了一个reason的属性判断用户是否修改了itemEdior的值
例子:event.reason=="cacelled" 来判断用户是否取消了修改
var bewData:String=TextInput(event.currentTarget.itemEditorInstance).text 来获取输入的值
event.preventDefault()来取消修改,使用默认值
其中通过TextInput(listInstance.itemEditorInstannce).setStyle("borderColor",0Xff0000)来设置样式,其中listInstance为List的ID
用于向组件添加右键菜单的例子: 主要使用ContextMenu和ContextMenuItem 以及使用push的方式
var personMenu:ContextMenu =new ContextMenu();
var lookupRecord:ContextMenuItem =new ContextMenuItem( "Look UpUpUp Record");
var lookupPicture:ContextMenuItem =new ContextMenuItem("Look UpUpUp Picture");
personMenu.customItems.push(lookupRecord);
personMenu.customItems.push(lookupPicture);
this .contextMenu = personMenu;
通过源码,可以了解到一些方法,通过继承然后重写里面的方法来实现一些特效,比如List的鼠标划过效果,可以通过override drawHighlighIndicator方法来实现修改.
DataGrid是基于列表的控件,Flex3添加了2个新控件AdvancedDataGrid和OLAPDataGrid更高级
自定义DataGrid排序,通过给DataGridColumn标签的sortCompareFunction属性赋值以执行自定义排序,
例子如下
private pfunction sortRanges(obj1:Object,obj2:Object):int{
var value1:Number = obj1.range.range1;
var value2:Number = obj2.range.range1;
ifififif (value1 < value2) {
return -1;
}
else ifififif (value1 > value2){
return 1;
}
else {
return 0;
}
}
AdvancedDataGrid提供了多列排序支持
通过给DataGrid的数据源的ArrayCollection指定一个filterfunction指定一个函数,传入一个Object对象作为参数,来实现过滤,返回Boolean值,然后使用refresh()方法来刷新数据源
AdvancedDataGrid的selectionMode属性为multipleCells和selectedCells属性为
Object数组,该数组包含了被选择单元格的rowIndex和columnIndex,用于处理多选的情况,其中selectionMode属性有5
种选择,此外要设置多选需要设置allowMultipleSelection属性为true
通过设置DataGrid的dragEnabled来开启拖拉 drioEnabled来开启放置,对于非列表型控件,可以使用DragManager来实现拖拽
通过设置DataGrid的editable属性为true来开启编辑功能
DataGrid中搜索并自动滚屏到匹配项,在ArrayCollection中使用IVewCursor的findFirst方法,使用DataGrid的scrollToIndex进行滚屏
例子:大概过程,新建一个sort对象 获取到数据源集合的curor对象,定义city为可排序字段,应该IViwCursor的findFirst只可以被可排序调用
private function f onResult(evt:ResultEvent): void {
ar sort:Sort = new Sort();
sort.fields = [ new SortField( "city", true) ];
this .homesForSale = evt.result.data.region;
this .homesForSale.sort = sort;
this .homesForSale.refresh();
this .cursor = this this this this .homesForSale.createCursor();
}
进行指定条件的搜索,通过.grid.scrollToIndex进行滚动到指定的行
private function searchCity(): void {
if (search_ti.text != "" ) {
if ( this .cursor.findFirst({city:search_ti.text})){
var idx:int =this .homesForSale.getItemIndex(this .cursor.current);
this .grid.scrollToIndex(idx);
this .grid.selectedItem = this.cursor.current;
GropingCollection可以用来异步更新数据源,不用全局刷新
渲染器和编辑器
创建渲染器最简单的方式,会把数据源中对应的元素赋值给itemRenderer的data属性.
<mx:list>
<mx:itemRenderer>
<mx:Component>
<mx:lable color="...."/>
</mx:Component>
</mx:itemRenderer>
</mx:list>
对于复杂类型的数据,最好重写一个Itemrenderer extends一个任意组件 如HBOX. 并且重写他的set data方法
然后在<mx:List 里面将itemRenderer属性="包名.类名" 在set data里面可以通过setStyle("","")来更新样式,也可以重写get data方法
Mxml方式的去定义个List 需要用<mx:dataProvider>..来定义数据源
Item renderer要访问父组件的一些属性,需要实现IDropInListItemRenderer,通过BaseListData类型访问renderer的父组件一些属性,其中包括使用.owner属性获取到父组件对象的引用
同时设置渲染器和编辑器,可以在dataGridColumn里面设置属性 rendererIsEditor,变更组件的状态,通过变更currentState="edit" 或者="display"进行切换
List编辑后会触发itemEditEnd事件 会带一个ListEvent类型的参数,使用event.preventDefault()来停止事件默认传播,然后再手动更新值,例子如下
list.editedItemRenderer.data= MultipleDataTypeEditor
(list.itemEditorInstance).data;
// Close the cell editor.
list.destroyItemEditor();
// Notify the list control to update its display.
list.dataProvider.notifyItemUpdate(list.editedItemRenderer); //用于直接更新数据源
}
如果要调用相对复杂的editor,比如使用NumericStepper来修改数值,需要修改DataGridColumn中的editorDataField属性为"value",表示用NumericStepper中的value属性中去取值更新.
对List增加编辑后的特效 需要在<mx:List>里面设置itemsChangeEffect属性指向,内部包含的<mx:DefaultListEffect id/> 这个只是当用户修改完成data后才触发
多媒体操作--图片,视频流等
简单的加载图片,Embed(source=".../ss.png") 然后定义个var flag:class;
当要设置成<mx:Image>数据源的时候使用 var asser:BitmapAsset=new flag() as BitmapAsset; id.source=asset;
也可以在mx:image 里面source="{flag}"
播放Mp3的方式
使用Sound和SoundChannel类,其中Sound代表一个声音文件,而SoundChannel用于控制播放
例子
var snd:Sound = new Sound( new URLRequest( "sound.mp3" ));
var channel:SoundChannel = snd.play();
也可以使用sound.load(new URLRequest("url"))来加载mp3,使用SoundTransform来控制音量
var trans:SoundTransform =new SoundTransform(volumeSlider.value,(panSlider.value - 5)/10);
chan.soundTransform = trans;
创建位图数据BitmapData的方式,先新建一个BitmapData类型,然后使用Image对象的.draw(BitmapData)进行绘制;
var maoData:BitmapData =
new BitmapData(firstImg.width,firstImg.height);
var shakeyData:BitmapData =
new BitmapData(secondImg.width,secondImg.height);
maoData.draw(firstImg);
shakeyData.draw(secondImg);
麦克风,使用Microphone.getMicrophone()去获取系统的麦克风,然后通过监听ActivityEvent.ACTIVITY判断是否有声音输入
平滑的播放视频,自定义组件包含flash.media.Video组件,然后设置视频的平滑属性为true,尤其注意需要创建单独的组件,
vid:video=new Video(width,height);
vid.soothing=true;---平滑
this.rawChildren.addChild(vid);
vid.y=50;
this.invalidateDisplayList();
然后使用vid.attachNetStream(ns) 一个newconn来加载视频,再调用ns.play("url")来进行播放
video对象的截图,并且添加数据到UrlRequest对象,并使用navigateToURL方法传送,保存JPEG图像到数据库,需要用到JPEGEncoder类的实例用于转换BitmapData对象
要点: 创建一个BitMapData对象 构造函数需要设置宽高
使用该BitMapData对象.draw(vid) 其中vid对象为加载视频后的videoDisplay组件
创建一个JPEGEncoder对象,构造函数使用数字100传入
使用该对象encode.encode(BitmapData)对象 返回一个ByteArray;
创建UrlRequest对象,设置.mothod="POST"
创建URLVariables来附加参数 urlVars.pic=ba-----ba为byteArray对象
设置urlRequest.data=urlVars;
使用flash.net.navigateToURL(urlRequest, "_blank"); 直接发起请求
混合效果 设置图像的blendMode属性.
flv的附加信息onMetaData 和onCuePoint 事件作为参数被对象接受,就是需要定义个function,然后进行赋值
var obj:Object = new Object();
obj.onCuePoint = onCuePoint;
obj.onMetaData = onMetaData;
ns.client = obj;
NetStream的seek 方法从视频开头起指定秒数的点开始播放ns.seek((playhead.x/timeline.width) * length);
设置连接的常见方式
nc = new NetConnection();
nc.addEventListener(NetStatusEvent.NET_STATUS,netStatus);
nc.connect(null);
然后在连接事件里面开始连接播放
private function netStatus(event:NetStatusEvent):void {
obj.onMetaData = onMetaData;
ns = new NetStream(nc);
ns.client = obj;
vid.attachNetStream(ns);
ns.play("http://localhost:3001/test.flv");
}
读取mp3文件的ID3数据 mp3文件的开头字节
sound = new Sound();
sound.addEventListener(Event.ID3, onID3InfoReceived);
sound.load(new URLRequest("../assets/1.mp3"));
onID3InfoReceived(event:Event):void{
var id3:ID3Info = event.target.id3;
for (var propName:String in id3)..
}
在加载图片的时候显示定制的动画,通过监听ProgressEvent.PROGRESS事件
image组件有两种方式显示图像,设置source和通过.load(URL).
grid.graphics.clear();用于清除旧图像
需要创建一个Matrix(); 然后m.createGradientBox(450, 40);
在加载的progress事件处理函数中,使用
grid.graphics.clear();
grid.graphics.beginGradientFill(""linear", [0x0000ff,
0xffffff], [1, 1], [0x00, 0xff], m);
grid.graphics.drawRect(0, 0, (img.bytesLoaded /
img.bytesTotal) * 300, 40);
grid.graphics.endFill();
进行填充
grid为Canvas的ID img为Image的ID
填充BitMapData的方式就是用BitMapData的实例.draw一个Image对象.
将一个BitMapData设置为Image数据的方法,通过new BitmapAsset(BitMapData)来实现,然后赋值给img.source=...
调用BitMapData.compare(BitmaoData)方法 返回两幅位图之间的差异 需要 as成 BitmapData
皮肤和样式: flex下默认的是Halo AeonThe主题,皮肤是样式的一组属性
flex下的css是通过<mx:Style>下的.来声明的 在组件上使用styleName="..." .后的名字就可以,
如果不加.号表示此类控件都应用该样式,使用''声明字符串的样式值
使用Flex3 SDK提供的mxmlc工具将css打包,然后利用mx.styles.StyleManager在运行时加载css文件,使用loadStyleDeclarations方法
StyleManager加载的是样式swf,使用 dos下的 mxmlc MyStyles.css文件进行编译
StyleManager.loadStyleDeclarations( "assets/styles/MyStyles.swf",true); 进行加载,第二个参数用于是否加载后进行更新
使用StyleEvent.COMPLETE来监视加载完成
通过设置Canvas等组件的themeColor="haloGreen" 等来设置主题颜色,默认是haloBlue
StyleManager.registerColorName 方法来创造自定义的关键字符串值
可以使用compc工具打包swc文件 用于大范围的数据交换
> compc –include-file MyStyles.css C:/mystyles/MyStyles.css –o MyTheme.swc
嵌入自定义字体:在ActionScript中利用[Embed]元标记或者在css中使用@font-face嵌入.
[Embed(source="assets/fonts/verdana.TTF"fontName="MyVerdana" fontWeight="bold")] 然后设置fontfamily="MyVerdana"
在加入fontWeight="bold" 否则无法使用粗体
使用css的方式可以用如下格式
@font-face
{
src: url('assets/fonts/verdana.TTF');
font-family: MyVerdana;
}
可以使用unicodeRage进行字体的部分嵌入
可以使用Flash IDE中生成新的FlA文件,编译使用其携带字体
@font-face {
src: url("styles/fonts/Verdana.swf");
font-family: Verdana;
}
使用自定义的图像为组件的视觉元素应用皮肤
<mx:Button label="" upSkin="@Embed('assets/images/text_button_up.png')"/>
带skin的应该都可以使用嵌入图片,之所以使用Embed是为了放置切换的时候产生延迟
在css中使用Embed指定时,不使用前缀@,其他和桥本中嵌入一致,可以使用scale-9缩放网格信息
up-skin:
Embed(source="assets/images/button_up.png",scaleGridTop="15",scaleGridBottom="20",scaleGridLeft="15",scaleGridRight="28");
可以使用Flash IDE生成的swf保存图片,然后提供加载,下面两种等效
thumbUpSkin: Embed(source="styles/scrollbar_skins.swf", symbol="thumb_upSkin");
thumbUpSkin: Embed(source="styles/scrollbar_skins.swf#thumb_upSkin");
使用编程的方法去绘制皮肤,而不是使用图像
通常来说Flex有两类组件:容器和控件,为控件生成皮肤需要继承mx.skins.ProgrammaticSkin类,为容器生成皮肤需生成ProgrammaticSkin
通常也生成Border或者RectangleBorder的子类 一共三种
需要重载受保护的updateDiplayList方法,也可以选择重载measuredWidth和Height的只读属性,默认值为0
拖拽的设置技巧,将dragEnabled绑定成一个变量{boolean} 然后在dragEnter事件被触发后进行修改,来判断是否进行拖拽
要为一个列表类自定义组件拖动图像,你需要扩展这个控件,并覆盖它的get dragImage():IUIComponent方法
通过继承IUIComponent类用于设置拖动时的显示,其中涉及到引用到list中的内容,以及代理对象ower的使用等等.
覆盖掉createChildren()方法,并且使用var list:List=List(owner);来获取父容器的引用,
然后get dragImage()中返回该IUIComponent实例,注意需要设置该实例的.owner=this;
特别:使用loader加载图片的方式: 实例化一个loader,监听Event.COMPLETE事件,添加addChild(loader)
调用.load(new URLRequest(..url))开始加载,在加载完成的事件中进行数据获取,使用
var info:LoaderInfo=LoaderInfo(evt.target);
var image:Bitmap=Bitmap(info.content);
同时可以设置image.width等进行设置
State的使用:用于控件内部状态的切换,也可以增加特效
大体结构
<mx:states>
<mx:State name=""/>
<mx:State name="addImg">
<mx:SetProperty target="{this}" name="height" value="500"/>
<mx:SetStyle target="{this}" name="backgroundColor" value="#xxxxxx"/>
<mx:addChild relativeTo="{mainHolder}">
<mx:Image source="../ss/ss.jpg"/>..
其中的mainHolder表示为嵌套的一个box的ID 3个类型的标签用于修改和变化,使用currentState="String" 进行状态的切换
设置State切换时候,进行effect播放,
使用Transitions对象 设置其formState和toState属性,并且将effect属性={特效ID}
和State一样,可以在transition对象定义使用setPropertyStyle或SetPropertyAction来改变样式或者当前组件的子组件属性.
targer="{id}" name="属性" value="新值"
Transition中 并行:Parallel 序列:Sequence.
State的继承
使用basedOn属性进行继承 这里注意State使用的是name来引用,不是id
使用flex框架的historyManagement机制整合states,可以用于state改变时,使用HistoryManager.saveState方法保存当前state
需要实现mx.managers.IHistoryManagerClient方法,在creationComplete="HistoryManager.register(this)" 用于注册
数据绑定使用{}或者在运行时使用bindProperty方法创建绑定
BindingUtils.bindProperty(控件ID,'属性',新控件ID,'属性');
<mx:SetEventHandler 用于在State中修改事件
State和Teansition对象都可以动态的创建,只要添加好属性,然后添加在每个UiComponent对象定义的states和transition数组中,
每个UIComponent对象都有这2个数组
使用实现IOverride接口的类,通过apply实现自定义动作,在状态切换时会自动执行,切换成其他后就会自动调用remove方法进行移除
特效Effect
可以使用ActionScript和mxml生成Effect对象,需要设置一个目标UIComponent,在ActionScript里面可以作为构造函数传入给Effect对象
在mxml里面需要使用target="{id}" 进行绑定,然后调用play()方法进行播放
自定义Effect特效, 需要创建两个类,一个继承Effect类,还有一个继承EffectInstance的实力类
集合对象常用的集合对象有ArrayCollection类和 XMLListCollection类
排序,使用coll.addItemAt({name:"James Fex",age:40},0);添加对象到数据.
使用contains和getItemIndex方法都是比较对象的指针,所以不能简单的用来比较值
如果需要进行比较和排序,可以使用Sort对象提供的findItem方法和fields方法
查找的例子:
var sort:Sort=new Sort();
return sort.findItem(coll.source,{name:"",age,Number:""},Sort.ANY_INDEX_MODE) 其中最后的参数有三种,返回的是索引
排序的方式:
var sort:Sort=new Sort();
sort.fields=[new SortField("age",false)];
coll.sort=sort;
coll.refresh();
用于asc的升序排序
ArrayCollection的数据过滤
将一个function(item:Object):Boolean函数传递给ArrayCollection的filterFunction属性,返回Boolean值判断是否保留
然后需要使用.refresh属性用于刷新,注意ArrayCollection元素并没有被过滤器函数所修改,数量等都保持不变
监听ArrayCollection数据项是否被修改
监听ArrayCollection类发出的扩展自EventDispatcher的事件类型collectionChange或者CollectionEvent.COLLECTION_CHANGE
关键在于触发的CollectionEvent类. 通用与所有的Collection集合类
分组集合GroupingCollection,使用Array作为source
创建Grouping实例,传递GroupingField对象数组给Grouping实例的fields,类似Sort的使用方法
var groupingInst:Grouping=new Grouping();
groupingInst.fields=[new GroupingField("需分组的属性")];
groupingColl.grouping=groupingInst;
groupingColl.refresh(false);
如果要传递过个分组,不能使用再建立grouping的方法,那样会覆盖掉第一次分组,需要传递多个GroupingField对象
groupingInst.fields=[new GroupingField("需分组的属性"),new GroupingField("需分组的属性")];
通过实现IHierarchicalData接口定义复杂类型的层级数据,作为DataGrid的dataProvider
遍历集合,可以使用视图游标 集合类.createCursor方法
先用Collection实例.createCursor()方法来创建游标对象,然后使用Cursor.findFirst({属性:值})来进行查找第一个对象
提供了三个主要的方法 findFirst,findlast,findAny进行查找,最后一种速度是最快的,这三个方法可以在未排序的集合中
ObjectHierarchicalData(Object)方法等使用的是将一个对象转换成Collection,而不是Array
Collection使用的过滤和排序是都使用继承的ListViewCollection类的filterFunction和sortFunction属性,或者直接传递sort类型
对象给XMLListCollection的sort属性
sort对象的关键在于fields=[new SortField("属性",false,false,true)]
记得到要使用refresh应用更新
在过滤函数中使用value.calories(@fat)访问属性,其中value为Object类型的参数
对日期类型进行比较和排序
使用mx.utils.ObjectUtil类的dateCompare方法比较日期
日期类型转换使用new Date(Date.parse("字符串")) 格式如下08/16/1982
使用sort:Sort=new Sort();
sort.compareFunction=sortFunction;
Collection.sort=sort;
Collection,refresh();
其中sortFunction(a:Object,b:Object,fields:Array=null):int 返回的结果包括 1<2=1; 1=2 =0; 1>2=-1
使用mx.utils.ObjectUtil.copy(Object)方法进行深拷贝. 该方法的工作原理是把原对象转换成ByteArray,再写到新对象上
var ba:ByteArray=new ByteArray();
ba.writeObject(objToCopy);
ba.position=0;
var objeToCopeInto:Object=ba.readObject();
通过ByteArray转换后.对象被序列化成ActionScript Message Format(AMF)二进制数据.
不过在拷贝指定类型的对象时候,需要特别的操作
需要使用flash.net.registerClassAlias方法事先在flash player中进行注册.需要两个参数完全类名和对象类型
使用var className:String=flash.utils.getQualifiedClassName(obj)获取对象的完整类名;
然后flash.utils.getDefinitionByName(ClassName) as Class获取对象类型
序列化对象的UID 类似java中的序列化ID,用于判断对象是否一致,而不用去判断属性
事先IUID接口,构造函数中使用UIDUtil.createUID();并且实现get和setuid的方法 uid:String
数据绑定
有三种方法定义数据绑定
在类中使用
[Bindable]
public class DataObject extends EventDispatcher{}...
所有可以绑定的类必须由IEventDispatcher类实现,因为数据绑定是基于事件驱动的
在变量面前只用[Bindable]
在getter/setter方法前使用[Bindable],注意放在get前
绑定的变量值更新时,会发送propertyChange事件来更新数据,也可以用[Bindable]标记接受一个事件属性
[Bindable(event="My...")];
在mxml中可以使用{}或者<mx:Binding>进行数据绑定
使用mx:Binding 可以使同一目标定义不止一个数据源
例子
<mx:Binding source="控件id.属性+'其他附加字符串'" destination="目标控件id.属性">
使用[Bindable(event="事件名")]
private Function isss():boolean{} 会在触发该事件后自动调用该方法
使用dispatchEvent(new Event("事件名")) 来触发事件
放置在set方法里面,监听值的变化
flex支持双向绑定,且不会有死循环
bindingUtils.bingProperty(目标ID,"属性",数据源ID,"属性");
通过方法BindingUtils.bindSetter,可以声明函数来处理数据绑定的源数据的更新事件,等于将数据变化指向了一个新的函数
BindingUtils.bindSetter(函数名,数据源ID,"property");
上述两个方法均返回changeWatcher对象,可以用于更新数据源,目标属性,以及停止数据绑定,其中使用unwatch来移除绑定
E4x语句;
var _data:xml=<items><item>
其中存在多个item时候,使用_data..item获取到所有的item节点.
可以使用_data..item.(@id=='1').name 用于xml的过滤,也可以调用string类型的方法
建议将多个Bindable对象合成一个代理Object对象,用于统一管理
private var obj:Object={name:'tom',geng:''};
[Bindable]
private var proxy:ObjectProxy=new ObjectProxy(obj);
验证,格式化和正则表达式
Validator验证器 Formatter 格式器
ActionScript里面的正则表达式用名为RegExp的类来表达,包含了两个主要的方法, /.../
test返回一个boolean,判断是否匹配
exec返回一个包含所有相配的项目的数组和对象
使用<mx:NumberValidator source={控件ID} property="属性" 用于绑定验证目标控件的指定属性,一般是输入控件的text
Formatter声明的方式:
<mx:PhoneFormatter id="phoneFormatter" formatString="(###)###-####" validPatternChars="#-()"/>
使用的时候id.text=phoneFormatter.format(id.text);
手工验证的时候,使用var vResult:ValidationResultEvent;
vResult=phoneValidator.validate();进行验证,然后判断属性
vResult.type==ValidationResultEvent.VALID 来判断是否验证成功
日期验证控件中,需要设置inputFormat="mm/dd/yyyy" 来设置格式
一般手动使用focusOut="function()" 来开启验证
自定义Formatter,继承Formatter类,重写format方法
使用error="错误信息" return "" 来返回错误提示
最终使用
var dataFormatter:SwitchSymbolFormatter=new SwitchSymbolFormatter();
return dataFormatter.formatValue(formatString,value);
使用数组一组的正则表达式不错的方法
自定义验证器
重写doValidation方法 返回一个Array,返回错误的时候
var err:ValidationResult=new ValidationResult(true,"","","错误提示");
reuslt.push(err) 其中result为一个Array;
验证radio button组件群是否被选中,可以判断selectedIndex属性是否为-1,可以使用NumberValidator控件
ComboBox的selectedItem为空,则未选中
批量执行验证:使用一个数组保存验证控件ID,validatorArr.push(tfValidator)
使用var ValidatorErrorArray:Array=Validator.validateAll(validatorArr)进行批量验证
然后通过判断该数组的长度,如果为0则无错误
Array.join("\n") 生成一个字符串
使用ToolTipManager去创建ToolTip,并放置在控件之上,用于显示错误,使用errorTip.setStyle("styleName","errorToolTip")
来设置提示样式
定位Tooltip, 使用var pt:Point=this.stage.getBounds(err.currentTarget.source)来定义 然后使用pt.x和.y来设置位置
完整的创建错误提示.
var errorTip:ToolTip=ToolTipManager.createToolTip(err.message,pt.x+err.currentTarget.source.width,pt.y)as ToolTip
使用TooltipManager的destoryToolTip来进行销毁
将errorTip对象保存在Array里面,便于移除
正则回顾 \d=[0-9] \D=[^0-9] \b表示一个单词 \B表示两个单词 \n表示换行符
\s表示所有空白的字符 \S表示非空白的字符 \t表示tab键 \unnnn表示对Unicode编码进行匹配
\w表示对单词字符 \W表示非单词 \xnn表示特定的ASCII编码
?表示0或1次 *表示0或者多次 +表示1次或者多次
^在外面表示开头 $表示结束单行
向前和向后匹配,去掉正则不能包含的对象或者字符
/(?<=\$)\d+/表示只截取$111后面的数字
/\b(?<!\$)\d+/表示不带$的数字
向后使用
var reg:RegExp=/pic(?!\.jpg)/表示匹配非jpg扩展名的文件 可以将!换成= 表示都.jpg文件
图表组件
Flex图表组件是Flex data visualization包中,只包含在fb专业版中
每一种图表都有一个ChartSeries对象与之对应
在series里面使用<mx:rollOverEffect><mx:fade ..><>来创建特效还有另外种为<mx:rollOutEffect>
更多的效果涉及到SeriesInterpolate,SeriesZoon,和SeriesSlide,
一般在数列对象的showDataEffect和hideDataEffect中, 其中SeriesInterpolate只能应用到showDataEffect
中,均为mx格式
让图表可选,设置selectionMode属性为single或者mulitiple, 设置成none为不可选
图表的change事件可以监听用户是否使用鼠标或者键盘改变选区,当是对程序改变选区无效
使用图表id.selectedChartItems来获取选中的数据
使用 AxisRenderer 中的样式来设置图表刻度线的外观
<mx:verticalAxisRenderers>
<mx:AxisRenderer axis=" { vertAxis } " styleName=" customTicks " />
</mx:verticalAxisRenderers>
vertAxis为坐标轴的ID
使用样式和标签函数,可以用于自定义图表的标签
图表中包括两种标签,坐标轴标签和数据标签,可以使用标签函数进行自定义配置
标签函数对于数字坐标轴,分类坐标轴和数列的用法略有不同
<mx:verticalAxis>
<mx:LinearAxis labelFunction=" { currencyAxisLabel } " />
</mx:verticalAxis>
ChartItemEvent的hitData,item.food属性来获取这个被点击的数据 其中food为数据源中的属性
要为图表更换皮肤,需要创建可以继承ProgrammaticSkin类以及实现IdataRenderer类
将一张图片设定为图表数列的 itemRenderer ，只需简单地把已嵌入的图片设置为itemRenderer 的属性即可。
<mx:PlotSeries xField="goals" yField="games" displayName="Goals per game" itemRenderer=
"@Embed(source='../assets/soccerball.png")" radius="20" legendMarkerRenderer="
@Embed(source='../assets/soccerball.png')"/>
也可以用继承类来实现..参考前面其他内容
使用ActionScript可以动态添加和删除图表中的列
使用图表id.series=[ColumnSet对象]
其中使用ColumnSet对象.series.push(Colunerises的实例)
覆盖图表组件的dragEnterHandler()和dragDropHandler()方法可创建一个可拖拽的图表
共享对象
SharedObject数据可以保存在用户的本地硬盘上,类似浏览器的cookie,使用AMF来序列化保存100k
SharedObject只能被创建他的应用程序访问,以及域问题.
本地共享对象Local SharedObjects
远程共享对象Remote SharedObject;使用FMS来保存
创建或者打开一个本地共享对象,可以使用
var myLoaclSharedObject:SharedObjec=SharedObject.getLocal("mylso");
远程共享对象可以使用sharedObject.getRemote("myRso")
文件的扩展名为.sol
var soInstance:SharedObjec=SharedObjec.getLocal("myLso");
使用soInstance.data.key="..."
所有的对象都需要附加在date.自定义key之上 否则会抛出异常
使用SharedObject.flush(大小) 来保存到硬盘上去
使用SharedObject的clear()方法删除文件,delete lso.data.key 用于删除该值
如果要保存自定义数据类型的对象到SharedObject,需要使用registerClassAlias()方法来注册flash运行时
所有共享对象都包含了一个叫做ObjectEncoding的属性,标示该共享对象使用的AMF版本.默认是AMF3 即as3格式,
如果要向后兼容,可以设置为AMF0
registerClassAlias("oreilly.cookbook.Automobile" , Automobile );
使用ObjectUtil.toString(lso.data.automobile);进行读取
使用多个应用程序中访问同一个共享对象
lso = SharedObject.getLocal("myLso", "/" ); 第二个参数用于指定路径
数据服务和服务端通信
Flex 提供了三个类来与服务器通讯： HTTPService ， RemoteObject 以及 WebService 。
使用Httpservice后,数据会从服务返回,并放置在服务组件所包含的lastResult对象,默认的resultFormat为ActionScript对象
使用HTTPService组件,设置他的url为接受数据的URL,如果反馈的是XML,就需要定制处理,指定一个方法到组件的xmlDecode属性
来处理xml
<mx:HTTPService>
<mx:request xmlns="" >
<id> {requestedId} </id>
</mx:request>
</mx:HTTPService>
这次发送 中 requestedId 属性会被包装在 id 标签，然后发送到 HTTPService 对象设定的 U RL上。
要访问请求回的数据,直接使用httpservice的lastResult就可以了,不需要用事件取得结果,事件只用来判断状态
xml返回结果的处理
<mx:HTTPService url=" http://localhost/service.php " id=" service "
result="serviceResult(event)" fault="serviceFault(event)"
method=" GET " contentType=" application/xml " useProxy=" false " >
然后就可以使用service.lastResult.age 进行访问
所谓 REST ful 的服务一般被用来描述一个服务使用所有 4 个可能的 HTTP 头 ： PUT,POST ，
DELETE 以及 GET 。这四个头通常对应四种基础的数据访问操作：创建，读取，更新以及删除
使用Httpservice可以直接设置id.method="Delete"类似get和post 也可以直接使用id.send("id=2")进行带参数的发送
<mx:RemoteObject id=" local_service " concurrency=" single "
destination=" http://localhost:8400/app " showBusyCursor=" true "
source=" LocalService.Namespace.Service.ServiceName " >
<mx:method name=" getNames " fault="getNamesFault(event)" result="getNamesResult(event)" />
<mx:method name=" getAges " fault="getAgesFault(event)" result="getAgesResult(event)" />
</mx:RemoteObject>
result事件返回的是ResultEvent类型的事件 使用
var namesColl:ArrayCollection = event.result as ArrayCollection; 处理返回结果的类型转换
fault事件返回的是FaultEvent类型的event.message as String来处理错误信息
var responder:Responder = new Responder( getNamesResult,getNamesFault );
var call:AsyncToken = ( local_service as AbstractService).getNames();
call.addResponder(responder);
用于给RemotObject定制事件 其中getNamesResult,getNamesFault 为函数名
加载 service-config.xml 文件需要改变 flex 的编译参数：
1, 菜单 Project->Properties
2, 选择 Flex Complier 块在 " locale en_US " 后面添加 -services service-config.xml 。
3, 确定。
[RemoteClass(alias= "project.Employee" )] 与服务器绑定对象
使用 IExternalizable 接口自定义序列化
使用 ActionScript 3 API flash.utils.IExternalizable ，它兼容 java.io.IExternalizable API.
使用类扩展该接口,并且写上两个对应的方法
public function freadExternal(input:IDataInput): void
{
_id = input.readObject() as String;
name = input.readObject() as String;
description = input.readObject() as String;
price = input.readInt();
}
使用HttpService请求 id.send方法返回的是一个AsyncToken类型的对象
var token:AsyncToken = service.send();
可以用如下进行事件捆绑,以及设置自定义的属性month等其他任意属性
token.resultHandler = onResult;
token.faultHandler = onFault;
token.month = monthName;
在返回结果的函数里面 可以使用ResultEvent.token.属性名 进行定义属性的访问
在服务端数据改变后主动通知客户端
使用 mx.messaging.Producer 和 mx.messaging.Consumer 标签配置用于通信的目标通道和消息
事件设置事件处理器。配置这些需要使用 Adobe LiveCycle 或 BlazeDS 服务器。
Flex的消息可以是ActionScript消息和Java Message Service(JMS)消息
使用Consumer通过mx.messageing.events.MessageEvent接受消息,使用Producer使用send方法发送消息,该方法接受
mx.messaging.AsyncMessage作为参数,AsyncMessage的主体作为值发送给通道的所有订阅者
例子
<mx:Producer id=" producer " destination=" http://localhost:8400/chatDestination " />
<mx:Consumer id=" subscriber " destination=" http://localhost:8400/chatDestination "
message="receiveChatMessage(event)" />
private function sendChatMessage(): void
{
var msg:AsyncMessage = new AsyncMessage();
msg.body = "test message";
producer.send(msg);
}
private function receiveChatMessage(msgEvent:MessageEvent): void
{
var msg:AsyncMessage = AsyncMessage(msgEvent.message);
trace ("msg.body" +msg.body);
}
注册服务端数据类型,就是将Javabean类和本地的ActionScript进行自动的转换
反序列化AMFshujuzhong的对象为类对象事,该类需要现在Flash Player中注册,这样反序列化才可以正常
使用e.result as 类型,获取到ResultEvent返回的类型对象.
flash.net.registerClassAlias( "oreilly.cookbook.vo.RecipeVO" ,RecipeVO);
需要先进行类注册,然后匹配的对象可以被转换成指定的类型
连接WebService
创建 mx.rpc.WebService 对象，设置 wsdl 属性为 WebService 的 WSDL 地址
<mx:WebService id="userRequest" wsdl="http://localhost:8400/service/service?wsdl">
<mx:operation name="getRecipes" result="getRecipeHandler()"
fault="mx.controls.Alert.show(event.fault.faultString)"/>
</mx:WebService>
其中<mx:operation> 用于返回结果处理函数
注意使用webservice时,需要判断当前的webservice是否可用,主要是是否载入和解析wsdl属性所指定的WSDL文件,并准备好所有的
方法已经可以调用. 可以通过WebService发出LoadEvent事件或者判断WebService组件的ready的boolean属性
<mx:WebService id=" userRequest " wsdl=" http://localhost:8500/service/service?wsdl "
load="callService()" >
<mx:operation name=" getRecipes " resultFormat=" object " fault="createRecipeFault(event)"
result="createRecipeHandler(event)" />
</mx:WebService>
添加SOAP头到WebService请求
创建一个 SOAPHeader 对象，参数为所使用的名称空间和添加到 header 的内容。然后调用WebService.addHeader 方法发送带有请求的 header
var qname:QName=new QName( ""http://soapinterop.org/xsd" , "CookbookHeaders" );
var headerone:SOAPHeader =new SOAPHeader(qname, {string: "header_one" ,int: "1" });
var headertwo:SOAPHeader =new SOAPHeader(qname, {string: "header_two" ,int: "2" });
然后再调用service.addHeader(headerone); 添加头部到服务中
添加 SOAPHeader 到指定的方法上：service.getRecipes.addHeader(headertwo);
如果SOAP不再需要了,调用WebService或者方法本身的clearHeaders方法
service.clearHeaders();
service.getRecipes.clearHeaders();
解析WebService的返回的SOAP响应,解析返回的SOAP编码的XML
使用SecureAMFChannel进行AMF的安全通信
使用AMF数据和安全的Sockets层(SSL)通过Flash Remoting进行通信,在编译程序所使用的services-config.xml中定义channel为
SecureAMFChannel
要创建一新的 channel ，使用安全版本的 AMF 类，只要在 services-config.xml 文件的 channel
中使用 mx.messaging.channels.SecureAMFChannel 作为其类,(endpoint) 终 端设置为
flex.messaging.endpoints.SecureAMFEndpoint 类：
然后在频道内,需要设置一个ChannelSet对象用于设置给RemoteObject,ChannelSet对象内也要设置好对应的SecureAMFChannel
使用Socket收发数据
要创建一个 Socket ，先要使用构造器创建 Socket 实例，调用 connect 方法，传递 IP 地址或域名和端口号作为方法参数：
Socket 可接收和发送 POP3 ， SMTP ， IMAP 信息
默认构造函数是空的 new Socket();
socket = new Socket();
socket.addEventListener(ProgressEvent.SOCKET_DATA,readSocketData);
socket.connect( "127.0.0.1", 8080);
socket.writeMultiByte(string, "iso-8859-1" ); 用于写入数据,其中string是值,后面为编码
读取的时候,使用
var ba:ByteArray = new ByteArray();
trace (socket.readBytes(bs));
用于读取数据
要连接端口号低于1024的Socket,需要在站点根目录下创建一个cross-domain.xml文件,其中定义允许的端口号,
<?xml version="1.0"?>
<cross-domain-policy>
<allow-access-from domain="*" to-ports="80" />
</cross-domain-policy>
XMLSocket 类实现了客户端 socket ，让 Flash Player 和 AIR 应用程序可以指定 IP 地址和域
名即可连接到服务器。要使用 XMLSocket 类，服务器端必须运行一个能了解 XMLSocket所使用协议的伺服器.
XML 信息是通过全双工传输控制协议 / 互联网协议 (TCP/IP) 流发送。
var xmlsock:XMLSocket = new XMLSocket();
xmlsock.connect( "127.0.0.1", 8080);
端口号是必须的，因为 XMLSocket 连接的端口号不能小于 1024 。给 DataEvent.DATA 事件添加监听器，用于接收数据：
xmlsock.addEventListener(DataEvent.DATA, onData);
private function onData(event:DataEvent): void
{
trace ("[" + event.type + "] " + XML(event.data));
}
返回的字符串可转换为 XML ，使用 E4X 进行解析。
XML 可拓展标记性语言 flex主要包括了XML和XMLList
XML 对象代表单一的 XML 元素 , 一个 XML 文档或该文档中的一个单
值元素。 XMLList 则代表一组跟其他组同级的 XML 元素。 XMLList 对象不需要设置顶级节点 , 例如 :
<item id="2" name="Chewing Gum"/>
<item id="3" name="Cotton Candy"/>
<item id="4" name="Candy Bar"/>
XML 对象需要设定顶级节点 :
<order>
<item id="2" name="Chewing Gum"/>
<item id="3" name="Cotton Candy"/>
<item id="4" name="Candy Bar"/>
</order>
加载XML的方式
使用 HTTPService 组件来加载 XML 文件 , 并把 resultFormat 设置为 ” xml ” 。 或者 , 使用
flash.net.URLLoader 类来创建一个 URLLoader 实例 , 并调用 load 方法来加载 XML 文件。
在默认的情况下 , HTTPService 组件会把任何加载的 XML 转换成一个 ActionScript 对象。 要
避免这种情况 , 可以对 HTTPService 对象的 resultFormat 属性进行以下设置 :
<mx:HTTPService url=" http://server/xmlDoc.xml " i d=" xmlService "
resultFormat=" e4x "result="xmlObj=XML(xmlService.lastResult" />
httpservice的lastResult用来保存请求的结果
Event.COMPLETE 事件监听器必须添加到 URLLoader 里 , 这样当文件加载完成时 , 应用程序
就会得到通知。 所加载的数据将会存放到 URLLoader.data 属性里 , 不能被修改。
通过E4x语法遍历xml文档
使用 E4X 语法的 ” @ ” 运算符来存取属性 , “ ([]) 运算符 ( 数组索引 ) ” 是用来指示 多个子节点 之间
的关系 , 而 ” . ” 运算符则用来表示已命名 子节点 之间的关系。
xml.bar[2].@type 表示xml对象第三个bar节点的type属性
要对属性值或节点进行测试的话 , 可以使用相等运算符 (==):
trace (xmlItems.item.(@id == "2").menuName);
使用正则表达式在 E4X中进行查询
xmlItems.item.(/\d\d\d/.test(@id)).price 进行验证
任何含有 3 位数字 id 属性的项目 , 将会返回一个该属性的价格值,关键在于()内返回的boolean值
使用 E4X 表达式 , 找出需要追加的 XMLList 对象所在的节点 , 然后在该节点上调用appendChild 方法。
这里所谓的xmlList对象就是不带根节点的xml,或者直接使用xml就可以了
var newXML:XML = <item id="4"/>
xmlNode.appendChild(newXML); 其中的xmlNode为原有的XML对象
要定义XmlList对象需要使用构造函数来创建xml数据源
new XMLList('<xx>dd</xx><xx>aa</xx>');
取出指定的节点使用var node:XMLList=xmlNode.item.(@id==3);
从数组生成xml对象的方法
var arr:Array = [1, 2, 3, 4, 5];
var xml:XML = new XML(<data></data>);
for (var i:int = 0; i<arr.length; i++) {
xml.appendChild(<id>{arr[i]}</id>);
}
要点就是通过循环访问数组下标来引用对象,使用xml.appendChild(xml)来新增到xml上
处理包含了命名控件的xml数据
private namespace w3c = "http://www.w3.org/2001/12/soap-envelope";
use namespace w3c;
通过 ” . ” 运算符可以存取任何使用限定命名空间的 XML 的 子节点 , 同时该命名空间 申明 时应
跟随着 ” :: ” 运算符及节点名义。 例如以下的 XML 对象 :
<m:PriceResult>
<m:Price>34.5</m:Price>
</m:PriceResult>
“ price ” 节点会通过以下的方法来存取 :
m::PriceResult.m::Price
要保持标签的完整性
将一个对象变成xml的方式, 这里用的是简单的Object对象
可以使用 SimpleXMLEncoder.encodeValue 方法把一 个对 象及 其属 性写 入到 一个XMLDocument 对象里。
encodeValue(obj:Object, qname:QName, parentNode:XMLNode):XMLNode
所生成的 XML 会由该方法返回 , 同时会附加到 parentNode 所在的 XMLDocument 对象内的
XMLNode 中 , 该方法会要求所有旧式 XMLDocument 所生成的 XML 附加到其中。
XMLDocument 生成以后 , 可以通过 XML 对象的构造函数 , 并将该文档当作参数传递到构造
函数中 , 由此转换成 XML 对象 :
var doc:XMLDocument =new XMLDocument( '<data></data>');
var xml:XML = new XML(doc);
private var o:Object = {name: "Josh" ,description_items:{height: '183cm' , weight: '77k' }};
doc = new XMLDocument( '<data></data>');
var simpleEncode:SimpleXMLEncoder =new SimpleXMLEncoder(doc);
var node:XMLNode = simpleEncode.encodeValue(o,new QName( 'http://localhost/ns/ws' , 'ls' ),doc.firstChild);
使用复杂的xml数据来填充组件
可以使用Tree和AdvancedDataGrid控件来显示数据,需要创建一个HierarchicalData对象,并将该xml传递给它,确保正确的定位数据
<mx:AdvancedDataGrid
dataProvider=" { new HierarchicalData(foodXML) } " width=" 100% " height=" 100% " >
将XML转换成自定义类型
通过使用限定命名空间及 SimpleXMLDecoder 类把 XML 译码成对象 , 然后使用
chemaTypeRegistry.registerClass 方法对类进行注册。
var qname:QName = new QName( "http://localhost/ns/ws","Plant" );
mx.rpc.xml.SchemaTypeRegistry.getInstance().registerClass(qname,Plant);
SchemaTypeRegistry.registerClass 可以让你注册一个类型为由 Web 服务所返回的类。这个类一定要在 WSDL 文件被描述
与浏览器通信
连接到外部 URL
使用 navigateToURL 方法将浏览器切换到新 URL 。
navigateToURL 方法让你可以在原窗口、新建窗口或者指定的窗口框架里切换到一个新URL 。这是 Flex 应用和浏览器通信中最 普遍 的一种 方式 。要在你的 Flex3 应用里调用navigateToURL 函数，使用下面的方法：
navigateToURL( new URLRequest( newUrl.text ),target.selectedItem as String );
第二个参数为_blank等 指定打开连接的方式
使用FlashVars
从容器HTML页面传递参数给Flex
<object>和 <embed> 标签来实现,也可以用Javascript进行加载使用
<object>内<param name="FlashVars" value="param1=one¶m2=2¶m3=3¶m4=four" />进行传递,也要在
<embed>或JavaScript内FlashVars="param1=one¶m2=2¶m3=3¶m4=four"
在 Flex 应用程序里，你可以随时使用 Application.application.parameters 对象来访问 FlashVars数据。
var parameters : Object = Application.application.parameters;
var param1 : String = parameters.param1;
默认的是字符串类型
Flex里面调用JavaScript的函数方法
在 AS 中使用 ExternalInterface 类调用 JavaScript 函数。
ExternalInterface.call( "simpleJSFunction" );
可以在调用 JavaScript 函数的同时传入参数：
ExternalInterface.call( "simpleJSFunctionWithParameters", "myParameter" );
可以用来获取返回值
var result:String = ExternalInterface.call( "simpleJSFunctionWithReturn" );
在JavaScript中调用ActionScript方法函数
使用 ExternalInterface 在 JavaScript 里设置对 Flex 的回调方法并且在 JavaScript 里调用ActionScript 方法。
在 JavaScript 调用 ActionScript 方法之前，你需要为开放给 JavaScript 调用 的 ActionScript 方
法注册一个回调函数。回调函数通过 ActionScript 的 ExternalInterface 类来注册。回调函数 为
JavaScript 方法提供一个对 ActionScript 方法的映射。
该例示范如何为ActionScript 方法函数注册回调方法。
private function registerCallbacks() : void
{
ExternalInterface.addCallback( "function1" , callback1 );
}
其中callback1为ActionScript内的函数,返回类型和参数随意
JavaScript中的调用方法
var swf="myswf"
var container=window//火狐下写法
var container=document//IE下写法
container[swf].function1(); 则调用第一个函数,可以直接在()内带参数传递
var result=container[swf].function1(); 用于接受返回值
使用BorwerManager类的实例与HTML的DOM进行交互
var bm : IBrowserManager = BrowserManager.getInstance();
bm.init();
bm.setTitle(newTitle) 用于修改浏览器的标题,不知道还有什么其他的方法,只能使用在URL和title之上
BrowserManager 和 URLUtil 类读取并解析当前页 URL
URL 会段为两个部分：基部 (base) 和片段 ( fragment ) 。 URL 基部 (base) 包含了 # 号左边
的所有内容。片段 (fragment) 则包含了 # 号右边所有的内容。片段 (fragment) 用以传递参数给
Flex 应 用 程 序 或 者 用 于 历 史 管 理 器,URL 片段 (fragment) 的每个键 - 值对都应该用分号 (;) 分隔开
http://localhost:8501/flex3cookbook/main.html#name=Andrew;index=12345;productId=987
var o:Object = URLUtil.stringToObject(bm.fragment); 进行解析
就可以使用o.name等方式进行访问
使用BrowerManager的实例进行更新URL
bm.setFragment( "firstName=" + firstName.text ";lastName=" + lastName.text );
在 Flex 中通过实现 mx.managers.IHistoryManagerClient 接口来实现自定义的历史记录管理器。
为了实现此解决办法，历史记录管理器必须对你的 Flex 项目 / 工程是激活的。为了验证， 我
们进入 Flex Project Properties 对话框，选择 Flex Compiler 项，并验证 Enable Integration wit h
Browser 复选框处于选中状态，这即表示你的历史记录管理器对你的 Flex 项目 / 工程是激活的。
可以使用浏览器的前进后退在这个TextInput控件的所有输入之间的来回切换,JavaScript应该也可以
"mx.managers.HistoryManager.register(this );" 用于注册控件开启功能
开发策略
配合Flash IDE使用
在 Flash CS3 IDE 中安装 Flex 组件工具包（ Flex Component Kit ）。然后创建一个元件，并使用
[ 转换成 Flex 组件 ] 命令把它转换成组件。最后把影片发布成 SWC ，添加到 Flex 项目中就可以了。
所有的 Flex 程序默认以每秒 24 帧的速度运行，发布后,生成的是一个swc,添加在flex应用程序库就可以
<local:Cloud height=" 200 " width=" 400 " /> 加入到程序中
如果需要扩展该组件,需要在Flash IDE里面扩展UIMovieClip创建一个类,保存成FLA,然后打开库中的这个影片剪辑的链接属性,
点击输入框后的验证标示,需要把类和FlA文件放在一起,提示找到后,设置好基类flash.display.MovieClip 。
可以在Flash IDE里面写上需要的函数,可以直接在组件里面进行调用
使用 Flex 组件工具包的 [ 元件转换成 Flex 容器 ] 的命令，或者更简单的，可以在 Flash IDE 中创
建一个扩展自 ContainerMovieClip 的类，然后在你的应用程序中导入一个包含那个类的 SWC 。
ContainerMovieClip 的实例可以拥有子项；响应点击，鼠标移动，及其他事件；定义视图状
态和过渡效果；像其他 Flex 组件一样使用各种效果。尽管在编译期或运行期只能往这样的 容器中添加 一个 子项，但是你可以添加一个 Flex 容器，这样就可以添加多个项了。
把元件转换成 MovieClipContainer 实例 后，接下来就可以放置这个 FlexContentHolder 了。它 决
定了 Flex 内容可以被添加到这个容器的哪个区域，它是 mx.flash.FlexContentHolder 类的实例 。
当向它里面添加内容时，内容显示在它指定的区域中。注意， FlexContentHolder 中只能添 加
一个子项，因此任何添加进来的子项都会自动填充它的整个区域。使用 Flash IDE ，你可以
调整 FlexContentHolder 的尺寸和位置.
要想添加多个组件,可以先添加一个容器,然后进行添加
使用Flash IDE中的控件
要在 Flash CS3 中生成 SWC 文件，首先你必须创建一个新的 Flash CS3 ActionScript3 的 FLA 文
件。把想要使用的组件拖到库里，选择文件 → 导出 → 导出影片，为 SWF 文件设置一个名称 ，
并选择要保存的文件夹。在导出 FlashPlayer 对话框里，勾选 [ 导出 SWC] ，然后点确定以确 保
设置生效。
当编译这个 FLA 文件时，会生成 2 个文件：一个 SWF 文件和一个 SWC 文件。这个 SWC 文件 很
有用，你可以把它添加到 Flex Builder 的应用程序的库路径中或者使用 mxmlc 时添加到编译 选
项 libary-path 中。
优化的技巧
1:多使用as 少用try..catch
2:稀疏数组访问起来比较慢，所以把空的项填上 null 会提高速度。
3:整数运算时候,会把整数转换成数字,加完再转换回来,因此当执行数学计算时,应该尽量使用数字,最后再转换成整数Number int
4:局部变量访问速度比较快
5:组件应该尽量使用延迟的实例化
6:数据绑定会消耗内存并减慢程序的启动时间
7:不用使用容器类作为List或DataGrid的itemRenderer,应该使用UIComponent
8:记得removeEventListener,便于垃圾回收
9:对色彩丰富的UIComponent或者包含位图数据的对象使用cacheASBitmap,不过缓存的位图数据缩放的时候可能会失真.
10:在DisplayObject对象添加到现实列表前调用setStyle的开支会小一些
模块(Modules)和运行时共享库(RSLs)
创建一个可以被下载和缓存的RSLs
使用自定义类，组件和其他资源创建一个库，编译为 SWC 文件，然后解压出 SWF 文件中的
library.swf 文件，引入到你的应用程序部署目录，作为一个 RSL 使用。
这是个简单的组件，允许用户输入信息和发出一个 submit 事件。要打包这个类为 SWC 文件。
你需要调用 compc 工具，设置 source-path 和 include-classes 参数，如下面的命令生成一个
CustomLibrary.swc ：
compc – source-path . –include-classes com.oreilly.flexcookbook.CustomEntryForm -output
CustomLibrary.swc
多个文件使用空格隔开
当编译应用程序时 SWC 文件作为动态链接，你可以根据需要重命名解压出来的 library 文件。在这个例子中，被命名为 CustomLibrary.swf 。
xmlns:flexcookbook=" com.oreilly.flexcookbook.* "
使用来自 RSL 中的类引用和 MXML 组件资源就像引用静态链接库和本地开发目录中的类文
件一样。在这个例子中在 <mx:Application> 标签中申明了 flexcookbook 名称空间，被用来添 加
CustomEntryForm 组件到显示列表中。
要编译使用了 RSL 的应用程序，调用 mxmlc 工具时要使用 external-library 和 runtime-shared
libraries 参数：
Code View:
> mxmlc – external-library=CustomLibrary.swc – runtime-shared-libraries=CustomLibrary.swf
RSLExample.mxml
使用跨域的 RSL,以便在不同域的应用程序都能访问到。
Compc 工具创建 RSL 时加上 compute-digest 参数后， RSL 摘要信息会在编译时期链接到 RSL 时
存储到应用程序中。然后创建跨域的授权文件引入 mxmlc 工具的 runtime-shared-library-paths
选项指定的 RSLs 位置。
下面的命令生成一个 SWC 文件命名为 CustomLibrary.swc ：
Code View:
> compc – source-path . – include-classes com.oreilly.flexcookbook.CustomEntryForm -output
CustomLibrary.swc – compute-digest=true
compute-digest 选项的默认值为 true ，当编译库时你不必引入它来创建摘要。当通过 MXML 编
译器的 runtime-shared-library-paths 选项链接跨域 RSLs 时才需要摘要。
跨域授权文件是一个 XML 文件，列举出可访问数据的已授权远程服务器。 要让其他应用程序 能
找到其他域中的 RSL ，在 crossdomain.xml 文件中用 <allow-access-from> 元素列举出域：
<?xml version="1.0"?>
<cross-domain-policy>
<allow-access-from domain="*.mydomain.com" />
<allow-access-from domain="*.myotherdomain.com" />
</cross-domain-policy>
上面的跨域授权文件允许任何来自 http://mydomain.com 和 http://myotherdomain.com 的
SWF 访问服务器数据，包括跨域 RSLs 。
要编译动态链接到上面生成的 CustomLibrary.swf 跨域 RSL 的应用程序，调用 mxmlc 工具， 使
用 runtime-shared-library-path 参数和目标服务器上的 RSL 完整 URL 路径和跨域授权文件：
> mxmlc RSLExample.mxml – runtime-shared-library-path=
CustomLibrary.swc,
http://www.mytargetdomain.com/libraries/CustomLibrary.swf,
http://www.mytargetdomain.com/libraries/crossdomain.xml
优化RSL
使用 optimizer 命令行工具删除 SWC 文件中的调试代码和不必要的元数据。
我们创建一个 MXML 组件，保存为 MyCustomComponent.mxml ：
使用下面的命令生成 SWC 文件并命名为 library.swc ：
Code View:
> compc – source-path . – include-classes MyCustomComponent -output library.swc
解压出 SWC 中的 library.swf 文件，这时的大小接近 320KB 。
使用 optimizer 工具通过删除没用的调试和元数据代码减小 RSL 的大小：
> optimizer – keep-as3-metadata=
"Bindable,Managed,ChangeEvent,NonCommittingChangeEvent,Transient"
– input library.swf – output optimized.swf
优化后的 RSL 只有原来一半还少，接近 135KB.
强烈建议你保留 Bindable, Managed, ChangeEvent, NonCommittingChangeEvent, 和 Transient
元数据名称标签，其他元数据如 RemoteClass, 可以添加到 RSL 库的类依赖项所基于的逗号分隔参数列表。
创建基于MXML的模块
使用<mx:module>表示一个模块
使用 mxmlc 工具编译这个例子：
> mxmlc ContactList.mxml
创建基于 ActionScript ActionScript ActionScript 的模块
创建一个继承自 mx.modules.Module 或 mx.modules.Modulebase 的 ActionScript 类，使用 mxmlc编译模块。
通过继承 Module 和 ModuleBase 类创建基于 ActionScript 的模块。
ModuleBase 类继承自 EventDispatcher ，可被用来分离应用程序逻辑代码使之不依赖于可视化元素。
Module 类是一个显示容器,可以放置视觉对象
编译方式和基于 MXML 的模块一样，同样是使用 mxmlc 工具：
> mxmlc ASContactList.as
使用 ModuleLoader ModuleLoader ModuleLoader 载入模块
ModuleLoader 和 SWFLoader 不同之处在于它 有一个 约 定 ，这个被载入的SWF须实现 IFlexModuleFactory 。被编译的模块包 含
IFlexModuleFactory 类工厂，它允许应用程序在运行期间动态载入模块化 SWF 而不需要在主应用程序中实现此接口。
虽然 ModuleLoader 对象是一个可视的容器， 可载入继承自 Module 和 ModuleBase 的模块，不
依赖于这个模块是否包含有框架代码或可视对象。 ModuleLoader 的 url 属性指向一个模块的 具
体位置。设置 url 属性后，组件内部会调用 loadModule 方法，开始下载模块。
ModuleLoader 组件也允许你动态卸载和加载模块。对 ModuleLoader 的 url 属性的设置在内部 会
调用 loadModule 方法，添加这个模块作为子节点。调用 unloadModule 方法可删除显示列表 中
的模块。调用 unloadModule 是设置 module 引用为 null ，但是并不会改变 url 属性值。
使用 ModuleManager 载入模块
ModuleManager 类 管 理 着 加 载 的 模 块 。 当 调 用 ModuleLoader.loadModule 和
ModuleLoader.unloadModule 方法时 <mx:ModuleLoader> 组件内部就是和这个管理器进行着
通 信 ， 你 可 以 直 接 访 问 ModuleManager 管 理 的 模 块 。 当 模 块 的 URL 传 递 给
ModuleManager.getModule 方法后，这个模块位置被添加到模块的管理列表中，返回一个
mx.modules.IModuleInfo 类实例。
模块实际上是 ModuleMananger 的私有 ModuleInfo 类实例。 ModuleInfo 对象加载 SWF 文件， 包
装为实现了 IModuleInfo 的代理类，并通过 ModuleManager.getModule 方法返回实例对象。你
可以监听这个代理的各种状态事件以便具体控制模块的加载。
var_moduleInfo:IModuleInfo;
_moduleInfo =ModuleManager.getModule('ContactList.swf' );
_moduleInfo.addEventListener( ModuleEvent.READY,moduleLoadHandler );
_moduleInfo.load();
用于开启加载,在加载事件中进行类型转换后,添加到界面中
private function moduleLoadHandler(evt:ModuleEvent): void
{
canvas.addChild( _moduleInfo.factory.create() as DisplayObject );
}
IModuleInfo 实现类的 unload 方法用于删除 ModuleManager 中的模块引用，但是不会删除显 示
列表中的 SWF 。要删除显示列表中的模块，你必须显示调用父对象的 removeChild 方法。
载入来自不同服务器的模块
使用 flash.system.Security 类在主应用程序 SWF 文件和模块文件之间建立信任机制。
要使模块和父swf交互,这个模块也需要调用allowDomain方法
为了让加载模块的 SWF 能与被加载模块进行跨脚本通信，你需要调用 Security.allowDomain
方法，参数为远程服务器域名，以载入 crossdomain.xml 文件，比如：
Security.allowDomain( "appserver" ); 子模块中设置
当模块被编译放到远程服务器 ( 这里的域名为 moduleserver) ，一个跨域授权文件被放到域名
的根目录，允许 appserver 的父 SWF 文件能加载模块：
<?xml version="1.0"?>
<cross-domain-policy>
<allow-access-from domain="appserver" to-ports="*" />
</cross-domain-policy>
父swf中设置
Security.allowDomain( "moduleserver" );
Security.loadPolicyFile( "http://moduleserver/crossdomain.xml" );
var loader:URLLoader = new URLLoader();
loader.addEventListener(Event.COMPLETE,loadHandler ) ;
loader.load( new URLRequest( "http://moduleserver/crossdomain.xml"));
主应用程序的初始化事件处理函数调用 SecurityDomain.allowDomain 方法建立与任何来自
moduleserver 服务器的资源的通信。应用程序也调用 Security.loadPolicyFile 方法， Flash Playe r
接收授权文件，确定 appserver 上的 SWF 是安全的。使用 URLLoader 加载跨域授权文件之前 必
须先调用 loadPolicyFile 方法，否则会抛出 security 异常。
在授权文件加载后,可以用于加载module组件
当使用 <mx:ModuleLoader> 对象时，可通过 child 属性获得模块实例：
myModule = moduleLoader.child asasas MyModule;
myModule.doSomething();
<mx:ModuleLoader> 的 child 属性类型重新映射为原模块类类型，现在你可以调用模块的公开方法访问其数据了。
而 当 使 用 ModuleManager 类 为 父 应 用 程 序 时 ， 模 块 实 例 是 通 过 IModuleInfo 的
IFlexModuleFactory 实例的 create 方法返回的：
var var var myModule:MyModule = _moduleInfo.factory.create() asasas
MyModule;
myModule.doSomething();
当 ModuleLoader 的 child 属性或 IFlexModuleFactory.create 方法返回值进行类型映射后，模块 和
主应用程序的联系分成紧密了，要想减少模块和它的类实例的紧密性，一般的做法是使用 接
口。使用接口，可 使 你的代码更具灵活性， 使你的主应用程序能连接更多的类实例。
一般来讲，模块是不应该访问父应用程序数据的，这是根据模块和 父应用程序 之间的松耦 合
设计原则决定的。为了减小这种联系，你可以把载入模块的应用程序映射为接口，就像上 面
的例子那样做。要确保不同的应用程序都能和同一个模块通信，强烈建议直接提供父应用 程
序数据给模块而不是通过动态 parentApplication 属性 . 做到了这些你就能轻松地开发模块化应
用程序了。
在模块 SWF 的 URL 里加上查询字符串，当模块加载完成后，使用模块的 loaderInfo 属性解析
URL 字符串。
你可以追加查询字符串参数给模块载入类的 URL 。当模块载入后，通过 mx.modules.Modul e
类的 loaderInfo 属性访问这个 URL 。使用 ActionScript ，你可以解析出有用 URL 中参数信息。
查询字符串紧跟在？号子后用 & 符号分割多个参数。
使用var query:String = loaderInfo.url.toString(); 进行字符串解析,进而获取到参数
使用连接报告优化模块
连接报告文件列出了主程序依赖的类，
当编译应用程序时使用 mxmlc 工具的 link-report 命令行参数生成一个连接报告文件，然后在 编
译模块时把报告文件作为 load-externs 命令行参数值，确保只有模块需要的类被编译进来。
报告文件。下面的命令生成连接报告文件 report.xml ：
>mxmlc -link-report=report.xml MyApplication.mxml
使用 link-externs 命令行参数值设置为刚才生成的连接报告文件
>mxmlc -link-externs=report.xml MyModule.mxml
要确保模块都是引用主程序中的同一个管理器，你需要在主程序中导入和申明一个类本地 变量：
import mx.managers.PopUpManager;
var popUpManager:PopUpManager;
用生成的连接报告文件去编译模块，确保模块都是使用同一个管理器引用，以减少代码冗 余和模块大小。
AIR部分
当开发基于 Web 的 Flex 程序时，主应用程序文件包含的根标签是<mx:Application> 。因为 AIR
程序使用本地操作系统窗体运行在桌面上，所以主应用程序文件的根标签是 <mx:WindowedApplication> 。
通过 Flex 3 SDK 的 bin 目录下的 amxmlc 命令行工具来编译 air 源程序。
打开和管理本地窗体
使用 flash.display.NativeWindow 和 mx.core.Window 类
要检测 AIR 程序运行在什么操作系统上，你可以使用
NativeWindow.supportsMenu //Windows stage.nativeWindow.menu = new NativeMenu(); 用于Windows下添加菜单
NativeApplication.supportsMenu //MAC OS： NativeApplication.nativeApplication.menu = new NativeMenu(); Mac下添加
添加菜单项的例子
var fileMenu:NativeMenuItem;
var fItem:NativeMenuItem =new NativeMenuItem( "File");
stage.nativeWindow.menu =new NativeMenu();
fileMenu = stage.nativeWindow.menu.addItem(fItem);
不同的平台下,添加菜单的方式有些不同,所以在添加前要先做判断
设置好根菜单后，接着就可以添加菜单或子菜单到 NativeMenu 对象上了。
fileMenu.submenu = createFileMenu(); 建立子菜单
private function createFileMenu():NativeMenu
NativeMenuItem 类还提供分割线支持，构造器默认的 isSeperator 参数值为 false ，如果设为 tru e
则会显示一条水平线：
var rule:NativeMenuItem = new NativeMenuItem( "Line", true );
你还可以在运行期间通过 NativeMenuItem 类的 enabled 属性启动和禁止菜单项：
var saveItem:NativeMenuItem = new NativeMenuItem( "Save" );
saveItem.enabled = false;
读写文件
文件系统上创建，访问和写文件
使用 AIR 的 file system API 的 File, FileStream, 和 FileMode 类。
用 FileStream 把 File 对象放入一个缓冲区，通过 FileStream 类的同步和异步方法读取和写入。
当使用的同步的 FileStream.open 方法时，文件被当作一个 ByteArray 对象，其他任何操作将 被
暂停直到文件被读取或写入。而异步的 FileStream.openAsync 方法类似于 URLStream 对象， 数
据被放置在缓冲区。使用同步还是异步方法这取决于你的程序需求，但是有点需要注意， 就
是所有操作完成后要记得关闭流。
当调用 FileStrema.open 和 FileStream.openAsync 方法时可通过 FileMode 类的字符串常量设定
文件的具体操作方式
为了读写文件，你需要把 File 对象指向一个用户电脑中的文件。 File 类有一些静态属性和方
法对应操作系统文件系统的标准目录以及应用程序目录和应用程序存储目录。
var file:File = File.desktopDirectory.resolvePath( "test.txt" );
var stream:FileStream = new FileStream();
stream.open( file, FileMode.WRITE );
stream.writeUTFBytes("..... World" );
stream.close();
要读取文件数据，可使用 FileStream.readUTFBytes 方法：
stream.readUTFBytes( stream.bytesAvailable )
如果使用 FileMode.WRITE 参数将会覆盖任何其他数据，要检测是否已经有文件存在，可使用 File 类的 exists 属性：
file.exists 返回个boolean值
包括了应用程序目录和应用程序存储目录,其中程序目录只读,存储目录可以读写
使用 AIR 文件系统 API ，你可以把经过 AMF 编码序列化过的对象写入文件流缓冲区中。
要启动自定义对象序列化支持，你需要用 registerClassAlias 方法用一 个类别名注册此类，或者在类定义前申明这个 [RemoteClass] 元数据标签。
你也可以在变量定义前加上 [Transient] 元数据标签，指示此变量不会被序列化。
FileStream.objectEncoding 属性，你可以使用 AMF 0 格式
添加自定义的文件过滤器
var filter:FileFilter =FileFilter( ""User File" , "*.user" );
file.browseForOpen( "Open "Open "Open User" User" User" , [filter] );
使用加密的本地存储区
使用 Windows 的 Data Protection API (DPAPI) 和 Mac OS X 的密匙链 for AIR applications on
Windows and Keychain for those on Mac OS X, 数据被加密且只有在相同的安全沙箱中可用，
加密本地存储区最大空间为 10MB 。
通过 flash.data.EncryptedLocalStore 类的静态方法访问加密的本地存储区其中包括了setItem()和getItem的方法
其中保留的对象都是被转换成ByteArray的对象
var bytes:ByteArray = new ByteArray();
bytes.writeObject(userData);
EncryptedLocalStore.setItem( "user" ,bytes);
读取的时候
var user:ByteArray =
EncryptedLocalStore.getItem( "user" );
userData = user.readObject() as UserData;
注意需要对自定类注册,那样才可以进行序列化,ByteArray的操作,类似于Java的DataInput
浏览本地文件,使用flash.filesystem.File 类的 browse 开头的那些方法。
File 类提供了一个对话框窗口用于打开一个或多个文件。使用 File.browseForOpen 方法选择 一
个文件时 select 事件被触发，使用 File.browseForOpenMultiple 方法选择多个文件时selecteMutiple 事件被触发。
file.browseForOpen( "Open File", [filter] );
其中第二个参数为过滤器,用于选择指定扩展名的文件
var filter:FileFilter = new new new FileFilter("*.Text" ,"*.html");
加载浏览的文件内容,一般在File的Event.SELECT事件中进行打开操作
var stream:FileStream =new FileStream();
stream.open( file, FileMode.READ );
File.browseForOpenMultiple 方法打开的对话框可以一次选择多个文件
file.browseForOpenMultiple( "Open File" , [filter] );
注意打开多个文件的事件变成为FileListEvent.SELECT_MULTIPLE,在监听函数中,使用参数类型FileListEvent
处理结果方法为:从事件中获取到文件列表数组,然后进行类型转换
var files:Array = evt.files;
for (var i:int = 0; i < files.length; i++ )
{
trace ( ( files[i] as File ).name +"\n" );
}
同样File类也支持保存对话框
file = File.desktopDirectory;
file.browseForSave("Save As" );
同样是进行监听Event.SELECT,然后在事件函数中使用如下处理
var stream:FileStream =new FileStream();
stream.open(evt.target as File, FileMode.WRITE);
stream.writeUTFBytes("Hello World.");
stream.close();
Browse系列方法适合不同的操作系统
使用AIR API提供的控件浏览电脑文件系统
使用 FileSystemComboBox 和 FileSystemList 组件浏览和显示计算机文件系统,这些控件的数据内容由directory决定
<mx:FileSystemComboBox id="fileCB" directory=" { fileList.directory } "
directoryChange="changeHandler(event);" />
<mx:FileSystemList id="fileList" directory=" { fileCB.directory } " />
在初始化时,使用fileCB.directory = File.documentsDirectory; 进行初始化设置
触发的事件changgeHandler(e:FileEvent)使用如下处理
trace (e.file.nativePath);
除了可显示隐藏文件和特定扩展名文件外， FileSystemList 类还有些属性用于浏览历史记录 ，
你可以使用 FileSystemHistoryButton 类启动历史记录导航功能。
<mx:FileSystemHistoryButton label=" Back " dataProvider=" { fileList.backHistory } "
enabled=" { fileList.canNavigateBack } " click="fileList.navigateBack();"
itemClick="fileList.navigateBack(event.index)" />
这里的event.index比较奇怪的用法
要通过 FileSystemTree 控件显示文件系统层级关系,FileSystemTree 类可以指示是否显
示隐藏文件以及特定扩展名的文件。 File 对象只表示目录，还有其他过滤选项以及如何自定义
使用 FileSystemTree 类显示文件系统根目录：
<mx:FileSystemTree id="fileTree" width="100%" height="100%" directory="{ FileSystemTree.COMPUTER } "/>
如果要显示完成文件信息
<mx:FileSystemDataGrid id="fileGrid" width="100%" height="100%" directory=" { File.desktopDirectory } " />
也需要用 FileSystemHistoryButton类控制返回操作
注意Air并不会对文件的变化自动通知,就是并不知道什么时候被进行删除后刷新, 对文件操作前,需要调用refresh方法
使用本地拖拽.用到了剪切板和NativeDragManager类进行管理拖拽
涉及到的记录点:
addEventListener( NativeDragEvent.NATIVE_DRAG_ENTER,dragEnterHandler );
addEventListener( NativeDragEvent.NATIVE_DRAG_DROP,dragDropHandler );
判断是否拥有该内容
if (evt.clipboard.hasFormat( ClipboardFormats.FILE_LIST_FORMAT ) )
NativeDragManager.acceptDragDrop(this );
事件全局左边和局部坐标的转换
var pt:Point = globalToLocal( new Point( evt.localX,evt.localY ));
xposition = pt.x;
yposition = pt.y;
获取数据,并进行数据的加载使用Loader
var files:Array = evt.clipboard.getData(ClipboardFormats.FILE_LIST_FORMAT ) as Array;
loader = new Loader();
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, completeHandler );
loader.load(new URLRequest( files[0].url ) );
在加载完成的事件函数中转换成图片
var bmp:Bitmap = loader.content asasas Bitmap;
var image:Image = new Image();
image.source = bmp;
image.x = xposition;
image.y = yposition;
addChild( image );
与操作系统剪贴板交互,使用Clipboard的静态generalClipboard属性
AIR 程序支持的数据交换格式有：位图数据标准文本数据,HTML,和 URL 格式。自定义数据只能在支持的Air程序中可用
新增数据
Clipboard.generalClipboard.setData(ClipboardFormats.TEXT_FORMAT,textField.text );
清空数据
Clipboard.generalClipboard.clear();
获取数据,注意先判断对象是否存在
if ( Clipboard.generalClipboard.hasFormat(
ClipboardFormats.TEXT_FORMAT ) )
{
textField.text =
Clipboard.generalClipboard.getData(ClipboardFormats.TEXT_FORMAT)as String;
}
类似集合的操作getData和setData,以及clear方法
在Air中显示HTML内容,渲染引擎是基于WebKit技术构建
通过location属性值,将HTML页面载入到<mx:HTML>控件
<mx:HTML id="html" width=" 100% " height=" 100% " location=" { urlLocation } "/>
其中的var urlLocation:String = "http://www.adobe.com";
HTMLLoader实例也是在内部进行对浏览历史进行管理,调用id.historyBack()等方法进行操作
除了这两个方法外，你还可以访问历史记录数多少,以及当前所处的位置,以及用 historyGo 方法直接载入指定的历史记录.
ActionScript和JavaScript的交互:监听complete事件,使用<mx:HTML>控件的domWindow属性进行访问HTML DOM
这种 在 JavaScript 和 ActionScript 直接的调用叫跨脚本
通过 <mx:HTML> 控件的 domWindow 属性可以访问 HTML 文档的全局 JavaScript 对象。
var p1:String=html.domWindow.document.getElementById( 'helloField').innerHTML;
其中html为组件id 另外个'内容'为html中元素的id,注意需要在complete完成后
修改样式的方法之一:
var styleSheets:Object = html.domWindow.document.styleSheets;
trace( styleSheets[0].cssRules[0].style.fontSize );
将访问样式表的第一个样式标签的字体大小
在<style>标签下名字为#helloField的样式属性
JavaScript函数与ActionScript函数之间的调用
html.domWindow.sayHello(), 用于在ActionScript里面直接调用JavaScript的function
html里面调用ActionScript的方法,需要涉及到回调函数的方式,需要先在ActionScript里面建立个桥接
html.domWindow.handleAgeChange = ageHandler;
然后在JavaScript里面直接调用handleAgeChange(参数); 参数的类型为Object
使用本地SQL SqlLite
Flash. dataSQLConnection 类的 open 和 openAsync 方法建立一个数据库连接.如果你没有传递一个File引用给
open和openAsync方法,则将会在内存中创建一个数据库,并允许执行SQL语句.
用于打开数据库,如果不存在,则新建一个文件
var db:File =File.applicationStorageDirectory.resolvePath( "Authors.db" );
var sqlConn:SQLConnection =new SQLConnection();
sqlConn.addEventListener( SQLEvent.OPEN, openHandler );
sqlConn.addEventListener( SQLErrorEvent.ERROR, errorHandler );
sqlConn.openAsync( db );
要执行 SQL 语句，先赋值申明的 SQL 字符串值传递给 SQLStatement 的 text 属性并调用 execute方法
创建一张新表格 使用CREATE TABLE IF NOT EXISTS authors(列名,类型,属性(NOT NULL等)); 其中authors为表名
var statement:SQLStatement =new SQLStatement();
statement.sqlConnection = sqlConn;
statement.text = sql;
statement.addEventListener( SQLEvent.RESULT, resultHandler );
statement.addEventListener(SQLErrorEvent.ERROR,errorHandler );
statement.execute();
这样就可以正常的创建一张表,。因为这里使用的是异步的 openAsync 方法，这样在执行异步方法时，其他操作也会继续被执行，不会被阻塞。
为了简化和增强执行查询的性能,SQLStatement 类提供了一个 parameters 属性和 itemClass属性。
:firstName,方式写在SQL的text中
insertQuery.parameters[ ":firstName" "] = fName; 用于赋值
其中insertQuery:SQLStatement = new new new SQLStatement();
当语句被执行前，这些值被替换，你可以在属性名前使用:或@ 符号,也可以是数字索引作为属性名,SQL 语句里用?取代：
insertQuery.parameters[1] = lName;
使用itemClass将数据对象与表进行映射
var selectQuery:SQLStatement = new SQLStatement();
var sql:String="SELECT authorId,firstName,lastName FROM authors"
selectQuery.itemClass = Author;
访问查询的结果
var authors:Array = selectQuery.getResult().data;
使用for循环进行遍历就可以, var author:Author = authors[i] as Author;
数组中的每个元素被映射为Author 对象，因为 Author 类已提供给 itemClass 属性
检测和监控网络连接
你可以监听 NativeApplication 实例发出的 networkChange 事件判断网络连接是否改变。当连接可用或不可用时触发该事件，
事件本身并没有很多关于连接的相关信息。因此，你需要使用事件处理器检测应用程序可工作在请求服务模式。
该事件并不有用判断的能力,只是在变化时候触发事件
用 SocketMonitor 和 URLMonitor 类检测所需服务是否可用。
例子:通过HTTP头检测web站点是否可用
var req:URLRequest = new URLRequest("http://www.adobe.com" );
req.method = URLRequestMethod.HEAD;
monitor = new URLMonitor( req );
monitor.pollInterval = 30000;
monitor.addEventListener( StatusEvent.STATUS, statusHandler );
monitor.start();
其中pollInterval单位为毫秒,将会每30秒调用一次查询
使用 SocketMonitor 实例检测 socket 连接和检测 HTTP 是类似的，只不过需要主机和端口参数 ：
socketMonitor =new SocketMonitor( "www.adobe.com" , 1025 );
socketMonitor.addEventListener(StatusEvent.STATUS,statusHandler ) ;
socketMonitor.start();
检查用户是否在线
检测用户在线的原理是基于键盘和鼠标的活动状态，离线是指键盘和鼠标在一段时间内不 处
于活动状态。你可以设置一个时间期限判断用户是否在线。
设置 NativeApplication 的 idleThreshold 属性，监听 userIdle 和 userPresent 事件。
NativeApplication.nativeApplication.idleThreshold =10;
NativeApplication.nativeApplication.addEventListener(Event.USER_IDLE, idleHandler );
NativeApplication.nativeApplication.addEventListener(Event.USER_PRESENT, presenceHandler );
其中Event.USER_IDLE为用于10秒超时后触发
Event.USER_PRESENT为用户返回后触发
创建系统托盘图标:即应用程序在后台运行,不需要主界面
在 <mx:WindowedApplication> 根标签和描述文件里设置应用程序的可见性为 false,使用
DockIcon 和 SystemTrayIcon 类，添加自定义程序图标。
DockIcon 类是运行在 Mac OS X 系统下而 SystemTrayIcon类是在 Windows下,要检测哪一个图标被操作系统所支持，
你可以使用 NativeApplication 类 的supportsDockIcon 和 supportsSystemTrayIcon 属性。
var shellMenu:NativeMenu = createShellMenu();
var icon:InteractiveIcon =NativeApplication.nativeApplication.icon;
if ( NativeApplication.supportsDockIcon )
{
( icon as DockIcon ).menu = shellMenu;
}
else
{
( icon as SystemTrayIcon ).menu = shellMenu;
( icon as SystemTrayIcon ).tooltip = "My App";
}
var bitmaps:Array = [new icon16(),new icon32(),new icon48(), new icon128()];
icon.bitmaps = bitmaps;
关键在于最后的两个添加操作,其中icon对象都是使用Embed进来的图片
隐藏主界面的关键在于<mx:WindowedApplication> 根标签的 visible 属性被设置为false,同样在描述文件设置visible属性
FlexUnit单元测试
使用FlexUnit框架类为应用程序创建测试,加载flexunit.swc文件
运行FlexUnit单元测试
使用TestSuite实例和TestRunnerBase组件运行测试
TestRunnerBase 是默认的包含 FlexUnit 框架的图形化测试运行器。想要用 TestRunnerBase 测试创建的应用程序，
编辑 MXML 文件，加入如下内容：
<mx:Application xmlns:mx=" http://www.adobe.com/2006/mxml "
xmlns:flexui=" flexunit.flexui.* " >
<flexui:TestRunnerBase id=" testRunner " width=" 100% "
height=" 100% " />
</mx:Application>
在Script中加入TestSuite实例
var testSuite:TestSuite =new TestSuite();
再把 TestSuite 实例赋值给 TestRunnerBase 实例：
testRunner.test = createTestSuite();
testRunner.startTest();
创建的过程,定义一个<mx:TestRunnerBase>
然后在Application创建完成后,调用函数,testRunner.test=一个TestSuite的实例,调用startTest()开始测试
创建完整的测试用例(TestCase)
创建 TestCase 子类，包含一个或多个以 test 开头的方法,而测试的类名命名为Test结尾
FlexUnit包含一系列断言类型用于不同的测试情形,常见的断言和函数如下
assertEquals 比较 ==.
assertTrue 检测条件是否为 true.
assertNull 检测条件是否为 null.
assertStrictlyEquals 比较 ===.
当一个断言失败,剩下的测试方法将不被执行.
断言的两个参数中,第一个表示错误的提示信息(可选),第二个为方法的调用主体.
添加测试用例到测试集中
var testSuite:TestSuite =new TestSuite();
testSuite.addTestSuite(RegExpTest);
记得保证类已经被正确导入
使用 addTestSuite 方法将测试用例添加到测试集合中，该方法接受一个 TestCase 类引用作为 参
数。在后台 FlexUnit 使用反射找到所有以 test 开头的方法并执行它们。
在测试前后运行代码,和Junit一样
override重写TestCase类的setUp和tearDown方法
无论断言是否失败或者异常,这2个方法都会执行
测试用例之间共享测试数据
创建能生成所需测试数据实例的工厂类。
处理测试用例事件
flexUnit默认对异步事件采取的是直接认为通过的方法,这样可能导致大量的问题不被发现
需要先通知 FlexUnit 应该等待触发的事件完成后再决定一个测试是通过还是失败，传递给addEventListener 的监听器必须替换为 addAsync ， addAsync 的前两个参数时必须的，
第一个是监听器,当事件发生时调用,第二个是以毫秒的超时时间
例子
urlLoader.addEventListener(Event.COMPLETE,addAsync(verifyParse, 1000));
关键在于替换掉原来的函数监听,应该只能用在TestCase子类里面
在测试期间,不过多次调用addAsync, 该方法的第三个参数为传递给事件函数的参数,第四个参数为超时后调用的函数
串联事件: 是指将另外个函数的监听放在第一个函数的回调方法内...这样就可以依照持续执行
使用FlexUnit测试可视化组件
注意:在组件中访问主程序的方法,使用Application.application;
自动构建和测试Flex应用程序,使用Antennae模板
编译和调试Flex
把一个 Flex 组件编译到 SWC 文件中，以便用于运行时共享库（ RSL ）
使用下面的语法调用组件编译器 compc ：
代码：
->compc -source-path . -include-classes oreilly.cookbook.foo -output example.swc
使用 Flex 3 SDK 中的 Flex Ant
拷贝 flex_ant/lib/flexTasks.jar 到 Ant 的库目录 ({ANT_root}/lib) 。
Flex Profiler在运行时查看FlashPlayer内存中的所有对象
通过一个本地的的Socket连接到应用程序,注意防火墙
浙公网安备 33010602011771号