爱华网描述
第 1-4 章，ActionScript 编程概述
讨论 ActionScript 3.0 核心概念，其中包括语言语法、语句和运算符、ECMAScript 第4 版语言规范草案、面向对象的 ActionScript 编程以及管理 Adobe® Flash® Player 9 显示列表中的显示对象的新方法。
第 5-10 章，ActionScript 3.0 核心数据类型和类
介绍 ActionScript 3.0 中的顶级数据类型（也是 ECMAScript 规范草案的一部分）。
第 11-26 章，Flash Player API
介绍在特定于 Adobe Flash Player 9 的包和类中实现的重要功能，其中包括事件处理、网络和通信、文件输入和输出、外部接口、应用程序安全模型等。
ActionScript 快速入门
关于 ActionScript
ActionScript 是由 Flash Player 中的 ActionScript 虚拟机 (AVM) 来执行的。ActionScript 代码通常被编译器编译成"字节码格式"（一种由计算机编写且能够为计算机所理解的编程语言），如 Adobe Flash CS3 Professional 或 Adobe® Flex™ Builder™ 的内置编译器或 Adobe® Flex™ SDK 和 Flex™ Data Services 中提供的编译器。字节码嵌入 SWF 文件中，SWF 文件由运行时环境 Flash Player 执行。
ActionScript 3.0 中的一些主要功能包括：
一个新增的 ActionScript 虚拟机，称为 AVM2，它使用全新的字节码指令集，可使性能显著提高。
一个更为先进的编译器代码库，它更为严格地遵循 ECMAScript (ECMA 262) 标准，并且相对于早期的编译器版本，可执行更深入的优化。
一个扩展并改进的应用程序编程接口 (API)，拥有对对象的低级控制和真正意义上的面向对象的模型。
一种基于即将发布的 ECMAScript (ECMA-262) 第 4 版草案语言规范的核心语言。
一个基于 ECMAScript for XML (E4X) 规范（ECMA-357 第 2 版）的 XML API。E4X 是 ECMAScript 的一种语言扩展，它将 XML 添加为语言的本机数据类型。
一个基于文档对象模型 (DOM) 第 3 级事件规范的事件模型。
编程基础
计算机程序主要包括两个方面：一、程序是计算机执行的一系列指令或步骤。 二、每一步最终都涉及到对某一段信息或数据的处理。 通常认为，计算机程序只是您提供给计算机并让它逐步执行的指令列表。每个单独的指令都称为"语句"。在 ActionScript 中编写的每个语句的末尾都有一个分号。实质上，程序中给定指令所做的全部操作就是处理存储在计算机内存中的一些数据位。
变量和常量
"变量"是一个名称，它代表计算机内存中的值。在编写语句来处理值时，编写变量名来代替值；只要计算机看到程序中的变量名，就会查看自己的内存并使用在内存中找到的值。
在 ActionScript 3.0 中，一个变量实际上包含三个不同部分：
变量名 计算机将名称用作值的占位符。
可以存储在变量中的数据的类型
存储在计算机内存中的实际值
在 ActionScript 中，要创建一个变量（称为"声明"变量），应使用 var 语句。
在 Adobe Flash CS3 Professional 中，还包含另外一种变量声明方法。在将一个影片剪辑元件、按钮元件或文本字段放置在舞台上时，可以在"属性"检查器中为它指定一个实例名称。在后台，Flash 将创建一个与该实例名称同名的变量，您可以在 ActionScript 代码中使用该变量来引用该舞台项目。
数据类型
在 ActionScript 中，您可以将很多数据类型用作所创建的变量的数据类型。其中的某些数据类型可以看作是"简单"或"基本"数据类型：
String：一个文本值
Numeric：对于 numeric 型数据，ActionScript 3.0 包含三种特定的数据类型：
Number：任何数值，包括有小数部分或没有小数部分的值
Int：一个整数（不带小数部分的整数）
Uint：一个"无符号"整数，即不能为负数的整数
Boolean：一个 true 或 false 值
简单数据类型表示单条信息。然而，ActionScript 中定义的大部分数据类型都可以被描述为复杂数据类型，因为它们表示组合在一起的一组值。
大部分内置数据类型以及程序员定义的数据类型都是复杂数据类型。您可能认识下面的一些复杂数据类型：
MovieClip：影片剪辑元件
TextField：动态文本字段或输入文本字段
SimpleButton：按钮元件
Date：有关时间中的某个片刻的信息（日期和时间）
经常用作数据类型的同义词的两个词是类和对象。"类"仅仅是数据类型的定义 ─ 就像用于该数据类型的所有对象的模板，而"对象"仅仅是类的一个实际的实例。下面几条陈述虽然表达的方式不同，但意思是相同的：
变量 myVariable 的数据类型是 Number。
变量 myVariable 是一个 Number 实例。
变量 myVariable 是一个 Number 对象。
变量 myVariable 是 Number 类的一个实例。
处理对象
在面向对象的编程中，程序指令被划分到不同的对象中 ─ 代码构成功能块，因此相关类型的功能或相关的信息被组合到一个容器（即 类）中。
在 ActionScript 面向对象的编程中，任何类都可以包含三种类型的特性：属性、 方法 、事件。
属性 表示某个对象中绑定在一起的若干数据块中的一个。您可以像处理单个变量那样处理属性；事实上，可以将属性视为包含在对象中的"子"变量。
将变量用作对象的名称，后跟一个句点 (.) 和属性名。句点称为"点运算符"，用于指示您要访问对象的某个子元素。整个结构"变量名-点-属性名"的使用类似于单个变量，变量是计算机内存中的单个值的名称。
方法 是指可以由对象执行的操作。可以通过依次写下对象名（变量）、句点、方法名和小括号来访问方法，这与属性类似。小括号是指示要"调用"某个方法的方式。有时，为了传递执行动作所需的额外信息，将值（或变量）放入小括号中。这些值称为方法"参数"。
与属性（和变量）不同的是，方法不能用作值占位符。然而，一些方法可以执行计算并返回可以像变量一样使用的结果。
事件 事件是确定计算机执行哪些指令以及何时执行的机制。本质上，"事件"就是所发生的、ActionScript 能够识别并可响应的事情。
基本事件处理
指定为响应特定事件而应执行的某些动作的技术称为"事件处理"。
在编写执行事件处理的 ActionScript 代码时，您需要识别三个重要元素：
事件源：发生该事件的是哪个对象？事件源也称为"事件目标"，因为 Flash Player 将此
对象（实际在其中发生事件）作为事件的目标。
事件：将要发生什么事情，以及您希望响应什么事情？识别事件是非常重要的，因为许多
对象都会触发多个事件。
响应：当事件发生时，您希望执行哪些步骤？
无论何时编写处理事件的 ActionScript 代码，都会包括这三个元素，并且代码将遵循以下基本结构（以粗体显示的元素是您将针对具体情况填写的占位符）：
function eventResponse(eventObject:EventType):void
{
// 此处是为响应事件而执行的动作。
}
eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);
此代码执行两个操作。首先，定义一个函数，这是指定为响应事件而要执行的动作的方法。接下来，调用源对象的 addEventListener() 方法，实际上就是为指定事件"订阅"该函数，以便当该事件发生时，执行该函数的动作。
"函数"提供一种将若干个动作组合在一起、用类似于快捷名称的单个名称来执行这些动作的方法。函数与方法完全相同，只是不必与特定类关联（事实上，方法可以被定义为与特定类关联的函数）。在创建事件处理函数时，必须选择函数名称（本例中为 eventResponse），还必须指定一个参数（本例中的名称为 eventObject）。指定函数参数类似于声明变量，所以还必须指明参数的数据类型。将为每个事件定义一个 ActionScript 类，并且为函数参数指定的数据类型始终是与要响应的特定事件关联的类。（即 此处的这个类的事件特性中必须包含要您希望要响应的事件。）最后，在左大括号与右大括号之间 ({ ...})，编写您希望计算机在事件发生时执行的指令。
一旦编写了事件处理函数，就需要通知事件源对象（发生事件的对象）您希望在该事件发生时调用函数。可通过调用该对象的 addEventListener() 方法来实现此目的（所有具有事件的对象都同时具有 addEventListener() 方法）。addEventListener() 方法有两个参数：
第一个参数是您希望响应的特定事件的名称。同样，每个事件都与一个特定类关联，而该类将为每个事件预定义一个特殊值；类似于事件自己的唯一名称（应将其用于第一个参数）。
第二个参数是事件响应函数的名称。请注意，如果将函数名称作为参数进行传递，则在写入函数名称时不使用括号。
了解事件处理过程
下面分步描述了创建事件侦听器时执行的过程。在本例中，您将创建一个侦听器函数，在单击名为 myButton 的对象时将调用该函数。
程序员实际编写的代码如下所示：
function eventResponse(event:MouseEvent):void
{
// Actions performed in response to the event go here.
}
myButton.addEventListener(MouseEvent.CLICK, eventResponse);
下面是此代码在 Flash Player 中运行时的实际工作方式：
1.加载 SWF 文件时，Flash Player 会注意到以下情况：有一个名为 eventResponse() 的函数。
2.Flash Player 随后运行该代码（具体地说，是指不在函数中的代码行）。在本例中，只有一行代码：针对事件源对象（名为 myButton）调用 addEventListener() 方法，并将 eventResponse 函数作为参数进行传递。
1.在内部，myButton 包含正在侦听其每个事件的函数的列表，因此，当调用其 addEventListener() 方法时，myButton 将 eventResponse() 函数存储在其事件侦听器列表中。
3.在某一时刻，用户单击 myButton 对象以触发其 click 事件（在代码中将其标识为 MouseEvent.CLICK）。
此时发生了以下事件：
1.Flash Player 创建一个对象，它是与所述事件（本示例中为 MouseEvent）关联的类的实例。对于很多事件，这是 Event 类的实例；对于鼠标事件，这是 MouseEvent 实例；对于其它事件，这是与该事件关联的类的实例。创建的该对象称为"事件对象"，它包含有关所发生的事件的特定信息：事件类型、发生位置以及其它特定于事件的信息（如果适用）。
2.Flash Player 随后查看 myButton 存储的事件侦听器的列表。它逐个查看这些函数，以调用每个函数并将事件对象作为参数传递给该函数。由于 eventResponse() 函数是 myButton 的侦听器之一，因此，Flash Player 将在此过程中调用 eventResponse() 函数。
3.当调用 eventResponse() 函数时，将运行该函数中的代码，因此，将执行您指定的动作。
创建对象实例
在 ActionScript 中使用对象之前，该对象首先必须存在。创建对象的步骤之一是声明变量；然而，声明变量仅仅是在计算机的内存中创建一个空位置。您必须为变量指定实际值 ─ 即创建一个对象并将它存储在该变量中 ─ 然后再尝试使用或处理该变量。创建对象的过程称为对象"实例化"；也就是说，创建特定类的实例。
有一种创建对象实例的简单方法完全不必涉及 ActionScript。在 Flash 中，当将一个影片剪辑元件、按钮元件或文本字段放置在舞台上，并在"属性"检查器中为它指定实例名时，Flash 会自动声明一个拥有该实例名的变量、创建一个对象实例并将该对象存储在该变量中。同样，在 Adobe Flex Builder 中，当您以 Adobe Macromedia® MXML™ 创建一个组件（通过用 MXML 标签进行编码或通过将组件放置在处于设计模式下的编辑器中）并为该组件分配一个 ID（在 MXML 标记中或在 Flex 属性视图中）时，该 ID 将成为一个 ActionScript 变量的名称，并且会创建该组件的一个实例并将它存储在该变量中。 （直观地创建对象。）
通过几种方法来仅使用 ActionScript 创建对象实例。
首先，借助几个 ActionScript 数据类型，可以使用"文本表达式"（直接写入 ActionScript 代码的值）创建一个实例。ActionScript 为Number 、int 、uint 、String 、Boolean 、Array、RegExp、XML 、Object 和 Function 数据类型定义了文本表达式。
对于其它任何数据类型而言，要创建一个对象实例，应将 new 运算符与类名一起使用，通常，将使用 new 运算符创建对象称为"调用类的构造函数"。"构造函数"是一种特殊方法，在创建类实例的过程中将调用该方法。请注意，当以此方法创建实例时，请在类名后加上小括号，有时还可以指定参数值 ─ 这是在调用方法时另外可执行的两个操作。
甚至对于可使用文本表达式创建实例的数据类型，也可以使用 new 运算符来创建对象实例。
如果需要创建无可视化表示形式的 ActionScript 数据类型的一个实例（无法通过将项目放置在 Flash 舞台上来创建，也无法在Flex Builder MXML 编辑器的设计模式下创建），则只能通过使用 new 运算符在ActionScript 中直接创建对象来实现此目的。
具体到 Flash 中，new 运算符还可用于创建已在库中定义、但没有放在舞台上的影片剪辑元件的实例。
常用编程元素
运算符 是用于执行计算的特殊符号（有时候是词）。
注释 "代码注释"是一个工具，用于编写计算机应在代码中忽略的文本。ActionScript 包括两种注释：
单行注释：在一行中的任意位置放置两个斜杠来指定单行注释。计算机将忽略斜杠后直到该行末尾的所有内容。
多行注释：多行注释包括一个开始注释标记 (/*)、注释内容和一个结束注释标记 (*/)。无论注释跨多少行，计算机都将忽略开始标记与结束标记之间的所有内容。
注释的另一种常见用法是临时禁用一行或多行代码。
流控制 就是用于控制执行哪些动作。ActionScript 中提供了几种类型的流控制元素。
函数：函数类似于快捷方式，提供了一种将一系列动作组合到单个名称下的方法，并可用于执行计
算。函数对于处理事件尤为重要，但也可用作组合一系列指令的通用工具。
循环：使用循环结构，可指定计算机反复执行一组指令，直到达到设定的次数或某些条件改变为止。
通常借助循环并使用一个其值在计算机每执行完一次循环后就改变的变量来处理几个相关项。
条件语句：条件语句提供一种方法，用于指定仅在某些情况下才执行的某些指令或针对不同的条件
提供不同的指令集。最常见的一类条件语句是 if 语句。if 语句检查该语句括号中的值或表达式。如果值为 true，则执行大括号中的代码行；否则，将忽略它们。
使用 ActionScript 构建应用程序
您可以使用 ActionScript 3.0 代码来实现任何目的，从简单的图形动画到复杂的客户端 ─ 服务器事务处理系统都可以通过它来实现。
将代码存储在 Flash 时间轴中的帧中
在 Flash 创作环境中，可以向时间轴中的任何帧添加 ActionScript 代码。该代码将在影片播放期间播放头进入该帧时执行。构建较大的应用程序时，这会容易导致无法跟踪哪些帧包含哪些脚本，应用程序越来越难以维护。
许多开发人员将代码仅仅放在时间轴的第 1 帧中，或放在 Flash 文档中的特定图层上，以简化在 Flash 创作工具中组织其 ActionScript 代码的工作。这样，就可以容易地在 Flash FLA 文件中查找和维护代码。
如果想要以后能够在其它 Flash 项目中使用您的 ActionScript 代码，您需要将代码存储在外部 ActionScript 文件（扩展名为 .as 的文本文件）中。
将代码存储在 ActionScript 文件中
可以采用以下两种方式之一来设置 ActionScript 文件的结构：
非结构化 ActionScript 代码：编写 ActionScript 代码行（包括语句或函数定义），就好像它们是直接在时间轴脚本、MXML 文件等文件中输入的一样。
使用 ActionScript 中的 include 语句或 Adobe Flex MXML 中的 <mx:Script> 标签，可以访问以此方式编写的 ActionScript。ActionScript include 语句会导致在特定位置以及脚本中的指定范围内插入外部 ActionScript 文件的内容，就好像它们是直接在那里输入的一样。在 Flex MXML 语言中，可使用 <mx:Script> 标签来指定源属性，从而标识要在应用程序中的该点处加载的外部 ActionScript 文件。
ActionScript 类定义：定义一个 ActionScript 类，包含它的方法和属性。
定义一个类后，您就可以像对任何内置的 ActionScript 类所做的那样，通过创建该类的一个实例并使用它的属性、方法和事件来访问该类中的 ActionScript 代码。这要求做到下面两点：
使用 import语句来指定该类的全名，以便ActionScript 编译器知道可以在哪里找到它。
此规则的唯一例外是，如果在代码中引用的类为顶级类，没有在包中定义，则必须导入该类。
在 Flash 中，将自动为附加到时间轴上的帧的脚本导入内置类（在 flash.* 包中）。但是，如果您编写自己的类、处理 Flash 创作组件（fl.* 包）或在 Flex 中工作，则需要显式地导入任何类以编写用于创建该类实例的代码。
编写明确引用类名的代码（通常声明一个用该类作为其数据类型的变量，并创建该类的一个实例以便存储在该变量中）。在 ActionScript 代码中引用其它类名即通知编译器加载该类的定义。
选择合适的工具
Flash 创作工具
除了创建图形和动画的功能之外，Adobe Flash CS3 Professional 还包括处理 ActionScript 代码（附加到 FLA 文件中的元素的代码，或仅包含 ActionScript 代码的外部文件中的代码）的工具。Flash 创作工具最适合于涉及大量的动画或视频的项目，或者您希望自己创建大部分图形资源的项目，尤其适合于用户交互很少或者具有需要 ActionScript 的功能的项目。如果您希望在同一个应用程序中既创建可视资源又编写代码，也可能会选择使用 Flash 创作工具来开发 ActionScript 项目。如果您希望使用预置的用户界面组件，但 SWF 较小或便于设置可视外观是项目的主要考虑因素，那么您也可能会选择使用 Flash 创作工具。
Adobe Flash CS3 Professional 包括两个编写 ActionScript 代码的工具：
"动作"面板：在 FLA 文件中工作时可用，该面板允许您编写附加到时间轴上的帧的 ActionScript 代码。
"脚本"窗口："脚本"窗口是专门用于处理 ActionScript (.as) 代码文件的文本编辑器。
Flex Builder
Adobe Flex Builder 是创建带有 Flex 框架的项目的首选工具。除了可视布局和 MXML 编辑工具之外，Flex Builder 还包括一个功能完备的 ActionScript 编辑器，因此可用于创建 Flex 或仅包含 ActionScript 的项目。Flex 应用程序具有以下几个优点：包含一组内容丰富的预置用户界面控件和灵活的动态布局控件，内置了用于处理外部数据源的机制，以及将外部数据链接到用户界面元素。但由于需要额外的代码来提供这些功能，因此 Flex 应用程序的 SWF 文件可能比较大，并且无法像 Flash 应用程序那样轻松地完全重设外观。
如果希望使用 Flex 创建功能完善、数据驱动且内容丰富的 Internet 应用程序，并在一个工具内编辑 ActionScript 代码，编辑 MXML 代码，直观地设置应用程序布局，则应使用 Flex Builder。
第三方 ActionScript 编辑器
由于 ActionScript (.as) 文件存储为简单的文本文件，因此任何能够编辑纯文本文件的程序都可以用来编写 ActionScript 文件。您可以使用任何文本编辑程序来编写 MXML 文件或 ActionScript 类。然后，可以使用 Flex SDK（包括 Flex 框架类和 Flex 编译器）来基于这些文件创建 SWF 应用程序（Flex 或仅包含 ActionScript 的应用程序）。或者，很多开发人员也可以使用第三方 ActionScript 编辑器来编写 ActionScript 类，并结合使用 Flash 创作工具来创建图形内容。
在以下情况下，您可以选择使用第三方 ActionScript 编辑器：
您希望在单独的程序中编写 ActionScript 代码，而在 Flash 中设计可视元素。
将某个应用程序用于非 ActionScript 编程（例如，创建 HTML 页或以其它编程语言构建应用程序），并希望将该应用程序也用于 ActionScript 编码。
您希望使用 Flex SDK 而不用 Flash 和 Flex Builder 来创建仅包含 ActionScript 的项目或 Flex 项目。
有一些提供特定于 ActionScript 的支持的代码编辑器值得注意，其中包括：Adobe Dreamweaver® CS3 、ASDT、 FDT、 FlashDevelop 、PrimalScript、 SE|PY、 Xcode（带有 ActionScript 模板和代码提示文件）。
ActionScript 开发过程
ActionScript 3.0 的应用程序的基本开发过程：
1.设计应用程序。
您应先以某种方式描述应用程序，然后再开始构建该应用程序。
2.编写 ActionScript 3.0 代码。
您可以使用 Flash、Flex Builder、Dreamweaver 或文本编辑器来创建 ActionScript 代码。
3.创建 Flash 或 Flex 应用程序文件来运行代码。
在 Flash 创作工具中，此步骤包括：创建新的 FLA 文件、设置发布设置、向应用程序添加用户界面组件以及引用 ActionScript 代码。在 Flex 开发环境中，创建新的应用程序文件涉及：定义该应用程序并使用 MXML 来添加用户界面组件以及引用 ActionScript 代码。
4.发布和测试 ActionScript 应用程序。
这涉及在 Flash 创作环境或 Flex 开发环境中运行应用程序，确保该应用程序执行您期望的所有操作。
不必按顺序执行这些步骤，或者说不必在完全完成一个步骤后再执行另一步骤。虽然记住开发过程的这 4 个阶段是十分有用的，但在实际的开发过程中适当地调整各个阶段的顺序通常有助于提高效率。
创建自己的类
类设计策略 下面还是给出了几条建议以帮助您着手进行面向对象的编程。
1.请考虑一下该类的实例将在应用程序中扮演的角色。通常，对象担任以下三种角色之一：
值对象：这些对象主要用作数据的容器 ─ 也就是说，它们可能拥有若干个属性和很少的几个方法（有时没有方法）。值对象通常是明确定义的项目的代码表示。
显示对象：它们是实际显示在屏幕上的对象。例如，用户界面元素（如下拉列表或状态显示）和图形元素（如视频游戏中的角色）等等就是显示对象。
应用程序结构：这些对象在应用程序执行的逻辑或处理方面扮演着广泛的支持角色。
2.确定类所需的特定功能。不同类型的功能通常会成为类的方法。
3.如果打算将类用作值对象，请确定实例将要包含的数据。这些项是很好的候选属性。
4.由于类是专门为项目而设计的，因此最重要的是提供应用程序所需的功能。回答下列问题可能会对
您很有帮助：
应用程序将存储、跟踪和处理哪些信息？确定这些信息有助于您识别可能需要的值对象和属性。
需要执行哪些操作 ─ 例如，在应用程序首次加载时，在单击特定的按钮时，在影片停止播放时，分别需要执行哪些操作？这些是很好的候选方法（如果"动作"仅涉及更改单个值，则是很好的候选属性）。
对于任何给定的动作，要执行该动作，该类需要了解哪些信息？这些信息将成为方法的参数。
随着应用程序开始工作，应用程序的其它部分需要了解类中的哪些内容将发生更改？这些是很好的候选事件。
5.如果有一个现有的对象与您需要的对象类似，只是缺少某些您需要添加的一些额外功能，应考虑创
建一个子类（在现有类的功能的基础之上构建的类，不需要定义它自己的所有功能）。
编写类的代码
下面是创建自己的 ActionScript 类的最基本步骤：
1.在特定于 ActionScript 的程序（如 Flex Builder 或 Flash）、通用编程工具（如 Dreamweaver）或者可用来处理纯文本文档的任何程序中打开一个新的文本文档。
2.输入 class 语句定义类的名称。为此，输入单词 public class，然后输入类名，后跟一个左大括号和一个右大括号，两个括号之间将是类的内容（方法和属性定义）。 单词 public 表示可以从任何其它代码中访问该类。
3.键入 package 语句以指示包含该类的包的名称。语法是单词 package，后跟完整的包名称，再跟左大括号和右大括号（括号之间将是 class 语句块）。
4.使用var语句，在类体内定义该类中的每个属性；语法与用于声明任何变量的语法相同（并增加了public 修饰符）。
5.使用与函数定义所用的相同语法来定义类中的每个方法。例如：
要创建普通方法。
要创建一个构造函数（在创建类实例的过程中调用的特殊方法），应创建一个名称与类名称完全匹配的方法。
如果没有在类中包括构造函数方法，编译器将自动在类中创建一个空构造函数（没有参数和语句）。
您还可以定义其它几个类元素。这些元素更为复杂。
"存取器"是方法与属性之间的一个特殊交点。在编写代码来定义类时，可以像编写方法一样来编写存取器，这样就可以执行多个动作（而不是像在定义属性时那样，只能读取值或赋值）。但是，在创建类的实例时，可将存取器视为属性 ─ 仅使用名称来读取值或赋值。
ActionScript 中的事件不是使用特定的语法来定义的。应使用 EventDispatcher 类的功能来定义类中的事件，以便跟踪事件侦听器并将事件通知给它们。
有关组织类的一些建议
Adobe 建议您始终将每个类的源代码保存在其自己的文件中，并为文件指定与类相同的名称。
ActionScript 语言及其语法
ActionScript 3.0 既包含 ActionScript 核心语言又包含 Adobe Flash Player 应用程序编程接口 (API)。ActionScript 核心语言是 ActionScript 的一部分，实现了 ECMAScript (ECMA-262) 第 4 版语言规范草案。Flash Player API 提供对 Flash Player 的编程访问。
语言概述
对象是 ActionScript 3.0 语言的核心 ─ 它们是 ActionScript 3.0 语言的基本构造块。您所声明的每个变量、所编写的每个函数以及所创建的每个类实例都是一个对象。可以将 ActionScript 3.0 程序视为一组执行任务、响应事件以及相互通信的对象。
在ECMAScript 第 4 版草案（ActionScript 3.0 所基于的标准）中，对象只是属性的集合。这些属性是一些容器，除了保存数据，还保存函数或其它对象。以这种方式附加到对象的函数称为方法。
尽管具有 Java 或 C++ 背景的程序员可能会觉得 ECMAScript 草案中的定义有些奇怪，但实际上，用 ActionScript 3.0 类定义对象类型与在 Java 或 C++ 中定义类的方式非常相似。在讨论 ActionScript 对象模型和其它高级主题时，了解这两种对象定义之间的区别很重要，但在其它大多数情况下，"属性"一词都表示类成员变量（而不是方法），使用"方法"一词表示作为类的一部分的函数。
ActionScript 中的类与 Java 或 C++ 中的类之间有一个细小的差别，那就是 ActionScript 中的类不仅仅是抽象实体。ActionScript 类由存储类的属性和方法的类对象 表示，这样便可以使用可能不为 Java 和 C++ 程序员所熟悉的方法，例如，在类或包的顶级包括语句或可执行代码。
ActionScript类与Java 或 C++ 类之间还有一个区别，那就是每个 ActionScript 类都有一个"原型对象"。在早期的 ActionScript 版本中，原型对象链接成"原型链"，它们共同作为整个类继承层次结构的基础。但是，在 ActionScript 3.0 中，原型对象在继承系统中仅扮演很小的角色。但是，原型对象仍非常有用，如果您希望在类的所有实例中共享某个属性及其值，可以使用原型对象来代替静态属性和方法。
对象和类
在 ActionScript 3.0 中，每个对象都是由类定义的。可将类视为某一类对象的模板或蓝图。类定义中可以包括变量和常量以及方法，前者用于保存数据值，后者是封装绑定到类的行为的函数。存储在属性中的值可以是"基元值"，也可以是其它对象。基元值是指数字、字符串或布尔值。
ActionScript 中包含许多属于核心语言的内置类。其中的某些内置类（如 Number、Boolean 和 String）表示 ActionScript 中可用的基元值。其它类（如 Array、Math 和 XML）定义属于 ECMAScript 标准的更复杂对象。
所有的类（无论是内置类还是用户定义的类）都是从 Object 类派生的。以前在 ActionScript 方面有经验的程序员一定要注意到，Object 数据类型不再是默认的数据类型，尽管其它所有类仍从它派生。在 ActionScript 2.0 中，下面的两行代码等效，因为缺乏类型注释意味着变量为 Object 类型：
var someObj:Object;
var someObj;
但是，ActionScript 3.0 引入了无类型变量这一概念，这一类变量可通过以下两种方法来指定：
var someObj:*;
var someObj;
无类型变量与 Object 类型的变量不同。二者的主要区别在于无类型变量可以保存特殊值 undefined，而 Object 类型的变量则不能保存该值。
您可以使用 class 关键字来定义自己的类。在方法声明中，可通过以下三种方法来声明类属性 (property)：用 const 关键字定义常量，用 var 关键字定义变量，用 get 和 set 属性 (attribute) 定义 getter 和 setter 属性 (property)。可以用 function 关键字来声明方法。
可使用 new 运算符来创建类的实例。
包和命名空间
包和命名空间是两个相关的概念。使用包，可以通过有利于共享代码并尽可能减少命名冲突的方式将多个类定义捆绑在一起。使用命名空间，可以控制标识符（如属性名和方法名）的可见性。无论命名空间位于包的内部还是外部，都可以应用于代码。包可用于组织类文件，命名空间可用于管理各个属性和方法的可见性。
包
在 ActionScript 3.0 中，包是用命名空间实现的，但包和命名空间并不同义。在声明包时，可以隐式创建一个特殊类型的命名空间并保证它在编译时是已知的。显式创建的命名空间在编译时不必是已知的。
类位于包中，因此编译器在编译时会自动将其类名称限定为完全限定名称，编译器还限定任何属性或方法的名称。完全限定的包引用点运算符 (.) 来表示。
许多开发人员（尤其是那些具有 Java 编程背景的人）可能会选择只将类放在包的顶级。但是，ActionScript 3.0 不但支持将类放在包的顶级，而且还支持将变量、函数甚至语句放在包的顶级。此功能的一个高级用法是，在包的顶级定义一个命名空间，以便它对于该包中的所有类均可用。但是，请注意，在包的顶级只允许使用两个访问说明符：public 和 internal。Java 允许将嵌套类声明为私有，而 ActionScript 3.0 则不同，它既不支持嵌套类也不支持私有类。
您还可以在包名称中嵌入点来创建嵌套包，这样就可以创建包的分层结构。
创建包
ActionScript 3.0 允许在一个源文件中包括多个类，但是，每个文件中只有一个类可供该文件外部的代码使用。换言之，每个文件中只有一个类可以在包声明中进行声明。您必须在包定义的外部声明其它任何类，以使这些类对于该源文件外部的代码不可见。在包定义内部声明的类的名称必须与源文件的名称匹配。
在 ActionScript 3.0 中，尽管包仍表示目录，但是它现在不只包含类。在 ActionScript 3.0 中，使用 package 语句来声明包，这意味着您还可以在包的顶级声明变量、函数和命名空间，甚至还可以在包的顶级包括可执行语句。如果在包的顶级声明变量、函数或命名空间，则在顶级只能使用 public 和 internal 属性，并且每个文件中只能有一个包级声明使用 public 属性（无论该声明是类声明、变量声明、函数声明还是命名空间声明）。
包的作用是组织代码并防止名称冲突。您不应将包的概念与类继承这一不相关的概念混淆。位于同一个包中的两个类具有共同的命名空间，但是它们在其它任何方面都不必相关。同样，在语义方面，嵌套包可以与其父包无关。
导入包
如果您希望使用位于某个包内部的特定类，则必须导入该包或该类。
通常，import 语句越具体越好。如果您只打算使用包中的某个类，则应只导入该类，而不应导入该类所属的整个包。导入整个包可能会导致意外的名称冲突。
还必须将定义包或类的源代码放在类路径 内部。类路径是用户定义的本地目录路径列表，它决定了编译器将在何处搜索导入的包和类。类路径有时称为"生成路径"或"源路径"。
在正确地导入类或包之后，可以使用类的完全限定名称，也可以只使用类名称本身。
当同名的类、方法或属性会导致代码不明确时，完全限定的名称非常有用，但是，如果将它用于所有的标识符，则会使代码变得难以管理。包的嵌套级别越高，代码的可读性越差。如果您确信不明确的标识符不会导致问题，就可以通过使用简单的标识符来提高代码的可读性。
如果您尝试使用标识符名称，而不先导入相应的包或类，编译器将找不到类定义。另一方面，即便您导入了包或类，只要尝试定义的名称与所导入的名称冲突，也会产生错误。
创建包时，该包的所有成员的默认访问说明符是 internal，这意味着，默认情况下，包成员仅对其所在包的其它成员可见。如果您希望某个类对包外部的代码可用，则必须将该类声明为 public。
不能将 public 属性应用于包声明。
完全限定的名称可用来解决在使用包时可能发生的名称冲突。如果您导入两个包，但它们用同一个标识符来定义类，就可能会发生名称冲突。要解决此冲突，必须使用每个类的完全限定名称。
ActionScript 3.0有一个include 指令，但是它的作用不是为了导入类和包。要在ActionScript 3.0中导入类或包，必须使用 import 语句，并将包含该包的源文件放在类路径中。
命名空间
通过命名空间可以控制所创建的属性和方法的可见性。请将 public、private、protected 和 internal 访问控制说明符视为内置的命名空间。如果这些预定义的访问控制说明符无法满足您的要求，您可以创建自己的命名空间。
要了解命名空间的工作方式，有必要先了解属性或方法的名称总是包含两部分：标识符和命名空间。标识符通常被视为名称。
只要定义不以命名空间属性开头，就会用默认 internal 命名空间限定其名称，这意味着，它们仅对同一个包中的调用方可见。如果编译器设置为严格模式，则编译器会发出一个警告，指明 internal 命名空间将应用于没有命名空间属性的任何标识符。为了确保标识符可在任何位置使用，您必须在标识符名称的前面明确加上 public 属性。
使用命名空间时，应遵循以下三个基本步骤。
第一，必须使用 namespace 关键字来定义命名空间。例如，下面的代码定义 version1 命名空间：
namespace version1;
第二，在属性或方法声明中，使用命名空间（而非访问控制说明符）来应用命名空间。下面的示例将一个名为 myFunction() 的函数放在 version1 命名空间中：
version1 function myFunction() {}
第三，在应用了该命名空间后，可以使用 use 指令引用它，也可以使用该命名空间来限定标识符的名称。下面的示例通过 use 指令来引用 myFunction() 函数：
use namespace version1;
myFunction();
您还可以使用限定名称来引用 myFunction() 函数，如下面的示例所示：
version1::myFunction();
定义命名空间
命名空间中包含一个名为统一资源标识符 (URI) 的值，该值有时称为命名空间名称。使用 URI 可确保命名空间定义的唯一性。（统一资源标识符 (Uniform Resource Identifier, URI) 用于唯一地标识元素或属性的数字或名称。URI 包括统一资源名称 (URN) 和统一资源定位器 (URL)。）
可通过使用以下两种方法之一来声明命名空间定义，以创建命名空间：像定义 XML 命名空间那样使用显式 URI 定义命名空间；省略 URI。
下面的示例说明如何使用 URI 来定义命名空间：
namespace flash_proxy = "http://www.adobe.com/flash/proxy";
URI 用作该命名空间的唯一标识字符串。如果您省略 URI（如下面的示例所示），则编译器将创建一个唯一的内部标识字符串来代替 URI。您对于这个内部标识字符串不具有访问权限。
namespace flash_proxy;
在定义了命名空间（具有 URI 或没有 URI）后，就不能在同一个作用域内重新定义该命名空间。如果尝试定义的命名空间以前在同一个作用域内定义过，则将生成编译器错误。
如果在某个包或类中定义了一个命名空间，则该命名空间可能对于此包或类外部的代码不可见，除非使用了相应的访问控制说明符。例如，下面的代码显示了在 flash.utils 包中定义的 flash_proxy 命名空间。在下面的示例中，缺乏访问控制说明符意味着 flash_proxy 命名空间将仅对于 flash.utils 包内部的代码可见，而对于该包外部的任何代码都不可见：
package flash.utils
{
namespace flash_proxy;
}
下面的代码使用 public 属性以使 flash_proxy 命名空间对该包外部的代码可见：
package flash.utils
{
public namespace flash_proxy;
}
应用命名空间
应用命名空间意味着在命名空间中放置定义。可以放在命名空间中的定义包括函数、变量和常量（不能将类放在自定义命名空间中）。
例如，请考虑一个使用 public 访问控制命名空间声明的函数。在函数的定义中使用 public 属性会将该函数放在 public 命名空间中，从而使该函数对于所有的代码都可用。在定义了某个命名空间之后，可以按照与使用 public 属性相同的方式来使用所定义的命名空间，该定义将对于可以引用您的自定义命名空间的代码可用。例如，如果您定义一个名为 example1 的命名空间，则可以添加一个名为 myFunction() 的方法并将 example1 用作属性，如下面的示例所示：
namespace example1;
class someClass
{
example1 myFunction() {}
}
如果在声明 myFunction() 方法时将 example1 命名空间用作属性，则意味着该方法属于 example1 命名空间。
在应用命名空间时，应切记以下几点：
对于每个声明只能应用一个命名空间。
不能一次将同一个命名空间属性应用于多个定义。换言之，如果您希望将自己的命名空间应用于 10 个不同的函数，则必须将该命名空间作为属性分别添加到这 10 个函数的定义中。
如果您应用了命名空间，则不能同时指定访问控制说明符，因为命名空间和访问控制说明符是互斥的。换言之，如果应用了命名空间，就不能将函数或属性声明为 public、private、protected 或 internal。
引用命名空间
在使用借助于任何访问控制命名空间（如 public、private、protected 和 internal）声明的方法或属性时，无需显式引用命名空间。这是因为对于这些特殊命名空间的访问由上下文控制。例如，放在 private 命名空间中的定义会自动对于同一个类中的代码可用。但是，对于您所定义的命名空间，并不存在这样的上下文相关性。要使用已经放在某个自定义命名空间中的方法或属性，必须引用该命名空间。
可以用 use namespace 指令来引用命名空间，也可以使用名称限定符 (::) 来引用命名空间限定名称。用 use namespace 指令引用命名空间会打开该命名空间，这样它便可以应用于任何未限定的标识符。例如，如果您已经定义了 example1 命名空间，则可以通过使用 use namespace example1 来访问该命名空间中的名称：
use namespace example1;
myFunction();
一次可以打开多个命名空间。在使用 use namespace 打开了某个命名空间之后，它会在打开它的整个代码块中保持打开状态。不能显式关闭命名空间。
但是，如果同时打开多个命名空间则会增加发生名称冲突的可能性。如果您不愿意打开命名空间，则可以用命名空间和名称限定符来限定方法或属性名，从而避免使用 use namespace 指令。例如，下面的代码说明如何用 example1 命名空间来限定 myFunction() 名称：
example1::myFunction();
使用命名空间
在 Flash Player API 中的 flash.utils.Proxy 类中，可以找到用来防止名称冲突的命名空间的实例。Proxy 类取代了 ActionScript 2.0 中的 Object.__resolve 属性，可用来截获对未定义的属性或方法的引用，以免发生错误。为了避免名称冲突，将 Proxy 类的所有方法都放在 flash_proxy 命名空间中。
为了更好地了解 flash_proxy 命名空间的使用方法，您需要了解如何使用 Proxy 类。Proxy 类的功能仅对于继承它的类可用。换言之，如果您要对某个对象使用 Proxy 类的方法，则该对象的类定义必须是对 Proxy 类的扩展。例如，如果您希望截获对未定义的方法的调用，则应扩展 Proxy 类，然后覆盖 Proxy 类的 callProperty() 方法。
前面已讲到，实现命名空间的过程通常分为三步，即定义、应用然后引用命名空间。但是，由于您从不显式调用 Proxy 类的任何方法，因此只是定义和应用 flash_proxy 命名空间，而从不引用它。Flash Player API 定义 flash_proxy 命名空间并在 Proxy 类中应用它。在您的代码中，只需要将 flash_proxy 命名空间应用于扩展 Proxy 类的类。
flash_proxy 命名空间按照与下面类似的方法在 flash.utils 包中定义：
package flash.utils
{
public namespace flash_proxy;
}
该命名空间将应用于 Proxy 类的方法，如下面摘自 Proxy 类的代码所示：
public class Proxy
{
flash_proxy function callProperty(name:*, ... rest):*
flash_proxy function deleteProperty(name:*):Boolean
...
}
如下面的代码所示，您必须先导入 Proxy 类和 flash_proxy 命名空间。随后必须声明自己的类，以便它对 Proxy 类进行扩展（如果是在严格模式下进行编译，则还必须添加 dynamic 属性）。在覆盖 callProperty() 方法时，必须使用 flash_proxy 命名空间。
package
{
import flash.utils.Proxy;
import flash.utils.flash_proxy;
dynamic class MyProxy extends Proxy
{
flash_proxy override function callProperty(name:*, ...rest):*
{
trace("method call intercepted: " + name);
}
}
}
如果您创建 MyProxy 类的一个实例，并调用一个未定义的方法（如在下面的示例中调用的 testing() 方法），Proxy 对象将截获对该方法的调用，并执行覆盖后的 callProperty() 方法内部的语句（在本例中为一个简单的 trace() 语句）。
var mySample:MyProxy = new MyProxy();
mySample.testing(); // 已截获方法调用：测试
将 Proxy 类的方法放在 flash_proxy 命名空间内部有两个好处。第一个好处是，在扩展 Proxy 类的任何类的公共接口中，拥有单独的命名空间可提高代码的可读性。（在 Proxy 类中大约有 12 个可以覆盖的方法，所有这些方法都不能直接调用。将所有这些方法都放在公共命名空间中可能会引起混淆。）第二个好处是，当 Proxy 子类中包含名称与 Proxy 类方法的名称匹配的实例方法时，使用 flash_proxy 命名空间可避免名称冲突。例如，您可能希望将自己的某个方法命名为 callProperty()。下面的代码是可接受的，因为您所用的 callProperty() 方法位于另一个命名空间中：
dynamic class MyProxy extends Proxy
{
public function callProperty() {}
flash_proxy override function callProperty(name:*, ...rest):*
{
trace("method call intercepted: " + name);
}
}
当您希望以一种无法由四个访问控制说明符（public、private、internal 和 protected）实现的方式提供对方法或属性的访问时，命名空间也可能会非常有用。例如，您可能有几个分散在多个包中的实用程序方法。您希望这些方法对于您的所有包均可用，但是您不希望这些方法成为公共方法。为此，您可以创建一个新的命名空间，并将它用作您自己的特殊访问控制说明符。
下面的示例使用用户定义的命名空间将两个位于不同包中的函数组合在一起。通过将它们组合到同一个命名空间中，可以通过一条 use namespace 语句使这两个函数对于某个类或某个包均可见。
本示例使用四个文件来说明此方法。所有的文件都必须位于您的类路径中。第一个文件 (myInternal.as) 用来定义 myInternal 命名空间。由于该文件位于名为 example 的包中，因此您必须将该文件放在名为 example 的文件夹中。该命名空间标记为 public，因此可以导入到其它包中。
// example 文件夹中的 myInternal.as
package example
{
public namespace myInternal = "http://www.adobe.com/2006/actionscript/examples";
}
第二个文件 (Utility.as) 和第三个文件 (Helper.as) 定义的类中包含应可供其它包使用的方法。Utility 类位于 example.alpha 包中，这意味着该文件应放在 example 文件夹下的 alpha 子文件夹中。Helper 类位于 example.beta 包中，这意味着该文件应放在 example 文件夹下的 beta 子文件夹中。这两个包（example.alpha 和 example.beta）在使用命名空间之前必须先导入它。
// example/alpha 文件夹中的 Utility.as
package example.alpha
{
import example.myInternal;
public class Utility
{
private static var _taskCounter:int = 0;
public static function someTask()
{
_taskCounter++;
}
myInternal static function get taskCounter():int
{
return _taskCounter;
}
}
}
// example/beta 文件夹中的 Helper.as
package example.beta
{
import example.myInternal;
public class Helper
{
private static var _timeStamp:Date;
public static function someTask()
{
_timeStamp = new Date();
}
myInternal static function get lastCalled():Date
{
return _timeStamp;
}
}
}
第四个文件 (NamespaceUseCase.as) 是主应用程序类，应是 example 文件夹的同级。在 Adobe Flash CS3 Professional 中，将此类用作 FLA 的文档类。NamespaceUseCase 类还导入 myInternal 命名空间，并使用它来调用位于其它包中的两个静态方法。在本示例中，使用静态方法的目的仅在于简化代码。在 myInternal 命名空间中既可以放置静态方法也可以放置实例方法。
// NamespaceUseCase.as
package
{
import flash.display.MovieClip;
import example.myInternal; // 导入命名空间
import example.alpha.Utility; // 导入 Utility 类
import example.beta.Helper; // 导入 Helper 类
public class NamespaceUseCase extends MovieClip
{
public function NamespaceUseCase()
{
use namespace myInternal;
Utility.someTask();
Utility.someTask();
trace(Utility.taskCounter); // 2
Helper.someTask();
trace(Helper.lastCalled); // [上次调用 someTask() 的时间]
}
}
}
变量
变量可用来存储程序中使用的值。要声明变量，必须将 var 语句和变量名结合使用。在 ActionScript 3.0 中，总是需要使用 var 语句。
如果在声明变量时省略了 var 语句，在严格模式下将出现编译器错误，在标准模式下将出现运行时错误。
要将变量与一个数据类型相关联，则必须在声明变量时进行此操作。在声明变量时不指定变量的类型是合法的，但这在严格模式下将产生编译器警告。可通过在变量名后面追加一个后跟变量类型的冒号 (:) 来指定变量类型。
可以使用赋值运算符 (=) 为变量赋值。您可能会发现在声明变量的同时为变量赋值可能更加方便。通常，在声明变量的同时为变量赋值的方法不仅在赋予基元值（如整数和字符串）时很常用，而且在创建数组或实例化类的实例时也很常用。
如果要声明多个变量，则可以使用逗号运算符 (,) 来分隔变量，从而在一行代码中声明所有这些变量。也可以在同一行代码中为其中的每个变量赋值。
了解变量的作用域
变量的"作用域"是指可在其中通过引用词汇来访问变量的代码区域。"全局"变量是指在代码的所有区域中定义的变量，而"局部"变量是指仅在代码的某个部分定义的变量。在 ActionScript 3.0 中，始终为变量分配声明它们的函数或类的作用域。全局变量是在任何函数或类定义的外部定义的变量。全局变量在函数定义的内部和外部均可用。
可以通过在函数定义内部声明变量来将它声明为局部变量。可定义局部变量的最小代码区域就是函数定义。在函数内部声明的局部变量仅存在于该函数中。该变量在该函数外部将不可用。
如果用于局部变量的变量名已经被声明为全局变量，那么，当局部变量在作用域内时，局部定义会隐藏（或遮蔽）全局定义。全局变量在该函数外部仍然存在。
代码块是指左大括号 ({) 与右大括号 (}) 之间的任意一组语句。在在ActionScript 中，如果您在某个代码块中声明一个变量，那么，该变量不仅在该代码块中可用，而且还在该代码块所属函数的其它任何部分都可用。
有趣的是，如果缺乏块级作用域，那么，只要在函数结束之前对变量进行声明，就可以在声明变量之前读写它。这是由于存在一种名为"提升"的方法，该方法表示编译器会将所有的变量声明移到函数的顶部。
但是，编译器将不会提升任何赋值语句。
这意味着您甚至可以在声明变量之前为变量赋值。
默认值
"默认值"是在设置变量值之前变量中包含的值。首次设置变量的值实际上就是"初始化"变量。如果您声明了一个变量，但是没有设置它的值，则该变量便处于"未初始化"状态。未初始化的变量的值取决于它的数据类型。
下表说明了变量的默认值，并按数据类型对这些值进行组织：
数据类型
默认值
Boolean
false
int
0
Number
NaN
Object
null
String
null
uint
0
未声明（与类型注释 * 等效）
undefined
其它所有类（包括用户定义的类）。
null
对于 Number 类型的变量，默认值是 NaN（而非某个数字），NaN 是一个由 IEEE-754 标准定义的特殊值，它表示非数字的某个值。
如果您声明某个变量，但是未声明它的数据类型，则将应用默认数据类型 *，这实际上表示该变量是无类型变量。如果您没有用值初始化无类型变量，则该变量的默认值是 undefined。
对于 Boolean、Number、int 和 uint 以外的数据类型，所有未初始化变量的默认值都是 null。这适用于由 Flash Player API 定义的所有类以及您创建的所有自定义类。
对于 Boolean、Number、int 或 uint 类型的变量，null 不是有效值。如果您尝试将值 null 赋予这样的变量，则该值会转换为该数据类型的默认值。对于 Object 类型的变量，可以赋予 null 值。如果您尝试将值 undefined 赋予 Object 类型的变量，则该值会转换为 null。
对于 Number 类型的变量，有一个名为 isNaN() 的特殊的顶级函数。如果变量不是数字，该函数将返回布尔值 true，否则将返回 false。
数据类型
"数据类型"用来定义一组值。ActionScript 3.0 中的所有值均是对象，而与它们是基元值还是复杂值无关。
"基元值"是一个属于下列数据类型之一的值：Boolean、int、Number、String 和 uint。基元值的处理速度通常比复杂值的处理速度快，因为 ActionScript 按照一种尽可能优化内存和提高速度的特殊方式来存储基元值。
ActionScript 在内部将基元值作为不可改变的对象进行存储。这意味着按引用传递与按值传递同样有效。这可以减少内存的使用量并提高执行速度，因为引用通常比值本身小得多。
"复杂值"是指基元值以外的值。定义复杂值的集合的数据类型包括：Array、Date、Error、Function、RegExp、XML 和 XMLList。
在 ActionScript 3.0 中，出于实用的目的，不对基元值及其包装对象加以区分。所有的值（甚至基元值）都是对象。Flash Player 将这些基元类型视为特例 ─ 它们的行为与对象相似，但是不需要创建对象所涉及的正常开销。
上面列出的所有基元数据类型和复杂数据类型都是由 ActionScript 3.0 核心类定义的。通过 ActionScript 3.0 核心类，可以使用字面值（而非 new 运算符）创建对象。
类型检查
ActionScript 3.0 是动态类型的语言，它在运行时执行类型检查，同时也支持在名为"严格模式"的特殊编译器模式下在编译时执行类型检查。在严格模式下，类型检查既发生在编译时也发生在运行时，但是在标准模式下，类型检查仅发生在运行时。
在构造代码时，动态类型的语言带来了极大的灵活性，但代价是在运行时可能出现类型错误。静态类型的语言在编译时报告类型错误，但代价是要求类型信息在编译时是已知的。
编译时类型检查
在较大的项目中通常建议使用编译时类型检查，因为随着项目变大，相对于尽早捕获类型错误，数据类型的灵活性通常会变得不那么重要。这就是为什么将 Adobe Flash CS3 Professional 和 Adobe Flex Builder 2 中的 ActionScript 编译器默认设置为在严格模式下运行的原因。
为了提供编译时类型检查，编译器需要知道代码中的变量或表达式的数据类型信息。为了显式声明变量的数据类型，请在变量名后面添加后跟数据类型的冒号运算符 (:) 作为其后缀。要将数据类型与参数相关联，应使用后跟数据类型的冒号运算符。
在严格模式下，ActionScript 编译器将类型不匹配报告为编译器错误。
但是，即使在严格模式下，也可以选择不在赋值语句右侧指定类型，从而退出编译时类型检查。可以通过省略类型注释或使用特殊的星号 (*) 类型注释，来将变量或表达式标记为无类型。
运行时类型检查
在 ActionScript 3.0 中，无论是在严格模式下还是在标准模式下编译，在运行时都将进行类型检查。
还可能会出现如下情形：即使在严格模式下运行，也可能会获得运行时类型错误。如果您使用严格模式，但是通过使用无类型变量而退出了编译时类型检查，就可能会出现上述情形。当您使用无类型变量时，并不会消除类型检查，而只是将其延迟到运行时执行。
与编译时类型检查相比，运行时类型检查还允许更灵活地使用继承。标准模式会将类型检查延迟到运行时执行，从而允许您引用子类的属性，即使您"上传"也是如此。当您使用基类来声明类实例的类型，但是使用子类构造函数来实例化类实例时，就会发生上传。上传被视为安全操作，这是因为基类不包含子类中没有的任何属性或方法。但是，子类中则包含其基类中没有的属性或方法。
is 运算符
is 运算符是 ActionScript 3.0 中的新增运算符，它可用来测试变量或表达式是否为给定数据类型的成员。is 运算符检查正确的继承层次结构，不但可以用来检查对象是否为特定类的实例，而且还可以检查对象是
否是用来实现特定接口的类的实例。
as 运算符
as 运算符是 ActionScript 3.0 中的新增运算符，也可用来检查表达式是否为给定数据类型的成员。但是，与 is 运算符不同的是，as 运算符不返回布尔值，而是返回表达式的值（代替 true）或 null（代替 false）。
在使用 as 运算符时，右侧的操作数必须是数据类型。如果尝试使用表达式（而非数据类型）作为右侧的操作数，将会产生错误。
动态类
"动态"类定义在运行时可通过添加/更改属性和方法来改变的对象。非动态类（如 String 类）是"密封"类。您不能在运行时向密封类中添加属性或方法。
在声明类时，可以通过使用 dynamic 属性来创建动态类。
如果要在以后实例化动态类的实例，则可以在类定义的外部向该类中添加属性或方法。添加到动态类实例中的属性是运行时实体，因此会在运行时完成所有类型检查。不能向以这种方式添加的属性中添加类型注释。您还可以定义一个函数并将该函数附加到动态类实例的某个属性，从而向动态类实例中添加方法。但是，以这种方式创建的方法对于动态类的任何私有属性或方法都不具有访问权限。而且，即使对动态类的公共属性或方法的引用也必须用 this 关键字或类名进行限定。
数据类型说明
基元数据类型包括 Boolean、int、Null、Number、String、uint 和 void。ActionScript 核心类还定义下列复杂数据类型：Object、Array、Date、Error、Function、RegExp、XML 和 XMLList。
Boolean 数据类型
Boolean 数据类型包含两个值：true 和 false。对于 Boolean 类型的变量，其它任何值都是无效的。已经声明但尚未初始化的布尔变量的默认值是 false。
int 数据类型
int 数据类型在内部存储为 32 位整数，它包含一组介于 -2,147,483,648 (-231) 和 2,147,483,647 (231 - 1) 之间的整数（包括 -2,147,483,648 和 2,147,483,647）。早期的 ActionScript 版本仅提供 Number 数据类型，该数据类型既可用于整数又可用于浮点数。在 ActionScript 3.0 中，现在可以访问 32 位带符号整数和无符号整数的低位机器类型。如果您的变量将不会使用浮点数，那么，使用 int 数据类型来代替 Number 数据类型应会更快更高效。
对于小于 int 的最小值或大于 int 的最大值的整数值，应使用 Number 数据类型。Number 数据类型可以处理 -9,007,199,254,740,992 和 9,007,199,254,740,992（53 位整数值）之间的值。int 数据类型的变量的默认值是 0。
Null 数据类型
Null 数据类型仅包含一个值：null。这是 String 数据类型和用来定义复杂数据类型的所有类（包括 Object 类）的默认值。其它基元数据类型（如 Boolean、Number、int 和 uint）均不包含 null 值。如果您尝试向 Boolean、Number、int 或 uint 类型的变量赋予 null，则 Flash Player 会将 null 值转换为相应的默认值。不能将 Null 数据类型用作类型注释。
Number 数据类型
在 ActionScript 3.0 中，Number 数据类型可以表示整数、无符号整数和浮点数。但是，为了尽可能提高性能，应将 Number 数据类型仅用于浮点数，或者用于 int 和 uint 类型可以存储的、大于 32 位的整数值。要存储浮点数，数字中应包括一个小数点。如果您省略了小数点，数字将存储为整数。
Number 数据类型使用由 IEEE 二进制浮点算术标准 (IEEE-754) 指定的 64 位双精度格式。此标准规定如何使用 64 个可用位来存储浮点数。其中的 1 位用来指定数字是正数还是负数。11 位用于指数，它以二进制的形式存储。其余的 52 位用于存储"有效位数"（又称为"尾数"），有效位数是 2 的 N 次幂，N 即前面所提到的指数。
可以将 Number 数据类型的所有位都用于有效位数，也可以将 Number 数据类型的某些位用于存储指数，后者可存储的浮点数比前者大得多。
Number 类型可以表示的最小值和最大值存储在 Number 类的名为 Number.MAX_VALUE 和 Number.MIN_VALUE 的静态属性中。
Number.MAX_VALUE == 1.79769313486231e+308
Number.MIN_VALUE == 4.940656458412467e-324
尽管这个数字范围很大，但代价是此范围的精度有所降低。Number 数据类型使用 52 位来存储有效位数，因此，那些要求用 52 位以上的位数才能精确表示的数字（如分数 1/3）将只是近似值。如果应用程序要求小数达到绝对精度，则需要使用实现小数浮点算术（而非二进制浮点算术）的软件。
如果用 Number 数据类型来存储整数值，则仅使用 52 位有效位数。Number 数据类型使用 52 位和一个特殊的隐藏位来表示介于 -9,007,199,254,740,992 (-253) 和 9,007,199,254,740,992 (253) 之间的整数。
Flash Player 不但将 NaN 值用作 Number 类型的变量的默认值，而且还将其用作应返回数字、却没有返回数字的任何运算的结果。其它特殊的 Number 值包括"正无穷大"和"负无穷大"。
在被 0 除时，如果被除数也是 0，则结果只有一个，那就是 NaN。在被 0 除时，如果被除数是正数，则结果为正无穷大；如果被除数是负数，则结果为负无穷大。
String 数据类型
String 数据类型表示一个 16 位字符的序列。字符串在内部存储为 Unicode 字符，并使用 UTF-16 格式。字符串是不可改变的值，就像在 Java 编程语言中一样。对字符串值执行运算会返回字符串的一个新实例。用 String 数据类型声明的变量的默认值是 null。虽然 null 值与空字符串 ("") 均表示没有任何字符，但二者并不相同。
uint 数据类型
uint 数据类型在内部存储为 32 位无符号整数，它包含一组介于 0 和 4,294,967,295 (232- 1) 之间的整数（包括 0 和 4,294,967,295）。uint 数据类型可用于要求非负整数的特殊情形。例如，必须使用 uint 数据类型来表示像素颜色值，因为 int 数据类型有一个内部符号位，该符号位并不适合处理颜色值。对于大于 uint 的最大值的整数值，应使用 Number 数据类型，该数据类型可以处理 53 位整数值。uint 数据类型的变量的默认值是 0。
void 数据类型
void 数据类型仅包含一个值：undefined。在 ActionScript 3.0 中，Object 实例的默认值是 null。如果您尝试将值 undefined 赋予 Object 类的实例，Flash Player 会将该值转换为 null。您只能为无类型变量赋予 undefined 这一值。无类型变量是指缺乏类型注释或者使用星号 (*) 作为类型注释的变量。只能将 void 用作返回类型注释。
Object 数据类型
Object 数据类型是由 Object 类定义的。Object 类用作 ActionScript 中的所有类定义的基类。ActionScript 3.0 中的 Object 数据类型与早期版本中的 Object 数据类型存在以下三方面的区别：第一，Object 数据类型不再是指定给没有类型注释的变量的默认数据类型。第二，Object 数据类型不再包括 undefined 这一值，该值以前是 Object 实例的默认值。第三，在 ActionScript 3.0 中，Object 类实例的默认值是 null。
在早期的 ActionScript 版本中，会自动为没有类型注释的变量赋予 Object 数据类型。ActionScript 3.0 现在包括真正无类型变量这一概念，因此不再为没有类型注释的变量赋予 Object 数据类型。没有类型注释的变量现在被视为无类型变量。如果您希望向代码的读者清楚地表明您是故意将变量保留为无类型，可以使用新的星号 (*) 表示类型注释，这与省略类型注释等效。
只有无类型变量才能保存值 undefined。如果您尝试将值 undefined 赋给具有数据类型的变量，Flash Player 会将该值 undefined 转换为该数据类型的默认值。对于 Object 数据类型的实例，默认值是 null，这意味着，如果尝试将 undefined 赋给 Object 实例，Flash Player 会将值 undefined 转换为 null。
类型转换
在将某个值转换为其它数据类型的值时，就说发生了类型转换。类型转换可以是"隐式的"，也可以是"显式的"。隐式转换又称为"强制"，有时由 Flash Player 在运行时执行。显式转换又称为"转换"，在代码指示编译器将一个数据类型的变量视为属于另一个数据类型时发生。在涉及基元值时，转换功能将一个数据类型的值实际转换为另一个数据类型的值。
要将对象转换为另一类型，请用小括号括起对象名并在它前面加上新类型的名称。
隐式转换
对于用户定义的类型，当要转换的值是目标类（或者派生自目标类的类）的实例时，隐式转换会成功。如果隐式转换不成功，就会出现错误。
对于基元类型而言，隐式转换是通过调用内部转换算法来处理的，该算法与显式转换函数所调用的算法相同。
显式转换
在严格模式下进行编译时，使用显式转换会非常有用，因为您有时可能会不希望因类型不匹配而生成编译时错误。当您知道强制功能会在运行时正确转换您的值时，可能就属于这种情况。
转换为 int、uint 和 Number
您可以将任何数据类型转换为以下三种数字类型之一：int、uint 和 Number。如果 Flash Player 由于某种原因而无法转换数字，则会为 int 和 uint 数据类型赋予默认值 0，为 Number 数据类型赋予默认值 NaN。如果将布尔值转换为数字，则 true 变成值 1，false 变成值 0。
仅包含数字的字符串值可以成功地转换为数字类型之一。看上去像负数的字符串或者表示十六进制值的字符串（例如，0x1A）也可以转换为数字类型。转换过程中会忽略字符串值中的前导或尾随空白字符。还可以使用 Number() 来转换看上去像浮点数的字符串。如果包含小数点，则会导致 uint() 和 int() 返回一个整数，小数点和它后面的字符被截断。
对于包含非数字字符的字符串值，在用 int() 或 uint() 转换时，将返回 0；在用 Number() 转换时，将返回 NaN。转换过程中会忽略前导和尾随空白，但是，如果字符串中包含将两个数字隔开的空白，则将返回 0 或 NaN。
在 ActionScript 3.0 中，Number() 函数不再支持八进制数或基数为 8 的数。对于 ActionScript 3.0 中的 Number() 函数， 会忽略前导 0。
将一种数值类型的值赋给另一种数值类型的变量时，转换并不是必需的。即使在严格模式下，数值类型也会隐式转换为其它数值类型。这意味着，在某些情况下，在超出类型的范围时，可能会生成意外的值。
var myUInt:uint = -3; // 将 int/Number 值赋给 uint 变量
trace(myUInt); // 4294967293
var myNum:Number = sampleUINT; // 将 int/uint 值赋给 Number 变量
trace(myNum) // 4294967293
var myInt:int = uint.MAX_VALUE + 1; // 将 Number 值赋给 uint 变量
trace(myInt); // 0
myInt = int.MAX_VALUE + 1; // 将 uint/Number 值赋给 int 变量
trace(myInt); // -2147483648
下表概述了将其它数据类型转换为 Number、int 或 uint 数据类型的结果。
数据类型或值
转换为 Number、int 或 uint 时的结果
Boolean
如果值为 true，则结果为 1；否则为 0。
Date
Date 对象的内部表示形式，即从 1970 年 1 月 1 日午夜（通用时间）以来所经过的毫秒数。
null
0
Object
如果实例为 null 并转换为 Number，则结果为 NaN；否则为 0。
String
如果 Flash Player 可以将字符串转换为数字，则结果为数字；否则，如果转换为 Number，则结果为 NaN，如果转换为 int 或 uint，则结果为 0。
undefined
如果转换为 Number，则结果为 NaN；如果转换为 int 或 uint，则结果为 0。
转换为 Boolean
在从任何数值数据类型（uint、int 和 Number）转换为 Boolean 时，如果数值为 0，则结果为 false；否则为 true。对于 Number 数据类型，如果值为 NaN，则结果也为 false。
在将字符串值转换为 Boolean 数据类型时，如果字符串为 null 或空字符串 ("")，则会返回 false。否则，将返回 true。
在将 Object 类的实例转换为 Boolean 数据类型时，如果该实例为 null，则将返回 false；否则将返回 true。
在严格模式下，系统会对布尔变量进行特殊处理，因为您不必转换即可向布尔变量赋予任何数据类型的值。即使在严格模式下，也可以将所有的数据类型隐式强制为 Boolean 数据类型。换言之，与几乎其它所有数据类型不同，转换为 Boolean 数据类型不是避免在严格模式下出错所必需的。
下表概述了在从其它数据类型转换为 Boolean 数据类型时的结果：
数据类型或值
转换为 Boolean 数据类型时的结果
String
如果值为 null 或空字符串 ("")，则结果为 false；否则为 true。
null
false
Number、int 或 uint
如果值为 NaN 或 0，则结果为 false；否则为 true。
Object
如果实例为 null，则结果为 false；否则为 true。
转换为 String
从任何数值数据类型转换为 String 数据类型时，都会返回数字的字符串表示形式。在将布尔值转换为 String 数据类型时，如果值为 true，则返回字符串 "true"；如果值为 false，则返回字符串 "false"。
在从 Object 类的实例转换为 String 数据类型时，如果该实例为 null，则返回字符串 "null"。否则，将返回字符串 "[object Object]"。
在从 Array 类的实例转换为 String 时，会返回一个字符串，其中包含所有数组元素的逗号分隔列表。
在从 Date 类的实例转换为 String 时，会返回该实例所包含日期的字符串表示形式。（输出结果显示的是太平洋夏令时）
下表概述了在将其它数据类型转换为 String 数据类型时的结果：
数据类型或值
转换为 String 数据类型时的结果
Array
一个包含所有数组元素的字符串。
Boolean
"true" 或 "false"。
Date
Date 对象的字符串表示形式。
null
"null"
Number、int 或 uint
数字的字符串表示形式。
Object
如果实例为 null，则结果为 "null"；否则为 "[object Object]"。
语法
语言的语法定义了一组在编写可执行代码时必须遵循的规则。
区分大小写
ActionScript 3.0 是一种区分大小写的语言。只是大小写不同的标识符会被视为不同。
点语法
可以通过点运算符 ( . ) 来访问对象的属性和方法。使用点语法，可以使用后跟点运算符和属性名或方法名的实例名来引用类的属性或方法。
定义包时，可以使用点语法。可以使用点运算符来引用嵌套包。
字面值
"字面值"是直接出现在代码中的值。
字面值还可以组合起来构成复合字面值。数组文本括在中括号字符 ([ ]) 中，各数组元素之间用逗号隔开。数组文本可用于初始化数组。您可以使用 new 语句将复合字面值作为参数传递给 Array 类构造函数，但是，您还可以在实例化下面的 ActionScript 核心类的实例时直接赋予字面值：Object、Array、String、Number、int、uint、XML、XMLList 和 Boolean。
字面值还可用来初始化通用对象。通用对象是 Object 类的一个实例。对象字面值括在大括号 ({ }) 中，各对象属性之间用逗号隔开。每个属性都用冒号字符 ( : ) 进行声明，冒号用于分隔属性名和属性值。
可以使用 new 语句创建一个通用对象并将该对象的字面值作为参数传递给 Object 类构造函数，也可以在声明实例时直接将对象字面值赋给实例。
分号
可以使用分号字符 ( ; ) 来终止语句。如果您省略分号字符，则编译器将假设每一行代码代表一条语句。由于很多程序员都习惯使用分号来表示语句结束，因此，如果您坚持使用分号来终止语句，则代码会更易于阅读。
使用分号终止语句可以在一行中放置多个语句，但是这样会使代码变得难以阅读。
小括号
在 ActionScript 3.0 中，可以通过三种方式来使用小括号 (())。
首先，可以使用小括号来更改表达式中的运算顺序。组合到小括号中的运算总是最先执行。
第二，可以结合使用小括号和逗号运算符 (,) 来计算一系列表达式并返回最后一个表达式的结果。
第三，可以使用小括号来向函数或方法传递一个或多个参数。
注释
ActionScript 3.0 代码支持两种类型的注释：单行注释和多行注释。这些注释机制与 C++ 和 Java 中的注释机制类似。编译器将忽略标记为注释的文本。
单行注释以两个正斜杠字符 (//) 开头并持续到该行的末尾。
多行注释以一个正斜杠和一个星号 (/*) 开头，以一个星号和一个正斜杠 (*/) 结尾。
关键字和保留字
"保留字"是一些单词，因为这些单词是保留给 ActionScript 使用的，所以，不能在代码中将它们用作标识符。保留字包括"词汇关键字"，编译器将词汇关键字从程序的命名空间中删除。如果您将词汇关键字用作标识符，则编译器会报告一个错误。
下表列出了 ActionScript 3.0 词汇关键字：
as
break
case
catch
class
const
continue
default
delete
do
else
extends
false
finally
for
function
if
implements
import
in
instanceof
interface
internal
is
native
new
null
package
private
protected
public
return
super
switch
this
throw
to
true
try
typeof
use
var
void
while
with
有一小组名为"句法关键字"的关键字，这些关键字可用作标识符，但是在某些上下文中具有特殊的含义。下表列出了 ActionScript 3.0 句法关键字：
each
get
set
namespace
include
dynamic
final
native
override
static
还有几个有时称为"供将来使用的保留字"的标识符。这些标识符不是为 ActionScript 3.0 保留的，但是其中的一些可能会被采用 ActionScript 3.0 的软件视为关键字。您可以在自己的代码中使用其中的许多标识符，但是 Adobe 不建议您使用它们，因为它们可能会在以后的 ActionScript 版本中作为关键字出现。
abstract
boolean
byte
cast
char
debugger
double
enum
export
float
goto
intrinsic
long
prototype
short
synchronized
throws
to
transient
type
virtual
volatile
常量
ActionScript 3.0 支持 const 语句，该语句可用来创建常量。常量是指具有无法改变的固定值的属性。只能为常量赋值一次，而且必须在最接近常量声明的位置赋值。例如，如果将常量声明为类的成员，则只能在声明过程中或者在类构造函数中为常量赋值。
如果您尝试以其它任何方法向常量赋予初始值，则会出现错误。
Flash Player API 定义了一组广泛的常量供您使用。按照惯例，ActionScript 中的常量全部使用大写字母，各个单词之间用下划线字符 ( _) 分隔。
运算符
运算符是一种特殊的函数，它们具有一个或多个操作数并返回相应的值。"操作数"是被运算符用作输入的值，通常是字面值、变量或表达式。
运算符可以是一元、二元或三元的。"一元"运算符有 1 个操作数。"二元"运算符有 2 个操作数。"三元"运算符有 3 个操作数。
有些运算符是"重载的"，这意味着它们的行为因传递给它们的操作数的类型或数量而异。例如，加法运算符 (+) 就是一个重载运算符，其行为因操作数的数据类型而异。如果两个操作数都是数字，则加法运算符会返回这些值的和。如果两个操作数都是字符串，则加法运算符会返回这两个操作数连接后的结果。
运算符的行为还可能因所提供的操作数的数量而异。减法运算符 (-) 既是一元运算符又是二元运算符。对于减法运算符，如果只提供一个操作数，则该运算符会对操作数求反并返回结果；如果提供两个操作数，则减法运算符返回这两个操作数的差。
运算符的优先级和结合律
运算符的优先级和结合律决定了运算符的处理顺序。虽然对于熟悉算术的人来说，编译器先处理乘法运算符 (*) 然后再处理加法运算符 (+) 似乎是自然而然的事情，但实际上编译器要求显式指定先处理哪些运算符。此类指令统称为"运算符优先级"。ActionScript 定义了一个默认的运算符优先级，您可以使用小括号运算符 (()) 来改变它。
您可能会遇到这样的情况：同一个表达式中出现两个或更多个具有相同的优先级的运算符。在这些情况下，编译器使用"结合律"的规则来确定先处理哪个运算符。除了赋值运算符之外，所有二进制运算符都是"左结合"的，也就是说，先处理左边的运算符，然后再处理右边的运算符。赋值运算符和条件运算符 (?:) 都是"右结合"的，也就是说，先处理右边的运算符，然后再处理左边的运算符。
如果将具有相同的优先级的两个运算符用于同一个表达式中，那么，由于这两个运算符都是左结合的，因此先处理左边的运算符。您可以用括号运算符来改变默认的左结合律。您可以通过用小括号括起小于运算符及其操作数来命令编译器先处理小于运算符。
下表按优先级递减的顺序列出了 ActionScript 3.0 中的运算符。该表内同一行中的运算符具有相同的优先级。在该表中，每行运算符都比位于其下方的运算符的优先级高。
组
运算符
主要
[] {x:y} () f(x) new x.y x[y] <></> @ :: ..
后缀
x++ x--
一元
++x --x + - ~ ! delete typeof void
乘法
* / %
加法
+ -
按位移位
<< >> >>>
关系
< > <= >= as in instanceof is
等于
== != === !==
按位"与"
&
按位"异或"
^
按位"或"
|
逻辑"与"
&&
逻辑"或"
||
条件
?:
赋值
= *= /= %= += -= <<= >>= >>>= &= ^= |=
逗号
,
主要运算符
主要运算符包括用来创建 Array 和 Object 字面值、对表达式进行分组、调用函数、实例化类实例以及访问属性的运算符。下表列出了所有主要运算符，它们具有相同的优先级。属于E4X 规范的运算符用 (E4X) 来表示。
运算符
执行的运算
[]
初始化数组
{x:y}
初始化对象
()
对表达式进行分组
f(x)
调用函数
new
调用构造函数
x.y x[y]
访问属性
<></>
初始化 XMLList 对象 (E4X)
@
访问属性 (E4X)
::
限定名称 (E4X)
..
访问子级 XML 元素 (E4X)
后缀运算符
后缀运算符只有一个操作数，它递增或递减该操作数的值。虽然这些运算符是一元运算符，但是它们有别于其它一元运算符，被单独划归到了一个类别，因为它们具有更高的优先级和特殊的行为。在将后缀运算符用作较长表达式的一部分时，会在处理后缀运算符之前返回表达式的值。
下表列出了所有的后缀运算符，它们具有相同的优先级：
运算符
执行的运算
++
递增（后缀）
--
递减（后缀）
一元运算符
一元运算符只有一个操作数。这一组中的递增运算符 (++) 和递减运算符 (--) 是"前缀运算符"，这意味着它们在表达式中出现在操作数的前面。前缀运算符与它们对应的后缀运算符不同，因为递增或递减操作是在返回整个表达式的值之前完成的。
下表列出了所有的一元运算符，它们具有相同的优先级：
运算符
执行的运算
++
递增（前缀）
--
递减（前缀）
+
一元 +
-
一元 -（非）
!
逻辑"非"
~
按位"非"
delete
删除属性
typeof
返回类型信息
void
返回 undefined 值
乘法运算符
乘法运算符具有两个操作数，它执行乘、除或求模计算。
下表列出了所有的乘法运算符，它们具有相同的优先级：
运算符
执行的运算
*
乘法
/
除法
%
求模
加法运算符
加法运算符有两个操作数，它执行加法或减法计算。下表列出了所有加法运算符，它们具有相同的优先级：
运算符
执行的运算
+
加法
-
减法
按位移位运算符
按位移位运算符有两个操作数，它将第一个操作数的各位按第二个操作数指定的长度移位。下表列出了所有按位移位运算符，它们具有相同的优先级：
运算符
执行的运算
<<
按位向左移位
>>
按位向右移位
>>>
按位无符号向右移位
关系运算符
关系运算符有两个操作数，它比较两个操作数的值，然后返回一个布尔值。下表列出了所有关系运算符，它们具有相同的优先级：
运算符
执行的运算
<
小于
>
大于
<=
小于或等于
>=
大于或等于
as
检查数据类型
in
检查对象属性
instanceof
检查原型链
is
检查数据类型
等于运算符
等于运算符有两个操作数，它比较两个操作数的值，然后返回一个布尔值。下表列出了所有等于运算符，它们具有相同的优先级：
运算符
执行的运算
==
等于
!=
不等于
===
严格等于
!==
严格不等于
按位逻辑运算符
按位逻辑运算符有两个操作数，它执行位级别的逻辑运算。按位逻辑运算符具有不同的优先级；下表按优先级递减的顺序列出了按位逻辑运算符：
运算符
执行的运算
&
按位"与"
^
按位"异或"
|
按位"或"
逻辑运算符
逻辑运算符有两个操作数，它返回布尔结果。逻辑运算符具有不同的优先级；下表按优先级递减的顺序列出了逻辑运算符：
运算符
执行的运算
&&
逻辑"与"
||
逻辑"或"
条件运算符
条件运算符是一个三元运算符，也就是说它有三个操作数。条件运算符是应用 if..else 条件语句的一种简便方法。
运算符
执行的运算
?:
条件
赋值运算符
赋值运算符有两个操作数，它根据一个操作数的值对另一个操作数进行赋值。下表列出了所有赋值运算符，它们具有相同的优先级：
运算符
执行的运算
=
赋值
*=
乘法赋值
/=
除法赋值
%=
求模赋值
+=
加法赋值
-=
减法赋值
<<=
按位向左移位赋值
>>=
按位向右移位赋值
>>>=
按位无符号向右移位赋值
&=
按位"与"赋值
^=
按位"异或"赋值
|=
按位"或"赋值
条件语句
ActionScript 3.0 提供了三个可用来控制程序流的基本条件语句。 if..else if..else if switch
if..else
if..else 条件语句用于测试一个条件，如果该条件存在，则执行一个代码块，否则执行替代代码块。
如果您不想执行替代代码块，可以仅使用 if 语句，而不用 else 语句。
if..else if
可以使用 if..else if 条件语句来测试多个条件。
switch
如果多个执行路径依赖于同一个条件表达式，则 switch 语句非常有用。它的功能大致相当于一系列 if..else if 语句，但是它更便于阅读。switch 语句不是对条件进行测试以获得布尔值，而是对表达式进行求值并使用计算结果来确定要执行的代码块。代码块以 case 语句开头，以 break 语句结尾。
循环
循环语句允许您使用一系列值或变量来反复执
