Flash 基础篇从0开始学 ActionScript

1、变量的定义:
如n=n+1,就是把变量n加1后再赋值给n,这时n就等于1,n默认为0
再如size=100;就是变量size的值为100
上面n、size都是数值型变量,它是存储数值型数据的。下面是一个简单的 应用:
画一条直线,按F8转换为mc,取名为line,在主场景的第一帧写上line._rotation=30;//设置影片的角度为30度。测试影片,看看有没有变化,并且可试着改变后面的值。
然后把代码改为line._rotation=a;a=a+1;并插入一帧,让其循环。测试影片,是不是可看到直线一直在旋转。原因是a的值不断在增加,每循环一次,a就加1。试试把1改为5,可改变旋转的速度。


2、变量的类型
变量实际上就是一个信息容器,容器本身是相同的,但是容器趾的内容却可以修改
变量可以存放任何数据
1、字符型
如:Myname="zhangjingshe";
2、数值型
如上贴中:n=1;
3、逻辑型
如:zz_press=true;
4、对象型
如:myarrey = new Array();//定义一个新的数组
等等
影片 | Movieclip
影片是 Flash 中唯一用来引用图像元素的数据类型. 你可以通过 MovieClip 对象的各种属性(Property)和方法(Method)来操作它的实例(Instance).
关于影片我们也会在后面详细讲解
空 | Null
空? 我是说"空", 也就是什么都没有. 这种数据类型就是这个意思, 而且它只有一个值: null. 那么它有什么用呢?
用来表示一个变量尚未赋值
用来表示一个变量已经不包含数据
用来表示一个函数没有返回值
用来表示一个函数的某个参数被省略了
不要认为它毫无意义, 在涉及到具体的程序问题时它是非常有用的.
定义 | Undefined
未定义类型同 Null 差不多, 也只有一个值: undefined.
它被用来表示一个变量尚未赋值


3、变量的命名
1、变量名必须以字母或下划线开关,由数字、字母和下划线组成,中间不能包含空格。变量名不区分大小写。
2、变量名不能是一个关键字或逻辑常量。
flash 中关键字有
break 跳出循环体 instanceof 返回对象所属的类(Class)
case 定义一个 switch 语句的条件选择语句块 new 使用构造函数(Constructor)创建一个新的对象
continue 跳到循环体的下一项目 return 在函数中返回值
default 定义 switch 语句的默认语句块 switch 定义一个多条件选择语句块
delete 清除指定对象占用的内存资源 this 引用当前代码所在的对象
else 定义 if 语句返回为假时的语句块 typeof 返回对象的类型
for 定义一个循环 var 声明一个本地变量(Local Variable)
function 定义一个函数语句块 void 声明返回值类型不确定
if 定义一个条件语句块 while 定义一个条件循环语句块
in 在一个对象或元素数组中创建循环 with 定义一个对指定对象进行操作的语句块

3、变量名在它的作用范围内必须是唯一的。



4、设置变量的使用范围
1、本地变量(局部变量)
在自身代码块中有效的变量,声明它可以使用 var 关键字:
如:function zjs() {
var n = 5;
trace(n);//把指定变量的值发送到输出窗口,这里是n

}zjs();
结果是:5。
如果改为
function zjs() {
var n = 5;
}
zjs();
trace(n);
结果为:未定义
使用本地变量可以fang止命名冲突,如上面第1个例中,变量n只在函数zjs中起作用,那么在其它的函数中使用,所以不会冲突。

2、全局变量
声明它可以在变量名前面使用_global
如:_global.n = 5;//声明一个全局变量n
function zjs() {
trace(n);
}
zjs();

结果是:5
如果改为
_global.n = 5;
function zjs() {
}
zjs();
trace(n);
结果还是:5

3、时间轴变量
如:n=5;
时间线范围变量声明后, 在声明它的整个层级(Level)的时间线内它是可访问的。



代码中使用变量
使用变量很简单, 有点编程基础的读者都可以办到. 下面用一个例子来说明在 Actions cript 中变量的使用:
function vars(x){
if(x<5){ //如果 x 小于 1
x = x + 1; //x 加 1
} else {
x = 10; //否则赋值 10
}
trace("x="+x);
return x;
}
vars(2);
vars(6);
trace("x="+x); //测试 x 是否为局部变量
函数声明中的参数无需加 var 声明也自动作为局部变量(例如上面例子中的 x). 通过上面例子的最后一句就可以看出来(返回值为空).
我们可以看到, 上面定义的函数中对局部变量 x (在函数参数中声明)进行了 4 种操作:
赋值: 就是改变变量所存贮的内容.
运算: 使用运算符运算并返回结果. 上例中的 x = x + 1 可视为一个运算操作(x + 1)和一个赋值操作(x = ...)的复合语句. 对于逻辑运算(上面 if 语句的条件), 返回的为逻辑值 true 或 false(就像 x<5 在 x 为 4 时会返回 true).
函数及命令调用: 就如上面 trace("x="+x); 中的一样, x 是被作为参数传递给函数的, 它代表的是它所存贮的实际内容(在 return x; 中也一样).
在 Actions cript 中变量的使用具有很大的灵活性, 下面我们将会针对不同的数据类型进行讲解.



常见数据类型---字符串 | String

一个字符串就是一系列的字符, 例如 "This" 就是一个字符串.
定义一个字符串变量很简单, 只要在初始化时将一个字符串数据赋给它就行了:
chapter = "第 2 章";
section = "第 2 节";
section_name = "常见数据类型";
full_name = section + " " add section_name + 999; //连接字符串
if(typeof(full_name) ne "string"){
full_name = "类型错误!";
}
trace("full_name=" + full_name);
上面的第 4 行的 full_name 的值是前面两个变量(section 和 section_name)和一个常量(999)的运算结果(使用了 + 和 add 运算符, 它们的功能是相同的). 请注意, 这行代码最后面的数值常量 999 不是同一类型的数据, 如果在 Pascal 这种数据类型检查极其严格的语言中这行代码是错误的. 但是 Actions cript 可以自动将它转换为字符串格式, 而不需要专门的函数(当然, 最安全的方法是使用 Number 对象的 toString() 函数或是 String() 函数). 由此可见, Actions cript 是一种弱类型检查的语言(即不严格限制各种数据类型间的运算和传递), 这和 VB 倒是有点相似, 只不过更过分一点.
在后面我用了一个 if 语句来测试后面加上 999 的代码是否运行正常(即检查表达式返回的值是否为字符串, 尽管在实际中并没有这个必要). 注意我用的是字符串类型专用的逻辑运算符 ne, 当然这只是为了表现字符串数据类型的特殊性, 实际应用中用 != 也就可以了. 对于 typeof 操作符, 我们会在这一章的末尾详细讲解.

--------------------------------------------------------------------------------
在实际应用中, 有一些特殊的字符不能直接输入在字符串中, 例如不能在字符串中直接输入引号(会破坏字符串的完整性). 这时我们就需要用到转义字符了(Escaping). 要使用转义字符, 首先要输入一个反斜杠(\), 然后输入相应的代码. 详细的代码列表如下:
转义字符 代表字符
\b 退格字符 (ASCII 8)
\f 换页符 (ASCII 12)
\n 换行符 (ASCII 10)
\r 回车符 (ASCII 13)
\t 制表符 (ASCII 9)
\" 双引号字符
\' 单引号字符
\\ 反斜杠字符
\000 - \377 八进制表示的字符
\x00 - \xFF 十六进制表示的字符
\u0000 - \uFFFF 十六进制表示的 16 位 Unicode 字符

例如:
trace("He said:\"I don\'t care about you.\"\nAnd she smiled:\"Really?\"");
你可以根据上面的对照列表读出上面代码的字符串内的实际内容. 运行后的输出为:
He said:"I don't care about you."
And she smiled:"Really?"
可以看到, 转义字符都被转换为相应的实际字符了. 这就是转义字符的作用, 学过 C++ 的读者应该很熟悉了.



数值 | Number

Actions cript 中的数值型数据为双精度浮点数(不懂是什么意思也没关系, 反正知道是数值就行了, 那只不过是个范围限制).
对数值型数据可以进行任何相应操作. 如下例:
a = 1;
b = 2;
sum = a + b; //求 a, b 之和
if(sum>0){ //假如结果大于 0
square_root = Math.sqrt(sum); //使用 Math 对象的平方根函数求 sum 的平方根
}
trace("sum=" + sum);
trace("square_root=" + square_root);



逻辑变量 | Boolean
逻辑变量又被称为布尔变量(由其英文名称而来). 它只有两个值: true 和 false. 在必要的情况下, Actions cript 会自动将它的值转换为 1 和 0, 你也可以用 1 和 0 给它赋值(这是可能是为了和 Windows API 函数调用兼容而产生的).
a = 10;
b1 = 1;
b2 = false;
if(b1 == true){
a = a + b1;
} else {
b2 = !b2;
}
trace("a=" + a);
trace("b1=" + b1);
trace("b2=" + b2);
上面代码混合了数值型和逻辑型变量的运算. a = a + b1 将逻辑值 b1(true 即 1)加到 a 上, b2 = !b2 则是对 b2 取反(即由 false 变为 true 或是由 true 变为 false, 因为逻辑值只有两种情况: 真或假). 你可以试着修改一下 b1 的值来看看不同的效果.



typeof 操作符
在实际应用中我们经常遇到需要判断具体变量和对象的数据类型的情况. Flash 提供了一个很好用的 typeof 来解决这个问题. 特别是对于自定义函数的设计, 确定参数的类型是非常重要的步骤.
参数类型 返回值(字符串)
String string
MovieClip movieclip
Button object
TextField object
Number number
Boolean boolean
Object object
Function function
Undefined undefined
Null null

typeof 操作符的优先级很高, 可以在逻辑运算或是算术运算符之前被运算. 下面是它具体应用的例子:
//常数的类型
trace("数值常数 36 的类型: "+typeof 26);
trace("字符串常数 what 的类型: "+typeof "what");
//一般 typeof 操作符可以像 +, -, add 等操作符一样使用
//但为了避免出错还是建议你使用括号, 如下例
trace("逻辑常数 true 的类型: "+typeof(true));
//对象的类型
trace("对象 Object() 的类型: "+typeof (Object()));
trace("new String() 的类型: "+typeof new String()); //注意 new 操作符优先级比 typeof 高
//函数的方法的类型取决于其返回值
trace("Math.sqrt() 方法的类型: "+typeof Math.sqrt());
trace("Math.toString() 方法的类型: "+typeof Math.toString());
//null 空类型
trace("null 的类型: "+typeof null);
//在这里我用了多级 typeof 来看看 typeof 返回的值的类型
trace("typeof 返回值的类型: "+typeof (typeof null));
你还可以自己试着改动一下代码, 看看其它东西的 typeof 是什么




条件语if句--if
由下面的例子可以了解它的格式:
name = "SiC";
//下面是 if 语句
if(name == "SiC"){
trace("作者");
}
if 语句通过判断其后圆括号内的逻辑表达式是否为 true 来确定是否执行大括号内的语句. 假如逻辑表达式 name == "SiC" 返回值为真, 就在输出窗口(Output Window)内显示"作者", 否则就不执行.
然后让我们设想一下下面例子的效果:
if(1){
trace("总是执行");
}
如果你还记得前面数据类型的内容, 那么应该可以看出, 这时的 if 语句基本上是多余的, 因为对于常量 1, 逻辑表达式的值恒为 true(其实 1 就是逻辑值 true 的数值表示形式). 但对于常量 0, 则永远为 false. 你可以试试把上例中的 1 改成一个字符串常量(例如 "hi!")看看会有什么效果.
再看一个例子:
name = "SiC";
//下面是 if 语句
if(name = "SiC"){
trace("作者");
}
比较一下看这个例子与第一个例子有什么不同? 不同之处就在于第一个用了 ==, 而这个用了 =. 对于这个例子, if 的判断永远为 true. 想想为什么? 问题就在于使用了赋值运算符 = 而不是逻辑运算符 ==. 对于赋值运算, 其返回的逻辑值总是 true. 这也是初学者常犯的错误.
一定要注意区分赋值运算符 = 和逻辑运算符 ==. 否则你会遇到一些莫名其妙的错误和问题, 而且语法检查也找不出错误(因为赋值运算表达式也是有效的条件表达式). 所以请记住, Actions cript 的相等逻辑运算符是 == 而不是 =.


if...else和if...else if
假如想要在判断条件不成立时执行另一项操作时怎么办? 很简单, 在 if 语句后面加上个 else 语句块就可以了:
name = "未知";
//下面是 if...else 语句
if(name == "SiC"){
trace("作者");
} else {
trace("未知");
}
很简单吧? 只要把在判断结果为假时要执行的语句放在 else 后的大括号里就行了.
if...else if
如果要进行很多个条件判断怎么办? 也好办, 用 else if 解决:
name = "Sam";
//下面是 if...else if 语句
if(name == "SiC"){
trace("作者");
} else if(name == "Flash MX") {
trace("Flash MX 是软件名称.");
} else if(name != "未知") {
trace("谁是 " + name + "?");
} else {
trace("未知");
}
你可以接任意多个的 else if 来进行多个条件的判断, 最后的 else 语句块可有可无(根据实际需要选用). 唯一不足的就是 else if 太多时执行速度较慢(在其它程序语言中也是一大问题). 这时就轮到 switch 出场了
switch
switch 在 Visual Basic 里面是个很好用的命令. 它可以通过判断不同的条件表达式来执行不同操作. 但是在 Actions cript 中就没有那么大的弹性了. 因为 Actions cript 中 switch 的条件被固定为 ===, 即绝对等于(包括数据类型也要相同), 不像在 VB 中可以额外使用 >, >= 之类的条件运算符. 所以, else if 在需要判断大于小于之类的情况下还是大有用处的. 现在来看看下面的例子:
mynumber = 3; //赋值给 mynumber
//下面是 switch 语句
switch (mynumber) {
case 1:
trace ("这是我希望得到的数字.");
break;
case 2:
trace ("这个数字比我的小一点.");
break;
case 3:
trace ("这是我的数字.");
break;
default:
trace ("这不是我要的数字.")
}
上面的例子是一个完整的 switch 语句块. 在 case 关键字后面的就是需要满足的条件, 如果都不满足, ActionScipt 会查找是否存在 default 语句块, 如果存在, 则执行其中的语句. 另外, 你可能已经发现在每个语句块后都有一个 break 关键字, 为什么呢? 因为如果没有用 break 来跳出 switch 条件选择语句, 程序会继续向下搜索满足条件的 case 项目(包括 defualt 块)并执行其中的语句. 下面是一个修改后的例子:
mynumber = 3; //赋值给 mynumber
//下面是没有加 break 的 switch 语句
switch (mynumber) {
case 1:
trace ("这是我希望得到的数字.");
case 2:
trace ("这个数字比我的小一点.");
case 3:
trace ("这是我的数字.");
default:
trace ("这不是我要的数字.")
}
运行一下这个例子, 你会发现会同时输出了 "这是我的数字" 和 "这不是我要的数字". 为什么? 因为没有了 break, 在运行了满足条件的 case 3: 语句块后, 条件选择语句仍会继续执行, 而 default 块作为默认条件, 它总是会被执行, 从而产生了这样的结果. 一些常见的程序错误也就由此而来.
在 Actions cript 中还有一个用于循环的 continue 命令, 它可以直接跳到所在循环的条件检测部分(即立即进行下一次循环的条件判断). 这个命令不常用到, 所以在这里没有讲解. 感兴趣的读者可以查阅 Flash 的 Actions cript Dictionary



循环语句--for
对于 for 循环, 我想大多数读者都不会陌生. 下面是一个求 1 到 100 的自然数之和的程序段.
var sum = 0;
//下面是 for 循环
for (var i=1; i<=100; i++) {
sum = sum + i;
}
trace ("sum="+sum);
很显然, 这和 BASIC 的 for 语句有很大区别, 同 PASCAL 也有一定的差异. for 后面括号里面的内容分为三部分: 初始值; 循环条件; 循环值变化方式. 对于初始值没什么可说的, 随便取; 循环条件就是在什么条件下继续循环, 只要懂得逻辑表达式就可以了; 循环值的变化方式可以用任意的赋值语句来改变. 下面是一个修改后的例子:
var sum = 0;
//下面是 for 循环
for (var i=2; i<100; i+=2) {
sum = sum + i; //trace(i);
}
trace("sum="+sum);
上例中我把初始值 i 改为了 2, 条件改为 <100 (即不包括 100), 循环值变成每次加 2. 运行后看看结果, 结果是 1 到 100 的开区间中所有双数之和. 如果不清楚循环内部的工作机理, 可以删除上例中 for 循环体内 //trace(i); 前的双斜杠, 运行代码时会在输出窗口中列出每次的 i 值. 那么如果初值不满足循环条件会怎样? 你可以把 i=2 改为 i=100 看看.
对应于 for 还有一个 for...in 循环, 这涉及到数组和对象的内容


while & do...while
while & do...while
说实在话, 对于一般的编程 while 用得不多. 但是在需要的时候你才会发现它的价值.
while 循环在运行时遵循下面的步骤:
检查 while 后面括号内的条件是否成立.
如果条件成立, 运行语句块内的语句. 否则结束循环, 运行循环体后面的语句.
运行完语句块内的语句后回到第一步.
n = 0;
//下面是 while 循环
while(n < 5) {
n++;
}
trace("n="+n);
上面的例子运行结果为 n=5. 当 n 小于 5 时循环的条件成立, 于是运行其中的 n++ (即 n 增加 1). 当 n 等于 5 时, 因为循环条件已经不成立, 所以中止循环, 执行后面的 trace 语句.

--------------------------------------------------------------------------------
while 还有一个结构, 即 do...while 循环. 看看下面这个例子的输出, 你就可以理解 do...while 循环是如何工作的了.
n = 0;
//下面是 do...while 循环
do {
n++;
} while (n > 5)
trace("n="+n);
你会发现输出的结果是 n=1, 即使我们给的 n=0 并没有满足 n>5 这个条件, 循环体也执行了一次(n++). 这个例子说明了 do...while 循环是一个条件后测试语句, 即先执行一次代码然后再检测条件是否成立. 利用这个特点, 我们可以满足一些特殊的编程需要.
但是仅仅这些还不够, 我们还需要一些别的东西来满足重复的需要, 那就是函数


创建自己的函数---函数定义(Definition)
要创建一个函数, 就需要有函数的定义. 对于 Actions cript, 就没有什么返回值类型, 形参实参之类的东西好讨论了. 下面是一个简单函数的定义:
//计算矩形面积的函数
function areaOfBox(a, b) {
return a*b; //在这里返回结果
}
//测试函数
area = areaOfBox(3, 6);
trace("area="+area);
现在来分析一下函数定义的结构. function 关键字说明这是一个函数定义, 而不是一段执行代码. 其后便是函数的名称: areaOfBox. 函数名后面的括号内是函数的参数列表(也可以没有参数, 但括号是必须要有的). 紧接着的大括号内是函数的实现代码, 即 Actions cript 语句. 如果函数需要返回值, 可以使用 return 关键字加上要返回的变量名, 表达式或常量名. 在一个函数中可以有多个 return 语句, 但无论何时, 只要执行了其中的任何一个 return 后, 函数便自行终止而不会继续执行下去. 如果没有 return 语句, 则在函数尾最后一个语句执行后结束.
因为 Actions cript 的特殊性, 函数的参数定义并不要求参数类型的声明, 即可以不指定参数类型. 这省去了很多麻烦, 也带来了一些问题. 虽然把上例中倒数第二行改为 area = areaOfBox("3", 6); 也同样可以得到 18 的结果, 但是这对程序的稳定性非常不利(假如函数里面用到了 a+b 的话, 就会变成字符串的连接运算, 结果自然会出错). 所以, 有时候在函数中类型检查是不可少的.
在函数体中参变量用来代表要操作的对象. 你在函数中对参变量的操作, 就是对传递给函数的参数的操作. 上例中的 a*b 在你调用函数时会被转化为参数的实际值 3*6 处理.

--------------------------------------------------------------------------------
函数还有一种创建方法, 叫做函数显式声明(function literal, 不是通过正式的函数声明而是在一个表达式内通过未命名的函数来进行声明):
areaOfBox = function(a,b) {return a*b;};
trace("area="+areaOfBox(2,3));
这种形式的声明经常用在对象的方法或是函数库的函数声明中.
在 Flash MX 的帮助中函数定义部分关于这种声明的范例代码有误, 请注意.

--------------------------------------------------------------------------------
上面是有返回值的函数, 在函数尾使用了 return 关键字来返回结果. 函数也可以不返回任何值. 如下例:
//无返回值的函数
function areaOfBox(a, b) {
_root.area = a*b;
}
//测试函数
areaOfBox(3, 6);
trace("area="+_root.area);
它的结果也是 18, 只不过最后的结果是传递到 _root 下的指定变量 area 而已.下面一个例子更简单:
//计算矩形面积的函数
function simpleFunc() {
trace ("什么都没有"); //在这里返回结果
}
//测试函数
simpleFunc();
最后的输出就是 trace 中的字符串. 就是说, 函数可以既没有参数也没有返回值, 而是一系列操作的集合. 可见函数的使用具有很高的灵活性.

--------------------------------------------------------------------------------
同变量一样, 函数也可以具有全局性. 只要在声明时在前面给它加一个 _global 就可以了:
//计算矩形面积的全局函数
_global.areaOfBox = function (a, b) {
return a*b; //在这里返回结果
}
//测试函数
area = areaOfBox(3, 6);
trace("area="+area);
请注意: 在函数体中出现的关键字 this 代表的是调用函数的 MovieClip, 而不是函数体所在的 MovieClip. 这很容易被忽略而产生不期望的结果. 如果要指定 this 所代表的对象就要用到 Function.call() 和 Function.apply() 方法. 在后面的 arguments 对象介绍中会讲到


函数参数的检查
了保证函数运行的正确性, 我们有时必须检测用户是否给了足够的或是正确类型的参数. 下面是我对上面例子进行改动后的代码:
//计算矩形面积的全局函数
_global.areaOfBox = function (a, b) {
//输出两个参数之和, 用于理解下面的 typeof 语句
trace("a+b="+(a+b));
//检测参数是否足够且类型正确
if(a==undefined || b==undefined || typeof(a+b)!="number") {
trace("<参数错误>");
return 0; //返回 0 作为错误时的结果
}
return a*b; //在这里返回结果
}
//测试函数
trace("----下面是正确的参数----");
area = areaOfBox(3, 6);
trace("area="+area);
trace("----下面是错误的参数----");
//这里为了节省篇幅, 我在命令中直接调用函数, 而不是先将返回值赋给一个变量
//其实这才是我们常用的函数调用方法
trace("area="+ areaOfBox(3, "6"));
trace("----下面是不足的参数----");
trace("area="+areaOfBox(3));
上例中我用 a==undefined 来判断 a 是否被赋值了(即是否已定义, 对于 undefined 数据类型的内容请参阅前一章的内容). 为了确保万无一失, 我还用了 b==undefined 来保证 b 也已被赋值, 中间使用一个逻辑 "或" 运算符 || 来连接这两个条件.
此外, 在这两个条件后面我又通过 typeof(a+b)!="number" 来确认参数类型是否正确(关于 typeof 关键字的信息请参考前一章). 这里我利用了 Actions cript 的一个特点: 数值与字符串相加的和会被优先做为字符串处理. 所以 a+b 中只要有一个为字符串, 那么整个 a+b 的返回值就是一个字符串, 在后面通过 typeof 来检测的结果自然就不是我们所要的 "number". 通过 trace("a+b="+(a+b)); 输出的结果可以看出这一点



在 Actions cript 中除了用户定义的函数外, 还有预定义的内建函数. 对于不同的对象, 也有不同的函数(或者说是方法)可以调用. 下面是拥有最高优先级的系统内建函数列表:
函数 说明
Boolean 将所给参数值转化为逻辑值(也叫做布尔值)
escape 将所给参数转化为字符串并用 URL 格式编码(所有非标准字符将被转化为以 % 开头的十六进制值)
eval 返回所给参数表示的对象, 参数可以是常量, 表达式, 属性等(这在 DuplicateMovieClip 时经常用到)
getProperty 返回指定对象的指定属性值
getTimer 返回从动画开始运行到当前所经过的毫秒数
getVersion 返回 Flash 版本和操作系统信息
isFinite 返回所给参数是否是有穷的(逻辑型返回值)
isNaN 返回所给参数是否是数值(逻辑型返回值)
Number 将所给参数转化为数值
parseFloat 将字符串转化为浮点数, 如果不可转化则返回 NaN (Not a Number, 不是数值)
parseInt 将字符串转化为整数, 如果不可转化则返回 NaN (常用于数值进制转化, 浮点数转化后会转化为整数)
String 将所给参数转化为字符串
targetPath 返回字符串格式的指定对象的路径
unescape 返回用 URL 格式解码的字符串
上面的函数的详细信息请查阅 Flash 的 Action Dictionary. 要懂得如何通过最简捷的方法获取资料.
调用函数---直接调用

声明了函数, 就要用它. 怎么用? 像上面例子中我们用来测试的例子一样. 输入函数名和它需要的参数, 然后把返回值赋给一个变量. 但是, 最简单的方法莫过于直接调用函数而不赋值给变量, 函数的调用语句会被作为与返回值数据类型相同的常量处理. 也就是说, 有返回值的函数可以被当作一个该返回值数据类型的变量来使用. 例如, 在前一个例子中的 trace("area="+areaOfBox(3,"6")); 结果不变.
定义后的函数可以在其作用域内无限次地反复调用, 每次调用都可以给予不同的参数.
对于无参数的函数, 只要简单的输入它的函数名加括号 () 来调用就行了. 例如下面一个例子:
//获得 Flash 版本信息
trace( getVersion() );
上例我调用了一个系统内建的无参数函数, 它会返回当前的 Flash 版本. 对于自定义的无返回值函数, 也是像这样直接调用.
有时候即使没有给函数足够的参数, 函数的功能依然可以使用. 例如:
//检查参数是否是数值
trace( isNaN() );
在上例中我们并没有给函数一个必要的参数, 但函数仍然可以处理并返回 true (因为没有参数就等于给函数一个 Null 类型的常量, 因为 null 不是数值类型, 所以最后的返回值为 true).
对于前面几个范例中的 areaOfBox 函数, 你可以试试少给它一个参数, 看看会有什么结果



通过 call 和 apply 方法调用

在 Flash 的 Actions cript 中函数(Function)其实是内建的对象. 所以我们可以通它的 call 和 apply 方法调用它:
//计算面积的函数
function areaOfBox(a, b) {
this.value = a*b; //将结果赋给 this 所代表的对象的 value 属性
}
//创建新对象
object_1 = new Object();
object_1.value = 0; //为对象加入 value 属性并给予初值 0
object_2 = object_1; //由 object_1 复制出一个 object_2, 此时两者的 value 属性均为 0
//测试函数
areaOfBox.call(object_1, 3, 6);
trace("object_1.value="+object_1.value);
array_ab = [4, 5]; //创建参数数组
areaOfBox.apply(object_2, array_ab);
trace("object_2.value="+object_2.value);

为什么要通过 call 和 apply 来调用函数? 这样不比前面的直接调用麻烦吗?
的确, 这样调用函数比较麻烦, 但你注意到了我使用的第一个参数没有? 通过第一个参数可以指定在函数体中的 this 关键字代表什么对象, 这就是用 call 和 apply 的好处(关于对象和 this 的内容在后面章节中才会提到, 在这里暂且不提). 这个好处只有在实际的编程中你才能体会得到, 这里只是简要介绍一下, 让你有个基本的概念.
如果函数中没有使用 this 关键字, 第一个参数要用 null 代替.
在本例中第一个返回值被放入 object_1 的 value 属性中, 另一个会被放入 object_2 的 value 属性中. 通过 call 和 apply 的第一个参数我们让函数体中的 this 先后代表了 object_1 和 object_2 两个对象. 第一个参数后面的实际参数的给予完全依照要调用函数的参数个数和类型确定.
至于 call 与 apply 的不同之处上面已经表示得很明白了: apply 的实际参数是通过数组传递的
Actions cript 中的数组有个很特殊的优点: 可以使用字段名. 这样的数组更像一个二维数据表(但实际上这是个对象的数组, 注意在定义每个子元素时使用的是大括号而不是中括号).
var team_member = new Array();
team_member[0] = {name: "SiC", job: "无业游民", sn: 1011};
team_member[1] = {name: "ReDo", job: "游戏杀手", sn: 2172};
team_member[2] = {name: "Crab_D", job: "帮倒忙", sn: 1012};
trace(team_member[1].name); //显示第 2 个元素中的 name 字段
后面的 trace 语句显示第二个元素的 name 字段的内容. 但实际上这是通过 team_member[1] 引用数组的第二个元素(一个对象), 然后通过点式语法引用其属性 name 的值. 你可以通过 Debugger 来查看这个数组的内容. 关于对象的具体内容将在后面章节中说明




arguments 对象
arguments 对象
arguments 对象, 顾名思义就是参数对象, 它包含的是函数调用的参数. 作为一个数组对象, 它只有三个属性:
属性 描述
arguments.callee 正被调用的函数
arguments.caller 正在进行此调用的函数
arguments.length 传递给被调用函数的参数数目//一个求平方和的函数
function sum1(x) {
//我们把 x>0 作为循环调用的条件
if (x>0) {
//通过 callee 来调用自身(因为自己是被调用的函数)
//同时将参数减 1(否则就成死循环了)
return x*x+arguments.callee(x-1);
} else {
return 0;
}
}
//另一个求立方和的函数
function sum2(x) {
if (x>0) {
//这里我们直接调用求平方函数
return sqr(x);
} else {
return 0;
}
}
//求平方函数(与 sum2 相互作用)
function sqr(x) {
if (x>0) {
//求平方, 然后通过 caller 反过来调用 sum2 函数(即调用求平方函数的函数)
return x*x+arguments.caller(x-1);
}
}
//通过测试来比较两者效果
trace("正确的参数---------------");
trace("sum(3)="+sum1(3)+" : "+sum2(3));
trace("sum(4.7)="+sum1(4.7)+" : "+sum2(4.7));
trace("sum(100)="+sum1(100)+" : "+sum2(100));
trace("错误的参数---------------");
trace("sum(-1)="+sum1(-1)+" : "+sum2(-1));
trace("sum(0)="+sum1(0)+" : "+sum2(0));

由上面的附图可以很明确地表现出 callee 和 caller 的不同. 一个是引用被调用的函数(callee), 另一个是引用正在调用函数的函数(caller). callee 常用于函数的递归(即循环调用自身). 通过 callee 调用自身可以避免因为改动声明部分的函数名, 但忘了改动函数体内的函数名而产生的错误. caller 常用在多个函数间的调用, 同时也可以用来判断调用者是谁(这样可以限定调用者范围和其它函数是否可以调用此函数).
至于 arguments.length 没什么可说的, 就是返回当前调用所传递的参数个数



函数的其它特性---局部变量在函数中使用的参数都是局部变量, 在函数调用结束后它们会被自动从内存中移除. 你也可以在函数中使用 var 声明其它的局部变量. 如果你在函数中使用了全局或是其它位置的变量, 一定要注意是否和函数中的局部变量混淆, 同时最好用注释标明它们不是函数的局部变量和它们的来源.function test(a) {var b = "Words"; //定义局部变量 bc = "Text Here"; //定义变量 ctrace("----从内部访问变量----");trace("a="+a); //显示参数 atrace("b="+b); //显示局部变量 btrace("c="+c); //显示变量 c}//调用函数test("Symbol");trace("----从外部访问变量----");trace("a="+a);trace("b="+b);trace("c="+c);由运行结果可以看出来参数 a 和局部变量 b 都只在函数体内可以访问, 而在函数内部定义的变量 c 则可以在函数体外部访问.



作用域

函数的作用域是定义它的代码所在的对象或时间线范围. 全局函数其实相当于一个基于 _global 全局对象的子函数.
如果要调用其它位置(即不在同一对象层内的函数), 必须使用路径(Path). 如在一个子 MovieClip 中要调用 _root 中的函数必须要用以下格式:
_root.myFunction();
若是要调用父级 MovieClip 下面的 mc1 里面的 mc2 里面的函数 myFunction 则要用以下代码:
_parent.mc1.mc2.myFunction();
说得更明确一点, 就是你在一个对象或是层级中定义了一个函数, 就等于为这个对象(或者说是类, Class)或层级增加了一个子函数(或是方法, Method). 要调用这个函数, 你就必须指明它所属的对象或是层级. 这也使得在不同的对象中可以用相同的函数名来创建函数(变量和对象也是一样). 关于路径的内容将后面的章节提到




函数的重定义

在 Actions cript 中, 当你重新定义了一个函数后, 这个函数就会被改写为新的版本, 旧的函数被覆盖. 你再次调用它时, 它就是新的函数了. 至于函数重载(C++ 的特色)这种东西在 Actions cript 中是没有的, 所以也不用费力气讲了.
关于函数的内容就简要介绍到这里. 在下一章我们会讨论在实际应用中非常有用的数组.



第 5 章: 数组--什么是数组?
那么, 什么是数组呢? 我也不懂该怎么定义. 所以就从 C++ 的教材上抄了一段: 数组由许多相同类型的数据项和索引变量组成, 数组不是一种基本数据类型, 它是由数据类型组成的集合类型.
算了, 这么多字, 人都会被绕糊涂, 还是来个大概吧: 数组就是许多对象的集合, 对象的类型可以为数值, 字符串, 其它对象等等. 你可以通过每个元素的序号(叫做索引, index)来访问指定的元素. 它的功能同变量一样, 也是存贮数据的地方, 只不过是一个"集中营"而已.
Actions cript 中的数组其实是系统内建的对象类型, 之所以要将它的对象性提前到这里讲, 是因为它的用途非常广泛(也因为在 C++ 的教材里面它被放在基础部分). 譬如说, 你可以用它来存贮一个名单或是一系列坐标等.



创建数组
到现在为止还没有让大家看看数组长什么样, 是不是值得花那么多时间学, 那么, 就让我们看看它的真面目吧:
team_member = new Array();
team_member[0] = "SiC";
team_member[1] = "ReDo";
team_member[2] = "Crab_D";
trace(team_member); //显示数组内容
上面就是数组 team_member 的定义语句, 它定义了一个包含 3 个字符串的数组(即数组长度为 3). 给它赋值的语句中, 在team_member 后面的方括号里是每个元素的索引(索引由 0 开始). 其实例子中是通过 new 关键字创建一个 Array 对象的实例, 这些我们会在有关对象的章节中提到, 这里请你先记住它.
同 C 和 Java 一样, Actions cript 中的数组索引也是由 0 开始的. 在编程时应特别注意, 因为这也是初学者的常见错误之一.
如果你觉得上面的语句太繁琐, 那么上面的例子可以改为如下形式:
team_member = new Array("SiC", "ReDo", "Crab_D");
trace(team_member); //显示数组内容
它的作用与上例相同, 只不过更简洁一点. 如果要更简捷, 就用下面的方法:
team_member = ["SiC", "ReDo", "Crab_D"];
trace(team_member); //显示数组内容
注意, 这里代码中用的是方括号. 今后使用数组时可以根据具体情况选用不同的方法, 不过用得最多的还是这种.
至于用 new Array(数组长度) 创建指定长度的空数组, 因为实用价值不高(虽然在读取外部数据时可能会用到), 而且也很容易理解, 所以就不讨论了, 其方法是一样的.

--------------------------------------------------------------------------------
有时候我们希望在一个元素中包含多个元素(即元素又是一个数组), 这时候就要用到多维数组了.
对于多维数组, 最简单的创建方法就是使用方括号:
//不要忘了下面的 var 代表着什么, 如果真的忘了就看看数据类型那一章
var team_member = [[ "SiC", "无业游民", 1011 ],
[ "ReDo", "游戏杀手", 2172 ],
[ "Crab_D", "帮倒忙", 1012 ]];
trace(team_member.join("\n")); //显示数组内容
每个元素(即子数组)在 trace 输出时用 \n (换行符)分隔开. 另外在每个子数组中的元素数目也可以不相同, 这里就不举例了.
访问数组
其实访问数组的方法很简单, 第一个例子的赋值语句就已经表明了这一点. 要修改数组中某个元素的值, 只需要用 数组名[索引号] = 新值; 的格式赋值. 如果要像变量一样引用某一个元素, 只需要用 数组名[索引号] 来表示该元素就行了. 对于多维数组, 格式为 数组名[索引号1][索引号2][索引号3]...(有多少个方括号就看你要访问的是那一级的数组元素了). 下面是一个简单的例子:
var team_member = [[ "SiC", "无业游民", 1011 ],
[ "ReDo", "游戏杀手", 2172 ],
[ "Crab_D", "帮倒忙", 1012 ]];
team_member[1] = [ "UnDo", "游戏白痴", 2171]; //修改第 2 个元素(子数组)
team_member[2][1] = "关心"; //修改 "帮倒忙" 为 "关心"
trace(team_member.join("\n")); //显示数组内容
--------------------------------------------------------------------------------
有一点方便普通用户的功能是: Actions cript 的数组对象是动态的, 没有 C 语言中静态数组和动态数组的分别(毕竟不会复杂到让用户分配内存的地步). 也就是说, 你可以很方便的任意添加或移除数组元素:
team_member = new Array("SiC", "ReDo", "Crab_D"); //原来只有 3 个元素
team_member[3] = "You"; //添加第 4 个元素, 注意索引为 4-1=3
trace(team_member); //显示数组内容
上例为数组添加了第 4 个元素 "You" (请注意不是第 3 个, 索引号是从 0 开始的). 从 trace 的结果可以看出这一点.

--------------------------------------------------------------------------------
对于多维数组, 只能通过父级元素添加新元素(注意新添加的元素可以有不同数目的子元素):
var team_member = [[ "SiC", "无业游民", 1011 ],
[ "ReDo", "游戏杀手", 2172 ],
[ "Crab_D", "帮倒忙", 1012 ]];
team_member[3] = ["You", "Unknown"]; //添加新元素
team_member[0][3] = ["Yeah!"]; //添加一个新的子数组到已有元素(子数组)
team_member[0][3][1] = "Hmm?"; //添加一个新元素到新的子数组中
trace(team_member.join("\n"));
上面的例子不能用 trace 的结果表现出 "Yeah!" 和 "Hmm?" 构成的子数组(它们被紧接着父数组显示出来了, 而且也是用逗号分隔). 你可以在 Debug Movie (调试动画, Ctrl+Shift+Enter) 中用 Debugger (调试)窗口的 Variables (变量)页面查看 _level0 中 team_member 数组的内容. 注意, 进入 Debug 模式后动画是暂停的, 数组还没有定义, 要按 F8 运行后才能查看其内容. 下面是对 Debugger 面板的一点介绍:




数组对象(Array)在前面我们提到数组也是系统内建对象, 那么现在我们要讨论一下作为对象的数组有什么特殊性质. 作为一个对象, 自然会有一些属性(Property)和方法(Method)可供使用. 下面就是它们的列表:属性 描述 Array.length 返回数组长度 方法 描述 Array.concat 连接指定数组和参数中的各个数组成为新的数组并返回. Array.join 将数组中所有元素连接成为一个字符串. Array.pop 移除数组的最后一个元素并返回它的值. Array.push 在数组末尾添加一个元素并返回新的数组长度. Array.reverse 反转数组元素. (相当方便, 特别是在写某些特效时) Array.shift 移除数组的第一个元素并返回它的值. Array.slice 将数组的指定部分以一个新的数组返回. (不影响原数组) Array.sort 对数组排序. (免去了另写排序函数的必要) Array.sortOn 按字段名对数组排序. Array.splice 添加和/或移除数组元素. Array.toString 返回以逗号 "," 分隔的数组元素列表字符串. Array.unshift 在数组开头添加一个或多个元素并返回新的数组长度. 这里面最常用的是 length 属性. 在写循环时, 有时我们不能确定要处理数组的元素数目, 这时候就可以通过 length 属性获得其数目. 至于其它的那些方法, 在用到的时候查查帮助和参考里面的详细信息就够了.//显示数组内容的函数function show_member(comment) {if (my_team != undefined) { //确认数组是否存在trace(my_team.join(" , ") add " << " add comment); //在数组内容后面我加了个注释, 便于在输出时辨认} else {trace("数组未定义!");}}//为数组元素添加序号的函数function add_number(the_array) {if (the_array != undefined && the_array.length>2) { //确认数组存在并且长度大于 2for (i=0; i
上一篇: 万能驱动
下一篇: Windows Internet Explorer 7 for Windows XP SP2
文章来自: 本站原创
引用通告: 查看所有引用 | 我要引用此文章
Tags: ActionScript Flash
相关日志:
评论: 0 | 引用: 11 | 查看次数: 7410