FLASH动做脚本详解

FLASH动做脚本详解

1、FLASH脚本基础入门讲解

2、按钮AS的编写

3、影片剪辑的AS编写

4、动态文本框

5、影片剪辑的拖拽

6、流程控制与循环语句

7、绘图及颜色的AS的编写

8、声音 AS 的编写与控制

9、时间日期的 AS编写

10、点语法以及路径

11、深刻了解时间控制

12、无条件转移

十3、变量

十4、运算符（一）

十5、变量（二）

十6、影片剪辑的属性

十7、再讲循环语句

十8、影片剪辑处理函数

十9、复制影片剪辑

二10、深刻 startDrag()与 stopDrag()

二11、for循环

二12、while与 do while循环

二十3、循环语句的嵌套

二十4、组件

二十5、播放器控制与网页链接以及动画发布输出

二十6、loadVariables命令

二十7、影片剪辑的深度

二十8、文本框

二十9、超文本标签

1、FLASH脚本基础入门讲解

认识“动做”面板
　 在Flash中，动做脚本的编写，都是在“动做”面板的编辑环境中进行，熟悉“动做”面板是十分必要的。
按【F9】键调出“动做”面板，能够看到“动做”面板的编辑环境由左右两部分组成。左侧部分又分为上下两个窗口。。
左侧的上方是一个“动做”工具箱，单击前面的图标展开每个条目，能够显示出对应条目下的动做脚本语句元素，双击选中的语句便可将其添加到编辑窗口。
　　 下方是一个“脚本”导航器。里面列出了FLA文件中具备关联动做脚本的帧位置和对象；单击脚本导航器中的某一项目，与该项目相关联的脚本则会出如今“脚本”窗口中，而且场景上的播放头也将移到时间轴上的对应位置上。双击脚本导航器中的某一项，则该脚本会被固定。
　　 右侧部分是“脚本”编辑窗口，这是添加代码的区域。能够直接在“脚本”窗口中编辑动做、输入动做参数或删除动做。也能够双击“动做”工具箱中的某一项或“脚本编辑”窗口上方的【添加脚本】工具 ，向“脚本”窗口添加动做。

　　在“脚本”编辑窗口的上面，有一排工具图标，在编辑脚本的时候，能够方便适时的使用它们的功能。

 

　　在使用“动做”面板的时候，能够随时点击“脚本”编辑窗口左侧的箭头按钮，以隐藏或展开左边的窗口。将左面的窗口隐藏能够使“动做”面板更加简洁，方便脚本的编辑。

　　好了，动做面板就介绍这些，有个印象，不要求记住，工具栏上每一个工具的做用和功能将在之后的课程中边用边熟悉。

 

如何编写flash中的脚本

 

首先，要知道编写脚本，不须要用户对AS有彻底的了解！

　　如今要考虑的问题是，如何在你的flash中添加编写脚本？简单的说，添加脚本可分为两种：一是把脚本编写在时间轴上面的关键桢上面（注意，必须是关键桢上才能够添加脚本）。二是把脚本编写在对象身上，好比把脚本直接写在MC（影片剪辑元件的实例）上、按钮上面。

　　此外，你们也须要简单理解一下flash是如何执行你编写的脚本的。当你在时间周的关键桢上添加了脚本，那么当flash运行的时候，它会首先执行这个关键桢上的脚本，而后才会显示这个关键桢上的对象。

　　还有一些简单的知识，AS中的对象都包括什么呢？它能够包含数据，也能够是舞台上的电影剪辑，也能够是舞台上的按钮等。既然包含了那么多对象，那么每种对象确定有各自的属性！好比电影剪辑（movieclip）对象，它的：属性就有_height(高度)，_rotation(旋转)，等，这些属性不须要你去特地的记忆，当使用的时候能够随时翻阅脚本字典。在之后的教程中会陆续给你们介绍一些基础脚本的使用技巧。

　　

　　2、须要学到的基本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影片的第一桢，并中止播放！
}

2、按钮AS的编写

在 flash 中的交互功能通常是由按钮来完成的。掌握按钮的编写规则也是一个闪客的基本技

能。

OK，如今我们来讲说按钮脚本如何编写。上一讲中提过，AS 脚本编写能够写在时间轴的关

键桢上，也能够写在对象自己上面。按钮也不例外，既能够写在时间轴上，也能够写在按钮

自己上面。只不过这两种编写规则都要遵循必定的规矩，这是后话。

如今我们来作一个例子， 作一个按钮， 这个按钮要实现的功能就是打开一个指定的网页。

（这个例子很是基础，用这个例子来说解按钮 AS 两种编写方法。）

第一种：把脚本写在按钮自己。

1、 在舞台上绘制一个矩形，选中矩形并按 F8，将这个矩形转换成按钮元件。

2、 编写动做脚本：

选中按钮，按 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的编写方法。

这种方法是把脚本程序写在时间轴上，而不是按钮自己上面。

1、 选中按钮，在下面的属性面板中为按钮起一个名字，这里我起了一个 bt

2、 选中时间轴的第一桢，按 F9 打开动做面板。输入以下脚本：

bt.onrelease = function() {

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

};

这种编写 AS 的方法要遵循的规则就是下面的公式而已：

按钮实例的名字.事件名称=function(){

//要执行的脚本程序。

}

你们只要记住这个公式就能够套用了。

按钮的 AS 就先将到这了，这个能够算是基本技能了。但愿你们都能掌握。

3、影片剪辑的AS编写

影片剪辑在flash中能够说是使用最多的一种元件了，那么对于它的AS也是不

少。

在讲解以前，我仍是要从新说一下电影剪辑AS 的编写规则，和上次讲按钮同样，

分为两种，一种是写在电影剪辑自己上，一种是写在时间轴上面。

1、首先咱们先来作个简单的小例子。

或许你不用 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的透明度是随机选择１００内的值。

4、动态文本框

1、flash 中的动态文本使用方法

在 flash中，文本工具提供了三种文本类型。分别是：静态文本、动态文本和输

入文本。

下面讲解的内容属于动态文本的 AS 编写规则。要建立一个动态文本很是简单，

只须要 选中文本工具，而后选择动态文本类型，而后在舞台上拖拽出所须要的

动态文本框就好了

。

2、如何为动态文本赋值

当在舞台上拖拽出动态文本框以后， 能够直接在里面进行文本输入或粘贴外部文

本内

容。那么用 AS 如何来对动态文本框赋值呢？在这里为你们介绍两种方法进行

赋值！

1、使用动态文本的实例名字来赋值

操做步骤：

（1）在舞台上建立一个动态文本框，并为这个动态文本实例起一个名字，例如

abc

（2）选中时间轴的第一桢，打开动做面板，输入如下脚本：

abc.text = "爱国者安全网"

按下 ctrl+回车就可进行测试了。从这个简单的例子能够知道，若是要用文本实

例名字 来进行赋值的话，必须使用如下格式：动态文本实例的名字.text=”须要

赋值的内容”

2、使用变量来赋值

（1）在舞台上建立一个动态文本框，并为这个动态文本实例起一个变量名

3800hk。

（2）选中时间轴的第一桢，打开动做面板，输入如下脚本：

3800hk= "欢迎你们来到爱国者安全网学习！"

不难看出，使用变量赋值更为简单实用！赋值格式为： 变量名=“赋值的内容”

以上两种赋值方法若是内容过多须要换行的时候，须要使用行用回车符（ “\r”

即 ASCII

13）分隔！

3、如何载入外部 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 还能够使用刚才所建立的文本文件 ，为了测试滚动

条的效

5、影片剪辑的拖拽

在网上常常看到的 flash影片中有的对象能够被鼠标进行拖动。例若有的相似七

巧板的拼图游戏，控制音量的滑杆等，所使用的就是 flash中的拖拽动做。

1、拖拽命令详细介绍

１、 首先介绍一下开始拖拽命令的详细用法， 稍后在后面的例子中进行测试。

命令格式： StartDrag(要拖动的影片剪辑,[是否锁定到鼠标位置中央,左,

上,右,下])或写为要拖动的影片剪辑.StartDrag([是否锁定到鼠标位置中央,左,上,

右,下])

命令讲解：在制做动画的过程当中，上面两种书写方法可任选一种。其中［］

内的为可选参数，也就是能够写，也能够不写。至于左，上，右，下四个参数是

用来控制被拖对象的移动范围。

２、中止拖拽命令讲解

命令格式： 被拖动的影片剪辑实例名.stopDrag()

这样就能够中止对对象的拖拽动做。

2、实例讲解

下面来用一个简单的例子实验拖拽命令。

操做步骤：

１、新建一个 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+回车去测试吧！

好了，关于拖拽的讲解先到这里，下面咱们来学习如何结合着拖拽动做来检

测对象之间的碰撞！

3、碰撞命令的讲解

命令格式： 目标影片剪辑的实例.hihkest(被拖拽的实例) 这个是比较

简单的检测碰撞命令

目标影片剪辑的实例.hihkest(被拖拽实例的Ｘ轴坐标，被拖

拽实例的Ｙ轴坐标，对象的矩形区域范围仍是对象自己范围) 这个是比较复

杂点的检测碰撞命令

命令解释： 以上两个命令都是用来检测碰撞的，能够根据须要选择不一样的

命令。重点解释一下对象的矩形区域范围和对象自己范围（上面的命令中，false

表示对象的矩形区域范围，true表示对象自己的范围）

4、碰撞命令与拖拽命令的结合使用

（一）、下面经过简单的例子来学习碰撞命令（咱们先来学习如何检测是否

碰到对象的矩形区域范围）

１、新建一个 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 = "没有碰到";

}

}

这个脚本和上次的碰撞检测脚本相似，只不过不须要再书写Ｘ轴和Ｙ轴，也

不用写是否碰到矩形区域范围。简单吧

如今又到了测试阶段了，去观看你的成果

6、流程控制与循环语句

众所周知，flash中动画依靠的是时间轴，在没有脚本的状况下，动画会依照时

间轴从第一帧不停的播放到最后一帧，而后始重复播放或者干脆中止。为了能更

好的控制动画，就必须使用脚本语句。而要想使动画具备逻辑判断的功能，就要

使用流程控制和循环控制语句了！ 下面经过几个简单的小例子来学习流程与循环

控制语句。

1、流程控制语句

所谓流程控制，无非就是咱们想控制动画程序的执行顺序而已。咱们可让

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语句。

３、测试影片。会看到圆不停的向右移动，当它的Ｘ坐标大于或等于４００的时候，程

序会把它的Ｘ坐标从新更改成０。

2、循环控制语句

所谓的循环语句，其实也是用条件来控制的，只要条件成立，那么，程序就会不停的执

行下去，一直执行到条件不成立为止！ 经常使用的循环语句包括 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 循环语句。

５、测试效果吧，你会看到舞台上会循环４次复制出４个圆。

但愿你们能经过这两个简单的例子掌握流程控制语句和循环控制语句

7、绘图及颜色的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+回车测试动画效果。

2、颜色命令讲解

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+回车来测试你的影片吧～会看到矩形会随着鼠标的移动而不断进行颜色变化。

8、声音 AS 的编写与控制

一个好的 flash做品，缺乏了声音，就如同人不会讲话同样。而 flash

中对声音的支持也很是不错，除了能够使用时间轴放置声音文件之

外，咱们还能够使用ＡＳ来更加准确的控制声音！

1、FLASH 中如何建立声音控件

若是想控制动画中的声音，咱们能够使用 flash中的 sound 对象，

经过 sound 命令建立一个新的 sound 对象。以后再用 attachSound 命

令链接到库里的声音，就能够用来控制动画中的声音了。

经常使用命令讲解：

new Sound() 此命令用来建立一个新的 sound 对象，有了

sound 对象咱们才能用ＡＳ来控制声音。

attachSound("库中的声音") 此命令能够使咱们建立的声

音对象链接到库里的声音，以便进行控制。

start([从第几秒开始播放, 循环次数]) 此命令能够是

声音开始播放，里面的两个参数是可选的。

stop() 中止声音的播放。

setVolume(音量级别) 此命令能够控制声音的音量高低，

音量级别只能是从０－１００之间的数字。

如今咱们也应该用ＡＳ先作一个简单的小例子了。

2、建立一个简单的声音播放动画，能够实现简单的开始与中止

播放声音。

操做步骤：

１、新建一个 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+回车来测试吧。

3、建立一个稍微复杂的例子，用来滑动按钮来控制声音的音量。

操做步骤：

１、新建一个 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 对象播放、中止

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

9、时间日期的 AS编写

1、日期时间的基本命令及解释

getFullYear() 按照本地时间返回 4 位数字的年份数。

getMonth() 按照本地时间返回月份数。

getDate() 按照本地时间返回某天是当月的第几天。

getHours() 按照本地时间返回小时值。

getMinutes() 按照本地时间返回分钟值。

getSeconds() 按照本地时间返回秒数。

以上命令并非很难理解，都是获取本地机器上日期及时间。可是要使用这些命令，我

们必须先用 Date 对象的构造函数建立一个 Date 对象的实例。而后，就能够用建立的这个

实例来进行操做！命令格式以下：

实例名＝new Date()

2、显示日期及作一个走动的表

下面咱们经过一个例子来介绍 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 的编写。在后面的课程中咱们就要提升性的讲解，同时

也但愿你们继续关注。

10、点语法以及路径

点（.）语法、 路径

经过本节的学习要掌握（.）；能正确地输入影片剪辑的实例名称；理解相对路径和绝对路径

的概念，理解分层结构中的包含关系和并列关系，

点（.）语法

动做脚本中，点（.）一般用于指定对象或影片剪辑相关联的属性或方法，或者标识影片剪

辑、变量、数对象的目标路径。点语法表达式是以对象或影片剪辑的名称开始，后跟一个点，

最后以要指定的元素 结束。

例如：（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

11、深刻了解时间控制

经过本课的学习，掌握在按钮上添加代码的方法；理解 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 也

能够成功的编译这个脚 本，但这是不规范的。

? 花括号“{ }” ，动做脚本中的一组语句能够被一对花括号“{……}”包

括起来，成为一 个语名组。在由多个动做状态组成的语句组中，使用花括号可

以有效地来区分各命令的层级和从属关系。

12、无条件转移

在上一课中咱们学习了时间轴控制命令中的 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();

}

实例制做完毕，你们测试景片，观看效果。

十3、变量

经过本节的学习，理解变量的概念；掌握变量命名的规则、给变量赋值的方法；会用动态

文本显示变量、输入文本输入变量，会使用调试命令 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 运算符的结果以下表所示。

十4、运算符（一）

运算符表达式

运算符是指定如何组合、比较或修改表达式值的字符。运算符对其执行运算的元素称为操做

数。例如，在语句“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。

十5、变量（二）

比较运算符

用于比较表达式的值，而后返回一个布尔值（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”是不起任何做用的，但语名格式中，不能没

有它。

十6、影片剪辑的属性

经过本课的学习了解影片剪辑的主要属性，学会设置和获取影片剪辑的属性的方法。

知识点：

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

}

测试影片，

说明：动态路径在实际编程中运用很是普遍，它大大提升了编程的效率。有关动态路径更多

应用将在后面的章节里讲解。

十7、再讲循环语句

掌握 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） 返回主主场景，把库里的跳动的心提进主场景，能够看到心脏在不停的跳动。

十8、影片剪辑处理函数

在前面咱们学习了帧 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命令。这一点你们必定要紧紧记住。

十9、复制影片剪辑

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） 回到主场景，从库里提出复制线条影片剪辑元件。测试影片。

二10、深刻 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);

}

二11、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;

}

}

}

二12、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循环结构不管条件是否符合,循环至少执行一次.

 

二十3、循环语句的嵌套

 

一个循环体内包含另外一个循环体结构，称为循环的嵌套．在这一讲中咱们介绍 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);

}

}

}

说明：本课中的实例理论性较强，牵涉的数学知识较多

 

二十4、组件

 

组件是拥有已定义了参数的复杂影片剪辑，这些参数在文档创做时设置。经过参数的设置和使用，咱们能够修改组件的外观和行为。每一个组件都有本身的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"的单选按钮注册到侦听对象

 

测试影片

 

二十5、播放器控制与网页链接以及动画发布输出

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、输出图像文件

二十6、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();

};

二十7、影片剪辑的深度

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

二十8、文本框

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

}

二十9、超文本标签

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

三10、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);