ActionScript(笔记1)

                 
              ActionScript
              第一章：针对非程序员的简单介绍
1：var 为定义变量，trace,为一个输出函数.
  var message11 ="hai,asdfsadfasdgood flash";
  trace(message11);
2: flash编程里可以为我们记忆某样东西，即是定义变量.
  P:24
3: 解释程序是ActionScrip的交换处理器，它理解你的命令，并负责执行，
  如果不理解就发出错误信息。
4:命令：所需要的额外信息，参数，
  粘合记：操作符
5:条件语句可以让flash进行逻辑选择。
 

                 第十九章 ：调试
 1：调试的工具：trace()函数；列举变量命令；列举对象命令；带宽调试；
    调试器
 2：所有工具在测试影片中使用。
 3：二种错误：语法错误，逻辑错误。
 4：trace()可以检查变量，属性和对象的状态，也可以跟踪代码的进程，
    通常，通过确认脚本中的每一个操作结果，我们就知道问题出在那里
    像：使用trace()命令返回的值是undefined那么我们应试检查问题出在
    那里。
 5：flash的优化
    a:如果可以用非循环的方式完成，尽量用非循环方式完成
    b:不要在循环中等待某个事件的发生
    c:尽可能归纳自己的代码，不必编写几乎相等的二个代码
    d:在发布设置中省略跟踪动作，以便在导出影片的时候将
      trace()语句全部去掉。
    f:尽可能重复使用影片资源
 6：错误的一般来源：
    a:代码位置错误：所有代码必须添加到影片剪切，帧，或者按钮上
    b:遗失事件处理器
      影片剪切：onClipEvent(event){
                        //语句 }
      按钮：on(event){
                        //语句 }
    c: 错误的影片剪切
    d: 类型转换错误
    e: 遗失分号
    f: 引号标记问题
    g: 错误使用文本域数据
    h: 作用域问题
    i: 全局函数和方法混淆
    j: 内容尚未载入
    k: 大小不正确
                     
 7：遇到改正不了的错误
    1：重新编写代码。原来的代码好的可以保留
    2：将有问题的部分分开单独调试
    3：回顾自己写的代码
    4：寻找帮助   
                          
                     第二章：变量
 1:创建变量
    var  在actionscript中，变量没有一定要声明数据类型
 2：自动创建变量，如果对一个并不存在的变量赋值解释程序会为我们
    创建一个新的变量。
   动态创建变量，使用set.
    set的用法，set(名称，值）；
      例:var  i =1;
         set ("player"+i+"name","bruce111");
         trace(player1name);
     注意：player1name为动态创建的变量
 3:在开始处创建变量是一个很好的方法
 4:ActionScript允许变量类型的转换。
 5:检查变量是否有值，将变量的值同undefined关键字比较
   例：if(someVariable!=undefined){
            //放在这里的代码仅当someVaribale有值的时候才能够执行"
          }
 6:ActionScript的变量能够包含任何类型的的数据。
   它还能够随着给变量赋的值类型的变化而改变变量的数据类型
   这个在C++和jave，C#，vb中都是不支持的

 7:值的自动转换
   有一些情况下，ActionScript希望有一个特殊的数据类型，如果我们使用
   的变量，其中的类型不符合所需要的类型解释程序变会试图对数据类型进行
   转换p:59
            例1：x=6 //x是数字6
                y="4"//y是串“4”
                z=x-y;//将z设置为数字2
            此中，actionscript会将y的值从串“4”转换为数字4.z的结果为2.
           
 8:手动确定数据类型
   用typeof操作符来确定变量的数据类型
                           //c#中也是一样的
   例：if (typeof age == "number")
          {trace("yes");}
       else {trace("no");}
                               
 9：变量的作用域
     a:当我们在时间线上定义了一个变量的时候，该变量可以从该时间线上的其它所有侦访问到。
       注意：如果变量定义是放在后面，程序第一次运行的时候，在前面用这个变量的时候是不知道
       这个变量是定义了的，但只要程序运行经过了定义变量的那个侦 以后在这个时间线的任何地方
       程序都能够识别
     b:放置在主时间线上的按钮，里面的设置的变量，在该时间线上的其他地方一样能够访问到
       因为，按钮放在时间线上，这个变量是属于这个时间线上的。
     c:在同一个时间线上定义的任何变量，只要该时间线存在，那么它上面的任何脚本都可以访问到这个
       变量
     b:我还发现在a场景中定义的变量，在b场景中照样能够调用
 
 10：变量的可以访问性                            
      传统的编程中，变量被分为全局和局域的，全局的是在整个程序内部能够被访问到的变量，
      局部的只有在程序某个部分才能够访问到的变量。
      flash支持传统的局域变量，但是它不支持真正的全局变量。
                                                   
 11:  在影片剪辑时间线上定义的变量，其作用域将被限制在该时间线上，其他时间线上的的脚本，
     （比如我们主时间线）不能直接访问到它。

 12：一个属于单独时间线上的变量只能够被该时间线上的变量访问到，由于flash变量都是定义在
     时间轴上的，所以没有哪个变量能够保正可以被影片中的所有变量访问到。因此没有什么变量
     能够堂而皇之的称为全局变量。

 13：将属于时间线上的变量称为时间线变量，或者影片剪辑变量
 
 14：模仿的全局变量
     可以用对象来模仿全局变量P:63
     使用下面语句：object.prototype.myGlobalVariable=myValue;
     （第十二章中有介绍）

 15：访问不同时间抽上的变量：使用点号语法，该变量的剪切名称后跟一个点
     号，然后是变量的名称，

 16：_root
     指想向影片的主时间线
    
    _parent
     指向影片剪辑事例所处时间线上的上一级时间线。
  
    这二个没有实现，有待解决

 17：局域变量P:70
     在函数里面的并声明的变量是局域变量，
    　下面的number2例子中的counter
     在函数调用结束时，局域变量也会跟着消失

     在函数里面的并没有声明的变量是非局域变量，
         
 18:    var b=49;
        function a(b) {
 var counter = 0;
 while (counter<b) {
  trace("Element"+counter+":"+1111);
  counter++;
                   }
                    } 
           a(b);
         trace("good");
        这个里面告诉我二个东西：
        a:function定义的函数a 要调用才能够运行function里面的语句，
        b:在actionScrpit中函数参数的传递:b
    
        
 19：关于while语句的使用细节：
     对于指针变量a的定义，如果a可以定义为 var a:Number=0
     也可以只是 a=0;
     注意number2数组的写法

    number1: var a:Number=0;
             var b=13;
            while(a<b)
                 {
               a++;
               trace("good");
                 }
                          
    number2:
              var theArray=["112","45","2312"];

              function displayElements(theArray)
               {
              var counter=0;
 
              while(counter<theArray.length)
               {
             trace("Element"+
             counter +":"+theArray[counter]);
             counter++;
                      }
               }
             displayElements(theArray);

  第二章总结：
  1：我觉得和其他专业的编程语言相比，ActiopScript趋向于傻瓜化

 

 

 

                    第三章　数据和数据类型
 
1:数据本身是无意义的　但是如果作为某种东西被存储就被成有意义的拉
2:用数据类型可以保持数据的意义

3:ActionScript的数据类型
  字符串：string
  数字: nunber
  逻辑判断：Boolean:ture,false.
  空的数据：null & undefined
  数据列表：array
  影片剪辑：movieclip
  内置或用户自定义的数据类型：object

4:数据创建的二种方式：
　直接表达式：值是直接赋给的
　复杂表达式：值是通过计算，函数等得到的。

5:解释程序会通过语法检测判断一个直接量的数据类型，所以使用正确的数据
　直接量语法是非常重要的，不正确的语法会产生错误，或者产生对数据内容
　的曲解。

6: a="1"+2;为一个串，因为解释程序有一个固定的原则：加操作符总是先匹配
　一个串，合并不同的数据类型或者在某语境中使用了不匹配的数据类型都会
　造成明确的状况，这样迫使解释程序自动按照武断然而可预测进行数据类型
　的转换

7:数据类型的转换（自动）
　a:自动类型的转换
　　如果语境中使用了不匹配的值，解释程序会试图进行转换，
　　如果转换不成功则把它转换为特殊字符NaN
 　 具体转换参考：80
 
　b:显式类型的转换（手动）
　　参考P82;

   串：toString();string();和空串串联的方法转换为串

　  数字：Number();减0;
     parselnt()：提取出现在串中的第一个整数,否则会产生Nan
     parseFloat()：提取出现在串中的第一个浮点数,否则会产生Nan

8:转换为布尔类型
　全局函数：boolean()

9：转换期限：
   所有在变量，数组元数和对象属性上进行的类型的转换都是临时的，除非
   转换的赋值的一部分。
   Example1: var x="10";  //x是一个串
             y=x-5;       //y现是5, x的值被转换为数字
             trace(typeof x); //显示"string",转换是临时性的
 
   Example2: x="10"     //x是一个串
             x=x-5;     //x被转换为数字
             trace(typeof x); //显示："number"转换是永久性的，因为它是
                              //赋值的一部分
　　
          

                     第四章 原始数据类型

1：使用整数的直接量的注意点
   a：整数不可以包括小数或者小数值
   b: 整数不能够超出ActionScript所规定的最大和最小合法数值范围。
   c: 十进制的整数不能够以0作为开始
   d:  以零开头的 表示八进制的数字：013；
       以0x开头的 表示十六进制的数字；0x13;

2: charAt（String.charAt 方法）的用法
   返回由参数 index 指定的位置处的字符。
   如果 index 不是从 0 到 string.length 减 1 之间的数字，
   则返回一个空字符串。
   Example:
           var testString = "0037";
           trace(testString.charAt(3));
   注意：这里面结果是7因为计算是从零开始的。

3：substring（String.substring 方法）
   public substring(start:Number, end:Number) : String

   返回一个字符串，该字符串由 start 和 end 参数指定的两点
   之间的字符组成。如果未指定 end 参数，则子字符串的结尾就
   是该字符串的结尾。如果 start 的值等于 end 的值，则该方法
   返回一个空字符串。如果 start 的值大于 end 的值，则在函数
   执行前两个参数将自动互换，且原始值不变。
   注：见帮助
   example:var testString = "0037";
           trace(testString.substring(2, testString.length));
   

4: 浮点直接量
   一个浮点的直接量可以包括下面四种成分中的部分或者全部。
   十进制整数：小数点：小数(以十为基数)：指数
   注意点：如果要表示一个很大的整数或者负数为浮点数，可以用e;
           12e2;   //1200
           143e-3  //0.143
   理解技巧：如果指数为正数，那么将小数点向右移动相应的位数。
             如果指数为负数，那么将小数点向左移动相应的位数。

5：浮点精度
   Flash使用双精度浮点数，它提供大约15位精度的有效数字，
   任何打头或者结尾的0，以及指数，都不属于这15个位数的范围.

6: math.round(x) 的用法
   将参数 x 的值向上或向下舍入为最接近的整数并返回该值。
   如果参数 x 与两个最接近的两个整数等距离（即该数字以 .5 结尾)，
   则该值向上舍入为下一个较高的整数。
   Example: var myNumber;
            var b
            myNumber =120.366;
            var b = Math.round(myNumber);
            trace(b);
     
7:pow（Math.pow 方法）
  public static pow(x:Number, y:Number) : Number
  计算并返回 x 的 y 次幂。

8:function中可以传递多个参数
  Example:
  function trim(theNumber,decPlaces,b,d)
     {
 trace(theNumber);
 trace(decPlaces);
 trace(b);
 trace(d);
     }
  trim(1.12645,2,4,"asdf");

9:数字类型的特殊值
  整数和浮点常量几乎占据了数字类型的全部合法值，但是仍然有一些特性的关键字
  用以表示这些数字概念：非数字，最小允许值，最大允许值，正无穷，以及无穷小
  每一个特性值都可以赋给变量和属性，或者和其他数字常量一样，用在直接
  表达式中，但是特殊值经常被解释程序作为一些表达式计算结果而返回。

10：关于非数字"NaN"
    它是为了表示那些虽然属于数据类型但是不是实数的数据。
    虽然它不是一个数但是它仍然是一个数据类型的合法值
    NaN是不能够比较相等的
    可以用内置函数isNaN()来检测一个变量包含的值是否为NaN;

11:最小值和最大允许值
   Number.MIN_VALUE  //允许的最小正值，最小值为-Number.MAX_VALUE
   Number.MAX_VALUE  //允许的最大值

12:Infinity和 -Infinity
   如果一个值大与Number.MAX_VALUE用Infinity
   如果一个值超过所允许的最小负值用 -Infinity

13:无理数
   Math.E    //e是自然对数的底数
   Math.LN10 //10是自然对数
   Math.LN2  //2的自然对数
   Math.LOG10E //10为底e的对数
   Math.LOG2E  //2为底e的对数
   Math.PI     //PI为圆周率
   Math.SQRT1_2 //1/2的平方根，注意：SQR要大写不然的话1_2不能够写成这样
　 Math.SQRT2   //2的平方根

14:内置数学函数
   Math.abs(x)   //x的绝对值
　 Math.min(x,y) //y和x中的最小者　　
　 Math.pow(x,y) //x升到y次幂
　 Math.round(x) //将x舍入近为最接近整数
   Math.random() //得到一个1到0之间的随机浮点数

15:注意有理数和无理数

16：单引号也可以像双引号一样使用，
    像 var a ="good" 等同于 var a='good'

17：转义字符
    注意如果语句本身里面有引号，那么写语句的时候 外面就可以用单引号
    如果在里面含有单引号，双引号的话 那么就可以用转义字符，\'  \"
    \b 退格字符
    \f 换页符
    \n 换行符
    \r 回车字符
    \t 跳格符
    \'单引号标记
    \"双引号标记
    \\反斜杠字符

18:空串
   空串和数字0，以及布尔值false被认为是相等的，因此为了确保检查的变量的确是一个空串，
   首先应该确定该变量属于串数据类型。
   if(typeof firstName == "string"&& firstName=="") {
         trace("you forgot to enter you name!");
     }

19:字符编码
   西方过去应用程序使用的ASCII的一些派生集，ASCII是一个标准的字符集，
   现代应用程序支持一个字符系列，总称ISO-8859 ActionScprit支持ISO-8859-1也就是Latin1
   作为它的主要字符映射
   注意：Latin1只支持大部分西欧语言  但Unicode可以映射到一百万个字符，是首选的国际标准
         但是在ActionScprit不支持 因为要支持Unicode会使Flash播放器变得很大。
         同时ActionScpit支持为日语设置的第二字符集，也就是SHift-JIS中的任何字符
  
         虽然Unicode本身不被支持 但是可以使用标准的Unicode的转义字符来表示Latin1或者
         Shift-JIS中的任何字符 还可以用Unicode类型的函数来处理字符串。（参考附录二)

         Unicode的不破坏原来代码的基础上是里添加到Flash中来的

20：在Unicode的转义字符序列
     参考附录二
      如：\u0040       //@标记
          \x40         //\x的简便形式
      在程序中实现为： trace("\u0040");
                   或者trace("\x40");

21：串的处理
    a:串的连接
      用加号  +
       如果想在一个名称中加一个空格  可以在中间独立一个空格 "Macromedia"+" "+"Flash"
      可以使用+=
      concat()函数
      它来改变它所处理的串，只是返回连接之后的串值，          
      concat()可以接收多个参数：就是说它可以将多个独立的串合并为一个
      Example:    firstName="karstem";
                  finalGreeting=firstName.concat(" ",firstName,"?");
   
    b:串的比较
      使用（==）和（！=）操作符号
      串的比较区分大小写的
     
    c:可以在字符顺序的基础上比较二个串 可以用比较操作符比较哪个字母在前面，
  
 22: 检查串
     a: charAt() 可以返回指定字符串中某个位置的指定字符
        Exampel:var my_str = "Chris";
                var firstChar_str = my_str.charAt(3);
                trace(firstChar_str);

     b:length 可以告诉我们一个串中拥有多少个字符
       注意它是属性不是串,字符索引是从零开始的
   
     c:indexOf()函数,用来搜索串中的字符，
        string.indexOf(character_sequence,start_index)
      character_sequence:要搜索的串 
      start_index：搜索的开始位置
      注意：如果搜到就返回字符索引的位置否则就返回-1;
            它还可以搜索整个字符序列，返回的是头一个字母的符索引位置

     d:lastIndexOf()函数
        indexOf()函数返回一个字符序列在串中第一次出现的位置
        lastindexOf()函数返回一个字符序列在串中最后一次出现的位置
        如果两个都是返回-1

 23:获取部分串
    a:substring() 从串中获取一个字符序列，这是基于开始和结束字符的索引
      string.substring()(start_index,end_index)
      string.substring(2,5) 表示从字符串中的第二个字符到第五个字符之间的字符串
      string.substr(2,5)则表示从字符串中第二个字符开始，依次往后的五个字符。

    b:substr()函数用开始索引和长度从串中截取一个字符序列   
      string.substr(start_index，length)
      start_index：用负数表示从后面数起
      length:表示字符长度，不可以为负数

   c: slice()函数:从串中截取一个字符系列
      string.slice(start_index,end_index);

   d:split()
     将一个串分散为多个子串，然后将这些子串,然后将这些串存在一个数组中返回,

   e:substring()
   因为substr(),slice()用的时间比substring多

 23:可以把窜检查和子窜抽取的结合
     Example:var msg="Welcome to my websiter!";
             var fistWord = msg.substring(0,msg.indexOf(" "));
             trace(fistWord);

 24:字符的大小写转换
    a: toUpperCase()函数
       将串所有的字符都转换为大写形式(也就是大写字母),并返回转换之后的版本,如果某一个给定的
       字符没有大写形式,那么返回的版本就没有变化.
       string.toUpperCase();
       Example:var msg="Listen TO me";
               msg.toUpperCase();
               trace(msg);
               trace(msg.toUpperCase());
       注意:toUpperCase()不影响调用它的窜,它只是返回原串的大写形式复本,
            所以 trace(msg);显示的是:Listen TO me
  
     b:toLowerCase()函数
       大写转换为小写,
  
     c:一个经典的例子
     第一侦代码:
      var i = 0;
      var msg = "my what fat cheeks you have";
       function caseAni() {
   var part1 = msg.slice(0, i);
   var part2 = msg.charAt(i);
   var part2 = part2.toUpperCase();
   var part3 = msg.slice(i+1, msg.length);
   msg = part1+part2+part3;
          trace(msg);
   msg = msg.toLowerCase();
   i++;
   if (i>(msg.length-1)) {
  //stop();
           }
          }
      第二侦代码:caseAni();
      第三侦代码:gotoAndPlay(2);
      
      从此例子中学到的:a:代码在多帧之间怎么用
                       b:在多侦之间函数的调用问题
                       c:把所有的代码打上断点符号,可以实现对整个程序的调试
                       d:此例子告诉了,结合字符窜的各种运用可以产生出许多的效果
        

   25:字符编码函数p:116
      ActionScript包括两个内置函数,用来处理串中的字符编码:fromCharCode()和charCodeAt();
    
    a: formCharCode()函数
      string.formCHarCode(code_point1,code_point2,...)
      注意:a:它是作为特殊String对象的一个方法
           b:和Unicode类型的转义序列不同,formChartCode()调用中的编码点表示为十进制的整数,
             而不是十六进制,如果不熟悉十六进制可以发现 它比Unicode类型转义序列更容易使用.
           c:可以调用它来创建任何字符或者字符序列
           exampe:var lastName=String.fromCharCode(109,111,111,99,107);
              trace(lastName);
       
    b: charCodeAt()函数
       确定串中任何字符的编码点
       string.charCodeAt(index); 
       string:表示任何直接量串值或者包含一个串的标识符
       index:我们要检查字符的位置,所指的字符和Unicode编码点相匹配
             它返回的是一个十进制的整数
       它通常用力处理我们不能够从键盘直接输入的字符
      
       学习编码的用途:
       如:检测一个字符是否为版权号
         msg = String.fromCharCode(169)+" 2000";
         if(msg.charCodeAt(0)==169) {
                   trace("the first character of msg is a copyright symbol");
         }
         
                          
   
   
    c:怎么样制作一个版权号
      copyNotice=String.fromCharCode(169)+"2001";
       trace(copyNotice);
 
   26:eval执行窜中的代码
     在javeScrpit中:eval()是一个顶层内置函数,它将任何串转换一个代码块,然后执行这个代码块,
     之所以把代码块写成窜放在里面,是因为eval()能够在你需要的时候动态的创建代码
     Example:有十个函数
             func1();
             func2();
             func3();    //依次类推
     如果用eval()实现
      for(i=1;i<=10;i++){
            eval("func"+i+"()");
            }

     在ActionScpit的eval()函数只支持javeScpit中的一个功能子集,它只在参数是标识符的时候起作用,因此
     ActionScpit的eval()函数只能获取和指定标识符对应的数据.
     Example:var num=1;
            var person1="geadfsad";
            trace(eval("person"+num)); //显示:"Eugene"

   27：用布尔值来创建预装载
        if(_frameLoaded>=_totalframes)
             {
                gotoAndPlay("intro");
             }
        else{
                gotoAndPlay(1);
            }
           
       _frameLoaded:装载数
       _totalframes:总帧数
       如果装载完成了 则播放 执行语句gotoAndPlay("intro");   
       否则播放第一帧      
  
   28: undefined
       最初定义一个变量的时候它会被默认为undefined
  
   29：null
       它可以赋给变量，数组元素或者对象属性，
       null只等于自身和undefined; 
   

 

                        第五章   操作符
   1:操作数的数目：一元操作数；二元操作数;三元操作数
   2:一次赋多个值：x=y=4; //将x和y都赋值为4；
   3:复合数据的等同性：
     a:两个数可以比较大小，如果字符或者数组相等的话，那么他们就相等，但是如果是两个  
       数组虽然有相同的数组元素，但是如果不是来源于同一类，那么它们也是不相等。参考：P:136
     b: 比较两个事例的例子，虽然它们来源于同一个灰，但是它们作为单独的事例而存在。相等 
          a = new b();
          c= new b();
          if(a==b)
          {
     trace("ok");
          }
          else
          {
     trace("no");
          }
     c:要复制数组的内容，而不复制数组的引用，可以用Array.sLice()方法，
        slice（Array.slice 方法）
        public slice([startIndex:Number], [endIndex:Number]) : Array
        返回由原始数组中某一范围的元素构成的新数组，而不修改原始数组。
        返回的数组包括 startIndex 元素以及从其开始到 endIndex 元素（但不包括该元素）的所有元素。
        如果您没有传递任何参数，则创建原始数组的一个副本。

     d：如果将不同数据类型进行比较的时候：出现的同等性数据类型的转换：参考:P:138
       
     f: Boolean 函数
        Boolean(expression:Object) : Boolean
        将 expression 参数转换为布尔值，并返回一个下面列表中说明的值：
        如果 expression 是布尔值，则返回值为 expression。
        如果 expression 是数字，则当该数字不为 0 时，返回值为 true；否则，返回值为 false。

     g:注意转换只是临时的
    
  4:getVersion 函数
    getVersion() : String
    返回一个包含 Flash Player 版本和平台信息的字符串。
    getVersion 函数只返回 Flash Player 5 或 Flash Player 更高版本的信息。

  5:比较操作符，注意串的比较，参考第四章
  
  6:比较操行符和数据类型的转换:参考P：142

  7：在逻辑操作符or中，当操作数有不是布尔的时候，系统会把它先转换为布尔P:146
  
  8: 在or中，如果如果第一个操作数为true那么系统不会理会第二个操作数

  9：getDate（Date.getDate 方法）
     public getDate() : Number
     按照本地时间返回指定的 Date 对象中表示月中某天的值
    （1 到 31 之间的整数）。本地时间由运行 Flash Player 的操作系统确定
 10：getMonth（Date.getMonth 方法）
     public getMonth() : Number
      按照本地时间返回指定的 Date 对象中的月份值（0 代表一月，1 代表二月，依此类推）。
      本地时间由运行 Flash Player 的操作系统确定

  11：逻辑 NOT(!)返回和它打操作数相反的布尔值，

 

                第六章 语句
 1：整体了解
     用来控制程序执行过程的语句
     loops(循环）
     conditionals(条件）
     ifFrameLoaded(如果侦已载入）
 
     变量声明的语句
     var
     set

     函数的声明，调用，值返回语句
     function
     function call
     call
     return
  
     对象处理语句
     with
     for...in
 2：在ActionScript中，每一个语句都应该以分号结束 

 3：对学ActionScrpit的体会，和所有的语言一样，ActionScript有自己的语法
    以及不同的词类，我们学习句型结构，名词，形容词，和关连词的相应内容，
    然后我们学习语句，它和动词一样，可以执行任务，语句让我们有足够的
    能力去实现类似句子的指令

 4: set有用法,set(varibale,expression);
    varibale:用作变量的名字，
    expression:赋给这个变量的新值
    注意：varibale要打引号
    var x=12;
    set("x",14);
    trace(x);  //x的输出为14 说明x和固定值被改变了
   

 5：function
    function funcName(param1,param2,param3,....paramn){
      statements
    }
    funcName:声明函数的名称
    param1：函数执行的时候所需要的参数
    注意：function 语句只创建一个供以后使用的函数，但不执行该函数
          要执行一个函数，要在函数调用语句中使用该函数的名称。
          要执行一个函数，要在函数调用语句中使用该函数的名称。

 6：对于自定义函数和系统自带函数的理解
    自定义函数是程序员自己通过function语句 自己定义的函数：其中函数名
    为funcName,至于这个自定义函数有什么功能：即执行什么，是不是返回什么， 
    要看程序员怎么样编程了
    对于系统给的函数：则不同 有些是只要调用这个函数，至于这个函数
    怎么样执行的我们不要管，我们就能够得到我们想要的结果
    example: today.getDate();
             circle.area();
             ball.play();

 7:对函数的理解：  
   函数就是一系列可以重复使用的语句，它在程序运行期间的任何的时候都
   可以得到执行，
 
 8: Flash4不支持真正的函数,这个时候call()语句进行调用
    而现在flash5及以后的版本支持真正的函数，所以没有必要再call语句了
 
 9：return
    在函数体内有选择的返回一个值
    一个return语句在函数内不是必须的，一个没有return语句的函数会在函数
    体的最后一个语句执行之后结束，并返回undefined

 10: with提供一个简化的方法来引用对象的属性,而无须重复的键入对象名称
     with (object){
      statements }
     注意：object指的是函数的名称
           在statements中，可以调用函数的方法和属性
           如果在函数外定义了一个和函数方法或者属性，那么以函数的
           函数内的以和函数方法或者属性为准，函数外的以变量名为准

      _root.form.suerProfile.userID="U346BX"
      _root.form.suerProfile.gotoAndPlay("questionnaire"); 
     
     如果上面用with
     whth(_root.form.suerProfile){
               userID="U346BX"
               gotoAndPlay("questionnaire");
         }
    当然还有其他的方法：
     var userForm=_root.form.suerProfile;
     userForm.useriD="U346BX";
     userForm.gotoAndPlay("questionnalire");

 11:ifFrameLoaded
    用在flash3或者更早的版本，现在不提倡
   一般用在if-else语句中使用_totalframes和_framesloaded来创建更通用的下载
 

 12：语句和动作
     因为每一个动作都用和它在语言的正式角色相匹配的词语来描述：语句，
     函数，或者是事件处理器 所以不用动作一词之说

 

 

 

                             第七章 条件语句
  1：if语句
     注意和其他if的用法和其他语言的基本相同 但是因为在ActionScript中存在数据类型转换的问题
     所以在if的条件中要注意数据类型的转换，数据是转换为ture 还是flase
     同时还可以利用这一点检测对象是否存在：
     exampel:检测一一个电影剪辑是否存在
         if(myClip){
            myClip._x=0;
          }

 

                             第八章：循环语句
1：复制电影剪辑
   duplicateMovieClip 函数
   duplicateMovieClip(target:String, newname:String, depth:Number) : Void
   duplicateMovieClip(target:MovieClip, newname:String, depth:Number) : Void

   当 SWF 文件正在播放时，创建一个影片剪辑的实例。无论播放头在原始影片剪辑中处于什么位置，
   在重复的影片剪辑中，播放头始终从第 1 帧开始。原始影片剪辑中的变量不会复制到重复的影片剪辑中。
   使用 removeMovieClip() 函数或方法可以删除用 duplicateMovieClip() 创建的影片剪辑实例。

   target:Object - 要复制的影片剪辑的目标路径。此参数可以是一个字符串（例如 "my_mc"），也可以是对影片剪辑实例的直接引用（例如    my_mc）。能够接受一种以上数据类型的参数以 Object 类型列出。

   newname:String - 所复制的影片剪辑的唯一标识符。

   depth:Number - 所复制的影片剪辑的唯一深度级别。深度级别是所复制的影片剪辑的堆叠顺序。这种堆叠顺序很像时间轴中图层的堆叠顺    序 ； 较低深度级别的影片剪辑隐藏在较高堆叠顺序的剪辑之下。必须为每个所复制的影片剪辑分配一个唯一的深度级别，以防止它替换已     占用深  度 上的 SWF 文件。

 

2：创建一个空影片剪辑
  createEmptyMovieClip（MovieClip.createEmptyMovieClip 方法）
  public createEmptyMovieClip(name:String, depth:Numbe r) : MovieClip
 

  创建一个空影片剪辑作为现有影片剪辑的子级。此方法的行为类似于 attachMovie() 方法，
  但是不必为新的影片剪辑提供外部链接标识符。新创建的空影片剪辑的注册点为左上角。
  如果缺少任意一个参数，则此方法将失败。

  您可以通过创建子类来扩展 MovieClip 类的方法和事件处理函数。
  a:example:
    this.createEmptyMovieClip("img_mc", this.getNextHighestDepth());
    trace(typeof(img_mc));

  b:注意前面要加this

3：getNextHighestDepth（MovieClip.getNextHighestDepth 方法）
   public getNextHighestDepth() : Number

  确定可传递给 MovieClip.attachMovie()、MovieClip.duplicateMovieClip()
  或 MovieClip.createEmptyMovieClip() 的深度值，以确保 Flash 将该影片剪辑
  呈现在当前影片剪辑中同一级和同一层上所有其它对象的前面。返回的值为 0 或
  更大的数字（即，不返回负数）。

  您可以通过创建子类来扩展 MovieClip 类的方法和事件处理函数。

   注意：如果使用第 2 版的组件，则不要使用此方法。如果您在舞台上或库中放置
  了第 2 版的版组件，getNextHighestDepth() 方法有时会返回深度 1048676，它
  超出了有效范围。如果使用第 2 版的组件，则应始终使用第 2 版的组件 DepthManager 类。
  Number - 一个整数，反映下一个可用的深度索引，采用该深度值的对象将呈现在影片剪辑中
  同一级和同一层上所有其它对象之上。

 

4:var container:MovieClip中，：加上MovieClip中表示的是加载类或接口

5:MovieClip对象
  Object
    |
    +-MovieClip

  public dynamic class MovieClip
  extends Object
  MovieClip 类的方法提供的功能与定位影片剪辑的动作所提供的功能相同。
  还有一些其它方法在"动作"面板中的"动作"工具箱中没有等效动作。

  请不要使用构造函数方法来创建影片剪辑。要创建新的影片剪辑实例，您可以从以下三种方法中选择：

  通过 attachMovie() 方法，可以基于库中存在的影片剪辑元件创建影片剪辑实例。
  通过 createEmptyMovieClip() 方法，可以基于其它影片剪辑创建新的空影片剪辑实例以作为子级。
  通过 duplicateMovieClip() 方法，可以基于其它影片剪辑创建影片剪辑实例。
  若要调用 MovieClip 类的方法，请使用以下语法按名称引用影片剪辑实例，其中 my_mc 是影片剪辑实例：

  my_mc.play();
  my_mc.gotoAndPlay(3);
  注意：MovieClip是对象而createEmptyMovieClip()是这个对象的方法

6：创建一个新的空文本字段
   createTextField（MovieClip.createTextField 方法）
   public createTextField(instanceName:String, depth:Number,
   x:Number, y:Number, width:Number, height:Number) : TextField

   参数
   instanceName:String - 一个字符串，标识新文本字段的实例名称。
   depth:Number - 一个正整数，指定新文本字段的深度。
   x:Number - 一个整数，指定新文本字段的 x 坐标。
   y:Number - 一个整数，指定新文本字段的 y 坐标。
   width:Number - 一个正整数，指定新文本字段的宽度。
   height:Number - 一个正整数，指定新文本字段的高度。

 
   文本字段的默认属性如下所示：
   type = "dynamic"
   border = false
   background = false
   password = false
   multiline = false
   html = false
   embedFonts = false
   selectable = true
   wordWrap = false
   mouseWheelEnabled = true
   contenseWhite = false
   restrict = null
   variable = null
   maxChars = null
   styleSheet = undefined
   tabInded = undefined

   用 createTextField() 创建的文本字段获得以下默认 TextFormat 对象设置：
  
   createTextField()的使用：参考帮助

   font = "Times New Roman" // "Times" on Mac OS
   size = 12
   color = 0x000000
   bold = false
   italic = false
   underline = false
   url = ""
   target = ""
   align = "left"
   leftMargin = 0
   rightMargin = 0
   indent = 0
   leading = 0
   blockIndent = 0
   bullet = false
   display = block
   tabStops = [] // (empty array)
  
   例子：
   面的示例创建一个宽 300，高 100 的文本字段，
   其 x 坐标为 100，y 坐标为 100，该文本字段没有边框，文本为红色并带下划线：

   this.createTextField("my_txt", 1, 100, 100, 300, 100);
   my_txt.multiline = true;
   my_txt.wordWrap = true;
   var my_fmt:TextFormat = new TextFormat();
   my_fmt.color = 0xFF0000;
   my_fmt.underline = true;
   my_txt.text = "This is my first test field object text.";
   my_txt.setTextFormat(my_fmt);

   注意：这个例子对于TextFormat的用法
  

7:Text
  指示文本字段中的当前文本
  text（TextField.text 属性）
  public text : String
  指示文本字段中的当前文本。行用回车符（"\r"，即 ASCII 13）分隔。
  此属性包含文本字段中普通的无格式文本，不包含 HTML 标签，即     使该文本字段为 HTML。
 
8：关于在电影剪辑里面用 html代码的问题
  下面的示例创建一个名为 my_txt 的 HTML 文本字段，并将 HTML 格式的文本字符串分配给该字段。
  当您跟踪 htmlText 属性时，"输出"面   板将显示 HTML 格式的字符串。当您跟踪 text 属性的值时，
  未经过格式化并带有 HTML 标记的字符串将显示在"输出"面板中。
  例子：
  this.createTextField("my_txt", this.getNextHighestDepth(), 10, 10, 400, 22);
  my_txt.html = true;
  my_txt.htmlText = "<B>Lorem ipsum dolor sit amet.</B>";

  trace("htmlText: "+my_txt.htmlText);
  trace("text: "+my_txt.text);
 
  注意：对于电影剪辑有很多属性，这里只是讲了运用了其中的htmlTexts属性，让我知道怎么
  往里面加html代码

9:关于for-in循环的用法
  for(var thisProp in object){
        substatements;
  }

 注意： thisProp为任意变量或者标识符
        object为对象

 Example1:
        var ball = new Object();
        ball.radius=12;
        ball.color="red";
        ball.style="beach";
        for(var prop in ball){
         trace("ball has the propetty"+prop);
         trace("ball"+prop+"is"+"\b"+ball[prop]);
        } 
     这个例子有值得学习的地方
    1：怎么样创建一个对象（ball)
    2: 怎么样给对象附值
    3: 通过for-in语句怎么样得到对象的属性和值的
    4：for-in不会列出没有默认值的输入文本域
    5：如果是对象是用户定义的，那么所有的属性都可以被列出，也包括任何继承的属性，但是
       ，内置对象的一些属性就会被for-in语句跳过。

Exampe2:
     var myArr=[123,234,345,456]
     for(var elem in myArr)
     {
 trace(elem);
 trace(myArr[elem]);
     }
     for-in怎么样引用数组的

10:getURL 函数
   getURL( url:String , [window:String, [method:String]]) : Void

   将来自特定 URL 的文档加载到窗口中，或将变量传递到位于所定义的 URL
   的另一个应用程序。若要测试此函数，请确保要加载的文件位于指定的位置。
   若要使用绝对 URL（例如， http://www.myserver.com ），则需要网络连接。
   window:String [可选] - 指定应将文档加载到其中的窗口或 HTML 帧。您可输入
   特定窗口的名称，或从下面的保留目标名称中选择：

   _self 指定当前窗口中的当前帧。
   _blank 指定一个新窗口。
   _parent 指定当前帧的父级。
   _top 指定当前窗口中的顶级帧。
    method:String [可选] - 用于发送变量的 GET 或 POST 方法。如果没有变量，
   则省略此参数。GET 方法将变量附加到 URL 的末尾，它用于发 送少量的变量。
   POST 方法在单独的 HTTP 标头中发送变量，它用于发送长字符串的变量。

11:onClipEvent 处理函数
  onClipEvent(movieEvent:Object) {
  // your statements here
  }

  触发为特定影片剪辑实例定义的动作。

  参数
  movieEvent:Object - movieEvent 是一个称为事件 的触发器。
  当事件发生时，执行该事件后面大括号 ({}) 中的语句。可以为 movieEvent 参数指定下面的任一值：

  load 影片剪辑一旦被实例化并出现在时间轴中，即启动此动作。
  unload 在从时间轴中删除影片剪辑之后，此动作即在第 1 帧中启动。
  在将任何动作附加到受影响的帧之前处理与 Unload 影片剪辑事件关联的动作。
  enterFrame 以影片剪辑的帧频连续触发该动作。在将任何帧动作附加到受影响的
  帧之前处理与 enterFrame 剪辑事件关联的动作。
  mouseMove 每次移动鼠标时启动此动作。使用 _xmouse 和 _ymouse 属性来确定鼠标的当前位置。
  mouseDown 当按下鼠标左键时启动此动作。
  mouseUp 当释放鼠标左键时启动此动作。
  keyDown 当按下某个键时启动此动作。使用 Key.getCode() 检索有关最后按下的键的信息。
  keyUp 当释放某个键时启动此动作。使用 Key.getCode() 方法检索有关最后按下的键的信息。
  data 在 loadVariables() 或 loadMovie() 动作中接收到数据时启动该动作。
  当与 loadVariables() 动作一起指定时，data 事件只在加载最后一个变量时发生一次。
  当与 loadMovie() 动作一起指定时，则在检索数据的每一部分时，data 事件都重复发生。

12:removeMovieClip 函数
 removeMovieClip(target:Object)
 删除指定的影片剪辑。
 参数
 target:Object - 用 duplicateMovieClip() 创建的影片剪辑实例的目标路径，
 或者是用 MovieClip.attachMovie()、MovieClip.duplicateMovieClip() 或
 MovieClip.createEmptyMovieClip() 创建的影片剪辑的实例名称
 实例：
 this.createEmptyMovieClip("myClip_mc", this.getNextHighestDepth());
 myClip_mc.loadMovie(" http://www.helpexamples.com/flash/images/image1.jpg ");
 duplicateMovieClip(this.myClip_mc, "newClip_mc", this.getNextHighestDepth());
 newClip_mc.loadMovie(" http://www.helpexamples.com/flash/images/image1.jpg ");
 newClip_mc._x = 200;
 this.button_mc.onRelease = function() {
 removeMovieClip(this._parent.newClip_mc);
 };
                                                     

                                                   第九章  函数

1:function  funcName(){
       statements }
  function: 标志着一个新函数声明的开始
  funcName():可以传递参数
  调用函数用funcName();

2：return
  a: 函数在程序执行期间遇到return语句的时候，它就跳过函数中剩下的所有其他语句
   但是注意它不是stop();并不是终止所以所有的应用程序

  b:return的结束一个函数的时候，它可以将某一个值发送回到调用函数的脚本
  c:如果一个函数如funciton a(b) 用了return 那么怎么样接受到它返回来的参数呢
     是用a(b); 例如把这个结果输出就是trace(a(b));

 
3:通常函数的表达式可以做为复杂表达式的一部分，甚至可以做为其他函数调用的变元；

 

4：onEnterFrame（MovieClip.onEnterFrame 处理函数）
   以 SWF 文件的帧频重复调用。分配给 onEnterFrame 事件处理函数的函数将在附加到
   受影响的帧上的所有 ActionScript 代码之前处理
   Example
   my_mc.onEnterFrame = function () {
    trace ("onEnterFrame called");
   }

 

5:函数的生命周期和可用性
  a:定义在影片剪辑上的的函数，当剪辑从场景上被删除的时候，就没有了
    但是如果放在主影片时间线上是确保函数永久的一个最好方法
    注意帧脚本的函数将在首次进入包含该脚本的帧时，得到初始化，变成可以访问的函数，因此可以在
    函数被声明之前调用该函数，只要在同一个脚本里。
  b:可用性，函数不会永远存在，也不会在整个影片中都可以直接访问到，如果要间接的访问就要加上路径.

6：函数的作用域
   当一个变量被加到影片剪辑的时候，语句的作用域，也就是能够影响到
   它所在的影片剪辑，
   函数体内的变量在其内部单独范围内进行操作，在函数调用时，被创建
   在结束时被破坏
   这样做减少了存储器的使用

7：在函数内,当定义一个局域变量的时候,不要担心它会和同名的时间线变量相冲突

8: loadSound
   var song=new Sound();//创建加载声音的对象
   loadSound（Sound.loadSound 方法）
   public loadSound( url:String , isStreaming:Boolean) : Void
   将 MP3 文件加载到 Sound 对象中。可以使用 isStreaming 参数指示该声音是事件声音还是声音流。
   事件声音在完全加载后才能播放。它们由 ActionScript Sound 类进行管理，并且响应此类的所有方法和属性。
   声音流在下载的同时播放。当接收的数据足以启动解压缩程序时，播放即开始

   url:String - MP3 声音文件在服务器上的位置。
   isStreaming:Boolean - 一个布尔值，指示声音是声音流 (true) 还是事件声音 (false)。
   
   exzample:  var my_sound:Sound = new Sound();
             my_sound.loadSound("song1.mp3", false);

9:start（Sound.start 方法）
  public start([secondOffset:Number], [loops:Number]) : Void
  从开头开始播放（如果未指定参数）最后附加的声音，或者从由 secondOffset
  参数指定的声音点处开始
  secondOffset:Number [可选] - 一个参数，通过它可以从特定点开始播放声音。
  例如，如果您有一个 30 秒的声音，
  而您希望该声音从中间   开始播放，可将 secondOffset 参数指定为 15。并非声音延迟 15 秒，
  而是从 15 秒标  记处开始播放。
  loops:Number [可选] - 一个参数，通过它可以指定声音应该连续播放的次数。
  如果声音是声音流，则此参数不可
  

 
10:setVolume（Sound.setVolume 方法）
  设置 Sound 对象的音量。
  value:Number - 一个从 0 到 100 之间的数字，表示音量级别。
  100 为最大音量，而 0 为没有音量。默认设置为   100。

11:attachSound（Sound.attachSound 方法）
  将在 id 参数中指定的声音附加到指定的 Sound 对象。该声音必须位于当前 SWF 文件的库中，
  并且必须已经在"链接属性"对话框中指定为导出。必须调用 Sound.start() 才能开始播放此声音。
  Example:
  var my_sound:Sound = new Sound();
  my_sound.attachSound("logoff_id.mp3");
  my_sound.start();

12:关于_Parent的用法，这一直是一个我比较头疼的问题不过今天终于解决了
   因为是否能够用好_Parent关系参数的传递函数的调用，对象的引用问题是否能够解决。
  
   _parent 属性
   _parent.property
   _parent._parent.property

   指定或返回一个引用，该引用指向包含当前影片剪辑或对象的影片剪辑或对象。
   当前对象是包含引用 _parent 的    ActionScript 代码的对象。
   使用 _parent 来指定一个相对路径，该路径指向当前影片剪辑或对象之上的影片剪辑或对象。

  a:
    有如下影片剪辑： a,b,c,d
    其中他们的关系： a包含了b,b包含了c,c包含了d
    _parent是可以从子影片访问父电影剪辑或者是父电影剪辑的上一级或者是更上的n级，
    而注意引用一个是父级有用一个_parent,引用n个就用n个_parent,如果d子集要访问
    最大的父级a的变量c 则用trace(this._parent._parent._parent.c);语句访问
    注意1：这里面的this 可以用也可以不用
        2：在d中不仅可以访问a中的变量c,还可以访问a中的函数，这是我实验过的，
           但是注意访问函数如果要传递参数到a中，那么传递过去的参数的值是在
           d中定义而不是在a中定义
   
  b:上面a,b,c,d都是存在一定的包含关系，如果把他们的关系理解为连接链条，那么有没有
    替代这些链条的其他的方法，就是不一定要一个电影剪辑一定要放在另一个电影剪辑里面
    呢，还有一种情况是如果中间有的剪辑是放在库里面呢
    有答案是肯定的，就是用到函数attachMovie，它的作用是从库中取出一个电影剪辑，
    放到取它的对象中，
    例：a放在主场景中，b剪辑放在a中，d放在c中，c放在库中，我现在要在库中取出c
    并把他放在b,于是我在b中用到attachMovie.达到了取出c的目的，但是要 问的是
    在b场景中我们没有看到c剪辑，因为我们是通过代码取出来的，然后我发现
    通过这种关系取出来的，仍然可以想a条说的那样，在d，c中可以访问a,b的变量与函数
    也可以说attachMovie可以任意地方起桥梁作用，其效果和包含关系一样的。
  
  c:注意上面所以说的代码不能够放在电影剪辑上，而要放在电影剪辑所在的时间轴上.

  d:可以利用路径提示工具这是很有用的，它能够帮你准确的定位路径，但是使用它要
　　注意方法正确不然就会出现错误，即在右边的选择框中要选择正确，所要插入代码
　　的地方所在的帧，然后在再点击路径工具，在找到你从那个对象里引用路径。

13:_root绝对路径的使用：这也是我不知道的。
　　　
  _root 属性
　_root.movieClip
　_root.action
　_root.property
　指定或返回一个对根影片剪辑时间轴的引用。如果影片剪辑有多个级别，
　则根影片剪辑时间轴位于包含当前正在执行脚本的级别上。

　注意：如果包含 _root 的影片剪辑被加载到另一个影片剪辑中，
　则 _root 指的是加载影片剪辑的时间轴，而不是包含 _root 的时间轴。
　如果要确保 _root 指的是被加载的影片剪辑的时间轴（即使该影片被加载到另一个影片剪辑中），
　请使用 MovieClip._lockroot。

　参数
　movieClip:String - 影片剪辑的实例名称。
　action:String - 一个动作或方法。
　property:String - MovieClip 对象的属性

　注意：
     a: 对于_root它是相对于跟目录的：
　　    如上面的a,b,c,d　
　　    要在a,b,c,d中访问场景中的东西要用语句：_root
　　    如果在c,b,d中访问a中的东西用用语句：_root.a
  　    如果在d中要访问c上的东西_root.a.b.c
   
     b: 对于绝对于路径的使用中，如果存在上上面_parent中所说的用attachMovie从库中取出的问题，
        一样的，把attachMovie当作一个桥梁和包含关系一样的，如：用attachMovie从库中取出b
        到a，和a包含b的效果一样的，所以使用绝对路径也是a包含b的用法该怎么用就怎么用。

     c:用_root的时候，必须给电影剪辑命上实例名
　　　
14：对于_root于_parent如果面对不是是上面11，12说的这样情况，而是多个不同的分支（电影剪辑分支
    一个分支可以包含多个电影剪辑）放在主场景中，那么从一个分支中要访问另一个分支的东西
    访问：
  
   a:对于_root
    1:主场景<--a<--b<--c--d
    2:主场景<--i<--j<--f--h
  
    注意_root是以根目录为标准的，所以它的路径是相对于根目录的，
　　如果要访问1支的a用_root.a; b用_root.a.b c用_root.a.b.c ;...
    而对于2场景中的i,j,f,h去访问1支中所用的代码都是一样的。
　　如果在一个分支中存在attachMovie也是一样的使用　
　　
   b:对与_parent
     1:主场景<--a<--b<--c--d
     2:主场景<--i<--j<--f--h　
     先用相对路径返回到主时间抽，再用绝对路径去访问要访问的剪辑所在的分支。
     如果：i 要访问a : trace(this._parent.a.参数)
   　      i 要访问b : trace(this._parent.a.b.参数)
        
           f要访问d:trace(this._parent._parent._parent.a.b.c.d.参数);
　　　　

15: _root是以主场景作为参照物的，_parent是以所在的电影剪辑作为参照物的。　　　
   
16：flash播发器在它的文挡堆栈里可以容纳多个文档，载入播放器文挡堆栈的
    任何影片主时间线都可以用_leveln表示。

17：setTransform（Color.setTransform 方法）  
    为 Color 对象设置颜色转换信息。从 new Object 构造函数创建的
    colorTransformObject 参数是通用对象。它   具有指定颜色的红、绿、
    蓝和 alpha（透明度）成分百分比和偏移量值的参数，以 0xRRGGBBAA 的格式输入。

    颜色转换对象的参数与"高级效果"对话框中的设置相对应，定义如下：

   ra 是红色成分的百分比（-100 到 100）。
   rb 是红色成分的偏移量（-255 到 255）。
   ga 是绿色成分的百分比（-100 到 100）。
   gb 是绿色成分的偏移量（-255 到 255）。
   ba 是蓝色成分的百分比（-100 到 100）。
   bb 是蓝色成分的偏移量（-255 到 255）。
   aa 是 Alpha 的百分比（-100 到 100）。

 

   ab 是 Alpha 的偏移量（-255 到 255）。

   例：c=new Color(this.weird);
       mctransform = new Object();
       mctransform.ra = 100;
       mctransform.rb = random(128);
       mctransform.ga = 100;
       mctransform.gb = random(128);
       mctransform.ba = 100;
       mctransform.bb = random(128);
       mctransform.aa = 100;
       mctransform.ab = 0;
       c.setTransform(mctransform);

18:作用域链
   函数它自己的局部作用域中进行操作，函数的局部作用域，是解释程序查找变量的一个地方，但是如果局部
   作用域中没有发现变量的引用，搜索就会延伸到包含该函数的影片剪辑或者对象。
   解释程序用来引用变量和对象属性的对象层次，对属于时间线的函数来说，作用域只有两个层次；局部作用域
   和包含该函数的影片剪辑的作用域，但是当我们将函数添加到自定义的对象和类中时，作用域链就会包含许多 
   层次。
   如果从函数体内访问的变量和属性的作用域不同于语句，的作用域，就必须使用点语法来构成精确的引用。
  
   注:本人认为，可以把函数的作用域理解成为一个个的链条，域与域又可以理解成为域链，访问域链要用
      点引号。
 
19：函数内部创建的变量在函数结束后几死亡了，在函数外面创建的变量在函数内部可以被永久性修改，
    函数结束后仍然还存在。即使函数是某个对象的方法，创建时间变量的规则也是适用的。

20：当参数传递的多少问题
    a:当调用函数的时候传递了少于规定函数目的参数的时候，每一个遗漏的参数值都会被设置为undefined.
    b:当函数调用的时候传递了多于规定数目的参数时，多余的参数值可以用arguments对象来访问。
    arguments对象：它可以访问三个信息：
    1:传递给函数参数数量
    2:包含所以参数值的一个数组
    3:所执行函数的名称。

   arguments 对象用于存储和访问函数的参数。尽管它在函数体内部，也可以用本地 arguments 变量对其进行访问     这些参数作为数组元素存储，第一个参数作为 arguments[0] 被访问，第二个参数作为 arguments[1] 被访问，依    此类推。arguments.length 属性表示传递给函数的参数数目。请注意，传递给函数的参数与该函数声明的参数的     数目可能不同。

 

  属性
    callee:Object
    对当前正在执行的函数的引用
    caller:Object
    对调用当前正在执行的函数的函数的引用；如果未从其它函数调用它，则为 null。
    length:Number
    传递给函数的参数数
 

  
    从arguments数组中获取参数值，用arguments[n].
    用arguments.length得到传递过来参数的多少。
    
     var x = 10;
     function viewVars(x) {
 trace(x);
 if (x>1) {
  arguments.callee(x-1);
          }
         }
        viewVars(x);

 21：原始数据可以说是值的传递，但是我们将复合数据作为参数传递给函数的时候，函数接收的是，
     指向与原变量相同的引用，而不是数据的拷贝，复合数据可以说是引用的传递。

 22：我们可以在变量和参数的传递过程中做手脚:
     var boys=["andrew","graham","derek"];
     var girls=["alisa","Gillianm","Daniella"];
     function setValue(myArray){
     myArray=girls;
     myArray[0]="Mary";
         }
     setValue(boys)
     trace("boys:"+boys);
     trace("Girls:"+girls);
 
     虽然我们可以从函数内部重写单个数组元素值，但给参数赋一个新值将会打断它和原变量的联系，以后如果
     改变参数变量，将不会影响原来的变量，在本例中，虽然boys数组被作为参数被传递，但是myArray参数变量
     很快被设置了girls,以后再改变myArray将影响girls数组，而不是boys数组。
     
23：递归函数
    是可以作用自身的函数（就是在它的函数体内使用自己的函数名）
    使用递归的一个典型实例就是：计算数字的数学阶乘
    例：var a = 3;
        function factorial(x) {
 if (x<0) {
  return undefined;
 } else if (x<=1) {
  return 1;
 } else {
  return x*factorial(x-1);
 }
         }
        trace(factorial(a));

    这里面临到一个问题：递归和不递归哪种方法更好，这要看所解决的问题是什么，
    一些问题用递归可以很容易解决
    但是递归会比非递归解决方式慢，递归的方法在不知道一个数据结构的嵌套有多深的时候比较适用。

 

24：在我们建立自己的函数的时候，别忘了我们还有系统给我们提供的一系列函数即内置函数，和任何自定义
    函数一样，每一个内置函数都有一个名称，有可选项参数，以及一个返回值（虽然有的时候为undefined)
    我们可以熟悉一下有效的函数类型但是没有必要去记住它特定的语法
  

25：内部函数的有效性
    一些内置函数在很多情况下都有效，而另外一些只能用对象来调用，如果一个函数为全局函数，它可以在
    任何地方使用，如果函数是对象中的方法，那么它的使用必须和对应的对象相联系。

26：上面提到了 一个很有意思的东西，就是函数可以调用自己，这里还有一个很有意思的事情
    函数可以当作参数被传递吗 答案是肯定的因为函数是一种类型的对象对象，所以我们可以将
    它当作任何其他数据来对待
    如：functionl(funciton2)
    注意：如果没有function2后面的括号，那么解释程序不会执行function2()而是将它的“对象引用” 
    作为参数传递给funcion1()也就是说，function1()接收到了function2本身，而不是function2的返回
    值，因为对象的引用是通过引用进行传递的，我们可以将一个函数的标识符传递给别一个函数。
    例：function factorial(dd) {
 dd("ok");}
        factorial(trace);

    还有一个很有意思的事情就是我们还可以给函数添加属性（我觉得这是因为我们可以把他当作对象）
    实例：function myFunction(){
   trace(myFunction.x);}
          myFunction.x=15;
          myFunction();
27：对于帧标签我还不太熟悉：出现找不到的情况其实很简单
    向帧添加标签
    现在，您将向特定的帧添加标签。通过为帧添加标签，就可以在 ActionScript 中引用该帧。
    这样，您将能够编写可以对这些帧执行动作的 ActionScript 代码。之后，您将添加使播放头
    跳到这些有标签的帧的 ActionScript 代码。
   例：
    步骤：
    在时间轴中，选择图层 2 的第 2 帧。
    在"属性"检查器中，在"帧标签"文本框中输入 slide0。
    在时间轴图层 2 的第 2 帧中，出现一个小的旗帜图标和帧标签

28:怎么做输出文本
   先用文本工具，拖出一个没有文字的空文本框，然后在属性文本框中将它改为动态文本，
   然后在变量填写框中写上要输出文本的变量

 

 

 

 

  对函数的一个小结：
      我们可以创建一个自己想要的一个函数，并按照我们自己的想法命名，同时我们可以向他传递参数
      当调用函数的时候传递了少于规定函数目的参数的时候，每一个遗漏的参数值都会被设置为undefined.
      当函数调用的时候传递了多于规定数目的参数时，多余的参数值可以用arguments对象来访问，
      同时我们可以利用  arguments对象它三个属性 可以让我们知道1:传递给函数参数数量
      2:包含所以参数值的一个数组    3:所执行函数的名称。 同时我们还知道函数有不同的使用范围
      这就叫他的作用域，从一个作用域去访问另一个作用域这就构成了函数的作用域链，如果从函数体内访问的变        量和属性的作用域不同于语句，的作用域，就必须使用点语法来构成精确的引用。同时我们在使用作用域的
      时候也引出并解决了二个问题：对_root 和_parent的使用
      同时针对参数的传递我们还可以从中做手脚就是给参数赋值，这样但给参数赋一个新值将会打断它和原变量的        联系，以后如果改变参数变量，将不会影响原来的变量
  
      从另一个角度看，我们可以终止函数的执行，还可以用return从函数内部返回数值，同时还有可用性，和生命
      的，可以性，函数不会永远存在，也不会在整个影片中都可以直接访问到，如果要间接的访问就要加上路径
      同时函数还有一定的生命周期，定义在影片剪辑上的的函数，当剪辑从场景上被删除的时候，就没有了
      但是如果放在主影片时间线上是确保函数永久的一个最好方法