Flash ActionScript 3.0 语言和组件参考（语句、关键字和指令）

语句是在运行时执行或指定动作的语言元素。例如，return 语句会为执行该语句的函数返回一个结果。if 语句对条件进行计算，以确定应采取的下一个动作。switch 语句创建 ActionScript 语句的分支结构。
属性关键字更改定义的含义，可以应用于类、变量、函数和命名空间定义。定义关键字用于定义实体，例如变量、函数、类和接口。主表达式关键字表示文本值。若要获得保留字的列表，请参见《ActionScript 3.0 编程》。
指令包含语句和定义，在编译时或运行时起作用。下表中将既不是语句也不是定义的指令标记为指令。
语句
break
出现在循环（for、for..in、for each..in、do..while 或 while）内，或出现在与 switch 语句中的特定情况相关联的语句块内。
case
定义 switch 语句的跳转目标。
continue
跳过最内层循环中所有其余的语句并开始循环的下一次遍历，就像控制正常传递到了循环结尾一样。
default
定义 switch 语句的默认情况。
do..while
与 while 循环类似，不同之处是在对条件进行初始计算前执行一次语句。
else
指定当 if 语句中的条件返回 false 时要运行的语句。
for
计算一次 init（初始化）表达式，然后开始一个循环序列。
for..in
遍历对象的动态属性或数组中的元素，并对每个属性或元素执行 statement。
for each..in
遍历集合的项目，并对每个项目执行 statement。
if
计算条件以确定下一条要执行的语句。
label
将语句与可由 break 或 continue 引用的标识符相关联。
return
导致立即返回执行调用函数。
super
调用方法或构造函数的超类或父版本。
switch
根据表达式的值，使控制转移到多条语句的其中一条。
throw
生成或抛出（使用 throw 语句）一个可由 catch 代码块处理或捕获的错误。
try..catch..finally
包含一个代码块，在其中可能会发生错误，然后对该错误进行响应。
while
计算一个条件，如果该条件的计算结果为 true，则会执行一条或多条语句，之后循环会返回并再次计算条件。
with
建立要用于执行一条或多条语句的默认对象，从而潜在地减少需要编写的代码量。
属性关键字
dynamic
指定类的实例可具有在运行时添加的动态属性。
final
指定不能覆盖方法或者不能扩展类。
internal
指定类、变量、常量或函数可用于同一包中的任何调用者。
native
指定函数或方法由 Flash Player 以本机代码的形式实现。
override
指定用一种方法替换继承的方法。
private
指定变量、常量、方法或命名空间仅可供定义它的类使用。
protected
指定变量、常量、方法或命名空间只可用于定义它的类及该类的任何子类。
public
指定类、变量、常量或方法可用于任何调用者。
static
指定变量、常量或方法属于类，而不属于类的实例。
定义关键字
... (rest) parameter
指定函数将接受任意多个以逗号分隔的参数。
class
定义一个类，它允许实例化共享您定义的方法和属性的对象。
const
指定一个常量，它是只能赋值一次的变量。
extends
定义一个作为其它类的子类的类。
function
包含为执行特定任务而定义的一组语句。
get
定义一个 getter，它是一种可像属性一样读取的方法。
implements
指定一个类可实现一个或多个接口。
interface
定义接口。
namespace
允许您控制定义的可见性。
package
允许您将代码组织为可由其它脚本导入的离散组。
set
定义一个 setter，它是一种在公共接口中作为属性出现的方法。
var
指定一个变量。
指令
default xml namespace
default xml namespace 指令可将默认的命名空间设置为用于 XML 对象。
import
使外部定义的类和包可用于您的代码。
include
包括指定文件的内容，就像该文件中的命令是调用脚本的一部分一样。
use namespace
使指定的命名空间添加到打开的命名空间集中。
命名空间
AS3
定义核心 ActionScript 类的方法和属性，将其作为固定属性而非原型属性。
flash_proxy
定义 Proxy 类的方法。
object_proxy
定义 ObjectProxy 类的方法。
主表达式关键字
false
表示 false 的布尔值。
null
一个可以分配给变量的或由未提供数据的函数返回的特殊值。
this
对方法的包含对象的引用。
true
表示 true 的布尔值。
语句、关键字和指令详细信息
用法
... (rest) parameter
definition keyword
function functionName(parameter0, parameter1, ...rest){
// 语句
}
指定函数将接受任意多个以逗号分隔的参数。参数列表成为了在整个函数体中可用的数组。在参数声明中，数组的名称在 ... 字符后指定。参数可以拥有保留字以外的任意名称。
如果与其它参数共同使用，则 ...（其余的）参数声明必须是最后指定的参数。只有传递给函数的参数数目超过其它参数的数目时，才会填充 ...（其余的）参数数组。
逗号分隔参数列表中的每一个参数都将放置在该数组的一个元素中。如果您传递了 Array 类的实例，则整个数组会放置到 ...（其余的）参数数组的单个元素中。
使用此参数会使 arguments 对象不可用。尽管 ...（其余的）参数提供了与 arguments 数组和 arguments.length 属性相同的功能，但是未提供与由 arguments.callee 提供的功能类似的功能。使用 ...（其余的）参数之前，请确保不需要使用 arguments.callee。
参数
示例
如何使用示例 
下例在两个不同函数中使用...（其余的）参数。第一个函数 traceParams 只对 rest 数组中每一个参数调用 trace() 函数。第二个函数 average() 调用参数列表并返回平均值。第二个函数还使用了该参数的其它名称 args。
package {
import flash.display.MovieClip;
public class RestParamExample extends MovieClip {
public function RestParamExample() {
traceParams(100, 130, "two"); // 100,130,two
trace(average(4, 7, 13));     // 8
}
}
}
function traceParams(... rest) {
trace(rest);
}
function average(... args) : Number{
var sum:Number = 0;
for (var i:uint = 0; i < args.length; i++) {
sum += args[i];
}
return (sum / args.length);
}
另请参见 arguments object
语言版本:
ActionScript 3.0
定义核心 ActionScript 类的方法和属性，将其作为固定属性而非原型属性。在将“-as3”编译器选项设置为 true 时， (which is the default setting in Flex Builder 2)将为所有核心类自动打开 AS3 命名空间。这意味着核心类的单个实例将使用固定的属性和方法，而不是使用同一属性和方法附加到此类的原型对象上的版本。使用固定属性通常可以提供更好的性能，但将无法向后兼容 ECMAScript 第 3 版语言规范 (ECMA-262)。
另请参见 Object class
运行时版本:
Flash Player 9
用法
rest:* — 标识符表示传递至函数的参数数组的名称。不需要将参数命名为 rest；它可以具有不同于关键字的任意名称。可以将 ...(rest) 参数的数据类型指定为 Array，但是这样可能会产生混淆，因为该参数可接受逗号分隔值列表，该列表与 Array 类的实例不同。
AS3
namespace
出现在循环（for、for..in、for each..in、do..while 或 while）内，或出现在与 switch 语句中的特定情况相关联的语句块内。当在循环中使用时，break 语句指示 Flash 跳过循环体的其余部分，停止循环动作，并执行循环语句后面的语句。在 switch 中使用 break 语句时，该语句将指示 Flash 跳过此 case 块中的其余语句，并跳到包含它的 switch 语句后面的第一个语句。
在嵌套循环中，break 语句只跳过当前循环的其余部分，而不是中断整个系列的嵌套循环。若要中断整个系列的嵌套循环，请使用 label 或 try..catch..finally。
break 语句可以具有可选标签，该标签必须与外部标记语句相匹配。使用与外部语句的标签不匹配的标签是一种语法错误。可以使用标记的 break 语句中断多层嵌套循环语句、switch 语句，或 block 语句。有关示例，请参见 label 语句条目。
参数
break
statement
示例
如何使用示例 
下例使用 break 以退出一个循环（如果没有该语句，该循环为无限循环）：
var i:int = 0;
while (true) {
trace(i);
if (i >= 10) {
break; // this will terminate/exit the loop
}
i++;
}
/*
0
1
2
3
4
5
6
7
8
9
10*/
另请参见
do..while
for
for..in
for each..in
label
while
break [label]
用法
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
定义 switch 语句的跳转目标。如果 jumpTarget 参数等于使用全等运算符 (===) 的 switch 语句的 expression 参数，则 Flash Player 将执行 statements 参数中的语句，直到遇到一个 break 语句或直到 switch 语句结束。
如果在 switch 语句外部使用 case 语句，会产生错误，而且脚本不能编译。
注意：在 statements 参数的结尾应始终使用 break 语句。如果省略 statements 参数中的 break 语句，则 Flash Player 会继续执行下一条 case 语句，而不是退出 switch 语句。
参数
label:* — 与语句关联的标签名称。
case
statement
示例
如何使用示例 
下例定义了 switch 语句 thisMonth 的跳转目标。如果 thisMonth 等于 case 语句中的表达式，则执行该语句。
var thisMonth:int = new Date().getMonth();
switch (thisMonth) {
case 0 :
trace("January");
break;
case 1 :
trace("February");
break;
case 5 :
case 6 :
case 7 :
trace("Some summer month");
break;
case 8 :
trace("September");
break;
default :
trace("some other month");
}
另请参见
break
switch
用法
case jumpTarget: statements
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
定义一个类，它允许实例化共享您定义的方法和属性的对象。例如，如果您正开发一个发票跟踪系统，则可以创建一个 Invoice 类，它定义每个发票应具有的所有方法和属性。然后您可以使用 new Invoice() 命令来创建 Invoice 对象。
每个 ActionScript 源文件只能包含一个对其它源文件或脚本可见的类。外部可见的类可以是公共类或内部类，必须在包语句内定义。如果在同一个文件中包括其它类，则该类必须放在包语句之外、文件结尾处。
外部可见的类的名称必须与包含该类的 ActionScript 源文件的名称匹配。源文件名称必须是类的名称加上文件扩展名 .as。例如，如果您将一个类命名为 Student，则定义该类的文件必须被命名为 Student.as。
您不能嵌套类定义；即，不能在一个类定义内定义其它类。
可以定义构造函数方法，每次创建该类的新实例时执行该方法。该构造函数方法的名称必须与类的名称匹配。如果未定义构造函数方法，则为您创建一个默认的构造函数。
若要表示对象可在运行时添加和访问动态属性，请在 class 语句前面放置 dynamic 关键字。若要声明一个类实现一个接口，请使用 implements 关键字。若要创建一个类的子类，请使用 extends 关键字。（某一类只能扩展一个类，但可以实现多个接口。）您可以在一个语句中使用 implements 和 extends。下面的示例将说明 implements 和 extends 关键字的典型用法：
class C implements Interface_i, Interface_j // OK
class C extends Class_d implements Interface_i, Interface_j // OK
class C extends Class_d, Class_e // not OK
参数
jumpTarget:* — 任何表达式。
statements:* — 如果 jumpTarget 和 switch 语句中的条件表达式匹配，则执行语句。
示例
如何使用示例 
下面的示例创建一个名为 Plant 的类。Plant 构造函数采用两个参数。
// Filename Plant.as
package {
public class Plant {
// Define property names and types
private var _leafType:String;
private var _bloomSeason:String;
// Following line is constructor
// because it has the same name as the class
public function Plant(param_leafType:String, param_bloomSeason:String) {
// Assign passed values to properties when new Plant object is created
_leafType = param_leafType;
_bloomSeason = param_bloomSeason;
}
// Create methods to return property values, because best practice
// recommends against directly referencing a property of a class
public function get leafType():String {
return _leafType;
}
public function get bloomSeason():String {
return _bloomSeason;
}
}
}
在脚本中，使用 new 运算符来创建一个 Plant 对象。
var pineTree:Plant = new Plant("Evergreen", "N/A");
// Confirm parameters were passed correctly
trace(pineTree.leafType);
trace(pineTree.bloomSeason);
另请参见
dynamic
extends
final
internal
public
用法
class
definition keyword
[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] {
// 此处是类定义
}
指定一个常量，它是只能赋值一次的变量。
附加后跟数据类型的 colon (:) 字符可以严格指定常量的类型。
参数
示例
如何使用示例 
下例说明，如果尝试多次为一个常量赋值将发生错误。
const MIN_AGE:int = 21;
MIN_AGE = 18; // error
下例说明，如果常量是一个数组，仍然可以调用 Array 类方法，包括 Array.push()。但是无法分配新数组文本。
const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze");
product_array.push("Flex"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array);
另请参见
var
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
className:Class — 类的完全限定名称。
const
definition keyword
跳过最内层循环中的所有剩余语句并开始循环的下一次遍历，就像控制正常传递到了循环结尾一样。continue 语句在循环外不起作用。在嵌套循环中，使用可选的 label 参数以跳过最内层以内的循环。
continue 语句可以具有可选标签，该标签必须与外部标记语句相匹配。使用与外部语句的标签不匹配的标签是一种语法错误。使用标记的 continue 语句可以跳过多层嵌套循环语句。
示例
如何使用示例 
在下面的 while 循环中，continue 语句用于遇到 3 的整数倍时跳过循环体的其余部分，并跳转到循环的顶端（在该处进行条件测试）：
var i:int = 0;
while (i < 10) {
if (i % 3 == 0) {
i++;
continue;
}
trace(i);
i++;
}
在 for 循环中，还可以使用 continue 语句以跳过循环体的其余部分。在下例中，如果 i % 3 等于 0，则跳过 trace(i) 语句：
for (var i:int = 0; i < 10; i++) {
if (i % 3 == 0) {
continue;
}
trace(i);
}
另请参见
do..while
for
for..in
for each..in
label
while
用法
const identifier = value
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
定义 switch 语句的默认情况。如果 switch 语句的 expression 参数不等于（使用全等运算符 [===]）给定 switch 语句的 case 关键字后的任何 expression 参数，则执行这些语句。
switch 语句不需要 default case 语句。default case 语句也不一定要出现在列表的最后。如果在 switch 语句外使用 default 语句，将会产生错误，并且脚本不能编译。
参数
示例
如何使用示例 
在下例中，如果某天是星期六或星期日，则不调用任何 case 语句，因此将转为执行 default 语句。
var dayOfWeek:int = new Date().getDay();
switch (dayOfWeek) {
case 1 :
trace("Monday");
break;
case 2 :
trace("Tuesday");
break;
case 3 :
trace("Wednesday");
break;
case 4 :
trace("Thursday");
break;
case 5 :
trace("Friday");
break;
default :
trace("Weekend");
}
另请参见
switch
identifier:* — 常量的标识符。
用法
continue
statement
continue [label]
default xml namespace 指令可将默认的命名空间设置为用于 XML 对象。
如果未设置 default xml namespace，则默认命名空间是未命名的命名空间（当 URI 设置为空字符串时）。default xml namespace 声明的作用域在函数块内，类似于变量的作用域。
示例
如何使用示例 
下例说明 default xml namespace 的作用域是函数块：
var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;
var x1:XML = ;
trace("x1 ns: " + x1.namespace());
scopeCheck();
var x2:XML = ;
trace("x2 ns: " + x2.namespace());
function scopeCheck(): void {
var x3:XML = ;
trace("x3 ns: " + x3.namespace());
var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
default xml namespace = nsDefault2;
var x4:XML = ;
trace("x4 ns: " + x4.namespace());
}
以下是本示例 trace() 的输出：
x1 ns: http://www.example.com/namespaces/
x3 ns:
x4 ns: http://schemas.xmlsoap.org/soap/envelope/
x2 ns: http://www.example.com/namespaces/
下例使用 default xml namespace 来分配默认的命名空间。因为第二个 XML 对象 (x2) 定义了自己的默认命名空间，所以 x2 未使用此设置：
var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;
var x1:XML = ;
trace(x1.namespace());
// http://www.example.com/namespaces/
var x2:XML = ;
trace(x2.namespace());
// http://www.w3.org/1999/XSL/Transform/
var x3:XML = ;
trace(x3.namespace());
// http://www.example.com/namespaces/
另请参见
namespace
Namespace Class
use namespace
XML
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
default
statement
与 while 循环类似，不同之处是在对条件进行初始计算前执行一次语句。随后，仅当条件计算结果是 true 时执行语句。
do..while 循环确保循环内的代码至少执行一次。尽管这也可以通过使用 while 循环在 while 循环开始前放置要执行的语句的副本来实现，但很多程序员认为 do..while 循环更易于阅读。
如果条件计算结果始终为 true，do..while 就会无限循环。如果进入了无限循环，则 Flash Player 会遇到问题，最终会发出警告信息，或播放器崩溃。如果知道要循环的次数，应该尽可能使用 for 循环。尽管 for 循环易于阅读和调试，但不是在所有情况下都能代替 do..while 循环。
参数
default: statements
示例
如何使用示例 
下例使用 do..while 循环以计算条件是否为 true，并跟踪 myVar 直到 myVar 大于等于 5。myVar 大于等于 5 时，循环结束。
var myVar:Number = 0;
do {
trace(myVar);
myVar++;
}
while (myVar < 5);
/*
0
1
2
3
4
*/
另请参见
break
continue
while
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
statements:* — 任何语句。
指定类的实例可具有在运行时添加的动态属性。如果在对类使用 dynamic 特性，可以在运行时向该类的实例添加属性。将未标记为 dynamic 的类视为密封的，这意味着无法向该类的实例添加属性。
如果类是密封的（非动态），尝试在类实例上获得属性或设置属性将导致错误。创建实例时，如果将编译器设置为严格模式并指定数据类型，尝试向密封的对象添加属性将导致编译器错误；否则，将发生运行时错误。
dynamic 属性不是由子类继承。如果扩展了动态类，则只有声明该子类具有 dynamic 属性时，子类才是动态的。
注意：仅支持在外部脚本文件中使用此关键字，而不支持在用“动作”面板编写的脚本中使用此关键字。
示例
如何使用示例 
下例创建了两个类，一个是命名为 Expando 的动态类，另一个是命名为 Sealed 的密封类，将在随后的示例中使用它们。
package {
dynamic class Expando  {
}
class Sealed {
}
}
以下代码创建 Expando 类的实例，并说明可以向该实例添加属性。
var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // new
以下代码创建 Sealed 类的实例，并说明尝试添加属性将导致错误。
var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error
另请参见
class
default xml namespace
directive
用法
default xml namespace = ns
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
do..while
statement
指定当 if 语句中的条件返回 false 时要运行的语句。如果仅执行一条语句，则无需使用花括号 ({}) 来括起要由 else 语句执行的语句。
参数
示例
如何使用示例 
在下面的示例中，else 条件用于检查 age_txt 变量是大于还是小于 18：
if (age_txt.text>=18) {
trace("welcome, user");
}
else {
trace("sorry, junior");
userObject.minor = true;
userObject.accessAllowed = false;
}
在下面的示例中，花括号 ({}) 是不必要的，因为 else 语句后面只有一条语句：
if (age_txt.text>18) {
trace("welcome, user");
}
else trace("sorry, junior");
下例使用 if 和 else 语句的组合来对 score_txt 和特定的值进行比较：
if (score_txt.text>90) {
trace("A");
}
else if (score_txt.text>75) {
trace("B");
}
else if (score_txt.text>60) {
trace("C");
}
else {
trace("F");
}
另请参见
if
do { statement(s) } while (condition)
用法
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
condition:Boolean — 要计算的条件。只要 condition 参数的计算结果为 true，就会执行 do 代码块内的 statement(s)。
定义一个作为其它类的子类的类。子类继承超类中定义的所有方法、属性、函数等。无法扩展标记为 final 的类。
也可以使用 extends 关键字来扩展接口。扩展另一个接口的接口包含原始接口的所有方法声明。
注意：若要使用此关键字，必须在 FLA 文件的“发布设置”对话框的“Flash”选项卡中指定 ActionScript 2.0 和 Flash Player 6 或更高版本。仅支持在外部脚本文件中使用此关键字，而不支持在用“动作”面板编写的脚本中使用此关键字。
参数
示例
如何使用示例 
在下面的示例中，Car 类扩展 Vehicle 类，以继承其所有方法、属性和函数。如果您的脚本对 Car 对象进行实例化，则来自 Car 类的方法和来自 Vehicle 类的方法都可以使用。
下面的示例显示名为 Vehicle.as 的文件（它定义 Vehicle 类）的内容：
package {
class Vehicle {
var numDoors:Number;
var color:String;
public function Vehicle(param_numDoors:Number = 2, param_color:String = null) {
numDoors = param_numDoors;
color = param_color;
}
public function start():void {
trace("[Vehicle] start");
}
public function stop():void {
trace("[Vehicle] stop");
}
public function reverse():void {
trace("[Vehicle] reverse");
}
}
}
下例说明同一目录中名为 Car.as 的第二个 ActionScript 文件。此类扩展 Vehicle 类，通过三种方式修改它。第一种是 Car 类添加变量 fullSizeSpare 以跟踪 car 对象是否具有标准尺寸的备用轮胎。第二种是它添加特定于汽车的新方法 activateCarAlarm()，该方法用于激活汽车的防盗警报。第三种是它覆盖 stop() 函数以添加 Car 类使用防抱死制动系统来停车的事实。
package {
public class Car extends Vehicle {
var fullSizeSpare:Boolean;
public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) {
numDoors = param_numDoors;
color = param_color;
fullSizeSpare = param_fullSizeSpare;
}
public function activateCarAlarm():void {
trace("[Car] activateCarAlarm");
}
public override function stop():void {
trace("[Car] stop with antilock brakes");
}
}
}
下面的示例对 Car 对象进行实例化，调用在 Vehicle 类中定义的方法 (start())，然后调用由 Car 类覆盖的方法 (stop())，最后从 Car 类调用一个方法 (activateCarAlarm())：
var myNewCar:Car = new Car(2, "Red", true);
myNewCar.start(); // [Vehicle] start
myNewCar.stop(); // [Car] stop with anti-lock brakes
myNewCar.activateCarAlarm(); // [Car] activateCarAlarm
使用 super 语句也可以编写 Vehicle 类的子类，此子类可以使用该语句访问超类的构造函数。下例显示第三个 ActionScript 文件，该文件名为 Truck.as，也在同一目录中。在构造函数和覆盖的 reverse() 方法中，Truck 类使用 super。
package {
class Truck extends Vehicle {
var numWheels:Number;
public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) {
super(param_numDoors, param_color);
numWheels = param_numWheels;
}
public override function reverse():void {
beep();
super.reverse();
}
public function beep():void {
trace("[Truck] make beeping sound");
}
}
}
下面的示例对 Truck 对象进行实例化，调用由 Truck 类覆盖的方法 (reverse())，然后调用在 Vehicle 类中定义的方法 (stop())：
var myTruck:Truck = new Truck(2, "White", 18);
myTruck.reverse(); // [Truck] make beeping sound [Vehicle] reverse
myTruck.stop(); // [Vehicle] stop
另请参见
class
final
interface
dynamic
attribute keyword
用法
dynamic class className { // 此处是类定义 }
语言版本:
ActionScript 3.0
表示 false 的布尔值。布尔值为 true 或 false；false 与 true 相反。
如果自动设置数据类型时将 false 转换为数字，则它变为 0；如果自动设置数据类型时将 false 转换为字符串，则它变为 "false"。
注意：字符串 "false" 转换为布尔值 true。
示例
如何使用示例 
此示例说明自动设置数据类型如何将 false 转换为数字以及转换为字符串：
var bool1:Boolean = Boolean(false);
// converts it to the number 0
trace(1 + bool1); // outputs 1
// converts it to a string
trace("String: " + bool1); // outputs String: false
下例说明字符串 "false" 转换为布尔值 true：
trace(Boolean("false")); // true
if ("false") {
trace("condition expression evaluated to true");
}
else {
trace("condition expression evaluated to false");
}
// condition expression evaluated to true
另请参见
Boolean class
true
运行时版本:
Flash Player 9
用法
else
statement
if (condition) {
// 语句
}
else {
// 语句
}
指定不能覆盖方法或者不能扩展类。尝试覆盖方法或扩展类，并标记为 final 将导致错误。
参数
语言版本:
ActionScript 3.0
另请参见
override
extends
运行时版本:
Flash Player 9
定义 Proxy 类的方法。Proxy 类方法位于自己的命名空间内，这是为了避免在 Proxy 子类包含与任一 Proxy 类方法名称相匹配的实例方法名称时发生名称冲突。
另请参见
Proxy class
condition:Boolean — 计算结果为 true 或 false 的表达式。
用法
extends
definition keyword
class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {}
语言版本:
ActionScript 3.0
计算一次 init（初始化）表达式，然后开始一个循环序列。循环序列从计算 condition 表达式开始。如果 condition 表达式的计算结果为 true，将执行 statement 并计算 next 表达式。然后循环序列再次从计算 condition 表达式开始。
如果只执行一条语句，则无需使用花括号 ({}) 来括起要由 for 语句执行的语句。
参数
运行时版本:
Flash Player 9
className:Class — 您所定义的类的名称。
示例
如何使用示例 
下面的示例使用 for 在数组中添加元素：
var my_array:Array = new Array();
for (var i:Number = 0; i < 10; i++) {
my_array[i] = (i + 5) * 10;
}
trace(my_array); // 50,60,70,80,90,100,110,120,130,140
下面的示例使用 for 重复执行相同的动作。在代码中，for 循环将从 1 到 100 的数字相加。
var sum:Number = 0;
for (var i:Number = 1; i <= 100; i++) {
sum += i;
}
trace(sum); // 5050
下例说明，在仅执行一条语句时无需使用花括号 ({})：
var sum:Number = 0;
for (var i:Number = 1; i <= 100; i++)
sum += i;
trace(sum); // 5050
另请参见
++ (increment)
false
primary expression keyword
用法
false
语言版本:
ActionScript 3.0
遍历对象的动态属性或数组中的元素，并对每个属性或元素执行 statement。对象属性不按任何特定的顺序保存，因此属性看似以随机的顺序出现。固定属性，例如在类中定义的变量和方法，不能由 for..in 语句来枚举。若要获得固定属性列表，请使用 flash.utils 包中的 describeType() 函数。
参数
运行时版本:
Flash Player 9
示例
如何使用示例 
下面的示例使用 for..in 遍历对象的属性：
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"};
for (var prop in myObject) {
trace("myObject."+prop+" = "+myObject[prop]);
}
/*
myObject.firstName = Tara
myObject.age = 27
myObject.city = San Francisco
*/
下面的示例将 typeof 运算符与 for..in 结合使用以迭代特定类型的子级：
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"};
for (var name in myObject) {
if (typeof (myObject[name]) == "string") {
trace("I have a string property named "+name);
}
}
/*
I have a string property named city
I have a string property named firstName
*/
另请参见
describeType()
final
attribute keyword
用法
final function methodName() {
// 此处是您的语句
}
final class className {}
语言版本:
ActionScript 3.0
遍历集合的项目，并对每个项目执行 statement。for each..in 语句作为 E4X 语言扩展的一部分引入，不仅可以用于 XML 对象，而且可以用于对象和数组。for each..in 语句仅遍历对象的动态属性，而不是固定属性。固定属性是指定义为类定义的一部分的属性。若要使用具有用户自定义类的实例的 for each..in 语句，则必须声明具有 dynamic 属性的类。
与 for..in 语句不同，for each..in 语句将遍历对象属性的值，而不是属性的名称。
参数
运行时版本:
Flash Player 9
示例
如何使用示例 
下例使用 for each..in 遍历对象的属性具有的值：
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"};
for each (var item in myObject) {
trace(item);
}
/*
Tara
27
San Francisco
*/
下面的示例使用 for each..in 遍历数组的元素：
var myArray:Array = new Array("one", "two", "three");
for each(var item in myArray)
trace(item);
/*
one
two
three
*/
下面的示例将 is 运算符与 for each..in 结合使用以迭代特定类型的子级：
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"};
for each (var item in myObject) {
if (item is String) {
trace("I have a string property with value " + item);
}
}
/*
I have a string property with value Tara
I have a string property with value San Francisco
*/
下例说明使用 for each..in 遍历 XMLList 对象中的属性 (doc.p)：
var doc:XML =

Hello

Hola

Bonjour

;
for each (var item in doc.p) {
trace(item);
}
/*
Hello
Hola
Bonjour
*/
methodName:Function — 无法覆盖的方法的名称。
className:Class — 无法扩展的类的名称。
用法
flash_proxy
namespace
for
statement
for ([init]; [condition]; [next]) {
// 语句
}
包含为执行特定任务而定义的一组语句。可以在 SWF 文件的一个地方定义函数，然后从 SWF 文件的其它脚本中调用它。定义函数时，还可以为其指定参数。参数是函数要对其进行操作的值的占位符。可以在每次调用一个函数时传递不同的参数，这样就可将一个函数重复用于不同的情况。
在一个函数的 statement(s) 块中使用 return 语句，以生成函数或返回 一个值。
用法 1：可以使用 function 关键字来定义具有特定函数名称、参数和语句的函数。当脚本调用函数时，就会执行函数定义中的语句。允许提前引用；在同一脚本中，函数可以先调用后声明。一个函数定义会替换同一函数先前的任何定义。只要是允许使用语句的地方就可使用此语法。
用法 2：您也可以使用 function 来创建匿名函数并返回对它的引用。此语法用于表达式中，对于在对象中安装方法尤其有用。
若需要其它功能，可以在函数定义中使用 arguments 对象。通常使用 arguments 对象来创建一个接受可变数量的参数的函数和递归的匿名函数。
参数
语言版本:
ActionScript 3.0
示例
如何使用示例 
下例定义了函数 sqr，此函数将返回数字的平方值：
function sqr(xNum:Number) {
return Math.pow(xNum, 2);
}
var yNum:Number = sqr(3);
trace(yNum); // 9
如果在同一脚本中定义和使用函数，使用该函数后可出现函数定义：
var yNum:Number = sqr(3);
trace(yNum); // 9
function sqr(xNum:Number) {
return Math.pow(xNum, 2);
}
另请参见
arguments object
return
运行时版本:
Flash Player 9
用法
init — 在开始循环序列前要计算的可选表达式，通常为赋值表达式。还允许对此参数使用 var 语句。
condition — 在开始循环序列前要计算的可选表达式，通常为比较表达式。如果表达式的计算结果为 true，则执行与 for 语句相关联的语句。
next — 循环序列后要计算的可选表达式，通常是递增或递减表达式。
定义一个 getter，它是一种可像属性一样读取的方法。getter 是一个特殊的函数，它将返回使用 var 或 const 关键字声明的属性的值。与其它的方法不同，调用 getter 时不使用括号 (())，这样 getter 看起来就像是变量。
通过允许创建私有属性的公共接口，getter 允许您应用信息隐藏规则。信息隐藏的好处是：即使私有属性的基础实现发生更改，公共接口也会保持不变。
getter 的另一个优点是它们可在子类中覆盖，而使用 var 或 const 声明的属性则不能。
可结合使用 getter 和 setter 创建读写属性。要创建只读属性，请创建一个没有对应 setter 的 getter。要创建只写属性，请创建一个没有对应 getter 的 setter。
注意：若要使用此关键字，必须在 FLA 文件的“发布设置”对话框的“Flash”选项卡中指定 ActionScript 2.0 和 Flash Player 6 或更高版本。仅支持在外部脚本文件中使用此关键字，而不支持在用“动作”面板编写的脚本中使用此关键字。
参数
for..in
statement
示例
如何使用示例 
下例定义 Team 类。Team 类包括用于在该类内检索和设置属性的 getter 和 setter 方法：
package {
public class Team {
var teamName:String;
var teamCode:String;
var teamPlayers:Array = new Array();
public function Team(param_name:String, param_code:String) {
teamName = param_name;
teamCode = param_code;
}
public function get name():String {
return teamName;
}
public function set name(param_name:String):void {
teamName = param_name;
}
}
}
在脚本中输入下面的代码：
var giants:Team = new Team("San Fran", "SFO");
trace(giants.name);
giants.name = "San Francisco";
trace(giants.name);
/*
San Fran San Francisco */
在跟踪 giants.name 时，使用 getter 方法以返回属性的值。
另请参见
set
for (variableIterant:String in object){
// 语句
}
用法
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
计算条件以确定下一条要执行的语句。如果条件为 true，则 Flash Player 将运行花括号 ({}) 内条件后面的语句。如果条件为 false，则 Flash Player 将跳过花括号内的语句，并运行花括号后面的语句。将 if 语句与 else 语句一起使用，以在脚本中创建分支逻辑。
如果仅执行一条语句，则无需使用花括号 ({}) 来括起要由 if 语句执行的语句。
参数
variableIterant:String — 要作为迭代变量的变量的名称，迭代变量引用对象的每个属性或数组中的每个元素。
另请参见
else
for each..in
statement
用法
for each (variableIterant in object){
// 语句
}
语言版本:
ActionScript 3.0
指定一个类可实现一个或多个接口。当类实现一个接口时，此类必须定义在该接口中声明的所有方法。将所有实现接口的类的实例视为由接口定义的数据类型的成员。因此，第一个操作数是类实例且第二个操作数是接口时，is 运算符将返回 true；此外，接口操作将定义来自和施于数据类型的类型强制。
注意：若要使用此关键字，必须在 FLA 文件的“发布设置”对话框的“Flash”选项卡中指定 ActionScript 2.0 和 Flash Player 6 或更高版本。仅支持在外部脚本文件中使用此关键字，而不支持在用“动作”面板编写的脚本中使用此关键字。
另请参见
class
interface
运行时版本:
Flash Player 9
用法
variableIterant:* — 要作为迭代变量的变量的名称引用集合中的项。
object:Object — 要遍历的集合的名称。集合可以是 XML 对象、通用对象或数组。
使外部定义的类和包可用于您的代码。例如，如果希望在脚本中使用 flash.display.Sprite 类，则必须导入它。此要求与 ActionScript 的先前版本不同，在这些版本中 import 指令是可选的。
使用 import 指令后，可以使用完整的类名称，此名称包含包名称，或只是类的名称。
import flash.display.Sprite;
// name of class only
var mySprite:Sprite = new Sprite();
// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();
如果要访问的包中有多个类，可以用一条语句将它们全部导入，如下例所示：
import flash.display.*;
import 指令仅导入类、函数和位于导入包顶级的变量。必须显式导入嵌套包。
如果导入一个类，但没有在脚本中使用该类，则该类不作为 SWF 文件的一部分导出。这意味着您导入大型包时可以不必担心 SWF 文件的大小；只有在实际使用某一类的情况下，才会在 SWF 文件中包括与该类关联的字节码。导入类的一个缺点是将增加名称冲突的可能性。
import 指令将应用于在其中调用该指令的整个时间轴。例如，假设您在某个 Flash 文档的第 1 帧上导入了 adobe.example 包中的所有类。那么，对于该帧或时间轴的任何后续帧，都可以使用相应的简单类名来引用该包中的类。
// 在 FLA 的第一帧上：
导入 adobe.example.*；
var myFoo:foo = new foo();
参数
function
definition keyword
function functionName([parameter0, parameter1,...parameterN]) : returnType{
// 语句
}
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{
// 语句
}
用法
包括指定文件的内容，就像该文件中的命令是调用脚本的一部分一样。include 指令在编译时调用。因此，如果对包含的文件进行了任何更改，则必须保存该文件，并重新编译使用它的任何 SWF 文件。
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
functionName:Function — 新函数的名称。
returnType:* — 返回值的数据类型。
定义接口。接口是定义一个方法组的数据类型，其中的方法必须由实现接口的任何类定义。
接口与类相似，但也有以下重要差异：
· 接口仅包含方法的声明，而不包含其实现。也就是说，实现接口的每个类必须为该接口中声明的每个方法提供实现。
· 接口方法定义无法具有任何属性，例如 public 或 private，但是在实现接口的类的定义中，实现的方法必须标记为 public。
· 多个接口可以通过 extends 语句由接口继承，或通过 implements 语句由类继承。
与 ActionScript 2.0 不同，ActionScript 3.0 允许在接口定义中使用 getter 和 setter 方法。
注意：若要使用此关键字，必须在 FLA 文件的“发布设置”对话框的“Flash”选项卡中指定 ActionScript 2.0 和 Flash Player 6 或更高版本。仅支持在外部脚本文件中使用此关键字，而不支持在用“动作”面板编写的脚本中使用此关键字。
另请参见
class
implements
get
definition keyword
用法
function get property() : returnType{
// 此处是您的语句
}
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
指定类、变量、常量或函数可用于同一包中的任何调用者。默认情况下，类、属性和方法属于 internal 命名空间。
参数
property:* — get 访问的属性的标识符；此值必须与相应 set 命令中使用的值相同。
returnType:* — 返回值的数据类型。
if
statement
if (condition) {
// 语句
}
另请参见
package
private
protected
public
用法
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
condition:Boolean — 计算结果为 true 或 false 的表达式。
将语句与可由 break 或 continue 引用的标识符相关联。在嵌套循环中，未引用标签的 break 或 continue 语句仅会跳过下一循环的其余部分，而不是跳过整个系列的循环。但是，如果定义整个系列循环的语句具有相关联的标签，则 break 或 continue 语句通过引用该标签可以跳过整个系列的循环。
标签还允许您跳出块语句。除非块语句是循环的一部分，否则无法放置未在该块语句内引用标签的 break 语句。如果块语句有相关联的标签，则可以放置在该块语句内部引用该标签的 break 语句。
参数
implements
definition keyword
myClass implements interface01 [, interface02 , ...]
示例
如何使用示例 
下例说明如何使用嵌套循环的标签来跳出整个系列的循环。代码使用嵌套循环以生成从 0 到 99 的数字列表。在数字即将达到 80 前产生 break 语句。如果 break 语句未使用 outerLoop 标签，则代码将仅跳过下一循环的其余部分并，且代码将继续输出从 90 到 99 的数字。然而，因为使用了 outerLoop 标签，break 语句将跳过整个系列循环的其余部分，最后输出的数字是 79。
outerLoop: for (var i:int = 0; i < 10; i++) {
for (var j:int = 0; j < 10; j++) {
if ( (i == 8) && (j == 0)) {
break outerLoop;
}
trace(10 * i + j);
}
}
/*
1
2
...
79
*/
下例说明如何使用块语句的标签。在下例中，块语句标记为 foo，它允许 break 语句跳过块中的最后语句：
foo: {
trace("a");
break foo;
trace("b");
}
// a
另请参见
break
continue
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
import
directive
允许您控制定义的可见性。预定义的命名空间包括 public、private、protected 和 internal。
下列步骤说明如何创建、应用和引用命名空间：
· 首先，使用 namespace 关键字来定义自定义命名空间。例如，代码 namespace version1 将创建名为 version1 的命名空间。
· 其次，在属性或方法的声明中使用自定义命名空间将此命名空间应用于属性或方法。例如，代码 version1 myProperty:String 将创建名为 myProperty 的属性，它属于 version1 命名空间
· 最后，通过使用 use 关键字或使用命名空间作为标识符的前缀来引用该命名空间。例如，代码 use namespace version1; 引用后续代码行的 version1 命名空间，而代码 version1::myProperty 引用 myProperty 属性的 version1 命名空间。
参数
导入 packageName.className
导入 packageName.*
另请参见
class
internal
package
private
protected
public
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
packageName:* — 在单独类文件中定义的包的名称。
className:Class — 在单独类文件中定义的类的名称。
include
directive
指定函数或方法由 Flash Player 以本机代码的形式实现。Flash Player 内部使用 native 关键字来声明 ActionScript 应用程序接口 (API) 中的函数和方法。在您自己的代码中无法使用此关键字。
用法
include "[path]filename.as"
一个可以分配给变量的或由未提供数据的函数返回的特殊值。您可以使用 null 表示缺少的或不具有已定义数据类型的值。
不要将值 null 与特殊值 undefined 相混淆。使用等于运算符 (==) 对 null 和 undefined 进行比较时，它们的比较结果为相等。但是，使用全等运算符 (===) 对 null 和 undefined 进行比较时，它们的比较结果为不相等。
示例
如何使用示例 
下例检查索引数组的前六个值，如果没有设置值（如果 value == null），则输出一条消息：
var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";
for (i = 0; i < 6; i++) {
if (testArray[i] == null) {
trace("testArray[" + i + "] == null");
}
}
/*
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/
另请参见
undefined
interface
definition keyword
定义 ObjectProxy 类的方法。ObjectProxy 类的方法位于自己的命名空间内，从而避免了 Proxy 子类中实例方法的名称与 Proxy 类的方法名称相匹配时，发生名称冲突。
interface InterfaceName [extends InterfaceName ] {}
用法
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
internal
attribute keyword
指定用一种方法替换继承的方法。若要覆盖继承的方法，则必须使用 override 属性，并确保名称、数字、参数类型和返回类型完全匹配。在未使用 override 属性的情况下尝试覆盖方法是错误的。同样的，如果方法没有匹配的继承方法，则使用 override 属性也是错误的。
无法对下列任一项使用 override 属性：
· 变量
· 常数
· 静态方法
· 未继承的方法
· 实施接口方法的方法
· 超类中标记为 final 的继承方法
尽管不能覆盖使用 var 或 const 声明的属性，但是通过使基类属性为 getter-setter，并覆盖使用 get 和 set 定义的方法，可以实现类似的功能。
参数
另请参见
final
get
set
[internal] var varName
[internal] const kName
[internal] function functionName()  {
// 此处是您的语句
}
[internal] class className{
// 此处是您的语句
}
[internal] namespace nsName
用法
语言版本:
ActionScript 3.0
允许您将代码组织为可由其它脚本导入的离散组。您必须使用 package 关键字以指示类是包的成员。
参数
运行时版本:
Flash Player 9
另请参见
internal
public
class
className:Class — 要指定为内部的类的名称。
varName:* — 要指定为内部的变量的名称。无论该变量是否是类的一部分，都可以应用 internal 属性。
kName:* — 要指定为内部的常量的名称。无论该常量是否是类的一部分，都可以应用 internal 属性。
functionName:Function — 要指定为内部的函数或方法的名称。无论该函数是否是类的一部分，都可以应用 internal 属性。
nsName:Namespace — 要指定为内部的命名空间的名称。无论该命名空间是否是类的一部分，都可以应用 internal 属性。
用法
label
statement
指定变量、常量或方法仅可供声明或定义它的类使用。与在 ActionScript 2.0 中的情况不同，在 ActionScript 3.0 中，private 不再提供对子类的访问。此外，private 限制编译时和运行时的访问。默认情况下，变量和函数对同一包中的任何调用者均可用。使用此关键字可以限制对变量或函数的访问。
您只能在类定义中使用此关键字，不能在接口定义中使用。无法将 private 应用于类或任何其它包级定义。
参数
label: statement
label: {
语句
}
语言版本:
ActionScript 3.0
示例
如何使用示例 
下面的示例说明了如何使用 private 关键字隐藏类中的某些属性。
class A {
private var alpha:String = "visible only inside class A";
public var beta:String = "visible everywhere";
}
class B extends A {
function B() {
alpha = "Access attempt from subclass"; // error
}
}
因为 alpha 是私有变量，从 A 类的外部无法访问它，即使从子类 B 中也无法访问。尝试访问私有变量将生成错误。
另请参见
internal
protected
public
运行时版本:
Flash Player 9
用法
label:* — 要与语句相关联的有效标识符。
statements:* — 要与标签相关联的语句。
namespace
definition keyword
namespace name [= uri]
指定变量、常量、方法或命名空间只可用于定义它的类及该类的任何子类。ActionScript 3.0 中的 protected 的定义与 ActionScript 2.0 版本的 private 的定义类似，只不过 protected 同时限制了编译时和运行时的访问。默认情况下，变量或函数可用于同一包中的任何调用者。使用此关键字可以限制对变量或函数的访问。
您只能在类定义中使用此关键字，不能在接口定义中使用。无法将 private 应用于类或任何其它包级定义。
ActionScript 3.0 中的 protected 的定义比 Java 编程语言中的 protected 的定义更具限制性。ActionScript 3.0 中的 protected 严格限制对子类的访问，而 Java 中的 protected 允许对同一包中的任何类进行访问。例如，如果名为 Base 的类包含标记为 protected 的属性，则在 ActionScript 3.0 中，只有扩展 Base 的类才可以访问受保护的属性。在 Java 中，Base 所在的同一个包中的所有类都可以访问受保护的属性，即使该类不是 Base 的子类。
参数
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
name:Namespace — 命名空间的名称，可以是任意合法的标识符。
uri:String — 命名空间的统一资源标识符 (URI)。这是一个可选参数。
示例
如何使用示例 
以下示例将在类 A 中创建一个受保护的类变量，并从类 B 中成功访问该变量（这是因为类 B 是类 A 的子类）。
class A {
private var alpha:String = "visible only inside class A";
protected var beta:String = "visible inside class A and its subclasses";
}
class B extends A {
public function B() {
beta = "Access attempt from subclass succeeded";
trace(beta);  // Access attempt from subclass succeeded
}
}
另请参见
internal
private
public
用法
native
attribute keyword
native function functionName();
class className{
native function methodName();
}
语言版本:
ActionScript 3.0
指定类、变量、常量或方法可用于任何调用者。默认情况下，类、变量和方法是内部的，这意味着它们仅在当前包中可见。若要使类、变量或方法对所有调用者可见，则必须使用 public 属性。
参数
运行时版本:
Flash Player 9
null
primary expression keyword
null
语言版本:
ActionScript 3.0
示例
如何使用示例 
下例说明如何在类文件中使用公共变量：
class User {
public var age:Number;
public var fname:String;
} // end of class User definition
var jimmy:User = new User();
jimmy.age = 27;
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // 27 jimmy
如果将 User 类中的一个公共变量更改为私有变量，则只要尝试在 User 类外部访问该变量，就会生成一个编译时错误。
另请参见
class
internal
private
protected
运行时版本:
Flash Player 9
用法
object_proxy
namespace
override
attribute keyword
导致立即返回执行调用函数。如果 return 语句后跟表达式，则计算此表达式并返回结果。
如果函数定义包含返回类型，则 return 语句必须后跟表达式。如果未指定返回类型且单独使用 return 语句，则返回 undefined。
无法返回多个值。如果尝试返回多个值，则将只返回最后一个值。在下面的示例中，返回 c：
返回 a、b、c；
如果需要返回多个值，则应改用数组或对象。
参数
override function name() {
// 此处是您的语句
}
结果
示例
如何使用示例 
下面的示例使用 sum() 函数体内的 return 语句，以返回三个参数相加后的值。下一行代码调用 sum() 并将返回值赋予变量 newValue。
function sum(a:Number, b:Number, c:Number):Number {
return (a + b + c);
}
var newValue:Number = sum(4, 32, 78);
trace(newValue); // 114
另请参见
function
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
name:Function — 要覆盖的方法的名称。
package
definition keyword
定义一个 setter，它是一种在公共接口中作为属性出现的方法。setter 是一种特殊方法，它设置使用 var 关键字声明的属性的值。与其它的方法不同，调用 setter 时不使用括号 (())，这样 setter 看起来就像是变量。
通过允许创建私有属性的公共接口，Setter 允许您应用信息隐藏规则。信息隐藏的好处是：即使私有属性的基础实现发生更改，公共接口也会保持不变。
setter 的另一个优点是它们可在子类中覆盖，而使用 var 声明的属性则不能。
setter 的返回类型必须为 void 或未指定。
可以将 setter 与 getter 相接合来创建读写属性。要创建只读属性，请创建一个没有对应 setter 的 getter。要创建只写属性，请创建一个没有对应 getter 的 setter。
注意：仅支持在外部脚本文件中使用此关键字，而不支持在用“动作”面板编写的脚本中使用此关键字。
参数
package packageName {
class someClassName{
}
}
示例
如何使用示例 
下例通过定义 getter-setter 创建了名为 age 的读写属性。
package {
class User {
private var userAge:Number;
public function get age():Number {
return userAge;
}
public function set age(x:Number):void {
userAge = x;
}
}
}
在脚本中输入下面的代码：
var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // 25
另请参见
get
用法
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
packageName:* — 包的名称。
private
attribute keyword
指定变量、常量或方法属于类，而不属于类的实例。
若要访问静态类成员，请使用类的名称而不是实例的名称。例如，Date 类具有名为 parse() 的静态方法，该方法仅能使用以下语法调用：
Date.parse()
对 Date 类的实例无法调用 parse() 方法。例如，以下代码将生成错误：
var myDate:Date = new Date();
myDate.parse("Jan 01 00:00:00 2006"); // error
您只能在类定义中使用 static，而不能在接口定义中使用。
未继承静态类成员。不能像在 Java 或 C++ 中那样，使用子类的名称引用静态类成员。然而，无需使用任何限定词，就可以在类或子类中引用静态变量或方法。请参见下例。
不能在静态方法内部使用 super 语句或 this 关键字。
注意：仅支持在外部脚本文件中使用此关键字，而不支持在用“动作”面板编写的脚本中使用此关键字。
参数
class className{
private var varName;
private const kName;
private function methodName() {
// 此处是您的语句
}
private namespace nsName;
}
示例
如何使用示例 
下面的示例说明如何使用 static 关键字创建一个计数器，该计数器跟踪已创建类的实例的数量。由于 numInstances 变量是静态的，因此它只对整个类创建一次，而不是对每个单独实例都创建一次。创建名为 Users.as 的新 ActionScript 文件，并输入以下代码：
class Users {
private static var numInstances:Number = 0;
function Users() {
numInstances++;
}
static function get instances():Number {
return numInstances;
}
}
在脚本中输入下面的代码：
trace(Users.instances);
var user1:Users = new Users();
trace(Users.instances);
var user2:Users = new Users();
trace(Users.instances);
下例扩展了 Users 类，以说明尽管未继承静态变量和方法，但是可以在子类中引用它们。
class PowerUsers extends Users{
function PowerUsers() {
instances++;  // unqualified reference to static property Users.instances is legal
}
}
trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class
用法
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
varName:* — 要指定为私有的变量的名称。仅当该变量位于类内部时，才可以应用 private 属性。
kName:* — 要指定为私有的常量的名称。仅当该常量位于类内部时，才可以应用 private 属性。
methodName:Function — 要指定为私有的方法的名称。仅当该方法位于类内部时，才可以应用 private 属性。
nsName:Namespace — 要指定为私有的命名空间的名称。仅当该命名空间位于类内部时，才可以应用 private 属性。
调用方法或构造函数的超类或父版本。在类构造函数体内使用 super() 语句时，该语句将调用构造函数的超类版本。对超类构造函数的调用必须有正确的参数数目。请注意，不管是否显式调用超类函数，都会调用到超类构造函数。如果不是显式调用它，则将在子类构造函数体中的第一个语句前自动插入不带参数的调用。这意味着，如果在子类中定义了构造函数，并且超类构造函数具有一个或多个参数，则必须显式调用具有正确参数数目的超类构造函数，否则将产生错误。然而，根据 ActionScript 2.0 的要求，对超类构造函数的调用无需是子类构造函数中的第一个语句。
在实例方法体中使用时，super 可以与 dot (.) 运算符共同使用以调用方法的超类版本，并可以选择将参数 (arg1 ... argN) 传递给超类方法。这对于创建某些子类方法很有用，这些子类方法在向超类方法添加附加行为的同时，又调用这些超类方法执行其原始行为。
在静态方法中不能使用 super 语句。
参数
另请参见
class
extends
用法
protected
attribute keyword
class className{
protected var varName;
protected const kName;
protected function methodName() {
// 此处是您的语句
}
protected namespace nsName;
}
根据表达式的值，使控制转移到多条语句的其中一条。如果没有任何 case 语句与表达式相匹配，则所有 switch 语句应该包含将执行的默认 case。每个 case 语句应该以 break 语句结尾，以避免发生落空错误。当一个 case 落空时，即使下一个 case 语句可能与测试表达式不匹配，它仍将执行此 case 中的代码。
参数
示例
如何使用示例 
下例定义了落空至默认 case 的 switch 语句：
var switchExpression:int = 3;
switch (switchExpression) {
case 0:
trace(0);
break;
case 1:
trace(1);
break;
case 2:
trace(2);
break;
default:
trace("Not 0, 1, or 2");
}
// Not 0, 1, or 2
另请参见
=== (strict equality)
case
default
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
varName:* — 要指定为受保护的变量的名称。仅当该变量位于类内部时，才可以应用 protected 属性。
kName:* — 要指定为受保护的常量的名称。仅当该常量位于类内部时，才可以应用 protected 属性。
methodName:Function — 要指定为受保护的方法的名称。仅当该方法位于类内部时，才可以应用 protected 属性。
nsName:Namespace — 要指定为受保护的命名空间的名称。仅当该命名空间位于类内部时，才可以应用 protected 属性。
对方法的包含对象的引用。执行脚本时，this 关键字引用包含该脚本的对象。在方法体的内部，this 关键字引用包含调用方法的类实例。
示例
如何使用示例 
若要调用在动态类中定义的函数，则必须使用 this 调用适当作用域内的函数：
// incorrect version of Simple.as
/*
dynamic class Simple {
function callfunc() {
func();
}
}
*/
// correct version of Simple.as
dynamic class Simple {
function callfunc() {
this.func();
}
}
将下面的代码添加到您的脚本中：
var simpleObj:Simple = new Simple();
simpleObj.func = function() {
trace("hello there");
}
simpleObj.callfunc();
当您在 callfunc() 方法中使用 this 时，以上代码生效。不过，如果您使用了不正确的 Simple.as 版本，将出现语法错误（在上例中已注释掉）。
用法
public
attribute keyword
生成或抛出（使用 throw 语句）一个可由 catch 代码块处理或捕获的错误。如果 catch 块未捕获异常，则将引发值的字符串表示形式发送到“输出”面板。If an exception is not caught by a catch or finally block, the string representation of the thrown value is sent to the log file.
通常，引发的错误是 Error 类或其子类的实例（请参阅“示例”部分）。
参数
public var varName
public const kName
public function functionName()  {
// 此处是您的语句
}
public class className {
// 此处是您的语句
}
public namespace nsName
示例
如何使用示例 
在此示例中，一个名为 checkEmail() 的函数检查传递给它的字符串是否为格式正确的电子邮件地址。如果该字符串不包含 @ 符号，则该函数将抛出一个错误。
function checkEmail(email:String) {
if (email.indexOf("@") == -1) {
throw new Error("Invalid email address");
}
}
checkEmail("someuser_theirdomain.com");
然后下面的代码调用 try 代码块内的同一函数 checkEmail()。如果电子邮件字符串不包含有效的电子邮件地址，则 trace 语句将输出错误消息。
try {
checkEmail("Joe Smith");
}
catch (e) {
trace(e);
}
// Error: Invalid email address.
在下面的示例中，将抛出 Error 类的一个子类。对 checkEmail() 函数进行了修改，使其抛出该子类的一个实例。
// Define Error subclass InvalidEmailError
class InvalidEmailAddress extends Error {
public function InvalidEmailAddress() {
message = "Invalid email address.";
}
}
在脚本中输入下面的代码：
import InvalidEmailAddress;
function checkEmail(email:String) {
if (email.indexOf("@") == -1) {
throw new InvalidEmailAddress();
}
}
try {
checkEmail("Joe Smith");
}
catch (e) {
trace(e);
}
// Error: Invalid email address.
另请参见
Error class
try..catch..finally
用法
语言版本:
ActionScript 3.0
表示 true 的布尔值。布尔值为 true 或 false；true 与 false 相反。如果自动设置数据类型将 true 转换为数字，则它变为 1；如果将 true 转换为字符串，则它变为 "true"。
示例
如何使用示例 
下面的示例说明 true 在 if 语句中的使用情况：
var shouldExecute:Boolean;
// ...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:
shouldExecute = true;
if (shouldExecute == true) {
trace("your statements here");
}
// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }
下例说明自动数据类型设置如何将 true 转换为数字 1：
var myNum:Number;
myNum = 1 + true;
trace(myNum); // 2
另请参见
Boolean class
false
运行时版本:
Flash Player 9
用法
className:Class — 要指定为公共的类的名称。
varName:* — 要指定为公共的变量的名称。无论该变量是否是类的一部分，都可以应用 public 属性。
kName:* — 要指定为公共的常量的名称。无论该常量是否是类的一部分，都可以应用 public 属性。
functionName:Function — 要指定为公共的函数的名称。无论该函数是否是类的一部分，都可以应用 public 属性。
nsName:Namespace — 要指定为公共的命名空间的名称。无论该命名空间是否是类的一部分，都可以应用 public 属性。
return
statement
包含一个代码块，在其中可能会发生错误，然后对该错误进行响应。异常处理是使用 try..catch..finally 语句实现的，是 ActionScript 3.0 中处理运行时错误条件的主要机制。产生运行时错误时，Flash Player 将引发异常，这意味着该 Flash Player 暂停了正常的执行并创建了一个 Error 类型的特殊对象。然后 Flash Player 将错误对象传递或抛给 第一个可用的 catch 块。如果没有可用的 catch 块，会将此异常视为未捕获的异常。未捕获的异常将导致脚本终止。
可以使用 throw 语句以显式引发代码中的异常。可以引发任意值，但是最佳做法是引发一个对象，因为这样比较灵活，并能与 Flash Player 的行为相匹配。
若要捕获一个异常，无论它是由 Flash Player 还是您自己的代码引发的，都要将可能引发异常的代码放置在 try 块中。如果 try 块中的任何代码引发异常，控制会传递到 catch 块（如果有），然后传递到 finally 块（如果有）。无论是否引发了异常，始终会执行 finally 块。如果 try 块中的代码未引发异常（即，如果 try 块正常完成），则会忽略 catch 块中的代码，但是仍将执行 finally 块中的代码。即使 try 代码块使用 return 语句退出，仍会执行 finally 代码块。
try 代码块后面必须跟有 catch 代码块、finally 代码块，或两者都有。单个 try 代码块可以有多个 catch 代码块，但只能有一个 finally 代码块。您可以根据需要嵌套任意层数的 try 代码块。
catch 处理函数中指定的 error 参数必须是一个简单的标识符，如 e、theException 或 x。还可以为参数指定类型。当与多个 catch 块一起使用时，如果指定了参数类型，则可以捕获从一个 try 块引发的多种类型的错误。
如果抛出的异常是对象，则当抛出的对象是指定类型的子类时，类型将匹配。如果抛出的错误属于特定类型，将执行处理相应错误的 catch 代码块。如果抛出的异常不属于指定类型，则不执行 catch 代码块，而自动将该异常从 try 代码块抛出到与其匹配的 catch 处理函数。
如果在某个函数内引发了错误，而该函数不包含 catch 处理函数，则 Flash Player 将退出该函数以及任何调用函数，直到找到一个 catch 块。在此过程中，在各层上都会调用 finally 处理函数。
参数
function functionName () {
return [expression]
}
示例
如何使用示例 
下面的示例说明一条 try..catch 语句。在 try 块内的代码包含非法操作。sprite 无法将自己添加为子项。因此，Flash Player 将引发异常，并将类型 ArgumentError 的对象传递到相应的 catch 块。
import flash.display.Sprite;
var spr:Sprite = new Sprite();
try {
spr.addChild(spr);
}
catch (e:ArgumentError) {
trace (e); // ArgumentError: Error #2024: An object may not be added as a child of itself.
}
在下面的示例中，RecordSetException 和 MalformedRecord 对象是 Error 类的子类。
class RecordSetException extends Error {
public function RecordSetException () {
message = "Record set exception occurred.";
}
}
class MalformedRecord extends Error {
public function MalformedRecord {
message = "Malformed record exception occurred.";
}
}
在 RecordSet 类的 sortRows() 方法内，将根据所发生异常的类型抛出其中一个以前定义的错误对象。下面的示例说明此代码的外观：
class RecordSet {
public function sortRows() {
var returnVal:Number = randomNum();
if (returnVal == 1) {
throw new RecordSetException();
}
else if (returnVal == 2) {
throw new MalformedRecord();
}
}
public function randomNum():Number {
return Math.round(Math.random() * 10) % 3;
}
}
最后，下面的代码调用 RecordSet 类的实例上的 sortRows() 方法。它为 sortRows() 引发的每种类型的错误定义 catch 块。
import RecordSet;
var myRecordSet:RecordSet = new RecordSet();
try {
myRecordSet.sortRows();
trace("everything is fine");
}
catch (e:RecordSetException) {
trace(e.toString());
}
catch (e:MalformedRecord) {
trace(e.toString());
}
另请参见
Error class
throw
语言版本:
ActionScript 3.0
用法
运行时版本:
Flash Player 9
expression:* — 要计算并返回为函数的值的表达式。此参数是可选的。
使指定的命名空间添加到打开的命名空间集中。退出当前代码块时，将从打开的命名空间集中删除指定的命名空间。use namespace 指令可以出现在程序、包定义或类定义的顶层。
参数
* — 经过计算的 expression 参数（如果提供了）。
另请参见
default xml namespace
namespace
XML class
set
definition keyword
用法
function set property(newValue:*) : void{
// 此处是您的语句
}
指定一个变量。如果变量是在函数内声明的，则这些变量是局部变量。它们是为该函数声明的，在函数调用结束时到期。
如果在函数外声明变量，该变量在包含该语句的整个时间轴中都可用。
无法将其它对象作用域内的变量声明为局部变量。
my_array.length = 25; // 正确
var my_array.length = 25; // 语法错误
为变量分配数据类型的方法是在变量后加冒号字符，后跟数据类型。
您可以在一条语句中声明多个变量，用逗号分隔各个声明（尽管此语法可能会降低代码的清晰程度）：
var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";
参数
语言版本:
ActionScript 3.0
示例
如何使用示例 
下面的 ActionScript 创建一个新的产品名称数组。Array.push 将一个元素添加到该数组的末尾。
var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze");
product_array.push("Flex");
trace(product_array);
// Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex
另请参见
const
运行时版本:
Flash Player 9
用法
property:* — set 修改的属性的标识符；此值必须与相应 get 命令中使用的值相同。
newValue:* — 要分配的新值。
static
attribute keyword
计算一个条件，如果该条件的计算结果为 true，则会执行一条或多条语句，之后循环会返回并再次计算条件。若该条件的计算结果为 false，则会跳过语句，并结束循环。
while 语句执行下面一系列步骤。第 1 步至第 4 步的每次重复，称作循环的一次迭代。每次遍历开始时都将测试该条件，具体步骤如下所示：
1. 计算表达式 condition。
2. 如果 condition 的计算结果为 true 或一个转换为布尔值 true 的值（如一个非零数），则转到第 3 步。否则，while 语句结束并继续执行 while 循环后面的下一个语句。
3. 运行语句块 statement(s)。如果遇到 continue 语句，则跳过其余的语句并转到步骤 1。如果遇到 break 语句，则 while 语句结束并从 while 循环之后的下一语句继续开始执行。
4. 转到步骤 1。
通常当计数器变量小于某指定值时，使用循环执行动作。在每个循环的结尾递增计数器的值，直到达到指定值为止。此时，condition 不再为 true，因此循环结束。
如果仅执行一条语句，则无需使用花括号 ({}) 来括起要由 while 语句执行的语句。
参数
示例
如何使用示例 
在下面的示例中，while 语句用于测试表达式。在 i 的值小于 20 时，跟踪 i 的值。当条件不再为 true 时，循环将退出。
var i:Number = 0;
while (i < 20) {
trace(i);
i += 3;
}
/*
0
3
6
9
12
15
18
*/
另请参见
break
continue
do..while
class someClassName{
static var varName;
static const kName;
static function methodName() {
// 此处是您的语句
}
}
用法
语言版本:
ActionScript 3.0
运行时版本:
Flash Player 9
建立要用于执行一条或多条语句的默认对象，从而潜在地减少需要编写的代码量。
object 参数变为在其中读取 statement(s) 参数中的属性、变量和函数的上下文。例如，如果 object 为 my_array，并且指定的两个属性为 length 和 concat，则这些属性将自动读取为 my_array.length 和 my_array.concat。在另一个示例中，如果 object 是 state.california，则 with 语句内部的任何动作或语句将从 california 实例的内部调用。
若要查找 statement(s) 参数中某个标识符的值，ActionScript 将从 object 指定的范围链的开头处开始，按照特定的顺序在范围链的每个级别中搜索该标识符。
with 语句使用范围链解析标识符，该范围链从下面列表中的第一项开始，到最后一项结束：
· 该对象在最内层的 with 语句中的 object 参数中指定。
· 该对象在最外层的 with 语句中的 object 参数中指定。
· Activation 对象（脚本调用函数时自动创建的临时对象，该函数包含函数中调用的局部变量）
· 该对象包含当前正在执行的脚本
· 全局对象（如 Math 和 String 等内置对象）。
若要在 with 语句内部设置变量，必须已在 with 语句外部声明了该变量，或必须输入了希望该变量所存在的时间轴的完整路径。如果在 with 语句中设置了未声明的变量，with 语句将根据范围链查找该值。如果该变量尚不存在，则将在调用 with 语句的时间轴上设置此新值。
参数
示例
如何使用示例 
下例设置 someOther_mc 实例的 _x 和 _y 属性，然后指示 someOther_mc 转到第 3 帧并停止。
with (someOther_mc) {
_x = 50;
_y = 100;
gotoAndStop(3);
}
下面的代码片断说明如何在不使用 with 语句的情况下编写上述代码。
someOther_mc._x = 50;
someOther_mc._y = 100;
someOther_mc.gotoAndStop(3);
with 语句对于同时访问一个范围链列表中的多个项很有用。下例中，内置的 Math 对象放置在范围链的前部。将 Math 设置为默认对象会将标识符 cos、sin 和 PI 分别解析为 Math.cos、Math.sin 和 Math.PI。标识符 a、x、y 和 r 不是 Math 对象的方法或属性，但由于它们存在于函数 polar() 的对象激活作用域内，所以将其解析为相应的局部变量。
function polar(r:Number):void {
var a:Number, x:Number, y:Number;
with (Math) {
a = PI * pow(r, 2);
x = r * cos(PI);
y = r * sin(PI / 2);
}
trace("area = " + a);
trace("x = " + x);
trace("y = " + y);
} polar(3);
/*
area = 28.2743338823081
x = -3
y = 3
*/
© 2004-2008 Adobe Systems Incorporated. All rights reserved.
Sun Oct 26 2008, 02:43 AM -07:00