Flex3.2 中数组的学习 笔记

简介: package com.yoyo{  /**  * 数组Array中的方法、属性、学习     * 注意:  每一个方法要分开测试,以免有影响   控制台打印,需要在Debug模式下运行才可以使用  */ public c...

package com.yoyo
{
 
 /**
  * 数组Array中的方法、属性、学习  
  * 注意:  每一个方法要分开测试,以免有影响   控制台打印,需要在Debug模式下运行才可以使用
  */
 public class _Array_class
 {
  private var initArray:Array;
  public function _Array_class()
  {
   initArray=new Array("ABC",123,"EFG","MNXO");
  }
  
  
  /**
   * Array(numElements:int = 0) 允许创建指定元素数量的数组。
   */
  public function array_Array():void{
   var tempArray:Array=new Array();
   trace("默认数组的长度:"+tempArray.length+"默认数组的值"+tempArray[0]);
   
   
   var tempArray2:Array=new Array(5);
   trace("默认数组的长度:"+tempArray2.length+"默认数组的值"+tempArray2[0]);
   for each(var e:Object in tempArray2){    //只遍历数组中存在的值 ,像undefined的元素责不遍历
    trace("数组中的每一个元素为:"+e);
   }
   tempArray2[2]="第三个元素值 ";
   for each(var e1:Object in tempArray2){
    trace("数组中的每一个元素为:"+e1);
   }
  }
  
  /**
   * Array(... values)  允许创建包含指定元素的数组。
   */
  public function array_Array1():void{
   var tempArray:Array=new Array("ABC",123,null,"",undefined,"EFG");  //此处为数组元数指定为undefined确遍历了
   trace("数组的长度为:"+tempArray.length);
   for each(var e:Object in tempArray){
    trace("数组中的每一个元素为:"+e);
   }
  }
  
  /*
   * shift():*  删除数组中第一个元素,并返回该元素。
   */
  public function array_shift():void{
   trace("删除前数组中的元素:"+"(长度:"+initArray.length+")");
   for each(var e:Object in initArray){
    trace(e.toString());
   }
   trace("删除的元素元:"+initArray.shift());
   trace("删除后数组中的元素:"+"(长度:"+initArray.length+")");
   for each(var e1:Object in initArray){
    trace(e1.toString());
   }
  }
 
  /*
   * pop():*  删除数组中最后一个元素,并返回该元素的值。
   */
  public function array_pop():void{
   trace("删除前数组中的元素:"+"(长度:"+initArray.length+")");
   for each(var e:Object in initArray){
    trace(e.toString());
   }
   trace("删除的元素元:"+initArray.pop());
   trace("删除后数组中的元素:"+"(长度:"+initArray.length+")");
   for each(var e1:Object in initArray){
    trace(e1.toString());
   }
  }
  
  
  /**
   * unshift(... args):uint  将一个或多个元素添加到数组的开头,并返回该数组的新长度。
   */
  public function array_unshift():void{
   
   trace("数组的初始数据:长度:("+initArray.length+")");
   for each(var e:Object in initArray){
    trace(e.toString());
   }
   trace("数组新长度为:"+initArray.unshift("增加元素1","增加元素2","增加元素3","增加元素4"));
   for each(var e1:Object in initArray){
    trace(e1.toString());
   }
  }
  /*
   *  push(... args):uint 将一个或多个元素添加到数组的结尾,并返回该数组的新长度。
   */
  public function array_push():void{
   trace("添加前数组中的元素:"+"(长度:"+initArray.length+")");
   for each(var e:Object in initArray){
    trace(e.toString());
   }
   trace("新数组的长度:"+initArray.push("再加一个"));
   for each(var e1:Object in initArray){
    trace(e1.toString());
   }
  }
  
  /**
   *  slice(startIndex:int = 0, endIndex:int = 16777215):Array  返回由原始数组中某一范围的元素构成的新数组,而不修改原始数组。
   *
   * 返回由原始数组中某一范围的元素构成的新数组,而不修改原始数组。返回的数组包括 startIndex 元素以及从其开始到 endIndex 元素(但不包括该元素)的所有元素。
         * 如果您没有传递任何参数,则创建原始数组的一个副本。
                             
                            参数 :  startIndex:int (default = 0) — 一个数字,指定片段起始点的索引。如果 startIndex 是负数,则起始点从数组的结尾开始,其中 -1 指的是最后一个元素。 
                 endIndex:int (default = 16777215) — 一个数字,指定片段终点的索引。如果省略此参数,则片段包括数组中从开头到结尾的所有元素。如果 endIndex 是负数,则终点从数组的结尾指定,其中 -1 指的是最后一个元素。 
                            返回        Array —    一个数组,由原始数组中某一范围的元素组成。 

   */
     public function array_slice():void{
      var letters:Array = new Array("a", "b", "c", "d", "e", "f");
      var someLetters:Array = letters.slice(1,3);
    trace(letters);     // a,b,c,d,e,f
   trace(someLetters); // b,c
     }
    
     /**
      * 下面的代码创建一个 Array 对象 letters,其中包含元素 [a,b,c,d,e,f]。
      * 然后创建数组 someLetters,方法是调用 slice() 方法(对元素 2 (c)),从而得到一个数组,其中包含元素 [c,d,e,f]。
      */
     public function array_slice1():void{
      var letters:Array = new Array("a", "b", "c", "d", "e", "f");
      var someLetters:Array = letters.slice(2);
   trace(letters);     // a,b,c,d,e,f
   trace(someLetters); // c,d,e,f

     }
    
     /**
      * 下面的代码创建一个 Array 对象 letters,其中包含元素 [a,b,c,d,e,f]。
      * 然后创建数组 someLetters,方法是调用 slice() 方法(对倒数第二个元素 (e)),从而得到一个数组,其中包含元素 e 和 f。
      */
     public function array_slice2():void{
      var letters:Array = new Array("a", "b", "c", "d", "e", "f");
      var someLetters:Array = letters.slice(-2);
   trace(letters);     // a,b,c,d,e,f
   trace(someLetters); // e,f

     }
    
    
    
      public function array_splice():void{
       
       //原始值 :"ABC",123,"EFG","MNXO"
        var spliced:Array = initArray.splice(2, 2);
       
//       trace("初始数组的数据:长度("+initArray.length+")");
//   for each(var e:Object in initArray){
//    trace(e);
//   }

 
   
   trace(initArray); // "ABC",123
//   trace("操作后数组的数据:长度("+spliced.length+")");
//   for each(var e1:Object in spliced){
//    trace(e1);
//   }
   trace(spliced);    // "EFG","MNXO"
   
   initArray.splice(1, 0, spliced);
   
//   trace("初始数组的数据:长度("+initArray.length+")");
//   for each(var e2:Object in initArray){
//    trace(e2);
//   }
   trace(initArray); // "ABC","EFG","MNXO",123

   trace("初始数组的数据:长度("+initArray.length+")");   //注意,新添加进来的数据只是作为原数组中的一个元素
   for each(var e2:Object in initArray){
    trace(e2);
   }
//   ABC
//   EFG,MNXO
//   123

      }
    
    
     /**
      *  将参数中指定的元素与数组中的元素连接,并创建新的数组。如果这些参数指定了一个数组,将连接该数组中的元素。
      *  ... args —  要连接到新数组中的任意数据类型的值(如数字、元素或字符串)。如果未传递任何值,则新数组将是原始数组的副本。
      *  Array —     一个数组,其中包含此数组中的元素,后跟参数中的元素。
      *
      *  •包含数字 1、2 和 3 的 numbers 数组。
   * •包含字母 a、b 和 c 的 letters 数组。
   * •调用 concat() 方法生成数组 [1,2,3,a,b,c] 的 numbersAndLetters 数组。
   * •调用 concat() 方法生成数组 [a,b,c,1,2,3] 的 lettersAndNumbers 数组。
      */
     public function array_concat():void{
      var numbers:Array = new Array(1, 2, 3);
   var letters:Array = new Array("a", "b", "c");
   var numbersAndLetters:Array = numbers.concat(letters);
   var lettersAndNumbers:Array = letters.concat(numbers);
   
   trace(numbers);       // 1,2,3
   trace(letters);       // a,b,c
   trace(numbersAndLetters); // 1,2,3,a,b,c
   trace(lettersAndNumbers); // a,b,c,1,2,3
     }
    
     /**
      * 对数组中的每一项执行测试函数,直到获得对指定的函数返回 false 的项。
      * 使用此方法可确定数组中的所有项是否满足某一条件,如具有的值小于某一特定数值
      */
     public function array_every():void{
      var numberArray:Array=new Array(1,2,3,4);
      trace(numberArray.every(isNumber));
      var objArray:Array=new Array(1,"b","c");
      trace(objArray.every(isNumber));
     }
    
     private function isNumber(element:*,i:int,arr:Array):Boolean{
      return (element is Number);
     }
    
    
     /**
      * 对数组中的每一项执行函数。
      */
     public function array_foreach():void{
      var employees:Array = new Array();
            employees.push({name:"Employee 1", manager:false});
            employees.push({name:"Employee 2", manager:true});
            employees.push({name:null, manager:null});
            employees.push({name:undefined, manager:undefined});
            employees.push({name:"", manager:""});
            employees.push({name:"Employee 6", manager:false});
            trace(employees);
   employees.forEach(traceArrayElement);
     }
    
     private function traceArrayElement(element:*,index:int,arr:Array):void{
      trace(element.name+"("+element.manager+")");
     }
    
     /**
      * 对数组中的每一项执行函数并构造一个新数组,其中包含与原始数组中的每一项的函数结果相对应的项。
      */
     public function array_map():void{
        var arr:Array = new Array("aa","bb","cc","dd","ee","ff");
        var newArray:Array=arr.map(toUpper);
     trace(arr);  //aa,bb,cc,dd,ee,ff
     trace(newArray); //AA,BB,CC,DD,EE,FF
     }
    
     private function toUpper(element:*,i:int,arr:Array):String{
      return String(element).toUpperCase();
     }
    
     /**
      * 使用全等运算符 (===) 搜索数组中的项,并返回项的索引位置。
      * searchElement:* — 要在数组中查找的项。
      * fromIndex:int (default = 0) — 数组中的位置,从该位置开始搜索项。
      */
     public function array_indexOf():void{
      trace(initArray.indexOf(123,1));
      trace(initArray.indexOf("123"));
     }
    
    
     public function array_lastIndexof():void{
      var tempArray:Array=new Array("A","B","C","A","C","A");
      trace(tempArray.indexOf("A")); //0
      trace(tempArray.lastIndexOf("A")); //5
     }
    
    
     /**
      * 将数组中的元素转换为字符串、在元素间插入指定的分隔符、连接这些元素然后返回结果字符串。
      * 嵌套数组总是以逗号 (,) 分隔,而不使用传递给 join() 方法的分隔符分隔。
      * 参数      sep:* (default = NaN) — 在返回字符串中分隔数组元素的字符或字符串。如果省略此参数,则使用逗号作为默认分隔符。
      * 返回      String — 一个字符串,由转换为字符串并由指定参数分隔的数组元素组成。 
      */
     public function array_join():void{
      var myArr:Array = new Array("one", "two", "three");
   var myStr:String = myArr.join(" and ");
   trace(myArr); // one,two,three
   trace(myStr); // one and two and three
     }
    
    
     /**
      * 字符串的分割成数组,将数组连接成字符串(目的:将字符串转换成指字的字符串)
      */
     public function array_split():void{
      var str:String="abcd,efg,hijk,,mno";
      var arr:Array=str.split(",");//字符串分割成数组
      trace(arr.length); //5
      trace(arr); //abcd,efg,hijk,,mno
      var str2:String=arr.join("");
      trace(str2);  //abcdefghijkmno
     }
    
     public function array_split1():void{
       var strPhone:String="(8610)010-58022266-145";
       var numberPhone:String=strPhone;
          var specialChars:Array=new Array("(",")","-"," ");
          for(var i:uint=0;i<specialChars.length;i++){
           numberPhone=numberPhone.split(specialChars[i]).join("");
          }
          trace(strPhone);  //(8610)010-58022266-145
          trace(numberPhone); //861001058022266145
     }
    
     /**
      * 在当前位置倒转数组。
      */
     public function array_reverse():void{
      trace(initArray); //ABC,123,EFG,MNXO
      var newArray:Array=initArray.reverse();
      trace(newArray); //MNXO,EFG,123,ABC
     }
    
     /**
      * 对数组中的每一项执行测试函数,直到获得返回 true 的项。使用此方法确定数组中的所有项是否满足条件,如具有小于某一特定数值的值。
      */
     public function array_some():void{
      var isExist:Boolean=initArray.some(findValue);
      if(isExist){
       trace("数组中包含该值123:"+initArray);
      }else{
       trace("数组中不包含该值123:"+initArray);
      }
     }
    
     private function findValue(ele:*,i:int,arr:Array):Boolean{
      return (arr[i]=="123");
     }
    
    
     /**
      * 下面的代码创建 Array 对象 vegetables,其中包含元素 [spinach, green pepper, cilantro, onion, avocado]。
      * 然后,通过 sort() 方法对该数组进行排序,调用该方法时不带参数。
      * 结果是 vegetables 按字母顺序排序 ([avocado, cilantro, green pepper, onion, spinach])。
      */
     public function array_sort():void{
      var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "cilantro",
                 "onion",
                 "avocado");

   trace(vegetables); // spinach,green pepper,cilantro,onion,avocado
   vegetables.sort();
   trace(vegetables); // avocado,cilantro,green pepper,onion,spinach
      
     }
    
    
     /**
      * 下面的代码创建 Array 对象 vegetables,其中包含元素 [spinach, green pepper, Cilantro, Onion, and Avocado]。
      * 然后,通过 sort() 方法对该数组进行排序,第一次调用该方法时不带参数,其结果是 [Avocado,Cilantro,Onion,green pepper,spinach]。然后再次调用 sort()(对 vegetables),调用时将 CASEINSENSITIVE 常数作为参数。
      * 结果是 vegetables 按字母顺序排序 ([Avocado, Cilantro, green pepper, Onion, spinach])。
      */
     public function array_sort1():void{
      var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "Cilantro",
                 "Onion",
                 "Avocado");

   vegetables.sort();
   trace(vegetables); // Avocado,Cilantro,Onion,green pepper,spinach
   //CASEINSENSITIVE : uint = 1 [静态] 指定 Array 类排序方法为不区分大小写的排序。
   vegetables.sort(Array.CASEINSENSITIVE);
   trace(vegetables); // Avocado,Cilantro,green pepper,Onion,spinach
      
     }
    
    
     public function array_sort2():void{
      var vegetables:Array = new Array();
   vegetables.push(new Vegetable("lettuce", 1.49));
   vegetables.push(new Vegetable("spinach", 1.89));
   vegetables.push(new Vegetable("asparagus", 3.99));
   vegetables.push(new Vegetable("celery", 1.29));
   vegetables.push(new Vegetable("squash", 1.44));

   trace(vegetables);
   vegetables.sort();
   trace(vegetables);

     }
    
     /**
      * 按自定义的排序方式进行排序
      */
     public function array_sort3():void{
         var vegetables:Array = new Array();
   vegetables.push(new Vegetable("lettuce", 1.49));
   vegetables.push(new Vegetable("spinach", 1.89));
   vegetables.push(new Vegetable("asparagus", 3.99));
   vegetables.push(new Vegetable("celery", 1.29));
   vegetables.push(new Vegetable("squash", 1.44));
   vegetables.sort(sortOnPrice);
   trace(vegetables);
     }
    
 
    
     private function sortOnPrice(a:Vegetable,b:Vegetable):int{
      if(a.getPrice()>b.getPrice()){
       return 1;
      }else if(a.getPrice()==b.getPrice()){
       return 0;
      }else{
       return -1;
      }
     }
    
    
     /**
      * 按数字进行排序
      */
      public function array_sort4():void{
      var numbers:Array = new Array(3,5,100,34,10);

   trace(numbers); // 3,5,100,34,10
   numbers.sort();
   trace(numbers); // 10,100,3,34,5
   numbers.sort(Array.NUMERIC); //按数字排序
   trace(numbers); // 3,5,10,34,100
     }
    
     /**
      * 根据数组中的一个或多个字段对数组中的元素进行排序。
      */
     public function array_sortOn():void{
      var vegetables:Array = new Array();
   vegetables.push(new Vegetable("lettuce", 1.49));
   vegetables.push(new Vegetable("spinach", 1.89));
   vegetables.push(new Vegetable("asparagus", 3.99));
   vegetables.push(new Vegetable("celery", 1.29));
   vegetables.push(new Vegetable("squash", 1.44));
   
   trace(vegetables);
   // lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
   
   vegetables.sortOn("name");
   //vegetables.sortOn(["name","price"]);
   trace(vegetables);
   // asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44
   
   vegetables.sortOn("price", Array.NUMERIC | Array.DESCENDING);
   trace(vegetables);
   // asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29
   

     }
    
     /**
      * 对数组的多个字段进行排序
      */
     public function array_sortOn1():void{
      var records:Array = new Array();
   records.push({name:"john", city:"omaha", zip:68144});
   records.push({name:"john", city:"kansas city", zip:72345});
   records.push({name:"bob", city:"omaha", zip:94010});
   
   for(var i:uint = 0; i < records.length; i++) {
       trace(records[i].name + ", " + records[i].city);
   }
   // Results:
   // john, omaha
   // john, kansas city
   // bob, omaha
   
   trace("records.sortOn('name', 'city');");
   records.sortOn(["name", "city"]);
   for(var j:uint = 0; j < records.length; j++) {
       trace(records[j].name + ", " + records[j].city);
   }
   // Results:
   // bob, omaha
   // john, kansas city
   // john, omaha
   
   trace("records.sortOn('city', 'name');");
   records.sortOn(["city", "name"]);
   for(var k:uint = 0; k < records.length; k++) {
       trace(records[k].name + ", " + records[k].city);
   }
   // Results:
   // john, kansas city
   // bob, omaha
   // john, omaha

     }
    
    
     public function array_sortOn2():void{
      var users:Array = new Array();
   users.push(new User("Bob", 3));
   users.push(new User("barb", 35));
   users.push(new User("abcd", 3));
   users.push(new User("catchy", 4));
   
   trace(users); // Bob:3,barb:35,abcd:3,catchy:4
   
   users.sortOn("name");
   trace(users); // Bob:3,abcd:3,barb:35,catchy:4
   
   users.sortOn("name", Array.CASEINSENSITIVE);
   trace(users); // abcd:3,barb:35,Bob:3,catchy:4
   
   users.sortOn("name", Array.CASEINSENSITIVE | Array.DESCENDING);
   trace(users); // catchy:4,Bob:3,barb:35,abcd:3
   
   users.sortOn("age");
   trace(users); // abcd:3,Bob:3,barb:35,catchy:4
   
   users.sortOn("age", Array.NUMERIC);
   trace(users); // Bob:3,abcd:3,catchy:4,barb:35
   
   users.sortOn("age", Array.DESCENDING | Array.NUMERIC);
   trace(users); // barb:35,catchy:4,Bob:3,abcd:3
   
   var indices:Array = users.sortOn("age", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
   var index:uint;
   for(var i:uint = 0; i < indices.length; i++) {
       index = indices[i];
       trace(users[index].name, ": " + users[index].age);
   }
   
   // Results:
   // Bob : 3
   // abcd : 3
   // catchy : 4
   // barb : 35
     }
  
  
  /*
     Array(numElements:int = 0)允许创建指定元素数量的数组。
     Array(... values)  允许创建包含指定元素的数组。
     push(... args):uint 将一个或多个元素添加到数组的结尾,并返回该数组的新长度。
     shift():* 删除数组中第一个元素,并返回该元素。
  */
  public function arrayAssignment():void{
   
  
   trace("原来数组一的值:");
   for each(var e:Object in initArray){
    trace(e.toString());
   }
   
   var twoArray:Array=initArray;
   trace("原来数组二的值:");
   for each(var e1:Object in twoArray){
    trace(e1.toString());
   }
   trace('向数组oneArray.push("aa","bb","ee")中添加新元素后返回新的数组长度:'+initArray.push("aa","bb","ee"));//将一个或多个元素添加到数组的结尾,并返回该数组的新长度。
   trace("删除数组中第一个元素,并返回该元素:"+initArray.shift());//shift():* 删除数组中第一个元素,并返回该元素
   
   trace("数组一的值:");
   for each(var e2:Object in initArray){
    trace(e2.toString());
   }
   
   trace("数组二的值:");
   for each(var e3:Object in twoArray){
    trace(e3.toString());
   }
   
   
  }
  
  public function getOneArray():uint{
   var oneArray:Array=new Array();
   return oneArray.length;
  }
  
  public function getTwoArray():uint{
   var twoArray:Array=new Array(5);
   return twoArray.length;
  }
  
  public function getThree():void{
   var threeArray:Array =new Array(5);
   for(var i:uint=0;i<threeArray.length;i++){
    trace(threeArray[i]);
   }
  }
  
  
  public function getFour():void{
   var fourArray:Array=new Array(5);
   trace("长度为:"+fourArray.length);
   for(var i:uint=0;i<fourArray.length;i++){
    trace("循环中的第"+i+"个:"+fourArray[i]);
   }
      fourArray[0]="第一个值";
   fourArray.push("测试");
   
   for(var j:uint=0;j<fourArray.length;j++){
    trace("循环中的第"+j+"个:"+fourArray[j]);
   }
   
   trace("长度为:"+fourArray.length);
  }
  
  
  
  

 }
 
 
 
 
 
}

相关文章
|
前端开发
前端学习案例2-flex重难点2
前端学习案例2-flex重难点2
44 0
前端学习案例2-flex重难点2
|
前端开发
前端学习案例1-flex重难点
前端学习案例1-flex重难点
59 0
前端学习案例1-flex重难点
|
前端开发
前端学习案例3-flex重难点3
前端学习案例3-flex重难点3
41 0
前端学习案例3-flex重难点3
|
前端开发
前端知识案例学习7-元素居中
前端知识案例学习7-元素居中
39 0
前端知识案例学习7-元素居中
|
编解码 容器
浅析flex及常用语法整理
浅析flex及常用语法整理
|
容器
Flex 布局教程:语法篇
Flex 布局教程:语法篇
142 0
Flex 布局教程:语法篇
flex布局及常用属性,学flex收藏这个就够用了,超详细分析“建议收藏”
flex布局及常用属性,学flex收藏这个就够用了,超详细分析“建议收藏”
114 0
|
XML JavaScript 数据格式