flash殿堂之路学习笔记

1.5hell,word.fla

trace("hell,word")

2.2.1如何声明变量.fla

/*声明变量的方法
var 变量名:数据类型
var 变量名：数据类型=值;*/

/*错误例子
i;//没有加var关键字 没有声明变量 报错
i=3//没有加var关键字 没有声明变量 报错
var i:int="hell" //声明了一个变量数据类型为int
但是值给了一个字符串类型数据 报错*/

//正确例子
var i:int//声明了一个变量i 数据类型为int但没有赋值 只好使用默认
var k:int=1000;//声明了变量k，赋值为1000
var g;//声明变量g 没指定类型 默认为untypde

2.2.3变量的本质 值类型与引用类型的区别.fla

//值类型直接储存值而 引用类型则是储存引用
//值类型有：Boolean,int,Number,uint,String其他的都是引用类型
//例子
var a:int=100;
var b:int=a
b=9
trace(a)
trace(b)//trace a=100 b=9
var c:Array=new Array(1,2,3)
var d:Array=c
d[2]=4
trace(c)
trace(d)//trace c=1 2 4 d=1 2 4
//可以看出值类型与引用类型的区别
//把才c的值赋给d d的值改变 c的值也跟着改变

//下面链接2.3

2.3用const声明常量.fla

const foo:int=100;
//foo=99;//报错1049
const foot:Array=[1,2]
var b:Array=foot;
b[1]=3
trace(b)
trace(foot)
//foot=[2,3]//报错1049
//对于值类型常量持有值，对于应用类型来说
//常量持有引用


2.4.4字符串.fla

//如何声明字符串
var aa:String//声明一个String型变量，此时未定义，默认为null
var bb:String=""//声明一个空的字符串，已经定义
var cc:String=new String()//用包装类来声明，与商行效果相同
var dd:String="asad"//声明了一个内容为asad的字符串
var ee:String=new String("asad")//同上
var ff:String='asad'//也可以使用单引号来声明新的字符串
var myString:String="this is a string"
var myStringlength:Number=myString.length
trace(myStringlength)//输出16 ？？因为还有三个空格
var gg:String="你好！崔永超"
trace(gg,gg.length)
/*在字符串中使用\n 表示换行 \r表示回车\t表示制表 \ 是转义符如果想在字符串中表示\怎么办
使用\\就可以了*/
var hh:String="你好\n我是\"崔永超\""
trace(hh)/*输出你好
我是“崔永超”*/
//如果要在字符串中表示单双引号 在前面加斜杠即可



2.4.5数组.fla


//AS3.0中数组的定义：数组是以非零整数为索引的稀疏数组，不支持类型化数组。
//以非负整数为索引值来访问数组元素。数组最多可容纳2的23次方-1个元素即4294967295个
var a:Array//声明一个数组型变量a，但没有告诉a这个引用指向谁。trace得到null
trace(a)//输出null
var b:Array=[]//直接声明了一个空的数组b，trace得到空白显示但不再是null了
trace(b)
var c:Array=new Array()//效果同声明b的方法
var d:Array=[1,2,3,4]//直接使用[]声明了一个含有整数1，2，3，4的数组
var e:Array=

new Array(1,2,3,4)//效果同上
var f:Array=new Array(5)//声明一个长度为5的空数组，此时每个数组元素都为空
trace(f)//输出,,,,
//如何访问数组的元素呢
var myArray:Array=[1,2,"呵呵","你好"]
trace(myArray[0])
trace(myArray[3])



2.4.6object及关联数组.fla

//Array通过数字来访问成员，Object通过名字来访问成员
//Object的成员有两种：一种是 属性 用来存放各种数据；另一种是方法，存放函数对象
//成员的名字也被称为键 成员被称为这个键对应的值
//声明一个新的object
//使用构造函数
var myobject:Object=new Object()
//使用空的{}作为new Object()函数的依法快捷方式
var myobject1:Object={}
//写入多个属性，属性名和属性值一"："号隔开，属性之间以"，"号隔开
var myfistObject:Object={xingming:"崔永超",dianhua:"1234567"}
trace(myfistObject.xingming)//输出 崔永超
//直接写入多个方法。
var dd:Object={hello:function(){trace("hello,崔永超")},ok:function(){return"我叫崔永超"}}
dd.hello()//输出 hello，崔永超
trace(dd.hello)//输出function Function() {}
trace(dd.ok())//输出 我叫崔永超
trace(dd.ok)//输出function Function() {}
//Object可以动态添加属性
//先初始化即新建一个空的对象 建起引用赋值kingda
var kingda:Object=new Object()
//新增属性 姓名，将"张三""赋值给他
kingda.姓名="张三"
//新增shuzi属性，把1赋值给他
kingda.shuzi=1
trace(kingda.姓名)
trace(kingda.shuzi)
//Object可以动态地添加方法
kingda.hello=function(){
trace("hi,崔永超")
}
kingda.hello()//输出hi,崔永超
//上例由于我们知道成员的名字，所以可以直接用点号运算符"." 添加或访问他们
//如何访问程序运行时才知道名字的成员呢，，，那么就需要运算符"[]"了
var ass:Object={}
var now:Date=new Date()
var bss:String
trace(now.getTime())//输出距离1970年1月1日的毫秒数
if((now.getTime()%2)==0){
bss="名字"
}else{
bss="name"
}
//注意：使用字符串变量bss作为ass的属性名字。使用了数组运算符
ass[bss]="张三"
//对ass对象进行属性遍历，显示 出所有的属性名和属性值
for(var i in ass){
trace("当前属性名"+i+" 当前属性值"+ass[i])
}
//输出：当前属性名name或名字 当前属性值：张三
//直接用[]运算符+字符串来访问或添加属性。
var asd:Object={}
asd["xingming"]="涨三"//这是数组运算符
//asd.xingming="wangwu"
trace(asd.xingming)//这是点号运算符二者相同
trace(asd["xingming"])



2.4基础数据类型.fla


/*基础数据类型包括
所有基元数据类型：Boolean，int，uint，Number
，String
两种复杂数据类型：Array，object
*/
//布尔值是用来表示真假的数据类型 他有两个值true，false
//声明了布尔型变量未赋值 那么就是没有初始化 它的默认值
//是fal

se 而As2.0中则是undefined
//as2
/*var b:Boolean
trace(b)//umdefined
trace(b==false)//输出false*/
//as3
var b:Boolean
trace(b)//false
trace(b==false)//输出true
//as3中表示数字值的类型有三种 int uint Number
//int和uint 都是整数值Numier用来处理浮点数
//-2147483648<=int<=2147483647
//0<=uint<=4294967295
//Number类型是64位浮点数 1.79769313486231e+308到4.940656458412467e-324
/*数字类型的选择:
整数运算使用整型值
涉及到小数用浮点值 整数数值涉及到除法时建议用浮
点值*/
/*能用整数值时优选使用int和uint。整数值有正负之分时 ，请用int。之处理正整数，优先使用
uint。处理和颜色相关的数值时，使用uint
碰到或可能碰到小数点时用number.*/

var a:int=9
var d:int=a/2
trace(d)//输出4
var c:Number=a/2
trace(c)//输出4.5
//要特别小心整整形数值的边界
var i:uint=0
i--
trace(i)//可能期望是-1 实际上是4294967295
var j:uint=4294967295
j++
trace(j)//可能期望是4294967296 实际上是0
var cf:int=-2147483648
cf--
trace(cf)//期望是-2147483649 实际是2147483647
var bf:int=2147483648
bf++
trace(bf)//期望是2147483649 实际是-2147483647
//Number浮点类型使用的注意事项
var bb:Number=1
var cc:Number=0
for(var iv:uint=0;iv<10;iv++){
cc+=0.1
}
trace(cc)//输出0.9999999999999999
trace (bb-cc)//输出1.1102230246251565e-16
/*如果实在需要浮点小数相加得到证书，那么急的使用
Math.round()来修正。*/
var bss:Number=0.999
var css:Number=0.001
trace(bss+css)//输出1
//不要让数值差距过大的浮点数相加减，结果可能有偏差
var aa:Number=10000000000
var aac:Number=aa+0.0000000001
trace(aac)//输出10000000000
for(var icc:uint=0;icc<10000000;icc++){
aa+=0.0000000001
}
trace(aa)//10000000000加了0.0000000001 10000000次结果还是10000000000
var asc=0.0000000001
trace(asc+0.0000000001)//相加正确 输出2e-10



2.47多维数组.fla

//数组的成员有 String、int、Function、Array等等
//所谓多维数组其实就是他的成员也是Array（数组）所以多维数组又叫嵌套数组
//三种杜维数组的构建方法
var aa:Array=[[1,2,3],[4,5,6],[7,8,9]]
trace(aa[2])//输出7，8，9
trace(aa[2][1])//输出8


var bb:Array=new Array(new Array(1,2,3),new Array(4,5,6),new Array(7,8,9))
trace(bb[2])//输出7，8，9
trace(bb[2][1])//输出8
var cc:Array=new Array(3)
cc[0]=[1,2,3]
cc[1]=[4,5,6]
cc[2]=[7,8,9]
trace(cc[2])//输出7，8，9
trace(cc[2][1])//输出8
//可以试一试
var dd:Array=[[1,2,3],[4,5],[6,[1,2,3],2,3],[5,3]]
trace(dd[1])//输出4,5
trace(dd[1][1])//输出5
trace(dd[2])//输出6，1，2，3，2，3
trace(dd[2][1])//输出1，2，3
trace(dd[2][1][1])//输出2




2.48 null nan undefined.fla


//我们声明变量时没有初始化也就是没有给他赋值 那么FlashPlay给予他一个值，
//这个值就是变量的默

认值
var a:int
var b:uint
var c:Number
var d:String
var e:Boolean
var f:Object
var g
var h:*
var i:Array
trace(a)//输出0
trace(b)//输出0
trace(c)//输出NaN
trace(d)//输出null
trace(e)//输出false
trace(f)//输出null
trace(g)//输出undefined
trace(h)//输出undefined
trace(i)//输出null
//Number类型数据没有初始化的运算
var aa:Number
var bb:Number=10
var cc:Number=aa+bb
var dd:Number=bb-aa
var ee:Number=aa*bb
var ff:Number=aa/bb
var gg:Number=bb/aa
var hh:int=bb+aa
var mm:uint=bb-aa
trace(cc)//输出NaN
trace(dd)//输出NaN
trace(ee)//输出NaN
trace(ff)//输出NaN
trace(gg)//输出NaN
trace(hh)//输出0
trace(mm)//输出0
//判断String能否转换成Number
var xxx:Number=Number("你好")
var zzz:Number=Number("123")
trace(xxx)
trace(zzz)
trace(xxx==NaN)//输出false
trace(zzz==NaN)//输出false
//上面的方法永远输出false请不要用
trace(!(xxx))//输出true
trace(!(zzz))//输出false
var nnn:Boolean=NaN
trace(nnn)//输出false




2.5运算符。表达式及运算.fla

//加减乘除不多说了
//下面说一下模运算 即除法取余数
var a:int=13
var b:int=5
trace(a%b)//输出3 正常
trace(13.1%5)//输出3.0999999999999996而不是3.1
trace(12.2%6.1)//输出0 整数倍时 即使有小数结果正确
trace(12.5%6.1)//输出0.3000000000000007
var c:int=-2
var d:int=-a//输出2
var e:int=0
e+=4//输出4 实际就是a=e+4
var f:int=0
f=f+4//输出4
/*
+= a+=b a=a+b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
*/
//关系运算符
/*判断运算符：等于运算符==
不等于运算符！=
全等运算符===
不全等运算符！==
判断大小关系：大于运算符>
小于运算符<
大于等于运算符>=
小于等于运算符<=
*/
//判断运算符下：基础数据类型运算符判断两边 值 是否相同
// 复杂数据类型运算符判断两边 引用 是否相同
//==和===
var g:int=5
var h:uint=5
trace(g==h)//输出 true
trace(g===h)//输出true。 int，uint，Number都是类型值相同，全等就成立
var l:String="5"
//trace(g==l)//输出 错误1176
trace(String(g)==l)//输出ture
//trace(g===l)//输出 错误1176
trace(String(g)===l)//输出ture
var m:int=1
var n:Boolean=true
trace(n==m)//输出true 执行了数据转换 n被转换成了数值1
trace(n===m)//输出false 没执行了数据转换
//==和===运算符对于变量默认值的比较是不同的

var o:Number
var p:Number
trace(o)//输出NaN
trace(p)//输出NaN
trace(o==p)//输出false
trace(o===p)//输出false
//trace(undefined==null)//输出报错1012
//trace(undefined===null)//输出报错1012
//关系运算符>,<,>=,<=
var q:int=3
var r:String="4"
//trace(q>r)//输出 错误1176
trace(qvar s:int=0
var t:Boolean=true
trace(s>t)//输出 false,执行了数据转换 t被转换成了数值1
//逻

辑运算符&&，||，！
//逻辑运算符两边必须有运算对象 这个运算对象 可以是变量，函数返回值，也可以是表达式
var age:uint=15
if((age>12)&&(age<18)){
trace("你是小朋友！")

}else{
trace("你不是小朋友！")
}
//输出：你是小朋友！
age=200
if((age<0)||(age>150)){
trace("你不是人呀！")
}
//输出：你不是人呀！
//!
var aa:Boolean=false
if(!aa){
trace("完全正确")
}


//2.5.11 typeof，is，as
trace(typeof 10)//输出：number
//is用来判断一个对象是否属于一种类型，返回布尔值，true表示属于false表示不属于
trace(9is Number)//输出 true
//一个对象是否属于一种类型，as返回这个对象，否则返回null
trace(9 as Number)//输出9
trace(9 as Array)//输出null
//in关键词用来判断一个对象是否作为另一个对象的键（key）或索引，存在返回true，不存在返回 false
var bb:Array=["q","w","e"]
trace(2 in bb)//输出 true 数组bb含有索引2

trace(3 in bb)//输出 false 数组bb不含有索引3
var cc:Object={ary:a,name:"ok"}
trace("ary"in cc)//输出 true 的确有ary为键的属性
trace("name" in cc)//同上
//delete关键字用来删除对象的动态实例属性，非动态属性不能删除
//如果要将一个属性所持有的引用删除，将null赋值给该属性即可
var ff:Object={ary:"one",name:"ok"}
delete ff.ary//因为ary是b对象的动态属性
trace(ff.ary)//输出 undefined
ff=null
trace(ff)//输出 null，那么b变量持有原有对象的引用就删除了



3.1 什么是面向过程.fla


var 盒子:Array=["语文","数学","英语","物理"]
var 目标课本:String="物理"
for(var i:int=0;i<盒子.length;i++){
if(盒子[i]==目标课本){
trace("找到物理课本了！")
}
}



3.3 if if else.fla

//if-else格式
/*
if(条件表达式){
流程
}
if(){
流程a
}else{
流程b
}
*/
var a:int=10;
var b:int=5;
if (a>b) {
trace("a比b大");
} else {
trace("b比a小");
}
//精简写法
if (a>b) {
trace("a比b大");
} else {
trace("b比a小");
}//if...else if...else
var c:int=100;
if (c>0) {
trace("c是一个大于0的数");
} else if (c>50) {
trace("c是一个大于50的数");
} else {
trace("c是一个小于零的数");
}//只输出了c是一个大于0的数

var d:int=49;
if (d>50) {
trace("d是一个大于50的数");
} else if (d>0) {
trace("d是一个大于0的数");
} else {
trace("d是一个小于零的数");
}//只输出了d是一个大于0的数



3.4循环.fla


//AS3.0 循环语句有 while, do-while,for,for...in,for each...in
/*while循环
while (循环条件) {
循环体;
}
*/
var box:Array=["语文","物理","数学"]
var i:int=0
while(iif(box[i]=="物理"){
trace("找到了！")
}
i++
}
/*do-while结构
do{
循环体
}
while(循环条件)
*/
//for循环比较灵活
/*for循环结构
for(初始化

；循环条件；步进){
循环体
}
*/
//看看上面的循环用for怎么写
var e:int=0
for(;;){
if(box[e]=="物理"){
trace("找到物理课本了！")
}
e++
if(e>=box.length)break
}

for(var d:int=0;dif(box[d]=="物理"){
trace("找到物理课本了！")
}
}
//for...in和for each...in
//数组 我们可以通过索引得到全部成员
//Object怎么办 它没有索引 对了用for...in和for each...in
//看例 码
var 盒子:Object={flash教程:"AS3.0殿堂之路",数学教程:"高等数学",语文教程:"高等语文教程"}
for(var k in 盒子){
trace(k+":"+盒子[k])
}
/*输出：语文教程:高等语文教程
数学教程:高等数学
flash教程:AS3.0殿堂之路
*/
for each (var m in 盒子){
trace(m)
}
/*输出：
高等语文教程
高等数学
AS3.0殿堂之路
*/
//上面例子看出for...in与for each in的区别
//3.4.6 break和continue的简单用法
//break和continue用来控制循环流程
//break用来直接跳出循环，不再执行循环体内后面的语句
//continue只是终止当前之一轮的循环，直接跳到下一轮循环，而在这一轮循环中，循环体内continue后面的语句也不会被执行
//reture也可以和break一样种植循环
//看例 码
for (var aa:int=0;aa<5;aa++){
if(aa==3)break
trace("当前数字："+aa)
}
/*
输出：
当前数字：0
当前数字：1
当前数字：2
*/for (var bb:int=0;bb<5;bb++){
if(bb==3)continue
trace("当前数字："+bb)
}
/*
输出：
当前数字：0
当前数字：1
当前数字：2
当前数字：4
*/
//3.4.7






3.4.7 控制嵌套循环的流程.fla


//3.4.7 控制嵌套循环的流程:break, continue 的标签用法
//为什么 flash会设计这个东西？
//因为 有时需要通过子循环break循环 等等 多种情况而设定
//看例码
/*
var i:int=-1
parent://本行设定最外层循环标签为parent
do{
trace("父循环")
son://本行设定第二层循环标签为：son
//子循环开始。。。。
while(true){
i++
trace("\t子循环：i="+i)
//孙循环开始。。。
for(var k:int=0;k<3;k++){
trace("\t\t孙循环：k="+k)
if(i==1){
trace("\t\ti==1:continue 孙循环")
continue
}
if(i==2){
trace("\t\ti==2:continue 子循环：son")
continue son
}
if(i==3){
trace("\t\ti==3:continue 父循环：parent")
continue parent
}
if(i==4){
trace("\t\ti==4:break 孙循环")
break
}
if(i==5){
trace("\t\ti==5:break 子循环：son")
break son
}
if(i==6){
trace("\t\ti==6:break 父循环：parent")
break parent
}
trace("\t\t孙循环")
}
trace("\t 子循环")
}
trace("父循环")
}while(true)
*/
/*输出
父循环
子循环：i=0
孙循环：k=0
孙循环
孙循环：k=1
孙循环
孙循环：k=2
孙循环
子循环
子循环：i=1
孙循环：k=0
i==1:continue 孙循环
孙循环：k=1
i==1:continue 孙循环
孙循环：k=2
i==1:continue 孙循环
子循环
子循环：i=

2
孙循环：k=0
i==2:continue 子循环：son
子循环：i=3
孙循环：k=0
i==3:continue 父循环：parent
父循环
子循环：i=4
孙循环：k=0
i==4:break 孙循环
子循环
子循环：i=5
孙循环：k=0
i==5:break 子循环：son
父循环
父循环
子循环：i=6
孙循环：k=0
i==6:break 父循环：parent
*/
//太复杂 写个简单的
/*
aa:
for (var cs:int=0; cs<8; cs++) {
trace("第"+cs+"次父循环");
for (var bs:int=0; bs<3; bs++) {
trace("\t第"+bs+"次子循环");
if (cs==1) {
trace("\tbreak 不再执行子循环");
break;
}
if (cs==2) {
trace("\tcontinue第2次子循环不再执行")
continue;
}
if (cs==3) {
trace("\tcontinue第3次父循环不再执行")
continue aa;
}
if (cs==4) {
trace("\tbreak 不再执行父循环")
break aa
}
}
}
*/
//下面看看switch

var 放水果的黑箱子:Array=["苹果","香蕉","小西红柿","桃子","橘子"];
var 随即摸:String=放水果的黑箱子[Math.floor(Math.random()*放水果的黑箱子.length)];
trace("摸到的水果是："+随即摸);
switch (随即摸) {
/*case "苹果" :
trace("很好吃的苹果");
break;
case "香蕉" :
trace("很好吃的香蕉");
break;
case "小西红柿" :
trace("很好吃的小西红柿");
break;
case "桃子" :
trace("很好吃的桃子");
break;
case "橘子" :
trace("很好吃的橘子");
break;*/
case "苹果" :
trace("很好吃的苹果");
case "香蕉" :
trace("很好吃的香蕉");
break;
case "小西红柿" :
case "桃子" :
trace("很好吃的桃子");
break;
default:
trace("很好吃的橘子");
}
//自己看输出



4.1 函数的定义方法.fla


//函数：函数是执行特定任务并可以在程序中重用的代码块
//as3中函数分为两类：方法和函数闭包
//如果将函数定义为类的一部分或者将它与某个对象绑定，则该函数称为方法
/*
function 函数名(参数1：参数类型，参数2：参数类型):返回值类型{
//函数内部语句
}
*/
//两种定义函数的方法
function a(b:int=3,c:int=4):int {
return a+b;
}
var e=function(f:int=1,g:int=2):int{
return f+g
};
//两种定义的区别
//aa();
bb();
var aa=function(){
trace("aa")
};
function bb() {
trace("bb");
}
/*输出TypeError: Error #1006: value 不是函数。
at 4_fla::MainTimeline/frame1()
*/
//把aa()注释掉后输出：bb
var cc=function(){
trace("aa")
};
cc();
dd();
function dd() {
trace("bb");
}
//输出：aa
// bb
//this 在两种 声明中也有区别 看例码
var num:int=3
function testThisA(){
trace(num)//3
trace(this.num)//3
trace(this)//[object MainTimeline]
}
var testThisB:Function=function(){
trace(num)//3
trace(this.num)//3
trace(this)//[object MainTimeline]
}
var obj:Object={num:300}
obj.testB=testThisB
obj.testA=testThisA
testThisA()
obj.testA()
testThisA.apply(obj)
//用apply试图将testThisA（）的this关

键字指向绑定到obj上，发现输出没改变
//输出
/*
3
3
[object MainTimeline]
3
3
[object MainTimeline]
3
3
[object MainTimeline]

*/

testThisB()
/*
3
3
[object MainTimeline]
*/
obj.testB()
/*
3
300
[object Object]
*/
testThisB.apply(obj)
//用apply试图将testThisB（）的this关键字指向绑定到obj上，发现输出改变.改变成功
//其他区别
/*
函数语句与函数表达式之间还有两个细微区别：第一个区别体现在内存管理和垃圾回收方面
*/





4.2 参数.fla



//AS3 中参数是按引用传入的
function aa(bb:int,cc:Array) {
bb=100;
cc.push(100);
}
var a:int=5;
var b:Array=[1,2,3];
aa(a,b);
trace(a);
trace(b);
//输出5
//1,2,3,100
//b的值改变了
function bb(a:int=1,b:int=2,c:int=3) {
trace(a+b+c,a,b,c);
}
bb()
bb(5)
bb(5,4)
bb(5,4,3)
/*
6 1 2 3
10 5 2 3
12 5 4 3
12 5 4 3

*/