以下是小编帮大家整理的ActionScript术语(共含9篇），供大家参考借鉴，希望可以帮助到您。同时，但愿您也能像本文投稿人“情人”一样，积极向本站投稿分享好文章。
象任何脚本语言一样，ActionScript也根据其特定的语法规则，使用专门的术语，本讲按字母顺序列出一些重要的ActionScript术语，并作简要介绍。这些术语以及管理它们的语法将在后续章节中作详细讨论。
1.Actions
Actions（动作）是指令一个动画在播放时做某些事情的一些语句。例如，gotoAndStop把播放头送到指定的帧或标签。请读者注意，在本教程中，动作和语句这两个术语常常交换使用。
2.Arguments
Arguments（参数），称为参数，通过它可以把值传递给函数。例如，下面的函数（welcome）使用两个值，由参数firstName和hobby接收：
function welcome(firstName, hobby) { welcomeText = “Hello, ” + firstName + “I see you enjoy ” + hobby;}
3.Classes
Classes（类）是可以创建的数据类型，用以定义新的对象类型，
要定义对象的类，需要创建一个构造函数。
4.Constants
Constants（常数）是不能改变的元素。例如，常数TAB总是具有相同的意思。常数在比较值时很有用。
5.Constructors
Constructors（结构体）是用来定义类的属性和方法的函数。例如，以下代码通过创建称为Circle的构造函数来创建一个新的圆类：
function Circle(x, y, radius){ this.x = x; this.y = y; this.radius = radius;}
一、动作
动作部分的Action是用来控制影片播放状态的脚本集合，以利于Flash脚本编写人员速查。
(一)影片控制
1.goto
语法：gotoAndPlay(scene, frame)
参数：scene 播放头将转到场景的名称。frame 播放头将转到的帧的编号或标签。
描述：动作；将播放头转到场景中指定的帧并从该帧开始播放。如果未指定场景，则播放头将转到当前场景中的指定帧。
2.on
语法：on(mouseEvent) {statement(s);}
参数： statement(s)是指发生mouseEvent时要执行的指令。
mouseEvent是“事件”触发器。当发生此事件时，执行事件后面花括号中的语句。可为mouseEvent参数指定下面的任何值：
press在鼠标指针经过按钮时按下鼠标；release在鼠标指针经过按钮时释放鼠标按钮；releaseOutside当鼠标指针在按钮之内时按下按钮后，将鼠标指针移到按钮之外，此时释放鼠标；rollOut鼠标指针移出按钮区域；rollOver；鼠标指针滑过按钮；dragOut在鼠标指针滑过按钮时按下鼠标，然后滑出此按钮区域；dragOver在鼠标指针移过按钮时按下鼠标，然后移出此按钮，再移回此按钮；keyPress(key)按下指定的key。此参数的key部分可使用Flash“键盘键和键控代码值”中所列的任何键控代码进行指定，或者使用Key对象的属性摘要中列出的任何键常量进行指定。
描述：事件处理函数；指定触发动作的鼠标事件或按键事件。
3.play
语法：play
描述：动作；在时间轴中向前移动播放头。
4.stop
语法：stop
描述：动作；停止当前正在播放的影片。此动作最通常的用法是用按钮控制影片剪辑。
5.stopAllSounds
语法：stopAllSounds()
描述：动作；在不停止播放头的情况下停止影片中当前正在播放的所有声音。设置到流的声音在播放头移过它们所在的帧时将恢复播放。
(二)浏览器/网络
该部分的Action是Flash MX用来与影片或外部文件进行交互操作的脚本集合。
1.fsCommand
语法：fscommand(″command″, ″parameters″)
参数：command。parameters均是一个传递给宿主应用程序用于任何用途的字符串；或者一个传递给Flash Player的值。
描述：动作；使Flash影片能够与Flash Player或承载Flash Player的程序(如Web浏览器)进行通讯。还可使用fsCommand动作将消息传递给Director，或者传递给VB、VC++和其他可承载ActiveX控件的程序。
2.getURL
语法：getURL(url [, window [, ″variables″]])
参数：url可从该处获取文档的URL。
window一个可选参数，指定文档应加载到其中的窗口或HTML框架。你可输入特定窗口的名称，或从下面的保留目标名称中选择：_self指定当前窗口中的当前框架；_blank指定一个新窗口；_parent指定当前框架的父级；_top指定当前窗口中的顶级框架；variables用于发送变量的GET或POST方法。如果没有变量，则省略此参数。GET方法将变量追加到URL的末尾，该方法用于发送少量变量。POST方法在单独的HTTP 标头中发送变量，该方法用于发送长的变量字符串。
描述：动作；将来自特定URL的文档加载到窗口中，或将变量传递到位于所定义URL的另一个应用程序。若要测试此动作，请确保要加载的文件位于指定的位置。若要使用绝对URL，则需要网络连接。
3.loadMovie
语法：loadMovie(″url″,level/target[, variables])
参数：url要加载的SWF文件或JPEG文件的绝对或相对URL。
target指向目标影片剪辑的路径。目标影片剪辑将替换为加载的影片或图像。只能指定target影片剪辑或目标影片的level这两者之一。
level一个整数，指定Flash Player中影片将被加载到的级别。在将影片或图像加载到级别时，标准模式下“动作”面板中的loadMovie动作将切换为loadMovieNum；在专家模式下，必须指定loadMovieNum或从“动作”工具箱中选择它。
variables一个可选参数，指定发送变量所使用的HTTP方法。该参数须是字符串GET或POST。
描述：动作；在播放原始影片的同时将SWF或JPEG文件加载到Flash Player中。loadMovie动作使你可以同时显示几个影片，并且无需加载另一个HTML文档就可在影片之间切换。
使用unloadMovie动作可删除使用loadMovie动作加载的影片。
4.loadVariables
语法：loadVariables (″url″ ,level/″target″[, variables])
参数：url变量所处位置的绝对或相对URL。
level指定Flash Player中接收这些变量的级别的整数。参数具体用法同loadmovie。
target指向接收所加载变量的影片剪辑的目标路径。
variables一个可选参数，指定发送变量所使用的HTTP方法。
描述：动作；从外部文件(例如文本文件，或由CGI脚本、ASP、PHP脚本生成的文本)读取数据，并设置Flash Player 级别或目标影片剪辑中变量的值。此动作还可用于使用新值更新活动影片中的变量。
5.unloadMovie
语法：unloadMovie[Num](level/″target″)
参数：level加载影片的级别(_levelN)。从一个级别卸载影片时，在标准模式下，“动作”面板中的 unloadMovie动作切换为unloadMovieNum；在专家模式下，必须指定unloadMovieNum，或者从“动作”工具箱中选择它。
target影片剪辑的目标路径。
描述：动作；从Flash Player中删除一个已加载的影片或影片剪辑。
(三)影片编辑控制
1.duplicateMovieclip
语法：duplicateMovieClip(target, newname,depth)
参数：target要复制的影片剪辑的目标路径。
newname复制的影片剪辑的唯一标识符。
depth复制的影片剪辑的唯一深度级别。深度级别是复制的影片剪辑的堆叠顺序。这种堆叠顺序很像时间轴中图层的堆叠顺序；较低深度级别的影片剪辑隐藏在较高堆叠顺序的剪辑之下。必须为每个复制的影片剪辑分配一个唯一的深度级别，以防止它替换现有深度上的影片。
描述：动作；当影片正在播放时，创建一个影片剪辑的实例。无论播放头在原始影片剪辑(或“父级”)中处于什么位置，复制的影片剪辑的播放头始终从第一帧开始。如果删除父影片剪辑，则复制的影片剪辑也被删除。
2.onClipEvent
语法：onClipEvent(movieEvent){
statement(s);
}
参数：movieEvent是一个称作“事件”的触发器。当事件发生时，执行该事件后面花括号中的语句。可以为movieEvent参数指定下面的任何值：load影片剪辑一旦被实例化并出现在时间轴中时，即启动此动作。；unload在从时间轴中删除影片剪辑之后，此动作在第一帧中启动。处理与Unload影片剪辑事件关联的动作之前，不向受影响的帧附加任何动作；enterFrame以影片帧频不断地触发此动作。首先处理与enterFrame 剪辑事件关联的动作，然后才处理附加到受影响帧的所有帧动作脚本；mouseMove每次移动鼠标时启动此动作。_xmouse和_ymouse属性用于确定当前鼠标位置；mouseDown当按下鼠标左键时启动此动作；mouseUp当释放鼠标左键时启动此动作；keyDown当按下某个键时启动此动作。使用Key.getCode方法获取最近按下的键的有关信息；keyUp当释放某个键时启动此动作。使用Key.getCode方法获取最近按下的键的有关信息；data当在loadVariables或loadMovie动作中接收数据时启动此动作。当与loadVariables动作一起指定时，data事件只发生一次，即加载最后一个变量时。当与loadMovie动作一起指定时，获取数据的每一部分时，data事件都重复发生。
statement(s)发生mouseEvent时要执行的指令。
描述：事件处理函数；触发为特定影片剪辑实例定义的动作。
3.removeMovieClip
语法：removeMovieClip(target)
参数：target用duplicateMovieClip创建的影片剪辑实例的目标路径，或者用MovieClip对象的 attachMovie或duplicateMovieClip方法创建的影片剪辑的实例名。
描述：动作；删除用MovieClip对象的attachMovie或duplicateMovieClip方法创建的，或者用 duplicateMovieClip动作创建的影片剪辑实例。
4.setProperty
语法：setProperty(″target″,property,value/expression)
参数：target到要设置其属性的影片剪辑实例名称的路径。
property要设置的属性。
value属性的新文本值。
expression计算结果为属性新值的公式。
描述：动作；当影片播放时，更改影片剪辑的属性值。
5.startDrag
语法：startDrag(target,[lock ,left ,top ,right,bottom])
参数：target要拖动的影片剪辑的目标路径。
lock一个布尔值，指定可拖动影片剪辑是锁定到鼠标位置中央(true)，还是锁定到用户首次点击该影片剪辑的位置上(false)。此参数是可选的。
left、top、right、bottom相对于影片剪辑父级坐标的值，这些坐标指定该影片剪辑的约束矩形。这些参数是可选的。
描述：动作；使target影片剪辑在影片播放过程中可拖动。一次只能拖动一个影片剪辑。执行startDrag动作后，影片剪辑将保持可拖动状态，直到被stopDrag动作明确停止为止，或者直到为其他影片剪辑调用了 startDrag动作为止。
6.stopDrag
语法：stopDrag()
描述：动作；停止当前的拖动操作。
7.updateAfterEvent
语法：updateAfterEvent()
描述：动作；当在onClipEvent处理函数中调用它时，或作为传递给setInterval的函数或方法的一部分进行调用时，该动作更新显示(与为影片设置的每秒帧数无关)。如果对updateAfterEvent的调用不在 onClipEvent处理函数中，也不是传递给setInterval的函数或方法的一部分，则Flash忽略该调用。
(四)变量
该部分Action是Flash MX脚本语言中的变量及对应操作的脚本集合。
1.delete
语法：delete reference
参数：reference要消除的变量或对象的名称。
描述：运算符；销毁由reference参数指定的对象或变量，如果该对象被成功删除，则返回true；否则返回false值。
2.set variable
语法：set(variable,expression)
参数：variable保存expression参数值的标识符；expression分配给变量的值。
描述：动作；为变量赋值。variable是保存数据的容器。变量可以保存任何类型的数据(例如，字符串、数字、布尔值、对象或影片剪辑)。每个影片和影片剪辑的时间轴都有其自己的变量集，每个变量又都有其自己独立于其他时间轴上的变量的值。
3.var
语法：var variableName1 [= value1][...,variableNameN [=valueN]]
参数：variableName标识符；value分配给变量的值。
描述：动作；用于声明局部变量。如果在函数内声明局部变量，那么变量就是为该函数定义的，且在该函数调用结束时到期。如果变量不是在块({})内声明的，但使用call动作执行该动作列表，则该变量为局部变量，且在当前列表结束时到期。如果变量不是在块中声明的，且不使用call动作执行当前动作列表，则这些变量不是局部变量。
4.with
语法：with (object) {
statement(s);
}
参数：object动作脚本对象或影片剪辑的实例；statement(s)花括号中包含的动作或一组动作。
描述：动作；允许你使用object参数指定一个对象(比如影片剪辑)，并使用statement(s)参数计算对象中的表达式和动作。这可以使你不必重复书写对象的名称或路径。
(五)条件/循环
该部分Action是Flash MX脚本中如何操作影片逻辑的脚本集合。
1.break
语法：break
描述：动作；出现在一个循环(for、for..in、do while或while 循环)中，或者出现在与switch动作内特定case语句相关联的语句块中。break动作可命令Flash跳过循环体的其余部分，停止循环动作，并执行循环语句之后的语句。当使用break动作时，Flash解释程序会跳过该case块中的其余语句，转到包含它的 switch动作后的第一个语句。使用break动作可跳出一系列嵌套的循环。
2.case
语法：case expression: statements
参数：expression任何表达式；statements任何语句。
描述：关键字；定义用于switch动作的条件。如果case关键字后的expression参数在使用全等(===)的情况下等于switch动作的expression参数，则执行statements参数中的语句。如果在switch语句外部使用case动作，则将产生错误，脚本不能编译。
3.continue
语法：continue
描述：动作；出现在几种类型的循环语句中；它在每种类型的循环中的行为方式各不相同。
在while循环中，continue可使Flash解释程序跳过循环体的其余部分，并转到循环的顶端(在该处进行条件测试)。在do while循环中，continue可使Flash解释程序跳过循环体的其余部分，并转到循环的底端(在该处进行条件测试)。在for循环中，continue可使Flash解释程序跳过循环体的其余部分，并转而计算for循环的后表达式(post-expression)。在for..in循环中，continue可使Flash解释程序跳过循环体的其余部分，并跳回循环的顶端(在该处处理下一个枚举值)。
4.Default
语法：default: statements
参数：statements任何语句。
描述：关键字；定义switch动作的默认情况。对于一个给定的switch动作，如果该switch动作的 Expression参数与case关键字后面的任何一个Expression参数都不相等(使用全等)，则执行这些语句。
5.do while
语法：do {
statement(s)
} while (condition)
参数：condition要计算的条件。
statement(s)只要condition参数计算结果为true就会执行的语句。
描述：动作；执行语句，然后只要条件为true，就计算循环中的条件。
6.else
语法：else statement
else {...statement(s)...}
参数：ondition计算结果为true或false的表达式。
statement(s)如果if语句中指定的条件为false，则运行的替代语句系列。
描述：动作；指定当if语句中的条件返回false时要运行的语句。
7.else if
语法：if (condition){
statement(s);
} else if (condition){
statement(s);
}
参数：condition计算结果为true或false的表达式。
statement(s)如果if语句中指定的条件为false，则运行的替代语句系列。
描述：动作；计算条件，并指定当初始if语句中的条件返回false时要运行的语句。如果else if条件返回true，则Flash解释程序运行该条件后面花括号({})中的语句。如果else if条件为false，则Flash跳过花括号中的语句，运行花括号之后的语句。在脚本中可以使用else if动作创建分支逻辑。
8.for
语法：for(init; condition; next) {
statement(s);
}
参数：init一个在开始循环序列前要计算的表达式，通常为赋值表达式。此参数还允许使用Var语句。
condition计算结果为true或false的表达式。在每次循环迭代前计算该条件；当条件的计算结果为false时退出循环。
next一个在每次循环迭代后要计算的表达式；通常为使用递增或递减运算符的赋值表达式。
statement(s)在循环体内要执行的指令。
描述：动作；一种循环结构，首先计算init(初始化)表达式一次，只要condition的计算结果为true，则按照以下顺序开始循环序列，执行statement，然后计算next表达式。
9.For..in
语法：for(variableIterant in object){
statement(s);
}
参数：variableIterant作为迭代变量的变量名，引用数组中对象或元素的每个属性。
object要重复的对象的名称。
statement(s)要为每次迭代执行的指令。
描述：动作；循环通过数组中对象或元素的属性，并为对象的每个属性执行statement。
10.if
语法：if(condition) {
statement(s);
}
参数：condition计算结果为true或false的表达式。
statement(s)如果或当条件的计算结果为true时要执行的指令。
描述：动作；对条件进行计算以确定影片中的下一步动作。如果条件为true，则Flash将运行条件后面花括号({})内的语句。如果条件为false，则Flash跳过花括号内的语句，运行花括号后面的语句。使用if动作可在脚本中创建分支逻辑。
11.switch
语法：switch (expression){
caseClause:
[defaultClause:]
}
参数：expression任意表达式。
caseClause一个Case关键字，其后跟表达式、冒号和一组语句，如果在使用全等的情况下，此处的表达式与switch expression参数相匹配，则执行这组语句。
defaultClause一个default关键字，其后跟着如果这些Case表达式都不与switch expression参数全等匹配时要执行的语句。
描述：动作；创建动作脚本语句的分支结构。像If动作一样，Switch 动作测试一个条件，并在条件返回true值时执行语句。
12.while
语法：while(condition) {
statement(s);
}
参数：condition每次执行while动作时都要重新计算的表达式。如果该语句的计算结果为 true，则运行statement(s)。
statement(s)条件的计算结果为true时要执行的代码。
描述：动作；测试表达式，只要该表达式为true，就重复运行循环中的语句或语句序列。
(六)用户定义的函数
该部分的Action可以通过用户自己组合开发更具灵活的程序脚本。
1.call
语法：call(frame)
参数：frame时间轴中帧的标签或编号。
描述：动作；执行被调用帧中的脚本，而不将播放头移动到该帧。一旦执行完该脚本，局部变量将不存在。
2.call function
语法：object.function([parameters])
参数：object其中定义了函数的对象(可以是影片剪辑)。
function指定用户定义的函数的标识符。
parameters可选参数，指示函数所需的任何参数。
描述：动作；允许你在标准模式下，使用“动作”面板中的参数字段来调用用户定义的函数。
3.function
语法：function functionname ([parameter0, parameter1,...parameterN]){
statement(s)
}
function ([parameter0, parameter1,...parameterN]){
statement(s)
}
参数：functionname新函数的名称。
parameter一个标识符，表示要传递给函数的参数。这些参数是可选的。
statement(s)为function的函数体定义的任何动作脚本指令。
描述：你定义的用来执行特定任务的一组语句。可以在影片的一个地方“声明”或定义函数，然后从影片的其他脚本调用它。定义函数时，还可以为其指定参数。参数是函数要对其进行操作的值的占位符。每次调用函数时，可以向其传递不同的参数。这使你可以在不同场合重复使用一个函数。
4.method
语法：object.method = function ([parameters]) {
...body of function...
};
参数：object对象的标识符。
method方法的标识符。
parameters要传递给函数的参数。可选参数。
描述：动作(仅限标准模式)；用于在标准模式下使用“动作”面板来定义对象的方法。
5.Return
语法：return[expression]
return
参数：expression要作为函数值计算并返回的字符串、数字、数组或对象。此参数是可选的。
返回值：如果提供了expression参数，则返回计算的结果。
描述：动作；指定由函数返回的值。return动作计算expression并将结果作为它在其中执行的函数的值返回。return动作导致函数停止运行，并用返回值代替函数。如果单独使用return语句，它返回null。
二、函数
函数是Flash MX中至关重要的部分，是完成复杂的程序操作的必要组合。
(一)常用函数
顾名思义，该部分的内容是介绍Flash MX中常用逻辑函数脚本集合。
1.escape
语法：escape(expression)
参数：expression要转换为字符串并以URL编码格式进行编码的表达式。
描述：函数；将参数转换为字符串，并以URL编码格式进行编码，在这种格式中，将所有非字母数字的字符都转义为十六进制序列。
2.eval
语法：eval(expression)
参数：expression包含要获取的变量、属性、对象或影片剪辑的名称的字符串。
描述：函数；按照名称访问变量、属性、对象或影片剪辑。如果expression是一个变量或属性，则返回该变量或属性的值。如果expression是一个对象或影片剪辑，则返回指向该对象或影片剪辑的引用。如果无法找到expression中指定的元素，则返回undefined。
3.getProperty
语法：getProperty(instancename , property)
参数：instancename 要获取其属性的影片剪辑的实例名称，
property影片剪辑的属性。
描述：函数；返回影片剪辑instancename的指定property的值。
4.getTimer
语法：getTimer()
描述：函数；返回自影片开始播放时起已经过的毫秒数。
5.targetPath
语法：targetpath(movieClipObject)
参数：movieClipObject对要获取其目标路径的影片剪辑的引用(例如，_root或_parent)。
描述：函数；返回包含movieClipObject的目标路径的字符串。此目标路径以点记号表示形式返回。若要获取以斜杠记号表示的目标路径，请使用_target属性。
6.unescape
语法：unescape(x)
参数：x要转义的十六进制序列字符串。
描述：顶级函数；将参数x作为字符串计算，将该字符串从URL编码格式(这种格式将所有十六进制序列转换为ASCII字符)进行解码，并返回该字符串。
(二)数学函数
该部分的Action帮助开发人员完成程序中的数学运算。
1.isFinite
语法：isFinite(expression)
参数：expression要计算的布尔表达式、变量表达式或其他表达式。
描述：顶级函数；对expression进行计算，如果其为有限数，则返回true，如果为无穷大或负无穷大，则返回false。无穷大或负无穷大的出现指示有错误的数学条件，例如被0除。
2.isNaN
语法：isNaN(expression)
参数：expression要计算的布尔表达式、变量表达式或其他表达式。
描述：顶级函数；对参数进行计算，如果值不是数字(NaN)，则返回true，指示存在数学错误。
3.parseFloat
语法：parseFloat(string)
参数：string要读取并转换为浮点数的字符串。
描述：函数；将字符串转换为浮点数。此函数读取(或“分析”)并返回字符串中的数字，直到它到达不是数字(其初始含义为数字)部分的字符。如果字符串不是以一个可以分析的数字开始的，则parseFloat返回NaN。有效整数前面的空白将被忽略，有效整数后面的非数值字符也将被忽略。
4.parseInt
语法：parseInt(expression, [radix])
参数：expression转换为整数的字符串。
radix表示要分析数字的基数(基)的整数。合法值为2～36。此参数是可选的。
描述：函数；将字符串转换为整数。如果参数中指定的字符串不能转换为数字，则此函数返回NaN。以0开头的整数或指定基数为8的整数被解释为八进制数字。以0x开头的字符串被解释为十六进制数字。有效整数前面的空白将被忽略，有效整数后面的非数值字符也将被忽略。
(三)转换函数
该部分的Action是Flash MX用来处理内容格式转换的脚本集合。
1.Boolean(函数)
语法：Boolean(expression)
参数：expression一个可转换为布尔值的表达式。
描述：函数；将参数expression转换为布尔值，并以如下形式返回值：如果expression是布尔值，则返回值为expression。如果expression是数字，则在该数字不为零时返回值为true，否则为false。如果expression是字符串，则调用toNumber方法，并且在该数字不为零时返回值为true，否则为false。如果expression未定义，则返回值为false。如果expression 是影片剪辑或对象，则返回值为true。
2.Number(函数)
语法：Number(expression)
参数：expression要转换为数字的表达式。
描述：函数；将参数expression转换为数字并按如下规则返回一个值：
如果expression为数字，则返回值为expression。如果expression为布尔值，当 expression为true时，返回值为1；当expression为false时，返回值为0。如果expression 为字符串，则该函数尝试将expression解析为一个带有可选尾随指数的十进制数字。如果expression为undefined，则返回值为0。
3.String(函数)
语法：String(expression)
参数：expression要转换为字符串的表达式。
描述：函数；返回指定参数的字符串表示形式，规则如下所示：
如果expression为布尔值，则返回字符串为true或false。如果expression是数字，则返回的字符串为此数字的文本表示形式。如果expression为字符串，则返回的字符串是 expression。如果expression是一个对象，则返回值为该对象的字符串表示形式，它是通过调用该对象的字符串属性而生成的，如果不存在此类属性，则通过调用Object.toString 而生成。如果expression是一个影片剪辑，则返回值是以斜杠(/)记号表示的此影片剪辑的目标路径。如果expression为undefined，则返回值为空字符串()。
三、常量
该部分的aAction罗列出Flash MX中常用的常量脚本集合。
1.false
语法：false
描述：表示与true相反的唯一的布尔值。
2.newline
语法：newline
描述：常量；插入一个回车符()，该回车符在动作脚本代码中插入一个空行。newline可用来为代码中的函数或动作所获取的信息留出空间。
3.null
语法：null
描述：关键字；一个可以赋予变量或者可以在函数未提供数据时由函数返回的特殊值。可以使用null表示缺少的或者未定义数据类型的值。
4.true
语法：true
描述：表示false相反的唯一布尔值。
5.undefined
语法：undefined
描述：一个特殊值，通常用于指示变量尚未赋值。对未定义值的引用返回特殊值undefined。动作脚本代码typeof(undefined) 返回字符串“undefined”。undefined类型的唯一值是 undefined。
当将undefined转换为字符串时，它转换为空字符串。undefined值与特殊值null相似。事实上，当使用相等运算符对null和undefined进行比较时，它们的比较结果为相等。
四、属性
用Flash MX制作或开发动画，其中必不可少的就是使用脚本定义所有movie的属性。
1.MovieClip._alpha
语法：myMovieClip._alpha
描述：属性；设置或获取由MovieClip指定的影片剪辑的Alpha透明度(value)。有效值为0(完全透明)到100(完全不透明)。如果影片剪辑的_alpha设置为 0，虽然其中的对象不可见，但也是活动的。
2.MovieClip._currentframe
语法：myMovieClip._currentframe
描述：属性(只读)；返回由MovieClip指定的时间轴中播放头所处的帧的编号。
3.MovieClip._droptarget
语法：myMovieClip._droptarget
描述：属性(只读)；以斜杠语法记号表示法返回MovieClip放置到的影片剪辑实例的绝对路径。_droptarget属性始终返回以斜杠(/)开始的路径。若要将实例的_droptarget属性与引用进行比较，请使用eval函数将返回值从斜杠语法转换为点语法表示的引用。
4.MovieClip._focusrect
语法：myMovieClip._focusrect
描述：属性；一个布尔值，指定当影片剪辑具有键盘焦点时其周围是否有黄色矩形。该属性可以覆盖全局_focusrect属性。
5.MovieClip._framesloaded
语法：myMovieClip._framesloaded
描述：属性(只读)；从影片流中已经加载的帧数。该属性可确定特定帧及其前面所有帧的内容是否已经加载，并且是否可在浏览器本地使用。该属性对于监视大影片的下载过程很有用。
6.MovieClip._height
语法：myMovieClip._height
描述：属性；以像素为单位设置和获取影片剪辑的高度。
7.MovieClip._name
语法：myMovieClip_name
描述：属性；返回由MovieClip指定的影片剪辑的实例名称。
8._quality
语法：_quality
描述：属性(全局)；设置或获取用于影片的呈现品质。设备字体始终是带有锯齿的，因此不受_quality属性的影响。
9.MovieClip._rotation
语法：myMovieClip._rotation
描述：属性；以度为单位指定影片剪辑的旋转。
10._soundbuftime
语法：_soundbuftime = integer
参数：integer在影片开始进入流之前缓冲的秒数。
描述：属性(全局)；规定声音流缓冲的秒数。默认值为5秒。
11.MovieClip._target
语法：myMovieClip._target
描述：属性(只读)；返回MovieClip参数中指定的影片剪辑实例的目标路径。
12.MovieClip._totalframes
语法：myMovieClip._totalframes
描述：属性(只读)；返回MovieClip参数中指定的影片剪辑实例中的总帧数。
13.MovieClip._url
语法：myMovieClip._url
描述：属性(只读)；获取从中下载影片剪辑的SWF文件的URL。
14.MovieClip._visible
语法：MovieClip._visible
描述：属性；一个布尔值，指示由MovieClip参数指定的影片是否可见。不可见的影片剪辑(_visible属性设置为false)处于禁用状态。例如，不能点击_visible属性设置为false 的影片剪辑中的按钮。
15.MovieClip._width
语法：MovieClip._width
描述：属性；以像素为单位设置和获取影片剪辑的宽度。
16.MovieClip._x
语法：MovieClip._x
描述：属性；设置影片坐标的整数，该坐标相对于父级影片剪辑的本地坐标。如果影片剪辑在主时间轴中，则其坐标系统将舞台的左上角作为(0, 0)。如果影片剪辑位于另一个具有变形的影片剪辑中，则该影片剪辑位于包含它的影片剪辑的本地坐标系统中。因此，对于逆时针旋转90的影片剪辑，该影片剪辑的子级将继承逆时针旋转90的坐标系统。影片剪辑的坐标指的是注册点的位置。
17.MovieClip._xmouse
语法：MovieClip._xmouse
描述：属性(只读)；返回鼠标位置的坐标。
18.MovieClip._xscale
语法：MovieClip._xscale
描述：属性；确定从影片剪辑的注册点开始应用的影片剪辑的水平缩放比例(percentage)。默认为(0,0)。
19.MovieClip._y
语法：MovieClip._y
描述：属性；设置影片的坐标，该坐标相对于父级影片剪辑的本地坐标。同MovieClip._x。
20.MovieClip._ymouse
语法：MovieClip._ymouse
描述：属性(只读)；指示鼠标位置的坐标。
21.MovieClip._yscale
语法：MovieClip._yscale
描述：设置从影片剪辑注册点开始应用的该影片剪辑的垂直缩放比例(percentage)。默认为 (0,0)。
五、对象
由于Flash MX的脚本编程方式符合OO(面向对象)概念，所以，对象的脚本集合也是开发者经常使用的。
(一)核心对象
1.arguments
arguments.callee
语法：arguments.callee
描述：属性；指当前被调用的函数。
2.arguments.caller
语法：arguments.caller
描述：属性；指进行调用的函数的arguments对象。
3.arguments.length
语法：arguments.length
描述：属性；实际传递给函数的参数数量。
4.Array
语法：new Array()
new Array(length)
new Array(element0, element1, element2,...elementN)
参数：length一个指定数组中元素数量的整数。在元素不连续的情况下，length参数指定的是数组中最后一个元素的索引号加1。
element0...elementN一个包含两个或多个任意值的列表。这些值可以是数字、字符串、对象或其他数组。数组中第一个元素的索引或位置始终为0。
描述：Array对象的构造函数；你可使用构造函数来创建不同类型的数组：空数组、具有特定长度但其中元素没有值的数组或其中元素具有特定值的数组。
5.Boolean
语法：new Boolean([x])
参数：x任何表达式。此参数是可选的。
描述：Boolean对象的构造函数；创建Boolean对象的实例。如果省略x参数，则将Boolean 对象初始化为具有值false。如果为x参数指定值，则该方法会计算它，并根据Boolean(函数)函数中的规则以布尔值返回结果。
6.Date
语法：new Date()
new Date(year,month [,date [,hour[,minute [,second[,millisecond]]]]])
参数：year一个0～99之间的值，表示19至；如果年份不在上述范围内，则必须指定表示年份数的所有4位数字。
返回：整数
描述：Date对象的构造函数；构造一个新的Date对象，该对象保存当前日期和时间或指定的日期。
7._global
语法：_global.identifier
返回值：对包含核心动作脚本类的全局对象(例如String、Object、Math和Array)的引用。
描述：标识符；创建全局变量、对象或类。
8.Math
语法：Math.abs(x)
参数：x一个数字。
返回值：一个数字。
描述：方法；计算并返回由参数x指定的数字的绝对值。
9.Math.acos
语法：Math.acos(x)
参数：x一个介于-1.0～1.0之间的数字。
描述：方法；以弧度为单位计算并返回参数x中指定的数字的反余弦值。
10.Math.asin
语法：Math.asin(x)
参数：x一个介于-1.0～1.0之间的数字。
描述：方法；以弧度为单位计算并返回参数x中指定的数字的反正弦值。
11.Math.atan
语法：Math.atan(x)
参数：x一个数字。
描述：方法；计算并返回参数x中指定的数字的反正切值。返回值介于-pi/2～+pi/2之间。
12.Math.atan2
语法：Math.atan2(y, x)
参数：x一个数字，指定点的x坐标。y一个数字，指定点的y坐标。
描述：方法；以弧度为单位计算并返回y/x的反正切值。返回值表示相对直角三角形对角的角，其中x是临边边长，而y是对边边长。
13.Math.sqrt
语法：Math.sqrt(x)
参数：x一个大于等于0的数字或表达式。
描述：方法；计算并返回指定数字的平方根。
14.Number
语法：myNumber = new Number(value)
参数：value要创建的Number对象的数值，或者要转换为数字的值。
描述：构造函数；新建一个Number对象。
15.Object
语法：new Object([value])
参数：value要转换为对象的数字、布尔值或字符串。此参数是可选的。如果未指定value，则该构造函数创建一个未定义属性的新对象。
描述：Object对象的构造函数；新建一个Object对象。
16.String
语法：new String(value)
参数：value新String对象的初始值。
描述：String对象的构造函数；创建一个新String对象。
17.Super
语法：super.method([arg1, ..., argN])
super([arg1, ..., argN])
参数：method要在超类中调用的方法。
arg1可选参数，这些参数或者传递给方法的超类版本，或者传递给超类的构造函数。
返回值：两种格式都调用一个函数。该函数可以返回任何值。
描述：运算符：第一种语法格式可以用于对象方法体内，用以调用方法的超类版本，而且可以选择向超类方法传递参数(arg1...argN)。这对于创建某些子类方法很有用，这些子类方法在向超类方法添加附加行为的同时，又调用这些超类方法执行其原始行为。
第二种语法格式可以用于构造函数体内，用以调用此构造函数的超类版本，而且可以选择向它传递参数。这对于创建子类很有用，该子类在执行附加的初始化的同时，又调用超类构造函数执行超类初始化。
(二)影片对象
1.Accessibility.isActive
语法：Accessibility.isActive()
返回值：布尔值
描述：方法；指示屏幕阅读器程序当前是否处于活动状态。当希望影片在有屏幕阅读器的情况下行为方式不同时，可使用此方法。
2.Button.getDepth
语法：myButton.getDepth()
描述：方法；返回按钮实例的深度。
3.Button.enabled
语法：myButton.enabled
描述：属性；指定按钮是否处于启用状态的布尔值。默认值为true。
4.Button.tabEnabled
语法：myButton.tabEnabled
描述：属性；可以对MovieClip、Button或TextField对象的实例设置该属性。默认情况下它是未定义的。
5.Button.tabIndex
语法：myButton.tabIndex
描述：属性；使你可以自定义影片中对象的Tab键排序。可以对按钮、影片剪辑或文本字段实例设置tabIndex属性，默认情况下为undefined。
6.Button.trackAsMenu
语法：myButton.trackAsMenu
描述：属性；指示其他按钮或影片剪辑是否可接收鼠标按钮释放事件的布尔值属性。这将允许你创建菜单。你可以设置任何按钮或影片剪辑对象的trackAsMenu属性。如果 trackAsMenu属性不存在，则默认行为为false。 可以在任何时间更改trackAsMenu属性；修改后的按钮会立即采用新的行为。
7.myButton.useHandCursor
语法：myButton.useHandCursor
描述：属性；一个布尔值，当设置为true时，指示在用户用鼠标指针滑过按钮时是否显示手形光标。useHandCursor的默认值为true。如果useHandCursor属性设置为false，则将改用箭头光标。可以在任何时间更改useHandCursor属性；修改后的按钮会立即采用新的光标行为。可以从原型对象中读出useHandCursor属性。
8.System.capabilities.hasAudio
语法：System.capabilities.hasAudio
描述：属性；指示播放器是否具有音频功能的布尔值。默认值为true。其服务器字符串为 A。
9.System.capabilities.hasAudioEncoder
语法：System.capabilities.hasAudioEncoder
描述：属性；音频解码器的数组。其服务器字符串为AE。
10.System.capabilities.screenColor
语法：System.capabilities.screenColor
描述：属性；指示屏幕的颜色是彩色(color)、灰度(gray)还是黑白(bw) 的。默认值为color。其服务器字符串为SC。
11.Color
语法：new Color(target)
参数：target影片剪辑的实例名称。
描述：构造函数；为由target参数指定的影片剪辑创建Color对象的实例。然后可使用该 Color对象的方法来更改整个目标影片剪辑的颜色。
12._level
语法：_levelN
描述：属性；对_levelN的根影片时间轴的引用。你必须使用loadMovieNum动作将影片加载到Flash Player中以后，才可使用_level属性来定位这些影片。还可使用_levelN来定位由N所指定级别处的已加载影片。
加载到Flash Player实例中的初始影片会自动加载到_level0。_level0中的影片为所有随后加载的影片设置帧频、背景色和帧大小。然后影片堆叠在处于_level0的影片之上的更高编号级别中。
你必须为每个使用loadMovieNum动作加载到Flash Player中的影片分配一个级别。你可按任意顺序分配级别。如果你分配的级别(包括_level0)中已经包含SWF文件，则处于该级别的影片将被卸载并替换为新影片。
13._parent
语法：_parent.property
_parent._parent.property
描述：属性；指定或返回一个引用，该引用指向包含当前影片剪辑或对象的影片剪辑或对象。当前对象是包含引用_parent的动作脚本代码的对象。使用_parent来指定一个相对路径，该路径指向当前影片剪辑或对象上级的影片剪辑或对象。
14._root
语法：_root.movieClip
_root.action
_root.property
描述：属性；指定或返回指向根影片时间轴的引用。如果影片有多个级别，则根影片时间轴位于包含当前正在执行脚本的级别上。指定_root与在当前级别内用斜杠记号(/)指定绝对路径的效果相同。
(三)客户端/服务器对象
1.LoadVars
语法：new LoadVars()
描述：构造函数；创建LoadVars对象的实例。然后你可使用该LoadVars对象的方法来发送和加载数据。
2.XML
语法：new XML([source])
参数：source为创建新的XML对象而进行分析的XML文本。
描述：构造函数；创建一个新的XML对象。必须使用构造函数方法创建一个XML对象的实例之后，才能调用任何一个XML对象的方法。
createElement与createTextNode方法是用于在XML文档树中创建元素和文本节点的“构造函数”方法。
3.XMLSocket
语法：new XMLSocket()
描述：构造函数；创建一个新的XMLSocket对象。XMLSocket对象开始时未与任何服务器连接。必须调用XMLSocket.connect方法将该对象连接到服务器。
本文是我（aw）在整理了相关文档和讨论之后，结合自己的亲自实验总结出来的一些经验和心得，我尽量描述详尽，避免模糊概念，当然也希望所有看官提出批评意见。为了表述方便，其中术语不限定语言，如我可能会一会儿用class，一会儿用“类”。
面向对象的难点部分就是理解变量作用域修饰符（modifier）其实也就是面向对象中我们已经熟悉的public、protected、private等等。本文还深入讨论了ActionScript3中新增的internal等概念。下面我依次列出：
一、关于package以及internal
package，用“形而上学”的方式理解，就是物理目录下的类集合。在AS2中只需要保证文件系统的路径匹配，然后用类似“import com.awflasher.someUtils”的方法导入即可。而AS3则要求您在所有的类中声明package关键词。package的大括号对 “{}”内，我们只能定义一个类，我们可以在这个大括号外面定义一些辅助类，不过这些类只能被当前这个类（你在package大括号对内定义的类）访问。当然，一个package大括号对内只有一个类，这并不代表一个package内只有一个类。你可以在同一目录下定义多个属于该package（指代这个目录）的类。它的意义绝不是简单的“类文件集合容器”，而是一个让各种应该协同工作的类集中到一起的项目包。值得一提的是，所谓“协同工作”是指至少有一个class要引入其他一些class 来进行功能设计，而这时候采用internal修饰可以省去很多getters和setters。我自己回忆起在湖南卫视的项目中用AS2开发的 Vplayer，两个类AVCore和AVControl就有很多getter和setter，搞的特别麻烦。
internal类似public，但限定在一个 package内了。在同一个package内的类可以访问同一个package内其他类的internal变量，而其他包内的类无法访问。 package 与类的继承性毫无关系，比如TextField和Sprite、MovieClip都继承自DisplayObject类，但TextField属于 flash.text包，而MovieClip和Sprite属于flahs.display包。也就是说，包对类的限定是与继承链毫无关联的、一个新的 “维度”的限定。
附：使用一个类的时候，我们必须import这个类，或者包含这个类的package。AS2时直接写完整包路径的使用方法在AS3中不管用了，本文后面有详细介绍。
二、关于public
public定义的类或者属性可以在任何作用域内由任何来源访问。构造函数永远都是public的，Flex中的应用程序类（Application Class）和Flash CS3中的文档类（Document Class）必须是public的。且不能缺省public这个关键词声明。我在测试中发现，如果不声明public，Flash根本就不会获取类的定义，进而编译无法通过。
三、关于protected
protected声明类似AS2的private，它定义的属性只能在自己子类中可见，而其它场合都是不可见的。这一点与Java等传统OOP语言类似。
四、关于private
注意AS3的private和AS2的private大不相同，它定义的属性只属于自己，子类可以定义毫无牵连的同名属性。
dynamic 和原来AS2的dynamic一样，用dynamic声明的类可以动态的加入属性。这些属性也可以通过delete来删除。动态加入的属性一旦被切断所有的引用就会被垃圾回收机制自动回收。有时候用System.totalMemory检测不到内存释放是因为垃圾回收机制并不是即时运行的。
五、关于dynamic
动态（dynamic）类允许在运行时动态地添加属性，常见的动态类有MovieClip和顶级（top-level）的Array。如果您的自定义类要继承于动态类，那么请也定义为动态的，不要省略dynamic关键词。
六、关于继承（extends）和override
继承其实并不太复杂，唯一要说明的就是：子类的构造函数一定要用“super”调用一次父类的构造函数，否则报错！对于继承后的子类，如果要重新定义父类的非private方法，必须使用override关键词。在override的时候，如果我们需要调用父类的方法，可以使用super关键词（由于继承方法在逻辑上与父类往往有相似性，因此没有必要把方法逻辑完全重写）官方帮助中的这个例子非常易懂：
package {
import flash.display.MovieClip;
public class SuperExample extends MovieClip
{
public function SuperExample()
{
var myExt:Extender = new Extender()
trace(myExt.thanks()); // output: Mahalo nui loa
}
}
}
class Base {
public function thanks():String
{
return “Mahalo”;
}
}
class Extender extends Base
{
override public function thanks():String
{
return super.thanks() + ” nui loa”;
}
}
override不能用于重载变量（成员属性），
但是却可以用于重写getter和setter函数，例如：（官方帮助的例子）
package
{
import flash.display.MovieClip;
public class OverrideExample extends MovieClip
{
public function OverrideExample()
{
trace(currentLabel)
}
override public function get currentLabel():String
{
var str:String = “Override: “;
str += super.currentLabel;
return str;
}
}
}
这个例子中，我们直接重写了MovieClip类的currentLabel属性。注意调用父类属性的时候，用了super.currentLabel。
关于静态方法，比较麻烦。首先，静态方法是无法被重载的。必须通过类来访问。但是您也可以自己定义与静态方法同名的方法，我把官方的例子做了一下修改就一目了然了：
package
{
import flash.display.MovieClip;
public class StaticExample extends MovieClip
{
public function StaticExample()
{
var myExt:Extender = new Extender();
}
}
}
class Base {
public static var test:String = “static”;
}
class Extender extends Base
{
private var test:String = “instance”;
public function Extender()
{
trace(Base.test); // output: static
trace(test); //added by awflasher.com, output: instance
}
}
七、关于import语法
在AS2时代，“import”语法只是为了让编程时代码简洁（省去了包名），比如我们import了mx.transitions.Tween之后，就可以直接new Tween()了。而如果不import，我们也可以直接用全类名来构造实例，例如：new mx.transitions.Tween();
然而，在AS3中，无论是否采用全名类声明，只要你用到这个类，就必须import。import估计是传统Flash程序员所需要养成的一个最大的习惯，在刚切入AS3开发平台的时候，我常常忘记import一些常用的类，例如从IDE 指向过来的文本和渲染元件，以及flash.event.*、flash.display.StageAlign等比较泛用的类。
AS3中不像AS2那样，我们不能用_root和Stage[”displayState”]来进行hacks了。
八、关于编译时的注意事项
AS3不再像AS2那样简单地Complie-Time（编译时，即FlashCS3/FlexBuidler/其他编译器发布ActionScript. 及所有资源为SWF文件的那一时刻）进行类型检测了，AS3在Run-Time（运行时，级Flashplayer或者其他播放SWF的软件在播放SWF 的时候）也有类型检测，因此AS2的Hacks（强制访问不能访问的属性）将不再有效。
九、一个不得不说的好消息
AS3中类所有的变量（属性）和函数（方法）的作用域都是运行时跟类/实例走的。这与AS2大有不同，我们不再需要去Delegate了。只要是类自己的方法，在调用的过程中，this永远指向类自己（实例）。
简要总结：
1、如果我需要属性公开，并且可以被自己的子类继承，那么定义成public的。子类也可重写（override）之。
2、如果我需要属性隐藏，但是可以被自己的子类继承，那么定义成protected的。与public类似，子类也可重写（override）之。
3、如果我的某一个类有一个属性不想在任何位置可见，包括其子类，那么定义为private的。其子类无需重写（override），因为它根本就不存在于子类中。
8.面向对象程序设计
8.1类和对象的概念
类：类是用来创建同 一类型的对象的“模板”，在一个类中定义了该类对象所应具有的成 员变量以及方法，
对象：对象是类的实例。
8.2类之间的关系
系统中的类有那些关系：依赖、关联（聚合、合成）、泛化、实现。
1.依赖：对于外部类或对象的引用；
5.关联：关联暗示两个类在 概念上位于相同的级别；
6.聚合：表示一种“拥有”关系，是 两个类之间一种整体 / 局部的关系；
7.合成：表示一种更强“拥有 ”关系，就像人和腿的关系一样。组合而成的新对象对组成部分的内容分配 和释放有绝对责任；
8.泛化：表现为继承 extends；
9.实现：表 现为实现 implements。
8.3 面向对象程序设计（OOP）
在面向对 象出现以前，结构化程序设计是程序设计的主流，结构化程序设计又称为面向过 程的程序设计。这种设计方法开发的软件稳定性、可修改性和可重用性都比较差 。
与过程相比对象是稳定的。面向对象的软件系统是由对象组成的，复杂 的对象是由比较简单的对象组合而成的。也就是说，面向对象方法学使用对象分 解取代了传统的功能分解。
面向对象的精髓在于考虑问题的思路是从现实 世界人类思维习惯出发的，只要领会了这一点，就领会了面向对象的思维方法。 万事万物皆为对象，大至日月星辰，小至沙粒微尘，都是对象。对象包容了一切 事物，不仅仅是那些看得见摸得着的是实体，如：地球、汽车、树叶，还包括那 些客观存在的事物，如：社会、互联网、朋友圈子等等，包罗万象。
以开 车为例，用面向过程的思想去考虑，那么你先得知道怎么启动，怎么踩油门，怎 么挂档。这些应该是司机的活，你要把这些步骤都实现出来。如果用面向对象的 思想，把自己看成领导，只需要下达命令，告诉它你要去哪里就行了（例如，调 用drive 方法），具体怎么开，怎么踩油门，怎么挂档，不需要我们去管。
那么 dirve() 这个方法放到车里是否合适呢，是不是应该放到“司 机”类更合理呢？封装是很灵活的，没有对与错之分，只有好与更好，需要 具体问题具体分析。因为 dirve() 方法要用到油门和车档，而这些东西都在车里 面，因此如果将它封装到车这个类里面可能更好些。
下面我们通过对比面 向过程和面向对象的设计方式体会什么才是面向对象的思维。
8.4 出圈游 戏 —— 面向过程 VS 面向对象
8.4.1 游戏规则
假设 有5 个小孩儿手拉手围成一圈。从第一个小孩儿开始以顺时针方向依次报数 —— “1，2，3”，报 3的人出列，第四个人从1 开始重 新报数，报到 3 时再出列。如此下去，直到所有人全部出列为止，要求按照出列 的顺序输出他们的序号。
下面来看图理解，首先有5 个小孩围成一个圈：
图一、 5 个小孩儿围成一圈
图二、数到 3的小孩儿退出去
图三、再从2 号开始数三个人， 5 号退出，然后是2 号，最后是4 号。
最终输出的顺序应该是3、1、5、2、4。
8.4.2 出圈游戏 —— 面向过程（cirgame/ CircleGame1.as）
下面用面向过程的思想写这个程 序，通过读注释先来看一下这个程序：
//有5 个小孩儿围成的圈
var array:Array = new Array(5);
for (var i = 0; i < array.length; i++) {
// 如果元素值为 true 表示他在圈内，如果是false 表示不在圈内
array[i] = true;
}
// 圈内还剩多少人，最开始人都在，等于 array.length
var leftCount:int = array.length;
// 当前所报的数，初始为 0
var countNum:int = 0;
// 圈子的数组下标，表示当前指向的是谁
var index:int = 0;
while(leftCount > 0) {
if (array[index] == true) {
// 如果当前这个人在圈内则报数
countNum++;
if (countNum == 3) {
// 如果所报的数是3 则出列，剩余人数减1，并且下一 次从新开始报数
trace(“out ” + (index + 1));
array[index] = false;
leftCount--;
countNum = 0;
}
}
//数组下标增加
index++;
if (index == array.length) {
// 如果下标是最后一个位则归 0，因为这个圈是圆的
index = 0;
}
}
用array数组代表这个围成的圈，开始让圈数组中的每个元素都 为 true，表示它们都在圈内，如果设为 false 则表示不在圈内，后面报数的时 候就不予考虑了。
接下来定义三个变量分别表示圈内还剩多少人，所报的 数是多少和数组下标。
下面 while 循环开始，只有圈内还有人 （leftCount > 0）就进行循环，首先判断当前 index 所指的元素是否为真， 如果是则报数加 1，再判断是不是加到 3 了，如果是则打印出当前的数组下标， 再将该元素设为 false，剩余人数减1，下一次从新开始报数，
最后让数组下标加 1，当指到最后时，将数组下标置为 0，因为这是一个圈， 要用循环的数组来表示。
8.4.3 出圈游戏 —— 面向对象 （cirgame/ CircleGame2.as）
回顾上一个例子，在面向过程的程序中， 明明是围成的一个圈儿，却要看成是一个数组；明明是一个个小孩儿却要看成是 数组的一个个元素。这不就是为了让计算机看懂吗？但是，面向对象是更加接近人类的思维模式，我们在现实中看到的就是一个个小孩儿，怎么能说是数组？那 么这一个个小孩儿就是一个个对象，他们都是Kid。围成的这个圈，就是一个 KidCircle。很自然吧，比大自然还自然！下面来体会面向对象的设计思想：
package cirgame {
public class CircleGame2 {
public function CircleGame2() {
var kc:KidCircle = new KidCircle(5);
var countNum:int = 0;
var k:Kid = kc.head;
while (kc.count > 0) {
countNum++;
if (countNum == 3) {
trace(k.id + 1);
kc.remove(k);
countNum = 0;
}
k = k.right;
}
}
}
}
// 每个Kid都有自己的id，并且左右手还拉着其它的Kid
class Kid {
var id:uint;
var left:Kid;
var right:Kid;
}
// 这个圈子里可以加入或移除一些Kid
class KidCircle {
var count:uint = 0;
var head:Kid;
var rear:Kid;
function KidCircle(n:uint) {
for (var i = 0; i < n; i++) {
var kid:Kid = new Kid();
add(kid);
}
}
function add(kid:Kid):void {
kid.id = count;
if (count == 0) {
head = kid;
rear = kid;
kid.left = kid;
kid.right = kid;
} else {
rear.right = kid;
kid.left = rear;
kid.right = head;
head.left = kid;
rear = kid;
}
count++;
}
function remove(kid:Kid):void {
if (count <= 0) {
return;
} else if (count == 1) {
head = rear = null;
} else {
kid.left.right = kid.right;
kid.right.left = kid.left;
if (kid == head) {
head = kid.right;
} else if (kid == rear) {
rear = kid.left;
}
}
count--;
}
}
这段程序中设计了两个类，代表两类客观事物 —— 小孩（Kid）和圈子（KidCircle）。从8.4.1的图中可以确切地看到。Kid有三个 属性：id 号、左手和右手，左手拉着一个Kid，右手拉着一个Kid，因此left和 right存放两个Kid的引用。
下面是KidCircle类，代表围成的圈子，这个圈子可以加入或移除一些Kid，因 此有add和remove两个方法。head和rear两个成员变量用于指向队首和队尾的两个 Kid，因为些添加的Kid 要放在队尾（rear）的后面，因为这是一个圈子，所以还 需要让队尾的小孩儿拉住队首（head）的小孩儿，因此需要保存这两个成员变量 。
最后是测试类，主要的逻辑和前一个例子比较像，这里就不多解释了。
通过这个例子大家可以看出，我们无形之间就完成了一个数据结构 —— 双向循环链表。而前面面向过程的例子，实际上就是一个顺序的 存储结构 —— 线性表。
后面，我会带大家写一个贪吃蛇的游 戏，目的是学习面向对象编程的思想（并非该游戏本身），在贪吃蛇中我们就会 运用到类似于单向链表的结构，如果双向链表掌握了，那么单向一定没问题。
通过本节请大家认真体会面向对象的设计思想。一次学会，终身受用。
优化
原著 Marco Lapi，aw译[特别感谢好友杨鑫]在这篇文章中，我们将讨论多种优化 Actionscript. 代码的方法.
此外我们也针对一些典型的游戏代码进行了系列测试，来最大限度的发掘、提高Flash播放器的性能，
代码优化简介
在本文中，我们将向您展示一些通过技术手段得到了优化的flash小游戏。代码优化之所以重要是因为它能帮您节约flash播放器的资源，还能让您的游戏在不同的硬件环境下运行得更加稳定。本文主要讨论基于flashplayer6.0的一些问题，以及如何通过可行的技术手段去解决它们！
随着flashplayer7.0的发布，一些技术问题已经得到解决了，而且性能大体地有所提高，然而在写本文之时，flashplayer6.0仍然有着广泛的应用。所以我们还是主要集中在6.0这个版本上。-aw猜测：国外买盗版的很少，所以很多人可能都来不及使用7.0，尤其是那些非职业的flash设计者。
何时进行优化
对现有程序进行优化的过程，有时十分的冗长与困难，这与原始代码的非优化程度有关，所以在投入大量时间进行代码优化之前，最重要的是要估计出要在什么地方对代码做出修改或替换。
一个游戏代码的最重要的部分就是主循环体，通常情况下该循环体要在flash的每一帧上执行，并控制游戏中的角色属性和重要的数据参数。而对于主循环体以外的部分，也可能是次要循环部分，同样要注意是给其否分配了过多的资源，而没有分配给那些更需要资源的核心部分。
通过积累在各处节约出来的时间(可能每处仅仅是几个毫秒)，您会明显发现自己的swf运行得更加稳定，并且游戏感也大大加强。
简洁与高效的代码
书写出十分简洁、可以再次调用的代码(有时可能是面向对象的)是一项精细的工作，但这需要多年的编程经验。对于OOP(object oriented programming， 面向对象的程序设计)，有些场合根本利用不到它的优势，这使得它显得十分奢侈。 在有限的资源条件下(可能是flash播放器的原因)，通过更先进的方法，像刚刚提到的OOP，就可能反而导致令人不满意的结果。
我们并不是说OOP对游戏编程不好，只是在某些场合它显得过于奢侈和多余。毕竟有时候“传统的方法”却能得到更好的结果。
大体而言，用OOP是比较好的，因为它让代码维护更加简单。但在后文中，你会看到有时为了充分发挥flashplayer性能，而不采用OOP技术。例如：处理快速滚动或者计算十分复杂的数学问题。
基本的优化
一提及代码优化，我们马上会联想到执行速度的改进，而很少去考虑系统资源的分配。这是因为当今，即使是将被淘汰的计算机，都有足够的内存来运行我们大部分的flash游戏(128M的内存足以满足大多数情况的需要，况且，512M的内存是当今新电脑的基本配置)
变量
在各种重要的代码优化手段中，有这么一条：在定义局部变量的时候，一定要用关键字var来定义，因为在Flash播放器中，局部变量的运行速度更快，而且在他们的作用域外是不耗占系统资源的。
aw附：var变量仅仅在花括号对中才有“生命”，个人认为没有系统学过编程的人容易出错的一个地方：
awMC.onLoad = function(){ var aw = 1;}awMC.onEnterFrame. = function(){ //不存在aw这个变量}
一段非优化代码:
function doSomething(){ mx = 100 my = 100 ar = new Array() for (y=0; y < my; y++) { for (x=0; x < mx; x++) { i = (y * mx) + x arr[i] = i } } return arr}
这段代码中，并未声明函数体内的那些变量(那些仅仅在函数内使用的变量)为局部变量，这使得这些变量被播放器调用的速度更慢，并且在函数执行完毕的时候仍然耗占系统资源。
下面列出的是经过改进的同样功能的代码：
function doSomething(){ var mx = 100 var my = 100 var ar = new Array() for (var y=0; y < my; y++) { for (var x=0; x < mx; x++) { var i = (y * mx) + x arr[i] = i } } return arr}
这样一来所有的变量均被定义为了局部变量，他们能够更快地被播放器调用。这一点在函数大量(10，000次)循环运行时显得尤为重要！当一个函数调用结束的时候，相应的局部变量都会被销毁，并且释放出他们占有的系统资源。
onEnterFrame. 事件
onEnterFrame事件对于游戏开发者而言是非常有用的，它使得我们能够快速、反复地按照预设帧频(fps)运行一段程序。回想在Flash5的时代，这(onEnterFrame实时监控)是一种非常流行的技术，用这样的事件来控制机器游戏对手的逻辑，又或者我们可以在每一个子弹上设置这样的事件来监测子弹的碰撞。
实际上，我们并不推荐给过多的MoveClip添加这样的事件，因为这样做会导致“无头绪码(spaghetti code)”的出现，并且容易导致程序效率明显降低。
大多数情况下，用单独一个onEnterFrame事件就可以解决问题了：用这一个主循环来执行你所需要的操作。
另一个简单的办法是设置一个合适的帧频：要知道帧频越高，CPU资源就越紧张。
在帧频为25-35(fps)之间时，onEnterFrame足以很好地执行较复杂代码，哪怕你的计算机配置较低。因此，在没有特殊要求的场合，我们不推荐使用高于60(fps)的帧频。
矢量图与位图
在处理图形前，我们一定要做出正确的选择。Flash能对矢量图和位图进行完美的兼容，然而矢量图和位图在播放器中的表现实质却完全不同。
在用到矢量图的时候，我们要尽可能简化它们的形状，去除多余的端点。这样做将大大降低播放器用于呈现矢量图所要进行的计算量。另一个重要方面在于线条的运用，尽量减少和避免冗陈的线条结构，因为它们会直接影响到flash的播放效率。
当某个实例透明度小于100时，也会对播放速率造成影响，所以如果你发现自己的Flash播放速率过慢，就去挑出这些透明的实例来吧！
那么，如果真的需要呈现比较复杂的场景时，你就最好考虑使用位图实现。虽然Flash在对位图的渲染效率上并不是最优越的(比如和Flash的“兄长”Director比起来)，但丰富的视觉内容呈现只能靠位图(与位图同复杂度的矢量图形渲染速率非常低)了，这也是很多基于区块的游戏中广泛采用像素图作为背景的原因。顺便要提到的是，Flash虽然对GIF,JPG和PNG都有所支持，但是渲染速度上PNG还是占有绝对优势，所以我们建议flash中的位图都尽可能采用PNG格式。
影片剪辑(MovieClip)的可视性[下面将MovieClip简称为mc]
您可能会经常碰到这样一种情况：有大量不可见/屏幕外的mc等待出场(比如游戏中屏幕外的地图、人物等等)。
要知道，播放器仍然要消耗一定的资源来处理这些不可见/屏幕外的mc，哪怕他们是单帧，非播放的状态。
最好的解决办法之一是给这些mc一个空白帧，当他们不出现在屏幕上时，你能用gotoAndStop()语句跳转到这一帧，从而减少播放器对资源的需求。
请务必记住，这种情况下，简单的设置可见度属性为不可见( _visible = false )是无效的，播放器将继续按照这些mc所停留或播放的帧的复杂度来分配资源 。
数组
数组在各种需要记录数据的应用程序和游戏中都被广泛的使用。
一个典型的例子就是基于区块的Flash游戏，在这样一类的游戏中，地图有时被存放成形如arr[y][x]的二维数组。虽然这是一种很常见的方法，但是如果用一维数组的话，却能提高程序的运行效率。另一个重要的方法来提高数组效率是在数组遍历的时候使用for in 循环来代替传统的 for 或者while循环语法。
例如：
一段代码如下
for (var i in arr){ if (arr[i] > 50) { // 进行某些操作 }}它的执行速度明显高于这一段代码：
for (var i=0; i<10000; i++){ if (arr[i] > 50) { // 进行某些操作 }}
前者的效率比后者提高了30%，这个数字在你的游戏要逐帧执行这一段代码的时候显得更加宝贵！
高级优化：
这里我们对一些游戏中的常用代码进行了效率测试，并给出了结果。其中有一些思路借鉴了本文最后所提到的一些个人或者团体。
我们在两个不同型号的电脑上进行了测试。
AthlonXP 2.6Ghz 台式机 512M内存，WindowsPro
P4 2.0Ghz 笔记本 ，WindowsXP家庭版
每一项测试都分为三组，取平均值得到最后结果。
测试的结果单位为“毫秒”，反映了代码执行时间。显然，数值越小，反映代码的性能越好。
所有的代码均由MX编译生成的Flash6.0版本。有趣的是，我们可以看到由MX和MX2004编译的差距。
所有的测试细节可以看这个PDF文件（aw注：未翻译，很简单的PDF文档，都能看懂的）
我把测试的结果如下归纳出来，同大家分享：
1)for循环和while循环
用while循环将会得到比for循环更好的效率。然而，从数组中读取数据，用for in循环式最好的选择！
所以我们不推荐使用：
for (var i=0; i<1000; i++){ //进行某些操作}
而推荐使用
var i=-1while (++i < 1000){ //进行某些操作}
2) 从数组中读取数据
我们通过测试发现，for in循环的效率大大高于其他的循环方式。参看：
arr = []MAX = 5000// Fill an arrayfor (i=0; i < MAX; i++){ arr[i] = i}var item = null// For Loopfor (var i=0; i < MAX; i++){ item = arr[i]}// For In Loopfor (var i in arr){ item = arr[i]}// While Loopi = -1while(++i < MAX){ item = arr[i]}
3) 向数组中写入数据(while,for)
可以看到while循环稍占优势，
4)_global(全局)变量同Timeline(时间轴)变量
我们猜测采用全局变量能提高变量调用速度，然而效果并不像预计的那样明显。
5)单行、多行变量赋值
我们发现单行变量赋值效率大大高于多行。比如：
a = 0b = 0c = 0d = 100e = 100
的效率就不如：
a = b = c = 0d = e = 100
6) 变量名寻址
这个测试反映了变量名的预寻址是非常重要的，尤其是在循环的时候，一定要先给丁一个指向。这样大大节约了寻址时间。
比如：
var num = nullt = getTimer()for (var i=0; i < MAX; i++){ num = Math.floor(MAX) - Math.ceil(MAX)}t1.text = “Always lookup: ” + (getTimer() - t)
就不如：
t = getTimer()var floor = Math.floorvar ceil = Math.ceilfor (var i=0; i < MAX; i++){ num = floor(MAX) - ceil(MAX)}
7)短变量名和长变量名
变量名越短，效率越高。考虑到长变量名也有它的好处（比如，便于维护等），因此建议在关键部位（比如大量循环出现的时候）使用短变量名，最好就1-2个字符。
8) 循环前、后声明变量
在测试前，我们认为循环前声明变量会更加节约时间，不料测试结果并不明显，甚至还恰恰相反！
// 内部声明t = getTimer()for (var i=0; i < MAX; i++){ var test1 = i}t1.text = “Inside:” + (getTimer() - t)// 外部声明t = getTimer()var test2for (var i=0; i < MAX; i++){ test2 = i}
9) 使用嵌套的if结构
当用到复杂的条件表达式时。把他们打散成为嵌套的独立判断结构是最佳方案。下面的代码我们进行了测试，发现这种效果改进明显！
MAX = 20000a = 1b = 2c = -3d = 4var i=MAXwhile(--i > -1){ if (a == 1 && b == 2 && c == 3 && d == 4) { var k = d * c * b * a }}//下面的判断更加节省时间var i=MAXwhile(--i > -1){ if (a == 1) { if (b == 2) { if (c == 3) { if (d == 4) { var k = d * c * b * a } } } }}
11) TellTarget语法同“点”语法比较
如果你从Flash5.0开始接触Flash代码，那么你一定会记得那时，我们用“tellTarget”来控制MC。
这里测试表明，用tellTarget比点语法效率更高。所以必要的时候，可以考虑采用这种官方公开否认的语法（aw注：个人觉得有点恍惚，不明白为什么会这样。不过既然测试结果如此，那么也有可行性了……）
MAX = 10000mc = _root.createEmptyMovieClip(“test”, 1000)function test_dot(){ var i=MAX while(--i > -1) { mc._x = 10 mc._y = 10 }}function test_tellTarget(){ var i=MAX while(--i > -1) { tellTarget(mc) { _x = 10 _y = 10 } } }
12) 寻找局部变量(this方法同with方法比较)
局部变量的定位方法很多。我们发现用with比用this更加有优势！
obj = {}obj.a = 1obj.b = 2obj.c = 3obj.d = 4obj.e = 5obj.f = 6obj.g = 7obj.h = 8obj.test1 = useThisobj.test2 = useWithMAX = 10000function useThis(){ var i = MAX while(--i > -1) { this.a = 1 this.b = 2 this.c = 3 this.d = 4 this.e = 5 this.f = 6 this.g = 7 this.h = 8 }}function useWith(){ var i = MAX while(--i > -1) { with(this) { a = 1 b = 2 c = 3 d = 4 e = 5 f = 6 g = 7 h = 8 } }}
13) 循环监听键盘事件
同刚才所提到的寻址一样，我们实现给一个指向会得到更好的效率，比如：
keyDown = Key.isDown keyLeft = Key.LEFT//我们再用 if (keyDown(keyLeft))
附：我们测试了按键代码和键值常量的效率发现并无太大差别。
14)Math.floor()方法与int()
这个问题曾在Flashkit的论坛被提出讨论过。测试表明，旧的int方法反而效率更高。我们的测试结果也反映了这一点。
15)eval表达式与中括号语法
我们并没有发现明显的差别，并不像刚才所述那样，旧的eval表达式比起中括号方法并没有太大的优势
var mc = eval(“_root.myMc” + i)var mc = _root[“myMc” + i]//两者效率差不多
16) 涉及MC的循环：ASBroadcaster同欢同循环的差别
测试反映，用未公开的ASBroadcaster方法能大大提高对MC的循环操作的效率。我们的测试中，建立了500个MC，然后测试把它们清楚所花费的时间。
传统的循环式：
MAX = 500SX = 550SY = 330MovieClip.prototype.onCustomEvent = function(){ this.removeMovieClip()}function init(){ var i=MAX var rnd = Math.random while(--i > -1) { var m = _root.attachMovie(“enemy”,“e”+i,i) m._x = rnd() * SX m._y = rnd() * SY }}init()function bench(){ var t = getTimer() var i=MAX while(--i > -1) { _root[“e”+i].onCustomEvent() } res.text = “time: ” + (getTimer() - t)}
同样的效果，用事件广播(ASBroadcaster)
MAX = 500evtManager = {}ASBroadcaster.initialize(evtManager)SX = 550SY = 330MovieClip.prototype.onCustomEvent = function(){ this.removeMovieClip()}function init(){ var i=MAX var rnd = Math.random while(--i > -1) { var m = _root.attachMovie(“enemy”,“e”+i,i) m._x = rnd() * SX m._y = rnd() * SY evtManager.addListener(m) }}init()function bench(){ var t = getTimer() evtManager.broadcastMessage(“onCustomEvent”) res.text = “time: ” + (getTimer() - t)}
用MX04为6.0播放器编译、生成文件：
在MX04种，一件有趣的事是，脚本编译器的性能在各方面提高不少。新的编译器在局部、全局变量寻址效率方面有极大的提高，您还可以通过PDF文件发现很多有趣的结果：全局变量寻址比时间轴变量更快了，而嵌套循环也有所改进。几乎每一个用MX04编译的代码效率都高于MX版本。
awflasher.com附：为什么要为6.0编译呢，国外还有相当一部分用户在使用MX6.0。虽然7.0Player是免费的，但是在国外升级软件似乎不像国内这么火，什么东西马上升到最高。我个人的一些猜测而已
结论：
我们从这些测试结果中发现，对于不同的需求，采用不同的代码，我们可以大大提高脚本的执行效率。虽然我们在这里罗列了许多的优化代码的方法，需要大家自己测试、实验的还有很多(考虑到每个人的需求不同).如果你想更加深入地讨论这类问题。可以来我们的论坛。
aw附：
终于翻译完了，自己也学到很多好东西，大家又什么问题可以去gotoAndPlay的官方，也可以来我的Blog提出！
这片HTML文档也可以直接保存（浏览器-文件-另存即可），不含有任何图片，下到本地亦可查看：）
数组
本文节选自本人最近在制作的AS2语法研究报告，供AS爱好者交流，学习，ActionScript数组使用小结
。哪里说得不对或不当，还请指正，谢谢.
数组：
AS2里的数组类型有两个比较牛的地方：
1)数组对象自身可以存放任何数据类型，而不是如C++中的int a[2],char a[3],someClass a[3].
当然，坏处也立刻突现了出来，无法直接创建对象数组。
2)完全的动态数组，使用非常简单，有点像Vector，但同时也更易用出错。这里的动态指的是数组边界的大小(当然，维数还是要声明好的)。
下面是关于数组类型的一些个人认为比较重要点的小结,一些旁枝性的东东都略去了，
哪里少讲了或讲错了什么的话请务必帮我指出一下，大家共同提高：
1
以下声明错误：
var a[1]:Array=new Array;
function test(arr[]:Array):Void
2声明方式1(注，这里的声明方式全部使用强类型声明方式)
var a:Array=new Array();
a[0]=0;
a[1]=1;
trace(a);
//Output
0,1
3声明方式2
var a:Array=new Array(4);
a[4]=1;
trace(a);
//Output
undefined,undefined,undefined,undefined,1
解释：动态数组，用a[4]后长度自动变成5。
4声明方式3
4.1
var b:Array=new Array(0,1,2,3);
trace(b);
0,1,2,3
4.2并不支持这种形式的二维数组的嵌套定义
var b:Array=new Array((1,2),(3,4),(5,6));
trace(b);
trace(b[0]+“ ”+b[1]+“ ”+b[2]+“ ”+b[3]);
trace(b[0][0]);
2,4,6
2 4 6 undefined
undefined
5用[]取代了C++中的{};
声明方式4
var b:Array=[[1,2],[3,4],[5,6]];
trace(b);
trace(b[0]+“ ”+b[1]+“ ”+b[2]+“ ”+b[3]);
trace(b[0][0]);
1,2,3,4,5,6
1,2 3,4 5,6 undefined//用b[0]输出了一个数组行.
1
6二维的维数设定同样是动态的：
var b:Array=[[1,2],[3,4],[5,6]];
b[2][3]=12;
trace(b[2][3]);
//Output
12
7其它的二维数组声明方式：
7.1通过行首参数设定相应的列数.
//
2*3 Array Declare.
var gRowIndex:Number=2;
var gColIndex:Number=3;
var a:Array=new Array(gRowIndex);
for (var i=0;i
{ a[i]=new Array(gColIndex);
for (var j=0;j
{
a[i][j]=String(i)+String(j);
}
}
trace(a);
//Output
00,01,02,10,11,12
8数组作函数为参数的传递.
8.1
var b:Array=new Array(0,1,2,3);
function test(arr:Array):Void
{
trace(arr[0]+“ ”+arr[1]+“ ”+arr[2]+“ ”+arr[3]+“ ”);
}
test(b);
0 1 2 3
8.2
二维数组：
var b:Array=[[1,2],[3,4],[5,6]];
function test(arr:Array):Void
{
trace(arr);
trace(arr[0]+“ ”+arr[1]+“ ”+arr[2]+“ ”+arr[3]+“ ”);
}
test(b);
1,2,3,4,5,6
1,2 3,4 5,6 undefined
8.3
行首参数的传递：
var b:Array=[[1,2],[3,4],[5,6]];
function test(arr:Array):Void
{
trace(arr);
trace(arr[0]+“ ”+arr[1]+“ ”);
}
test(b[0]);
test(b[1]);
test(b[2]);
1,2
1 2
3,4
3 4
5,6
5 6
9更多：
9.1
var gRowIndex:Number=2;
var gColIndex:Number=3;
var a:Array=[[0,1],[3,4,5]];//某个位置空缺某个元素，这里为[0][2]
trace(a);
for (var i=0;i
{
for (var j=0;j
{
trace(a[i][j]);
}
}
0,1,3,4,5
0
1
undefined
3
4
5
9.2动态维数并不支持
var b:Array=[5,6];
b[0][0]=3;
trace(b[0][0]);
//Output
undefined，
9.3一个间接对象数组实现的例子.
var enArray=new Array(3);
// ------ 连接到ENEMY数组 --------- //
for(var j=0;j<3;j++){
attachMovie(“baddie”, “baddie”+j, 200+j);
enArray[j] = _root[“baddie”+j];
enArray[j]._x = 50*j;
enArray[j]._y = 100;
}
9.4
还有很多实际中用得到的例子，比方说，用array 来保存颜色数据，加载图片的变量名等等。
10删除数组元素：
10.1一维：
var p=new Array(1,2,3,4,5);
p.splice(1);
trace(p);
var t=new Array(1,2,3,4,5);
t.splice(2,1);
trace(t);
//Output
1
1,2,4,5
10.2二维情况:
var b:Array=[[1,2],[3,4],[5,6]];
b[0].splice(0);//delete c[0][0] c[0][1]
trace(b);
var c:Array=[[1,2],[3,4],[5,6]];
c[1].splice(1);//c[1][1]
trace(c);
,3,4,5,6
1,2,3,5,6
11长度测试:
var b:Array=[[1,2,2],[3,4],[5,6,4,5]];
trace(b.length);
trace(b[0].length);
trace(b[2].length);
//Output
3
3
4
=========================================================
一个月后的补充：
11动态维数:跟JAVA中一样的.
var arr:Array=new Array(1);
arr[0]=new Array(3);
arr[0][0]=1;
arr[0][1]=2;
arr[0][2]=3;
trace(arr);
trace(arr[0][0]);
trace(arr[0][1]);
trace(arr[0][2]);
1,2,3
1
2
12加载数据的新方式(多重属性):
mData=new Array();
mData.addItem({ label: “二球动量守恒(一维)” ,data:0});
mData.addItem({ label: “三球动量守恒(一维)” ,data:1});
mData.addItem({ label: “多球平面碰撞(二维)”,data:2});
mData.addItem({ label: “子母球”,data:3});
用于配合V2Component中的ComboBox的使用:
_root.menuCombo.dataProvider=mData;
数组
难度:中级软件环境:Flash 5
如果你对数组感性趣的话，那么你也一定了解变量吧，变量是装着数据的容器，数据可以是数字、字符串或者是个布尔值。
数组与变量相似同样是做为数据的容器，但它还能包含更多的数据，每一个元素（数据中的一部分）都被附于一个索引。
数组可以用来保存你的脚本和组织结构，它们通常用来去组织一些在某些方面有些关联的数值，这些数值采用一个索引值
与数组中其它的元素区分开来。你可以用下面这个方法 去定义 3个变量：:
quote1=“Flash is cool!”
quote2=“Flash is my favourite program”
quote3=“Flash rules”
显然有一个更好的方法 去实现上面的例子 那就是 使 用 数组。有很多的方法可以创建 一个数组，但我首先展示的是最简单的方法：
name_of_array=new Array()
所以我们想去引用一个数组的话，就用这个：
quotes=new Array()
很好，现在我们有了一个数组了，但问题是那里面没有任何的数据，它是没有用处的，所以我们现在把数据放到我们的数组里面，我们
用一个索引号码去定义它在数组中的位置。
我们可以用下面的方法 把第一个元素放到数组中：
quotes[0]=“Flash is cool!”
我要说的是在Flash 5中数组索引下标是基于0的，意思是在数组中的第一个元素它的索引值为0。
因此我们可以在我们的数组中的第二个元素中放入一个数据：
quotes[1]=“Flash is my favourite program”
使用如下语法可以添满数组内所有元素：
name_of_array[index]=value
说明：上面的name_of_array是你数组的名子，index是你想要增加到你的数组中数据的位置。
因此我们更早的创建了使用变量的代码：
quote1=“Flash is cool!”
quote2=“Flash is my favourite program”
quote3=“Flash rules”
也可以被写成这样:
quotes=new Array()
quotes[0]=“Flash is cool!”
quotes[1]=“Flash is my favourite program”
quotes[2]=“Flash rules”
我们还可以采有如下的语法去创建：
name_of_array=new Array(“value1”,“value2”,“value3”)
这是一个在一行代码中 实现的，value1 是数组中第一个元素 value2是数组中第二个元素，以此类推。
我们使用如下语法创建我们引用的数组：
quotes=new Array(“Flash is cool!”,“Flash is my favourite program”,“Flash rules”)
现在我们知道该如何创建数组，并且如何去使用，在下面的这个语法中同样可以去创建 一个数姐:
name_of_array=[“value1”,“value2”,“value3”]
这个与前面不同的是 没有使用数组对像（new Array()）
所以我们可以这样创建引用的数组 代码如下：
quotes=[“Flash is cool!”,“Flash is my favourite program”,“Flash rules”]
我不管你用什么方法做做，但我还是喜欢用这最后一个方法去创建数组，它是如此的简单，
现在我们知道 怎么创造数组，但是有时你想在脚本中访问你的数组，嗯 幸运的是还有一种方法可以实现它：
mynewvariable=name_of_array[index]
那么我们想去为一个新的变量附值为数组中第一个元素的值话 请这样做：
firstquote=quotes[0]
这个名为firstquote的新变量值就是“Flash is cool!”
在脚本中数组的实现
设想一下 如果我们想得出数组中所有的元素，但是我们并不知道数组中有多少个元素啊，还好的是Flash中为
数组对像设置了若干属性与方法，其中有一个属性为Length可以得出该数组中元素的个数。
语法如下：
myarraylength=name_of_array.length
上面的这段代码创建了一个新变量，里面的值 就是你所指定的数组对像（name_of_array）元素的个数。
在我们引用数组的情况中，使用下面的代码得到数组中元素的个数：
假如quotes是一个数组的话那么
len=quotes.length 这个len变量 的值 就是该数组的长度
数组的长度等于它的最高索引值加1。最高索引值如果是2的话那么这个数组的长度就是3，也就是说它里面有
3个元素，原因就在于Flash 5中 数组下标是基于0的。
现在我们知道了如何去用数组的Length属性了，采用下面的脚本可以得出数级中所有元素的值。
for(z=0;z
write（name_of_array[z]）
}
让我们逐步来分析一下上面的代码。
首先创建了一个临时的变量 z
z=0
下列的代码是一个循环的条件，当变量z小于数组的元素长度就循环
z
然后 再作变量z的增量 使它本身加1 ；
++z
你可以在这里面放入你需要的代码 它们会被执行（name_of_array.length的值）次
for(z=0;z
...
}
Associative arrays:
关联数组可以提供另一种存储信息的方法，用它你可以实现采用字符串做为数组的下标而不是一个数字，这样会更容易记忆。
这样的不便是在循环中不能被采用，因为它不是一个数值。
关联数组的定义与变通数组是相同的，而唯一不同的是它采用字符串 作为索引下标
请看下面的例子，我们定义一个汽车的数组：
mycars=new Array()
mycars[0]=“peugoet 306”
mycars[1]=“citreon saxo”
mycars[2]=“ford fiesta”
这是关联数组的格式：
mycars=new Array()
mycars[“fast”]=“peugoet 306”
mycars[“sporty”]=“citreon saxo”
mycars[“old”]=“ford fiesta”
用字符做索引值有时会很有用，但当在循环中检索数组是非常的不便。
现在当要得到这种类型数组中的值，你就得用字符串做为索引了，参照上面的例子写出：
mysportycar=mycars[“sporty”]
结果就是变量mysportyca的值 就是“citreon saxo”
如果有任何疑问，请直接于作者联系！mailto:flashguru@flashkit.com在创建交互动画时，你可以使用Flash提供的动作或方法来控制时间轴，可以使用某些动作（Actions）和MovieClip对象的方法(Methods)指向一个电影剪辑或载入某层级的动画，或对它们执行一些任务。例如，setProperty动作可以设置时间轴的某种属性（如_width）为某个值（如100），某些MovieClip对象的方法可以复制指向时间轴的所有动作的功能，还有一些完成其它任务的方法，如hitTest（碰撞测试）和swapDepths（交换深度）等等。不管你使用动作还是方法，当动作或方法被调用时，目标时间轴必须已经载入Flash播放器中。
关于方法与动作
使用方法来控制时间轴，采用的是点语法。你可以通过指定指向实例名的目标路径，接着是一个点，然后指定方法名和参数的方式来调用一种方法。 如下面的语句：
myMovieClip.play;parentClip.childClip.gotoAndPlay(3);
在第一个语句中，play方法使实例myMovieClip播放。在第二个语句中，gotoAndPlay方法把childClip（实例parentClip的一个子剪辑） 电影剪辑的播放头移到第3帧播放。
使用动作控制时间轴，要用一个Target（目标）参数来指定目标路径。例如，在下面的脚本中，startDrag动作指向 customCursor 实例，使它可以拖动。
on(press){ startDrag(“customCursor”);}
如果改用方法，则可以写成：
customCursor.startDrag();
使用MovieClip对象的方法书写的语句更为简短，因为它们不需要tellTarget动作。tellTarget动作与ECMA-262规范不兼容，所以不鼓励使用。
例如，使用MovieClip对象的方法指令电影剪辑myMovieClip开始播放，你可以使用下面的代码：
myMovieClip.play();
如果使用tellTarget动作，就要这样书写：
tellTarget (“myMovieClip”) { play();}
两种方法的效果相同，但前者更为简洁，
这里所列的动作可以指向电影剪辑：loadMovie、unloadMovie、setProperty、 startDrag、 duplicateMovieClip和removeMovieClip。要使用这些动作，你必须在动作的Target（目标）参数中输入目标路径，指明动作的受体。在这些动作中，有些可以指向电影剪辑或层级，有些则只能指向电影剪辑。
下面的MovieClip对象的方法可以控制电影剪辑或载入某层级的动画，且没有等价的动作：attachMovie、getBounds、 getBytesLoaded、getBytesTotal、globalToLocal、localToGlobal、 hitTest和swapDepths。
当一种动作和一种方法均能提供同样的功能时，你可以选择其中一种来控制电影剪辑，这取决于你的喜好和使用ActionScript编写脚本的熟悉程度。
使用多种方法或动作指向时间轴
使用多种方法或动作指向时间轴
你可以使用with 动作对目标电影剪辑编址一次，然后对该剪辑执行一系列动作。 with动作对所有ActionScript对象（如Array、Color和Sound）有效，而不是仅仅对电影剪辑有效。tellTarget动作类似于 with动作。 然而，最好不要使用tellTarget动作，因为它并非对所有的ActionScript对象有效，且与ECMA-262不兼容。
with动作使用对象作为参数。指定的对象被添加到当前目标路径的末尾。嵌套在 with动作内的所有动作在新的目标路径或范围内执行。例如，在下列主时间轴的脚本中， with动作传递对象donut.hole，以改变hole的属性：
with (donut.hole){ _alpha = 20; _xscale = 150; _yscale = 150;}
就好像从hole实例的时间轴中调用with动作内的语句一样。
在下面的例子中，使用with动作和MovieClip对象的方法来发布几个指令：
with (myMovieClip) { _x -= 10; _y += 10; gotoAndPlay(3);}
《编写ActionScript》教学反思
1、教法反思
本节课运用“设置情境”、“任务驱动”、“小组协作”、“老师演示”等教学法，任务明确、可行、并且层次不同，老师布置学习任务后，小组成员积极参与，把主动权交给学生，整个教学过程成为师生交流、生生交流、积极互动的过程，确定了学生的`课堂主体地位，对激发学生使用信息技术的兴趣是非常有利的。
2、学法反思
学生在任务的驱动下，自主探究，小组成员互助学习，培养了学生自主学习能力和团队协作精神。
3、教学收获
本节课本人运用了知识迁移法，把本章节教材中相关知识之间建立联系，用已有的知识、技能去学习掌握新的知识、技能。教学中，本人开展以教师为主导，学生为主体的自主探究学习模式，让学生依靠自己已有的知识和经验去自主学习探索，充分发挥学生的潜能，对学习任务进行探索、分析、研究，在实践操作中培养创新精神和创造能力，提高学生总体的信息素养。 上完本节课后，本人发现学生的潜力很大，积极性很高，大部分学生能完成探究任务，作品能体现学生的创造力和个性表现力。但还有部分同学习惯于依赖老师与教材，本人在今后的教学中还应加强指导和引导。
★ 外贸术语
★ 主板术语
★ 汽车术语
★ 商务英语经济术语
★ 常用法律术语
★ 贸易术语名词解释
