第2章 AS 3.0编程语言基础
语法、数据、变量、运算符和语句构成了编程语言的基础。本章将通过大量的测试代码，详细介绍ActionScript 3.0中的语法、数据类型、变量以及运算符。通过本章的学习，将为以后的面向对象编程打下一个坚实的基础。
2.1 AS 3.0语法
任何一门编程语言在编写代码时都必须遵循一定的规则，这个规则就是语法。本节将着重介绍从ActionScript 2.0开始使用的点语法和区分大小写，了解编程常用的标点符号的使用，以及程序注释的使用方法。
2.1.1 点语法
Flash中使用点（.）运算符来访问对象的属性和方法，点运算符主要用于以下几个方面：
1）可以采用对象后面跟点运算符的属性名称（方法）来引用对象的属性（方法）。
具体语法格式如下：
对象.属性
对象.方法()
其示例代码如下：
Math.Pi;
Math.sin(Math.Pi/2);
2）可以采用点运算符表示包路径。
比如类文件要放在Com目录下的Lzxt目录下，那么包路径就可以表示为：
Com.Lzxt
同样，引用包时，要使用点运算符引入包。比如要引入Point类，那么引入的代码为：
import flash.geom.point;
3）可以使用点运算符描述显示对象的路径。
比如物体上有一个实例名称为mc1的影片剪辑，同时mc1影片剪辑中嵌套有另一个影片剪辑mc2，可以通过下面的代码来访问mc2：
mc1.mc2.x=100;
注意 在ActionScript 1.0中使用的斜杠语法在ActionScript 3.0中不再支持，不能继续使用。
2.1.2 标点符号的使用
在Flash中有多种常用的标点符号，包括：分号（;）、逗号（,）、冒号（:）、小括号（()）、中括号（[]）和大括号（{}）。这些标点符号在Flash中都有各自不同的作用，可以帮助定义数据类型，终止语句或者构建ActionScript代码块。
1. 分号（；）
ActionScript语句用分号（;）字符表示语句结束。如下面的语句：
var i:Number =50;
myClip._alpha =i;
该分号在编写过程中可以省略不写，ActionScript编译器会认为每行代码表示单个语句。但为了增强代码的可读性，最好还是使用分号。动作面板的“自动套用格式”按钮可以帮助给没有书写分号的语句自动在行尾加上分号。
当然也可以把多句代码放在一行中，句与句之间使用分号隔开。如下面的语句：
var myint:int=1;var str:String="String";
这样不会使编译器产生错误，但是由于代码位于一行当中，给代码的阅读造成了不便。
分号的另一个用途是在for循环中，使用分号来分隔参数。下面的示例使用循环输出数字0～9，代码如下所示：
for (var i:Number =0;i<10;i++) {
trace(i);//输出：0,1,...,9
}
说明
代码部分，“//”字符后的语句内容为注释。
2. 逗号（，）
逗号的作用主要用于分隔参数，比如函数的参数、方法的参数等。比如下面的代码：
trace(1,2,3);//输出：1,2,3
//创建位于坐标(1,1)的点实例
var p:Point=new Point(1,1);
3. 冒号（：）
冒号的作用主要用于为变量指定数据类型。要为一个变量指明数据类型，需要使用var关键字和后冒号法为其指定。比如下面的代码：
// 严格指定变量或对象的类型
var i:Number = 7;
var myDate:Date = new Date();
// 严格指定参数的类型
function welcome(firstName:String, myAge:Number) {
}
// 严格指定参数和返回值的类型
function square(num:Number):Number {
var squared:Number = num ＊ num;
return squared;
}
4. 小括号（()）
小括号在ActionScript 3.0中有3种用途。
首先，在数学运算方面，可以用来改变表达式的运算顺序。小括号内的数学表达式优先运算。比如下面的代码：
trace(2 + 3 ＊ 4); // 14
trace( (2 + 3) ＊ 4); // 20
其次，在表达式运算方面，可以结合使用小括号和逗号运算符，优先计算一系列表达式的结果，并返回最后一个表达式的结果。比如下面的代码：
var i:int=1;
var j:int=3;
trace((i+j),i＊j);
最后，括号一个最重要的作用就是用于函数的定义，利用括号向函数或者方法传递一些参数。比如下面的代码：
trace("欢迎你！")
5. 中括号（[]）
中括号主要用于数组的定义和访问，比如下面的代码：
//创建一个新的数组，内容为1,2,3
var arr:Array=[1,2,3]
//输出数组的第二个元素
trace(arr[1])//输出：2
6. 大括号（{}）
大括号主要用于编程语言程序控制，函数和类中。
在构成控制结构的每个语句前后添加大括号（例如if...else或for），即使该控制结构只包含一个语句。比如下面的代码：
var i:int;
if (i==1) {
trace(i);
}
在面向对象的编程中，大括号是使用最为频繁的语句控制符号，注意大括号都要成对出现。下面定义一个简单的类Sample，代码如下所示：
//定义包
package {
//定义类
class Example {
//构造函数
public function Example() {
trace("这是一个例子");
}
}
}
当然，在ActionScript 3.0中使用的标点符号很多，其各自的用法在用到的时候再进行说明。
2.1.3 注释
注释是使用一些简单易懂的语言对代码进行简单的解释的方法。注释语句在编译过程中并不会进行求值运算。可以用注释来描述代码的作用，或者返回到文档中的数据。注释也可以帮助记忆编程的原理，并有助于其他人的阅读。若代码中有些内容阅读起来含义不大明显，应该对其添加注释。
ActionScript 3.0中的注释语句有两种：单行注释和多行注释。
单行注释以两个单斜杠（//）开始，之后的该行内容均为注释。比如下面的代码：
trace("1234")//输出:1234
多行注释以一个正斜杠和一个星号（/*）开头，以一个星号和一个正斜杠（*/）结尾。比如下面的代码：
/＊
这是一个可以跨
多行代码的多行注释
＊/
注意 注释语句在动作面板和脚本窗口显示的颜色均为灰色，也可以通过首选参数设置注释语句显示的颜色。
2.1.4 关键字和保留字
保留字，从字面上就很容易知道这是保留给ActionScript 3.0语言使用的英文单词，因而不能使用这些单词作为变量、实例、类名称等。如果在代码中使用了这些单词，编译器会报错。
ActionScript 3.0中的保留字分为3类：词汇关键字、句法关键字和供将来使用的保留字。
1. 词汇关键字
词汇关键字共有45个，是ActionScript 3.0编程语言中作为关键字使用的，具体内容如表2.1所示。
表2.1 词汇关键字
2. 句法关键字
句法关键字共有10个，在ActionScript 3.0中可用作标识符，但在编程的上下文具有特殊的含义。具体内容如表2.2所示。
表2.2 句法关键字
3. 供将来使用的保留字
供将来使用的保留字共有22个，这是为ActionScript语言的发展而预留的。具体内容如表2.3所示。
表2.3 供将来使用的保留字
2.2 变量和常量
变量和常量，都是为了储存数据而创建的。变量和常量就像是一个容器，用于容纳各种不同类型的数据。当然对变量进行操作，变量的数据就会发生改变，而常量则不会。
变量必须要先声明后使用，否则编译器就会报错。道理很简单，比如现在要去喝水，那么你首先要有一个杯子，否则怎样去装水呢？要声明变量的原因与此相同。
2.2.1 声明变量的语法
在ActionScript 3.0中，使用var关键字来声明变量。格式如下所示：
var 变量名:数据类型;
var 变量名:数据类型=值;
变量名加冒号加数据类型就是声明变量的基本格式。要声明一个初始值，需要加上一个等号并在其后输入相应的值。但值的类型必须要和前面的数据类型一致。
下面通过一段代码来说明写代码声明变量时可能遇到的情况。
var i;
说明：此为正确写法，声明了一个变量，但未指定类型。
var i:int;
说明：此为正确写法，声明一个int型变量，但没有赋值。
var i:int=1;
说明：此为正确写法，声明一个int型变量，并赋值为1。
var i:＊;
说明：此为正确写法，声明一个变量，但未指定类型。
i;
说明：此为错误写法，没有加var关键字。
Var i;
说明：此为错误写法，var关键字首字母小写而非大写。
i=1;
说明：此为错误写法，没有var关键字。
var i:int="hello";
说明：此为错误写法，声明的数据类型和值数据类型不同。
ActionScript 3.0支持一个关键字同时声明多个变量，多个变量使用逗号分开。比如下面所示的代码都是正确的：
var a:int, b:int, c:int;
var a:int = 10, b:int = 20, c:int = 30;
如果只声明变量而没有赋值，则该变量为其默认值。
2.2.2 变量的命名规则
变量的命名既是任意的，又是有规则、有目的的。随手牵来、杂乱无章的命名在Flash中既容易引起代码的混乱，也不容易进行维护操作。
变量的命名首先要遵循下面的几条原则：
❑它必须是一个标识符。它的第一个字符必须是字母、下划线（_）或美元记号（$）。其后的字符必须是字母、数字、下划线或美元记号。注意，不能使用数字作为变量名称的第一个字母。
❑它不能是关键字或动作脚本文本，例如true、false、null或undefined。特别是不能使用ActionScript的保留字，否则编译器会报错。
❑它在其范围内必须是唯一的，不能重复定义变量。
仅仅遵循上面的规则，命名的变量并不一定能够使自己的代码条理清晰、可读性强。特别是命名的变量不能只有自己才能够明白变量的意思。对变量进行标准清晰的命名是一个优秀的程序员必备的素质之一。
除了上面必须遵循的几点之外，下面的几点也需要注意：
❑尽可能地使用与要命名的变量意义接近的英文单词作为变量名。
❑变量名最好大小写字母混合使用，单词的第一个字母尽可能大写。
❑变量名在能清晰表达意义的前提下，越短越好。
❑尽可能地不要使用数字编号排序变量名。
2.2.3 变量的作用域
变量的作用域是指可以使用或者引用该变量的范围，通常变量按照其作用域的不同可以分为全局变量和局部变量。全局变量指在函数或者类之外定义的变量，而在类或者函数之内定义的变量为局部变量。
全局变量在代码的任何地方都可以访问，所以在函数之外声明的变量同样可以访问。如下面的代码，函数Test()外声明的变量i在函数体内同样可以访问。
var i:int=1;
//定义Test函数
function Test() {
trace(i);
}
Test()//输出：1
而局部变量只能在函数或类内访问，而在外部不能访问。下面的代码，函数Test()内声明的变量i在函数体外不能访问。
function Test() {
var i:int=1;
trace("函数体内访问变量i："+i);
}
Test();
trace("函数体外访问变量i："+i);
说明
该代码不能编译通过，输出为“访问的属性i未定义”。说明在函数体内定义的变量为局部变量，外部无法访问。
既然全局变量在函数内和函数外都可以访问，若函数内和函数外都定义有一个同名的变量，则函数体内和体外以哪一个为准呢？请看下面的测试代码：
//函数体外定义变量
var i:int=10;
trace("函数使用前访问变量i："+i);
function Test() {
//函数体内定义变量
var i:int=1;
trace("函数体内访问变量i："+i);
}
Test();
trace("函数体使用后访问变量i："+i);
代码运行后的输出结果如下所示：
函数使用前访问变量i：10
函数体内访问变量i：1
函数体使用后访问变量i：10
说明
从输出的结果来看，在函数体内，局部变量起作用，而全局变量不起作用，但其不会影响全局变量。
ActionScript 3.0变量对块级作用域没有限制，代码块中的变量使用范围不仅仅局限有代码块。块级作用域指的是{}之内的代码。看下面的一段代码：
//使用for循环输出
for (var i = 0; i < 5; i ++) {
trace("块内的变量"+i);
}
trace("块外的变量"+i);
代码运行后的输出结果如下所示：
块内的变量0
块内的变量1
块内的变量2
块内的变量3
块内的变量4
块外的变量5
说明
从这段代码的输出结果可以看出，块内声明的变量，在块外同样起着作用，并且延续了变量的结果。
这样的结果，对于ActionScript 2.0中习惯使用下面编程方式的用户来说，将是一件很苦恼的事情。代码如下所示：
for (var i = 0; i < 5; i ++) {}
for (var i = 0; i < 5; i ++) {}
说明
同时使用两个i作为变量建立循环，编译器会提示“变量i存在冲突”，原因就在于块代码域。
ActionScript 3.0中还有一种技术能够使声明的变量在编译时被提到函数的最顶端。所以只要在函数中声明变量，无论在哪个位置声明，在整个函数中都可以使用。比如下面的代码在编译时能够编译通过：
trace(i);//输出：0
i=10;
trace(i);//输出：10
var i:int;
trace(i);//输出：10
i=20;
trace(i);//输出：20
说明
从上面的代码可以看出，只要声明变量，可以不用管其在何位置。
2.2.4 变量的默认值
变量的默认值是指变量在没有赋值之前的值。对于ActionScript 3.0的数据类型来说，都有各自的默认值，下面使用代码来测试一下：
var p:Boolean;
trace("Boolean型变量的默认值是："+p);
var i:int;
trace("int型变量的默认值是："+i);
var j:Number;
trace("Number型变量的默认值是："+j);
var obj:Object;
trace("Object型变量的默认值是："+obj);
var str:String;
trace("String型变量的默认值是："+str);
var u:uint;
trace("uint型变量的默认值是："+u);
var v:＊;
trace("＊型变量的默认值是："+v);
代码运行后的输出结果如下所示：
Boolean型变量的默认值是：false
int型变量的默认值是：0
Number型变量的默认值是：NaN
Object型变量的默认值是：null
String型变量的默认值是：null
uint型变量的默认值是：0
＊型变量的默认值是：undefined
通过上面的代码输出，已经可以得到这些数据类型变量的默认值，分别为：
❑Boolean型变量的默认值是：false。
❑int型变量的默认值是：0。
❑Number型变量的默认值是：NaN。
❑Object型变量的默认值是：null。
❑String型变量的默认值是：null。
❑uint型变量的默认值是：0。
❑*型变量的默认值是：undefined。
注意 如果一个变量没有声明它的数据类型，那么它会默认为*型(无类型变量)，其默认值也为undefined。
2.2.5 使用const声明常量
ActionScript 3.0中增加了一个const关键字，用于声明常量。常量是指具有无法改变的固定值的属性。比如Math.PI就是一个常量。常量可以看做一种特殊的变量，不过这种变量不能赋值，不能更改而已。
使用const声明常量的语法格式和var声明变量的格式相同：
const 常量名:数据类型;
const 常量名:数据类型=值;
下面声明常量的代码：
const g:Number=9.8;
说明：此为正确写法，声明一个数值型常量，并赋值。
const g:Number;
说明：此为错误写法，常量已声明，但未初始化。编译器将报错。
如果试图改变常量的值，则编译器会报错。如下面的代码：
const g:Number=9.8;
g=10;
const常量的应用非常广泛。比如数学中的PI、物理中的重力加速度等保持不变的量，都要把其定义为常量。
常量是不能进行修改的。对于引用型常量来说，虽然不能直接进行修改，但是可以通过修改对常量引用的方式来实现对常量的修改。比如下面的代码：
//定义数组常量
const arr_1:Array=new Array(1,2,3);
trace(arr_1);//输出：1,2,3
var arr_2:Array=arr_1;
trace(arr_2);//输出：1,2,3
arr_2[0]=100;
trace(arr_1);//输出：100,2,3
trace(arr_2);//输出：100,2,3
说明
从输出的代码可以看出，通过修改变量arr_2的值，修改了常量arr_1的值。
而对值类型来说，常量的值不能进行修改，无论是修改它本身还是修改其引用。比如下面的代码：
//定义常量a并赋值1
const a:Number=1;
trace(a);//输出：1
//定义变量b并引用常量a
var b:Number=a;
trace(b);//输出：1
//改变变量b的值
b=3;
trace(a);//输出：1
trace(b);//输出：3
说明
从输出的代码可以看出，通过修改变量b的值，并不能改变常量a的值。
2.3 基础数据类型
和其他的面向对象编程的数据类型一样，ActionScript 3.0的数据类型同样分为两种，具体划分方式如下所示：
❑基元型数据类型：Boolean、int、Number、String和uint。
❑复杂型数据类型：Array、Date、Error、Function、RegExp、XML和XMLList。
一般来说，基元值的处理速度通常比复杂值的处理速度要快。
基元型数据和复杂型数据类型的最大的区别是：基元型是值对类型数据，而复杂型是引用类型数据。值对类型直接储存数据，使用它为另一个变量赋值之后，若另一个变量改变，并不影响原变量的值。引用类型指向要操作的对象，另一个变量引用这个变量之后，若另一变量发生改变，原有的变量跟着也要发生改变。
另外，最明显的一个区别是，如果数据类型能够使用new关键字创建，那么它一定是引用型数据变量。
2.3.1 基础数据类型说明
本小节通过大量的测试代码，来说明各种不同的数据类型的用法和使用中的注意事项。
1. Boolean数据类型
布尔值是一个用来表示真假的数据类型，其有两个值：true（真）和false（假）。Boolean型数值变量的初始值为false。如果声明了一个Boolean型的变量，但是没有给它赋值，那么这个变量的值已经默认为false。通过下面的代码测试一下：
//定义一个Boolean型变量并且未赋值
var b:Boolean;
trace(b);//输出：false
//判断变量b的值是否和false相等并输出
trace(b==false);
在ActionScript 2.0中可以把一个Boolean型的变量与数值1和0来对应，ActionScript 3.0中该用法同样可以使用，如下面的代码所示：
var b:Boolean;
trace(b==0);//输出：true
b=true;
trace(b==1);//输出：true
说明
上面的代码说明布尔型变量的false值和数值0相等，而true与数值1相等。
但不能直接给布尔型变量赋值为1或者0，否则会造成编译器错误。
2. 数字：int、uint和Number
ActionScript 2.0中表示数字的变量只有一个Number，用于表示双精度浮点数。而ActionScript 3.0中增加了int和uint两种数字类型变量，共有三种：
int数据类型：32位有符号整数。为范围在-2 147 483 648（-231）～2 147 483 647（231-1）之间的一个整数（包括-2 147 483 648和2 147 483 647）。该数据用于存储整数，包括正整数和负整数。
uint数据类型：32位无符号整数。为范围在0～4 294 967 295（232-1）之间的整数（包括0和4 294 967 295）。该数据只能存储0和正整数，不能存储负整数。
Number数据类型：64位的浮点数。为范围在1.797 693 134 862 31e+308～4.940 656 458 412 467e-324之间的浮点数。该数据可以存储整数，也可以存储小数。“e+308”是数学中的科学计数法的表示方式，意思是“乘以10的正308次方”。
ActionScript语言中的数字类型有三种，使用过程中尽量遵循以下原则：
❑整数运算时优先使用int和uint。
❑整数有正负之分时，使用int。
❑只有正整数，使用uint。
❑处理颜色相关的数据时，使用uint。
❑带有小数的数值使用Number。
在编程过程中，如果要进行整数运算，应尽可能地使用int数据类型。通常认为int的效率比Number的效率要高。比如在使用for循环时，可以选择使用int类型的变量而不是Number类型。
在处理与颜色相关的信息时，尽可能使用uint。十六进制的颜色数值信息0x000000~0xFFFFFF，转换为十进制数就是0~16 777 215。处于uint型数值的范围内，使用其来处理数据已经足够，就是处理含有Alpha通道的像素值时，也可以使用uint范围。因为其数值信息的范围0x00000000~0xFFFFFFFF，为十进制的0~4 294 967 295，正是uint型数值的范围。可以说，uint型数据就是为处理像素数值而专门准备的。
整数类型int和uint只能是整数类型的数值，但是在赋值的时候如果把一个小数赋值给整数变量，系统并不会报错。请看下面的代码：
var i:int=1.1;
trace(i);//输出：1
var j:int=1.6;
trace(j);//输出：1
var a:uint=1.7;
trace(a);//输出：1
var b:uint=1.05;
trace(b);//输出：1
说明
编译器并没有报错，说明声明的整数类型变量可以接受浮点数。不过接受的浮点数在使用的过程中被编译器处理了，直接保留了整数。保留的方法是取整，不是四舍五入。
整数类型int和uint在使用的过程中，如果运算的结果可能出现小数，请使用Number数据类型，否则会出现意外的错误。请看下面的代码：
var a:int=7;
var b:int=a/2;
trace(b);//输出：3
var c:Number=a/2;
trace(c);//输出：3.5
说明
输出的结果中，变量b和变量c的数据类型不同，输出的结果也不相同。
整数类型还要注意的是上下边界问题。
使用int类型时，它的上限值为2 147 483 647，下限值是-2 147 483 648。数据是一个环形结构，或者说是一个循环，从最小值-2 147 483 648开始递加直到最大值2 147 483 647，然后下一个数字又变为最小值-2 147 483 648。
这样造成的结果是：执行完最大值之后，如果还要继续加1的话，那么下一个数字将变为最小值，而不是预期的最大值加1。从最小值减1的效果与此相同。请看下面的代码：
var i:int=2147483647;
i++;
trace(i);//输出：-2147483648
var j:int=-2147483648;
j--;
trace(j);//输出：2147483647
另外，int类型数据可以接受大于其上界或者小于其下界的值，但是编译器会对其进行处理，处理的方法同样是数字环方式。请看下面的代码：
var i:int=2147483648;
trace(i);//输出为：-2147483648
var j:int=-2147483649;
trace(j);//输出为：2147483647
注意 输入的大于上界的变量可以接受，但处理过的值变为了-2 147 483 648，循环到了下界。
使用uint类型时，其上界值为4 294 967 265，下界值为0。特别要注意它是一个正整数，千万不能在其前使用负号，否则编译器会报错。其数值顺序也是一个环形结构，上界之后的数值是下界，下界之后的数值是上界。请看下面的代码：
var i:uint=0;
i--;
trace(i);//输出：4294967295
var j:uint=4294967295;
j++;
trace(j);//输出：0
uint类型数据不能接受大于其上界值或小于其下界值的数字，否则编译器将会报错。比如下面的定义代码是错误的：
var i:uint=-1
var j:uint=4294967296
uint类型数据在使用for循环倒序输出时，其变量的控制条件只能是“变量>0”，而不能是“变量>=0”，否则就会造成死循环。如下面的代码：
for (var i:uint=5; i>0; i--) {
trace(i);
}//输出：5、4、3、2、1
说明
输出的结果只能到1，而不能到0。
若要预期到0，想使用下面的代码：
for (var i:uint=5; i>=0; i--) {
trace(i);
}
说明
这段代码编译器不能通过，输出“脚本的执行时间已经超过了15秒的默认超时设置”，也就是所说的进入了死循环。
使用Number类型时，需要注意的一点是小数相加不一定能得到一个想要的整数。
比如下面使用循环把10个0.1相加，期望得到的结果是1，实际的结果是0.999 999 999 999 9。代码如下所示：
var a:Number=0;
for (var i:int=0; i<10; i++) {
a=a+0.1;
}
trace(a);//输出：0.9999999999999999
trace(a==1);//输出：false
trace(a-1);//输出：-1.1102230246251565e-16
说明
继续输出的结果，输出的a值并不和1相等，而如果再减去1的话，则会输出一个更加莫名其妙的结果：-1.110 223 024 625 156 5e-16。
这是浮点数运算的一个问题。如果编程中一定要使用浮点数，最好使用Math.round()函数处理计算的结果。
另一个要注意的是不要让差距太大的浮点数直接相加减，否则结果也会出现偏差。请看下面的代码：
var a:Number=1000000000;
var b:Number=0.000000001;
trace(a+b);//输出：1000000000
说明
从上面代码输出可以看出，把一个很大的数1 000 000 000和一个很小的数0.000 000 001相加，输出的结果为：1 000 000 000，和没有加一样。
当然，如果两个很小的数相加，则不会出现问题。请看下面的代码：
var a:Number=0.000000001;
var b:Number=0.000000001;
trace(a+b);//输出：2e-9
一般来说，如果两个浮点数的差距不是很大，就不会出现问题。只是对于非常精确的计算，则会产生一定的影响。
3. String数据类型
String数据（字符串）类型，用于表示一个16位字符的序列。字符串在内部存储为Unicode字符，并使用UTF-16格式。字符串是最重要的数据类型。对普通文本的处理、对XML文本的处理、对外部传入数据的处理等，没有一个不与字符串有关。
声明字符串的方法如下代码所示:
//声明一个字符型变量，未赋值
var str1:String;
//声明一个字符串变量，赋值为空
var str2:String="";
//用类来声明一个空字符串
var str3:String=new String();
//声明一个内容为welcome的字符串
var str4:String="welcome";
//同上的效果
var str5:String=new String("welcome");
//使用单引号同样可以声明字符串
var str6:String='welcome';
要注意的是，定义了变量未赋值和定义一个空字符串并不相等。如下面的代码所示：
var str1:String;
var str2:String="";
trace(str1==str2);//输出：false
4. Array数组类型
数组就像一个容器，可以容纳各种不同的内容，将多种对象组合在一起。在编程的过程中，为了储存各个具有共同特性的变量，可使用数组作为存取的工具。
在ActionScript 3.0中，声明数组的方式如下面的代码所示：
//声明一个数组变量arr1，但是没有引用的对象，输出为null var arr1:Array; //直接声明一个空数组，输出为空白 var arr2:Array=[]; //效果同上 var arr3:Array=new Array(); //直接使用[]操作符，建立一个含有整数1、2、3、4的数组 var arr4:Array=[1,2,3,4]; //使用Array类建立一个数组，内容为1、2、3、4 var arr5:Array=new Array(1,2,3,4); //声明一个长度为5的空数组，所有的元素都为空 var arr6:Array=new Array(5);
另外，在ActionScript 3.0中在使用[]操作符定义数组的时候，可以在最后一个元素的后面保留一个逗号。代码如下：
var arr7:Array=[1,2,3,4,];
注意 此操作只对[]操作符有效，而对Array()和new Array()无效。
访问数组的方式要使用数组运算符[]来访问。比如下面的代码：
arr1[0];
arr2[1];
注意 数组元素的第一个索引是0，访问第一个元素要使用arr1[0]来访问。
5. Object数据类型
Object数据类型是由Object类定义的。Object类用作ActionScript中的所有类定义的基类。
Object的成员有两个：一个是属性，用来存放各种数据；一个是方法，用来存放函数对象。
成员的名字，有时也被称为键，成员被称为与这个键对应的值。
定义Object（对象）的方法如下代码所示：
//此法为构造函数法
var obj1:Object=new Object();
//{}为new Object()函数的语法快捷方式
var obj2:Object={};
这两种方法构造的结果完全相同，都是新建一个空白的Object。
使用空的大括号构造对象时，可以把对象的属性和方法都写进去。下面的代码写入对象的属性：
var obj:Object={name:"lzxt",url:"www.flasc.cn"};
trace(obj.name);
trace(obj.url);
代码运行后的输出结果如下所示：
lzxt
www.flasc.cn
说明
可以同时写入多个属性，属性名和属性值用“:”分开，属性与属性之间用“,”分开。
下面的代码写入对象的方法：
var obj:Object={hello:function hello():void{
trace("你好，欢迎学习AS3.0")
}};
obj.hello();//输出：你好，欢迎学习AS3.0
Object支持动态添加属性和方法，请看下面的代码：
//新建一个空对象obj
var obj:Object={};
//给对象obj添加一个属性name，并将字符串“浪子啸天”赋值给它
obj.name="浪子啸天";
//给对象obj添加一个属性name，并将数字30赋值给它
obj.age=30;
trace(obj.name);
trace(obj.age);
//给对象obj添加一个方法hello
obj.hello=function(){
trace("你好，欢迎学习AS3.0")
};
obj.hello();
代码运行后的输出结果如下所示：
浪子啸天
30
你好，欢迎学习AS3.0
2.3.2 数据类型检查
任何编程代码在执行前或者执行时都要执行数据类型的检查，以避免出现数据错误。ActionScript 3.0是动态类型的语言，它默认的是执行时进行数据类型检查。同时它也在适合使用严格模式的编译器编译时执行数据类型检查。在使用严格模式的编译器中，数据类型检查既可以在执行前执行编译器检查，也可以在运行时执行检查。在标准模式下，只支持默认执行时的数据类型检查。
比如在程序编写过程中，要明确传递变量值的类型和接受参数类型相同。如下面的代码：
function func(mystr:String) {
trace(mystr);
}
var str:String="welcome you";
func(str);
上面代码中函数func接受的参数mystr的数据类型为String，则在调用函数时输入的参数也必须为String类型，否则就会编译报错。
在严格模式下，ActionScript编译器将类型不匹配报为编译器错误，此为编译时检查。请看下面的例子，在下面的代码中，在函数中声明一个对象类型的参数，但是后来又将这个参数赋给了字符串和数字型，在安全模式中将产生一个编译错误：
//定义一个函数
function DynamicTest(varx:Object){
if(varx is String){
var string:String=varx;
//在安全模式中将产生一个编译错误
trace("String"+string);
}else if(varx is Number){
var number:Number=varx;
//在安全模式中将产生一个编译错误
trace("Nubmer"+number);
}
}
在普通模式中，Flash Player同样也有严格要求。请看下面的例子，在函数func中参数接受了一个值3，因为参数的类型声明是一个（Array），即使在普通模式中运行也会报错：
function func(arr:Array) {
trace(arr);
}
var str:int=3;
func(str);
即使这里输入的str不设定数据类型，在编译时同样报错。代码如下所示：
function func(arr:Array) {
trace(arr);
}
var str=3;
func(str);
2.3.3 隐式数据类型转换
数据类型转换是指把某个值转换为其他类型的数据。类型的转换有两种方式：隐式转换和显式转换。隐式转换又称为强制转换，由Flash Player在运行时执行。比如将2赋值给Boolean数据类型的变量，则Flash Player会先将2转换为布尔值true，然后再将其赋值给该变量。
隐式转换也可以称为自动转换，是在程序编译的过程中由程序本身来进行数据类型的转换。它主要发生在许多上下文中。主要分为以下几种情况：
❑在赋值语句中。
❑ 在将值作为函数的参数传递时。
❑ 在从函数中返回值时。
❑ 在使用某些运算符（如加法运算符（+））的表达式中。
下面的代码对上面所列的情形进行测试：
var a:Number=1.5;
//把变量a赋值给b
var b:int=a;
trace(b);//输出：1，程序运行时自动把Number型转换为int型
function test(n:int) {
trace(n);
}
var c:Number=10.10;
test(c);//输出：10，程序运行时自动把Number型转换为int型
function tests(s:Number):int {
return s;
}
var d:Number=3.45;
trace(tests(d));//输出：3，程序运行时自动把Number型转换为int型
var i:Number=15;
var j:String="1";
trace(i+j);//输出：151，程序运行时自动把Number型转换为String型
说明
数据类型的隐式转换是根据不同的情形进行的，有时能够转换，有时不能转换，在不能转换时会抛出错误。
2.3.4 显式数据类型转换
显式转换是指代码指示编译器将一个数据类型的变量视为属于另一个类型的变量时执行该转换。该转换主要利用数据类型的对象名称来转换。常用的数据转换均为此方式。
显式转换是利用数据类型的对象名称来转换，常见的主要有下面几种。
1. 转换为int、uint和Number
任何数据类型都可以转换为int、uint和Number三种数字类型之一。如果Flash Player由于某种原因无法转换，则转换为这些数字数据类型的默认值。
布尔值（Boolean）转换数字，true转换为1，false转换为0。代码如下所示：
var p:Boolean=true;
trace(uint(p));//输出：1
trace(int(p));//输出：1
trace(Number(p));//输出：1
p=false;
trace(uint(p));//输出：0
trace(int(p));//输出：0
trace(Number(p));//输出：0
仅包含数字的字符串可以转换为对应的数字类型。代码如下所示：
trace(uint("5"));//输出：5
trace(uint("-5"));//输出：4294967291。它从上界开始递减
trace(uint(" 27 "));//输出：27
trace(uint("3.7"));//输出：3
trace(int("3.7"));//输出：3
trace(int("0x1A"));//输出：26
trace(Number("3.7"));//输出：3.7
说明
要注意的有两方面：一是如果字符串的变量转为数字之后超出了数字类型的边界，则按照环形进行转换；二是如果含有表示十六进制值的字符串（如0x1A），该字符串也可以转为数字。
对于包含非数字字符的字符串值，在用int()或uint()转换时，将返回0；在用Number()转换时，将返回NaN。转换过程中会忽略前导和尾随空白，但是，如果字符串中包含将两个数字隔开的空白，则将返回0或NaN。代码如下所示：
trace(uint("5a")); //输出：0
trace(uint("ten")); //输出：0
trace(uint("17 63")); //输出：0
trace(int("5a")); //输出：0
trace(Number("5a")); //输出：NaN
在ActionScript 3.0中，Number()函数不再支持八进制数或基数为8的数。ActionScript 3.0会忽略变量中的前导0。代码如下所示：
trace(Number("044"));//输出：44
其他数据类型转换为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。
2. 转换为Boolean
数字数据类型转换为Boolean时，若数值为0，结果为false；否则为true。对于Number数据类型，如果值为NaN，则结果也为false。代码如下所示：
trace(Boolean(-2));//输出：true
trace(Boolean(0));//输出：false
trace(Boolean(1));//输出：true
trace(Boolean(2));//输出：true
trace(Boolean(1.5));//输出：true
trace(Boolean(NaN));//输出：false
字符串值类型转换为Boolean数据类型时，如果字符串为null或空字符串（" "），则会返回false；否则将返回true。代码如下所示：
// 未初始化的字符串为 null
var str1:String;
trace(Boolean(str1));// false
// 空字符串
var str2:String = "";
trace(Boolean(str2));// false
// 仅空白
var str3:String = " ";
trace(Boolean(str3));// true
Object类的实例转换为Boolean数据类型时，如果该实例为null，则会返回false；否则将返回true。
// 未初始化的对象为 null
var obj:Object;
trace(Boolean(obj)); // false
// 实例化
obj = new Object();
trace(Boolean(obj)); // true
数据类型转换为Boolean数据类型时的结果总结如下：
❑ String：如果值为null或空字符串（" "），则结果为false；否则为true。
❑ null：false。
❑ Number、int或uint：如果值为NaN或0，则结果为false；否则为true。
❑ Object：如果实例为null，则结果为false；否则为true。
3. 转换为String
数值数据类型转换为String数据类型时，都会返回数字的字符串形式。代码如下所示：
var i:int=-1;
var j:uint=3;
var k:Number=1.56;
trace(String(i)); //输出：-1
trace(String(j)); //输出：3
trace(String(k)); //输出：1.56
布尔值转换为String数据类型时，如果值为true，则返回字符串“true”；如果值为false，则返回字符串“false”。代码如下所示：
var p:Boolean=true;
trace(String(p));//输出：true
p=false;
trace(String(p));//输出：false
Object类的实例转换为String数据类型时，如果该实例为null，则返回字符串“null”；否则，将返回字符串“[object Object]”。代码如下所示：
var obj:Object
trace(String(obj));//输出：null
obj={}
trace(String(obj));//输出：[object Object]
Array类的实例转换为String时，会返回一个字符串，其中包含所有数组元素的逗号分隔列表。代码如下所示：
var arr:Array=new Array("one","two","three");
trace(String(arr))//输出：one,two,three
Date类的实例转换为String时，会返回该实例所包含日期的字符串表示形式。代码如下所示：
var date:Date=new Date()
trace(String(date))//输出：Wed Mar 5 22:29:43 GMT+0800 2008
其他数据类型转换为String数据类型时的结果总结如下：
❑ Array：一个包含所有数组元素的字符串。
❑ Boolean：“true”或“false”。
❑ Date：Date对象的字符串表示形式。
❑ null：“null”。
❑ Number、int或uint：数字的字符串表示形式。
❑ Object：如果实例为null，则结果为“null”；否则为“[object Object]”。
2.3.5 无类型说明符
ActionScript 3.0引入了3种特殊类型的无类型说明符：*、void和null。
❑ 使用*类型用于指定属性是无类型的。使用*作为类型注释与不使用类型注释等效。从无类型属性中读取的表达式可视为无类型表达式。该说明符主要用于两个方面：将数据类型检查延缓到运行时和将undefined存储在属性中。
❑ void用于说明函数无法返回任何值。void类型只有一个值：undefined。该说明符仅用于声明函数的返回类型。
❑ null是一个没有值的特殊数据类型。Null数据类型只有一个值：null。Null数据类型不与任何类相关联。不可将Null数据类型用作属性的类型注释。
2.4 运算符与表达式
学习一门编程语言，首先要弄清楚的就是如何对其中的数据进行运算。使用表达式来表达想要达到的效果，使用运算符来进行相关的运算，这就是数据运算的关键。本节主要介绍常用的运算符的用法。
2.4.1 运算符与表达式基础知识
运算符可以通过给出的一个或者多个值来产生另一个值。可以说它是一种特殊的函数。其中的值称为“操作数”，具体包括字面值、变量和表达式。
运算符分为3种：一元运算符、二元运算符、三元运算符。一元运算符只运算一个值，例如递增运算符++；二元运算符比较常见，ActionScript 3.0中大部分运算符都是二元运算符；三元运算符具有3个操作数，例如条件运算符（?:）具有3个操作数。
有些运算符是支持重载的，也就是在运算符运算之后直接返回运算的结果。这种运算符的行为因操作数的数据类型的不同而不同。比如加法运算符（+），如果两个操作数都是数字，则加法运算符会返回这些值的和；如果两个操作数都是字符串，则加法运算符会返回这两个操作数连接后的结果。请看下面的代码：
trace(5 + 5); //输出：10
trace("5" + "5"); //输出：55
操作数和运算符的组合，就构成了表达式。每个表达式都要产生一个值，这个值就是表达式的值。比如1+3是一个表达式，+就是运算符，其表达式的值为4；1==2是一个表达式，其值为false；a=0是一个表达式，其值是0。
2.4.2 赋值运算符
赋值运算符有两个操作数，它根据一个操作数的值对另一个操作数进行赋值操作。ActionScript中的赋值运算有12个，如表2.4所示。
表2.4 赋值运算符
本小节主要介绍最常用的一个赋值运算符等号（=）。它的意思是将等号右边的值赋值给左边的变量。语法格式如下：
变量名=值
格式说明如下：
❑变量名：必须是一个变量，可以是事先声明好的，也可以在变量前使用var关键字声明。
❑值：可以是基元型数据类型数据，也可以是一个表达式、函数返回值或者对象的引用。
其符合标准的代码如下所示：
//声明一个变量，并赋值
var a:int=1;
//声明一个变量，未赋值
var b:String;
//对已经声明好的变量赋值
b="welcome";
//右边为一数学表达式，使用表达式赋值
a=1+3+5;
//创建一个新的显示对象，并赋值给变量sp
var sp:Sprite=new Sprite();
//将sp的引用赋值给sp p
var spp:Sprite=sp;
下面是不符合标准的代码，编译器无法通过：
/左边是基元类型数字
10=10;/
var a;
//左边是基元类型字符串
"welcome"=a;
//左边是未声明的对象
new A()=5;
注意 在ActionScript中，等号（=）是一个赋值运算符，而不是关系运算符，不能使用其来比较两边的值是否相等。
2.4.3 算术运算符
算术运算符共有6个，分别为加、减、乘、除、模运算和求反运算。
加、减、乘、除的运算很简单，请看下面的代码示例：
var a:int=1;
var b:int=2;
var c:int=a+b;
var d:int=a-b;
var e:int=a＊b;
var f:int=a/b;
模运算实际就是数学中的求余数的运算，但是要注意，如果模运算的运算数值不是整数，可能会出现一些意外的情况。请看下面的代码示例：
var i:int=7%2;
trace(i);//输出：1 正确的结果
trace(7.1%2);//输出：1.0999999999999996 并非期望的值1.1
求反运算符其实就是减号，或者是数学中的负号，实际就是求一个值的相反数。请看下面的代码示例：
var s:int=1;
var z=-s;
trace(z);//输出：-1
算术运算符的具体使用方法总结如表2.5所示。
表2.5 算术运算符
2.4.4 算术赋值运算符
算术赋值运算符和算术运算符对应，共有5个，分别为+=、-=、*=、/=和%=。和赋值运算符一样，运算符的左侧只能是变量，右侧是一个要值、变量或表达式。
这种类型的赋值运算符有时也叫做自赋值运算符，就是利用自身进行运算并赋值给自己。比如下面的代码语句：
a+=1;
其要表达的运算过程就是下面的代码要执行的运算过程：
a=a+1;
下面的代码用来测试这两种方式执行的结果：
var a:int=0;
a=a+1;
trace(a);//输出：1
var b:int=0;
b+=1;
trace(b);//输出：1
算术赋值运算符的具体使用方法总结如表2.6所示。
表2.6 算术赋值运算符
2.4.5 关系运算符
关系运算符用于比较两个操作数的值的大小关系。常见的关系运算符一般分为两类：一类用于判断大小关系，一类用于判断相等关系。其具体情况如下：
判断大小关系：>大于运算符、<小于运算符、>=大于等于运算符、<=小于等于运算符。
判断相等关系：==等于运算符、!=不等于运算符、===严格等于运算符、!==严格不等于运算符。
关系运算符左右两侧可以是数值、变量或者表达式。关系表达式的结果是Boolean值，false或者true。
1. 判断大小关系的运算符
>大于运算符、<小于运算符、>=大于等于运算符、<=小于等于运算符这4种关系运算符，在针对数值的比较时，和数学运算的结果一样，按照大小关系进行判断。请看下面的测试代码：
var a:int=1;
var b:Number=4;
trace(a>b);//输出：false
trace(a>=b);//输出：false
var c:uint=4;
trace(b>c);//输出：false
trace(b>=c);//输出：true
数值的比较，对数字的3种类型int、uint和Number并不区分，按照数值大小来比较。但是，对于int型和uint型的数值，如果输入的值不符合类型的要求，系统会自动转换。比如一个变量为int型，如果给其赋值为4.1，则系统会自动将其值处理为整数4。测试代码如下所示：
var c:uint=4;
var d:int=4.1;
trace(d>c);//输出：false
trace(d>=c);//输出：true
当运算符左右两侧的数据类型不一致时，系统会把非数值的一侧的对象转换成数值，然后再进行比较。
注意 Boolean类型的转为数值1或者0。
var a:Number=6;
var c:Boolean=true;
trace(a>c);//输出：true
但是，若运算符的一侧为数字，一侧为字符串时，在执行比较运算时，编译器不能通过。测试代码如下：
var a:Number=6;
var b:String="7";
trace(a>b);
注意 此代码不能编译通过，输出为：“在属于static类型Number的值与可能的非相关类型String之间进行比较”。
所以，要对数字与字符串进行比较时，需要执行显式转换，把字符串转换成字符串再进行比较。或者字符串变量不声明数据类型而进行比较。如下代码所示：
var a:Number=6;
var b:String="5";
trace(a>Number(b));//输出：true
var c:Number=4;
var d="5";
trace(c<d);//输出：true
此外，如果非数值对象不能转换为数值，那么这个表达式的执行结果则一直为false。如下代码所示：
var a="welcome";
//不能设置变量的数据类型，否则编译不能通过
var b:Number=4;
trace(a>b);//输出：false
var c:Object=new Object();
//此处可以定义数据类型
trace(b>c);//输出：false
如果比较运算符两侧的操作数都是字符串的话，则要按照从左到右的字母顺序来进行比较。如下代码所示：
var str1:String="abc";
var str2:String="abd";
trace(str1<str2);//输出：true
2. 判断相等关系的运算符
相等有两种情况：一种是通过数据类型的转换能够实现数值的相等，此为通常意义上的相等；另一种是绝对的相等，要求不仅数值相等，而且数据类型也完全相同，此为严格相等。注意，int、uint、Number都为数值类型，在比较的时候认为数据类型相同。测试代码如下所示：
var a:int=3;
var b:uint=3;
trace(a==b);//输出：true
trace(a===b);//输出：true
var c="3";
trace(a==c);//输出：true
trace(a===c);//输出：false
var d:int=1;
var e:Boolean=true;
trace(d==e);//输出：true
trace(d===e);//输出：false
说明
从以上代码可以看出，相等运算符可以通过数据类型隐式转换之后进行比较，而严格相等则没有任何的转换，直接进行比较。
注意 字符串类型的变量还是不能声明数据类型。
此外，相等和严格相等对变量的默认值的比较是不同的。
若比较运算符两侧对象的值都是数值类型，则都为NaN时，相等和严格相等的比较结果相同，都为false。测试代码如下所示：
var a:Number;
var b:Number;
trace(a);//输出：NaN
trace(b);//输出：NaN
trace(a==b);//输出：false
trace(a===b);//输出：false
不等于和严格不等于的用法相同，此处不再赘述。
关系运算符的具体使用方法总结如表2.7所示。
表2.7 关系运算符
2.4.6 逻辑运算符
逻辑运算符有3个，分别为：&&逻辑“与”运算符、||逻辑“或”运算符、!逻辑“非”运算符。逻辑运算符常用于逻辑运算，运算的结果为Boolean型。
逻辑与（&&）和逻辑或（||）运算表达式要求左右两侧的表达式或者变量必须是Boolean型的值。
❑&&：左右两侧有一个为false，结果都为false；只有两侧都为true，结果才为true。
❑||：左右两侧有一个为true，结果都为true；只有两侧都为false，结果才为false。
测试代码如下所示：
var a:int=1;
var b:int=-1;
trace(a>0);//输出：true
trace(b<0);//输出：true
trace(a>0&&b<0);//输出：true
trace(true&&false);//输出：false
trace(false&&false);//输出：false
trace(b>0);//输出：false
trace(a>0||b>0);//输出：true
trace(true||true);//输出：true
trace(false||false);//输出：false
逻辑非（!）运算符主要用于对Boolean型变量进行取反操作。具体用法如下面的代码所示：
var p=false;
trace(p);//输出：false
trace(!p);//输出：true
逻辑运算符的具体使用方法总结如表2.8所示。
表2.8 逻辑运算符
2.4.7 按位和按位赋值运算符
按位运算符共有6个，分别为&按位“与”、^按位“异或”、|按位“或”、<<按位左移位、>>按位右移位、>>>按位无符号移位。同样，按位赋值运算符也有6个，对照按位运算符分别为&=按位“与”赋值、^=按位“异或”赋值、|=按位“或”赋值、<<=按位左移位赋值、>>=按位右移位赋值、>>>=按位无符号移位赋值。
按位操作需要把十进制的整数转换为二进制的数，然后进行操作。
按位与操作过程：按位与操作的规则为1+1=1，1+0=0，0+1=0，0+0=0。比如11&34，11转二进制数为001011，34转二进制数为100010。现在按照位置从右向左第一位分别为1和0，所以取与后仍为0，依次取与的最后结果为000010。000010转为十进制数为2，所以最后的输出结果为2。代码如下所示：
var a:int=11;
var b:int=34;
trace(a&b);//输出为：2
按位异或操作过程：按位异或操作的规则为1+1=0，1+0=1，0+1=1，0+0=0。比如11&34，11转二进制数为001011，34转二进制数为100010。现在按照位置从右向左第一位分别为1和0，所以取异或后为1，依次取异或的最后结果为101001。101001转为十进制数为41，所以最后的输出结果为41。代码如下所示：
var a:int=11;
var b:int=34;
trace(a^b);//输出为：41
按位或操作过程：按位或操作的规则为1+1=1，1+0=1，0+1=1，0+0=0。比如11&34，11转二进制数为001011，34转二进制数为100010。现在按照位置从右向左第一位分别为1和0，所以取异或后为1，依次取异或的最后结果为101011。101011转为十进制数为43，所以最后的输出结果为43。代码如下所示：
var a:int=11;
var b:int=34;
trace(a|b);//输出为：43
按位移动运算符主要用于表示色彩的二进制数，用此可以进行色彩的转换。在这里只说明按位左移运算符的原理和用法，其他的原理和用法与其相似。
按位左移运算符的语法格式如下：
数值<<位数;
格式说明如下：
❑数值：十进制数字。
❑<<：按位左移运算符。
❑位数：按位移动的位数，一个正整数。
按位左移的操作规则：把数值转为二进制数，然后左移位数，右边空出的位置补零。比如3<<4，3的二进制数为11，左移4为并补零后为110000，转为十进制数为48，故输出的结果即为48。代码如下所示：
var a:int=3;
trace(a<<4);//输出：48
按位赋值运算符也是自运算符，和算术赋值运算符表示的意思一样，在此不再赘述。
按位和按位赋值运算符的具体使用方法总结如表2.9所示。
表2.9 按位和按位赋值运算符
2.4.8 递加运算符和递减运算符
++递加运算符和--递减运算符常用于循环计算过程中，对循环中的变量进行递加或者递减操作。比如i++，它等价于i=i+1。测试代码如下：
var i:int=0;
i++;
trace(i);//输出：1
同样，i--等价于i=i-1。测试代码如下：
var i:int=5;
i--;
trace(i);//输出：4
2.4.9 三元条件运算符
?:运算符是唯一的一个三元运算符，也就是说，这个运算符有3个操作数。具体的语法格式如下：
(条件表达式)?（表达式1）:(表达式2);
格式说明如下：
❑条件表达式：判断表达式，通过逻辑判断，得到一个Boolean型的结果。
❑表达式1：判断表达式的结果为true，执行该语句。
❑表达式2：判断表达式的结果为false，执行该语句。
示例代码如下所示：
var i:int=11;
i>10?trace("大于10了"):trace("小于10了");
代码运行后的输出结果如下所示：
//输出：大于10了
2.4.10 其他运算符
在ActionScript 3.0中还有几个常见的运算符，如typeof、is、as。下面对这几个运算符进行简单地说明。
1. typeof运算符
typeof用于测试对象的类型，使用的方法如下：
typeof(对象);
下面的语句使用typeof函数测试10这个对象的类型，示例代码如下所示：
trace(typeof(10));//输出：number
2. is运算符
is运算符用于判断一个对象是不是属于一种数据类型，返回Boolean型变量。如果对象属于同一类型，则返回true，否则返回false。
下面代码测试一个字符串是否是一个数字类型，代码如下所示：
trace("5" is Number);//输出false
3. as运算符
as运算符和is运算符的使用格式相同，但是返回的值不同。如果对象的类型相同，返回对象的值；若不同，则返回null。测试代码如下所示：
trace("5" as Number);//输出：null
trace("5" as String);//输出：5
2.4.11 运算符的优先级
运算符的优先级顺序决定了一个表达式的运算顺序。就像数学中的乘除运算要优先于加减运算一样， ActionScript 3.0中的各运算符之间也有一个优先运算的顺序。具体请参照表2.10所示。
表2.10 运算符优先顺序表
2.5 练习题
1. 给出以下代码输出的结果。
var obj:Object=new Object();
trace(Number(obj));
结果：_______。
2. 以下输出为0的是( )。
A. var num:Number;trace(num);
B. var num:int=10;trace(num>0);
C. trace(Number("5" is Number));
D. var i:int=10;var num:int=i>0?0:1;trace(i);
3. 以下代码编写正确的是( )。
A. var arr:Array={1,2,3,4};
B. var obj:Object=[1,2,3,4];
C. var arr:Array=new Array(); arr(0)=1;
D. var obj:Object={[1,2,3],[2,3,4]}
4. （多选）以下描述正确的是( )。
A. 数字和字符串是不同的数据类型，进行大小比较时需要进行显式转换
B. 数字和字符串进行相等（==）判断时，不用进行显式转换
C. is运算符，用于判断对象是不是某种类型，如果是会将对象转换成此类型，并返回此对象
D. as运算法，用于判断对象是不是某种类型，是返回true，否返回false
5. 思考trace(NAN==NAN)的结果是true还是false，为什么？