ActionScript中的关键词

语句是在运行时执行或指定动作的语言元素。 例如，return 语句会为执行它的函数返回一个结果值。if 语句会对一个条件求值，以确定应采取的下一个动作。switch 语句会创建 ActionScript 语句的分支结构。

Attribute 关键字可以更改定义的含义，还可用于定义类、变量、函数和命名空间。Definition 关键字用于定义变量、函数、类和接口等实体。主表达式关键字代表文本值。要获取保留字列表，请参阅《ActionScript 3.0 编程》。

指令包括语句和定义，可以在编译时或运行时发挥作用。既非语句又非定义的指令列在以下指令表中。

 


  语句 摘要
  break 出现在一个循环（for、for..in、for each..in、do..while 或 while）中，或者出现在与 switch 语句内特定的 case 相关联的语句块中。
  case 定义 switch 语句的跳跃目标。
  continue 跳过最里层循环中剩余的所有语句并开始循环的下一个迭代，就像控件正常传递到了循环结尾一样。
  default 定义 switch 语句的默认 case。
  do..while 与 while 循环类似，不同之处是在初次计算条件前要执行该语句一次。
  else 指定当 if 语句中的条件返回 false 时要运行的语句。
  for 计算一次 init（初始化）表达式，然后开始一个循环序列。
  for..in 迭代对象的动态属性或数组中的元素，并对每个属性或元素执行 statement。
  for each..in 遍历集合中的所有项目，并对每个项目执行 statement。
  if 计算条件以确定要执行的下一条语句。
  label 将语句与可由 break 或 continue 引用的标识符相关联。
  return 立即将执行结果返回到调用函数。
  super 调用方法或构造函数的超类版本或父版本。
  switch 将控制权传递给多条语句之一，具体取决于表达式的值。
  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 类的方法。
  flash10 定义 Flash Player 10 类的方法和属性，它们是固定属性，而非原型属性。
  object_proxy 定义 ObjectProxy 类的方法。
  主表达式关键字 摘要
  false 代表 false 的布尔值。
  null 一个特殊值，可以赋给变量，而如果未提供任何数据，也可以由函数返回。
  this 对方法中包含的对象的引用。
  true 代表 true 的布尔值。
语句、关键字和指令详细信息
... (rest) parameter definition keyword
用法
  
function functionName(parameter0, parameter1, ...rest){ // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定函数将接受任意数目的用逗号分隔的参数。参数列表将变为数组，在整个函数体内都可用。该数组的名称在参数声明中的 ... 字符之后指定。参数可以使用除保留字之外的任何名称。

如果与其它参数一起使用，则 ...（其余）参数声明必须是最后一个指定参数。仅当传递给函数的参数数量超过其它参数的数量时，才填充 ...（其余）参数数组。

使用逗号分隔的参数列表中的每个参数都放到数组的一个元素中。如果传递 Array 类的一个实例，则会将整个数组放置到 ...（其余）参数数组的一个元素中。

使用此参数会导致 arguments 对象不可用。虽然 ...（其余）参数可以为您提供与 arguments 数组和arguments.length 属性相同的功能，但却不能像 arguments.callee 一样提供类似的功能。在使用 ...（其余）参数前，请确保不需要使用 arguments.callee。

 

 

参数
  rest:* — 一个标识符，表示传递给函数的参数数组的名称。此参数不必命名为 rest；它可以使用关键字以外的任何名称。您可以将 ...（其余）参数的数据类型指定为 Array，但这会导致混淆，因为此参数接受使用逗号分隔的值列表，这与 Array 类的实例不同。

示例
如何使用示例
以下示例在两个不同的函数中使用 ...（其余）参数。第一个函数 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); }

 

另请参见

AS3 namespace  

 

定义核心 ActionScript 类的方法和属性，它们是固定属性，而非原型属性。如果将“-as3”编译器选项设置为true（这是 Flex Builder 2 中的默认设置），则会自动为所有核心类打开 AS3 命名空间。这意味着核心类的某个实例将使用固定属性和方法，而不使用与附加到该类的原型对象的属性和方法相同的版本。使用固定属性通常可以提供更好的性能，但会影响与 ECMAScript edition 3 语言规范 (ECMA-262) 的向后兼容性。

另请参见

break statement  
用法
 

break [label]

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

出现在一个循环（for、for..in、for each..in、do..while 或 while）中，或者出现在与 switch 语句内特定的 case 相关联的语句块中。当在循环中使用时，break 语句指示 Flash 跳过循环体的其余部分，停止循环动作并执行循环语句后面的语句。当在 switch 中使用时，break 语句指示 Flash 跳过该 case 块中的其余语句，跳到包含它的 switch 语句后面的第一个语句。

在嵌套循环中，break 只跳过当前循环的其余部分，而不是跳出整个系列的嵌套循环。要跳出整个系列的嵌套循环，请使用 label 或 try..catch..finally。

break 语句可以选择标签，但该标签必须与外部标记语句匹配。如果使用的标签与外部语句的标签不匹配，则属于语法错误。带标记的 break 语句可以用于跳出多层嵌套循环语句、switch 语句或 block 语句。有关示例，请参阅 label 语句的条目。

 

 

参数
  label:* — 与语句相关联的标签的名称。

示例
如何使用示例
以下示例使用 break 退出循环（如果没有此语句，则该循环为无限循环）： 
var i:int = 0; while (true) { trace(i); if (i >= 10) { break; // this will terminate/exit the loop } i++; }

 

另请参见

case statement  
用法
  
case jumpTarget: statements

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

定义 switch 语句的跳跃目标。如果 jumpTarget 参数等于 switch 语句的 expression 参数（使用全等 (===) 运算），则 Flash Player 将执行 statements 参数中的语句，直到遇到 break 语句或到达 switch 语句的结尾。

如果在 switch 语句外部使用 case 语句，将会产生错误，并且脚本无法编译。

注意：应始终使用 break 语句来结束 statements 参数。如果在 statements 参数中省略 break 语句，它将继续执行下一个 case 语句，而不是退出 switch 语句。

 

 

参数
  jumpTarget:* — 任何表达式。
  statements:* — 当 jumpTarget 与 switch 语句中的条件表达式匹配时要执行的语句。

示例
如何使用示例
以下示例定义 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"); }

 

另请参见

class definition keyword  
用法
  
[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { // class definition here }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

定义一个类，通过该类可以实例化那些共享您定义的方法和属性的对象。例如，如果您正在开发发票跟踪系统，就可以创建一个 Invoice 类，在其中定义每个发票都应具有的所有方法和属性。然后，您可以使用 new Invoice() 命令来创建 Invoice 对象。

每个 ActionScript 源文件只能包含一个对其它源文件或脚本可见的类。外部可见类可以是公共类或内部类，并且必须在包语句内部定义。如果在同一文件中包括其它类，则这些类必须放置在包语句外面并且是文件结尾处。

外部可见类的名称必须与包含此类的 ActionScript 源文件的名称匹配。源文件名称必须是类的名称加上文件扩展名 .as。例如，如果您将一个类命名为 Student，则定义该类的文件必须命名为 Student.as。

您不能嵌套类定义；也就是说，您不能在某个类定义内定义其它类。

您可以定义一个构造函数方法，创建类的新实例后必须执行该方法。构造函数方法的名称必须与类名称匹配。如果未定义构造函数方法，则会为您创建一个默认的构造函数。

若要指示对象可在运行时添加和访问动态属性，请在类声明前面添加 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

 

 

参数
  className:Class — 类的完全限定名称。

示例
如何使用示例
以下示例创建一个名为 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);

 

另请参见

const definition keyword  
用法
  
const identifier = value

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定一个常数，即只能赋一次值的变量。

您可以通过在数据类型后追加一个冒号 (:) 字符来严格限定常数的类型。

 

 

参数
  identifier:* — 常数的标识符。

示例
如何使用示例
以下示例显示，如果您尝试多次对一个常数赋值，就会发生错误。 
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);

 

另请参见

continue statement  
用法
  
continue [label]

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

跳过最里层循环中剩余的所有语句并开始循环的下一个迭代，就像控件正常传递到了循环结尾一样。continue语句在循环外部时无作用。在嵌套循环中，使用可选的 label 参数不只可以跳过最里层的循环。

continue 语句可以选择使用标签，但该标签必须与外部标记语句匹配。如果使用的标签与外部语句的标签不匹配，则属于语法错误。标记的 continue 语句可用于跳出多层嵌套循环语句。

 


示例
如何使用示例
在下面的 while 循环中，只要遇到 3 的倍数，就使用 continue 语句跳过循环体的其余部分，并跳到循环的顶端（在此处测试条件）： 
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); }

 

另请参见

default statement  
用法
  
default: statements

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

定义 switch 语句的默认 case。如果 switch 语句的 expression 参数（使用全等 [===] 运算）不等于给定switch 语句的 case 关键字后面的任何 expression 参数，则执行该语句。

switch 语句不要求一定有 default case 语句。default case 语句也不一定出现在列表的最后。如果在switch 语句外部使用 default 语句，将会产生错误，并且脚本无法编译。

 

 

参数
  statements:* — 任何语句。

示例
如何使用示例
在下面的示例中，如果 day of the week 是 Saturday 或 Sunday，则不应用任何 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"); }

 

另请参见

default xml namespace directive  
用法
 

default xml namespace = ns

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

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 = <test1 />; trace("x1 ns: " + x1.namespace()); scopeCheck(); var x2:XML = <test2 />; trace("x2 ns: " + x2.namespace()); function scopeCheck(): void { var x3:XML = <test3 />; trace("x3 ns: " + x3.namespace()); var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/"); default xml namespace = nsDefault2; var x4:XML = <test4 />; 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 = <test1 />; trace(x1.namespace()); // http://www.example.com/namespaces/ var x2:XML = <test2 xmlns = "http://www.w3.org/1999/XSL/Transform/" />; trace(x2.namespace()); // http://www.w3.org/1999/XSL/Transform/ var x3:XML = <test3 xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/" />; trace(x3.namespace()); // http://www.example.com/namespaces/

 

另请参见

do..while statement  
用法
  
do { statement(s) } while (condition)

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

与 while 循环类似，不同之处是在初次计算条件前要执行该语句一次。随后，仅当条件的计算结果为 true 时才执行该语句。

do..while 循环可确保循环内的代码至少执行一次。尽管使用 while 循环也可以实现相同的效果，只要在while 循环开始前放置要执行的相应语句即可，但很多程序员都认为 do..while 循环更容易阅读。

如果条件的计算结果始终为 true，则 do..while 循环将为无限循环。如果陷入无限循环，则 Flash Player 会遇到问题，最终导致发出警告信息，或播放器崩溃。如果知道要循环的次数，则应该尽可能使用 for 循环。尽管 for 循环易于阅读和调试，但并非在所有情况下都能代替 do..while 循环。

 

 

参数
  condition:Boolean — 要计算的条件。只要 condition 参数的计算结果为 true，即会执行 do 代码块内的 statement(s)。

示例
如何使用示例
以下示例使用 do..while 循环计算一个条件是否为 true,，并跟踪 myVar，直到 myVar 等于或大于 5。当myVar 等于或大于 5 时，循环结束。 
var myVar:Number = 0; do { trace(myVar); myVar++; } while (myVar < 5);

 

另请参见

dynamic attribute keyword  
用法
  
dynamic class className { // class definition here }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定在运行时类的实例可以拥有添加的动态属性。如果使用某个类上的 dynamic 属性，您可以在运行时向该类的实例添加属性。未标记为 dynamic 的类被视为密封类，这意味着不能向该类的实例添加属性。

如果某个类是密封的（非动态），则尝试获得或设置该类实例中的属性就会导致错误。如果将编译器设置为严格模式并在创建实例时指定数据类型，则尝试向密封对象添加属性将生成编译器错误；否则发生运行时错误。

dynamic 属性不能被子类继承。如果扩展动态类，则只有声明子类具有 dynamic 属性时，子类才是动态的。

注意：仅支持在外部脚本文件中使用此关键字，而不支持在使用“Actions”面板编写的脚本中使用此关键字。

 


示例
如何使用示例
以下示例创建了两个类，一个是名为 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

 

另请参见

else statement  
用法
  
if (condition) { // statement(s) } else { // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定当 if 语句中的条件返回 false 时要运行的语句。如果要执行的语句只有一条，则用来括起要由 else 语句执行的语句的大括号 ({}) 是不必要的。

 

参数
  condition:Boolean — 一个计算结果为 true 或 false 的表达式。

示例
如何使用示例
在以下示例中，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"); }

 

另请参见

extends definition keyword  
用法
  
class className extends otherClassName {} interface interfaceName extends otherInterfaceName {}

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

定义一个类，该类是另一个类的子类。子类继承超类中定义的所有方法、属性、函数等。标记为 final 的类不能扩展。

您还可以使用 extends 关键字扩展接口。扩展另一个接口的接口包含原始接口的所有方法声明。

注意：若要使用此关键字，必须在 FLA 文件的“Publish Settings”对话框的“Flash”选项卡上指定 ActionScript 2.0 和 Flash Player 6 或更高版本。仅支持在外部脚本文件中使用此关键字，而不支持在使用“Actions”面板编写的脚本中使用此关键字。

 

 

参数
  className:Class — 您定义的类的名称。

示例
如何使用示例
在以下示例中，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"); } } }
以下示例显示同一目录下的第二个 ActionScript 文件，该文件名为 Car.as。此类扩展了 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，也在同一目录中。Truck 类在构造函数中和被覆盖的reverse() 方法中使用 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

 

另请参见

false primary expression keyword  
用法
  
false

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

代表 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

 

另请参见

final attribute keyword  
用法
  
final function methodName() { // your statements here } final class className {}

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定不能覆盖某个方法或不能扩展某个类。尝试覆盖标记为 final 的方法或扩展带有此标记的类将发生错误。

 

参数
  methodName:Function — 不能覆盖的方法的名称。
  className:Class — 不能扩展的类的名称。

另请参见

flash_proxy namespace  

 

定义 Proxy 类的方法。Proxy 类方法位于自己的命名空间中，这样，当 Proxy 子类包含的实例方法名称与任一 Proxy 类方法名称相同时，可以避免发生名称冲突。

另请参见

flash10 namespace  

 

定义 Flash Player 10 类的方法和属性，它们是固定属性，而非原型属性。使用固定属性通常可以提供更好的性能，但会影响与 ECMAScript edition 3 语言规范 (ECMA-262) 的向后兼容性。

另请参见

for statement  
用法
  
for ([init]; [condition]; [next]) { // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

计算一次 init（初始化）表达式，然后开始一个循环序列。此循环序列从计算 condition 表达式开始。如果condition 表达式的计算结果为 true，则执行 statement 并计算 next。然后，此循环序列再次从计算condition 表达式开始。

如果要执行的语句只有一条，则用来括起要由 for 语句执行的语句块的大括号 ({}) 是不必要的。

 

 

参数
  init — 在开始循环序列之前要计算的可选表达式；通常为赋值表达式。还允许对此参数使用 var 语句。
  condition — 在开始循环序列之前要计算的可选表达式；通常为比较表达式。如果该表达式的计算结果为 true，则执行与 for语句相关联的语句。
  next — 在循环序列之后要计算的可选表达式；通常为递增或递减表达式。

示例
如何使用示例
以下示例使用 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

 

另请参见

for..in statement  
用法
  
for (variableIterant:String in object){ // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

迭代对象的动态属性或数组中的元素，并对每个属性或元素执行 statement。对象属性没有特定的保存顺序，因此属性可能以看似随机的顺序出现。固定属性（如类中定义的变量和方法）不能由 for..in 语句枚举。若要获取固定属性的列表，请使用 flash.utils 包中的 describeType() 函数。

 

参数
  variableIterant:String — 要作为迭代变量的变量的名称，迭代变量将引用对象的每个属性或数组中的每个元素。

示例
如何使用示例
以下示例使用 for..in 遍历某个对象的属性。 
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; for (var prop in myObject) { trace("myObject."+prop+" = "+myObject[prop]); }
以下示例将 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); } }

 

另请参见

for each..in statement  
用法
  
for each (variableIterant in object){ // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

遍历集合中的所有项目，并对每个项目执行 statement。for each..in 语句作为 E4X 语言扩展的一部分引入，不仅可用于 XML 对象，还可用于其它对象和数组。for each..in 语句只能循环访问某个对象的动态属性，而不能访问固定属性。固定属性是指作为类定义的一部分来定义的属性。若要将 for each..in 语句与用户定义的类的实例结合使用，必须声明此类具有 dynamic 属性。

与 for..in 语句不同，for each..in 语句遍历对象属性的值，而不是属性名称。

 

 

参数
  variableIterant:* — 要作为迭代变量的变量的名称，迭代变量将引用集合中的项目。
  object:Object — 要遍历的集合的名称。此集合可以是 XML 对象、一般对象或数组。

示例
如何使用示例
以下示例使用 for each..in 遍历对象属性中存放的值： 
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; for each (var item in myObject) { trace(item); }
以下示例使用 for each..in 遍历数组的元素： 
var myArray:Array = new Array("one", "two", "three"); for each(var item in myArray) trace(item);
以下示例将 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); } }
以下示例说明如何使用 for each..in 遍历 XMLList 对象中的属性 (doc.p)： 
var doc:XML = <body> <p>Hello</p> <p>Hola</p> <hr /> <p>Bonjour</p> </body>; for each (var item in doc.p) { trace(item); }

 

另请参见

function definition keyword  
用法
  
function functionName([parameter0, parameter1,...parameterN]) : returnType{ // statement(s) } var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

包含为执行特定任务而定义的一组语句。可以在 SWF 文件中的某个位置定义函数，然后从该文件的其它脚本中调用它。定义函数时，还可以为其指定参数。参数是函数要用到的值的占位符。可以在每次调用同一个函数时为其传递不同的参数，这样就可在不同的情况下重复使用该函数。

在某个函数的 statement(s) 块中使用 return 语句将使函数生成或返回一个值。

用法 1：可以借助 function 关键字定义一个使用指定函数名、参数和语句的函数。当脚本调用函数时，就会执行函数定义中的语句。允许提前引用；在同一脚本中，函数可以先调用后声明。一个函数定义会替换同一函数先前的任何定义。只要是允许使用语句的地方就可使用此语法。

用法 2：还可以使用 function 创建一个匿名函数，并返回对它的引用。此语法用于表达式中，对于在对象中设置方法尤其有用。

若需要更多功能，可以在函数定义中使用 arguments 对象。arguments 对象通常用于创建可接受不同数量的参数的函数，以及创建递归的匿名函数。

 

 

参数
  functionName:Function — 新函数的名称。
  returnType:* — 返回值的数据类型。

示例
如何使用示例
以下示例定义函数 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); }

 

另请参见

get definition keyword  
用法
  
function get property() : returnType{ // your statements here }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

定义一个 getter 方法，可以像读取属性一样读取该方法。 getter 是一个特殊的函数，它返回使用 var 或const 关键字声明的属性的值。与其它方法不同，调用 getter 时不需要括号 (())，这使得 getter 看起来像是一个变量。

您可以使用 getter 为私有属性创建公用接口，进而应用信息隐藏原则。隐藏信息的优点在于即使私有属性的基础实现发生更改，公用接口仍保持不变。

getter 的另一项优点是在子类中可以被覆盖，而使用 var 或 const 声明的属性则不可以。

getter 可与 setter 结合使用来创建可读写的属性。若要创建只读属性，需要创建一个不带相应 setter 的 getter。若要创建只写属性，需要创建一个不带相应 getter 的 setter。

注意：若要使用此关键字，必须在 FLA 文件的“Publish Settings”对话框的“Flash”选项卡上指定 ActionScript 2.0 和 Flash Player 6 或更高版本。仅支持在外部脚本文件中使用此关键字，而不支持在使用“Actions”面板编写的脚本中使用此关键字。

 

 

参数
  property:* — get 所访问的属性的标识符；此值必须与相应的 set 命令中使用的值相同。
  returnType:* — 返回值的数据类型。

示例
如何使用示例
以下示例定义一个 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);

在跟踪 giants.name 时，使用 getter 方法返回该属性的值。

 

另请参见

if statement  
用法
  
if (condition) { // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

计算条件以确定要执行的下一条语句。如果条件为 true，Flash Player 将运行该条件后面大括号 ({}) 内的语句。如果条件为 false，Flash Player 将跳过大括号内的语句，而运行大括号后面的语句。将 if 语句与 else语句一起使用可在脚本中创建分支逻辑。

如果要执行的语句只有一条，则用来括起要由 if 语句执行的语句的大括号 ({}) 是不必要的。

 

 

参数
  condition:Boolean — 一个计算结果为 true 或 false 的表达式。

另请参见

implements definition keyword  
用法
  
myClass implements interface01 [, interface02 , ...]

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定类可以实现一个或多个接口。当类在实现某个接口时，此类必须定义该接口中声明的所有方法。 实现接口的类的任何实例都被视为此接口定义的数据类型中的成员。因此，如果类实例是第一个操作数，并且接口为第二个操作数，is 运算符就会返回 true；此外，还会基于由接口定义的数据类型进行强制类型转换。

注意：若要使用此关键字，必须在 FLA 文件的“Publish Settings”对话框的“Flash”选项卡上指定 ActionScript 2.0 和 Flash Player 6 或更高版本。仅支持在外部脚本文件中使用此关键字，而不支持在使用“Actions”面板编写的脚本中使用此关键字。

 

 

另请参见

import directive  
用法
  
import packageName.className import packageName.*

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

使得在外部定义的类和包对您的代码可用。 例如，如果您希望在脚本中使用 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 包中的所有类。那么，在该帧或时间轴的任意后续帧上，您都可以使用该包中的类的简单名称来引用它们：

// On Frame 1 of a FLA: import adobe.example.*; var myFoo:foo = new foo();

 

 

参数
  packageName:* — 已在单独的类文件中定义的包的名称。
  className:Class — 已在单独的类文件中定义的类的名称。

另请参见

include directive  
用法
  
include "[path]filename.as"

 

包含指定文件的内容，就好像文件中的命令是调用脚本的一部分一样。 include 指令用于在编译时调用。因此，如果对包含的文件进行了任何更改，都必须保存该文件并重新编译使用该文件的所有 SWF 文件。

另请参见

interface definition keyword  
用法
  
interface InterfaceName [extends InterfaceName ] {}

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

定义接口。接口是定义了一组方法的数据类型；这些方法必须由实现接口的任意类定义。

接口与类相似，但存在以下重要区别：

  • 接口仅包含方法的声明，而不包含其实现。也就是说，实现接口的每个类都必须为该接口中声明的每个方法提供实现。
  • 接口方法定义不能包含任何属性（如 public 或 private），但在实现接口的类的定义中，已实现的方法必须标记为 public。
  • 通过 extends 语句可以使用一个接口继承多个接口，通过 implements 语句可以使用一个类继承多个接口。

与 ActionScript 2.0 不同，ActionScript 3.0 允许在接口定义中使用 getter 和 setter 方法。

注意：若要使用此关键字，必须在 FLA 文件的“Publish Settings”对话框的“Flash”选项卡上指定 ActionScript 2.0 和 Flash Player 6 或更高版本。仅支持在外部脚本文件中使用此关键字，而不支持在使用“Actions”面板编写的脚本中使用此关键字。

 

另请参见

internal attribute keyword  
用法
  
[internal] var varName [internal] const kName [internal] function functionName() { // your statements here } [internal] class className{ // your statements here } [internal] namespace nsName

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定类、变量、常数或函数可供同一个包中的任何调用程序使用。默认情况下，类、属性和方法属于 internal命名空间。

 

参数
  className:Class — 要指定为 internal 的类的名称。
  varName:* — 要指定为 internal 的变量的名称。无论此变量是否为类的一部分，都可以应用 internal 属性。
  kName:* — 要指定为 internal 的常数的名称。无论此常数是否为类的一部分，都可以应用 internal 属性。
  functionName:Function — 要指定为 internal 的函数或方法的名称。无论此函数是否为类的一部分，都可以应用 internal 属性。
  nsName:Namespace — 要指定为 internal 的命名空间的名称。无论此命名空间是否为类的一部分，都可以应用 internal 属性。

另请参见

label statement  
用法
  
label: statement label: { statements }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

将语句与可由 break 或 continue 引用的标识符相关联。在嵌套循环中，不引用标签的 break 或 continue 语句只跳过当前循环的其余部分，而不是跳出整个系列的循环。然而，如果定义整个循环系列的语句具有相关联的标签，则 break 或 continue 语句通过引用该标签便可以跳过整个系列的循环。

您还可以使用标签跳出块语句。仅当块语句为循环的一部分时，才可以将不能引用标签的 break 语句放置在块语句内。如果块语句具有相关联的标签，则可以将引用该标签的 break 语句放置在块语句内。

 

 

参数
  label:* — 与语句相关联的有效的标识符。
  statements:* — 与标签相关联的语句。

示例
如何使用示例
以下示例显示了如何结合使用标签和嵌套循环跳出整个系列的循环。此代码使用嵌套循环生成一个从 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); } }

以下示例显示了如何结合使用标签和块语句。在以下示例中，块语句标记为 foo，因此 break 语句可跳过块中的最终语句：

foo: { trace("a"); break foo; trace("b"); } // a

 

另请参见

namespace definition keyword  
用法
  
namespace name [= uri]

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

允许您控制定义的可见性。预定义的命名空间包括 public、private、protected 和 internal。

下列步骤显示了如何创建、应用和引用命名空间：

  • 首先，使用 namespace 关键字定义自定义命名空间。例如，代码 namespace version1 可以创建名为version1 的命名空间。
  • 其次，通过在属性或方法声明中使用自定义命名空间，将该命名空间应用到相应的属性或方法中。例如，代码 version1 myProperty:String 可创建名为 myProperty 的属性，该属性属于 version1 命名空间。
  • 再次，通过使用 use 关键字或将命名空间作为标识符的前缀来引用命名空间。例如，代码 use namespace version1; 可为对后续代码行引用 version1 命名空间；代码 version1::myProperty 可为 myProperty 属性引用 version1 命名空间。

 

 

参数
  name:Namespace — 命名空间的名称，可能是任何合法的标识符。
  uri:String — 命名空间的统一资源标识符 (URI)。这是可选参数。

另请参见

native attribute keyword  
用法
  
native function functionName(); class className { native function methodName(); }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定函数或方法是由 Flash Player 在本机代码中实现的。Flash Player 在内部使用 native 关键字声明 ActionScript 应用程序编程接口 (API) 中的函数和方法。此关键字不能在您自己的代码中使用。  

null primary expression keyword  
用法
  
null

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

一个特殊值，可以赋给变量，而如果未提供任何数据，也可以由函数返回。可以使用 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"); } }

 

另请参见

object_proxy namespace  

 

定义 ObjectProxy 类的方法。ObjectProxy 类方法位于自己的命名空间中，这样，当 Proxy 子类包含的实例方法名称与任一 Proxy 类方法名称相同时，可以避免发生名称冲突。

override attribute keyword  
用法
  
override function name() { // your statements here }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定使用某种方法替换继承的方法。若要覆盖继承的方法，则必须使用 override 属性，并确保参数的名称、数量和类型以及返回类型都完全匹配。尝试在不使用 override 属性的情况下覆盖方法会出现错误。同样，如果与该方法匹配的继承方法，那么使用 override 属性也会出现错误。

对以下各项都不能使用 override 属性：

  • 变量
  • 常数
  • 静态方法
  • 并非继承而来的方法
  • 用于实现接口方法的方法
  • 在超类中标记为 final 的继承方法

虽然不能覆盖使用 var 或 const 声明的属性，但可以将基类属性设置为 getter-setter 然后覆盖使用 get 和set 定义的方法，进而实现类似的功能。

 

 

参数
  name:Function — 要覆盖的方法的名称。

另请参见

package definition keyword  
用法
  
package packageName { class someClassName { } }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

允许您将代码组织到可由其它脚本导入的分散组中。必须使用 package 关键字指示类是包的成员。

 

参数
  packageName:* — 包的名称。

另请参见

private attribute keyword  
用法
  
class className{ private var varName; private const kName; private function methodName() { // your statements here } private namespace nsName; }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定变量、常数或方法只可由声明或定义它的类使用。与 ActionScript 2.0 不同，ActionScript 3.0 中的private 不再提供对子类的访问权限。而且，在编译时和运行时 private 都限制访问。默认情况下，变量或函数可供同一个包中的任何调用程序使用。若要限制对某个变量或函数的访问，可使用此关键字。

您只能在类定义中使用此关键字，而不能在接口定义中使用。不能将 private 应用于类或任何其它的包级定义。

 

 

参数
  varName:* — 要指定为 private 的变量的名称。仅当变量在类的内部时，才可以应用 private 属性。
  kName:* — 要指定为 private 的常数的名称。仅当常数在类的内部时，才可以应用 private 属性。
  methodName:Function — 要指定为 private 的方法的名称。仅当方法在类的内部时，才可以应用 private 属性。
  nsName:Namespace — 要指定为 private 的命名空间的名称。仅当命名空间在类的内部时，才可以应用 private 属性。

示例
如何使用示例
以下示例演示如何使用 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 中也不可以。尝试访问该私有变量将生成错误。

 

另请参见

protected attribute keyword  
用法
  
class className{ protected var varName; protected const kName; protected function methodName() { // your statements here } protected namespace nsName; }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定变量、常数、方法或命名空间只可由定义它的子类使用。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 的子类也无妨。

 

 

参数
  varName:* — 要指定为 protected 的变量的名称。仅当变量在类的内部时，才可以应用 protected 属性。
  kName:* — 要指定为 protected 的常数的名称。仅当常数在类的内部时，才可以应用 protected 属性。
  methodName:Function — 要指定为 protected 的方法的名称。仅当方法在类的内部时，才可以应用 protected 属性。
  nsName:Namespace — 要指定为 protected 的命名空间的名称。仅当命名空间在类的内部时，才可以应用 protected 属性。

示例
如何使用示例
以下示例在 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 } }

 

另请参见

public attribute keyword  
用法
  
public var varName public const kName public function functionName() { // your statements here } public class className { // your statements here } public namespace nsName

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定类、变量、常数或方法可供任何调用程序使用。在默认情况下，类、变量和方法都是内部元素，这意味着它们只在当前包的内部可见。若要使类、变量或方法对所有调用程序都可见，则必须使用 public 属性。

 

参数
  className:Class — 要指定为 public 的类的名称。
  varName:* — 要指定为 public 的变量的名称。无论此变量是否为类的一部分，都可以应用 public 属性。
  kName:* — 要指定为 public 的常数的名称。无论此常数是否为类的一部分，都可以应用 public 属性。
  functionName:Function — 要指定为 public 的函数或方法的名称。无论此函数是否为类的一部分，都可以应用 public 属性。
  nsName:Namespace — 要指定为 public 的命名空间的名称。无论此命名空间是否为类的一部分，都可以应用 public 属性。

示例
如何使用示例
以下示例显示了如何在类文件中使用公共变量： 
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 类之外访问该变量都将生成编译时错误。

 

另请参见

return statement  
用法
  
function functionName () { return [expression] }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

立即将执行结果返回到调用函数。如果 return 语句后面是一个表达式，则计算该表达式并返回结果。

如果函数定义包括返回类型，则 return 语句后面必须跟有一个表达式。如果未指定返回类型，并且是单独使用return 语句，那么它将返回 undefined。

不能返回多个值。如果尝试此操作，只能返回最后一个值。在以下示例中，将返回 c：

return a, b, c ;

如果需要返回多个值，可以改用数组或对象。

 

 

参数
  expression:* — 要进行计算并作为函数值返回的表达式。此参数是可选的。

 

结果
  * — 计算后的 expression 参数（如果提供）。

示例
如何使用示例
以下示例在 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

 

另请参见

set definition keyword  
用法
  
function set property(newValue:*) : void{ // your statements here }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

定义一个 setter 方法，用作公用接口中的属性。 setter 是一种特殊的方法，它可以为使用 var 关键字声明的属性设置值。与其他方法不同，调用 setter 时不需要使用圆括号 (())，这使得 setter 看起来像是变量。

您可以使用 setter 为私有属性创建公用接口，进而应用信息隐藏原则。隐藏信息的优点在于即使私有属性的基础实现发生更改，公用接口仍保持不变。

setter 的另一项优点是在子类中可以被覆盖，而使用 var 声明的属性则不可以。

setter 的返回类型必须是 void 或不指定任何类型。

setter 可与 getter 结合使用来创建可读写的属性。若要创建只读属性，需要创建一个不带相应 setter 的 getter。若要创建只写属性，需要创建一个不带相应 getter 的 setter。

注意：仅支持在外部脚本文件中使用此关键字，而不支持在使用“Actions”面板编写的脚本中使用此关键字。

 

 

参数
  property:* — 由 set 修改的属性的标识符；此值必须与对应的 get 命令使用的值相同。
  newValue:* — 要分配的新值。

示例
如何使用示例
以下示例通过定义 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

 

另请参见

static attribute keyword  
用法
  
class someClassName{ static var varName; static const kName; static function methodName() { // your statements here } }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定变量、常数或方法属于类，而不是属于类的实例。

若要访问静态类成员，请使用该类的名称而不是实例的名称。例如，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 关键字。

注意：仅支持在外部脚本文件中使用此关键字，而不支持在使用“Actions”面板编写的脚本中使用此关键字。

 

 

参数
  varName:* — 要指定为 static 的变量的名称。
  kName:* — 要指定为 static 的常数的名称。
  methodName:Function — 要指定为 static 的方法的名称。

示例
如何使用示例
以下示例演示如何使用 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

 

另请参见

super statement  
用法
  
super([arg1, ..., argN]) super.method([arg1, ..., argN])

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

调用方法或构造函数的超类版本或父版本。在类构造函数体中使用 super() 语句时，该语句可调用构造函数的超类版本。调用超类构造函数必须拥有正确的参数数量。请注意，超类构造函数始终会被调用，与是否显式调用无关。如果没有显式调用它，则会在子类构造函数体中的第一条语句前自动插入不包含参数的调用。这意味着，如果您在子类中定义了一个构造函数，并且超类构造函数使用了一个或多个参数，就必须使用正确数量的参数显式调用此超类构造函数，否则将出现错误。然而，与 ActionScript 2.0 不同，对超类构造函数的调用不需要是子类构造函数中的第一条语句。

在实例方法体中使用 super 时，它可以与点 (.) 运算符结合用于调用某种方法的超类版本，还可以选择将参数(arg1 ... argN) 传递给超类方法。如果要创建的子类方法不仅可以向超类方法添加其他行为，还可以调用超类方法执行其原始行为，这将非常有用。

不能在静态方法中使用 super 语句。

 

 

参数
  method:Function — 要在超类中调用的方法。
  argN:* — 可选参数，用于传递给方法的超类版本或超类的构造函数。

另请参见

switch statement  
用法
  
switch (expression) { caseClause: [defaultClause:] }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

将控制权传递给多条语句之一，具体取决于表达式的值。所有 switch 语句都应该包括一个默认的 case，如果不存在与表达式匹配的 case 语句，则执行此默认 case。每条 case 语句都应以 break 语句结束，这可以防止出现“失败”错误。当某个 case 失败时，则执行下一条 case 语句中的代码，即使该代码与测试表达式不匹配也不例外。

 

参数
  expression:* — 任何表达式。

示例
如何使用示例
以下示例定义一个落空到默认 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

 

另请参见

this primary expression keyword  
用法
  
this

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

对方法中包含的对象的引用。执行脚本时，this 关键字会引用包含此脚本的对象。在方法体中，this 关键字引用包含所调用的方法的类实例。


示例
如何使用示例
若要调用在动态类中定义的函数，必须使用 this 在适当的作用域中调用此函数： 
// incorrect version of Simple.as // 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 版本不正确，则会提示语法错误，此错误在上述示例中已被注释掉。

 

另请参见

throw statement  
用法
  
throw expression

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

生成或抛出一个可由 catch 代码块处理或捕获的错误。如果异常未被 catch 块捕获，则抛出的值的字符串表示形式将被发送到“Output”面板。如果异常未被 catch 或 finally 块捕获，则抛出的值的字符串表示形式将被发送到日志文件。

通常，您会抛出 Error 类或其子类的实例（请参见“示例”部分）。

 

 

参数
  expression:* — 一个 ActionScript 表达式或对象。

示例
如何使用示例
在此示例中，名为 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.

 

另请参见

true primary expression keyword  
用法
  
true

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

代表 true 的布尔值。布尔值可以为 true 或 false，true 与 false 是对立的。如果自动数据类型转换将true 转换为数字，则为 1；如果将 true 转换为字符串，则为 "true"。


示例
如何使用示例
以下示例说明了如何在 if 语句中使用 true： 
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

 

另请参见

try..catch..finally statement  
用法
  
try { // try block } finally { // finally block } try { // try block } catch(error[:ErrorType1]) { // catch block } [catch(error[:ErrorTypeN]) { // catch block }] [finally { // finally block }]

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

包含一个代码块，如果该代码块内发生错误，则对错误进行响应。 使用 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 处理函数。

 

 

参数
  error:* — 从 throw 语句中抛出的表达式通常是 Error 类或其某个子类的实例。

示例
如何使用示例
以下示例演示了 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()); }

 

另请参见

use namespace directive  
用法
  
use namespace ns1[, ns2, ...nsN]

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

将指定的命名空间添加到打开的命名空间集。 退出当前的代码块时，将从打开的命名空间集中删除指定的命名空间。use namespace 指令可以位于程序顶层、包定义或类定义中。

 

参数
  nsN:Namespace — 要添加到打开的命名空间集中的一个或多个命名空间。

另请参见

var definition keyword  
用法
  
var variableName [= value1][...,variableNameN[=valueN]]

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

指定一个变量。如果变量是在函数内部声明的，则该变量是局部变量。这些变量是为该函数定义的，在函数调用结束时到期。

如果变量是在函数外部声明的，则该变量在包含该语句的整个时间轴上都是可用的。

 

不能将位于另一个对象的作用域中的变量声明为局部变量。

my_array.length = 25; // ok var my_array.length = 25; // syntax error

您可以通过在数据类型后追加冒号字符来将该数据类型分配给一个变量。

您可以在一条语句中声明多个变量，并使用逗号分隔每个声明（但此语法可能会降低代码的清晰度）：

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

 

 

参数
  variableName:* — 一个标识符。

示例
如何使用示例
以下 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

 

另请参见

while statement  
用法
  
while (condition) { // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  Flash Player 9

 

计算一个条件。如果该条件的计算结果为 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 语句执行的语句的大括号 ({}) 是不必要的。

 

 

参数
  condition:Boolean — 一个计算结果为 true 或 false 的表达式。

示例
如何使用示例
在以下示例中，while 语句用于测试表达式。当 i 的值小于 20 时，跟踪 i 的值。当条件不再为 true 时，将退出循环。 
var i:Number = 0; while (i < 20) { trace(i); i += 3; }

 

另请参见

with statement  
用法
  
with (object:Object) { // statement(s) }

 

语言版本 :  ActionScript 3.0
RuntimeVersions:  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 对象（当脚本调用的函数包含该函数中调用的局部变量时自动创建的临时对象）
  • 包含当前执行的脚本的对象
  • Global 对象（诸如 Math 和 String 等内置对象）

若要在 with 语句内部设置变量，必须首先在 with 语句外部声明该变量，或者必须输入该变量所处时间轴的完整路径。如果在 with 语句中设置了未经声明的变量，则 with 语句将根据作用域链查找该值。如果该变量尚不存在，则将在调用 with 语句的时间轴上设置此新值。

 

 

参数
  object:Object — ActionScript 对象或影片剪辑的实例。

示例
如何使用示例
以下示例首先设置 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);
posted on 2012-01-11 10:06  星^_^風  阅读(332)  评论(0)  编辑  收藏  举报
Copyright © 2024 星^_^風
Powered by .NET 8.0 on Kubernetes Powered By: 博客园