FLASH動作腳本詳解

FLASH動作腳本詳解

一、FLASH腳本基礎入門講解

二、按鈕AS的編寫

三、影片剪輯的AS編寫

四、動态文本框

五、影片剪輯的拖拽

六、流程控制與循環語句

七、繪圖及顔色的AS的編寫

八、聲音 AS 的編寫與控制

九、時間日期的 AS編寫

十、點文法以及路徑

十一、深入了解時間控制

十二、無條件轉移

十三、變量

十四、運算符（一）

十五、變量（二）

十六、影片剪輯的屬性

十七、再講循環語句

十八、影片剪輯處理函數

十九、複制影片剪輯

二十、深入 startDrag()與 stopDrag()

二十一、for循環

二十二、while與 do while循環

二十三、循環語句的嵌套

二十四、元件

二十五、播放器控制與網頁連接配接以及動畫釋出輸出

二十六、loadVariables指令

二十七、影片剪輯的深度

二十八、文本框

二十九、超文本标簽

一、FLASH腳本基礎入門講解

認識“動作”面闆

　 在Flash中，動作腳本的編寫，都是在“動作”面闆的編輯環境中進行，熟悉“動作”面闆是十分必要的。

按【F9】鍵調出“動作”面闆，可以看到“動作”面闆的編輯環境由左右兩部分組成。左側部分又分為上下兩個視窗。。

左側的上方是一個“動作”工具箱，單擊前面的圖示展開每一個條目，可以顯示出對應條目下的動作腳本語句元素，輕按兩下選中的語句即可将其添加到編輯視窗。

　　 下方是一個“腳本”導航器。裡面列出了FLA檔案中具有關關聯作腳本的幀位置和對象；單擊腳本導航器中的某一項目，與該項目相關聯的腳本則會出現在“腳本”視窗中，并且場景上的播放頭也将移到時間軸上的對應位置上。輕按兩下腳本導航器中的某一項，則該腳本會被固定。

　　 右側部分是“腳本”編輯視窗，這是添加代碼的區域。可以直接在“腳本”視窗中編輯動作、輸入動作參數或删除動作。也可以輕按兩下“動作”工具箱中的某一項或“腳本編輯”視窗上方的【添加腳本】工具 ，向“腳本”視窗添加動作。

　　在“腳本”編輯視窗的上面，有一排工具圖示，在編輯腳本的時候，可以友善适時的使用它們的功能。

　　在使用“動作”面闆的時候，可以随時點選“腳本”編輯視窗左側的箭頭按鈕，以隐藏或展開左邊的視窗。将左面的視窗隐藏可以使“動作”面闆更加簡潔，友善腳本的編輯。

　　好了，動作面闆就介紹這些，有個印象，不要求記住，工具欄上每個工具的作用和功能将在以後的課程中邊用邊熟悉。

如何編寫flash中的腳本

首先，要知道編寫腳本，不需要使用者對AS有完全的了解！

　　現在要考慮的問題是，如何在你的flash中添加編寫腳本？簡單的說，添加腳本可分為兩種：一是把腳本編寫在時間軸上面的關鍵桢上面（注意，必須是關鍵桢上才可以添加腳本）。二是把腳本編寫在對象身上，比如把腳本直接寫在MC（影片剪輯元件的執行個體）上、按鈕上面。

　　此外，大家也需要簡單了解一下flash是如何執行你編寫的腳本的。當你在時間周的關鍵桢上添加了腳本，那麼當flash運作的時候，它會首先執行這個關鍵桢上的腳本，然後才會顯示這個關鍵桢上的對象。

　　還有一些簡單的知識，AS中的對象都包括什麼呢？它可以包含資料，也可以是舞台上的電影剪輯，也可以是舞台上的按鈕等。既然包含了那麼多對象，那麼每種對象肯定有各自的屬性！比如電影剪輯（movieclip）對象，它的：屬性就有_height(高度)，_rotation(旋轉)，等，這些屬性不需要你去特意的記憶，當使用的時候可以随時翻閱腳本字典。在以後的教程中會陸續給大家介紹一些基礎腳本的使用技巧。

　　

　　二、需要學到的基本AS指令如下：

　　stop()、play()、gotoandplay()、gotoandstop()、nextFrame()、prevFrame();、nextScene()、prevScene();、stopAllSounds(); 按鈕的AS編寫規則

播放

on (release) {

_root.mc.play();

}

　　如果要在按鈕身上寫腳本的話，必須使用on(事件){//腳本程式}的格式來寫！上面的腳本作用就是：當你在這個按鈕上按一下滑鼠（release事件）的時候，就會執行下面的_root.mc.play();程式，它的意思是讓舞台上的mc開始播放！

　　6、同理：咱們選中舞台上的暫停按鈕，在它上面輸入：

on (release) {

_root.mc.stop()

}

　　然後依次在快退上輸入：

on (release) {

_root.mc.prevFrame(); //prevFrame表示回到動畫的上一桢

}

　　在快進的按鈕上輸入：

on (release) {

_root.mc.nextFrame();

}

　　在停止的按鈕上輸入：

on (release) {

_root.mc.gotoAndStop(1); //跳到mc影片的第一桢，并停止播放！

}

二、按鈕AS的編寫

在 flash 中的互動功能一般是由按鈕來完成的。掌握按鈕的編寫規則也是一個閃客的基本技

能。

OK，現在咱們來說說按鈕腳本如何編寫。上一講中提過，AS 腳本編寫可以寫在時間軸的關

鍵桢上，也可以寫在對象本身上面。按鈕也不例外，既可以寫在時間軸上，也可以寫在按鈕

本身上面。隻不過這兩種編寫規則都要遵循一定的規矩，這是後話。

現在咱們來做一個例子， 做一個按鈕， 這個按鈕要實作的功能就是打開一個指定的網頁。

（這個例子非常基礎，用這個例子來講解按鈕 AS 兩種編寫方法。）

第一種：把腳本寫在按鈕本身。

一、 在舞台上繪制一個矩形，選中矩形并按 F8，将這個矩形轉換成按鈕元件。

二、 編寫動作腳本：

選中按鈕，按 F9，打開動作面闆，在專家模式下輸入以下腳本：

on(release){

getURL("http://3800hk.com/","_blank")

}

現在這個按鈕就實作了一個打開網頁的功能。通過例子你應該注意到，按鈕的 AS 書寫規則

就是：

on(事件){

//要執行的腳本程式，剛才的例子是用 getURL 來打開一個網頁。你也可以使用腳本程式來

執行其他功能，例如跳轉到某一個桢，或載入外部一個動畫檔案。

}

大可以看到，其實就一個 on語句，這個 on語句就是按鈕的 AS 編寫規則了。需要注意

的是 on 裡面的事件，這個事件你可以了解為是滑鼠或鍵盤的動作。剛才的例子我們使用的

事件是 release（按一下滑鼠）我現在把常用的按鈕事件列出來：

事件名字 說明

Press 事件發生于滑鼠在按鈕上方，并按下滑鼠

Release 發生在按鈕上方按下滑鼠，接着松開滑鼠時。也就是“按一下”滑鼠

Releaseoutside 發生于在按鈕上方按下滑鼠，接着把光标移動到按鈕之外，然後松開

滑鼠

Rollover 當滑鼠滑入按鈕時

Rollout 當滑鼠滑出按鈕時

Dragover 發生于按着滑鼠不放，光标滑入按鈕

Dragout 發生于按着滑鼠不放，光标滑出按鈕

Keypress 發生于使用者按下特定的鍵盤按鍵時

下面來看看第二種按鈕 AS的編寫方法。

這種方法是把腳本程式寫在時間軸上，而不是按鈕本身上面。

一、 選中按鈕，在下面的屬性面闆中為按鈕起一個名字，這裡我起了一個 bt

二、 選中時間軸的第一桢，按 F9 打開動作面闆。輸入如下腳本：

bt.onrelease = function() {

getURL("http:// http://3800hk.com/", "_blank");

};

這種編寫 AS 的方法要遵循的規則就是下面的公式而已：

按鈕執行個體的名字.事件名稱=function(){

//要執行的腳本程式。

}

大家隻要記住這個公式就可以套用了。

按鈕的 AS 就先将到這了，這個可以算是基本技能了。希望大家都能掌握。

三、影片剪輯的AS編寫

影片剪輯在flash中可以說是使用最多的一種元件了，那麼對于它的AS也是不

少。

在講解之前，我還是要重新說一下電影剪輯AS 的編寫規則，和上次講按鈕一樣，

分為兩種，一種是寫在電影剪輯本身上，一種是寫在時間軸上面。

一、首先我們先來做個簡單的小例子。

或許你不用 AS 就能做出一個小球的移動動畫。但是如果讓你用 AS 來實作小球的移動呢？

下面來看看如何用 AS 來實作吧。

在這個例子裡，你首先會了解到如何在電影剪輯本身上編寫 AS，以及編寫規則。

1、 建立立一個影片剪輯元件，裡面你就随便畫一個圓吧。之後把這個影片剪輯拖放到

舞台之中（也就是建立一個此影片剪輯的執行個體）。

2、 現在開始編寫腳本，選中這個 MC，按 F9 打開動作面闆，按照圖 01 顯示選擇

onClipEvent，之後在顯示的事件中選擇 enterFrame，然後在裡面編寫腳本如下：

this._x+=5

這個腳本編寫之後應該是：

onClipEvent (enterFrame) {// enterFrame的意思四以影片幀頻不斷地觸發此動作

this._x += 5; //this 代表這個影片剪輯自身。_x 表示影片剪輯的X 軸坐标。

}

呵呵，按下你的 ctrl+回車測試一下吧，一個簡單的移動動畫就搞定了。

從這個例子咱們不難看出，如果把 AS 寫在影片剪輯本身上，那麼它是有自己的書寫格

式的。正确的書寫格式就是：

onClipEvent (事件) {

//需要執行的腳本程式

}

這個可以看成是公式，你記住就行了，是寫在影片剪輯身上的。括号裡的“事件”其實是

個觸發器，當事件發生時，執行該事件後面花括号中的語句。，具體有哪些事件，我把它們

都列出來。

- load 影片剪輯一旦被執行個體化并出現在時間軸中時，即啟動此動作。

- unload 在從時間軸中删除影片剪輯之後，此動作在第一幀中啟動。處理與 Unload 影

片剪輯事件關聯的動作之前，不向受影響的幀附加任何動作。

- enterFrame 以影片幀頻不斷地觸發此動作。

- mouseMove 每次移動滑鼠時啟動此動作。_xmouse 和 _ymouse 屬性用于确定目前鼠

标位置。

- mouseDown 當按下滑鼠左鍵時啟動此動作。

- mouseUp 當釋放滑鼠左鍵時啟動此動作。

- keyDown 當按下某個鍵時啟動此動作。使用 Key.getCode 方法擷取最近按下的鍵的

有關資訊。

- keyUp 當釋放某個鍵時啟動此動作。 使用 Key.getCode 方法擷取最近按下的鍵的有關

資訊。

- data 當在 loadVariables 或 loadMovie 動作中接收資料時啟動此動作。當與

loadVariables 動作一起指定時，data 事件隻發生一次，即加載最後一個變量時。當與

loadMovie 動作一起指定時，擷取資料的每一部分時，data 事件都重複發生。

了解了事件之後，你可以自己試着修改一下腳本，如果讓你們點一下滑鼠，舞台上的圓

就移動一下，該怎麼做呢？

關于把 AS 寫在影片剪輯本身的例子先講到這，下面來看看如果把 AS 寫在時間軸上面

的話，應該怎麼寫。

首先你把剛才的腳本去掉。然後需要為這個影片剪輯執行個體起一個名字，比如起名為 mc

在選中時間軸的第一桢，打開動作面闆，輸入以下腳本：

mc.onEnterFrame = function() {

this._x += 5; //你也可以把這句改為 mc._x+=5 自己想一下為什麼。

};

顯而易見，在時間軸上的寫法就應該套用以下公式：

執行個體名.事件名稱=function(){

//腳本程式

}

需要注意的是，這種寫法的事件名稱不要忘了在前面加一個 on，比如，事件如果是

enterframe的話，你就應該寫成 onenterframe

下面簡單說一下影片剪輯的屬性。比如，影片剪輯有自己的X、Y 軸坐标，有自己的透

明度(_alpha)，這些都是它的屬性。

那麼如何使用這些屬性呢？你可以使用“點”文法來對屬性進行設定。

把上面的腳本修改一下。

mc.onenterframe = function() {

mc._x += 5;

mc._alpha = random(100);

};

這裡我加了一句 this._alpha = random(100)，它是設定影片剪輯的透明度的，使用的語句

就是_alpha。後面的 random()函數是随機選取一個100 以内的數字作為它的透明度。從這個

句子可以看出，“點”文法使用方法就是：執行個體名.屬性（mc._alpha），你甚至可以簡單了解為

“點”就是“的”，那麼 this._alpha 這句你就可以了解為：影片剪輯 mc的透明度

上面的腳本 mc._alpha = random(100)也可以改為_root. mc._alpha = random(100)

那麼，你就可以了解為：舞台上的影片剪輯 mc的透明度是随機選擇１００内的值。

四、動态文本框

一、flash 中的動态文本使用方法

在 flash中，文本工具提供了三種文本類型。分别是：靜态文本、動态文本和輸

入文本。

下面講解的内容屬于動态文本的 AS 編寫規則。要建立一個動态文本非常簡單，

隻需要 選中文本工具，然後選擇動态文本類型，然後在舞台上拖拽出所需要的

動态文本框就行了

。

二、如何為動态文本指派

當在舞台上拖拽出動态文本框之後， 可以直接在裡面進行文本輸入或粘貼外部文

本内

容。那麼用 AS 如何來對動态文本框指派呢？在這裡為大家介紹兩種方法進行

指派！

1、使用動态文本的執行個體名字來指派

操作步驟：

（1）在舞台上建立一個動态文本框，并為這個動态文本執行個體起一個名字，例如

abc

（2）選中時間軸的第一桢，打開動作面闆，輸入以下腳本：

abc.text = "愛國者安全網"

按下 ctrl+回車就可進行測試了。從這個簡單的例子可以知道，如果要用文本實

例名字 來進行指派的話，必須使用以下格式：動态文本執行個體的名字.text=”需要

指派的内容”

2、使用變量來指派

（1）在舞台上建立一個動态文本框，并為這個動态文本執行個體起一個變量名

3800hk。

（2）選中時間軸的第一桢，打開動作面闆，輸入以下腳本：

3800hk= "歡迎大家來到愛國者安全網學習！"

不難看出，使用變量指派更為簡單實用！指派格式為： 變量名=“指派的内容”

以上兩種指派方法如果内容過多需要換行的時候，需要使用行用回車符（ “\r”

即 ASCII

13）分隔！

三、如何載入外部 txt 文本裡的内容

當内容過多的時候，使用上面的方法并不是太好，我們可以使用下面的方法，從

外部獲 取文本資料内容！而外部的資料内容就放在一個普通的 txt（記事本）文

件中。

具體操作步驟如下：

1、建立一個動态文本執行個體，并為這個動态文本執行個體起一個變量名 hk

2、選中時間軸的第一桢，打開動作面闆，輸入以下腳本：

loadVariablesNum("heiying.txt", 0);//載入外部名字叫 heiying.txt 的文本檔案,加載

級别為0

3、現在來準備外部的 heiying.txt 文本檔案了。注意：要把這個文本檔案和你剛

才做的 flash檔案放在一個檔案夾裡！

這個 txt 檔案裡的資料應該按照如下格式編寫：flash中動态文本變量的名字=這

裡就是 所需要的資料内容。 對應上面的格式，外部 heiying.txt 中的内容為：

hk=歡迎大家來到愛國者安全網學習！

。

最後一點，需要将這個文本檔案儲存為 UTF-8 格式。

4、 完成以上步驟之後，就可以進行測試了。

下面介紹另外一種載入外部文本資料的方法， 并介紹當文本内容過多時候，如

何使用滾

動條元件

（1）建立一個動态文本執行個體，并并為這個動态文本執行個體起一個執行個體名字 anquan

（注： 是執行個體名而不是變量名）起一個變量名為 hk

（2）打開 flash 的元件面闆（快捷鍵 ctrl+F7），找到 UIScrollBar（滾動條）組

件。按着 它不動，然後拖放此元件至剛才的動态文本執行個體的右部邊緣，如果成

功的話，元件會和文本 框結合在一起！

（3）選中舞台第一桢，編寫如下腳本：

tt = new LoadVars();//建立一個 LoadVars 對象的執行個體，這裡的執行個體名字叫 tt

tt.load("heiying.txt");//建立的 tt 執行個體需要載入的對象是 heiying.txt 文本檔案。

tt.onLoad = function(s) { //開始載入外部檔案，具體格式請按照此例格式。參數 s

是訓示 load 操作是否成功完成。如果完成，那麼 S 的值就為 true( 真)，反之

為 false(假)

if (s) {

anquan.text = tt.hk;

}//如果載入成功， 則 anquan文本框中的内容就等于 tt.執行個體中的 heiying的内容！

（hk是我們 外部文本檔案中的變量。）

};

(4) 至于外部的 heiying.txt 還可以使用剛才所建立的文本檔案 ，為了測試滾動

條的效

五、影片剪輯的拖拽

在網上經常看到的 flash影片中有的對象可以被滑鼠進行拖動。例如有的類似七

巧闆的拼圖遊戲，控制音量的滑杆等，所使用的就是 flash中的拖拽動作。

一、拖拽指令詳細介紹

１、 首先介紹一下開始拖拽指令的詳細用法， 稍後在後面的例子中進行測試。

指令格式： StartDrag(要拖動的影片剪輯,[是否鎖定到滑鼠位置中央,左,

上,右,下])或寫為要拖動的影片剪輯.StartDrag([是否鎖定到滑鼠位置中央,左,上,

右,下])

指令講解：在制作動畫的過程中，上面兩種書寫方法可任選一種。其中［］

内的為可選參數，也就是可以寫，也可以不寫。至于左，上，右，下四個參數是

用來控制被拖對象的移動範圍。

２、停止拖拽指令講解

指令格式： 被拖動的影片剪輯執行個體名.stopDrag()

這樣就可以停止對對象的拖拽動作。

二、執行個體講解

下面來用一個簡單的例子實驗拖拽指令。

操作步驟：

１、建立一個 flash 文檔，并在舞台上繪制一個圓形。選中圓形并按Ｆ８，

将此圓形轉換為影片剪輯，起名為：圓 。确定後将會在舞台上建立一個圓的實

例。

２、選中此執行個體，并按Ｆ９打開動作面闆。輸入如下腳本：

on (press) {

this.startDrag(true);//當滑鼠按下（press）之後，這個執行個體（因為我們把腳本寫

在執行個體本身了，是以這裡用 this 代替影片剪輯執行個體的名字）可以被拖拽，使用

指令如上面的指令解釋。對于參數的選擇方面，這裡隻填寫了鎖定到滑鼠位置

中央，如果想選不鎖定到滑鼠位置中央，可以把true改為 false。有興趣的朋友

可以更改為 false看看。

}

on (release) {

this.stopDrag();//同樣道理，當滑鼠釋放（release）之後，将停止拖拽動作。

}

３、好了，現在讓我們按 Ctrl+回車來測試一下吧，你将會看到舞台上的圓

被你的滑鼠拖動的效果。

４、ＯＫ，通過這個例子我們可以簡單的應用拖拽動作了。現在需要把這個

例子繼續完成，還記得上面指令講解中的左，上，右，下四個控制拖動範圍的參

數嗎？現在來制作具有限制拖動範圍的效果。

５、現在在舞台上繪制一個２００*１００大小的矩形，注意隻要邊框不要填

充。

６、如果我們希望在拖動的時候這個圓隻能在矩形内拖動的話，就要先設定

這個矩形的坐标，并記下矩形四個頂點的坐标（這點很重要！）。ＯＫ，比如，現

在此例子中的矩形的四個頂點分别如上圖所示。那我們要取的四個參數就應該

是：左＝５０，上＝１００，右＝２５０，下＝２００ 現在打開動作面闆，修

改剛才的腳本如下：

on (press) {

this.startDrag(true, 50, 100, 250, 200);//這裡我們就使用剛才确定好的４個參數。

４個點的參數就對拖動對象實作了一個矩形區域的移動限制！

}

on (release) {

this.stopDrag();

}

７、好了，按Ctrl+回車去測試吧！

好了，關于拖拽的講解先到這裡，下面我們來學習如何結合着拖拽動作來檢

測對象之間的碰撞！

三、碰撞指令的講解

指令格式： 目标影片剪輯的執行個體.hihkest(被拖拽的執行個體) 這個是比較

簡單的檢測碰撞指令

目标影片剪輯的執行個體.hihkest(被拖拽執行個體的Ｘ軸坐标，被拖

拽執行個體的Ｙ軸坐标，對象的矩形區域範圍還是對象本身範圍) 這個是比較複

雜點的檢測碰撞指令

指令解釋： 以上兩個指令都是用來檢測碰撞的，可以根據需要選擇不同的

指令。重點解釋一下對象的矩形區域範圍和對象本身範圍（上面的指令中，false

表示對象的矩形區域範圍，true表示對象本身的範圍）

四、碰撞指令與拖拽指令的結合使用

（一）、下面通過簡單的例子來學習碰撞指令（我們先來學習如何檢測是否

碰到對象的矩形區域範圍）

１、建立一個 flash 文檔，在舞台上繪制一個圓形。選中圓形并按Ｆ８将它

轉換為影片剪輯，起名：圓 。這樣就在舞台上建立了一個圓的執行個體。

２、選中此執行個體，為它起一個名字，此例起名為：yuan

３、選擇文字工具，并選擇文字類型為“動态文本”，在圓的執行個體下面拖繪出一個

動态文本框。并起一個變量名為：hk

４、選中時間軸的第一桢，按Ｆ９打開動作面闆，輸入以下腳本：

_root.onEnterFrame = function() {

//這個是在時間軸上的ＡＳ編寫規則，解釋為舞台上每桢都執行下面的腳本

（onEnterFrame）。

if (_root.yuan.hitTest(_root._xmouse, _root._ymouse, false)) {

//根據上面指令的講解，這個語句就是檢測碰撞了。如果滑鼠碰到舞台上

yuan這個執行個體的矩形區域範圍的話，就執行下面的腳本。

hk = "接觸矩形區域範圍";

//動态文本框就顯示出“接觸矩形區域範圍”

} else {

hk = "沒有接觸到矩形區域範圍";

//如果滑鼠沒有碰到舞台上 yuan 這個執行個體的矩形區域範圍的話，就顯示

沒有接觸到矩形區域範圍。

}

};

現在可以按Ctrl+回車去測試我們的成果

（二）、拖拽碰撞檢測

現在再來一個例子講解拖拽碰撞檢測， 想偷懶的話可以通過修改上面例子的

代碼來學習。

１、現在稍微修改一下上面的例子，以便讓我們學習拖拽碰撞檢測，在上面

例子的舞台上繪制一個矩形，并把這個矩形轉換成電影剪輯，起名為：矩形 。

這樣就在舞台上又建立了一個矩形的執行個體，現在為這個矩形執行個體起一個名為：

juxing 。

２、選中這個矩形執行個體，打開動作面闆，輸入可以拖拽這個執行個體的腳本。如下：

on (press) {

this.startDrag(true);

}

on (release) {

this.stopDrag();

}

這個腳本就是為了能拖動這個矩形執行個體。 具體解釋請回顧第一個拖動對象例

子的腳本說明。

３、現在來修改腳本，選中時間軸的第一桢，按Ｆ９打開動作面闆，你将會

看到上個例子的碰撞檢測腳本，把它修改為如下腳本：

_root.onEnterFrame = function() {

if (_root.yuan.hitTest(_root.juxing)) {

hk = "碰到了";

} else {

hk = "沒有碰到";

}

}

這個腳本和上次的碰撞檢測腳本類似，隻不過不需要再書寫Ｘ軸和Ｙ軸，也

不用寫是否碰到矩形區域範圍。簡單吧

現在又到了測試階段了，去觀看你的成果

六、流程控制與循環語句

衆所周知，flash中動畫依靠的是時間軸，在沒有腳本的情況下，動畫會依照時

間軸從第一幀不停的播放到最後一幀，然後始重複播放或者幹脆停止。為了能更

好的控制動畫，就必須使用腳本語句。而要想使動畫具有邏輯判斷的功能，就要

使用流程控制和循環控制語句了！ 下面通過幾個簡單的小例子來學習流程與循環

控制語句。

一、流程控制語句

所謂流程控制，無非就是我們想控制動畫程式的執行順序而已。我們可以讓

flash根據一些特定的條件，來決定要執行哪個程式。這樣就好象給了程式一些

判斷的機制。

if...else控制語句

根據英文的意思，大家可以簡單的了解上面的控制語句：如果...就...否

則...就... 下面來看看這個流程控制語句的書寫格式。

if(條件){

//條件成立的話，就執行這裡的程式。

}else{

//條件不成立的話就執行這裡的程式。

}

下面重點說一下 if 後面括号内的條件。這個條件可以是一個固定的值，也

可以是一個變量或表達式。如果條件成立的話，也就是條件為真（true），就會

執行 if 後面的程式，如果條件不成立，也就是條件為假（false），就會執行

else裡的程式。例如：有這麼一個條件，A>B 将這個表達式代入if後面的括号

内， 這個流程語句的意思就變成： 如果A>B的話， 就執行第一個大括号内的程式，

如果Ａ不大于Ｂ，就将執行else後面大括号内的程式。

執行個體講解：

１、建立一個flash文檔，在舞台上繪制一個圓，選中圓并按Ｆ８轉換成影

片剪輯，起名為：圓 這樣就在舞台上建立一個圓的執行個體。

２、選中舞台上的執行個體，按Ｆ９打開動作面闆，輸入如下腳本：

onClipEvent (enterFrame) {

if (this._x<400) {//流程條件控制語句，如果這個圓的執行個體的Ｘ軸坐标小于４００，就執行後

面的程式。

this._x += 5;//讓這個圓的坐标向右移動５個象素

} else {

this._x = 0;//控制語句，如果剛才的條件不成立。也就是圓執行個體的Ｘ坐标不小于４００，就

讓它的Ｘ坐标為０

}

}

上面的腳本是一個非常簡單的流程控制語句，根據執行個體的坐标來進行判斷。因為我們

使用了 enterFrame事件，是以 flash會不停的執行下面 if...else語句。

３、測試影片。會看到圓不停的向右移動，當它的Ｘ坐标大于或等于４００的時候，程

序會把它的Ｘ坐标重新更改為０。

二、循環控制語句

所謂的循環語句，其實也是用條件來控制的，隻要條件成立，那麼，程式就會不停的執

行下去，一直執行到條件不成立為止！ 常用的循環語句包括 while 循環、for 循環等。因

為篇幅有限，下面隻重點講解 for 循環的使用方法。

For 循環指令格式：

for(初始變量；條件語句；疊加指令語句){

//使用者自己編寫的腳本。

}

首先強調一點，for 語句的括号内有三個項目，必須要用分号間隔開！

初始變量：循環語句也是用條件是否成立來控制的，通常我們用一個變量來控制程式執

行的次數。那麼，這個初始變量就要先定義一個值。要注意的是，初始變量這個項目隻執行

一次！

條件語句：這個項目就是我們的判斷語句了。如果這個項目判斷為真（true），也就是

條件成立了。它就直接跳進大括号｛｝内執行裡面的程式！反之，如果條件為假（false），

它就直接跳出這個 for 語句了。

疊加指令語句：接上面的條件語句，如果條件語句成立，會執行｛｝内的程式，那麼執

行完程式之後，就要回來執行疊加指令語句了。通常它就用來增加或減少剛開始時的初始變

量的值。

執行個體講解：

１、建立一個 flash 文檔，在舞台上繪制一個圓，選中圓并按Ｆ８轉換成影片剪輯，起

名為：圓 這樣就在舞台上建立一個圓的執行個體。

２、為這個執行個體起名為：yuan

３、添加一個新的層，并選中新層的第一幀，按Ｆ９打開動作面闆，輸入如下腳本：

for (i=1; i<5; i++) {

duplicateMovieClip("yuan", "yuan"+i, i);

_root["yuan"+i]._x = random(400);

_root["yuan"+i]._y = random(300);

_root["yuan"+i]._alpha = random(100);

}

如果大家實在覺得 for 語言很難讀懂的話，你可以按照 for 語言執行的順序把 i=1 代入程式

走一遍，可以幫助你了解程式。例如：當 i 等于１的時候，程式開始判斷它是否小于５，那

麼１肯定小于５了，條件為真，就執行｛｝内的複制程式，同時複制出來的新執行個體的名字就

變成了 yuan1 ，接着就是設定 yuan1 的坐标和透明度。之後，for 語句開始回去執行 i++，

此時，i 的值就變為２了。然後又開始循環判斷執行下去......（你可以算一下，這個 for 循環

總共循環了幾次呢？答案是４次。）

４、選中時間軸的第６幀，按Ｆ６插入一關鍵幀，打開動作面闆輸入以下腳本：

gotoAndPlay(1);

讓 flash播放到第６幀的時候傳回第１幀再來執行 for 循環語句。

５、測試效果吧，你會看到舞台上會循環４次複制出４個圓。

希望大家能通過這兩個簡單的例子掌握流程控制語句和循環控制語句

七、繪圖及顔色的AS的編寫

在使用 flash 的過程中，難免會進行繪圖的操作。除了用工具面闆上的工具繪制圖形之外，

我們也可以使用 ActionScript 來繪制圖形。

如何繪制線段及指令解釋

lineStyle(粗細，顔色，透明度) //設定繪制圖形的線條粗細、顔色和透明度

Moveto(Ｘ坐标，Ｙ坐标) //設定繪圖線條的起點坐标

lineto(Ｘ坐标，Ｙ坐标) //設定線條的結束坐标

現在就用剛才的三個指令在舞台上繪制出來一個３００*１００大小的矩形。

步驟：

１、建立立一個 flash文檔。

２、既然要繪制一個３００*１００大小的矩形， 我們就要先确定矩形４個頂點的坐标，

然後就可以使用 lineto指令進行編寫了。

３、選中時間軸的第一桢，打開動作面闆。現在已經确定了矩形的４個頂點，那麼我

們就可以來編寫腳本指令了，請輸入以下腳本：

_root.lineStyle(1, 0x000000, 100);//設定線條的粗細，顔色和透明度

_root.moveTo(50, 50);//設定開始點的坐标。

_root.lineTo(350, 50);

_root.lineTo(350, 150);

_root.lineTo(50, 150);

_root.lineTo(50, 50); //設定結束點坐标，整個矩形繪制完畢

相信大家通過上面的指令就很容易的用ＡＳ繪制出所需要的形狀，充分發揮你的想象

力，可以通過 lineto指令來設定多個點，進而創造出各種各樣的形狀。

熟悉了繪制線條的指令之後我們來用一個例子加深印象。

操作步驟：

１、建立立一個 flash 文檔，在舞台上繪制一個圓，選中它并按Ｆ８轉換成影片剪輯，

起名為：圓 。

２、打開庫面闆，請将影片剪輯“圓”在舞台上再拖放一個執行個體，使舞台上存在兩個圓的

執行個體。

３、現在為舞台上兩個執行個體分别起名字為 a和 b

４、選中時間軸第一桢，打開動作面闆，輸入以下腳本：

function draw() { //自己定義一個函數，這個函數起名為 draw（可自定），函數的功能是要實

現以 a 執行個體的坐标為起點，向 b 執行個體繪制線條。

_root.hkear();//清除舞台上繪制的線條。

_root.lineStyle(1, 0x000000, 90);//設定線條的粗細，顔色和透明度。

_root.moveTo(a._x, a._y);//以 a執行個體的坐标為起點開始繪制線條。

_root.lineTo(b._x, b._y);//以 b 執行個體的坐标為繪制線條的結束點。

}

draw();//執行函數 draw，它将會在a 與 b 之間繪制出一條黑色的線條。

解釋：為了減輕編寫ＡＳ的工作量和程式的重複率，可以将某些功能定義為一個函數，

例如上面的 draw()，在使用的時候，直接執行定義過的函數，就可以完成函數的功能。

５、現在建立拖動效果，選中舞台上的 b 執行個體，打開動作面闆，輸入以下腳本：

on (press) {

//點選此執行個體，開始拖動

this.startDrag(true);

}

on (release) {

//釋放滑鼠，停止拖動

this.stopDrag();

}

onClipEvent (mouseMove) { //當滑鼠移動，也就是這個 b 執行個體移動的時候，就執行裡面的程

序。

_root.draw();//執行舞台上定義過的 draw()函數，開始在 a 與 b之間繪制線條。

updateAfterEvent();//強制更新畫面，是整個動畫更加流暢。

}

按 Ctrl+回車測試動畫效果。

二、顔色指令講解

setRGB() 用來設定執行個體的顔色值，注意，這個值用１６進制表示，例如 0x000000

（黑色）

getRBG() 擷取執行個體的顔色值

下面用一個相對簡單的例子來說明顔色指令的使用以及如何填充顔色

要想使用顔色指令，我們必須先建構一個 Color 對象。方法就是 自定義名字 = new

Color("要改變顔色的對象")，建構完 color 對象之後，我們就能使用 setRGB 或 getRGB 來設

置或擷取顔色了。

步驟：

１、建立立一 flash文檔，背景大小為５５０*４００

２、選中時間軸第一桢，打開動作面闆，我們現在要用ＡＳ來幫助我們建立一個影片剪

輯的執行個體。所用到的指令為：

createEmptyMovieClip("執行個體名稱",深度)。建立一個影片剪輯執行個體，并起名為 hk。輸入下面

腳本。

_root.createEmptyMovieClip("hk", 1);

//使用建立指令在舞台上建立一個名字叫 hk的影片剪輯執行個體，深度為 1

接下來我們要對這個 hk 執行個體進行繪制圖形和填充圖形！現在我們用ＡＳ繪制一個３０

０*１００大小的矩形，并且把這個矩形填充為黑色，腳本如下：

with (hk) {

//使用 with指令設定 hk的各個屬性

beginFill(0x000000, 85);

//開始填充這個 hk執行個體，顔色為黑色，透明度為 85

lineStyle(1, 0x999999, 100);

//設定這個執行個體的邊框粗細為 1,顔色為灰色，透明度為 100

moveTo(50, 50);

//設定繪制線條的起點坐标

lineTo(350, 50);

lineTo(350, 150);

lineTo(50, 150);

lineTo(50, 50);

//結束繪制，将在舞台上繪制出一個 300*100 大小的矩形。

endFill();

//結束填充，與 beginFill()指令對應。

}

OK，現在我們就已經建立了一個黑色的矩形。現在我們要繼續實作變色的功能，也就

是當滑鼠移動的時候，這個矩形會随機變換顔色！就需要用到我們的建構 Color 對象的指令

了。腳本如下：

_root.onMouseMove = function() {//當滑鼠移動的時候就執行下面的腳本指令。

hk_color = new Color("hk");//建構一個名字叫 hk_color 的 Color 對象。

yanse = "0x"+random(100)+random(100)+random(100);//用一個變量 yanse來擷取一個數值，

這個數值就是顔色值

hk_color.setRGB(yanse);//設定矩形的顔色。

};

好了，這個例子是完全由腳本編寫而成，所有腳本都在時間軸的第一桢

３、按 Ctrl+回車來測試你的影片吧～會看到矩形會随着滑鼠的移動而不斷進行顔色變化。

八、聲音 AS 的編寫與控制

一個好的 flash作品，缺少了聲音，就如同人不會講話一樣。而 flash

中對聲音的支援也非常不錯，除了可以使用時間軸放置聲音檔案之

外，我們還可以使用ＡＳ來更加準确的控制聲音！

一、FLASH 中如何建立聲音控件

如果想控制動畫中的聲音，我們可以使用 flash中的 sound 對象，

通過 sound 指令建立一個新的 sound 對象。之後再用 attachSound 命

令連接配接到庫裡的聲音，就可以用來控制動畫中的聲音了。

常用指令講解：

new Sound() 此指令用來建立一個新的 sound 對象，有了

sound 對象我們才能用ＡＳ來控制聲音。

attachSound("庫中的聲音") 此指令可以使我們建立的聲

音對象連接配接到庫裡的聲音，以便進行控制。

start([從第幾秒開始播放, 循環次數]) 此指令可以是

聲音開始播放，裡面的兩個參數是可選的。

stop() 停止聲音的播放。

setVolume(音量級别) 此指令可以控制聲音的音量高低，

音量級别隻能是從０－１００之間的數字。

現在我們也應該用ＡＳ先做一個簡單的小例子了。

二、建立一個簡單的聲音播放動畫，可以實作簡單的開始與停止

播放聲音。

操作步驟：

１、建立一個 flash文檔，按 Ctrl+R（檔案\導入）導入一個聲音

檔案，聲音檔案可以是 MP3 或 WAV 格式的。聲音檔案導入之後，在

舞台上是看不見的，必須打開庫才能看到我們導入的聲音。

２、 選中庫中的聲音檔案， 單擊滑鼠右鍵， 在彈出的菜單中選擇“鍊

接...”将會彈出一個連結的對話框，請勾選“為動作腳本導出”和“在第

一幀導出”選項，并輸入一個辨別符：mysound （名字可任意寫），

單擊确定。

３、回到主舞台，選中時間軸的第一桢，按Ｆ９打開動作面闆。現

在我們要建立一個新的聲音對象，并且連接配接到庫裡的聲音。用來控制

聲音。輸入以下腳本：

music = new Sound();//建立一個名字叫 music 的聲音對象。

music.attachSound("mysound");//将這個聲音對象與庫裡的辨別符為

“mysound”的聲音連接配接。

４、現在需要在舞台上放置兩個按鈕分别控制聲音的播放與停止。

５、此時，舞台上将有播放和停止兩個按鈕，選中 Play按鈕，打開

動作面闆，輸入以下腳本：

on (release) {

music.start();

}//播放聲音

選中 Stop 按鈕，輸入以下腳本：

on (release) {

music.stop();

}//停止播放聲音

６、ＯＫ，一個簡單的控制聲音播放與停止的例子就完成了，快

按 Ctrl+回車來測試吧。

三、建立一個稍微複雜的例子，用來滑動按鈕來控制聲音的音量。

操作步驟：

１、建立一個 flash文檔，并按 Ctrl+R 導入一個聲音檔案。

２、參照上個例子，打開庫，并把導入的聲音檔案設定一個鍊界

辨別符。這裡設定辨別符為“mysound”。

３、選中舞台時間軸第一桢，打開動作面闆，建立一個新的聲音

對象，連接配接庫中聲音，并播放這個聲音。輸入腳本如下：

music = new Sound();

music.attachSound("mysound");

music.start(1, 10);//播放聲音，從第一秒開始播放，并循環１０次

４、現在需要一個按鈕做為滑動按鈕，用來控制聲音的音量！按

鈕可以自己制作或使用公用庫中的按鈕， 此例中我使用公用庫中的按

鈕。請在舞台适當位置放置一個按鈕執行個體。

５、選中按鈕，打開動作面闆輸入以下腳本：

on (press) {

this.startDrag(false, left, top, right, bottom);//開始拖動這個按鈕， 并且要

規定它的拖動範圍，分别由四個變量控制，４個變量的初始值稍後設

置。

drag = true;//用一個變量來判斷這個按鈕是否被拖動了。如果它被拖

動了，變量值為 true（真）

}

on (release, releaseOutside) {

this.stopDrag();//當松開按鈕或在按鈕外部松開，就停止拖動。并且下

面的 drag 變量為假，表示按鈕沒有被拖動。

drag = false;

}

６、再次選中這個按鈕，并按Ｆ８鍵将它轉換成一個影片剪輯！起

名為：控制音量。也就是“控制音量”這個影片剪輯裡面包含了剛才的

按鈕。

７、選中舞台上這個控制音量影片剪輯的執行個體，打開動作面闆，

現在要設定拖動範圍的４個初始值和設定音量大小控制。 請輸入以下

腳本：

onClipEvent (load) {//當這個 flash 動畫一開始，就設定下面４個變量

的初始值。為了使按鈕隻能上下拖動，是以，拖動範圍的左、右都固

定！隻能讓按鈕在上下１００象素以内拖動。

top = _y;

left = _x;

right = _x;

bottom = _y+100;

}

onClipEvent (enterFrame) {

if (drag == true) {//如果按鈕被拖動了，就開始執行下面的設定音量的

算法，用來控制音量。

_root.music.setVolume(100-(_y-top));//設定音量大小，比較難了解的是

裡面的算法：100-(_y-top)，通過代入數字來幫助我們了解，如果_y

的值是１００，我們的 top 值也是固定的為１００。當拖動按鈕往下

時，_y值就會變大，比如變為１３０，那麼_y-top 就等于３０了，在

用 100-30 就等于７０，這個７０就是音量的級别了。伴随着按鈕越

往下拖，音量級就會變的越小，那麼也就實作音量的控制了。

}

}

通過以上兩個例子，應該要掌握的就是建立 sound 對象播放、停止

聲音，以及控制聲音的方法。

九、時間日期的 AS編寫

一、日期時間的基本指令及解釋

getFullYear() 按照本地時間傳回 4 位數字的年份數。

getMonth() 按照本地時間傳回月份數。

getDate() 按照本地時間傳回某天是當月的第幾天。

getHours() 按照本地時間傳回小時值。

getMinutes() 按照本地時間傳回分鐘值。

getSeconds() 按照本地時間傳回秒數。

以上指令并不是很難了解，都是擷取本地機器上日期及時間。但是要使用這些指令，我

們必須先用 Date 對象的構造函數建立一個 Date 對象的執行個體。然後，就可以用建立的這個

執行個體來進行操作！指令格式如下：

執行個體名＝new Date()

二、顯示日期及做一個走動的表

下面我們通過一個例子來介紹 Date對象的各種指令使用方法。

步驟：

１、建立立一 flash 文檔，将層１改名為：文字顯示，并在舞台下方繪制出一個動态文

本框，起一個變量名：mytime

２、建立立一個層，并把這個建立立的層起名為：表盤，然後使用繪圖工具在舞台上繪制出

一個不帶分針、時針和秒針的表盤。

３、現在來繪制指針。按 Ctrl+F8 建立立一個影片剪輯，起名為：指針 ，選擇繪圖工具，

在裡面垂直繪制出一條細線做為指針。注意：将線條的下方與影片剪輯的中心點對齊

４、傳回主舞台，建立一個層，改名為：指針—秒 将剛才制作的指針拖放在表盤的中

間，注意要把指針的中心點與表盤的中心點對齊。之後，為這個指針執行個體起一個名字為：sec

我們先做秒針。

５、同理，再建立一個層，并起名字為：指針—分 将庫裡的“指針”元件再拖放出來，并改

變這個執行個體的長度和顔色，讓它做為分針。執行個體名起為：min

６、現在按照上面的方法來制作時針，建立一個層，改名為：指針-時 将指針元件拖放

在舞台中，與表盤中心對齊，并把這個執行個體起名為：hour

７、呵呵，現在咱們開始編寫程式了，為了觀察友善，我們再建立一個層，改名為ＡＳ，選

中ＡＳ層的第一桢，打開動作面闆，開始編寫腳本，首先，我們要讓舞台上的動态文本框顯

示日期及時間。

_root.onEnterFrame = function() {//需要讓影片不停執行下面腳本。

mydate = new Date();//首先建構一個名字叫 mydate的日期對象， 因為以後我們就要用 mydate

這個執行個體來控制了。

myear = mydate.getFullYear();//擷取本地機器上的年份，并放在 myear 變量中。

mmon = mydate.getMonth()+1;//擷取本地機器上的月份，并放在 mmon變量中。因為擷取的

值是 0 代表一月，1 代表二月，依此類推，是以要加上 1 才正确

mdate = mydate.getDate();//擷取本地機器上的本月的第幾天，并放在 mdate變量中。

mou = mydate.getHours();//擷取本地機器上的小時數值，放在 mou變量中，這個指令能擷取

0--23之間的數值。

mm = mydate.getMinutes();//擷取本地機器上的分鐘數值，并放在 mm變量中。

ms = mydate.getSeconds();//擷取本地機器上的秒數值，放在 ms 變量中。

mytime = myear+"年"+mmon+"月"+mdate+"日 "+mou+":"+mm+":"+ms; //讓舞台上變量名為

mytime的動态文本框顯示日期及時間。

}

現在可以測試一下了，可以發現舞台上文本框會顯示出日期及時間，那麼還有表裡面的秒、

分、時針怎麼跟時間對應起來呢？現在我們加入如下一些腳本

sec._rotation = 6*ms;//利用flash中對象旋轉指令來實作指針的走動。 _rotation旋轉一周是360

度，是以，秒針每走一下，就等于走了6 度，是以用一個算法來擷取每秒的度數 6*ms

min._rotation = 6*mm;//同理，讓分針也是根據擷取的分鐘數值乘以 6 來進行度的旋轉。

hour._rotation = mou*30+mm/60*30;//小時的走動，算法稍微複雜一點，因為時針走一圈是 12

個大格。具體上面的算法有興趣的朋友可以自己研究一下。

日期及時間的 AS 編寫并不複雜，這裡我隻簡單的講解了擷取日期及時間。，當然了，我們

還可以進行日期及時間的修改設定，使用的指令及方法與擷取類似，希望大家能通過這個簡

單的例子掌握基本的日期及時間 AS 的編寫。在後面的課程中我們就要提高性的講解，同時

也希望大家繼續關注。

十、點文法以及路徑

點（.）文法、 路徑

通過本節的學習要掌握（.）；能正确地輸入影片剪輯的執行個體名稱；了解相對路徑和絕對路徑

的概念，了解分層結構中的包含關系和并列關系，

點（.）文法

動作腳本中，點（.）通常用于指定對象或影片剪輯相關聯的屬性或方法，或者辨別影片剪

輯、變量、數對象的目标路徑。點文法表達式是以對象或影片剪輯的名稱開始，後跟一個點，

最後以要指定的元素 結束。

例如：（1）張三的身高。這句話用 AS 語言表示為：張三.身高

（2）安徽合肥中澳學院。這句話用 AS 語言表示為：安徽.合肥.中澳學院

元件命名

在上面的例子中， “張三”是人名， “身高”是他的屬性，那麼，在 FLASH 中怎麼樣

用 AS 語言來表示一個影片剪輯的高度呢？

類似地我們要給影片剪輯取一個名稱，如果在主場景中有放入一個影片剪輯，那麼這個影片

剪輯相 對于場景是場景的一個執行個體，在場景中選中影片剪輯就可以在屬性面闆中鍵入執行個體

名。

好了，小球有了執行個體名稱了，我們現在來表示它的高度(_height)。

注意: 在命名執行個體名時，最好意義明确，可以用英文、漢語拼音和中文，并且不同類型的元

件加不同的前字尾,在實際程式設計中我們往往不太注意這些，規範的命名不僅容易閱讀，還能

為其增加一些特定的字尾觸發代碼提示。

命名影片剪輯執行個體;加 _mc 字尾，例如 my_mc。

命名按鈕時，應使用 _btn 字尾。例如 my_btn.。

命名文本時，應使用 _txt 字尾。例如 my_txt。

例如上例中小球的執行個體名如果加上字尾_mc就會出現影片剪輯屬性的代碼提示

安徽.合肥.中澳學院

小球._height

張三.身高

路徑

“路徑”指“道路”,“路線”其含義是：如何到達目的地，這個目的地叫做路徑的目标，

在 flash 中 引用了目标路徑的概念，目标路徑：是 SWF 檔案中影片剪輯執行個體名稱,變量和

對象的分層結構位址。

? 目标：指的是将要被動作腳本控制的對象,有影片剪輯執行個體，變量等。

? 路徑：指如何到達目标，即我們如何從控制點到達被控制點。

? 分層結構：flash檔案是有一個個影片或影片剪輯組成的，它們有各自的時間軸、變量、

數組等，它們 的位置關系有兩種，一是父子關系；二是并列關系。

所謂父子關系指的是包含與被包含的關系，例如： 把影片剪輯 mc1 拖放到影片剪輯 mc

中，則稱 mc1 是 mc 的子級，反過來 mc 稱作 mc1 的父級。它們的層次結構用點文法表

示，圓點前面的對象包含着圓點 後面的對象，如_root.mc.mc1 即_root 包含了 mc，而 mc

包含了 mc1。

所謂并列關系指的是對等的關系，它們之間沒有包含與被包含的關系，如：_root.mc_a 和

_root.mc_b。

在 flash 應用中，可以從 1 個時間軸向另一個時間軸發送資訊，發送資訊的時間軸叫控制

時間軸，接 收資訊的時間軸叫目标時間軸。也就是說控制時間軸發出的指令可以控制目标

時間軸的動作。要實作這種 控制功能必須編寫目标路徑。目标路徑分為絕對路徑和相對路

徑。

絕對路徑

絕對目标路徑指的是從根時間軸開始，一直延續到清單中目标時間軸中的執行個體為止。 絕對目

标路徑簡單易懂但重用性差。

在編寫絕對目标路徑時，首先寫上_root，一方面表示這個路徑是一個絕對路徑，另一方面

表示這個路徑的最頂層時間軸是本場景中的根時間軸_root。

相對路徑

相對目标路徑取決于控制時間軸和目标時間軸之間的關系， 相對目标路徑就是站在控制點去

看被控制 點。 若向父級方向看也就是向根時間軸方向看， 在相對路徑中， 使用關鍵字 this 指

示目前時間軸：使用别 名_parent 訓示目前時間軸的父級時間軸，可以重複使用_parent，每

使用一次就會在同一層的影片剪輯的層 次中上升一級，有多少元件就寫多少_parent，若向

下看隻需要用點運算符，中間有多少元件就寫多少執行個體名。

例如：

this._parent

this._parent._parent

this.mc.mc1

編寫目标路徑的方法

在 Flash8 中可以用多種方法編與目标路徑，直接手工輸路徑，或者使用“插入目标路徑”

對話框。我 們隻需要為影片剪輯和變量等正确的輸入名稱，使用動作腳本面闆的“插入目

标路徑”按鈕，找到你要控 制的對象即可。

其具體步驟如下：

（1）選擇想為其配置設定動作的影片剪輯，幀或按鈕執行個體，它将變為控制時間軸。

（2）在“動作”工具箱（面闆左側）中選擇需要目标路徑的動作或方法。

（3）單擊動作腳本中想插入目标路徑的參數框或位置。

（4）單擊動作腳本編輯窗格上面的“插入目标路徑”按鈕，打開“插入目标路徑”對話框。

（5）選擇“絕對”或“相關”目标路徑模式。

（6）在“插入目标路徑”顯示清單中選擇一個影片剪輯，單擊“确定” 。

觀察目标路徑

由上圖在以看出影片剪輯之間的分層結構：mc 中包含了兩個子級 mcA、mcB；而 mcA 中

又包含了三 個子級 mc1、mc2、mc3。

按 F9 打開動作面闆，點選“插入目标路徑”按鈕後，在彈出的“插入目标路徑”對話框

中我們可以 清楚地看到分層結構。

當我們選中一個目标後，再選擇“相對”或“絕對”按鈕後，在“插入目标路徑”對話框的

最上面一 欄裡就會顯示出路徑，例如：控制點為 mcA，控制目标為 mc1，路徑為：

相對路徑：this.mc1 絕對路徑：_root.mc.mcA.mc1

十一、深入了解時間控制

通過本課的學習，掌握在按鈕上添加代碼的方法；了解 on 指令的函數功能；

掌握時 間軸控制指令的功能，文法格式，掌握在幀上添加指令基本操作，能使

用幀指令和按鈕命 令控制一些簡單的時間軸動畫。

on 事件處理函數

事件是指軟體或硬體發生的事情，它需 Macromedia Flash 的應用程式對事件有

一定的 響應。硬體發生的事件如按下滑鼠、單擊滑鼠、拖動滑鼠等。軟體發生

的事件如影片剪輯 剛剛被載入場景、影片剪輯被解除安裝等。為了使應用程式對事

件做出反應，必須使用事件處 理函數。

下面我們就來學習 on 事件外理函數。 輕按兩下代碼選擇區中的“全屬函數”|“影

片剪輯控制” |“on”指令後，彈出選項

On 事件動作使用較多，它一般直接作用于按鈕，也可以作用于影片剪輯執行個體。

其調用格式如下： 了解 on 事件中的參數意義

在建立一個動态文本,在屬性面闆裡輸入變量名:txt.再建立一個按鈕執行個體,選中按

鈕,

打開動作腳本面闆輸入代碼:

on (press) {

txt = "發生了滑鼠按下(press)事件";

}

on (release) {

txt = "發生了滑鼠釋放(release)事件";

}

on (releaseOutside) {

txt = "發生了滑鼠外部釋放"+newline+"(releaseOutside)事件";

}

on (rollOver) {

txt = "發生了滑鼠滑過(rollOver)事件";

}

on (rollOut) {

txt = "發生了滑鼠滑離(rollOutr)事件";

}

on (dragOver) {

txt = "發生了滑鼠拖過(dragOver)事件";

}

on (dragOut) {

txt = "發生了滑鼠拖離(dragOut)事件";

}

on (keyPress "<Left>") {

txt = "發生了按左鍵事件"+newline+"(keyPress\"<Left>\")事件";

時間軸控制指令

時間軸控制語句是較基礎的 ActionScript 控制 語句。時間軸控制語句是掌握

ActionScript 語句的基 礎， 它們的主要任務是控制幀的停止、 播放、 跳轉等。隻

要帶有時間軸的動畫效果，就可以用時間軸控制 語句來進行控制。時間軸一共

有兩種，一種是場景中的 時間軸， 我們叫做主時間軸。 另一種是元件中的時

間軸， 例如影片剪輯、圖形元件中的時間軸。是以，時間軸控 制語句也可以分

成兩類，一類是控制主時間軸，一類控制影片剪輯時間軸。打開動作腳本箱，點

擊“全局函數”“時間軸控制”我們會看到時間軸控 9 條時間軸控制命 令。在

這一課中我們将分别介紹它們的功能及使用方法。

play( ) 與 stop ()

play 和 stop 在 Flash 中用于控制動畫的播放和停止，play 指令使播放頭從它當

前位置 向前移動。stop 停止目前正在播放的 SWF 檔案。此動作最通常的用法

是用按鈕控制影片 剪輯。是 Flash中控制動畫最基本的指令。

使用方法如下：路徑.play()               路徑.stop()

幀指令

我們知道一個有動畫的影片剪輯，場景時間軸隻有一幀這個影片剪輯也能正常

播放， 但如果是圖形元件中做的動畫，在場景中必須有與元件時軸同樣的幀頻

數才能正常播放。

這就說明了影片剪輯有獨立的時間軸。而圖形元件的時間軸必須依賴父級時間

軸，是以， 場影中的影片剪輯執行個體，必須控制影片剪輯的時間軸。 要在場景

中控制影片剪輯的時間軸， 就要給影片剪輯輸入執行個體名稱。

下面我們做一個執行個體，通過該例，我們來掌握在幀上添加指令的方法，初步了解

控制目前時間、根時間軸控制元件時間。元件時間軸控元件時間軸的方法。

我們播放動畫時，可以看到每個動畫都是動的，現在我們來進行控制。

（1）打開素材， 分别選中場景中的小花， 和樹葉， 在屬性面闆裡輸入執行個體名

“花” “葉” 。

（2） 進入名稱為“葉引導線”的影片剪輯元件的編輯區中，點選“AS 層”的

第 1幀打開動作面闆。輸入指令：

stop();//停時目前時間軸

在第 50 幀插入空白關鍵幀，選中此幀，打開動作面闆，輸入指令：

this._parent.play();//父級時間軸(根時間軸) 播放

在主場景“AS 層”的第 1 幀，添加指令：

this.花.play()//當時間軸中的影片剪輯執行個體"花"播放

在主場景“AS 層”的第 170 幀添加指令：

stop();//停止目前時間軸

this.葉.play();//目前時間軸中的執行個體"葉"播放

測試影片看看效果。

總結：通過本課學習，要掌握自身時間軸的控制，子級時間軸的控制，父級時

間軸的控制， 對初學的朋友，最簡單的方法是：正解輸入執行個體名後，通過“插

入目标對話框，找到你的控制目标，這時軟體會自動給你編寫好路徑，你隻需在

路徑後面加上一個小點“.”然後加 上 stop()或 play()指令。 幀指令是播放頭來

觸發的，播放頭經過你的指令幀，這幀上的指令就被執行了。

按鈕的互動控制

我們利用此動畫練習在不同的控制點上來控制影片。現在我們任意選兩個控

制點，如果選擇 mcA 中放一個停按鈕，mc1 中放一個播放 按鈕，用這兩個按

鈕來控制所有影片剪輯。

停止按鈕上的代碼 ：

on (press) {

_root.mc.stop();

_root.mc.mcA.stop();

_root.mc.mcB.stop();

_root.mc.mcA.mc1.stop();

_root.mc.mcA.mc2.stop();

_root.mc.mcA.mc3.stop();

}

播放按鈕上的代碼：

on (press) {

_root.mc.play();

_root.mc.mcA.play();

_root.mc.mcB.play();

_root.mc.mcA.mc1.play();

_root.mc.mcA.mc2.play();

_root.mc.mcA.mc3.play();

}

說明：上例中使用的都是“絕對”路徑，如果你對路徑的概念掌較好，可以選

擇性的

使用“相對”路徑或“絕對”路徑。

本課涉及的文法及規範

? 圓括号 “ （）” ：圓括号在動作腳本中作用非常大，在定義函數時在将參

數全部放到圓 括号内；在調用函數時要将傳遞給函數的所有參數包含在小括号

裡； 在設定表達式優先級或增強動作語名的易讀性時都需要使用到圓括号。例如：

本課學的 on 函數用來定義滑鼠或鍵盤響應事件， 其中選擇的滑鼠事件就是參

數。有時也可以沒有參數例如：函數 play()。

? 分号 “;” ：動作腳本中的分号是用來作為語句結束的标記，在 Flash AS 腳

本中，任何 一條語句都是以“;”号結束的。雖然有時省略了“;”号，Flash 也

可以成功的編譯這個腳 本，但這是不規範的。

? 花括号“{ }” ，動作腳本中的一組語句可以被一對花括号“{……}”包

括起來，成為一 個語名組。在由多個動作狀态組成的語句組中，使用花括号可

以有效地來區分各指令的層級和從屬關系。

十二、無條件轉移

在上一課中我們學習了時間軸控制指令中的 play()和 stop()指令,這一課中我們

學習時間軸控制指令中的另外6個指令。通過本節的學習掌握跳轉指令的功能；

能進行一些簡單的互動控制。

正常情況下時間軸從第一幀開始按順序向下播放,使用跳轉指令可以打破原來

的播放順序,進而實作各種特效,跳轉指令有兩個它們是 gotoAndPlay 和

gotoAndStop,應用格式為：

scene:String [可選] — 一個字元串，指定播放頭要轉到其中的場景的名稱。

frame:Object — 表示播放頭轉到的幀編号的數字，或者表示播放頭轉到的幀标

簽的字元串。

gotoAndPlay|(“scene”, frame)的函數意義是：将播放頭轉到場景中指定的幀并

從該幀開始播放。如果未指定場景，則播放頭将轉到目前場景中的指定幀。

gotoAnd Play

在動作面闆的 “代碼選擇區” 中選擇 “全局函數” | “時間軸控制” | “gotoAndStop”

指令後，在此可以選擇此指令的參數。

該參數共有兩個提示，其含義如下所述。

“gotoAndPlay(幀);” ：按照該提示，可以在括号内輸入需要跳轉的幀數，例如，

當播放到目前幀的時候,跳轉到第 20 幀,則應當在目前幀上添加代碼

gotoAndPlay(20);。

“gotoAndPlay(“場景” ，幀)” ：按照該訓示可以在括号内指定播放某一場景

中的某一幀。将播放頭

轉到場景中指定的幀并停止播放。例如：當播放到目前幀的時候自動跳轉至

scene_2(場景2)的第 20 幀， 則在目前幀上添加代碼： gotoAndPlay("場景_2", 25);

如果未指定場景，播放頭将轉到目前場景中的幀。

注意:

? 在進行跳轉時應該盡力避開場景和幀編号,而使用幀标簽,幀标簽可以穿越所

有場景,可以減少 錯誤的發生,還可以使 flash 運作速度增快。還便于修改。

? 隻能在根時間軸上跳轉時使用 scene 參數，不能在影片剪輯或文檔中的其它

對象的時間軸内使用該參數。

gotoAndPlay([scene:String], frame:Object) : Void

gotoAndStop([scene:String], frame:Object) : Void

gotoAndPlay("場景"，幀);

gotoAndStop("場景"，幀)

2 ? 如果從元件時間軸跳轉元件時間軸時，應該先加路徑再寫跳轉指令。例如

從元件時間軸轉到根時間軸的标簽為“f”的幀上停止，代碼該這樣寫：

_root.gotoAndStop("f");

gotoAndStop

在動作面闆的代碼選擇區中選擇“全局函數”|“時間軸控制”|“gotoAndStop”

指令後,在代碼顯示區中的參數意義與 gotoAndPlay的一樣,這裡就不再重述。

例如：當播放到目前幀時要自動跳轉到“f2”幀處停止，則在目前幀上添加代碼：

gotoAndStop("f2");//跳轉到幀标簽為“f2”的該幀處停止。

又如：gotoAndStop("場景 2", 1);//播放頭從目前幀跳轉到“場景 2”的第1 幀，

并在該幀處停止。

場景面闆的操作

場景：執行“視窗”|“設計面闆”|“場景”菜單指令，就會調出“場景面闆” ，

在該面 闆中可以進行場景的添加、複制、删除、重命名、排序等操作。

為了友善組織文檔可以使用場景,例如， 可以使用單獨的場景用于簡介、 出現

的消息以及片頭片字幕。

當文檔含有多個場景時，播放時是按場景的先後順序依次進行播放的,而且所有

場景中的幀是按場景順序 連續編号的， 例如:如果文檔包含兩個場景， 場景 1 中

有 10 幀，場景 2 中有 20 幀，則場景 2 中的幀的編

号為 11 到 30。

nextFrame 和 nextScene

這兩個指令通常與 on 指令結合，并作用于按鈕上。單擊滑鼠後，播放下一幀

（nextFrame）或下一個場景（nextScene）。 prevFrame 和 prevScene

這兩下指令通常用來控制播放上一幀或上一個場景。其功能剛好與 nextFrame

和 nextScene相反

。

場景跳轉

制作播放面闆的操作步驟如下：

（1）點選“視窗”|“其它面闆”|“場景” ，打開的場景面闆，點選添加場景

按鈕，建立 3 個場景，這樣共是 4 個場景。在場景 4 的第 1 幀輸入幀标簽

“s4_f1” ，分别在場景 2~場景 4 中建立一個按鈕。

（3）進入“場景 1” ，在“圖層 1”的第 1 幀制作一個播放界面

(4)給按鈕添加代碼

按鈕 1 上的代碼：

on (release) {

gotoAndStop("場景 2", 1);

}

按鈕 2 上的代碼：

on (press) {

gotoAndStop(3);

}

按鈕 3 上的代碼：

on (press) {

gotoAndStop("s4_f1");

}

分别進入每個場景中，選種按鈕添加代碼：

on (press) {

gotoAndPlay("場景 1", 1);

}

在“場景 1”的第 1幀添加代碼。

stop();

測試影片觀看效果。

在“場景 1”中的三個按鈕，分别用了參數的三種形式來練習，建議在使用時

最好用幀标簽來跳轉。

制作簡易相冊

本例的目的是為了練習跳轉指令及上一課中學習過on指令。

效果說明：點選滾動按鈕可以看到對應的圖檔，點選左邊的按鈕可以進行前一張

後一張的切換，并在動

1．建立一個 flash文檔。設定文檔屬性為：寬 465、高 280，背景色白色。

2．導入素材，把本例的素材全部導入到庫。

3．建立一個名為“圖檔”的影片剪輯元件，在此元件“圖層 1”新插入 9 個空

白關鍵幀，分别在這 10 個關空白關鍵幀中依次分别放入庫中的“tp1”~“tp10”

這 10 張圖檔，并居中對齊。

4．建立一個名為“按鈕 1”的按鈕元件，在按鈕元件“圖層 1”的彈起幀中，

從庫時提進“tp1”位圖，在屬性面闆裡設定寬70、高 45，居中對齊。在“點選

幀”插入幀。插入“圖層 2”在“圖層 2”的彈起幀給制一個寬 70、高 45 的

無筆觸的矩形，填充色為淺灰色，并把透明度調為 30%，在“滑鼠經過” 幀插

入空白關鍵幀。 5．用同樣的方法制作另外 9 個按鈕，大家可以用複制元件，替換圖檔的方法來

制作。

6．建立一個名為“按鈕組”的影片剪輯元件，在其編輯區中，從庫裡提進“按

鈕 1”~“按鈕10” ，并用對齊面闆排列成一橫排，再把前 6 張複制後接在後

面。 7．（1）建立一個名為“滾動圖檔”的影片剪輯元件， 在“圖層 1”繪制一個寬

465、高 50 的無筆觸的矩形框，填充色為淡紫色，并把透明度設為 30%。居中

對齊。

（2）插入“圖層 2”在此圖層的第 1 幀上，從庫裡提進“按鈕組”影片剪輯元

件，并與下面的矩形條左對齊。 在第 100 幀插入關鍵幀， 并在些幀上把圖檔

按鈕組向左移動，（移動多少要參照第 1 幀上的位置，確定循環播放時沒有跳躍

的視覺感。）如下圖所示。然後建立動畫。

第 1 幀上的圖檔位置 第 100 幀上的圖檔位置 8． 建立一個名為 “蒙闆” 的影片剪輯元件， 在其編輯區裡繪制一個寬 287、 高208

的無邊框矩形，居中 對齊。填充色為四個色（這四個色自定）的狀填充并把每

個色的透明度設為 45%左右。在第 10 幀插入關 鍵幀，在此幀上把各色的透明

度調為 0%。建立形狀動畫。并在最後一幀輸入停止指令。

stop();

5 9．場景組裝

（1）把場景“圖層 1”更名為“背景” ，從庫裡提進“背景”圖形元件居中對

齊。

（2）插入“圖層 2”更名為“滾動菜單” 。從庫裡提進“滾動菜單”影片剪輯

元件，相對于場景，左 對齊、底對齊。并在屬性面闆裡輸入執行個體名“菜單” 。

（3）插入“圖層 3”更名為“圖檔” ，從庫時提進“圖檔”影片剪輯元件，放

在對應背的左上角的矩形框裡。并在屬性面闆裡輸入執行個體名“圖檔” 。

（4）插入“圖層 3”更名為“蒙闆” ，從庫時提進“蒙闆”影片剪輯元件，放

在“圖檔”上，并在屬性面闆裡輸入執行個體名“蒙闆” 。

（7）插入“圖層 7” ，更名為“AS”

場景組裝完畢

添加代碼

（1）選中 AS 層的第 1幀，打字開動作面闆，在動作面闆中輸入代碼：

_root.mc.stop();

onEnterFrame = function () {

_root.a.text = _root.mc._currentframe;

};

（2）進入“按鈕組”影片剪輯元件的編輯區，用選擇工具選中“按鈕 1” （最

左邊的一個），打開動作 面闆，在動作面闆中輸入代碼：

on (rollOver) {

_root.菜單.stop();

}

on (release, rollOut) {

_root.菜單.play();

}

on (press) {

_root.圖檔.gotoAndStop(1);

_root.蒙闆.play();

}

（3）把“按鈕 1”上的語句複制粘貼到其它按鈕上，然後把語名中的第 8 行

_root.mc.gotoAndStop(1);

改為“圖檔”元件中放圖檔的對應放圖檔的那一幀，例如按鈕 5 上的語句應改

為：

on (rollOver) {

_root.菜單.stop();

}

on (release, rollOut) {

_root.菜單.play();

}

on (press) {

_root.圖檔.gotoAndStop(5)

_root.蒙闆.play();

}

_root.蒙闆.play();

}

執行個體制作完畢，大家測試景片，觀看效果。

十三、變量

通過本節的學習，了解變量的概念；掌握變量命名的規則、給變量指派的方法；會用動态

文本顯示變量、輸入文本輸入變量，會使用調試指令 trace。了解 Flash中的資料類型.

認識變量

在日常生活中人們處理資訊的時候,必需首先把資訊儲存起來,比如你将一群羊分成兩部分,

你必須把它們趕到不同的領地,這些領地暫時儲存着羊群,即便你是憑空想象,你想象時的信

息也要暫時儲存在腦細胞中,也就說要處理任何資訊首先就得儲存資訊,動作腳本也不例外,

動作腳本使用變量儲存資訊,是以說變量是儲存資料的一種容器,容器本身始終不變，但内容

可以更改,這個比喻是非常形象的,現在有一個容器名稱為 a,放進一些鹽它就是鹽罐子,放進

一些醋它就是醋罐子了。在 flash 中，通過動作腳本可以建立很多“容器”來存放 flash 中

的資訊，比如影片剪輯的透明度、坐标等，也可以存放人的名字、年齡等。為了差別不同的

“容器”必須為每個“容器”取一個自己的名字， 即變量名。怎麼樣來定義“容器”呢？

下面來定義一個容器，它的名字是 myAge,用來存放年齡。定義如下：

var myAge;

var 是用來定義變量的關鍵字。

MyAge 便是變量名。

那麼這個變量怎麼存放年齡呢？在定義變此時可以給定一個值，即變量值，如下所示：

var myAge=66；其中“=”号代表指派運算符，把 66 這個值賦給變量 myAge。

注意 ：首次定義變量時，為該變量指定一個已知值，這就是所謂的初始化變量。

變量的命名的規則

用不同的符号對不同的事物進行标記,用作标記的符号就是辨別符,辨別符是用于表示變量、

屬性、對象、函數或方法的名稱。

命名變量名要遵守如下的規則：

（1）不能是as 關鍵字，所謂關鍵字也稱保留字，指as 預先定義好的辨別符。

（2）不能以數字開頭，第一個字元必須是字母或下劃線“_”和美元符“$” 。

（4）中間不能有空格。

（5）變量名中不能使用标點符号，

（6）不應将動作腳本語言中的任何元素用作變量名稱。

正确的示例：

a,m,ba,assw,a_aa,my_mc,$abc,$_ss,$_mc等等

my_txt 儲存文本的變量

錯誤的示例：

2_m   //不能用數字開頭

my-a  //不能用減号分割

a.ss  //不能使用标點符号

a b //不能有空格

如：

var 年齡=20;

其中年齡就是變量名。

注意 ： 在命名變量時規範的方法是不同類型的變量加不同的字首或者字尾,在實際程式設計中

我們往往不太注意這些， 規範的命名變量使其他人更容易閱讀， 命名變量時通過為其增加

一些特殊的字尾觸發代碼提示。下表中為支援代碼提示所需字尾 trace()函數

在編寫腳作腳本中，我們會大量用到 trace()指令。trace()實際算是一個調試指令，它的輸出

都會在“輸出面闆”顯示出來。 而真正釋出作品的時候 trace()卻不再輸出。是最友善的調

試指令，trace()指令非常簡單：

應用格式:

trace(expression:Object)

參數:expression 要顯示的變量或者表達式。

下面我們使用 trace 函數輸出變量值

在主場景第 1 幀打開動作面闆，輸入下列代碼：

var a=5

var b="歡迎大家來到愛國者安全網學習 AS"

var c=(3+5)

trace(a);

trace(b)

trace(c)

變量指派

使用變量儲存資訊就叫做給變量指派。在 Flash中給變量指派常用的方法有：

var a=5;//把常量 5 指派給變量 a。

trace(a);//輸出面闆輸出 5

set(“a”,5);//用 set()方法為變量指派為 5。

trace(a);//5

this["a"+1]=0

trace(a1);//0

确定變量的範圍和聲明變量

變量的範圍是指變量在其中已知并且引用區域。在動作腳本中有 3 種類型的變量範圍：

? 本地變量在聲明它們的函數體（由大括号界定）内可用。

? 時間軸變量可用于該時間軸上的任何動作腳本。

? 全局變量和函數對于文檔中的每個時間軸和範圍可見。

本地變量

要聲明本地變量，請在函數體内部使用 var 語句。本地變量的使用範圍隻限于它的代碼塊，

它會在該代碼塊結束時到期。沒有在代碼塊中聲明的本地變量會在它的動作腳本結束時到

期。本地變量也可防止出現名稱沖突,在定義本地變量時可以為其指定資料類型，這有助于

防止将類型錯誤的資料賦給現有變量

trace(expression:Object)

var a=5

var b="歡迎大家來到愛國者安全網學習 AS"

var c=(3+5)

trace(a);

trace(b)

trace(c)

時間軸變量

時間軸變量可用于該時間軸上的任何動作腳本。要聲明時間軸變量，可以使用 set variable

動作或指派“=”動算符，應在該時間軸中的所有幀上都初始化這些變量，應確定首先初始

化變量，然後嘗試在動作腳本中通路它。聲明時間軸變量也可以使用 var

例如：如果将代碼“var x=10;”放置在第 20 幀上，則附加到第 20 幀之前的任何幀上的動

作腳本都無法通路變量

全局變量

全局變量和函數對于文檔中的每一時間軸和範圍而言都是可見的。若要建立具有全局範圍

的變量，請在變量名稱前使用_global 辨別符，并且不使用 var 文法。

例如

在根時間軸第一幀上定義兩個變量,然後将 trace()放在不同地點去傳回它們的值,以觀察它

們的差別

Var a=5

_global.b=3

在程式中使用變量

1．必須在動作腳本首先給變量指派，然後才能在表達式中使用它。在 flash 中可以使用變

量動态的設定其它動作中的不同參數。

例如：

on (release) {

k = random(30)+50;

setProperty("mc", _xscale, k);

setProperty("mc", _yscale, k);

}

2．如果使用未賦初值過的變量該變量的值将是 NaN或 undefined。并且動件腳本可能産生

意外的結

果。

例如：

var k=x*x;

trace(k);//NaN

var x=6;

在下面的示例中申明變量的語句必順排在第一行，這樣 k 就可以替換為一個值；

var x = 6;

var k = x*x;

trace(k);//36

用動态文本顯示變量值

（1） 啟動 flash，建立一個文檔，文檔屬性預設。

（2） 單擊文本工具，打開“屬性”面闆，在其文 檔類型選項中選擇“動态文本”

（3） 在舞台中單擊建立一個動态文本，在“屬性”面闆把變量名設為 myAge,

選擇圖層 1的第 1 幀，打開動作面闆，輸入以下代碼：

var myAge=20

測式影片，在動态文本中可以看到剛才定義的變量值。

用輸入文本輸入變量值

（1）在場景“圖層 1”的第一幀，在舞台上建立一個動态文本和輸入文本，在屬性面闆裡

為動态文本輸入執行個體名“輸入” ，為輸入文本輸入執行個體名“輸出” 。

（2）制作一個“送出”按鈕和“清空”按鈕。然後為按鈕添加代碼

送出按鈕上的代碼：

on (press) {

輸出 = 輸入;

}

清空按鈕上的代碼 ：

on (press) {

var 輸入 = "";

var 輸出 = "";

}

（3）插入“圖層 2” ，在圖層 2 的第 1 幀，添加代碼：

輸入=""

測試影片，觀看效果。

圓柱表面積計算公式

在輸入文本中輸入半徑和高的值後,點選計算按鈕,對應的面積值就會顯示在動态文本中.

1）在舞台上建立兩個輸入文本，分别在屬性面闆裡輸入變量名“r”和“h” 。再建立一個

輸入文本，在屬性面闆裡輸入變量名“s” ，自己安排好文本的位置。

（2）制作一個“計算”按鈕和“清空”按鈕，拖入舞台，放到适當位置。

（3）添加 AS 代碼：

計算按鈕上的代碼為：

on (release) {

s = 2*Math.PI*(r*r)+2*Math.PI*r*h;

}

清空按鈕上的代碼為：

on (press) {

r = "";

h = "";

s = "";

}

代碼解釋：在表達式 2*Math.PI*(r*r)+2*Math.PI*r*h 中，Math.PI 代表圓周率，在計算精确

度不高時， 通常是取它的近似值為 3.14。 而 2*Math.PI*(r*r)表示兩底面的面積和；

2*Math.PI*r*h表示側面積。

資料類型

我們思考一下計算機程式所作的一些事情,财務管理程式能夠列印帳單,字處理程式能夠輸

入和編輯文本,視訊處理程式能夠讓我們觀看影片和玩各種遊戲,等等數不勝數,但所有程式

都有一個共同特點;他們都需要處理資料.flash 中根據資料的處理方法的不同,對資料進行了

分類,他們是;數值類型,字元串類型,布爾類型,對象類型,影片剪輯類型,未定義和空值。

計算機在處理這些資料的時候,必需使用某種方法存儲這些資料,變量就是服務于該目的,所

以我們常說"變量是儲存資訊的容器" ， 為了差別分不同類型的變量,就有了資料類型,變量有

多種資料類型,資料類型描述變量或動作腳本元素可以包含的資訊種類,下面講解常見的資料

類型.函數的值是由變量決定的，那麼什麼來決定變量呢？那是資料， 下面我們就說說 AS

中使用到的資料類型。AS 中的資料有兩大類，一 類稱之為原始類型（也叫初始類），另

一類叫做參考類型 （也叫引用類）。

原始類型資料分為字元串、數值和邏輯型三種，它們都有常量 值，能夠為其所代表的元素

賦一個實際值。

參考類型資料包括影片剪輯和對象兩種， 它們有一個可變的值， 包含了對元素實際值的引用。

此外還有兩個特殊類型的資料：空值和未定義值。

字元串型（string） ：字元串是諸如文字、字母、數字和标點符号等字元的序列。在動作腳

本語句中輸入字元串的方式是将其放在單引号或雙引号之間，字元串被當作字元，而不是變

量進行處理。例如“學習 Flash”“abcd”的等。還可以使用”+”等運算符對字元串進行操

作。

例如

trace("歡迎大家");

trace(\'來愛國者安全網學習\');

trace("歡迎大家"+\'來愛國者安全網學習\');

數值型( (N umber) )：您可以使用加(+)、減(-)、乘(*)、除(/)、求模(%)、遞增(++)和遞減(- -)

等算術運算符來處理數字，也可使用内置的 Math 和 Number 類的方法來處理數字。下面

的示例使用 sqrt()（平方根）傳回數值 100 的平方根 10。

trace(Math.sqrt(100));// 傳回數值 100 的平方根 10

布爾型(boolean) ：隻有 “真 （true） ”“假（false） ” 兩種值的資料。布爾值是 true 或 false

中的一個，動作腳本也會在适當時将值 true 和 false 轉換為 1 和 0。 布爾值經常與動作腳

本中的比較運算符一起使用。

例如

trace(3<1);

trace(-8<0);

對象(Object )：： 對象是屬性的集合。 每個屬性都有名稱和值， 屬性的值可以是任何的 Flash

資料類型，甚至可以是對象資料類型。這樣就可以使對象互相包含（即将其嵌套）。若要指

定對象及其屬性，可以使用點(.) 運算符。

影片剪輯 ( Movie Clip) ：影片剪輯是 Flash 應用程式中可以播放動畫的元件，是唯一引用

圖形元素的資料類型。MovieClip 資料類型允許您使用 MovieClip 類的方法控制影片剪輯

元件，可以使用點(.) 運算符調用這些方法。影片剪輯是 Flash中最活躍的元素之一。

例如：

trace(_root.mc._x);

trace(_root.mc._height);

Undefined：表示未定義的資料類型,如下情況傳回 undefined 值：

(1)對象屬性不存在，

(2)聲明了變量但從未指派。

例如沒有定義變量 a 的情況下。

trace(a);// Undefined。

trace(a+3);//NaN

測試資料類型

我們用如下函數可以判斷資料類型：

typeof();

typeof()通常與 trace()結合使用

本例使用 trace 語句與 typeof 函數共同測試資料類型。為大家學習 Flash 資料類型實作更

加深入的認識。

注意：我們的所有測試必須在 fla 源檔案編輯狀态下單擊“控制”|“測試影片”才能在輸

出面闆看到效果，測試 swf檔案是不會得到任何輸出的。

typeof用法

typeof(表達式)

表達式：一個字元串、影片剪輯、按鈕、對象或函數。

說明: 運算符； 放在單個參數前的一進制運算符。typeof 運算符讓 Flash 解釋器計算 表達式；

其結果為一個字元串，訓示該表達式是字元串、影片剪輯、對象、函數、數字，布爾值。

示例：測試資料類型

（1）在舞台中放一個影片剪輯元件，并輸入執行個體名“my_mc” 。

（2）在舞台中放一個按鈕。并輸入執行個體名“my_btn” 。

（3）在舞台中繪制一個動态文本，輸入變量名“txt1”在動态文本中任意輸入文字。

（4）在舞台中繪制一動态文本，輸入文本執行個體名“txt2” 。在動态文本中任意輸入文字。

在第一幀中輸入腳本：

trace("測試結果");

trace(typeof (txt1));

trace(typeof (my_mc));

trace(typeof (my_btn));

trace(typeof (txt2));

trace(typeof (Math.PI));

trace(typeof (3<1));

trace(typeof (System));

trace(typeof (stop));

顯示對各類表達式使用 typeof 運算符的結果如下表所示。

十四、運算符（一）

運算符表達式

運算符是指定如何組合、比較或修改表達式值的字元。運算符對其執行運算的元素稱為操作

數。例如，在語句“foo+3”中， “+”運算符會将數值文本的值添加到變量 foo的值中；foo

和 3 就是操作數。

用運算符連接配接變量或者常量得到的式子叫做“表達式” 。各種表達式用運算符連接配接在一

起還叫做表達式，例如：圓柱體表面積計算公式 2*Math.PI*r*r+2Math.PI*r*h。

其中“2”和“Math.Pi” （表示圓周率π）都是常數，而“r”和“h”分别表示半徑和高，

是變量。 “+”和“*”分别表示加法運算和乘法運算，是運算符，這個式子就是表達式。

運算符的優先順序

在同一語句中使用兩個或多個運算符時， 各運算符會遵循一定的優先順序進行運算， 例如加

(+)，減(-)的優先順序最低， (*),除(/)的優先順序較高，而括号具有最高的優先順序，當一

個表達式中隻包含有相同優先級的運算符時，動作腳本将按照從左到右的順序依次進行計

算；而當表達式中包含有較高優先級的運算符時,動作腳本将按照從左到右的順序，先計算

優先級高的運算符，然後再計算優先級較低的運算符;當 表達式中包含括号時，則先對括号

中的内容進行計算，然後按照優先級順序依次進行計算。

算術運算符

可以執行加法、減法、乘法、除法運算，也可以執行其他算術運算。Flash 中的算術運算符

及簡單的用法如下圖 加法運算執行個體

在場景中繪制三個動态文本，變量名分别為 c1、c2、c3。再繪制兩個輸入文本，變量名為

a、b。放入四個按鈕，分别選中按鈕輸入 AS：

（1） 數字類型相加

on (press) {

c1 = 3+2;

}

（2） 字元串相加

on (press) {

c2 = "學習"+"flash";

}

（3） 輸入文本中的變量相加

on (press) {

c3 = a+b;

}

（4） 字元串類型轉化為數字類型

on (release) {

c3 = Number(a)+Number(b);

}

說明：在執行加法運算時，如果，操作數是數字類型，那麼執行的加法就是數字相加，如果

操作數是字元串類型，那麼這裡的加法就是合并字元串；如果，操作數中有字元串，有數字，

那麼程式就會把其中的數字當成字元串； 動态文本和輸入文本中的變量值， 程式都把它看成

字元串類型，要執行數字相加時，要轉化成數字類型。例如上例中的

c3 = Number(a)+Number(b);

差別 x++和++x

場景第 1 幀上

x=1

y=1

（1） x++

on (release) {

a_txt = ++x;

}

(2) ++x

on (release) {

b_txt = y++;

}

幀循環 i++

場景第 1 幀上 ：

i=1;

stop();

場景第 2 幀上：

i++;

a_txt = i;

場景第 3 幀上：

gotoAndPlay(2);

播放按鈕上：

on (release) {

this.play();

}

停止按鈕上：

on (release) {

this.stop();

}

說明：在使用增量運算符時，運算符放在表達式前面與放在後面所執行的操作是不同的，當

用++i 格式時将先執行加 1 操作,然後在使用表達式的值，當使用 i++格式時則首先使用表

達式的值然後執行加 1 操作。

取模運算

場景第 1 幀上：

var i=0;

按鈕上：

on (release) {

a_txt = i++;

b_txt=Number(a_txt)%2;

}

說明： ：取餘運算：首先進行除法運算然後取餘數，叫取餘運算,取餘運算并不在乎其

商是多少，目的隻是獲

取餘數,例如 7/2 餘 1，我們使用餘數 1 去參加運算,稱為數字 7 對數字 2 的餘(模)，在

flash中取餘運算用%

表示， 上式中的餘數 1 儲存到變量 my_a 中可以寫 my_a=7%2,有些程式設計語言中取餘運算

不用%， 而是用 mod

表示，是以有的人就把取餘運算叫做取模運算。

6. .2 2 指派運算符

FLASH 用了大量的指派運算符,可以使設計的動作腳本更簡潔,下面列出了 FLASH 中使用

的指派運算符。 指派運算符原理

第 1 幀上初始變量：

a=b=c=d=e=100;

按鈕 1 上的 AS：

on (release) {

a += 1;

a_txt1 = a;

}

按鈕 2 上的 AS：

on (release) {

b -= 1;

a_txt2 = b;

}

按鈕 3 上的 AS：

on (release) {

c *= 0.1;

a_txt3 = c;

}

按鈕 4 上的 AS：

on (release) {

d /= 0.1;

a_txt4 = d;

}

按鈕 5 上的 AS：

on (release) {

e += 5;

e %= 2;

a_txt5 = e;

}

鼠 滑鼠 标跟 跟随 随特 特效

（ （1 1） ）在 在舞台上用靜态文本輸入文字“滑鼠跟随特效”一次分離後，分别把各個

字分别轉換為影片剪輯元件。 注意： 轉換時注冊點要居中。 然後依次分别輸入執行個體名稱：

“mc1” 、 “mc2” 、 “mc3” 、 “mc4” 、 “mc5” 、

“mc6” 、 “mc7”

（2） 插入“圖層 2”在“圖層 2”第 1 幀輸入 AS 代碼：

_root.mc1._x += (_root._xmouse-_root.mc1._x)/5

_root.mc1._y += (_root._ymouse-_root.mc1._y)/5;

_root.mc2._x += (_root.mc1._x-_root.mc2._x)/5;

_root.mc2._y += (_root.mc1._y-_root.mc2._y)/5;

_root.mc3._x += (_root.mc2._x-_root.mc3._x)/5;

_root.mc3._y += (_root.mc2._y-_root.mc3._y)/5;

_root.mc4._x += (_root.mc3._x-_root.mc4._x)/5;

_root.mc4._y += (_root.mc3._y-_root.mc4._y)/5;

_root.mc5._x += (_root.mc4._x-_root.mc5._x)/5;

_root.mc5._y += (_root.mc4._y-_root.mc5._y)/5;

_root.mc6._x += (_root.mc5._x-_root.mc6._x)/5;

_root.mc6._y += (_root.mc5._y-_root.mc6._y)/5;

（3） 圖層 2 第 2 幀上的 AS 代碼 ：

gotoAndPlay(1);

語句講解：

（1）_root._xmouse—滑鼠在場景中的橫坐标；_root._ymouse—滑鼠在場景中的縱坐标。

（2）計算移動距離的方法：

距離=(終點坐标－執行個體坐标)/速度

執行個體坐标+=距離

或者描述為：執行個體坐标+=(終點坐标－執行個體坐标)/速度。

它實作的效果是從執行個體的初始位置開始， 減速地運動到終點。 在上例中隻不過終點坐标也

是執行個體坐标。

實際上就是計算出兩執行個體距離，然後把這個距離除以 5，每次移動距離的五分之一，是以把

這裡的 5 叫做速度。

這個公式不僅用于執行個體的移動， 如果用于影片剪輯的其它屬性，如透明度可以實作執行個體透明

度慢慢變化，如：

mc._alpha+=(20-mc._alpha)/5

可以實作 mc的透明度慢慢從 100 減到 20。

十五、變量（二）

比較運算符

用于比較表達式的值，然後傳回一個布爾值（true 或 false）。這些運算符最常用于循環語句

和條件語句中。Flash中的算術運算符及簡單的用法如表 比較傳回值

在舞台上繪制四個動态文本框,變量名分别為: m_txt1、m_txt2、m_txt3、m_txt4。再放入兩

個按鈕。 按鈕 1 上的 AS：

on (release) {

m1_txt = 1 == 2;

m2_txt = 1>2;

m3_txt = 1<2;

m4_txt = 1 != 2;

}

按鈕 2 上的 AS:

on (release) {

m1_txt=""

m2_txt=""

m3_txt=""

m4_txt = ""

}

條件運算符

?:（條件）

格式：表達式式 1? 表達式 2：表達式 3

參數： 表達式 1計算結果為布爾值的表達式， 通常為像 x < 5 這樣的比較表達式。 表達式 2、

表達式 3 任何類型的值。

說明：訓示 Flash 計算表達式 1，如果表達式 1 的值為 true，則它傳回表達式 2 的值；否

則，它傳回表達式 3 的值。

條件運算符原理

在舞台上繪制兩個輸入文本， 一個動态文本。 變量名分别為 “x_txt”、“y_txt”、“z_txt”。

在放入一個“計算”按鈕、一個“清空”按鈕。 運算按鈕上的 AS 代碼：

on (press) {

x = Number(x_txt);

y = Number(y_txt);

z = (x<y) ? x : y;

z_txt = z;

}

清空按鈕上的 AS 代碼 ：

on (press) {

x_txt=""

y_txt=""

z_txt=""

}

說明：影片播放時分别在輸入文本中輸入不能的數值，點選運算按鈕，觀察傳回值，進而理

解其原理。

一個按鈕兩種功能

制作一個小球旋轉的影片剪輯元件，輸入執行個體名 mc，放入一個按鈕，然後輸入 AS 代碼 ：

場景第 1 幀上的 AS 代碼 ：

var i=1

按鈕上的 AS 代碼 ：

on (press) {

i++%2 == 0 ? _root.mc.play() : _root.mc.stop();

}

說明：此例中是用取模來分支的，我們也可要用布爾值來進行分支，例如上例中可以這樣寫

語句：

第 1 幀上：

var k =false;

按鈕上：

on (press) {

k ? _root.mc.play() : _root.mc.stop();

k = !k;

}

如果要控制幾個影片剪輯代碼要以這樣寫：

on (press) {

i++%2 == 0 ?[ _root.mc1.play(),_root.mc2.play()]:[_root.mc1.stop(),_root.mc2.stop()];

}

邏輯運算符

邏輯運算符對布爾值（true 和 false）進行比較，然後傳回第三個布爾值。在表達式中，用

戶可以使用邏輯運算符來判斷某個條件是否存在。邏輯運算符主要用在 if和 do while動作

中。有關邏輯運算符及其功能如表 邏輯運算原理

說明：我們打開素材，播放狀态下，點選按鈕，觀察邏輯運算的傳回值，進而了解邏輯運算

原理。

控制小球運動

1．運作 Flash 8，大小預設，幀頻為 24fps。

2．在舞台上繪制一個直徑為 60 的無筆觸放射狀填充的小正圓（小球）。

3．選中小球，按 F8 鍵轉化為影片剪輯元件，注冊點居中。

4．選中小球，在屬性面闆裡輸入執行個體名： “mc”

5．插入“圖層 2” ，把“圖層 2”重命名為“AS” 。

6．在“AS”的第 2 幀，第三幀上插入空白關鍵幀。

在第 1 幀上添加 AS 代碼：

var i = 20;

var j = 10;

第二幀上添加 AS 代碼：

_root.mc._x<=30 || _root.mc._x>=520 ? i=-i : 0;

_root.mc._y<=30 || _root.mc._y>=370 ?j=-j : 0;

_root.mc._x += i;

_root.mc._y += j;

第 3 幀上的代碼：

gotoAndPlay(2);

7．大家可以自己加一個背景，放在場影的最下層。

8．播放影片，觀看效果。

代碼講解：

（1） 第 1 幀上初始的變量值是決定小球的運動方向與運動速度的。

（2） 第 2 幀上用條件運算符來控制小球運動到場影的邊緣時就要反向，速度不變。

（3） 第 3 幀上是讓播放頭在第 2 幀同第 3 幀之間循環。

（4） 此例條件運算式了中,第三個表達式:“0”是不起任何作用的，但語名格式中，不能沒

有它。

十六、影片剪輯的屬性

通過本課的學習了解影片剪輯的主要屬性，學會設定和擷取影片剪輯的屬性的方法。

知識點：

（1）影片剪輯的常用屬性

（2）用點文法設定和擷取影片剪輯的屬性

（3）用 setProperty()和 getProperty()函數動态設定和擷取影片剪輯屬性

（4）用數組運算符[]動态設定和擷取影片剪輯屬性

影片剪輯的屬性

我們已經知道影片剪輯的一些屬性可以通過屬性面闆，資訊面闆，變形面闆，來設定，在

這一課中我們将深入學習在 AS 語言是怎樣描述影片剪輯的屬性的、 怎樣用程式來設定和獲

取影片剪輯的屬性。下面列出了影片剪輯常用屬性 用點文法設定和擷取影片剪輯的屬性

對于大多數影片剪輯的屬性既可以設定，又可以擷取，比如坐标、旋轉度，透明度等。 這

裡我們通過下面的例子來學習用點文法設定和擷取影片剪輯的屬性。

用點文法設定影片剪輯屬性 1．命名執行個體名和變量名

（1）打開素材，進入到花元件中，選中“花 1”影片剪輯元件，在屬性面闆裡輸入執行個體名

稱： “mc1” 。在場影中，選中“花”影片剪輯元件，在屬性面闆裡輸入執行個體名稱：“mc” 。

（2）在場景中建立一個動态文本，并在屬性面闆裡輸入變裡名： “txt”.

2．寫代碼（場景中的按鈕從上到下依次叫按紐 1~按鈕 6）

按鈕 1 上的代碼：

on (release) {

_root.mc.mc1._xscale += 10;

_root.mc.mc1._yscale += 10;

_root.txt = "放縮度:"+_root.mc.mc1._xscale;

}

按鈕 2 上的代碼：

on (release) {

_root.mc.mc1._xscale-= 10;

_root.mc.mc1._yscale-= 10;

_root.txt="放縮度:"+_root.mc.mc1._xscale

}

按鈕 3 上的代碼：

on (release) {

_root.mc.mc1._rotation += 2;

_root.txt ="旋轉度:"+ _root.mc.mc1._rotation;

}

按紐 4 上的代碼：

on (release) {

_root.mc.mc1._rotation-= 2;

_root.txt = "旋轉度:"+ _root.mc.mc1._rotation;

}

按紐 5 上的代碼：

on (release) {

_root.mc.mc1._alpha -= 5;

_root.txt ="透明度:"+  _root.mc.mc1._alpha;

}

按紐 6 上的代碼：

on (release) {

_root.mc.mc1._xscale = 100;

_root.mc.mc1._yscale = 100;

_root.mc.mc1._rotation = 0;

_root.mc.mc1._alpha = 100;

_root.txt="還原"

}

在上例中我們學習了點運算符設定和擷取影片剪輯的屬性， 但點運算符不能動态的設定影片

剪輯的屬性。這一課中我們将學習動态的設定影片剪輯的屬性。

setProperty()//設定電影片斷在螢幕中的屬性。

腳本位置：全屬函數|影片剪輯控制|setProperty

文法格式：setProperty (target:Object, property:Object, expression:Object) : Void

功能：當影片播放時更改影片剪輯的屬性。

參數：

◆ target：Object — 要設定其屬性的影片剪輯的執行個體名稱的路徑。

◆ Property：Object—要設定的屬性。

◆ Expression：Object — 或者是屬性的新的字面值，或者是計算結果為屬性新值的等式。

點選：全屬函數|影片剪輯控制|setProperty後，

◆ 目标—要設定其屬性的影片剪輯的執行個體名稱的路徑。

◆ 屬性—要設定的屬性

◆ 值—或者是屬性的新的字面值，或者是計算結果為屬性新值的等式。

getProperty()函數

我們已經知道 setProperty()函數可以設定影片剪輯的屬性但它沒有傳回值

例如：例如在舞台上建立兩個影片剪輯，執行個體名為： “mc1” 、 “mc2”水準中齊。在第

一幀寫入代碼：

mc1._x = 275;

trace(mc1._x);//275

setProperty(mc2, _x, 275);

trace(setProperty(mc2, _x, 275));//undefined

flash給我們提供了動态擷取影片剪輯屬性的函數 getProperty()。

腳本位置：全屬函數|影片剪輯控制|getProperty

文法格式：getProperty(my_mc:Object, property:Object) : Object

功能:傳回影片剪輯 my_mc 的指定屬性的值。

參數：

◆ my_mc:String — 要檢索其屬性的影片剪輯的執行個體名稱。

◆ property — 影片剪輯的一個屬性。

傳回：Object— 指定屬性的值。

點選,全屬函數|影片剪輯控制|getProperty後

此對話本框中參數能選項如下所述。

目标—要檢索其屬性的影片剪輯的執行個體名稱。

屬性—指定屬性的值。

設定和擷取影片剪輯的屬性

（1） 在舞台任意繪制一個圖形，轉化為影片剪輯元件，注冊點居中。在屬性面闆中設定實

例名為“a_mc”

（2） 複制一個影片剪輯執行個體，把複制的這個執行個體用任意變形工具任意改變它的高和寬。并

在屬性面闆裡設定執行個體名為“b_mc” 。

（3） 建立一個按鈕，選中按鈕，打開“動作”面闆，寫入代碼：

on (release) {

setProperty("b_mc", _width, getProperty("a_mc", _width));

setProperty("b_mc", _height, getProperty("a_mc", _height));

setProperty("b_mc", _x, getProperty("a_mc", _x)+200);

setProperty("b_mc", _y, getProperty("a_mc", _y));

}

測試影片，點選按鈕後，兩個執行個體完全一樣。

在這個執行個體中是靜态地設定和獲敢影片剪輯屬性的，下面我們來練習動态設定屬性。

使用 setProperty()函數批量更改影片剪輯屬性

下圖是實效果中的一個面畫 制作步驟

（1） 建立 flash文檔，文檔大小：600×400，其它預設。

（2） 在舞台上繪制一個直徑為 60 的正圓，轉化為影片剪輯元件，注冊點居中。

（3） 複制 4 個影片剪輯執行個體， 在屬性面闆裡分别設定執行個體名稱為 “qiu1” 、“qiu2” 、

“qiu3” 、 “qiu4” 、 “qiu5” 。把 5 個影片剪輯執行個體拖入到舞台外。

（4） 在舞台上建立兩個按鈕元件。分别選中按鈕，打開動作面闆，寫入代碼：

on (release) {

i<5 ? i++ : i=1;

setProperty("qiu"+i, _x, 100*i);

setProperty("qiu"+i, _y, 180);

setProperty("qiu"+i, _alpha, 100-(i-1)*20);

}

on (release) {

i<5 ? i++ : i=1;

setProperty("qiu"+i, _x, 100*i);

setProperty("qiu"+i, _y, 2/3*100*i);

setProperty("qiu"+i, _alpha, 100-(i-1)*20);

}

在場景第 1幀輸入代碼：

var i=0

測試影片，觀看效果。

分析： 在第 1 幀上初始變量值為 i=0,當第一次點選按鈕時， i++的值為 1， 第二次點選時 i++

的值為 2，……

是以，_alpha 的值 100-(i-1)*20 依次為：100、80、60、40、20。

_x 的值 100*i 依次為：100、200、300、400、500。

縱坐标_y 的算法：場景大小為 600×400，坐标原點（0，0）在左上角，是以對角線的斜率

為：400/600=2/3，對角線方程為：y=2/3x,因為橫坐标_x 為：100*i，是以縱坐标_y的值設定

為：100*i*2/3。

在這個執行個體中，我們用點運算符分别來設定小球的屬性還不算太困難，要是有 100 個影片

剪輯執行個體呢？那你要寫多少代碼。是以掌握動态設定影片剪輯屬性的方法很有必要。 在以後

我們學習到複制指令、條件、循環後會更有體會的。

動态路徑

影片剪輯一般可以通過手工建立,通過“屬性”面闆設定影片剪輯的執行個體名稱，通過執行個體名

稱和路徑可以通路不同層次的影片剪輯執行個體。但有的影片剪輯執行個體是通過程式建立的，例如

通過複制函數可以複制出若幹的新影片剪輯執行個體， 它們的執行個體名也是在程式中指定的。要訪

問這些複制出來的影片剪輯，最好的方法是用動态路徑。

動态路徑是利用數組運算符來實作的

。

我們可以使用動态路徑來通路"qiu"+i

_root["qiu"+i]

也可以使用 this 來指定

this["qiu"+i]

注意：動态路徑使用數組運算符 “ [] ” 實作，路徑同執行個體名之間沒有點運算符。

說明:使用動态路徑可以批量實作路徑.假如場景中有影片剪輯執行個體 mc1，mc2…mc100 假如

用絕對路徑要寫 100 行程式，用動态路徑非常友善，因為這些執行個體名有一定的規律，開頭

的字母都是一個的，都是 mc，後面的數字可以用一個變量 n來表示，因為變量是可以變化

的，表不如下：

_root[“mc”+i]

如果有多重路徑，如要通路主場景下的 mcA下的 mc1 到 mc100，可以這樣來表示：

_root.mcA["mc"+i]

又如要通路"mc"+i 中的變量 txt，可以這樣來表示：

_root["mc"+i+".txt"]

利用動态路徑批量更改影片剪輯的屬性。 。

(1) 打開源檔案。

(2) 進入 qiu1 的編輯場影中，插入“圖層 2”在此圖層上建立一個動态文本，在屬性面闆

裡輸入變量名 txt。

因為另外四個影片剪輯執行個體是由 qiu1 複制的，是以每個影片剪輯執行個體中都有了動态文本。

(3) 把兩個按鈕上的代碼分别改為：

on (release) {

i<5 ? i++ : i=1;

_root["qiu"+i]._x = 100*i;

_root["qiu"+i]._y = 180;

_root["qiu"+i+".txt"] = "qiu"+i;

}

on (release) {

i <5 ? i++ : i=1;

_root["qiu"+i]._alpha = 100-(i-1)*20;

_root["qiu"+i]._x = 100*i;

_root["qiu"+i]._y = 2/3*100*i;

_root["qiu"+i+".txt"] = "qiu"+i;

}

測試影片，

說明：動态路徑在實際程式設計中運用非常廣泛，它大大提高了程式設計的效率。有關動态路徑更多

應用将在後面的章節裡講解。

十七、再講循環語句

掌握 if 語句、if-else語句、else if 語句的文法格式及其功能。

一個程式都是由若幹個基本結構組成，每個基本結構包含一個或多個語句。 程式有三種基本

結構，順序結構、選擇結構、循環結構。

在實際運用中，往往有一些需要根據條件來判斷結果的問題，條件成立是一種結果，條件不

成立又是一種結果。像這樣比較複雜的問題就必須用選擇結構來解決。

在選擇結構程式中，有一個條件，當條件為真時，執行一段代碼,否則的話，執行另一段

代碼，是以選擇結構的程式的特點是隻能執行兩段代碼中的一段。

在這一課中我們将繼續學習條件語句。

if 語句

腳本位置： 語句|條件/循環|if 語句

文法格式：

if(條件) { //小括号裡的條件是一個計算結果為 true 或 false 的表達式。

這裡是當條件計算為 true時執行的指令

}

功能：其中，if是表示條件語句的關鍵詞，注意字母是小寫，這個 if語句的功能是 if後面

小括号裡面的條

件隻能有兩種結果：真（true）或假（false）。隻有當條件為真時才執行大括号中的程式，如

果條件為假，

将跳過大括号中的程式，執行下面的語句。if語句執行過程如圖 參數：condition:Boolean—計算結果為 true 或 false 的表達式。

if 語句執行過程 （1）如圖所示，在舞台上建立一個輸入文本，三個動态文本， （按照圖中從上到下的順序

排列）， 按照這個順序依次分别輸入變裡名：“a_txt”、“b_txt”、“c_txt”、“d_txt”。

（2）插入“圖層 2” ，在“圖層 2”上建立兩個按紐執行個體（計算按鈕和清空按紐）。

（3）選中計算按鈕，打開動作面闆，輸入下面代碼：

on (release) {

var k = Number(a_txt);

b_txt = (k%3 == 0);

if (k%3 == 0) {

c_txt = "a 能被3 整除";

}

d_txt = "這裡顯示的是花括号後面的語句";

}

（4）選中清空按鈕，打開動作面闆，輸入下面代碼：

on (release) {

a_txt = "";

b_txt = "";

c_txt = "";

d_txt = "";

}

（5）測試影片，在輸入文本時輸入數字。點選計算按鈕，可以看到當條件為真時執行大括

号内的語句，當條件為假時跳過大括号執行大括号外的語句。

條件語句中的條件

（1）條件語句中的條件可以非常簡單，一個變量也可以作為一個條件，如果變量有一個确

定的值，它傳回的結果是真，如：

var 我的名字 = "雷克斯 de眼淚";

if (我的名字) {

trace(我的名字);

}

（2）條件語句中的條件還可以是一個指派表達式。如：

var 我的名字 = "雷克斯 de眼淚";

if (我的名字=="雷克斯 de眼淚") {

trace(我的名字);

}

（3）if 名句中的條件可以是多個的，要用邏輯運算符進行連接配接，這時 flash 将進行判斷，

計算最後的結果是真還是假，如：

var 使用者名 = "雷克斯 de眼淚";

var 使用者密碼 = "123";

if (使用者名 == "雷克斯 de眼淚" && 使用者密碼 == "123") {

trace("使用者名和密碼正确");

}

在這段代碼中，if 中的條件有兩個，用&&運算符來連接配接，代表兩個條件都為真時才執行語

句中大括号内的代碼。

總結： 由此可見， 條件的類型一般為邏輯表達式和關系表達式， 但也可以是任意的資料

類型。 這時 flash将按真處理。

if-else 語句

if-else 語句的一般形式為：

if (條件){

//程式 1，條件為真時執行的程式

} else {

//程式 2，條件為假時執行的程式

}

功能：當條件成立時執行程式 1，當條件不成立時執行程式 2，這兩個程式隻選擇一個執行

後，就執行下面的程式。if-else 語句執行的過程如圖 if-else 語句執行的過程

(1) 如圖所示,在舞台上建立一個輸入文本， 在屬性面闆裡設定變量名為 “a_txt” ， 再建

立三個動态文本，變量名分别為“b_txt” 、 “c_txt” 、 “d_txt” 。 (2) 插入新圖層，在此圖層上建立兩個按鈕執行個體，用于計算和清空。

(3) 單擊“清空”按鈕上的代碼：

on (release) {

a_txt = "";

b_txt = "";

c_txt = "";

d_txt = "";

}

計算按鈕上的代碼：

on (release) {

var k = Number(a_txt);

b_txt = (k%3 == 0);

if (k%3 == 0) {

c_txt = "a 能被3 整除";

} else {

d_txt = "a 不能被 3整除";

}

}

（4） 測試影片， 在輸入文本時輸入數字。 點選計算按鈕， 可以看到當條件為真時執行程式 1，

當條件為假時執行程式 2。

小課件 100以内的加法運算

課件效果

本例是一個測試 100 以内的兩個整數加法運算的填空題課件，運作課件時，單擊“請出題”

按鈕，随機顯示兩個加數，填好答案後，單擊“查成績”按鈕，即可判斷答題是否正确。 制作步驟

1．建立一個 flash文檔，文檔屬性保持預設設定。

2．建立一個名為“填空題”的影片剪輯元件，将“圖層 1”更名為“背景和标題” ，然後

在此圖層上建立背景和标題。

3．建立一個名為“動态文本”的圖層，在這個圖層上，建立 4 個動态文本框，在屬性面闆

裡設定好文本屬性，并輸入分别輸入執行個體名a、b、c、d。（其中a、b 用來顯示兩個加數，c

用來顯示和，d 用來顯示回報）按照它的們的功能，安排好位置。再用靜态文本輸入“+”

号和“=”号。

4．建立一個名為“按鈕”的圖層，在此圖層中，建立兩個按鈕執行個體，一個用來出題，一個

用來查成績。

5．給按鈕添加代碼:

出題按鈕上的代碼:

on (press) {

a = random(100);

b = random(100);

c = "";

d = "";

}

查成績按鈕上的代碼:

on (press) {

if (Number(a)+Number(b) == Number(c)) {

d = "答對了！";

} else {

d = "答錯了！";

}

}

6．回到場景，從庫裡提出名為“填空題”的影片剪輯元件，居中對齊。測試影片。

else if 語句

腳本位置：ActionScript 語言元素 > 語句 > else if 語句

文法格式：

if(條件 1) {

程式 1;

} else if(條件 2) {

程式 2;

…

} else if(條件 s) {

程式 (s);

}

功能：else if 語句是這樣執行的：進行條件 1 的判斷，如果條件 1 為真執行程式 1，如果

條件 1 為假則跳過程式 1，進行條件 2 的判斷，其它依此類推。

心心相印

心髒每時每刻都在不停的跳動， 我們利用變量的遞增遞減及條件語句可以實作這個效果。當

數字增大時心髒變大，當數字減小時心髒變小。

制作步驟：

（1） 建立一個 FLASH 文檔，大小預設。

（2） 建立一個名為“跳動的心”的影片剪輯元件，在其編輯區繪制一個心髒。

（3） 把心髒轉化為影片剪輯元件，注冊點在圖形的中心。在屬性面闆中設定心髒的執行個體名

為： “heart” 。

（4） 建立一個名為 AS 的層，單擊第一幀，打開動作面闆，輸入下列代碼：

var i = 1;

var j = 8;

var con = true;

在 AS 層的第 2 幀插入空白關鍵幀，在其動作面闆中輸入下列代碼 ：

heart._xscale = heart._yscale=i+100;

if (con) {

i++;

} else {

i--;

}

if (i == 1) {

con = true;

} else if (i == j) {

con = false;

}

在 AS 層的第 3 幀插入空白關鍵幀，在其動作面闆中輸入下列代碼 ：

gotoAndPlay(2);

（5） 傳回主主場景，把庫裡的跳動的心提進主場景，可以看到心髒在不停的跳動。

十八、影片剪輯處理函數

在前面我們學習了幀 Script 和按鈕 Script，我們注意到幀 Script 的執行是由時間決定

的，如果時間停 止了，則幀 Script 就不會執行了，而按鈕則不同，按鈕 Script 是基于事

件的，它隻和其驅動函數 on(...)中

的事件有關，影片剪輯和按鈕一樣也支援事件驅動，它的驅動函數為 onClipEvent (...);通常

叫做影片剪輯的事件處理函數，其中的事件分為影片播放(load,enterframe,data 等)和使用者反

應(mouseDown,keyDown 等)兩類，另外影片剪輯擁有獨立的時間軸，其關鍵幀上也可以加

入幀 Script，是以影片剪輯的控制功能十分強大。

onClipEvent 處理函數

? 腳本位置： 全局函數|影片剪輯控制|onClipEvent 處理函數

? 文法格式：在 FLASH 中使用 onClipEvent 指令來根據影片剪輯的狀态觸發動作，

onClipEvent 通常使用以下的格式

onClipEvent(事件名稱) {

// 程式

}

? 功能：觸發為特定影片剪輯執行個體定義的動作。

? 參數：movieEvent:Object - movieEvent 是一個稱為事件的觸發器。當事件發生時，執行

該事件後面大括号 ({}) 中的語句。可以為 movieEvent 參數指定下面的任一值：

事件的觸發器常見的取值如下： 編寫程式時，Flash 會自動提示 onClipEvent ()的事件名稱，在一個影片剪輯的“動作”面

闆中輸入 onClipEvent 時會自動彈出事件清單

Load 事件

load事件在影片剪輯完全加載到記憶體中時發生。在每次播放 Flash影片時，每個影片剪輯的

load事件隻發生一次。

認識 load事件

（1） 在場景中建立一個影片剪輯執行個體，選中執行個體，打開“動作”面闆，輸入下列代碼：

onClipEvent (load) {

trace("發生 load事件");

}

（2） 測試影片，在“輸出”面闆中看到的輸出資訊隻有一次。

（3） 傳回主場景，在第二幀插入一幀，測試影片，雖然幀不斷循環播放，但輸出資訊也隻

有一次。

（4） 傳回主場景，在第二幀插入一空白關鍵幀，讓其循環播放。測試影片，将不斷的輸出

資訊。

說明：通過測試可以看出，當影片剪輯出現在時間軸上時，load事件發生，當執行個體在時間軸

上消失時又重新出現時，也會發生 load事件。Load 事件通常用來聲明初始化變量，當影片

一出現時就會加載這些變量，其它程式就可以調用這些變量。

Unload 事件

Unload 與 load 事件剛好相反，當影片剪輯執行個體在時間軸在消失時才會發生。

對比 load事件和 unload 事件,在上面執行個體的基礎上，執行下列操作。

（1） 打開影片剪輯的執行個體面闆，把代碼改為：

onClipEvent (load) {

trace("發生 load事件");

}

onClipEvent (unload) {

trace("發生 unload事件");

}

（2）移出第二幀上的空白關鍵幀，在第 20 幀插入幀，第 21 幀插入空白關鍵幀。第 40

幀插入幀。

測試影片，觀看輸出資訊。間隔地發生 load事件和 unload事件

enterFrame 事件

在主時間軸停止播放時，影片中的影片剪輯并不會停止播放，這個特性決定了影片剪輯的另

一個事件 enterFrame的重要性。enterFrame事件是以影片剪輯幀頻不斷觸發的動作。且觸發

的頻率與 Flash影片的幀

頻一緻。enterFrame 事件首先處理與 enterFrame 影片剪輯事件關聯的動作，然後才處理附

加到受影響幀的所有動作。

enterFrame 事件其實是一個不斷執行的程式，執行的速度取決于幀頻。Flash 中預設的幀頻

是 12fps，表示播放 12 幀需要一秒的時間，利用這個原理可以制作一個簡單的計時器。

enterFrame事件制作計時器

制作：

(1) 在舞台上建立兩個動态文本,并在屬性面闆裡設定變量名為： “a_txt” 、 “b_txt” 。

在第 2 幀插入幀

(2) 插“圖層 2” ，在此圖層上用靜态文本輸入文字： “簡單記時器” ，然後轉化為影

片剪輯元件。在第 2 幀插圖入關鍵幀。

(3) 選中此執行個體，打開“動作”面闆，輸入下列代碼：

onClipEvent (load) {

_root.stop();

var i = 0;

}

//當影片載入時初始變量 i

onClipEvent (enterFrame) {

i++;

//影片進入幀時,程式每執行一次,i 加1

_root.a_txt = i;

//場景中的動态文本顯示 i 的值

_root.b_txt = Math.round(i/12*100)/100;

//把 i 除以幀頻,使 enterFrame每執行一次得到所需時間,并保留兩位數

}

（4）插入“圖層 3”在“圖層 3”建立三個按鈕執行個體，分别用作“計算” 、 “停止” 、

清除

（5）分别選中兩個按鈕，打開“動作”面闆，輸入下列代碼：

計算按鈕上的代碼：

on (press) {

gotoAndStop(2);

}

停止按鈕上的代碼：

on (press) {

gotoAndStop(1);

}

清除按鈕上的代碼：

on (press) {

i = 0;

a_txt = "";

b_txt = "";

}

（5）插入“圖層 4”在“圖層 4“的第1 幀添加代碼：

stop();

測試影片。

通過這個執行個體我們可以看到：enterFrame 事件是以影片剪輯幀頻不斷觸發的動作。且觸發

的頻率與 Flash影片的幀頻一緻。

mouseDown 事件:每次移動滑鼠時啟動此動作。 _xmouse 和_ymouse 屬性用于确定目前鼠

标位置。

mouseMove 事件:當按下滑鼠左鍵時啟動此動作

mouseUp 事件:釋放滑鼠左鍵時啟動此動作

對于這三個滑鼠響應事件，要與按鈕中的滑鼠事件差別，前者在影片的任何位置都能觸發事

件，後者一定要單擊按鈕區域才會觸發事件。

滑鼠行為控制小球

制作步驟：

（1）建立一個影片剪輯“元件 1” ，在其編輯區中給制一個小球，用放射狀填充，填充色

為#FBFBFB、#070707，居中對齊，然後把繪制好的小球轉換為影片剪輯“元件 2” 。

（2）選中元件 1 中的“元件 2” ，打開動作面闆，添加代碼：

onClipEvent (load) {

kk = false;

}

onClipEvent (mouseDown) {

kk = true;

}

onClipEvent (mouseUp) {

kk = false;

}

onClipEvent (enterFrame) {

if (kk) {

_x += (this._parent._xmouse+_x)/20;

_y += (this._parent._ymouse+_y)/20;

} else if (kk == false) {

_x += (this._parent._xmouse-_x)/20;

_y += (this._parent._ymouse-_y)/20;

}

}

（3）把“元件”1 提到場景，用任意變形工具把小球的注冊點移到垂直下移到小球外，再

用變形面闆，設定旋轉 60 度，點選複制并應用變形按鈕 5 次，複制出 5 個小球，此時 6

個小球排成一排

（4） 在屬性面闆裡分别改變小球的顔色。

（5） 測試影片。滑鼠移動，按下，釋放觀看效果。

制作簡單的 Flash塗鴉闆

（1） 建立一個影片剪輯元件。傳回主場景，打開“庫”面闆，從“庫”面闆中拖出影片剪

輯，建立一個空影片剪輯執行個體。

（2） 選中場景中的空影片剪輯執行個體，打開“動作”面闆，輸入下面代碼：

onClipEvent (mouseMove) {

if (myDraw) {

_root.lineStyle(5, 0xFF0000, 100);

_root.lineTo(_root._xmouse, _root._ymouse);

}

}

//當滑鼠移動時，沿滑鼠位置不斷畫線

onClipEvent (mouseDown) {

myDraw= true;

_root.moveTo(_root._xmouse, _root._ymouse);

}

//滑鼠按下時 myDraw為真，并在滑鼠位置定義畫線的起點

onClipEvent (mouseUp) {

myDraw = false;

}

//當滑鼠釋放時，myDraw為假，停止畫線

（3） 在舞台上建立一個按鈕，在按鈕上添加代碼 ：

on (press) {

clear()//删除所畫線

}

提示：使用 moveTo（）和 lineTo（）函數時隻需在函數中加入參數，如 moveTo(x1,y1)代

表從點（x1,y1）

處開始畫線，lineTo(x2,y2)代表畫線的終點是（(x2,y2）。使用這兩個函數之前必順先用

lineStyle（）函數定

義線的式樣。

moveTo（）功能：将目前繪畫位置移動到 (x, y)。如果缺少任何一個參數，則此方法将失敗，

并且目前繪畫位

置不改變。您可以通過建立子類來擴充 MovieClip 類的方法和事件處理函數。

lineTo（）功能： 使用目前線條樣式繪制一條從目前繪畫位置到 (x, y) 的線條； 目前繪畫

位置随後會設定為 (x,y)。如果正在其中繪制的影片剪輯包含用 Flash 繪畫工具建立的内

容，則調用 lineTo() 方法将在該内容下面進行繪制。如果在對 moveTo() 進行任何調用之

前調用了 lineTo()，則目前繪畫位置預設為 (0, 0)。如果缺少任何一個參數，則此方法将失

敗，并且目前繪畫位置不改變。

lineStyle（）功能：指定 Flash 用于後續 lineTo() 和 curveTo() 方法調用的線條樣式，在以

不同參數調用 lineStyle() 方法之前，線條樣式不會改變。可以在繪制路徑的中間調用

lineStyle() 以為路徑中的不同線段指定不同的樣式。

keyDown:當按下某個鍵時啟動此動作。使用 Key.getCode() 擷取有關最後按下的鍵的資訊

KeyUp: 當釋放某個鍵時啟動此動作。

小結：在 onClipEvent（）函數的事件中 load 事件和 enterFrame 事件是最常用，最重要的。

大家一定要

掌握好。在影片剪輯上寫指令一定要選加上 onClipEvent（）事件處理函數。就如同在按鈕

上加指令要先加 on指令。這一點大家一定要牢牢記住。

十九、複制影片剪輯

duplicateMovieClip()函數

duplicateMovieClip()函數的作用是通過複制建立的影片剪輯的執行個體。在 Flash作品中常見的

傾盆大雨、雪花飄飄、繁星點點等動畫特效，就是利用 duplicateMovieClip()函數的功能來

實作的。

腳本位置：全局函數|影片剪輯控制|duplicateMovieClip

文法格式： duplicateMovieclip(目标、新執行個體名稱、深度)；

參數意義：

? 目标：target:Object - 要複制的影片剪輯的目标路徑。此參數可以是一個字元串（例如

"my_mc"），也可以是對影片剪輯執行個體的直接引用（例如 my_mc）。能夠接受一種以上資料

類型的參數以 Object 類型列出。

? 新執行個體名稱：newname:String- 所複制的影片剪輯的唯一辨別符。

? 深度：depth:Number - 所複制的影片剪輯的唯一深度級别。深度級别是所複制的影片剪

輯的堆疊順序。這種堆疊順序很像時間軸中圖層的堆疊順序；較低深度級别的影片剪輯隐藏

在較高堆疊順序的剪輯之下。必須為每個所複制的影片剪輯配置設定一個唯一的深度級别，以防

止它替換已占用深度上的 SWF 檔案。

函數：當 SWF 檔案正在播放時，建立一個影片剪輯的執行個體。無論播放頭在原始影片剪輯

中處于什麼位置，在重複的影片剪輯中，播放頭始終從第 1 幀開始。原始影片剪輯中的變

量不會複制到重複的影片剪輯中。

在使用 duplicateMovieClip()函數時，需要注意以下幾點。

（1）複制得到的影片剪輯保持父級影片剪輯原來的所有屬性，是以，原來的影片剪輯是靜

止的，複制後的影片剪輯也是靜止的，并且一個疊放在另一個上。如果不給它們設定不同坐

标，就隻能看到編号最大的影片剪輯複本，而看不出複制的效果。

（2）原來的影片剪輯在做補間運動，那麼複制品也要做同樣的運動，并且無論播放頭在原

始影片剪輯(或“父”級)中處于什麼位置，複制的影片剪輯播放頭始終從第上幀開始。是以，

複制品和原影片剪輯始終有個時間差，是以，即使不給複制得到的影片剪輯執行個體設定坐标，

也可以看到複制品在運動。

（ 3 ） 複制得到的影片剪輯執行個體經常要與影片剪輯屬性控制 ( 特别是

_x,_y,_alpha,_rotation,_xscale,_yscale等屬性的控制)結合才能更好地發揮複制效果。

removeMovieClip()函數

通過 duplicateMovieClip()函數産生的執行個體可以通過removeMovieClip()函數進行删除 。

removeMovieClip()函數的一般形式為：

removeMovieClip(執行個體名)

複制與删除）

（1） 在舞台上繪制一朵小花，按 F8 鍵轉化為影片剪輯元件。并建立執行個體名“mc” 。

（2） 插入“圖層 2”在此圖層的第 1 幀輸入代碼：

var i=0

在場景中建立兩個按鈕，（複制按鈕和删除按鈕）。分别在兩個按鈕上輸入代碼：

on (press) {

i++;

if (i<=12) {

duplicateMovieClip("mc", "mc"+i, i);

} else {

i = 12;

}

_root["mc"+i]._x = 275+120*Math.sin(i*1/6*Math.PI);

_root["mc"+i]._y = 180+120*Math.cos(i*1/6*Math.PI);

}

on (press) {

if (i>=1) {

removeMovieClip("mc"+i);

} else {

i = 1;

}

i--;

}

attachMovie()

腳本位置：ActionScript 2.0 影片|MovieClip

|方法|attachMovie

文法格式： attachMovie(目标, 新執行個體名, 深度, [對象參數])

說明：這條語句中的四個參數，第四個參數是可選，如果不使用第四個參數，那麼它的參數

設定同 duplicateMovieClip()是一樣的，但也有一點差別，在 attachMovie（）函數中的第一

個參數隻能是字元串類型。而 duplicateMovieClip()的第一個參數，可以是一個字元串，也

可以是對影片剪輯執行個體的直接引用。

attachMovie()語句與 duplicateMovieClip()相比，優點是 attachMovie()複制的“目标”是 庫中

要附加到舞台上某影片剪輯的影片剪輯元件的連結名稱。 這是在 “連結屬性” 對話框中的 “标

識符”字段中輸入的名稱。

在上例中我們可以這樣來什麼時候修改

(1) 把舞台上小花執行個體删除。

(2)打開庫，右鍵單擊庫中的花執行個體，在彈出的連結屬性對話框中，把作為 Actionscript 導

出選項選中，在辨別符欄輸入“mc” 。

在複制按鈕上把語句改為：

on (press) {

i++;

if (i<=12) {

attachMovie("mc", "mc"+i, i);

} else {

i = 12;

}

_root["mc"+i]._x = 275+120*Math.sin(i*1/6*Math.PI);

_root["mc"+i]._y = 180+120*Math.cos(i*1/6*Math.PI);

}

梅花

（1） 打開素材源檔案。 打開庫， 分别右鍵點選落三朵梅花， 在連結屬性對話框中輸入

辨別符 “h0” 、 “h1” 、 “h2”.

（2）分别進入小花影片剪輯編輯區，在最後一幀添加語句: stop();

（3）選中場景中的梅枝影片剪輯元件，打開動作面闆添加代碼：

onClipEvent (load) {

var i = 0;

}

on (press) {

i++;

var n = random(3);

attachMovie("h"+n, "mc"+i, i);

this["mc"+i]._x = this._xmouse;

this["mc"+i]._y = this._ymouse;

this["mc"+i]._rotation = random(5)*(120);

}

奇妙的線條

（1） 建立一個名稱為“線”的的影片剪輯元件。進入其編輯區裡，在第一幀上繪制一條筆

觸高度為 1 長為 150 的白色線條。利用對齊面闆，左對齊、垂直中齊。

（2） 分别在第 10 幀、第 20 幀、第 30 幀、第 40幀插入關鍵幀。并改變第 10 幀，第 20

幀、第 30 幀上線條的着顔色，然後再把第 1 幀和第 20 幀、第 40 幀上的線條改為線

（3） 建立一個名稱為“複制線條”的影片剪輯元件。進入“複制線條”的影片剪輯元件編

輯區裡，在“圖層 1”的第 1 幀，從庫裡提進“線條”影片剪輯元件。左對齊、底對齊。

在屬性面闆裡輸入執行個體名“line” 。

（4） 插入“圖層 2” ，在此圖層寫 AS：

第一幀上的 AS：

var i = 0;

line._visible = 0;

第二幀上的 AS：

i++;

duplicateMovieClip("line", "line"+i, i);

this["line"+i]._rotation = i*3;

this["line"+i]._x = 0

this["line"+i]._y =0

第四幀上的 AS：

if (i<120) {

gotoAndPlay(2);

} else {

stop();

}

說明：在第一幀上初始化變量，在第二幀上複制線條，在第四幀上控制雪花的複制數量，如

果不加控制，就會造成死循環，最後當機。第三幀上的語句可以解釋為：如果 i<120 就跳

轉到第二幀，繼續複制，否則就跳轉到第一幀，重新複制。這種三幀循環用得很多，大家一

定要掌握。

（5） 回到主場景，從庫裡提出複制線條影片剪輯元件。測試影片。

二十、深入 startDrag()與 stopDrag()

startDrag()函數

腳本位置：全局函數|影片剪輯控制|startDrag

文法格式：startDrag(target:Object, [lock:Boolean, left:Number, top:Number,

right:Number, bottom:Number]) : Void

即： startDrag(目标，固定，左，上，右，下)

參數意義：目标（target）表示要拖動的影片剪輯的目标路徑。

固定（Lock）是一個布爾值，指定的可拖動影片剪輯是鎖定到滑鼠指針位置中央(true),還

是鎖定到使用者首次單擊該影片剪輯的位置上(false)。此參數是可選的。

Lefk、top、 right、 bottom、這四個參數分别設定影片剪輯拖動在左、上、右、下的範

圍，注意相對于影片剪輯父級坐标的值，這些值指定該影片剪輯被限制的矩形。這些參數

是可選的。

函數功能：startDrag()函數的作用是使影片剪輯執行個體在影片中播放過程中可拖動。

stopDrag()函數

腳本位置：全局函數|影片剪輯控制|startDrag

文法格式：stopDrag()

函數功能：停止目前的拖動操作。

了解 startDrag()函數中參數的作用

制作步驟

（１）在舞台上任意繪制一個圖形，選中圖形，單擊“修改”|“轉換為元件”

指令，把圖形轉換為影片剪輯元件。

（２）選中舞台上影片剪輯元件，在屬性面闆的影片剪輯的”執行個體名稱”中填入 mc。

（３）單擊“視窗”|“其它面版”|“公用庫”|“按鈕”指令，打開公用庫面闆，從中選擇

按鈕拖放到舞台中。

（4）分别在按鈕中添加如下 AS：

第 1 個按鈕中的 AS 為：

on (release) {

startDrag(_root.mc);

//實作 mc的滑鼠跟随.。效果是元件與滑鼠有間隔。

}

第 2 個按鈕中的 AS 為：

on (release) {

startDrag("_root.mc", true);

//是否鎖定參數為真。元件與滑鼠無間隔。

}

第 3 個按鈕中的 AS 為：

on (release) {

startDrag("_root.mc", true, 0, 0, 550, 400);

//寬 550 高 400 的矩形範圍内拖動

}

第 4 個按鈕中的 AS 為：

on (release) {

startDrag("_root.mc", true, 0, 100, 550, 100);

//寬 0 高為 200 的線型範圍。

}

第 5 個按鈕中的 AS 為：

on (release) {

stopDrag();

//停止 startDrag()

}

（5）、儲存測試影片，單擊不同的按鈕所産生的不同效果。注意第４個按鈕按下後就隻能點

第 5 個按鈕，之後才能點選其它按鈕．想想這是什麼原因？

說明：startDrag()可以作為影片剪輯的方法，上面示例的語句也可以這樣來寫:

以第 1 個按鈕為例：

on(release){

mc.startDrag();//實作 mc的滑鼠跟随.無參數。效果是元件與滑鼠有間隔。

幻影泡泡

1. 運作 Flash 8，背景色為黑色,其它預設。

2. 建立一個名為“泡泡圖”的圖形元件。在其編輯區裡繪制一個直徑為 100 的正圓，填充

顔色

3．建立一個名為“泡泡”的影片剪輯元件，在其編輯區“圖層 1”的第 1 幀庫裡提進圖形

元件“泡泡圖”居中對齊。接下來在第 12 幀，第 19 幀插入關鍵幀，并在第 1 幀上把泡

泡大小設為：48×48，alpha 值為：50%，第 12 幀上，大小：60×60，alpha 值為：100%。

第 19 幀上，大小：80×80，alpha 值為 0。建立動作補間動畫。在 20 幀上插入控白關鍵

幀加上停止指令：stop();。

4． 建立一個名為滑鼠的影片剪輯元件， 在其編輯區裡繪制一個滑鼠圖形。 插入 “圖層

2” ，

把“圖層 1”的第 1幀複制粘貼到“圖層 2”的第 1 幀上，并在此幀上改變填充效果。

分别在兩個圖層的第10 幀插入幀。

插入圖層 3，在圖層 3 上繪制一個如圖 12-5 所示的矩形條，組合，在第 10 幀上插入關

建幀，把矩形條移至滑鼠圖的右下方，如圖 12-6 所示。建立補間動畫。并把圖層 3 設為遮

罩。

5．回主場景，在主場景的第 1 幀上，從庫裡提進“泡泡”影片剪輯元件，輸入執行個體“mc” 。

插入“圖層 2” ，在“圖層 2”的第 1 幀上，從庫裡提進“滑鼠”影片剪輯元件，輸入實

例“ms” 。

并選中此執行個體,打開動作面闆輸入 AS 代碼：

onClipEvent (load) {

k = 1;

startDrag(_root.ms, true);

Mouse.hide();//隐藏指針

}

onClipEvent (enterFrame) {

k++;

if (k>20) {

k = 1;

}

duplicateMovieClip("_root.mc", "mc"+k, k);

msx = getProperty(_root.ms, _x);

msy = getProperty(_root.ms, _y);

setProperty(_root.mc, _x, msx-25);

setProperty(_root.mc, _y, msy-30);

}

6．制作完畢，測試儲存。

提示：Mouse.hide();//隐藏指針

腳本位置：ActionScript2.0 類|影片|Mouse| hide（Mouse.hide 方法）

拼圖遊戲

1．導入一張圖檔到舞台，調整好大小。選中圖檔，執行“修改菜單”下的“分離”指令，

然後用“直線工具”把圖檔 12 等分。

2．分别選左上角的第一份，按 F8 鍵轉化為影片剪輯元件，在“轉換為元件”對話框中設

置元件名為圖 1，注冊點居中。然後在屬性面闆裡建立執行個體名為： “mc1” 。

3．選中此影片剪輯元件，打開動作面闆，輸入如下代碼：

on (press) {

this.swapDepths(getNextHighestDepth());

startDrag(this, true);

}

on (release, rollOut) {

stopDrag();

}

4．用同樣的方法制作另外的 11 個影片剪輯。

5．制作好後，把場景中的各影片剪輯位置打亂，放在舞台的右邊。

6．插入“圖層 2” ，在些圖層的左上角放上原圖的縮略圖。作為拼圖時的參考。

代碼解釋：

（1）swapDepths（MovieClip.swapDepths 方法）

腳本位置：ActionScript2.0 類|影片|MovieClip|swapDepths

功能：交換此影片剪輯與另一影片剪輯的堆棧或深度級别（z-順序），另一影片剪輯由 target

參數指定，

或指定為目前占用由 target 參數指定的深度級别的影片剪輯。兩個影片剪輯必須具有相同

的父級影片

剪輯。

my_mc.swapDepths(depth/target);

my_mc1.onRelease=function(){

this.swapDepths(1);

}

my_mc2.onRelease=function(){

this.swapDepths(my_mc1);

}

getNextHighestDepth()

my_mc.getNextHighestDepth();

my_mc._parent.getNextHighestDepth();

（2）getNextHighestDepth（MovieClip.getNextHighestDepth 方法）

腳本位置：ActionScript2.0 類|影片|MovieClip| 方法|getNextHighestDepth

功能：以確定 Flash 将該影片剪輯呈現在目前影片剪輯中同一級和同一層上所有其它對象

的前面。

以上兩條語句大家想進一步了解，請檢視幫助。

示例 12-4 滑條控制

滑條控制是一種很有用的控制方法,比如在 MP3 播放器中,用滑條來控制音量、聲道等。下

面我們介紹

一個簡單的滑條控制

（1） 打開素材

（2） 輕按兩下庫中的“滑快 1”影片剪輯元件，進入其編輯區，選中按鈕，打開動作面闆，添

加代碼：

on (press) {

startDrag(this, true, -50,0 , 50, 0);

}

on (release, dragOut) {

stopDrag();

}

（3）輕按兩下庫中的“滑快 2”影片剪輯元件，進入其編輯區，選中按鈕，打開動作面闆，添

加代碼：

on (press) {

startDrag(this, true, 0,-50 , 0, 50);

}

on (release, dragOut) {

stopDrag();

}

（4）分别進入“橫控制條”和“縱控制條”兩個影片剪輯元件的編輯區，分别給兩個滑塊

建立執行個體名稱：

“h_mc1” 和“h_mc2” 。

（5）在場影中給橫控制條命名執行個體名“xbut” ，給橫控制條命名執行個體名“ybut” 。給紅

色正方形元件命名實

例名“mc” 。

(6)場景中的動态文本，按從上到下的順序，在屬性面闆裡依次輸入執行個體名“a_txt” 、

“b_tat” 、 “c_txt” 。

(7)選中紅矩形影片剪輯元件，打開用作面闆，添加代碼：

onClipEvent (enterFrame) {

dx = _root.xbut.h_mc1._x;

dy = _root.ybut.h_mc2._y;

xx = _root.mc._width=dx+100;

yy = _root.mc._height=dy+100;

_root.a_txt = xx;

_root.b_txt = yy;

_root.c_txt = Math.round(xx*yy);

}

二十一、for循環

for 循環語句是功能最強大，使用最靈活的一種循環語句，它不僅可以用于循環次數已經确

定的情況，還可以用于循環次數不确定而隻給出循環結束條件的情況。

腳本位置：語句|條件/循環|for

文法格式：for（初始表達式；條件表達式；遞增（或遞減）表達式）｛語句塊//或者稱循環

體｝

參數意義：

? 初始表達式： 一個在開始循環序列前要計算的表達式， 通常為指派表達式。 此參數還

允許使用 var 語

句。為指派表達式時。推薦使用 var 可以使運作加快。其原理主要是使用了本地變量。

? 條件表達式： 計算結果為 true 或 false 的表達式。在每次循環疊代前計算該條件；當

條件的計算結果為 false 時退出循環。

? 遞增（或遞減）表達式： 在每次循環疊代後要計算的表達式；通常為使用 ++（遞增）

或 --（遞減）運算符的指派表達式。

? 語句塊。在大括号内的所有指令組。統稱循環體。

說明：for 語句中的三個表達式，中間用分号隔開。第一個初始表達式通常用來設定語句循

環執行次數的變量初值，這個表達式隻會執行一次； 第二個條件表達式通常是一個關系表達

式或者邏輯表達式， 用來判定循環是否繼續； 第三個遞增表達式是每次執行完 “循環體語句”

以後，就會執行的語句，通常都是用來增加或者減少變量初值。

for 語句的執行流程圖 for 求和

(1) 在場景中制作一個如圖的界面 (2) 在屬性面闆裡分别給三個動太文本輸入為量名“a_txt” 、 “b_txt” 、 “c_txt”

(3) 選中按鈕，打開動作面闆，添加代碼：

on (release) {

k1 = 0;

k2 = 0;

a_txt = 0;

b_txt = 0;

c_txt = 0;

for (i=1; i<=100; i += 2) {

k1 += i;

k2 += i+1;

a_txt = k1;

b_txt = k2;

c_txt = k1+k2;

}

}

注意：

1．用類似形式可以友善的控制循環的次數，此例中，100 就是循環的次數。

2． 循環體内可以使用”i”的值參與運算。有時這種參與是非常必要的。

3． 三個表達式内部用“;”分割。

提示：

（1）for 循環結構的原理如下，它首先計算一次表達式 1，然後按照以下順序開始循環序

列：隻要表達式 2 的計算結果為 true，就執行循環體，然後計算下一個表達式。

使用 for 循環語句的注意事項

1．為了使程式效率更高，在初始表達式中使用 var 關鍵字來聲明變量。

2．在初始表達式中可以定義多個變量，兩個表達式中間用逗号（，）分開，如：

for (var i = 1, sun = 0; i<=100; i++) {

sun = sun+i;

}

trace(sun);

3．初始表達式也可以省略，但必順在 for 語句前初始化變量，如：

var i=0

var sun = 0;

for (; i<=100; i++) {

sun = sun+i;

}

trace(sun);

注意：當省略初始表達式時，其後的分号不能省略。

4．遞增表達式也可以省略，但必順保正循環能正常結速，如：

var sun = 0;

for (var i = 0; i<=100; ) {

sun = sun+i;

i += 1;

}

trace(sun);

5．for 語句中可以同時省略初始表達式和遞增表達式，如：

var i=1

var sun = 0;

for (; i<=100;) {

sun = sun+i;

i+=1;

}

trace(sun);

這時程式和 while 完全一樣，是以可以用 for 來代替 while 語句，也就是說 for 語句的功

能比 while 語句強大得多。

煙花

本例是實作一個煙花效果。滑鼠點選後，會綻放一朵燦爛煙花。而煙花由小流星複制而成。

複制的個數由循環語句來控制的。

1．建立文檔，背景黑色。其它預設。

2．建立一個名為“禮花 1”的影片剪輯元件，在此元件的第 1 幀繪制一個流星式的圖形。

3．在第 10 幀處插入關鍵幀，把繪制的圖形右移，并适當放大。

4．在第 19 幀插入空白關鍵幀，任意繪制一個圖形，位置相對第 10 幀上的圖形的右移

5．建立每兩關鍵幀之間的形狀補間動畫。

6．在庫中右鍵點選“煙花 1”影片剪輯元件，在快捷菜單中選擇“連結”選項，在彈出的

“連結屬性”對話框中輸入辨別符 yh1

7．在庫中右鍵點選“煙花 1”影片剪輯元件，在快捷菜單中選擇“直接複制 ”選項，在彈

出的“直接複制元件”的對話框中把元件名改為“煙花 2” 。

8．用同樣的方法在制作另一朵煙花，（顔色與式樣最好以第一朵有所差別）并設定标認符為

“yh2” 。

9．導入一個煙花聲音檔案到庫，右鍵點選聲音檔案，在快捷菜單中選擇“連結”選項，在

連結屬性對話框中設定聲音辨別任為“Sound” 。

10．建立一個空影片剪輯，拖入場景。場景中它顯示為一個空心小白點。用“黑箭頭工具”

選中該小白點，打開動作面闆，添加 AS 代碼：

onClipEvent (load) {

var k = 1;

mySound= new Sound();//建立一個聲音對象

mySound.attachSound("Sound");//把庫中的聲音檔案附加到所建立的聲音對象上

}

onClipEvent (mouseDown) {

k=-k;

mySound.start();//播放聲音

for (var i = 1; i<=100; i++) {

if (k == 1) {

this.attachMovie("yha", "yh"+i, i);

} else {

this.attachMovie("yhb", "yh"+i, i);

}

this["yh"+i]._x = _xmouse;

this["yh"+i]._y = _ymouse;

this["yh"+i]._rotation = random(360);

this["yh"+i]._xscale = random(50)+10;

this["yh"+i]._yscale = random(50)+10;

}

}

複制跟随

1．建立文檔，背景黑色。

2．建立一個名為“心 1”影片剪輯元件，在其編輯區内繪制一個“心圖”形。

3．建立一個名為“心 2”影片剪輯元件，把“心1”提進其編輯區内，居中對齊。選中“心

2”濾鏡面闆裡添加發光濾鏡效果。

4．在“連結屬性”對話框中設定影片剪輯“心 2”的辨別符為“mc” 。

5．建立一個名為“空”的影片剪輯元件，拖入場景，選中此空影片剪輯元件，輸入 AS：

onClipEvent (load) {

for (var i = 1; i<=20; i++) {

_root.attachMovie("mc", "mc"+i, 20-i);

_root["mc"+i]._xscale = 100-i*3;

_root["mc"+i]._yscale = 100-i*3;

_root["mc"+i]._alpha = 100-i*5;

}

}

onClipEvent (enterFrame) {

for (var i = 1; i<=20; i++) {

if (i == 1) {

startDrag(_root["mc"+i], true);

} else {

var zx = _root["mc"+(i-1)]._x-_root["mc"+i]._x;

var zy = _root["mc"+(i-1)]._y-_root["mc"+i]._y;

_root["mc"+i]._x = _root["mc"+i]._x+zx/4+zx/10;

_root["mc"+i]._y = _root["mc"+i]._y+zy/4+zy/10;

}

}

}

二十二、while與 do while循環

在程式設計的許多問題中都要用到循環結構,比如要對 10 個數字的排序,兩個數字之間的比較,如

果采用選擇結構,進行的條件分支非常多,是以寫的代碼也相當長,利用循環結構可快速解決

這個問題,大大提高程式的效率.

ActionScript 語言中可通過四種語句實作程式的循環,分别是 while、do...while、for 循環和

for in 循環語句.它們與 if 語句的最大差別在于隻要條件成立,循環裡面的程式語句就會不

斷地重複執行.而 if語句中的程式代碼隻可能被執行一次.

while 的格式如下：

while(條件表達式) {

循環體;

}

說明:在運作語句塊之前，首先測試條件表達式；如果該測試傳回 true，則運作該語句塊。

如果該條件為 false，則跳過該語句塊，并執行 while 動作語句塊之後的第一條語句。其流

程圖如圖所示. 通常當計數器變量小于某指定值時， 使用循環執行動作。 在每個循環的結尾遞增計數器的值，

直到達到指定值為止。此時，件條表達式的傳回值不再為 true，且循環結束。

求 1 + 2+ 3+…+100 的和

建立一個 FLASH 文檔，在第一幀打開動作面闆，輸入下列代碼：

var i = 1;

var sum = 0;

while (i<=100) {

sum += i;

i++;

}

trace(sum)

代碼執行過程：

在上面的循環程式中，變量 i 的初始值是 1，表達式 i<=100 為真，變量 sum 加上 1，然

後 i+1 等于 2。再進行 i<=100 的判斷，條件真，sum 再加上 2，i 又加上 2 等于 3，這樣

循環執行，i 一直自加到 101，此時條件 i<=100 為假，結束循環。這樣程式共進行了 100

次判斷，也就是進行了 100 次循環，100 次執行表達式 sum+=i，這樣就算出了 1+2+3+…

+100 和。

注意：在循環結構中，應該有使循環趨于結束的語句，在本例的代碼中，用變量 i 來控制，

i 不斷遞加到 101，使條件為假，結束循環。

在前面我們知道 enterFrame 事件也是循環執行的，但是循環結構的執行要快行多，我們通

過下面的小程控來測試 while語句的執行速度：

var t = getTimer()/1000;//開始時間以秒為機關

var i = 0;

while (i<1000) {

i++

}//進行 100 次循環

trace(getTimer()/1000-t+"秒");

//結束時間減去開始時間,即循環所需時間.

用 while語句優化代碼

大家還記得在第十四課中我們用加法指派作了一個滑鼠跟随效果， 當時每個字我們都要分别

設定它的_x 和_y。如果有 10個字就要寫 20 行語句，如果 100 個字呢，那不是就很麻煩

嗎？我們用 while就可以把代碼優化了。

打開第十四課滑鼠跟随特效源檔案，把第 1 幀上的代碼删除，選中第 1 個字的影片

剪輯元件，打開動作面闆，輸入代碼：

onClipEvent (enter Frame) {

var i = 1;

while (i<=6) {

_root.mc1._x += (_root._xmouse-_x)/5;

_root.mc1._y += (_root._ymouse-_y)/5;

_root["mc"+i]._x += (_root["mc"+(i-1)]._x-_root["mc"+i]._x)/5+8;

_root["mc"+i]._y += (_root["mc"+(i-1)]._y-_root["mc"+i]._y)/5;

i++;

}

}

說明：

（1）如果字的個數增加了，隻需改條件即可，例如是 10 個字，那麼隻需把條件 i<=6 改為

i<=10 就可以了。

（2）由于我們用了 enter Frame事件，是以第 2 幀就可以不要了。

用 while循環實作批量複制影片剪輯

打開源檔案，場景第一幀加上代碼：

var i = 1;

var num = 5;

while (i<=num) {

attachMovie("qiu", "qiu"+i, i);

_root["qiu"+i]._x = Stage.width/6*i;

_root["qiu"+i]._y = Stage.height/2

_root["qiu"+i+".txt"] = "qiu"+i;

i++;

}

這段代碼作用是複制5 個影片剪輯執行個體，執行個體名分别為 qiu1、qiu2、qiu3、qiu4、qiu5，并

實作橫向等距離排列。要實作同樣的交果，代碼的寫法有很多，如：

var i = 0

var num = 5;

while (i++<num) {

attachMovie("qiu", "qiu"+i, i);

_root["qiu"+i]._x = Stage.width/6*i;

_root["qiu"+i]._y = Stage.height/2;

_root["qiu"+i+".txt"] = "qiu"+i;

}

或者這樣寫：

var i = 1

var num = 5;

while (i<=num) {

attachMovie("qiu", "qiu"+i++, i);

_root["qiu"+(i-1)]._x = Stage.width/6*(i-1);

_root["qiu"+(i-1)]._y = Stage.height/2;

_root["qiu"+(i-1)+".txt"] = "qiu"+(i-1);

}

dowhile語句：

do while 語句的格式

do {

循環體;

} while(條件表達式)

說明：和 while 循環語句相反，do while 循環語句是一種先斬後奏的循環語句。不管怎樣

do{“和”}之間的程式至少要執行一次，然後再判斷條件是否要繼續循環。如果 while()裡

的條件成立，它繼續執行 do 裡面的程式語句，直到條件不成立為止。其流程圖如圖 用 do while 語句求和

同樣的累加問題：1+2+3+…+100，用 do while語句程式為：

var i = 1;

var sum = 0;

do {

sum = sum+i;

i++;

} while (i<=100);

trace(sum);

程式中的 i 不一定隻能加 1，可能加上任意數，比如求 100 以内的偶數之和，用這程這樣

表示：

var i = 1;

var sum = 0;

do {

sum += i;

} while ((i += 2)<=100);

trace(sum);

差別 whi le與 dowhile 語句

（1） 選中第 1 幀，打開動作面闆，輸入下列代碼；

var i=1

var j=5

（2） 在場景中建立兩個按鈕執行個體，分别測試兩種語句的結果，兩個按鈕上的語句分别為；

on (press) {

while (i<j) {

i++;

}

trace(i);

}

on (press) {do {

i++

} while (i<j);

trace(i)

}

（3） 測試影片，不斷地單擊按鈕

從輸出面闆可以看出，當程式第一次執行時，就是第一次單擊按鈕時，。結果都是一樣，都

是數字 5。 但多單擊一次時， while 語句結果還是 5， 而 do while 語句的測試結果不斷加 1，

原因是 do while 語句先執行程式， 再進行條件判斷， 是以從第二次單擊按鈕開始， 變量 i 就

加 1。

小結：

while 與 do_while 結構都可以按照一定的條件循環執行循環體,wihle 結構先判定循環條件,

當條件符合時就執行循環體,按順序執行完循環體中的語句後,在傳回 wihle 語句開始處,重新

判定條件,并以此規則進行循環操作,直到循環條件為 false時終止循環,轉而執行 wihle 結構

下面的指令,與 wihle 結構不同的是 do_while 循環結構先執行循環體中的語句,然後判定循

環條件.這就是說 do_while循環結構無論條件是否符合,循環至少執行一次.

二十三、循環語句的嵌套

一個循環體内包含另一個循環體結構，稱為循環的嵌套．在這一講中我們介紹 for 語句的嵌套、for 與while語句的嵌套。

二個for嵌套（乘法九九表）

（1）在舞台上建立一個動态文本，變量名為： “sir”

(2)插入“圖層 2”在此第 1 幀輸入代碼：

var str:String = "";

for (var i = 1; i<=9; i++) {

for (var j = 1; j<=i; j++) {

var k = i*j;

str = str+i+"×"+j+"="+k+(k<10 ? "  " : " ")+(j == i ? "\n" : "");

}

}

三個f or嵌套（求水仙花數）

提示：所謂的“水仙花數” ，是指一個三位數，其各位數字的立方和等于該數本身，例如：153 是一個，“水仙花數” ，因為153 等于 1的立方加上 5 的立方加上 3 的立方。程式如下：

var str:String = "";

var n = 0;

for (var i = 1; i<=9; i++) {

for (var j = 0; j<=9; j++) {

for (var k = 0; k<=9; k++) {

m = i*100+j*10+k;

if(m == i*i*i+j*j*j+k*k*k) {

n++;

str = str+m+(n == 0 ? "  " : " ");

}

}

}

}

for語句可以和while語句嵌套使用。（因數分解）

下面我們做一個因數分解的程式。這個執行個體子 for 語句可以和 while語句嵌套。

（1） 在舞台上建立一個輸入文本， 變量名為： “my_txt1” ,再建立一個動态文本， 變量名為： “my_txt2” 。

（2） 建立兩個按鈕執行個體，分别用來做分解計算和清空

（3） 添加代碼：

“分解”按鈕上的代碼：

on (release) {

         m = Number(my_txt1);

         var str:String = m+"=";

         var flag = 1;

         for (i=2; i<m; i++) {

                   while (m%i == 0) {

                            if (flag == 1) {

                                     str = str+""+i;

                                     flag = 0;

                            } else {

                                     str = str+"×"+i;

                            }

                            m = m/i;

                   }

         }

         if (m != 1) {

                   str = str+"×"+m;

         }

         my_txt2 = str;

}

清空按鈕上的代碼：

on (release) {

my_txt1 = "";

my_txt2 = "";

}

嵌套複制

（1）打開素材源檔案。

（2）選中複制按鈕，打開動作腳本面闆，添加代碼：

on (release) {

for (i=1; i<=4; i++) {

for (j=1; j<=4; j++) {

duplicateMovieClip("mc", "mc"+i+j, i*4+j);

this["mc"+i+j]._x = (i-1)*100;

this["mc"+i+j]._y = (j-1)*100;

this["mc"+i+j+".txt"] = "mc"+i+j;

}

}

}

（3）選中删除按鈕，打開動作在闆，添加代碼：

on (release) {

for (i=1; i<=4; i++) {

for (j=1; j<=4; j++) {

removeMovieClip("mc"+i+j);

}

}

}

說明：本課中的執行個體理論性較強，牽涉的數學知識較多

二十四、元件

元件是擁有已定義了參數的複雜影片剪輯，這些參數在文檔創作時設定。通過參數的設定和使用，我們可以修改元件的外觀和行為。每個元件都有自己的AS方法，允許我們設定和修改其選項。

    FLASH提供幾類元件，它包括資料元件、多媒體元件、UI元件。使用元件時，我們可以使用動作腳本方法添加元件，也可以按下Ctrl+F7組合鍵打開元件面闆。

元件的添加和參數設定

  使用元件面闆來選擇添加元件，按下Ctrl+F7組合鍵，打開元件面闆，将需要的元件拖到場景中。打開屬性面闆，就可以在屬性面闆中的參數頁籤中為元件添加參數，并為元件命名和設定元件尺寸及位置。屬性面闆中的ComboBox元件參數頁籤如圖所示

也可以按Alt+F7組合鍵打開元件檢查器，如圖所示，我們可以對元件進行設定。

 建立ComboBox元件

下面通過使用元件面闆來建立元件。

1、按下Ctrl+F7組合鍵，打開元件面闆，選擇UI元件類中的ComboBox元件，将它拖入場景中。

2、打開屬性面闆，在屬性面闆中的參數頁籤中為元件添加參數。選擇labels項，單擊labels右面的資料欄，彈出值對話框

3、在值對話框中輸入資料項參數。

4、選擇rowCount行數項，輸入所需要的行數

測試效果

用程式指令控制元件

 用程式指令處理元件時事件，有兩種方法：一種使用on()函數控制元件，另一種使用Click元件偵聽器控制元件。使用on()函數控制元件是FLASH傳統的程式設計思想，容易了解和掌握。使用Click元件偵聽器控制元件，是FLASH提倡使用的程式設計思想，這種方法更符合面向對象的程式設計特性，程式更安全，功能更強。

使用on()函數控制元件

1、建立元件對象。按下Ctrl+F7組合鍵，打開元件面闆，選擇UI元件類中的RadioButton元件，将它拖入場景中。

2、打開屬性面闆，在屬性面闆的參數頁籤中為元件添加參數。選擇label資料項，在右面的數值欄中輸入"選擇"

3、對元件進行程式設計。選中元件，打開動作面闆，輸入幀指令：

on(click){

trace("選擇正确");

}

測試影片，單擊"選擇"按鈕，将在輸出面闆中輸出"選擇正确"字樣

使用元件偵聽器控制元件

将上例中控制元件的on()函數去掉，改為使用元件偵聽器控制元件

1、選中場景中的元件，打開屬性面闆，在屬性面闆左邊，輸入元件執行個體名為"hack"。

2、選擇第一幀，輸入幀指令：

zt=new Object();//建立偵聽器對象

zt.click=function(){

trace("選擇正确");

};//為偵聽器對象上的click定義一個函數

hack.addEventListener("click",zt);//将元件名為hack的元件注冊到偵聽對象

元件應用

利用元件制作選擇題

1、按下Ctrl+F7組合鍵，打開元件面闆，選擇UI元件類中的RadioButton元件，将它拖入場景中。并複制一個RadioButton元件。在場景中建立選擇題畫面

2、選擇左邊的RadioButten元件，打開屬性面闆，在屬性面闆的參數頁籤中為元件修改參數。

在寬度欄輸入60，将該元件的寬度改為60像素寬。

下面我們來解釋下該元件的參數作用：

data資料參數：在資料參數欄輸入資料15，這個資料将會作為選擇題的判斷依據。

label标簽參數：将标簽參數改為"對"。

groupName組名參數:它是很重要的參數，擁有相同組名的單選按鈕，同時隻能有一個被選中，這樣在同一組内就不會出現多個選擇。在這個參數欄輸入a1。

選擇右邊的RadioButten元件，在寬度欄同樣輸入60，将該元件的寬度改成了40像素寬。右邊的label标簽采納數欄改成"錯",資料欄data中輸入資料"13",這個資料将會作為選擇題的判斷依據，在組名參數欄輸入a1

3、選擇右下方的文本框，打開屬性面闆，在左邊的文本類型欄中選擇動态文本，在文本類型欄下面輸入文本框名為"txt"

4、插入新的圖層，作為AS層，選中第一幀，輸入幀指令：

Listener=new Object();//建立偵聽對象

Listener.click=function(hk){//建立偵聽對象的click事件函數

if(15==hk.target.selection.data){//判斷單選按鈕元件中資料欄中的數值是不是等于15

txt.text="選擇正确";//如果等于15，将"選擇正确"賦予txt文本變量

}else{

txt.text="選擇錯誤";//如果不等于15，将"選擇錯誤"賦予txt文本變量

}

};

a1.addEventListener("click",Listener);//将組名為"a1"的單選按鈕注冊到偵聽對象

測試影片

二十五、播放器控制與網頁連接配接以及動畫釋出輸出

fscommand指令

fscommand指令是一個非常強大的浏覽器與網絡動作指令。它可以讓FLASH影片能夠與FLASH播放器或者承載FLASH播放器的程式進行通信。還可以将消息傳遞給其他應用程式(比如VB、C++等),它的文法格式如下：

fscommand(command:String,parameters:String):Void

fscommand指令包含兩個參數，即command和parameters，各自的意義如下：

"command:String"是傳遞給主機應用程式用于任何用途的一個字元串，或者傳遞給FLASH播放器的一個指令.

"parameters:String"是傳遞給主機應用程式用于任何用途的一個字元串，或者傳遞給FLASH播放器的一個值。

如果要把消息發送給獨立的播放器就需要使用到系統内置的六個指令和參數。這六個指令和參數在使用腳本助手添加fscommand指令時，可以進行選擇

系統内置的六個指令和參數的具體說明如下：

command                     parameters                            說明

fullscreen                    true或者false  打開FLASH動畫時是否進行全屏播放，true表示全屏播放

allowscale                   true或者false   是否允許使用者在縮放動畫播放視窗的同時改變FLASH檔案中的對象大小

showmenu                  true或者false  選擇false就隐藏了"設定"和"關于Flash Player"以外的所有右鍵菜單

trapallkeys                   true或者false           設定為true就可以鎖定所有的鍵盤輸入，使所有的快捷鍵都無效

exec                      應用程式的路徑          在可播放FLASH檔案的非FLASH播放器中調入并執行應用程式(.exe .com或者.bat)

quit                              無                 關閉可播放FLASH檔案的播放器視窗

關于以上指令的用法大家看下面的語句：

fscommand("fullscreen","true");//打開FLASH檔案自動進行全屏播放

fscommand("allowscale","true");//允許對FLASH檔案中的對象進行縮放

fscommand("showmenu","false");//隐藏主要的FLASH右鍵菜單

fscommand("trapallkeys","true");//鍵盤的輸入對FLASH播放器無效

fscommand("exec", "C:\\WINDOWS\\system32\\calc.exe");//調用應用程式"電腦"

fscommand("quit");//關閉FLASH播放器視窗

FLASH動畫的釋出

1、釋出設定

2、輸出視訊檔案

3、輸出圖像檔案

二十六、loadVariables指令

一．  loadMovie指令

1.loadMovie指令可以将外部的SWF動畫或者圖檔檔案加載到FLASH影片中。

loadMovie指令文法格式：

loadMovie(url:String,target:Object/String, [method:String]):Void

此指令包含三個參數：url  target  method

url:String 要加載的swf檔案或者圖檔檔案所在的路徑

target:Object/String 對影片剪輯的引用或者目标影片剪輯路徑的字元串。

method:String 指定用于發送變量的HTTP方法，這個參數必須時字元串GET或者POST。如果沒有要發送的變量，就省略這個參數。GET方法用于發送少量的變量，POST方法用于發送長字元串的變量。

2.使用loadMovie加載影片

我們可以使用loadMovie指令加載外部的SWF檔案

loadMovie(“1.swf”,_root.mc)

3．使用loadMovie加載圖檔

       loadMovie(“1.jpg”,_root.mc)

二．  loadVariables指令

使用loadVariables指令可以從外部檔案中讀取資料，并設定影片剪輯中變量的值，比如設定影片剪輯中動态文本框的變量。外部檔案可以是ASP JSP PHP等腳本生成的檔案。

  loadVariables(url:String,target:Object,[method:String]):Void

此指令包含三個參數：url  target  method

url:String 要加載變量所處位置的絕對路徑或者相對的url

target:Object 指向接收所加載變量的影片剪輯的目标路徑

method:String 指定用于發送變量的HTTP方法，這個參數必須時字元串GET或者POST。如果沒有要發送的變量，就省略這個參數。GET方法用于發送少量的變量，POST方法用于發送長字元串的變量。

  loadVariables(“aa.txt”,_root.mc);

三．  loadVariablesNum指令

  使用loadVariablesNum指令可以從外部檔案中讀取資料，并且可以設定播放器的級别中的變量的值。

loadVariablesNum(url:String,level:Number, [method:String]):Void

其中level是一個整數，用來指定FLASH播放器接收這些變量的級别

var tu = ["1.jpg", "2.jpg", "3.jpg", "4.jpg"];

var i = 0;

function show() {

         _root.createEmptyMovieClip("pic", 0);

         _root.pic.loadMovie(tu[i]);

         _root.pic._alpha = 0;

         _root.pic._xscale=10;

         _root.pic._yscale=10;

         i++;

         i%=4;

         _root.onEnterFrame = function() {

                   _root.pic._alpha += 7;

                   _root.pic._xscale += 5;

                   _root.pic._yscale += 5;

                   if (_root.pic._alpha>=100) {

                            delete _root.onEnterFrame;

                   }

         };

}

onMouseDown = function () {

         show();

};

二十七、影片剪輯的深度

1.        getDepth方法

 getDepth方法可以傳回影片剪輯執行個體的深度值

mc. getDepth();

mc是影片剪輯的執行個體名稱，getDepth傳回的是一個整數，表示影片剪輯所在的深度

2．getInstanceAtDepth方法

 我們可以使用getInstanceAtDepth方法來傳回指定深度上的影片剪輯執行個體。通過此來檢視指定的深度是否已經被占用。

mc. getInstanceAtDepth(depth);

mc是所要檢查的範圍，depth是整數，用來檢查mc中指定深度級别。如果這個深度上沒有影片剪輯執行個體。那麼就傳回undefined.

3．getNextHighestDepth方法

getNextHighestDepth方法可以傳回下一個可用的最大深度值。

mc. getNextHighestDepth();

傳回的是一個整數。代表可用最大深度值。

4．影片剪輯深度的交換

如果要将一個影片剪輯移到另一個影片剪輯的前面或者後面，可用使用swapDepths方法來交換兩個影片剪輯的深度。

mc.swapDepths(depth/target);

mc指的是要與其他執行個體交換深度的執行個體名稱，如果執行個體名稱是depth，那麼就表示mc和深度是depth上的執行個體交換深度。如果參數是target，表示mc與執行個體target交換深度

num = 7;//加載圖檔的數量

a = 275;//圖檔做橢圓形運動的X軸的中心

b = 200;//圖檔做橢圓形運動的Y軸的中心

rx =190;//圖檔做橢圓形運動的X軸的半徑

ry = 50;//圖檔做橢圓形運動的Y軸的半徑

n = 0;//用來計算運動速度的角度值

angle=0;//用來計算運動速度的弧度值

speed=0;//計算圖檔響應滑鼠運動的速度增量

for (i=1; i<=num; i++) {//從庫中将辨別符為mc的元件附加到舞台

         _root.attachMovie("mc", "mc"+i, i);

}

if (_xmouse>50 && _xmouse<500 && _ymouse>50 && _ymouse<350) {

         speed = (275-_xmouse)*.08;

         n += speed;

} else {

         n = (n<360) ? n+1 : 1;

}

for (i=1; i<=num; i++) {

         angle = (i*360/num+n)*Math.PI/180;

         _root["mc"+i]._x = a-rx*Math.cos(angle);

         _root["mc"+i]._y = b-ry*Math.sin(angle);

         _root["mc"+i]._xscale = 10-100*Math.sin(angle);

         _root["mc"+i]._yscale = 100-10*Math.sin(angle);

         if (_root["mc"+i]._y>200) {

                  _root["mc"+i].swapDepths(100+i);

         } else {

                  _root["mc"+i].swapDepths(10-i);

         }

         _root["mc"+i].gotoAndStop(i);

}

gotoAndPlay(2);

二十八、文本框

1.       文本框的類型

2.       動态文本框

3.       輸入文本框

影片剪輯的第一幀的腳本：

textarea=textshow.substring(0,index)+"_";

index++;

if(index>textshow.length)

stop();

gotoAndPlay(Math.ceil(Math.random()*5)+5);

gotoAndPlay(1);

影片剪輯screen上的腳本：

onClipEvent(load)

{

textshow=new String;

textshow="請在下方區域輸入文字";

index=1;

}

播放按鈕上的：

on(press)

{

screen.textshow=textinput;

screen.index=1;

screen.gotoAndPlay(1);

}

二十九、超文本标簽

1.       超連結标簽<a>

href和target屬性

2.       粗體标簽<b>

     3．斜體标簽<i>

     4．換行标簽<br>

     5．字型标簽<font>

     color  face  size

     6．清單項标簽<li>

     7．段落标簽<p>

     align  class

     8．下劃線标簽<u>

     9．圖像标簽<img>

     src  id   width   height    align    hspace    vspace

mytxt.html = true;

xin1.html = true;

xin2.html = true;

xin3.html = true;

xin4.html = true;

xin5.html = true;

xin6.html = true;

mytxt.htmlText = " <img src=\'pic/heart.jpg\' id=\'mypic\'>";

xin1.htmlText = " <img src=\'pic/twoheart.jpg\' id=\'p1\'>";

xin2.htmlText = " <img src=\'pic/twoheart.jpg\' id=\'p2\'>";

xin3.htmlText = " <img src=\'pic/twoheart.jpg\' id=\'p3\'>";

xin4.htmlText = " <img src=\'pic/twoheart.jpg\' id=\'p4\'>";

xin5.htmlText = " <img src=\'pic/twoheart.jpg\' id=\'p5\'>";

xin6.htmlText = " <img src=\'pic/twoheart.jpg\' id=\'p6\'>";

onEnterFrame = function () {

       mytxt.mypic._x += 8;

       mytxt.mypic._alpha -= 5;

       if ((mytxt.mypic._x)>=600) {

              mytxt.mypic._x = -340;

       }

       if ((mytxt.mypic._alpha)<=0) {

              mytxt.mypic._alpha = 100;

       }

       xin1.p1._alpha -= 6;

       if ((xin1.p1._alpha)<=0) {

              xin1.p1._alpha = 100;

       }

       xin2.p2._alpha -= 4;

       if ((xin2.p2._alpha)<=0) {

              xin2.p2._alpha = 100;

       }

       xin3.p3._alpha -= 2;

       if ((xin3.p3._alpha)<=0) {

              xin3.p3._alpha = 100;

       }

       xin4.p4._alpha -= 6;

       if ((xin4.p4._alpha)<=0) {

              xin4.p4._alpha = 100;

       }

       xin5.p5._alpha -= 4;

       if ((xin5.p5._alpha)<=0) {

              xin5.p5._alpha = 100;

       }

       xin6.p6._alpha -= 2;

       if ((xin6.p6._alpha)<=0) {

              xin6.p6._alpha = 100;

       }

};

titletxt.html=true;

titletxt.htmlText="<font color=\'#6600ff\' face=\'隸書\' ><i>浪漫情人節<i></font>";

三十、TextField類

1．  TextField類的屬性

text 文本框中顯示的文本

type 文本框的類型，dynamic是動态文本框，input是輸入文本框

autoSize 控制文本字段的自動大小調整和對齊

background 文本字段是否有背景填充

backgroundColor 文本字段背景的顔色

border 文本字段是否具有邊框

borderColor 文本字段邊框的顔色

bottomScroll 文本字段中目前可見的最後一行

hscroll 文本框的目前水準滾動位置

html 文本字段是否起用html格式

htmlText文本框包含的html形式的文本内容

length傳回文本框的字元數

maxChars 文本框最多可以容納的字元數

multiline 文本框是否顯示多行文字

password　文本框輸入的内容是否用＊表示

scroll　傳回文本框目前滾動位置

selectable 文本框是否可以選擇

_url 在文本框中指定url連結

variable 傳回與文本框相關聯的變量名

wordWrap 指定文本框是否換行

restrict 使用者輸入到文本字段中的字元集

2．  TextField類的方法

TextField.addListener()  注冊一個對象

TextField.getFontList() 以數組的形式傳回播放器的主機系統上的字型名稱

TextField.getDepth() 傳回文本框的深度

TextField.getNewTextFormat() 擷取配置設定給新插入文本的預設文本格式

TextField.getTextFormat() 傳回一個字元或整個文本框的文本格式

TextField.reMoveListener() 删除偵聽器對象

TextField.reMoveTextField() 删除使用MovieClip.createTextField()建立的文本框

TextField.replaceSel() 替換目前所選的内容

TextField.setNewTextFormat() 設定文本格式

TextField.setTextFormat() 為文本框中指定的文本設定格式

TextField.replaceText() 替換文本框中指定的文本

mc.createTexeField(instanceName,depth,x,y,width,height);

var i = 0;

var count = 0;

_root.onEnterFrame = function() {

   count++;

   count %= 5;

   if (count == 0) {

      _root.createTextField("txt"+i, i, 25+500*Math.random(), 0, 12, 12);

      with (_root["txt"+i]) {

         text = String.fromCharCode(Math.floor(26*Math.random())+65);

         autoSize = "center";

         type = "dynamic";

         textColor = 0x0000FF;

         border = true;

         borderColor = 0x999999;

         background = true;

         backgroundColor = 0xDDDDDD;

      }

      i++;

   }

   for (var j in _root) {

      _root[j]._y += 5;

      if (_root[j]._y>400) {

         _root[j].removeTextField();

      }

   }

};

_root.onKeyDown = function() {

   for (var j in _root) {

      if (_root[j].text == String.fromCharCode(Key.getCode())) {

         _root[j].text = "PASS";

         _root[j].textColor = 0xFF0000;

         _root[j].borderColor = 0xFF0000;

         _root[j].backgroundColor = 0xFFFF00;

         break;

      }

   }

};

Key.addListener(_root);