查看完整版本: [原创] FL新春新教程，绝对原创，非常适合初、中级学习者

[原创] FL新春新教程，绝对原创，非常适合初、中级学习者

■[杂谈五] 成为编程高手的八大奥秘
■[AS 功能代码教程15] 点间距离公式 [FL基础理论大师]
■[Flash基础理论课16] 矩阵革命 [双重循环]
■[AS 功能代码教程14] 鱼眼放大镜 [FL基础理论大师]
■[AS 功能代码教程13] 贪吃蛇游戏制作 [FL基础理论大师]
■[Flash基础理论课15] 绚酷鼠标 [目标移动]
■[Flash基础理论课14] 制作Loading [Loading]
■[杂谈四] JavaScript就这么回事 [二次编辑贴]
■[AS 功能代码教程12] 填色游戏 [FL基础理论大师]
■[Flash基础理论课13] FL记事本 [SharedObject]
■[杂谈四] AS代码优化技巧 [综合贴]
■[AS 功能代码教程11] 图片转场效果 [FL基础理论大师]
■[Flash基础理论课12] 倒计时系统 [getTime]
■[杂谈四] 程序员应该学C语言的十个理由
■[AS 功能代码教程10] 数据结构排序算法 [FL基础理论大师]
■[Flash基础理论课11] AS文本计算器 [文本类]
■[AS 功能代码教程09] 点阵字效果 [FL基础理论大师]
■[AS 功能代码教程08] BitmapData动态效果 [FL基础理论大师]
■[Flash基础理论课10] 缓动效果 [Tween类]
■[杂谈三] 微软Silverlight和Flash短兵相接
■[AS 功能代码教程07] 百变图 [FL基础理论大师]
■[AS 功能代码教程06] AS绘图总结及补充 [FL基础理论大师]
■[Flash基础理论课09]满天星及变幻线[MC.onEnterFrame]
■[Flash基础理论课08]旋转花朵[for...in]
■[游戏赏玩]吸泡泡
■[Flash基础理论课07]制作控制滑块[startDrag]
■[杂谈二]人类的15个欲望与游戏设计
■[AS 功能代码教程04] 进阶三角函数及应用 [FL基础理论大师]
■[Flash基础理论课06]制作移动角色[Key类]
■[Flash基础理论课05]制作摇奖盘[onEnterFrame]
■[AS 功能代码教程05] 打字机效果及字符串概念 [FL基础理论大师]
■[AS 功能代码教程03] 基础三角函数及应用 [FL基础理论大师]
■[AS 功能代码教程02]数字魔方及数组概念[FL基础理论大师]
■[AS 功能代码教程01]通用延迟代码及FPS概念[FL基理大师原创]
■[Flash基础理论课04] 制作音乐播放器[Sound类]
■[Flash基础理论课03]制作简易涂鸦板[画线指令]
■[Flash基础理论课02]制作个性鼠标[updateAfterEvent]
■[Flash基础理论课01]制作时钟[Date类]
■[杂谈一] 什么是真正的Flash高手？
欢迎来到我的博客参观学习：[url=http://blog.sina.com.cn/yyy98]http://blog.sina.com.cn/yyy98[/url]
希望朋友们多提保贵议建，您的题问和课题将成文我前进的最大动力。

很不错的，我把内容复制如下。感谢分享：
1。[杂谈五] 成为编程高手的八大奥秘
不知不觉做软件已经做了十年，有成功的喜悦，也有失败的痛苦，但总不敢称自己是高手，因为和我心目中真正的高手们比起来，还差得太远。世界上并没有成为高手的捷径，但一些基本原则是可以遵循的。

1.扎实的基础

　　数据结构、离散数学、编译原理，这些是所有计算机科学的基础，如果不掌握它们，很难写出高水平的程序。程序人人都会写，但当你发现写到一定程度很难再提高的时候，就应该想想是不是要回过头来学学这些最基本的理论。不要一开始就去学OOP，即使你再精通OOP，遇到一些基本算法的时候可能也会束手无策。因此多读一些计算机基础理论方面的书籍是非常有必要的。

2.丰富的想像力

　　不要拘泥于固定的思维方式，遇到问题的时候要多想几种解决问题的方案，试试别人从没想过的方法。丰富的想像力是建立在丰富的知识的基础上，除计算机以外，多涉猎其他的学科，比如天文、物理、数学等等。开阔的思维对程序员来说很重要。

3.最简单的是最好的

　　这也许是所有科学都遵循的一条准则，复杂的质能转换原理在爱因斯坦眼里不过是一个简单得不能再简单的公式：E=mc2。简单的方法更容易被人理解，更容易实现，也更容易维护。遇到问题时要优先考虑最简单的方案，只有简单方案不能满足要求时再考虑复杂的方案。

4.不钻牛角尖

　　当你遇到障碍的时候，不妨暂时远离电脑，看看窗外的风景，听听轻音乐，和朋友聊聊天。当我遇到难题的时候会去玩游戏，当负责游戏的那部分大脑细胞极度亢奋的时候，负责编程的那部分大脑细胞就得到了充分的休息。当重新开始工作的时候，我会发现那些难题现在竟然可以迎刃而解。

5.对答案的渴求
　　人类自然科学的发展史就是一个渴求得到答案的过程，即使只能知道答案的一小部分也值得我们去付出。只要你坚定信念，一定要找到问题的答案，你才会付出精力去探索，即使最后没有得到答案，在过程中你也会学到很多东西。

6.多与别人交流

　　三人行必有我师，也许在一次和别人不经意的谈话中，就可以迸出灵感的火花。多上上网，看看别人对同一问题的看法，会给你很大的启发。

7.良好的编程风格

　　注意养成良好的习惯，代码的缩进编排，变量的命名规则要始终保持一致。大家都知道如何排除代码中错误，却往往忽视了对注释的排错。注释是程序的一个重要组成部分，它可以使你的代码更容易理解，而如果代码已经清楚地表达了你的思想，就不必再加注释了，如果注释和代码不一致，那就更加糟糕。

8.韧性和毅力

　　这也许是“高手”和一般程序员最大的区别。高手们并不是天才，他们是在无数个日日夜夜中磨炼出来的。成功能给我们带来无比的喜悦，但过程却是无比的枯燥乏味。你不妨做个测试，找个10000以内的素数表，把它们全都抄下来，然后再检查三遍，如果能够不间断地完成这一工作，你就可以满足这一条。

[[i] 本帖最后由 8765004 于 2008-2-2 14:49 编辑 [/i]]

2。[AS 功能代码教程15] 点间距离公式 [FL基础理论大师]
两点间距离
Math.sqrt(Math.pow((p1._x-p2._x),2)+Math.pow((p1._y-p2._y),2))
由这个公式可以推导出某点与原点距离公式：
因为原点坐标为(0,0)，所以公式变形如下
Math.sqrt(p1._x * p1._x + p1._y * p1._y)
下面我们就来运用这两个公式来制作一些效果
实例一: 旋转指针
思路：
求一个夹角的θ方法很多如:
distance.jpg
正弦函数 sinθ=y/r
余弦函数 cosθ=x/r
正切函数 tanθ=y/x
余切函数 cotθ=x/y
正割函数 secθ=r/x
余割函数 cscθ=r/y
这些三角函数都可以求出同一个夹角θ
在本实例中只使用 atan 和 acos 而没有使用其它三角函数是因为他们的返回值都是一个任意数字，而其它函数的返回值均为限定的数字。
步骤一:
    绘制一指针，保存为影片剪辑，注册点在指针根部，实例名为"pointer"

步骤二:
在第一帧加入AS代码(正切函数)：
pointer.onMouseMove = function() {
var dx = _xmouse-this._x;
var dy = _ymouse-this._y;
var theta = Math.atan2(dy, dx);
//使用正切函数求出夹角
this._rotation = theta/Math.PI*180;
//将弧度转换为角度
};

在第一帧加入AS代码(反余弦函数)：
pointer.onMouseMove = function() {
var dx = _xmouse-this._x;
var dy = _ymouse-this._y;
var r = Math.sqrt(dx*dx+dy*dy);
//r为点与鼠标的直线距离，这里也是斜边r
var theta = Math.acos(dx/r)*Math.abs(dy)/dy;
//使用反余弦函数求出夹角
this._rotation = theta/Math.PI*180;
//将弧度转换为角度
};
实例二: 泡泡效果
思路：
通过判断鼠标的移动距离改变复制出泡泡的大小，移动得越远，泡泡越大

步骤一:
    绘制泡泡，保存为影片剪辑，连接—＞导出—＞标志符"bubble"
步骤二:
在第一帧加入AS代码：
var n:Number = 0;
var old_x, old_y;
//这两个全局变量用于存储前一次的鼠标位置
_root.onMouseMove = function() {
var dx = _xmouse-old_x;
var dy = _ymouse-old_y;
var distance = Math.sqrt(dx*dx+dy*dy);
//求出本次鼠标位置和前一次鼠标位置的距离
var p = attachMovie("bubble", "b"+n, n);
p._x = _xmouse;
p._y = _ymouse;
p._width = p._height=distance;
//用得出的距离为泡泡设置尺寸
p.onEnterFrame = function() {
  if (this._alpha>0) {
   this._xscale = this._yscale += 5;
   this._alpha -= 5;
   //做一个泡泡变大消失的效果
  } else {
   delete this.onEnterFrame;
   removeMovieClip(this);
   //泡泡看不见后，别忘了删除他的影片和函数，否则会卡哟
  }
};
old_x = _xmouse;
old_y = _ymouse;
//保存本次鼠标位置作为前一次鼠标的位置
n++;
};

实例三: 辐射点效果
思路：
1.把点以行列的形式平均分配到舞台上
2.用点间距离公式，判断每个点与鼠标的距离
3.缩放值 = 距离 - 120

4.当120<距离<220时，则缩放值开始变小[100～0]，表现为向内开始变小
5.当距离<120时，则缩放值小于0，表现为向内开始变大，开始走向负数

6.当距离为0时，则缩放值为 -120，表现为鼠标中心位置上较大的那些圆
步骤一:
    绘制一黑点，尺寸为20*20，保存为影片剪辑，
    注册点在中心，连接—＞导出—＞标志符"dot"
步骤二:
var size = 20;
//黑点的大小
var Colum = Math.floor(Stage.width/size);
var Row = Math.floor(Stage.height/size);
for (var i = 0; i<Colum; i++){
for (var j = 0; j<Row; j++){
  var p = _root.attachMovie("dot", "d"+(i*Row+j), i*Row+j);
  p._x = (size/2)+i*size;
  p._y = (size/2)+j*size;
  //以行列的形式把点平均分配到舞台上
  p.onMouseMove = function() {
   var dx = this._x-_xmouse;
   var dy = this._y-_ymouse;
   var distance = Math.sqrt(dx*dx+dy*dy);
   var d = distance-120;
   //如果距离大于220，则不进行缩放，距离小于220则为进行缩放
   if (d>100) {
    d = 100;
   }
   //或 d = d>100 ? 100 : d;
   this._xscale = this._yscale=d;
  };
}
}
实例四: 狡猾的小球
先复习一下圆的参数方程：x坐标 = R*cosθ+m; y坐标 = R*sinθ+n
根据正弦函数 sinθ=y/r 和 余弦函数 cosθ=x/r推出圆的参数方程为：
x坐标 = R*(x/r)+m; y坐标 = R*(y/r)+n 其中(m,n)为原点坐标。
思路：
1.使用变型的圆参数方程: x= R*(x/r)+m; y= R*(y/r)+n
2.为了让小球躲得更远可以加入新圆心坐标dif_x, dif_y
3.得出球的新位置 ＝球的初始位置—(圆心位置＋圆上的位置)
步骤一:
    绘制一黑点，尺寸为20*20，保存为影片剪辑，
    注册点在中心，连接—＞导出—＞标志符"dot"
步骤二:
在第一帧加入AS代码：
var size = 30;
//比点的尺寸大出10像素作为行列间距
var Colum = Math.floor(Stage.width/size)-2;
var Row = Math.floor(Stage.height/size)-2;
//行数列数减2，目的是在周围空出2行
var Max = 1000;
//反映及影响圆半径的常量
for (var i = 0; i<Colum; i++){
for (var j = 0; j<Row; j++){
  var p = _root.attachMovie("dot", "d"+(i*Row+j), i*Row+j);
  p._x = p.oldx=20+(size/2)+i*size;
  p._y = p.oldy=20+(size/2)+j*size;
  //以行列的形式把点平均分配到舞台上，同时保存初始位置为oldx,oldy
  p.onEnterFrame = function() {
   var dx = _xmouse-this._x;
   var dy = _ymouse-this._y;
   var r = Math.sqrt(dx*dx+dy*dy);
   //r为点与鼠标的直线距离，这里也是斜边r
   var Circle_x = (dx/r)*Max/r;
   var Circle_y = (dy/r)*Max/r;
   //计算出该点在圆上的位置，Max/r为半径，所以r越小半径越大
   var dif_x = (this.oldx-this._x)/2;
   var dif_y = (this.oldy-this._y)/2;
   //以球的新位置与初始位置之差为新的圆心
   this._x = this.oldx-(dif_x+Circle_x);
   this._y = this.oldy-(dif_y+Circle_y);
   //得出球的新位置＝球的初始位置—(圆心位置＋圆上的位置)
   //之所以减去(圆心位置＋圆上的位置): 让小球位置与鼠标位置相反
  };
}
}

教程到此结束
QQ：147461195（FL基理大师）

3。[Flash基础理论课16] 矩阵革命 [双重循环]
在本次课中我们将介绍两种方法来完成该效果，重点掌握双重循环语句
还要介绍 TextField._alpha 方法不可用的解决办法
单循环:
for (i=0; i<5; i++) {
trace("i="+i);
}

运行结果如下：
i=0
i=1
i=2
i=3
i=4

双重循环:
就是在for循环中再加入一个for循环
for (i) {
   for(j) {}
}

下面看一个双重循环的例子
for (i=0; i<5; i++) {
for (j=0; j<3; j++) {
  trace("i="+i+" j="+j);
}
}
运行结果如下：
i=0 j=0
i=0 j=1
i=0 j=2
i=1 j=0
i=1 j=1
i=1 j=2
i=2 j=0
i=2 j=1
i=2 j=2
i=3 j=0
i=3 j=1
i=3 j=2
i=4 j=0
i=4 j=1
i=4 j=2
i=5 j=0
i=5 j=1
i=5 j=2
i=6 j=0
i=6 j=1
i=6 j=2
i=7 j=0
i=7 j=1
i=7 j=2
i=8 j=0
i=8 j=1
i=8 j=2
i=9 j=0
i=9 j=1
i=9 j=2



总结一下可以这样写：
当i=0时，j=0, j=1, j=2
当i=1时，j=0, j=1, j=2
当i=2时，j=0, j=1, j=2
当i=3时，j=0, j=1, j=2
当i=4时，j=0, j=1, j=2

我们再形象地解释一下双重循环的意思：
把 for (i=0;i<5;i++){...} i从0到4，循环了5次，就把这五次循环表示为5个人
"小赵"，"小钱"，"小孙"，"小李"，"小周"
把 for (j=0;j<3;j++){...} j从0到2，循环了3次，就把这三次循环表示为3件事
"买菜"，"买肉"，"买米"
就相当于：
当i="小赵"时，他要去 j="买菜", j="买肉", j="买米"
当i="小钱"时，他要去 j="买菜", j="买肉", j="买米"
当i="小孙"时，他要去 j="买菜", j="买肉", j="买米"
当i="小李"时，他要去 j="买菜", j="买肉", j="买米"
当i="小周"时，他要去 j="买菜", j="买肉", j="买米"

本节中将用到的利用双重循环实现行列分配的问题
columrow2.jpg

已知库中有一个链接名为 mc 的影片剪辑，为一个圆，大小为30，注册点在左上
var size = 30;
var Colum = Math.floor(Stage.width/size);
//根据圆大小，确定横向能容纳多少个圆，就是有多少个列
var Row = Math.floor(Stage.height/size);
//根据圆大小，确定纵向能容纳多少个圆，就是有多少个行
for (var i = 0; i<Colum; i++){
for (var j = 0; j<Row; j++){
  var p = _root.attachMovie("dot", "d"+(i*Row+j), i*Row+j);
//i*Row+j 确保每个影片的新名字和深度都不相同

//这里也可使用getNextHighestDepth()
  p._x = i*size;
  p._y = j*size;
//设置圆的位置，双循环的意思是: 有 Colum 行，且每一行中都有 Row 个列
}
}

解释过来就是：
当 x 坐标 ＝ 第1列时，分配Row个圆，y坐标从0到Row-1
当 x 坐标 ＝ 第2列时，分配Row个圆，y坐标从0到Row-1
当 x 坐标 ＝ 第3列时，分配Row个圆，y坐标从0到Row-1

                        ... ...
当 x 坐标 ＝ 第Colum-1列时，分配Row个圆，y坐标从0到Row-1



矩阵革命:

制作方法（一）

思路:
1.制作一个有若干帧的影片剪辑，每一帧都代表一个随机的字母或数字;
2.设置影片文本的大小为30，用舞台大小除以字母大小，确定每行每列能容纳多少文本;
3.每列容纳字符个数为Colum个，共Row列;
4.根据Colum和Row的确定影片的行位置和列位置。

步骤1:

columrow2.jpg

    制作一个影片剪辑，有若干帧，每帧中一个静态文本框

    内容为一个字母或一个数字
    字体: Arial，字号: 30，加粗，颜色:0x00FF00
    连接—＞导出—＞字符"txt"

步骤2:
在第一帧中写入代码
var size = 32;
//比文本框大出2个象素，做为行列间距
var Colum = Math.floor(Stage.width/size);
//按照字符大小，确定每列能容纳多少个字符
var Row = Math.floor(Stage.height/size);
//按照字符大小，确定每行能容纳多少个字符
for (var i = 0; i<Colum; i++){

for (var j = 0; j<Row; j++){
  var p = _root.attachMovie("txt", "t"+(i*Row+j), i*Row+j);
  p._x = i*size;
  p._y = j*size;
  //安排每个新字符影片的位置，每一行中都有Row个列
  p.onEnterFrame = function() {
   this.gotoAndStop(random(this._totalframes));
   //每次随机取一帧，实现随机字母或数字
   this._alpha = random(100);
   //随机的设置影片剪辑的透明度
  };
}
}


在写本节内容时，原本只想用方第二种方法（纯AS编写），但在测试中发现 TextField._alpha 和TextField._rotation 方法是“无效”的，随后在网络上发现了解决的办法，下面我们先来看一下纯AS编写的部分，然后在看“失效”的解决办法。



制作方法（二）
思路：这次只使用创建TextFiled的方法，而不是再使用影片剪辑中的方法

在第一帧中加入以下代码
var t_f:TextFormat = new TextFormat();
t_f.size = 20;
t_f.font = "Arial";
//设置字体格式
var Colum = Math.floor(Stage.width/t_f.size);
var Row = Math.floor(Stage.height/t_f.size);
for (var i = 0; i<Colum; i++) {

  for (var j = 0; j<Row; j++) {
var T=_root.createTextField("txt"+(i*Row+j),i*Row+j,0,0,0,0)
  //创建文本框
  T._x = i*t_f.size;
  T._y = j*t_f.size;
  //设置其坐标位置
  T.textColor = 0x00ff00;
  T.setNewTextFormat(t_f);
  T.autoSize = true;
  T.selectable = false;
  //T.embedFonts = true;
  //设置文本框属性
}
}
_root.onEnterFrame = function () {
for (var i = 0; i<Colum*Row; i++) {
  if (Math.random()<0.5) {
   this["txt"+i].text = String.fromCharCode(65+random(26));
   //随机的字母
  } else {
   this["txt"+i].text = String.fromCharCode(48+random(10));
   //随机的数字
  }
  //this["txt"+i]._alpha = random(100);
  //随机的文本透明度
}
};


解释一下被注释掉的两句:
T.embedFonts = true;
使用嵌入字体轮廓进行呈现，前提是在库中要导入该字体元件
this["txt"+i]._alpha = random(100);
在T.embedFonts = true; 设置文本框透明度



TextField._alpha 和 TextField._rotation 方法“失效”解决办法

1.在库中创建字型
<1>点库右上角的倒三角，选择“新建字型...”
<2>建立字体元件（和你的字体名字变量一样），然后选择字体
<3>右键选择你刚创立的元件。选择“为ActionScript导出”写入链接名，本节中为"Arial"

2.设置 TextField._embedFonts = true

使用嵌入字体轮廓进行呈现，是使用 TextField._alpha 和TextField._rotation 的前提，嵌入字体轮廓就是指在库中导入字型。

好了现在可以加上注释掉的两句使一使效果了
教程到此结束。QQ：147461195（FL基理大师）

4。[AS 功能代码教程14] 鱼眼放大镜 [FL基础理论大师]
本节加了星号，借黑羽的话：“本节的内容稍微有些难度，如果不明白，可以暂时不看，待日后碰到类似问题时，再来查阅”

下面我们先用图解法来解释一下本实例

思路：
1.鱼眼放大镜是于若干个渐小的圆组成的;
2.使每个圆都去遮罩一个渐大的图片来实现，里面的小圆遮罩大较图片，外面的大圆遮罩较小图片;
3.还有最后一个重要的步骤是"对焦"，由于图片是渐大的，所以鼠标所在的一个点位对于小图来说也许是头部，而对于大图来说也许都到了场外，那么显示出的效果就错了。使用"对焦"可以让鼠标指在小图上是头部，大图上也要是头部，这么说给大家一个印象，下面请看图解.

图解：

Mag4.jpg

1.首先在舞台上放入两个影片剪辑，其中一个是图片，实例名"pic"，注册点在左上(0,0)；另一个是圆，大小：200*200，实例名"ball"，注册点在中心;



Mag4.jpg

2.鱼眼放大镜是于若干个渐小的圆组成，让这些圆作为镜片，重叠在一起，同时成像，圆(镜片)的数量越多，成像效果越细，图中数量为3
代码如下：
var Count:Number = 3;
//复制圆(镜片)的数量
for (var i = 0; i<Count; i++){
var b = ball.duplicateMovieClip("B"+i, i*2+1);
//复制圆
b._xscale = b._yscale=(1-i/Count)*100;
//圆的缩放＝ (1-第i个圆/圆的数量)*100，例:100～90～80～70
}


Mag4.jpg

3.每个圆都加载一个渐大的图片，先来创建这些渐大的图片，图的数量为3
  代码如下：
var Count:Number = 3;
//复制圆(镜片)的数量
var Zoom:Number = 0.08;
//图片放大的递增倍数
for (var i = 0; i<Count; i++){
var dif = 1+i*Zoom;
//缩放比(dif)为递增量，例:1.00～1.08～1.16～1.24...
var p = pic.duplicateMovieClip("P"+i, i*2);
//复制图片
p._xscale = p._yscale=dif*100;
//图片缩放＝递增量*100，例:100～108～116～124...
}


Mag4.jpg

4.综合上述实现，里面的小圆遮罩大较图片，外面的大圆加载较小图片，再加入一句保存初始缩放比的语句
var Count:Number = 30;
//复制圆(镜片)的数量
var Zoom:Number = 0.08;
//图片放大的递增倍数
for (var i = 0; i<Count; i++){
var dif = 1+i*Zoom;
//dif为递增量，例:1.00～1.08～1.16～1.24...
var b = ball.duplicateMovieClip("B"+i, i*2+1);
//复制圆
b._xscale = b._yscale=(1-i/Count)*100;
//圆的缩放＝ (1-第i个圆/圆的数量)*100，例:100～90～80～70
b.Zoom = dif;
//保存图片的缩放比
var p = pic.duplicateMovieClip("P"+i, i*2);
//复制图片
p._xscale = p._yscale=dif*100;
//图片缩放＝递增量*100，例:100～108～116～124...
p.setMask(b);
//进行遮罩
}

5."对焦"
请大家看一看下面的演示动画，也许能让你了解他的含义

Mag4.jpg

这是两张没有"对焦"的图片，大家注意，如果鼠标在小图的红星位置，那么对于大图来说，也许是人物的脸部，而不是大图的红星位置
Mag4.jpg

这是两张执行"对焦"后的图片，如果鼠标在小图的红星位置，那么对于大图来说，也要在红星位置上
如何实现"对焦"功能，请看下面代码：
_root.onMouseMove = function() {
for (var i = 1; i<=Count; i++) {
  var balls = this["B"+i];
  balls._x = _xmouse;
  balls._y = _ymouse;
  //使每个镜片都跟着鼠标移动
  this["P"+i]._x = _xmouse-(_xmouse-pic._x)*balls.Zoom;
  this["P"+i]._y = _ymouse-(_ymouse-pic._y)*balls.Zoom;
  //调整每个复制出的图片的位置
  //新的位置 ＝ 鼠标位置 — (鼠标位置 — 原图pic的位置) * 缩放比
}
};

根据 "对焦" 公式：
新的位置 ＝ 鼠标位置 — (鼠标位置 — 原图pic的位置) * 缩放比
本实例中，原图pic的位置为左上(0,0)点，所以，公式可以变形为：
新的位置 ＝ 鼠标位置 — 鼠标位置 * 缩放比

这个公式也是本节的难点，就以原图位置在左上(0,0)为例

如果鼠标在右边，那么新位置肯的为负数，新位置向左移，因为缩放比是大于1.00的数；反之，则是两个负数相加，新位置向右移
好的，整个思路就这些，下面给出完整过程

步骤1：
    首先在舞台上放入两个影片剪辑

    其中一个是图片，实例名”pic”，注册点在左上(0,0)；

    另一个是圆，大小：200*200，实例名”ball”，注册点在中心
步骤2：
在第一帧加入AS代码
var Count:Number = 30;
//复制圆(镜片)的数量
var Zoom:Number = 0.08;
//图片放大的递增倍数
for (var i = 0; i<Count; i++){
var dif = 1+i*Zoom;
//dif为递增量，例:1.00～1.08～1.16～1.24...
var b = ball.duplicateMovieClip("B"+i, i*2+1);
//复制圆
b._xscale = b._yscale=(1-i/Count)*100;
//圆的缩放＝ (1-第i个圆/圆的数量)*100，例:100～90～80～70
b.Zoom = dif;
//保存图片的缩放比
var p = pic.duplicateMovieClip("P"+i, i*2);
//复制图片
p._xscale = p._yscale=dif*100;
//图片缩放＝递增量*100，例:100～108～116～124...
p.setMask(b);
//进行遮罩
}
_root.onMouseMove = function() {
for (var i = 1; i<=Count; i++) {
  var balls = this["B"+i];
  balls._x = _xmouse;
  balls._y = _ymouse;
  //使每个镜片都跟着鼠标移动
  this["P"+i]._x = _xmouse-(_xmouse-pic._x)*balls.Zoom;
  this["P"+i]._y = _ymouse-(_ymouse-pic._y)*balls.Zoom;
  //调整每个复制出的图片的位置
  //新的位置 ＝ 鼠标位置 — (鼠标位置 — 原图pic的位置) * 缩放比
}
};


教程到此结束
QQ：147461195（FL基理大师）

5。FL基础理论大师———贪吃蛇游戏   按'方向键'开始
思路:
1.首先规定蛇的运动区域宽度(stagew)和高度(stageh)
2.增加键盘侦听,获得键控代码,如果该键与前一个键是反向的则不予改变
3.初始化中, 请注意：蛇头、蛇身、食物的大小均为 7 象素
4.每一次移动的步长(Move)均为8象素,以实现身体为一格一格的效果
5.吃到食物后，蛇身(body)长度增加5个单位,复制出5个身体
6.履带式前进:从尾部开始,后一个跟随前一个的位置,最前面的跟随蛇头



图示:
1.整体思路

SnakeTree.jpg

2.蛇头、蛇身、食物的大小均为 7 象素，步长 8 象素

SnakeTree.jpg


步骤1:

SnakeTree.jpg

  *绘制一个正方形做(代表蛇头、蛇身、食物)，尺寸随意，保存为影片剪辑
   注册点在左上(0,0)，连接—＞导出—＞标志符"block"

  *FPS为18左右
步骤2:
加入AS代码

//========== 绘制出蛇活动的区域 ==========
var stagew:Number = 447;
var stageh:Number = 255;
beginFill(0xeeeeee);
moveTo(0, 0);
lineTo(stagew, 0);
lineTo(stagew, stageh);
lineTo(0, stageh);
endFill();
//========== 创建一个文本框用于显示信息 ==========
_root.createTextField("txt", -100, 1, 255, 400, 30);
txt.text = "贪吃蛇游戏   按'方向键'开始";
//========== 建立键盘侦听 ==========
Key.addListener(txt);
//使用一个已有的对象txt作侦听，免去了新建侦听对象了，节约了空间
var NowKey:Number;
//NowKey全局变量用于存储当前按下的键
txt.onKeyDown = function() {
var c = Key.getCode()-37;
//c= 左键0 上键1 右键 2 下键3
if ((c<4) && (Math.abs(NowKey-c) != 2)) {
  NowKey = c;
//如果蛇正在向左移动那么他就不能向右移动，如果正向上移动就不能向下移动
//左(0)和右(2)相差2，上(1)和下(3)相差2，所以如果他们相差2则该键无效

}
};
//========== 下面是一系列初始化 ==========
_root.attachMovie("block", "head", -1, {_width:7, _height:7});
//首先创建蛇头，它的大小为7像素
var Move:Number = 8;
//每次移动的距离比蛇头多出1像素，这样就可以做出一格一格的效果了
head._x = head._y=20*Move;
//蛇头的起点位置要(移动距离的倍数)
var body:Number = 0;
//蛇身的长度初值
var GameOver:Boolean = false;
//标志游戏是否结束的标记
//========== 创建食物的函数 ==========

createfood();
function createfood() {
_root.attachMovie("block", "food", 0, {_width:7, _height:7});
//食物的深度永远为0，这样省去了删除被吃掉的食物的操作
new Color(food).setRGB(0xff0000);

//食物为红色的block
var Colum:Number = stagew/Move;
var Row:Number = stageh/Move;
//Colum为总列数，Row为总行数
food._x = random(Colum)*Move;
food._y = random(Row)*Move;
//食物随机出现的位置(移动距离的倍数)
}
//========== 主函数 ==========
_root.onEnterFrame = function() {
switch (NowKey) {
  //根据方向键值决定蛇头的移动方向
case 0 :
  head._x -= Move;
  break;
case 1 :
  head._y -= Move;
  break;
case 2 :
  head._x += Move;
  break;
case 3 :
  head._y += Move;
}
if (head._x<0 || head._x>stagew || head._y<0 || head._y>stageh) {
  GameOver = true;
  //头部出界则游戏结束
}
if (head.hitTest(food)) {
  createfood();
  //头部与食物接触后，调用新的食物
  for (var i = 1; i<=5; i++) {
   _root.attachMovie("block", "body"+(body+i), body+i, {_width:7, _height:7, _x:-50, _y:-50});
   //同时，蛇的身长增加5个单位,初始大小 7 ，初始位置在场景外
  }
  body += 5;
  txt.text = "分数 "+body;
}
for (var i = body; i>0; i--) {
  if (head.hitTest(this["body"+i])) {
   GameOver = true;
   //判断蛇体是否与头部接触，如果是游戏结束
  }
  if (i == 1) {
   this["body"+i]._x = head._x;
   this["body"+i]._y = head._y;
  } else {
   this["body"+i]._x = this["body"+(i-1)]._x;
   this["body"+i]._y = this["body"+(i-1)]._y;
  }
  //这个循环从尾至头各向前移动一个单位，与蛇头最近的身体与蛇头重合

}
if (GameOver) {
  //标志位GameOver为真时，显示游戏结束，删除onEnterFrame，移动停止
  txt.text = "游戏结束";
  delete this.onEnterFrame;
}
};

Flash 充电1: mc.attachMovie()
作用: 从库中复制影片剪辑

语法:
mc.attachMovie(id:String, name:String, depth:Number, [initObject:Object])
mc:MovieClip - 为该影片的父级影片
id:String - 库元件的链接名称;
name:String - 该影片剪辑实例的唯一名称;
depth:Number - 指定 SWF 文件所放位置的深度级别;
initObject:Object [可选] - 影片剪辑的属性的对象。

例如: 在库中有一元件标识符为"block"
_root.createEmptyMovieClip("MC", -1);
for (var i = 0; i<10; i++) {
MC.attachMovie("block", "b"+i, i, {_width:30, _height:30, _x:i*30, _y:10});
}
trace(MC["b"+0]._parent);
//被复制出的影片剪辑的父级影片为MC
trace(MC["b"+0]._parent._parent);
//被复制出的影片剪辑的父级影片的父级影片为_root


Flash 充电2: mc.duplicateMovieClip()
作用: 复制舞台上的影片剪辑

语法:
mc.duplicateMovieClip(name:String, depth:Number, [initObject:Object])
mc:MovieClip - 被复制的对象
name:String - 该影片剪辑实例的唯一名称;
depth:Number - 指定 SWF 文件所放位置的深度级别;
initObject:Object [可选] - 影片剪辑的属性的对象。

例如: 舞台中有一影片剪辑实例名为"MC"
for (var i = 0; i<10; i++) {
MC.duplicateMovieClip("M"+i, i, {_width:30, _height:30, _x:i*30, _y:10});
}

Flash 充电3: 影片剪辑的删除
注意：在删除时要区分复制的影片剪辑和非复制的影片剪辑
      对于复制的影片剪辑使用 removeMovieClip(target:Object)
      对于非复制的影片剪辑使用 unloadMovie(target:Object)
复制的影片剪辑: 指用duplicateMovieClip()、MovieClip.duplicateMovieClip()、MovieClip.createEmptyMovieClip() 或 MovieClip.attachMovie() 创建的影片剪辑实例。
非复制的影片剪辑: 指一开始就存在于舞台上的影片剪辑，即不是使用代码复制出来的影片。

教程到此结束
QQ：147461195（FL基理大师）

6。[Flash基础理论课15] 绚酷鼠标 [目标移动]
本次课中我们将演示三种鼠标跟随效果的实例

在学习之前，我们先复习一下前面(功能代码07<百变图>)曾用过的
目标移动公式:

mc.当前坐标 += (mc.目标坐标 - mc.当前坐标) * A 缓动常量(0<A<1)


例如:

舞台上有一个影片剪辑，实例名为 mc，使其移动到 x=400, y=300 的位置
mc.Tox = 400;
mc.Toy = 300;
mc.onEnterFrame = function() {
  this._x += (this.Tox-this._x)*0.3;
  this._y += (this.Toy-this._y)*0.3;
//更新每个实例的坐标了，可理解为:
//实例的 X 坐标 = 自己的X坐标 +（目标的X坐标–自己的X坐标）*0.3
//实例的 Y 坐标 = 自己的Y坐标 +（目标的Y坐标–自己的Y坐标) *0.3
};

实例一

思路:
1.复制出Num个鼠标，鼠标的透明度递减(如果i是递增的，N-i 就是递减的);
2.用第Num鼠标作为当前鼠标，其它均为跟随;
3.跟随的原理就是以前一个鼠标位置作为目标坐标，使后一个鼠标向前一个的位置移动。

步骤1:

CoolMouse1.jpg

     绘制一个鼠标，保存为影片剪辑，连接—＞导出—＞标志符"mouse"
步骤2:
加入AS代码:
Mouse.hide();
//隐藏原有鼠标
var Num = 10;
//鼠标跟随的数量
for (var i = 0; i<Num ; i++){
_root.attachMovie("mouse", "m"+i, i);
//复制出Num个鼠标的影片剪辑
this["m"+i]._alpha = (Num-i)/Num*100;
//设置出渐隐效果，每个鼠标的透明度递减
}
_root.onEnterFrame = function() {
this["m"+0]._x = _xmouse;
this["m"+0]._y = _ymouse;
//让this["m"+0]作为当前鼠标
for (var i = 1; i<Num ; i++){
  this["m"+i]._x += ((this["m"+(i-1)]._x)-this["m"+i]._x)*0.5;
  this["m"+i]._y += ((this["m"+(i-1)]._y)-this["m"+i]._y)*0.5;
}
//令后一个鼠标跟随前一个鼠标的位置，缓动地向前一个鼠标接近
};

实例二

思路:
1.方法与实例一类似;
2.改变了鼠标跟随的样式;
3.使小的鼠标透明度大，大的鼠标透明度小(如果i是递增的，N-i 就是递减的)。

步骤1:

CoolMouse1.jpg

     绘制一个鼠标，保存为影片剪辑，连接—＞导出—＞标志符"mouse"
步骤2:
加入AS代码:
Mouse.hide();
//隐藏原有鼠标
var Num = 10;
//鼠标跟随的数量
for (var i = 0; i<Num ; i++){
_root.attachMovie("mouse", "m"+i, i);
this["m"+i]._xscale = this["m"+i]._yscale=i/Num*100;
//鼠标的尺寸递增
this["m"+i]._alpha = (Num-i)/Num*100;
//鼠标的透明度递减
}
_root.onEnterFrame = function() {
this["m"+0]._x = _xmouse;
this["m"+0]._y = _ymouse;
for (var i = 1; i<Num ; i++){
  this["m"+i]._x += ((this["m"+(i-1)]._x)-this["m"+i]._x)*0.5;
  this["m"+i]._y += ((this["m"+(i-1)]._y)-this["m"+i]._y)*0.5;
}
};

实例三

思路:
1.方法与实例一类似;
2.改变了鼠标跟随的样式，也是使鼠标跟随围成一个圆的关键;
3.改变每个鼠标的旋转。

步骤1:

CoolMouse1.jpg

     绘制一个鼠标，保存为影片剪辑，连接—＞导出—＞标志符"mouse"
     注意：鼠标与注册点之间要留有一定的距离，这是使之围成圆的关键
步骤2:
加入AS代码:
var Num = 30;
//鼠标跟随的数量
for (var i = 0; i<Num ; i++){
_root.attachMovie("mouse", "m"+i, i);
this["m"+i]._rotation = i*24;
//设置初始的旋转角度
this["m"+i]._alpha = (Num-i)/Num*100;
}
_root.onEnterFrame = function() {
this["m"+0]._x = _xmouse;
this["m"+0]._y = _ymouse;
this["m"+0]._rotation += 10;
for (var i = 1; i<Num ; i++){
  this["m"+i]._x += ((this["m"+(i-1)]._x)-this["m"+i]._x)*0.5;
  this["m"+i]._y += ((this["m"+(i-1)]._y)-this["m"+i]._y)*0.5;
  this["m"+i]._rotation += 10;
  //使所有鼠标都转起来
}
};

Flash 充电: for 循环实现数组反向存储
var Len = 20;
//数组长度
var A:Array = new Array(Len);
for (var i = 0; i<Len ; i++){
A[i] [I]= Len-i;
//A[Len-i-1] = i;
}
trace(A);

教程到此结束QQ：147461195（FL基理大师）[/i]

[[i] 本帖最后由 8765004 于 2008-2-2 15:13 编辑 [/i]]

7。[Flash基础理论课14] 制作Loading [Loading]
思路:
1.制作一个100帧的读取动画，这样可以做出各式各样的Loading效果;
2.读取的百分比(percent) = 已读取字节数 / 总字节数 *100;
3.根据读取的百分比数(percent)停止到影片剪辑(Loading)的相应帧上。



步骤1:
制作一个100帧的Loading动画,保存为影片剪辑,放在舞台中,实例名为Loading
步骤2:
在第一帧加入AS代码
stop();
_root.onEnterFrame = function() {
var percent = Math.floor(getBytesLoaded()/getBytesTotal()*100);
//变量percent保存读取的百分比数
loading.gotoAndStop(percent);
//停止到影片剪辑 Loading 的相应帧上
if (percent == 100) {
  _root.play();
  //percent=100时，说明读取完毕，整个动画开始播放
}
};



Flash 充电1: getBytesLoaded()和getBytesTotal()

getBytesLoaded():获取已读取的字节数

getBytesTotal(): 获取整个SWF文件的全部字节数



Flash 充电2: 如何测试制作的Loading是否成功

load.jpg

1.测试Loading必需在测试影片(Ctrl+Enter)时才能使用;

2.我们可以在第2帧后导入2张稍大些的图片来占用字节数;

3.测试影片(Ctrl+Enter)后，在窗口中选择视图—＞下载设置—＞DSL;

4.在窗口中选择视图—＞模拟下载(Ctrl+Enter)。


教程到此结束
QQ：147461195（FL基理大师）

[code]《JavaScript就这么回事》
来源:网络／二次编辑:Fl基础理论大师
这篇贴子在网上广为流传，今天拿来和大家一起分享
对于AS学习者来说，学习JS会相对容易很多，因为他们的语法和关键字都很像

前言：

    有些时候你精通一门语言，但是会发现你其实整天在和其它语言打交道，也许你以为这些微不足道，不至于影响你的开发进度，但恰恰是这些你不重视的东西会浪费你很多时间，我一直以为我早在几年前就已经精通JavaScript了，直到目前，我才越来越觉得JavaScript远比我想象的复杂和强大，我开始崇拜它，就像崇拜所有OOP语言一样～
    趁着节日的空隙，把有关JavaScript的方法和技巧整理下，让每个在为JavaScript而烦恼的人明白，JavaScript就这么回事！并希望JavaScript还可以成为你的朋友，让你豁然开朗，在项目中更好的应用～



基础知识：HTML

请注意: 为中凡用到“JavaScript”处，要把“ ”改为 " "才能正常使用



JavaScript就这么回事1：基础知识

1 创建脚本块
<script language=“JavaScript”>
JavaScript code goes here
</script>


2 隐藏脚本代码
<script language=“JavaScript”>
<!--
document.write("Hello");
// -->
</script>


在不支持JavaScript的浏览器中将不执行相关代码
3 浏览器不支持的时候显示
<noscript>
Hello to the non-JavaScript browser.
</noscript>  


4 链接外部脚本文件
<script language=“JavaScript” src="filename.js"></script>


5 注释脚本
// This is a comment
document.write("Hello");


6 输出到浏览器
document.write("<strong>Hello</strong>");


7 定义变量
var myVariable = "some value";


8 字符串相加
var myString = "String1" + "String2";


9 字符串搜索
<script language=“JavaScript”>
var myVariable = "Hello there";
var therePlace = myVariable.search("there");
document.write(therePlace);
</script>


10 字符串替换
thisVar.replace("Monday","Friday");  


11 格式化字串
<script language=“JavaScript”>
var myVariable = "Hello there";
document.write(myVariable.big() + "<br>");
document.write(myVariable.blink() + "<br>");
document.write(myVariable.bold() + "<br>");
document.write(myVariable.fixed() + "<br>");
document.write(myVariable.fontcolor("red") + "<br>");
document.write(myVariable.fontsize("18pt") + "<br>");
document.write(myVariable.italics() + "<br>");
document.write(myVariable.small() + "<br>");
document.write(myVariable.strike() + "<br>");
document.write(myVariable.sub() + "<br>");
document.write(myVariable.sup() + "<br>");
document.write(myVariable.toLowerCase() + "<br>");
document.write(myVariable.toUpperCase() + "<br>");
var firstString = "My String";
var finalString = firstString.bold().toLowerCase().fontcolor("red");
</script>


12 创建数组
<script language=“JavaScript”>
var myArray = new Array(5);
myArray[0] = "First Entry";
myArray[1] = "Second Entry";
myArray[2] = "Third Entry";
myArray[3] = "Fourth Entry";
myArray[4] = "Fifth Entry";
var anotherArray = new Array("First Entry","Second Entry","Third Entry","Fourth Entry","Fifth Entry");
</script>


13 数组排序
<script language=“JavaScript”>
var myArray = new Array(5);
myArray[0] = "z";
myArray[1] = "c";
myArray[2] = "d";
myArray[3] = "a";
myArray[4] = "q";
document.write(myArray.sort());
</script>


14 分割字符串
<script language=“JavaScript”>
var myVariable = "a,b,c,d";
var stringArray = myVariable.split(",");
document.write(stringArray[0]);
document.write(stringArray[1]);
document.write(stringArray[2]);
document.write(stringArray[3]);
</script>


15 弹出警告信息
<script language=“JavaScript”>
window.alert("Hello");
</script>


16 弹出确认框
<script language=“JavaScript”>
var result = window.confirm("Click OK to continue");
</script>  


17 定义函数
<script language=“JavaScript”>
function multiple(number1,number2) {
var result = number1 * number2;
return result;
}
</script>


18 调用JS函数
<a href="#" onClick="functionName()">Link text</a>
<a href="javascript:functionName()">Link text</a>


19 在页面加载完成后执行函数
<body onLoad="functionName()">
Body of the page
</body>


20 条件判断
<script>
var userChoice = window.confirm("Choose OK or Cancel");
var result = (userChoice == true) ? "OK" : "Cancel";
document.write(result);
</script>


21 指定次数循环
<script>
var myArray = new Array(3);
myArray[0] = "Item 0";
myArray[1] = "Item 1";
myArray[2] = "Item 2";
for (i = 0; i < myArray.length; i++) {
document.write(myArray[i] + "<br>");
}
</script>


22 设定将来执行
<script>
function hello() {
window.alert("Hello");
}
window.setTimeout("hello()",5000);
</script>


23 定时执行函数
<script>
function hello() {
window.alert("Hello");
window.setTimeout("hello()",5000);
}
window.setTimeout("hello()",5000);
</script>


24 取消定时执行
<script>
function hello() {
window.alert("Hello");
}
var myTimeout = window.setTimeout("hello()",5000);
window.clearTimeout(myTimeout);
</script>


25 在页面卸载时候执行函数
<body onUnload="functionName()">
Body of the page
</body>



JavaScript就这么回事2：浏览器输出

26 访问document对象
<script language=“JavaScript”>
var myURL = document.URL;
window.alert(myURL);
</script>


27 动态输出HTML
document.write("<p>Here is some information about this document:</p>");
document.write("<ul>");
document.write("<li>Referring Document: " + document.referrer + "</li>");
document.write("<li>Domain: " + document.domain + "</li>");
document.write("<li>URL: " + document.URL + "</li>");
document.write("</ul>");
</script>


28 输出换行
document.writeln("<strong>a</strong>");
document.writeln("b");


29 输出日期
<script language=“JavaScript”>
var thisDate = new Date();
document.write(thisDate.toString());
</script>


30 指定日期的时区
<script language=“JavaScript”>
var myOffset = -2;
var currentDate = new Date();
var userOffset = currentDate.getTimezoneOffset()/60;
var timeZoneDifference = userOffset - myOffset;
currentDate.setHours(currentDate.getHours() + timeZoneDifference);
document.write("The time and date in Central Europe is: " + currentDate.toLocaleString());
</script>


31 设置日期输出格式
<script language=“JavaScript”>
var thisDate = new Date();
var thisTimeString = thisDate.getHours() + ":" + thisDate.getMinutes();
var thisDateString = thisDate.getFullYear() + "/" + thisDate.getMonth() + "/" + thisDate.getDate();
document.write(thisTimeString + " on " + thisDateString);
</script>


32 读取URL参数
<script language=“JavaScript”>
var urlParts = document.URL.split("?");
var parameterParts = urlParts[1].split("&");
for (i = 0; i < parameterParts.length; i++) {
var pairParts = parameterParts[i].split("=");
var pairName = pairParts[0];
var pairValue = pairParts[1];
document.write(pairName + " ：" +pairValue );
}
</script>


你还以为HTML是无状态的么?
33 打开一个新的document对象
<script language=“JavaScript”>
function newDocument() {
document.open();
document.write("<p>This is a New Document.</p>");
document.close();
}
</script>


34 页面跳转
<script language=“JavaScript”>
window.location = "http://www.liu21st.com/";
</script>


35 添加网页加载进度窗口
<html>
<head>
<script language=“JavaScript”>
var placeHolder = window.open("holder.html","placeholder","width=200,height=200");
</script>
<title>The Main Page</title>
</head>
<body onLoad="placeHolder.close()">
<p>This is the main page</p>
</body>
</html>



JavaScript就这么回事3：图像

36 读取图像属性
<img src="image1.jpg" name="myImage">
<a href="#" onClick="window.alert(document.myImage.width)">Width</a>


37 动态加载图像
<script language=“JavaScript”>
myImage = new Image;
myImage.src = "image1.jpg";
</script>


38 简单的图像替换
<script language=“JavaScript”>
rollImage = new Image;
rollImage.src = "rollImage1.jpg";
defaultImage = new Image;
defaultImage.src = "image1.jpg";
</script>
<a href="#" onMouseOver="document.myImage.src = rollImage.src" onMouseOut="document.myImage.src = defaultImage.src">
<img src="image1.jpg" name="myImage" width=100 height=100 border=0>


39 随机显示图像
<script language=“JavaScript”>
var imageList = new Array();
imageList[0] = "image1.jpg";
imageList[1] = "image2.jpg";
imageList[2] = "image3.jpg";
imageList[3] = "image4.jpg";
var imageChoice = Math.floor(Math.random() * imageList.length);
document.write("<img src=" + imageList[imageChoice] + ">");
</script>


40 函数实现的图像替换
<script language=“JavaScript”>
var source = 0;
var replacement = 1;
var rollImage1 = createRollOver("image1.jpg","rollImage1.jpg");
function createRollOver(originalImage,replacementImage) {
var imageArray = new Array();
imageArray[source] = new Image;
imageArray[source].src = originalImage;
imageArray[replacement] = new Image;
imageArray[replacement].src = replacementImage;
return imageArray;
}
</script>
<a href="#" onMouseOver="document.myImage1.src = rollImage1[replacement].src" onMouseOut="document.myImage1.src = rollImage1[source].src">
<img src="image1.jpg" width=100 name="myImage1" border=0>
</a>


41 创建幻灯片
<script language=“JavaScript”>
var imageList = new Array;
imageList[0] = new Image;
imageList[0].src = "image1.jpg";
imageList[1] = new Image;
imageList[1].src = "image2.jpg";
imageList[2] = new Image;
imageList[2].src = "image3.jpg";
imageList[3] = new Image;
imageList[3].src = "image4.jpg";
function slideShow(imageNumber) {
document.slideShow.src = imageList[imageNumber].src;
imageNumber ++
if (imageNumber < imageList.length) {
window.setTimeout("slideShow(" + imageNumber + ")",3000);
}
}
</script>
</head>
<body onLoad="slideShow(0)">
<img src="image1.jpg" width=100 name="slideShow">


42 随机广告图片
<script language=“JavaScript”>
var imageList = new Array();
imageList[0] = "image1.jpg";
imageList[1] = "image2.jpg";
imageList[2] = "image3.jpg";
imageList[3] = "image4.jpg";
var urlList = new Array;
urlList[0] = "http://some.host/";
urlList[1] = "http://another.host/";
urlList[2] = "http://somewhere.else/";
urlList[3] = "http://right.here/";
var imageChoice = Math.floor(Math.random() * imageList.length);
document.write("<a href=" + urlList[imageChoice] + "><img src=" + imageList[imageChoice] + "></a>");
</script>



JavaScript就这么回事4：表单
还是先继续写完JS就这么回事系列吧～

43 表单构成
<form method="post" action="target.html" name="thisForm">
<input type="text" name="myText">
<select name="mySelect">
<option value="1">First Choice</option>
<option value="2">Second Choice</option>
</select>
<br>
<input type="submit" value="Submit Me">
</form>


44 访问表单中的文本框内容
<form name="myForm">
<input type="text" name="myText">
</form>
<a href="#" onClick="window.alert(document.myForm.myText.value)">Check Text Field</a>


45 动态复制文本框内容
<form name="myForm">
Enter some Text: <input type="text" name="myText"><br>
Copy Text: <input type="text" name="copyText">
</form>
<a href="#" onClick="document.myForm.copyText.value = document.myForm.myText.value">Copy Text Field</a>


46 侦测文本框的变化
<form name="myForm">
Enter some Text: <input type="text" name="myText" onChange="alert(this.value)">
</form>


47 访问选中的Select
<form name="myForm">
<select name="mySelect">
<option value="First Choice">1</option>
<option value="Second Choice">2</option>
<option value="Third Choice">3</option>
</select>
</form>
<a href="#" onClick="alert(document.myForm.mySelect.value)">Check Selection List</a>


48 动态增加Select项
<form name="myForm">
<select name="mySelect">
<option value="First Choice">1</option>
<option value="Second Choice">2</option>
</select>
</form>
<script language=“JavaScript”>
document.myForm.mySelect.length++
document.myForm.mySelect.options[document.myForm.mySelect.length - 1].text = "3";
document.myForm.mySelect.options[document.myForm.mySelect.length - 1].value = "Third Choice";
</script>


49 验证表单字段
<script language=“JavaScript”>
function checkField(field) {
if (field.value == "") {
window.alert("You must enter a value in the field");
field.focus();
}
}
</script>
<form name="myForm" action="target.html">
Text Field: <input type="text" name="myField" onBlur="checkField(this)">
<br><input type="submit">
</form>


50 验证Select项
function checkList(selection) {
if (selection.length == 0) {
window.alert("You must make a selection from the list.");
return false;
}
return true;
}


51 动态改变表单的action
<form name="myForm" action="login.html">
Username: <input type="text" name="username"><br>
Password: <input type="password" name="password"><br>
<input type="button" value="Login" onClick="this.form.submit()">
<input type="button" value="Register" onClick="this.form.action = 'register.html'; this.form.submit()">
<input type="button" value="Retrieve Password" onClick="this.form.action = 'password.html'; this.form.submit()">
</form>


52 使用图像按钮
<form name="myForm" action="login.html">
Username: <input type="text" name="username"><br>
Password: <input type="password" name="password"><br>
<input type="image" src="login.gif" value="Login">
</form>


53 表单数据的加密
<script language=“JavaScript”>
function encrypt(item) {
var newItem = "";
for (i=0; i < item.length; i++) {
newItem += item.charCodeAt(i) + ".";
}
return newItem;
}
function encryptForm(myForm) {
for (i=0; i < myForm.elements.length; i++) {
myForm.elements[i].value = encrypt(myForm.elements[i].value);
}
}
</script>
<form name="myForm" onSubmit="encryptForm(this); window.alert(this.myField.value)">
Enter Some Text: <input type="text" name="myField"><input type="submit">
</form>



JavaScript就这么回事5：窗口和框架

54 改变浏览器状态栏文字提示
<script language=“JavaScript”>
window.status = "A new status message";
</script>


55 弹出确认提示框
<script language=“JavaScript”>
var userChoice = window.confirm("Click OK or Cancel");
if (userChoice) {
document.write("You chose OK");
} else {
document.write("You chose Cancel");
}
</script>


56 提示输入
<script language=“JavaScript”>
var userName = window.prompt("Please Enter Your Name","Enter Your Name Here");
document.write("Your Name is " + userName);
</script>


57 打开一个新窗口
<script language=“JavaScript”>
window.open("http://www.liu21st.com/","myNewWindow");
</script>


58 设置新窗口的大小
<script language=“JavaScript”>
window.open("http://www.liu21st.com/","myNewWindow","height=300,width=300");
</script>


59 设置新窗口的位置
<script language=“JavaScript”>
window.open("http://www.liu21st.com/","myNewWindow","height=300,width=300,left=200,screenX=200,top=100,screenY=100");
</script>


60 是否显示工具栏和滚动栏
<script language=“JavaScript”>
window.open("http://www.x-force.cn/", toolbar=0 , menubar=0);
</script>


61 是否可以缩放新窗口的大小
<script language=“JavaScript”>
window.open("http://www.liu21st.com/", "myNewWindow", "resizable=1");
</script>


62 加载一个新的文档到当前窗口
<a href="#" onClick="document.location = '125a.html' ">Open New Document</a>


63 设置页面的滚动位置
<script language=“JavaScript”>
if (document.all) {
//如果是IE浏览器则使用scrollTop属性
document.body.scrollTop = 200;
}
else {
//如果是NetScape浏览器则使用pageYOffset属性
window.pageYOffset = 200;
}
</script>


64 在IE中打开全屏窗口
<a href="#" onClick="window.open("http://www.juxta.com/","newWindow",'fullScreen=yes')">Open a full-screen window</a>


65 新窗口和父窗口的操作
<script language=“JavaScript”>
//定义新窗口
var newWindow = window.open("128a.html","newWindow");
newWindow.close();
//在父窗口中关闭打开的新窗口
</script>
//在新窗口中关闭父窗口
window.opener.close()


66 往新窗口中写内容
<script language=“JavaScript”>
var newWindow = window.open("","newWindow");
newWindow.document.open();
newWindow.document.write("This is a new window");
newWIndow.document.close();
</script>


67 加载页面到框架页面
<frameset cols="50%,*">
<frame name="frame1" src="135a.html">
<frame name="frame2" src="about:blank">
</frameset>
//在frame1中加载frame2中的页面
parent.frame2.document.location = "135b.html";


68 在框架页面之间共享脚本
<script language=“JavaScript”>
function doAlert() {
window.alert("Frame 1 is loaded");
}
</script>
<!--那么在frame2中可以如此调用该方法-->
<body onLoad="parent.frame1.doAlert()">
This is frame 2.
</body>


69 数据公用
可以在框架页面定义数据项，使得该数据可以被多个框架中的页面公用
<script language=“JavaScript”>
var persistentVariable = "This is a persistent value";
</script>
<frameset cols="50%,*">
<frame name="frame1" src="138a.html">
<frame name="frame2" src="138b.html">
</frameset>
这样在frame1和frame2中都可以使用变量persistentVariable


70 框架代码库
根据以上的一些思路，我们可以使用一个隐藏的框架页面来作为整个框架集的代码库
<frameset cols="0,50%,*">
<frame name="codeFrame" src="140code.html">
<frame name="frame1" src="140a.html">
<frame name="frame2" src="140b.html">
</frameset>




[/code]

[code]9。[AS 功能代码教程12] 填色游戏 [FL基础理论大师]
在本次课程中我们将学习使用 Color 类来制作一个填色游戏
并通过本实例复习 for...in 及 SharedObject 的应用

思路:
1.使用脚本代码创建一个调色盘，鼠标点击色块后进行取色;
2.绘制作为填充的影片剪辑并把每一部都存为影片剪辑。例如: 填充对象是一个人物，那么要把他的头发，眼睛，脸等部分都保存成影片剪辑;
3.最后把各部分影片再统一保存到一个影片剪辑(mc)中;
4.为了保存和读取mc中各影片中的颜色，所以要加入两个按钮 save_btn 和 load_btn 。



步骤1:
    绘制作为填充的影片剪辑并把每一部都存为影片剪辑;
    最后把各部分影片统一保存到一个影片剪辑中，实例名mc;
    绘制两个按钮实例名分别为 save_btn 和 load_btn 。
步骤2:
加入AS代码
//===== 绘制一个正方形作为色块以备调用 =====
_root.createEmptyMovieClip("box", -1);
var box_size:Number = 12;
var TheCol = 0x0;
//用于存储所取的色彩值
with (box) {
beginFill(TheCol);
moveTo(0, 0);
lineTo(box_size, 0);
lineTo(box_size, box_size);
lineTo(0, box_size);
lineTo(0, 0);
endFill();
}
box._visible = false;
//============================================
//************* 下面生成一个调色盘 *************
var panex:Number = 3;
var paney:Number = 3;
var column:Number = 18;
//起点 x 坐标为 3, 起点 y 坐标为 3, 总行数为 18
var i = 0;
for (var r = 0; r<=0xFF; r += 0x33) {
for (var g = 0; g<=0xFF; g += 0x33) {
  for (var b = 0; b<=0xFF; b += 0x33) {
   var p:MovieClip = box.duplicateMovieClip("box"+i, i);
   new Color(p).setRGB(r*256*256+g*256+b);
    //new Color(p).setRGB(r << 16 | g << 8 | b);
    //RGB转换公式，以上两种都可以使用
   p._x = panex + Math.floor(i/column)*(box_size+1);
   p._y = paney + i%column*(box_size+1);
//设置每个色块的坐标 行坐标: [i/column], 列坐标: i%column
   p.onRelease = function() {
    TheCol = new Color(this).getRGB();
    new Color(curser.BG).setRGB(TheCol);
   //点击到该色块后进行取色于保存到TheCol变量中
   };
   i++;
  }
}
}
//******************************************
//===== 判断点击到图案上以后对哪个影片剪辑填色 =====
mc.onRelease = function() {
var flag:Boolean = true;
//增加一个flag为了避免一次对多个影片进行填色
for (var k in mc) {
  if (mc[k].hitTest(_xmouse, _ymouse, true) && flag) {
   new Color(mc[k]).setRGB(TheCol);
   flag = false;
  }
}
};
//============================================
//************* 对mc中所有填充色的读取和保存 *************
save_btn.onRelease = function() {
var so:SharedObject = SharedObject.getLocal("Color_save");
for (var k in mc) {
  so.data[k] = new Color(mc[k]).getRGB();
}
};
load_btn.onRelease = function() {
var so:SharedObject = SharedObject.getLocal("Color_save");
for (var k in mc) {
  new Color(mc[k]).setRGB(so.data[k]);
}
};
//******************************************



Flash充电: 例举 Color 类中常用方法简介
请注意: 我们在舞台中所绘制出的影片剪辑即使给他是填充了纯色影片，使用getRGB()也不会取得其RGB值。我们只有对其使用过setColor()后，才能用getRGB()获取该影片的颜色值。



例1: 为影片剪辑 mc 创建一个名为 m_Col 的 Color 对象，并将其RGB值设置为橙色:
var my_color:Color = new Color(my_mc);
my_color.setRGB(0xff9933);



例2: 获取影片剪辑 mc 的RGB值并以16进制显示出来:
var m_Col:Color = new Color(mc);
m_Col.setRGB(0xff9933);
var myValue:String = m_Col.getRGB().toString(16);


教程到此结束
QQ：147461195（FL基理大师）[/code]

[code]10。[Flash基础理论课13] FL记事本 [SharedObject]
SharedObject(本地共享对象)功能类似于网页中的Cookie

允许设计者存储少量信息在客户端

思路:

1.用脚本创建出两个文本框和两个按钮;

2.两个文本框分别为 title_txt 和 content_txt 用于输入及显示信息;
3.两个按钮分别为 save_btn:保存文本内容，load_btn:读取文本内容。





在第一帧中加入以下代码:
//====================创建两个文本框====================
//创建及设置标题文本框
var t_f:TextFormat = new TextFormat();
t_f.size = 20;
_root.createTextField("title_txt", 1, 10, 10, 150, 25);
with (title_txt) {
border = true;
borderColor = 0x0;
type = "input";
setNewTextFormat(t_f);
}
//创建及设置内容文本框
_root.createTextField("content_txt", 2, 10, 40, 150, 150);
with (content_txt) {
border = true;
borderColor = 0x0;
type = "input";
wordWrap = true;
setNewTextFormat(t_f);
}

//====================创建两个按钮====================
//存储按钮
_root.createEmptyMovieClip("save_btn", 3);
save_btn.createTextField("txt", 0, 0, 0, 40, 20);
save_btn.txt.text = "Save";
save_btn._x = 50;
save_btn._y = 200;
save_btn.onRelease = function() {
var so:SharedObject = SharedObject.getLocal("log_save");
//与本地共享对象进行连接,注意这是个静态方法
so.data.title_txt = title_txt.text;
so.data.content_txt = content_txt.text;
//存储标题及内容信息为log_save的数据
};
//读取按钮
_root.createEmptyMovieClip("load_btn", 4);
load_btn.createTextField("txt", 0, 0, 0, 40, 20);
load_btn.txt.text = "Load";
load_btn._x = 100;
load_btn._y = 200;
load_btn.onRelease = function() {
var so:SharedObject = SharedObject.getLocal("log_save");
//与本地共享对象进行连接,注意这是个静态方法
title_txt.text = so.data.title_txt;
content_txt.text = so.data.content_txt;
//将log_save的数据读取到标题及内容文本框中,这两句与存储操作正好相反
};





Flash充电: SharedObject 概念及常用方法简介
1.SharedObject 作用: 将共享对象永久贮存在用户计算机上。在Flash中我们可用来实现如用户登陆，保存日记，甚至游戏存盘等功能。



2.SharedObject 引用(getLocal):

请注意getLocal()方法为静态方法，声明方法如下:
var so:SharedObject = SharedObject.getLocal("kookie");



3.SharedObject 存储(data): 下面示例实现一个简单的个人信息的存储
var my_so:SharedObject = SharedObject.getLocal("savedData");
my_so.data.name = "Alan"
my_so.data.sex = "male"
my_so.data.age = "21"



4.SharedObject 部分读取(data): 下面示例实现个人信息的读取
var my_so:SharedObject = SharedObject.getLocal("savedData");
trace(my_so.data.name)
trace(my_so.data.sex)
trace(my_so.data.age)



5.SharedObject 全部读取(data): 结合 for...in 语句读取所有属性对象
var my_so:SharedObject = SharedObject.getLocal("savedData");
for (var prop in my_so.data) {
    trace(prop+": "+my_so.data[prop]);
}



6.SharedObject 清除数据(clear):
var my_so:SharedObject = SharedObject.getLocal("savedData");
my_so.clear();


教程到此结束
QQ：147461195（FL基理大师）[/code]

11。[杂谈四] AS代码优化技巧 [综合贴]
[code]第一章  AS3的一些优化计算方法
来源：John Grden Blog

1.用乘法来代替除法（当除数可转化为有限数的时候）。比如var n:Number = value * 0.5;要比var n:Number = value / 2;快。但差别并不是很大。只有在需要大量计算情况下，比如3D引擎中差别才比较明显。



2.用位运算代替除2或乘2。比如10>>1要比10*2快，而10<<1要比10*2 快。从测试来看位运算几乎比乘除快一倍，但是一般情况下，我们不能选择位运算，比如我们就不能用13>>1来代替13/2，尽管前者比后者运算速度更快，但2者的运算结果却不一样。所以还是要看具体情况。



3.用unit()或int()代替取整运算Math.floor()和Math.ceil()。比如var test:uint = uint(1.5);要比var test:Number = Math.floor(1.5);快；而var test:uint = uint(1.5)+1;要比var test:Number = Math.ceil(1.5);也快。如果是Math.floor()，还可以用位运算(>>0)来代替。比如var test:uint =1.5>>0，比unit()或int()更快。



4.用乘-1来代替Math.abs()方法。比如var nn:Number = -23;var test:Number= nn < 0 ? nn * -1 : nn;要比var nn:Number = -23;var test:Number = Math.abs(nn);快。

当然还有更多的优化计算的方法。一般来说，低级运算要比高级运算速度；内部方法比调用其他方法速度快。另外要注意的是，这些方法有的时候可能并一定适用。




第二章  Actionscript 优化指南
来源 gotoAndStop.it

原著 Marco Lapi,alias Lapo, aw译

在这篇文章中，我们将讨论多种优化 Actionscript 代码的方法.
此外我们也针对一些典型的游戏代码进行了系列测试，来最大限度的发掘、提高Flash播放器的性能。

何时进行优化

对现有程序进行优化的过程，有时十分的冗长与困难，这与原始代码的非优化程度有关，所以在投入大量时间进行代码优化之前，最重要的是要估计出要在什么地方对代码做出修改或替换。

一个游戏代码的最重要的部分就是主循环体，通常情况下该循环体要在flash的每一帧上执行，并控制游戏中的角色属性和重要的数据参数。而对于主循环体以外的部分，也可能是次要循环部分，同样要注意是给其否分配了过多的资源，而没有分配给那些更需要资源的核心部分。
通过积累在各处节约出来的时间(可能每处仅仅是几个毫秒)，您会明显发现自己的swf运行得更加稳定，并且游戏感也大大加强。

简洁与高效的代码

书写出十分简洁、可以再次调用的代码(有时可能是面向对象的)是一项精细的工作，但这需要多年的编程经验。对于OOP(object oriented programming，面向对象的程序设计)，有些场合根本利用不到它的优势，这使得它显得十分奢侈。在有限的资源条件下(可能是flash播放器的原因)，通过更先进的方法，像刚刚提到的OOP，就可能反而导致令人不满意的结果。

我们并不是说OOP对游戏编程不好，只是在某些场合它显得过于奢侈和多余。毕竟有时候“传统的方法”却能得到更好的结果。

大体而言，用OOP是比较好的，因为它让代码维护更加简单。但在后文中，你会看到有时为了充分发挥flashplayer性能，而不采用OOP技术。例如：处理快速滚动或者计算十分复杂的数学问题。

基本的优化

一提及代码优化，我们马上会联想到执行速度的改进，而很少去考虑系统资源的分配。这是因为当今，即使是将被淘汰的计算机，都有足够的内存来运行我们大部分的flash游戏(128M的内存足以满足大多数情况的需要，况且，512M的内存是当今新电脑的基本配置)

变量

在各种重要的代码优化手段中，有这么一条：在定义局部变量的时候，一定要用关键字var来定义，因为在Flash播放器中，局部变量的运行速度更快，而且在他们的作用域外是不耗占系统资源的。

aw附：var变量仅仅在花括号对中才有“生命”，个人认为没有系统学过编程的人容易出错的一个地方：

awMC.onLoad = function(){
  var aw = 1;
}
awMC.onEnterFrame = function(){
//不存在aw这个变量
}
一段非优化代码:

function doSomething()
{
mx = 100
my = 100
ar = new Array()

for (y=0; y < my; y++)
{
  for (x=0; x < mx; x++)
  {
   i = (y * mx) + x
   arr[i] = i   
  }
}

return arr
}

这段代码中，并未声明函数体内的那些变量(那些仅仅在函数内使用的变量)为局部变量，这使得这些变量被播放器调用的速度更慢，并且在函数执行完毕的时候仍然耗占系统资源。

下面列出的是经过改进的同样功能的代码：

function doSomething()
{
var mx = 100
var my = 100
var ar = new Array()

for (var y=0; y < my; y++)
{
  for (var x=0; x < mx; x++)
  {
   var i = (y * mx) + x
   arr[i] = i   
  }
}
return arr
}
这样一来所有的变量均被定义为了局部变量，他们能够更快地被播放器调用。这一点在函数大量(10，000次)循环运行时显得尤为重要！当一个函数调用结束的时候，相应的局部变量都会被销毁，并且释放出他们占有的系统资源。



onEnterFrame 事件

onEnterFrame事件对于游戏开发者而言是非常有用的，它使得我们能够快速、反复地按照预设帧频(fps)运行一段程序。回想在Flash5的时代，这(onEnterFrame实时监控)是一种非常流行的技术，用这样的事件来控制机器游戏对手的逻辑，又或者我们可以在每一个子弹上设置这样的事件来监测子弹的碰撞。

实际上，我们并不推荐给过多的MoveClip添加这样的事件，因为这样做会导致“无头绪码(spaghetti code)”的出现，并且容易导致程序效率明显降低。

大多数情况下，用单独一个onEnterFrame事件就可以解决问题了：用这一个主循环来执行你所需要的操作。

另一个简单的办法是设置一个合适的帧频：要知道帧频越高，CPU资源就越紧张。

在帧频为25-35(fps)之间时，onEnterFrame足以很好地执行较复杂代码，哪怕你的计算机配置较低。因此，在没有特殊要求的场合，我们不推荐使用高于60(fps)的帧频。



矢量图与位图

在处理图形前，我们一定要做出正确的选择。Flash能对矢量图和位图进行完美的兼容，然而矢量图和位图在播放器中的表现实质却完全不同。

在用到矢量图的时候，我们要尽可能简化它们的形状，去除多余的端点。这样做将大大降低播放器用于呈现矢量图所要进行的计算量。另一个重要方面在于线条的运用，尽量减少和避免冗陈的线条结构，因为它们会直接影响到flash的播放效率。

当某个实例透明度小于100时，也会对播放速率造成影响，所以如果你发现自己的Flash播放速率过慢，就去挑出这些透明的实例来吧！

那么，如果真的需要呈现比较复杂的场景时，你就最好考虑使用位图实现。虽然Flash在对位图的渲染效率上并不是最优越的(比如和Flash的“兄长” Director比起来)，但丰富的视觉内容呈现只能靠位图(与位图同复杂度的矢量图形渲染速率非常低)了，这也是很多基于区块的游戏中广泛采用像素图作为背景的原因。顺便要提到的是，Flash虽然对GIF,JPG和PNG都有所支持，但是渲染速度上PNG还是占有绝对优势，所以我们建议flash中的位图都尽可能采用PNG格式。

影片剪辑(MovieClip)的可视性[下面将MovieClip简称为mc]

您可能会经常碰到这样一种情况：有大量不可见/屏幕外的mc等待出场(比如游戏中屏幕外的地图、人物等等)。
要知道，播放器仍然要消耗一定的资源来处理这些不可见/屏幕外的mc，哪怕他们是单帧，非播放的状态。

最好的解决办法之一是给这些mc一个空白帧，当他们不出现在屏幕上时，你能用gotoAndStop()语句跳转到这一帧，从而减少播放器对资源的需求。

请务必记住，这种情况下，简单的设置可见度属性为不可见( _visible = false )是无效的，播放器将继续按照这些mc所停留或播放的帧的复杂度来分配资源。


数组
数组在各种需要记录数据的应用程序和游戏中都被广泛的使用。

一个典型的例子就是基于区块的Flash游戏，在这样一类的游戏中，地图有时被存放成形如arr[y][x]的二维数组。虽然这是一种很常见的方法，但是如果用一维数组的话，却能提高程序的运行效率。另一个重要的方法来提高数组效率是在数组遍历的时候使用for in 循环来代替传统的 for 或者while循环语法。
例如：

一段代码如下
for (var i in arr)
{
if (arr[i] > 50)
{
  // 进行某些操作
}
}

它的执行速度明显高于这一段代码：
for (var i=0; i<10000; i++)
{
if (arr[i] > 50)
{
  // 进行某些操作
}
}
前者的效率比后者提高了30%，这个数字在你的游戏要逐帧执行这一段代码的时候显得更加宝贵！

高级优化：
1) for循环 和 while循环
用while循环将会得到比for循环更好的效率。然而，从数组中读取数据，用for in循环式最好的选择！

所以我们不推荐使用：
for (var i=0; i<1000; i++)
{
//进行某些操作
}而推荐使用

var i=-1
while (++i < 1000)
{
//进行某些操作
}



2) 从数组中读取数据
我们通过测试发现，for in循环的效率大大高于其他的循环方式。参看：
arr = []
MAX = 5000

//数组赋值
for (i=0; i < MAX; i++)
{
arr[i] = i
}
var item = null

// For Loop
for (var i=0; i < MAX; i++)
{
item = arr[i]
}

//For循环
for (var i in arr)
{
item = arr[i]
}


// While循环
i = -1
while(++i < MAX)
{
item = arr[i]
}



3) 向数组中写入数据(while , for)
可以看到while循环稍占优势。



4) _global(全局)变量同Timeline(时间轴)变量
我们猜测采用全局变量能提高变量调用速度，然而效果并不像预计的那样明显。



5) 单行、多行变量赋值
我们发现单行变量赋值效率大大高于多行。比如：
a = 0
b = 0
c = 0
d = 100
e = 100

效率就不如：
a = b = c = 0
d = e = 100



6) 变量名寻址
这个测试反映了变量名的预寻址是非常重要的，尤其是在循环的时候，一定要先给丁一个指向。这样大大节约了寻址时间。

比如：
var num = null
t = getTimer()
for (var i=0; i < MAX; i++)
{
num = Math.floor(MAX) - Math.ceil(MAX)
}
t1.text = "Always lookup: " + (getTimer() - t)

就不如：
t = getTimer()
var floor = Math.floor
var ceil  = Math.ceil
for (var i=0; i < MAX; i++)
{
num = floor(MAX) - ceil(MAX)
}



7) 短变量名和长变量名
变量名越短，效率越高。考虑到长变量名也有它的好处（比如，便于维护等），因此建议在关键部位（比如大量循环出现的时候）使用短变量名，最好就1-2个字符。



8) 循环前、后声明变量
在测试前，我们认为循环前声明变量会更加节约时间，不料测试结果并不明显，甚至还恰恰相反！

// 内部声明
t = getTimer()
for (var i=0; i < MAX; i++)
{
var test1 = i
}
t1.text = "Inside:" + (getTimer() - t)

// 外部声明
t = getTimer()
var test2
for (var i=0; i < MAX; i++)
{
test2 = i
}



9) 使用嵌套的if结构
当用到复杂的条件表达式时。把他们打散成为嵌套的独立判断结构是最佳方案。下面的代码我们进行了测试，发现这种效果改进明显！
MAX = 20000
a = 1
b = 2
c = -3
d = 4

var i=MAX
while(--i > -1)
{
if (a == 1 && b == 2 && c == 3 && d == 4)
{
  var k = d * c * b * a
}
}

//下面的判断更加节省时间
var i=MAX
while(--i > -1)
{
if (a == 1)
{
  if (b == 2)
  {
   if (c == 3)
   {
    if (d == 4)
    {
     var k = d * c * b * a
    }
   }
  }
}
}



10) 寻找局部变量(this方法同with方法比较)
局部变量的定位方法很多。我们发现用with比用this更加有优势！
obj = {}
obj.a = 1
obj.b = 2
obj.c = 3
obj.d = 4
obj.e = 5
obj.f = 6
obj.g = 7
obj.h = 8
obj.test1 = useThis
obj.test2 = useWith
MAX = 10000
function useThis()
{
var i = MAX
while(--i > -1)
{
  this.a = 1
  this.b = 2
  this.c = 3
  this.d = 4
  this.e = 5
  this.f = 6
  this.g = 7
  this.h = 8
}
}
function useWith()
{
var i = MAX
while(--i > -1)
{
  with(this)
  {
   a = 1
   b = 2
   c = 3
   d = 4
   e = 5
   f = 6
   g = 7
   h = 8
  }
}
}



11) 循环监听键盘事件
同刚才所提到的寻址一样，我们实现给一个指向会得到更好的效率，比如：
keyDown = Key.isDown
keyLeft = Key.LEFT

//我们再用 if (keyDown(keyLeft))
附：我们测试了按键代码和键值常量的效率发现并无太大差别。



12) Math.floor()方法与int()
这个问题曾在Flashkit的论坛被提出讨论过。测试表明，旧的int方法反而效率更高。我们的测试结果也反映了这一点。



13)eval表达式与中括号语法
我们并没有发现明显的差别，并不像刚才所述那样，旧的eval表达式比起中括号方法并没有太大的优势
var mc = eval("_root.myMc" + i)
var mc = _root["myMc" + i]
//两者效率差不多16) 涉及MC的循环：ASBroadcaster 同欢同循环的差别

结论
我们从这些测试结果中发现，对于不同的需求，采用不同的代码，我们可以大大提高脚本的执行效率。虽然我们在这里罗列了许多的优化代码的方法，需要大家自己测试、实验的还有很多(考虑到每个人的需求不同).如果你想更加深入地讨论这类问题。可以来我们的论坛。

aw附:
终于翻译完了，自己也学到很多好东西，大家又什么问题可以去gotoAndPlay的官方，也可以来我的Blog提出！


第三章  黑羽AS心得:浅释ActionScript的代码优化
来源：Kingda blog

本文既为浅谈代码优化，那么就不深入到OOP设计层面。仅涉及Flash8帮助里面提到的一些代码编写优化原则，并加以解释。
准则来源于Flash8 帮助，我做了一些解释：


1.避免从一个循环中多次调用一个函数。
在循环中包含小函数的内容，可使效果更佳。小函数生命期短，利于资源释放。尤其是在大的循环中时。


2.尽可能使用本机函数。
本机函数要比用户定义的函数运行速度更快。本机函数即Flash中内有的一些函数(intrinsic)，比如hitTest()，你没必要自己写一个类似的。


3.不要过多使用 Object 类型。
数据类型注释应力求精确，这样可以提高性能。只有在没有适当的备选数据类型时，才使用 Object 类型。同时也便于代码管理，时刻知道对象的类型和作用。
同时也有利于编译器编译时优化。


4.避免使用 eval() 函数或数据访问运算符。
通常，较为可取且更有效的做法是只设置一次局部引用。不得已时才用eval，比如转换_droptarget为MovieClip时。


5.在开始循环前将 Array.length 赋予变量，尤其是大的循环。
在开始循环前将 Array.length 赋予变量(比如var iLength:Number)，将其作为条件使用，而不是使用 myArr.length 本身。
原因，在循环中，iLength是Number变量，会被放入寄存器使用，效率远比访问Array再得到length高。例如，应使用

var fontArr:Array = TextField.getFontList();
var arrayLen:Number = fontArr.length;
for (var i:Number = 0; i < arrayLen; i++) {
    trace(fontArr[i]);
}

来代替：
var fontArr:Array = TextField.getFontList();
for (var i:Number = 0; i < fontArr.length; i++) {
    trace(fontArr[i]);
}



6.注重优化循环及所有重复动作。
Flash Player 花费许多时间来处理循环(如使用 setInterval() 函数的循环)。


7.在局部变量够用时，不要使用全局变量。类静态变量也要少用。
全局变量是开发者的恶梦。实在需要全局变量的话，我建议使用singleton设计模式来进行管理。


8.声明变量时，添加 var 关键字。
这是为了编译时让编译器知道你的变量类型，优化编译。


黑羽补充一点：对关键字的使用要谨慎。
不赞成使用关键字作为自己的method和属性名，除非你确认后续开发不会用到相同的事件名和属性名。
但你怎么知道flash使用了多少隐藏关键字？太多了！比如说 className, invalidate, refresh, mouseOver等等不常用的关键词。好的方法是使用SEPY编辑器来写代码，那里面加亮了所有公布的和没有公布的关键词。
而且因为很有可能和start,load,等这些常用的事件名重复，带来代码不必要的修改和麻烦。


9.对涉及到调用绘图资源的函数时，尽量先多判断再调用。
所有渐变，位置变化，创建删除MC，组件等函数都涉及到绘图资源的调用。在很多情况下，尽量先用逻辑判断变量或者对象的属性，必要时再调用这些函数。这样可以节省较多的计算资源。



[/code]

12。[AS 功能代码教程11] 图片转场效果 [FL基础理论大师]

[code]这是我们经常会在浏览网页和论坛时看到的图片转场效果

制作这些效果我们很自然会想到用setMask函数来完成

在本节中我们将介绍七种基本转场效果

思路:
1.注意共三张图片,一张是底版(pic_old)放在最底层,一张是切换来的新图

  (pic_new)放在中间层,最后还有一张用来做新图的遮罩层(mask);
2.新图和底版的深度不要颠倒,新图要比底版的深度高,否则会发生错误;
3.我们只在mask上面作文章，让mask去加载遮罩物，这样就可以完成许许多多不同的效果了。



步骤1:
(1)绘制一个正方形(50*50),注册点在中心,保存为影片剪辑

   连接—＞导出—＞标志符 Rec;

(2)绘制一个圆形(50*50),注册点在中心,保存为影片剪辑

   连接—＞导出—＞标志符 Cir;

(3)导入图片n张，均保存为影片剪辑,注册点在左上(0,0)
   这些图片的连接—＞导出—＞标志符 分别从 pic1, pic2, pic3 ... picn



步骤2:
加入AS代码
var old_p:String;
//临时变量用于存储当前图片
var n:Number = 0;
//变量n为当前所在图片
var Num:Number = 5;
//Num图片数量
//=======================================================
//鼠标点击后设置底版图、新图和遮罩层，并调用(PassEffect)
_root.onMouseDown = function() {
n = n < Num ? ++n : 1 ;

_root.createEmptyMovieClip("pic_old", -3);
pic_old.attachMovie(old_p, old_p, 1);
old_p = "pic"+n;
_root.createEmptyMovieClip("pic_new", -2);
pic_new.attachMovie("pic"+n, pic, 1);
_root.createEmptyMovieClip("mask", -1);
pic_new[pic].setMask(mask);
//在测试时，可以把setMask这句注释掉,可更好地观察遮罩层的情况
PassEffect();
};


//============================================================

function PassEffect() {
switch (1+Math.floor(Math.random()*7)) {
  //***************效果1[见附录]***************
  //复制若干个圆，分布在每行每列，并使每个圆的大小不断增加至覆盖整张图
case 1 :
  for (i=0; i<7; i++) {
   for (j=0; j<6; j++) {
    var p:MovieClip = mask.attachMovie("Cir", "Cir"+i*10+j,

i*10+j);
  //注意这里是mask.attachMovie()，加载来的图形都属于遮罩层(mask)
    p._width = 20;
    p._height = 20;
    p._x = 20+i*60;
    p._y = 20+j*60;
    p.onEnterFrame = function() {
     if (this._width<180) {
      this._width = this._height += 8;
     } else {
      delete this.onEnterFrame;
     }
    };
   }
  }
  break;
//=================================================================
  //***************效果2[见附录]***************
  //复制一个正方形,放入舞台中心,设置他其初始大小为10*10,并放大
case 2 :
  var p:MovieClip = mask.attachMovie("Rec", Rec, 1);
  p._width = 10;
  p._height = 10;
  p._x = Stage.width/2;
  p._y = Stage.height/2;
  p.onEnterFrame = function() {
   if (this._width
    this._width += 40;
    this._height += 40;
   } else {
    delete this.onEnterFrame;
   }
  };
  break;
//=================================================================
  //***************效果3[见附录]****************
//复制一个正方形,其初始大小比舞台的尺寸多一些,使其移动到舞台中心
case 3 :
  var p:MovieClip = mask.attachMovie("Rec", "Rec"+1, 1);
  p._width = Stage.width+10;
  p._height = Stage.height+10;
  p._x = 0-p._width;
  p._y = 0-p._height;
  p.onEnterFrame = function() {
   this._x += (Stage.width/2-this._x)*0.3;
   this._y += (Stage.height/2-this._y)*0.3;
  };
  break;
//=================================================================
  //***************效果4[见附录]***************
  //复制二个正方形,放到舞台外的左右各一个,使它们都向舞台中心移动
case 4 :
  var p:MovieClip = mask.attachMovie("Rec", "Rec"+1, 1);
  p._width = Stage.width;
  p._height = Stage.height;
  p._x = -p._width/2;
  p._y = Stage.height/2;
  p.onEnterFrame = function() {
   if (this._x
    this._x += 15;
   } else {
    delete this.onEnterFrame;
   }
  };
  var p:MovieClip = mask.attachMovie("Rec", "Rec"+2, 2);
  p._width = Stage.width;
  p._height = Stage.height;
  p._x = Stage.width+p._width/2;
  p._y = Stage.height/2;
  p.onEnterFrame = function() {
   if (this._x>Stage.width/2) {
    this._x -= 15;
   } else {
    delete this.onEnterFrame;
   }
  };
  break;
//=================================================================
  //***************效果5[见附录]***************
//随机产生两种倾斜角度,用一个递增变量d_time来控制每个遮罩物的开始时间
case 5 :
  if (Math.random()<=0.5) {
   var rotation = 45;
  } else {
   var rotation = -45;
  }
  for (i=-10, d_time=0; i<30; i++, d_time++) {
   var p:MovieClip = mask.attachMovie("Rec", "Rec"+d_time, d_time);
   p._width = 0;
   p._height = Stage.height*2;
   p._x = p._width/2+i*20;
   p._y = Stage.height/2;
   p._rotation = rotation;
   p.delay = d_time;
   p.start_time = 0;
   p.onEnterFrame = function() {
    if (this.start_time
     this.start_time += 3;
    } else if (this._xscale<30) {
     this._xscale += 2;
    } else {
     delete this.onEnterFrame;
    }
   };
  }
  break;
//=================================================================

   //***************效果6[见附录]***************
  //与效果5相近，但在遮罩物的尺寸及位置上要略加改动
case 6 :
  if (Math.random()<=0.5) {
   for (i=0; i<45; i++) {
    var p:MovieClip = mask.attachMovie("Rec", "Rec"+i, i);
    p._width = 0;
    p._height = Stage.height+10;
    p._x = i*10;
    p._y = Stage.height/2;
    p.delay = i;
    p.start_time = 0;
    p.onEnterFrame = function() {
     if (this.start_time
      this.start_time += 3;
     } else if (this._xscale<30) {
      this._xscale += 2;
     } else {
      delete this.onEnterFrame;
     }
    };
   }
  } else {
   for (i=0; i<35; i++) {
    var p:MovieClip = mask.attachMovie("Rec", "Rec"+i, i);
    p._width = Stage.width+10;
    p._height = 0;
    p._x = Stage.width/2;
    p._y = i*10;
    p.delay = i;
    p.start_time = 0;
    p.onEnterFrame = function() {
     if (this.start_time
      this.start_time += 3;
     } else if (this._yscale<30) {
      this._yscale += 2;
     } else {
      delete this.onEnterFrame;
     }
    };
   }
  }
  break;
//=================================================================
  //***************效果7[见附录]***************
//复制长条,均放在舞台外的上方,并使Y坐标有所差异,向下运动
case 7 :
  for (i=0; i<40; i++) {
   var p:MovieClip = mask.attachMovie("Rec", "Rec"+i, i);
   p._width = 10;
   p._height = Stage.height+50;
   p._x = p._width/2+i*p._width;
   p._y = -p._height+Math.random()*50;
   p.onEnterFrame = function() {
    if (this._y
     this._y += 20;
    } else {
     delete this.onEnterFrame;
    }
   };
  }
  break;
}
}


Flash充电1: MovieClip.setMask 方法
mc.setMask(mask:Object): 使参数 mask 中的影片剪辑成为 mc 的遮罩层。

Flash充电2: 条件运算符(三目运算) ? :
格式:expression1 ? expression2 : expression3
例如:
var x:Number = 5;
var y:Number = 10;
var z = (x < 6) ? x: y;
trace (z);
// returns 5
附录:
效果1:
效果2:
效果3:
效果4:
效果5:
效果6:
效果7:
教程到此结束
QQ：147461195（FL基理大师）[/code]

13。[Flash基础理论课12] 倒计时系统 [getTime]
[code]在本实例中只介绍倒计时的计算方法

至于本机存储，我们会在下次课专门讲到



思路:1.创建一个文本用于输出时间;
     2.实例化一个Date类，给定参数为倒计时时间;
     3.用倒计时时间减不断变化的新的系统时间求出相差的毫秒数;
     4.最后学会毫秒-秒-分钟-小时-天之间转换。



加入AS代码:
_root.createTextField("txt", 1, 150, 150, 0, 0);
txt.autoSize = true;
//创建一个文本框用于输出时间
var year = 2008;
var month = 8;
var date = 8;
var hour = 20;
var minute = 0;
var second = 0;
//设置定时时间(本例以北京奥运为倒计时)
var End:Date = new Date(year, month-1, date, hour, minute, second);
//Date类实例化将日期和时间指定为毫秒, 月份(0～11)所以要减1


_root.onEnterFrame = function () {

var Now:Date = new Date();
//获得当前的日期和时间(单位:毫秒)



var dif = (End-Now)/1000;
//计算出二者相差的毫秒数,除以1000转换为秒数



var dif_d = Math.floor(dif/(3600*24));
//相差的天数=[相差的总秒数/一天的总秒数(60秒*60分*24小时)]



var dif_h = Math.floor((dif-dif_d*3600*24)/3600);
//相差的小时=[(天数取整后剩于的总秒数)/一小时的总秒数]



var dif_m = Math.floor((dif-dif_d*3600*24-dif_h*3600)/60);
//相差的分钟=[(天数和小时取整后剩于的总秒数)/一分钟的总秒数]



var dif_s = Math.floor(dif-dif_d*3600*24-dif_h*3600-dif_m*60);
//相差的秒数=[天数和小时和分钟取整后剩于的总秒数]



txt.text = dif_d+"天 "+dif_h+"小时 "+dif_m+"分钟 "+dif_s+"秒";
};



Flash充电: Date类简介
1.Date类的构造函数
public Date([yearOrTimevalue:Number], [month:Number], [date:Number], [hour:Number],[minute:Number], [second:Number], [millisecond:Number])



2.构造函数中的参数
yearOrTimevalue:Number [可选]: 如果指定了其它参数，则此数字表示年份(如 1965)。如果该数字表示

时间值（未指定任何其它参数），则为 1970 年 1月 1日 0:00:00 之前或之后的毫秒数。

month:Number [可选]: 0(一月)到 11(十二月)之间的整数。

date:Number [可选]: 1 到 31 之间的整数。

hour:Number [可选]: 0(午夜) 到 23(晚上11点)之间的整数。

minute:Number [可选]: 0 到 59 之间的整数。

second:Number [可选]: 0 到 59 之间的整数。

millisecond:Number [可选]: 0 到 999 之间的整数（毫秒）。



3.示例

例1:
var d1:Date = new Date();
//Date 对象被设置为运行赋值语句的时间。
trace(d1)
//返回: Tue Dec 18 22:35:38 GMT+0800 2007



例2:
var d2:Date = new Date(2000, 0, 1);
//使用传递 Date 对象的年份、月份和日期参数创建 Date 对象。

trace(d2)
//返回: Sat Jan 1 00:00:00 GMT+0800 2000



例3:
var d1:Date = new Date();
var d2:Date = new Date(2000, 0, 1);
var dif = d1-d2
trace(dif);
//返回相差的毫秒数: 251332873437



例4:也可以通过getTime()函数得到相同的结果
var d1:Date = new Date();
var d2:Date = new Date(2000, 0, 1);
var dif = d1.getTime()-d2.getTime();
trace(dif);
//返回相差的毫秒数: 251332873437


教程到此结束
QQ：147461195（FL基理大师）[/code]

14。[杂谈四] 程序员应该学C语言的十个理由[code]
每个程序员都应该在他的编程生涯中学习C语言。它的好处多到你不能忽视。不仅是因为它能带来很多工作机会，而且它也从整体上让你认识电脑。

C比其他的编程语言 (C++, Java)更底层一点。在底层编程会使你从整体上更好的理解电脑。
设备驱动和操作系统都是专门用C写成的。现在你可以再也不用写一个设备驱动程序和操作系统了，但是如何你要修改一个这样的程序你怎么办呢？
如果你想要找一份微控制器编程的工作你怎么办呢？它们是用C写的。你要放弃可能的工作机会，只是因为你不想学一门新的语言吗？
C程序比其它任何语言产生的程序都要更小更快。有时候你的程序需要那一点点速度提升，只有C能给你。
如果你学过C，你能学其他任何现代编程语言。原因是，所有现代编程语言 (Java, C++, C#, 等)都是基于C的。
因为C已经发展了很多年，它有巨大的社区和集体代码基础。这能让你快速有效的实现先前已经编好的新算法和函数。

C是开源社区的语言。开源的榜样，Linux，是用C编写的。如果你了解C，你能参与和贡献到大量开源社区中去，比如Source Forge。
C是唯一一门告诉你指针到底是什么的语言。C#和Java完全跳过了这个主题。指针赋与了C强大的能力。
C仍然是编程工作最普遍要求掌握的语言。在你的领域下绝对值得花去时间学C。
任何带有微处理器的东西都支持C。从你的微波炉到手机，C 提供了强大的技术动力。
[/code]

15。[AS 功能代码教程10] 数据结构排序算法 [FL基础理论大师]

[code]一、概论
对于数据的处理工作，排序是其最基本的运算之一。在当今的计算机系统中，花费在排序上的时间占系统CPU运行时间的很大比重。有资料表明，在一些商用计算机上，在排序上的CPU时间达到20％至60％。为了提高计算机的工作效率，人们提出了各种各样的排序方法和算法。这些算法有力地发展、并充分地展示了算法设计的某些重要原则和高超技巧。因此，对于计算专业人员来说掌握排序算法是十分重要的。



二、排序算法简介
本次课程中我们将介绍六种排序方法：插入排序，选择排序，冒泡排序，希尔排序，快速排序及二路归并。



<1>直接选择排序(Selection Sort)：简单的选择排序，它的比较次数一定：n(n-1)/2。也因此无论在序列何种情况下，它都不会有优秀的表现（从上100K的正序和反序数据可以发现它耗时相差不多，相差的只是数据移动时间），可见对数据的有序性不敏感。它虽然比较次数多，但它的数据交换量却很少。所以我们将发现它在一般情况下将快于冒泡排序。



<2>直接插入排序(Insertion Sort)：简单的插入排序，每次比较后最多移掉一个逆序，因此与冒泡排序的效率相同。但它在速度上还是要高点，这是因为在冒泡排序下是进行值交换，而在插入排序下是值移动，所以直接插入排序将要优于冒泡排序。直接插入法也是一种对数据的有序性非常敏感的一种算法。在有序情况下只需要经过n-1次比较，在最坏情况下，将需要n(n-1)/2次比较。



<3>冒泡排序(Bubble Sort)：将相邻的两个数据元素按关键字进行比较，如果反序，则交换。对于一个待排序的数据元素序列，经一趟排序后最大值数据元素移到最大位置，其它值较大的数据元素向也最终位置移动，此过程为一次起泡。然后对下面的记录重复上述过程直到过程中没有交换为止，则已完成对记录的排序。



<4>快速排序(Quick Sort)：是冒泡排序的改进，它通过一次交换能消除多个逆序，这样可以减少逆序时所消耗的扫描和数据交换次数。在最优情况下，它的排序时间复杂度为Ｏ(nlog2n)。即每次划分序列时，能均匀分成两个子串。但最差情况下它的时间复杂度将是Ｏ(n^2)。即每次划分子串时，一串为空，另一串为m-1（程序中的100K正序和逆序就正是这样，如果程序中采用每次取序列中部数据作为划分点，那将在正序和逆时达到最优）。从100K中正序的结果上看“快速排序”会比“冒泡排序”更慢，这主要是“冒泡排序”中采用了提前结束排序的方法。有的书上这解释“快速排序”，在理论上讲，如果每次能均匀划分序列，它将是最快的排序算法，因此称它作快速排序。虽然很难均匀划分序列，但就平均性能而言，它仍是基于关键字比较的内部排序算法中速度最快者。



<5>希尔排序(Shell Sort)：增量的选择将影响希尔排序的效率。但是无论怎样选择增量，最后一定要使增量为１，进行一次直接插入排序。但它相对于直接插入排序，由于在子表中每进行一次比较，就可能移去整个经性表中的多个逆序，从而改善了整个排序性能。希尔排序算是一种基于插入排序的算法，所以对数据有序敏感。



<6>归并排序(Merge Sort)：归并排序是一种非就地排序，将需要与待排序序列一样多的辅助空间。在使用它对两个己有序的序列归并，将有无比的优势。其时间复杂度无论是在最好情况下还是在最坏情况下均是O (nlog2n)。对数据的有序性不敏感。若数据节点数据量大，那将不适合。但可改造成索引操作，效果将非常出色。


三、排序方法的选择

因为不同的排序方法适应不同的应用环境和要求，所以选择合适的排序方法很重要

(1)若n较小，可采用直接插入或直接选择排序。
当记录规模较小时，直接插入排序较好，它会比选择更少的比较次数；
但当记录规模较大时，因为直接选择移动的记录数少于直接插人，所以宜用选直接选择排序。
这两种都是稳定排序算法。


(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜(这里的随机是指基准取值的随机，原因见上的快速排序分析)；这里快速排序算法将不稳定。


(3)若n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。
快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
堆排序虽不会出现快速排序可能出现的最坏情况。但它需要建堆的过程。这两种排序都是不稳定的。
　归并排序是稳定的排序算法，但它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。


(4)特殊的箱排序、基数排序
它们都是一种稳定的排序算法，但有一定的局限性：
1>关键字可分解。
2>记录的关键字位数较少，如果密集更好
3>如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。




四、AS中排列数组
1.申请一个长度为n的数组A：
var n:Number = 400;
var A:Array = new Array(n);
for (i=0; i<n; i++) {
A[i] = i;
}
trace(A);



2.将长度为n的数组打乱次序：
for (i=0; i<n; i++) {
var ran = int(Math.random()*n);
var temp = A[i];
A[i] = A[ran];
A[ran] = temp;
}
trace(A)



3.将数组中的所有元素倒排序：
A.reverse();
trace(A)


五、AS实现排序算法：
1.直接插入排序
var n:Number = 400;
var A:Array = new Array(n);
for (i=0; i<n; i++) {
A[i] = i;
}
for (i=0; i<n; i++) {
var ran = int(Math.random()*n);
var temp = A[i];
A[i] = A[ran];
A[ran] = temp;
}
trace(A);
trace("========== Order the array =========");
for (i=0; i<n; i++) {
var temp = A[i];
for (j=i; j>0 && temp<A[j-1]; j--) {
  A[j] = A[j-1];
  A[j-1] = temp;
}
}
trace(A);



2.直接选择排序

var n:Number = 400;
var A:Array = new Array(n);
for (i=0; i<n; i++) {
A[i] = i;
}
for (i=0; i<n; i++) {
var ran = int(Math.random()*n);
var temp = A[i];
A[i] = A[ran];
A[ran] = temp;
}
trace(A);
trace("========== Order the array =========");
var s:Number;
for (i=0; i<n-1; i++) {
s = i;
for (j=s+1; j<n; j++) {
  if (A[j]<A[s]) {
   s = j;
  }
}
var temp = A[i];
A[i] = A[s];
A[s] = temp;
}
trace(A);



3.冒泡排序
var n:Number = 400;
var A:Array = new Array(n);
for (i=0; i<n; i++) {
A[i] = i;
}
for (i=0; i<n; i++) {
var ran = int(Math.random()*n);
var temp = A[i];
A[i] = A[ran];
A[ran] = temp;
}
trace(A);
trace("========== Order the array =========");
for (i=0; i<n; i++) {
for (j=i; j<n; j++) {
  if (A[i]>A[j]) {
   var temp = A[i];
   A[i] = A[j];
   A[j] = temp;
  }
}
}
trace(A);



4.希尔排序
var n:Number = 400;
var A:Array = new Array(n);
for (i=0; i<n; i++) {
A[i] = i;
}
for (i=0; i<n; i++) {
var ran = int(Math.random()*n);
var temp = A[i];
A[i] = A[ran];
A[ran] = temp;
}
trace(A);
trace("========== Order the array =========");
var increment = 6;
while (increment>1) {
increment = int(increment/3+1);
Shellpass(increment);
}
function Shellpass(c) {
for (i=c; i<n; i++) {
  if (A[i]<A[i-c]) {
   var temp = A[i];
   j = i-c;
   do {
    A[j+c] = A[j];
    j = j-c;
   } while (j>0 && temp<A[j]);
   A[j+c] = temp;
  }
}
}
trace(A);



5.快速排序
var n:Number = 400;
var A:Array = new Array(n);
for (i=0; i<n; i++) {
A[i] = i;
}
for (i=0; i<n; i++) {
var ran = int(Math.random()*n);
var temp = A[i];
A[i] = A[ran];
A[ran] = temp;
}
trace(A);
trace("========== Order the array =========");
function QuickSort(A, low, hig) {
var i = low, j = hig;
var mid = A[int((low+hig)/2)];
do {
  while (A[i]<mid) {
   i++;
  }
  while (A[j]>mid) {
   j--;
  }
  if (i<=j) {
   var temp = A[i];
   A[i] = A[j];
   A[j] = temp;
   i++;
   j--;
  }
} while (i<=j);
if (low<j) {
  arguments.callee(A, low, j);
}
if (i<hig) {
  arguments.callee(A, i, hig);
}
}
QuickSort(A, 0, n-1);
trace(A);



6.二路归并
var n:Number = 400;
var A:Array = new Array(n);
for (i=0; i<n; i++) {
A[i] = i;
}
for (i=0; i<n; i++) {
var ran = int(Math.random()*n);
var temp = A[i];
A[i] = A[ran];
A[ran] = temp;
}
trace(A);
trace("========== Order the array =========");

var A1:Array = new Array(n);
for (k=1; k<n; k *= 2) {
MergePass(k);
}
function MergePass(len) {
for (i=0; i+2*len<n; i=i+2*len) {
  MergeA(i, i+len-1, i+2*len-1);
}
if (i+len<n) {
  MergeA(i, i+len-1, n-1);
}
}
function MergeA(low, m, hig) {
var i = low, j = m+1, z = 0;
while (i<=m && j<=hig) {
  A1[z++] = (A[i]<=A[j]) ? A[i++] : A[j++];
}
while (i<=m) {
  A1[z++] = A[i++];
}
while (j<=hig) {
  A1[z++] = A[j++];
}
for (z=0, i=low; i<=hig; z++, i++) {
  A[i] = A1[z];
}
}
trace(A);


教程到此结束
QQ：147461195（FL基理大师）[/code]

16。[Flash基础理论课11] AS文本计算器 [文本类]
[code]
通过这个实例顺便介绍一下定义函数在程序中的应用，及代码的优化过程

思路:

1.用AS创建四个文本框第一个用于输入数字，第二个用于输入运算符，第三个还用于输入数字，最后一个用于输出结果。


2.设置一个按钮(count_btn)，按下后跟据第二个文本框给出的运算符将第一个和第三个文本内容进行运算，并在最后一个文本框内输出。


3.第一个文本框名为"in1"

第二个文本框名为"sign"

第三个文本框名为"in2"

第四个文本框名为"out"

可执行程序一：

var t_f:TextFormat = new TextFormat();

t_f.size = 20;

//设置文本格式中的字体为20

//================设置第一个文本框====================

_root.createTextField("in1", 1, 25, 50, 150, 25);

//创建一个文本框，注意再往下的文本框Y坐标是递增的
in1.setNewTextFormat(t_f);

//将设置好的文本格式赋给该文本框

in1.type =
"input";
//设置文本框类型为输入

in1.background = true;
//文本框有背景色

in1.backgroundColor =
0xffffff;
//背景色为白色

in1.border = true;
//文本框有边框

in1.borderColor = 0x0;
//边框颜色为黑色

in1.maxChars =
7;
//文本框中字符最大为7个

in1.restrict =
"0-9";
//文本框中允许输入的字符集为0到9

//============设置第二个文本框(基本同上)==============

_root.createTextField("sign", 2, 25, 80, 150, 25);
sign.setNewTextFormat(t_f);


sign.type = "input";

sign.background = true;

sign.backgroundColor = 0xffffff;

sign.border = true;

sign.borderColor = 0x0;

sign.maxChars = 1;

sign.restrict =
"+*/\\-";
//============设置第三个文本框(基本同上)==============


_root.createTextField("in2", 3, 25, 110, 150, 25);
in2.setNewTextFormat(t_f);


in2.type = "input";

in2.background = true;

in2.backgroundColor = 0xffffff;

in2.border = true;

in2.borderColor = 0x0;

in2.restrict = "0-9";

in2.maxChars =
7;
//==============设置第四个输出文本框===============


_root.createTextField("out", 4, 25, 165, 150, 25);
out.setNewTextFormat(t_f);


out.type = "dynamic";

out.background = true;

out.backgroundColor = 0xffffff;

out.border = true;

out.borderColor =
0x0;
//================按钮按下后进行计算================


count_btn.onRelease = function() {

if (sign.text == "+") {

  out.text =
int(in1.text)+int(in2.text);

}

if (sign.text == "-") {

  out.text =
int(in1.text)-int(in2.text);

}

if (sign.text == "*") {

  out.text =
int(in1.text)*int(in2.text);

}

if (sign.text == "/") {

  out.text =
int(in1.text)/int(in2.text);

}

};

在这个程序中的们看到对于文本框属性的设置重复了多次，为了精简代码我们考虑使用函数来解决代码的重用问题，请看第二段程序

可执行程序二：

var t_f:TextFormat = new TextFormat();

t_f.size = 20;
function F(txt) {

txt.setNewTextFormat(t_f);

txt.background = true;

txt.backgroundColor = 0xffffff;

txt.border = true;

txt.borderColor = 0x0;

txt.type = "input";

if (txt == sign) {

  txt.maxChars = 1;

  txt.restrict = "+*/\\-";

}

if (txt == out) {

  txt.type = "dynamic";

}

if (txt == in1 || txt == in2) {

  txt.maxChars = 7;

  txt.restrict = "0-9";

}

}
_root.createTextField("in1", 1, 25, 50, 150,
25);

F(in1);

_root.createTextField("sign", 2, 25, 80, 150, 25);

F(sign);

_root.createTextField("in2", 3, 25, 110, 150,
25);
F(in2);
_root.createTextField("out",
4, 25, 165, 150, 25);

F(out);

count_btn.onRelease = function() {

if (sign.text == "+") {

  out.text =
int(in1.text)+int(in2.text);

}

if (sign.text == "-") {

  out.text =
int(in1.text)-int(in2.text);

}

if (sign.text == "*") {

  out.text =
int(in1.text)*int(in2.text);

}

if (sign.text == "/") {

  out.text =
int(in1.text)/int(in2.text);

}

};
//在这段程序中我们通过调用函数来设置属性，属性相同的地方写在函数的最开始，不同的地方用if语句进行判断后再赋予

最后我们再优化一下代码：使用with语句，批量设置属性，再将按钮中的if改为switch使他的结构更加清晰，可读性更好：


可执行程序三：

var t_f:TextFormat = new TextFormat();

t_f.size = 20;
function F(txt) {

with
(txt) {

  setNewTextFormat(t_f);

  background = true;

  backgroundColor =
0xffffff;

  border = true;

  borderColor = 0x0;

}

if (txt == sign)
{
  with
(txt)
{
   type
= "input";

   maxChars =
1;

   restrict =
"+*/\\-";

  }
}

if (txt == out)
{
  txt.type
= "dynamic";
}

if (txt == in1 || txt == in2) {

  with
(txt) {

   type =
"input";

   maxChars =
7;

   restrict =
"0-9";

  }


}

}

_root.createTextField("in1", 1, 25, 50, 150, 25);

F(in1);

_root.createTextField("sign", 2, 25, 80, 150, 25);

F(sign);

_root.createTextField("in2", 3, 25, 110, 150, 25);

F(in2);

_root.createTextField("out", 4, 25, 165, 150, 25);

F(out);

count_btn.onRelease = function()
{
switch (sign.text)
{

case "+" :

  out.text =
int(in1.text)+int(in2.text);

  break;

case "-" :

  out.text =
int(in1.text)-int(in2.text);

  break;

case "*" :

  out.text =
int(in1.text)*int(in2.text);

  break;

case "/" :

  out.text =
int(in1.text)/int(in2.text);

  break;

}

};
//好了到这里就完成了代码的由繁到简的优化，希望同学们在今后的实践中加深领悟。


FLASH充电1: TextField
常用属性及事件处理函数
常用属性:

1.createTextField("实例名", 深度, x坐标, y坐标, 宽度,
高度)

用来创建一个文本框。

例:createTextField("txt", 1, 10, 20, 100, 100);

2.autoSize:控制文本字段的自动大小调整和对齐。


autoSize 的可接受值为 "none"(默认值)、"left"、"right" 和
"center"。当您设置 autoSize 属性时，true 是 "left" 的同义词，false
是 "none" 的同义词。

注意:当txt.autoSize = true 时,表示自动匹配尺寸

这时createTextField("txt", 1, 10, 20, 0, 0)宽和高可以为0

3.background:指定文本字段是否具有背景填充;


backgroundColor:文本字段背景的颜色。

注意:这两句要配合使用:

例如:txt.background = true;

   
txt.backgroundColor = 0xff0000;

4.border:指定文本字段是否具有边框。

borderColor:文本字段边框的颜色。

注意:这两句一般要配合使用:

例如:txt.border = true;

   
txt.borderColor = 0x0;

5.selectable:一个布尔值,指示文本字段是否可选。


例如:txt.selectable=false 表示txt文本字段可选。

6.textColor:指示文本字段中文本的颜色。


例如:txt.textColor = 0xFF0000;

7.type:指定文本字段的类型。


有两种值:

"dynamic":指定不能由用户对其进行编辑的动态文本字段;

"input":指定输入文本字段。

例如: txt.type = "dynamic" 指定txt的类型为动态文本;

     
txt.type = "input" 指定txt的类型为输入文本。

8.wordWrap:一个布尔值，指示文本字段是否自动换行。


例如:txt.wordWrap = true 表示自动换行。

9.multiline:指示文本字段是否为多行文本字段。


例如:txt.multiline = true 表示txt文本框为多行。

10.hscroll:指示当前水平滚动位置。

注意:在txt为单行不换行的情况下

一般在按钮中写入:txt.hscroll+=5。

scroll:文指示当前垂直滚动位置(与hscroll相对)。

注意:在txt为多行且换行的情况下

一般在按钮中写入:txt.scroll+=5。

11.maxChars:指示文本字段最多可容纳的字符数。


例如:txt.maxChars = 7 表示txt最多容纳7个字符。

12.password:指定文本字段是否是密码文本字段。


例如:txt.password = true 表示txt中的字段以密码形式出现。

13.restrict:约束用户可输入到文本字段中的字符集。


例如:

<1>仅允许在文本字段中输入大写字符、空格和数字:

txt.restrict = "A-Z 0-9";
<2>包含除小写字母之外的所有字符:

txt.restrict = "^a-z";
<3>可以使用反斜杠输入 ^ 或 -
的本义。认可的反斜杠序列为 \-、\^ 或
\\。反斜杠在字符串中必须是一个本义字符，因此在
AS中指定时必须使用两个反斜杠。下面的代码只包含 - 和 ^ :

txt.restrict = "\\-\\^";
<4>可在字符串中的任何地方使用
^，以在包含字符与排除字符之间进行切换。包含除大写