第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;

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);

既然全局變量在函數內和函數外都可以訪問，若函數內和函數外都定義有一個同名的變量，則函數體內和體外以哪一個為準呢？請看下面的測試代碼：

    //函數體外定義變量
    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 ++) {}

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。

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

而對值類型來說，常量的值不能進行修改，無論是修改它本身還是修改其引用。比如下面的代碼：

    //定義常量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

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

但不能直接給布爾型變量賦值為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

整數類型還要注意的是上下邊界問題。

使用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

使用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

若要預期到0，想使用下面的代碼：

    for (var i:uint=5; i>=0; i--) {
            trace(i);
    }

使用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

這是浮點數運算的一個問題。如果編程中一定要使用浮點數，最好使用Math.round()函數處理計算的結果。

另一個要注意的是不要讓差距太大的浮點數直接相加減，否則結果也會出現偏差。請看下面的代碼：

    var a:Number=1000000000;
    var b:Number=0.000000001;
    trace(a+b);//輸出：1000000000

當然，如果兩個很小的數相加，則不會出現問題。請看下面的代碼：

    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,];

訪問數組的方式要使用數組運算符[]來訪問。比如下面的代碼：

    arr1[0];
    arr2[1];

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

對于包含非數字字符的字符串值，在用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;

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

當運算符左右兩側的數據類型不一致時，系統會把非數值的一側的對象轉換成數值，然后再進行比較。

    var a:Number=6;
    var c:Boolean=true;
    trace(a>c);//輸出：true

但是，若運算符的一側為數字，一側為字符串時，在執行比較運算時，編譯器不能通過。測試代碼如下：

    var a:Number=6;
    var b:String="7";
    trace(a>b);

所以，要對數字與字符串進行比較時，需要執行顯式轉換，把字符串轉換成字符串再進行比較。或者字符串變量不聲明數據類型而進行比較。如下代碼所示：

    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，為什么？