数组

indexOf,lastindexOf用来直接查找目标元素在数组中的索引。

indexOf用法: 目标数组.indexOf(要查找的元素) 或者 目标数组.indexOf(要查找的元素，查找的起始位置) //按索引从小到大查找，找到返回索引值

lastindexOf用法:目标数组.lastindexOf(要查找的元素) 或者 目标数组.lastindexOf(要查找的元素，查找的起始位置)//按索引从大到小查找，找到返回索引值

push用法:数组.push(元素);数组.push(元素1，元素2，…元素n) //在数组尾部新增一个或多个元素

unshift用法:数组.unshift(元素);数组.unshift(元素1，元素2，…元素n) //在数组头部新增一个或多个元素

pop用法:数组.pop() //将数组最后一个元素删除

shift用法:数组.shift() //将数组第一个元素删除，剩余元素索引值自动减1
splice的四种用途:
(1)数组.splice(删除点索引，要删除的元素数目，新元素1，新元素2,…新元素n) //从数组某位置开始，删除被指定数目的元素，并插入一些新元素。
(2)数组.splice(删除点索引，要删除的元素数目) //删除数组中某位置之后的几个元素
(3)数组.splice(删除点索引) //删除数组中某位置之后的所有元素
(4)数组.splice(删除点索引，0，新元素1,新元素2…新元素n) //在数组某位置之后，插入新元素
—-{删除点的索引可以是负值，表示数组从尾部倒数的位置。比如，索引为-3，指的是数组倒数第三个元素}

slice可以获取数组中一段连续的元素，而不改变原有数组的内容。也就是说从原有数组复制一部分数组出来组成一个新数组。
用法：数组.slice(起始索引，终点索引) //返回值是截取的元素组成的新数组，新中包括起点索引的元素，但不包括终点索引的元素。
        数组.slice（起始索引） //返回的是从起始点索引开始到数组终点的这段元素
—-{起始点和终点的索引可以是负值，表示数组从尾部倒数的位置。比如，索引为-3，指的是数组倒数第三个元素}

concat将多个元素或数组拼成一个新的数组。
用法: 数组.concat(参数1，参数2，…参数n) //concat会将数组分开成各个元素按顺序加入新数组中
例子：
     var foo:Array=["a","b","c"]
     var bar1:int=1
     var bar2:Array=[2,3,4]
     var newarr=foo.concat(bar1,bar2)
     trace(newarr)
     //输出：a,b,c,1,2,3,4
     trace(newarr.length)
     //输出:7
   —-{concat与push的区别：concat不会改变原有数组内容，push直接改变原有数组内容。concat加入数组时会将数组打散再按顺序将元素加入到新数组中，push加入数组时会将整个数组当作一个元素加入到原数组的后面}
   reverse能将数组元素倒序
   用法:数组.reverse() //返回的是新的数组

 

    反转数组顺序:reverse()

    var aa:Array = [1,2,3];

    aa.reverse();

    trace(aa);//输出3,2,1

   sort对数组元素排序
   用法：
     (1)数组.sort() //默认排序 按照字符串字母顺序排序，如果元素是数值，也会被当成字符串来排序
     (2)数组.sort(排序方式) //使用“排序方式”参数来排序，排序方式是一些定义好的整数常量
     (3)数组.sort(比较函数) //使用自定义的比较函数，注意此处只可写函数排序
   sortOn 当数组元素是复杂数据类型，且需要根据这种对象的某个属性值来排序时使用。比如说某俎元素都有一个属性值name，希望根据name来排序，那么使用的方法如下
   用法：
     (1)数组.sortOn(”name”)   //根据指定属性，默认排序
     (2)数组.sortOn(”name”,排序方式) //根据指定属性，使用指定的“排序方式”来排序
     (3)数组.sortOn(”name”,比较函数) //根据指定属性，使用自定义的函数排序
   排序方式，是指一些再Array类中定义好的整形常量，代表几种不同的排序方式
   (1)Array.CASEINSENSITIVE 值为1，表示大小写不敏感按字母顺序排序，如果是数字则从小到大。
   (2)Array.DESCENDING 值为2，表示按字母到序排序
   (3)Array.UNIQUESORT 值为4，表示必须是唯一性排序，如果比较值结果相同，则放弃排序 返回值为 0
   (4)Array.RETURNINDEXEDARRAY 值为8，让sort()和sortOn()函数返回值返回排序后的索引列表，同时保持原数组不变
   (5)Array.NUMERIC or 16 值为16，强制sort()和sortOn()中对数值采用从小到大排序。
   比较函数的要求是，有两个参数，返回值是1，0，-1中的一个。
   function 函数名(参数A，参数B):int{}
   比较函数的作用是将数组里的元素一对对的取出来分别作为这个比较函数的两个参数，如果返回为1，那么作为A参数的元素就应该排在B的后面；如果返回为-1，那么A参数的元素就应该排在B前面，如果为0，表示结果一样。
   forEach用法：数组.forEach(callFunction:Function,thisObject:*=null):viod //遍历操作：操作数组中的每一项元素。回调函数不需要返回任何值。
   filter用法：数组.every(callFunction:Function,thisObject:*=null):Array //过滤器：将符合回调函数条件的元素提出来，构成一个新的数组并返回。
   every用法：数组.filter(callFunction:Function,thisObject:*=null):Boolean //全员满足才为真：必须所有元素都让回调函数返回为true，every()才返回true，否则为false。回调函数返回单个元素比较结果，布尔值。
   map用法：数组.filter(callFunction:Function,thisObject:*=null):Array //映射器：根据回调函数操作原数组每个元素，并利用回调函数返回的结果生成新的数组。回调函数返回的是单个新数组元素。
   some用法：数组.filter(callFunction:Function,thisObject:*=null):Boolean //有一个满足为真：只要有一个元素能让回调函数返回true，则some（）返回true，否则为false。回调函数返回的是单个元素比较结果，布尔值。

 

join用法：

将数组中的元素转换为字符串、在元素间插入指定的分隔符、连接这些元素然后返回结果字符串。嵌套数组总是以逗号 (,) 分隔，而不使用传递给 join()方法的分隔符分隔。

下面的代码创建一个 Array 对象 myArr，其中包含元素 one、two 和three，然后创建一个包含one and two and three 的字符串（使用 join() 方法）。

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

下面的代码创建一个 Array 对象 specialChars，其中包含元素 (、)、- 和一个空格，然后创建一个字符串，其中包含 (888) 867-5309。然后使用for 循环，删除specialChars 中列出的每种类型的特殊字符，以生成一个字符串 (myStr)，该字符串中仅包含剩余的电话号码数字：888675309。请注意，其它字符（如+）可能已添加到了specialChars 中，这样此例程即可处理国际电话号码格式。

var phoneString:String = "(888) 867-5309";

var specialChars:Array = new Array("(", ")", "-", " ");
var myStr:String = phoneString;

var ln:uint = specialChars.length;
for(var i:uint; i < ln; i++) {
    myStr = myStr.split(specialChars[i]).join("");
}

var phoneNumber:Number = new Number(myStr);

trace(phoneString); // (888) 867-5309
trace(phoneNumber); // 8888675309

indexOf lastIndexOf

返回索引，查找不到返回-1

var arr:Array = ["a","b","c","d","e","f","g"]; 
arr.indexOf("e"); 
arr.indexOf("b",2);//从第3个元素开始查找 
arr.lastIndexOf("b",2);//从第3个元素反向查找

push unshift

在首尾插入元素，返回增加元素后数组的长度

var arr:Array = ["a","b","c","d","e","f","g"]; 
arr.push("h");//在数组尾部插入元素h 
arr.push("i","j","k");//在数组尾部插入多个元素 
arr.unshift("h");//在数组头部插入元素h 
arr.unshift("i","j","k");//在数组头部插入多个元素

pop shift

删除首尾元素，返回被删除的元素

var arr:Array = ["a","b","c","d","e","f","g"]; 
arr.pop();//删除尾元素 
arr.shift();//删除首元素 

splice

删除数组一段连续的元素，返回被删除的元素数组

var arr:Array = ["a","b","c","d","e","f","g"]; 
arr.splice(删除点的索引,要删除的个数,新元素1,新元素2); 
arr.splice(2,3,"o","p","q");//从索引为2开始，删除3个元素，并插入3个新元素"o","p","q"
arr.splice(-2,3,"o","p","q");//从倒数为2的索引开始，删除3个元素，并插入3个新元素"o","p","q"
arr.splice(2,3);//单纯的删除从索引2开始的3个元素(不插入) 
arr.splice(2);//单纯的删除从索引2开始的所有元素(不插入) 
arr.splice(2,0,"x","y","z");//在索引2的后面插入3个新元素(不删除)

slice

获取数组中的部分元素

var arr:Array = ["a","b","c","d","e","f","g"]; 
var newArr:Array = arr.slice();//浅复制数组 
var newArr:Array = arr.slice(2); 
var newArr:Array = arr.slice(-2); 
var newArr:Array = arr.slice(2,5); 

concat

将多个元素或数组拼接成一个新数组

var arr:Array = ["a","b","c","d","e","f","g"]; 
var newArr = arr.concat("x","y","z");//原数组不变，新数组是原数组拼接后的结果 
var newArr = arr.concat();//浅复制数组

reverse

将数组倒序排列

var arr:Array = ["a","b","c"]; 
arr.reverse();//得到"c","b","a" 

 

3. sort(Array.UNIQUESORT) 同sort(),如果数组有相同元素，则放弃排序，返回0

 

var arr:Array = ["b","C","a","X",235,8641,38,2365]; 
if(arr.sort(Array.UNIQUESORT)=="0") 
{  
    trace("有相同元素"); 
} 
else 
{  
    trace("没有相同元素"); 
}

 

 

sort(args) 按参数排序,一共有5种(注意：除了Array.RETURNINDEXEDARRAY,其它方式只要排序成功，都会实际改变数组)

1. sort(Array.CASEINSENSITIVE) 同sort(),不过不区分大小写,数字也是按字符串来处理

var arr = ["b","X","A","c"]; 
arr.sort(Array.CASEINSENSITIVE);//得到"A","b","c","X"

2. sort(Array.DESCENDING) 按字符串的倒序排列,区分大小写,数字也是按字符串来处理

var arr:Array = ["b","C","a","X",235,8641,38]; 
trace(arr.sort(Array.DESCENDING));//得到b,a,X,C,8641,38,235

3. sort(Array.UNIQUESORT) 同sort(),如果数组有相同元素，则放弃排序，返回0

var arr:Array = ["b","C","a","X",235,8641,38,2365]; 
if(arr.sort(Array.UNIQUESORT)=="0") 
{  
    trace("有相同元素"); 
} 
else 
{  
    trace("没有相同元素"); 
}

4. sort(Array.RETURNINDEXEDARRAY) 同sort(),返回排序后的索引列表，原数组不变

var arr:Array = ["b","C","a","X",235,8641,38,2365]; 
trace(arr.sort(Array.RETURNINDEXEDARRAY));//得到4,7,6,5,1,3,2,0 
trace(arr);//得到b,C,a,X,235,8641,38,2365(原数组)

5. sort(Array.NUMERIC) 按数字从小到大排序,如果数组里含有非数字，会抛出异常

var arr:Array = [235,8641,38,2365]; 
trace(arr.sort(Array.NUMERIC));//得到38,235,2365,8641

sort(函数名) 按自定义函数比较,该函数必须接受2个参数，返回值为1、-1、0

public function Sample1008() 
{ 
    var objA:Object = {price:200,quantity:2}; 
    var objB:Object = {price:400,quantity:4}; 
    var objC:Object = {price:100,quantity:1}; 
    var arr:Array = [objA,objB,objC]; 
    trace("原数组是："); 
    for(var i:int=0;i<arr.length;i++) 
    { 
        trace(arr[i].price); 
    } 
    arr.sort(Compare); 
    trace("排序后的数组是："); 
    for(var j:int=0;j<arr.length;j++) 
    { 
        trace(arr[j].price); 
    } 
} 
private function Compare(paraA:Object,paraB:Object):int 
{ 
    var totalPriceA:int = paraA.price * paraA.quantity; 
    var totalPriceB:int = paraB.price * paraB.quantity; 
    if(totalPriceA>totalPriceB) 
    { 
        return 1; 
    } 
    else if(totalPriceA<totalPriceB) 
    { 
        return -1; 
    } 
    else 
    { 
        return 0; 
    } 
} 
/*运行结果是 
原数组是： 
200 
400 
100 
排序后的数组是： 
100 
200 
400*/

sortOn

常用于对象数组的排序

var obj1:MyClass = new MyClass(); 
var obj2:MyClass = new MyClass(); 
var obj3:MyClass = new MyClass(); 
obj1.orderID = 300; 
obj2.orderID = 100; 
obj3.orderID = 200; 
var arr:Array = [obj1,obj2,obj3]; 
//trace(arr.sortOn("orderID")); 
trace(arr.sortOn("orderID",Array.RETURNINDEXEDARRAY));//得到索引1,2,0

every

判断数组里的每个元素是否满足某些条件，只有全部都满足才为true

public function Sample1008() 
{ 
    //必须5个人都满70级，才可以进副本
   var player1:Object = {name:"wayne",level:70}; 
    var player2:Object = {name:"tom",level:69}; 
    var player3:Object = {name:"jacky",level:70}; 
    var player4:Object = {name:"andy",level:68}; 
    var player5:Object = {name:"bill",level:70}; 
     
    var playerList:Array = [player1,player2,player3,player4,player5]; 
    if(!playerList.every(CheckLevel)) 
    { 
        trace("队伍中有人等级未到70，无法进入副本"); 
    } 
} 
private function CheckLevel(item:*,index:int,arr:Array):Boolean 
{ 
    if(item.level<70) 
    { 
       //trace(item.name+"等级未到70,无法进入副本"); 
        return false; 
    } 
    return true; 
}

map

映射器，逐个处理数组中的元素，最后生成一个修改后的新数组(不会更改原数组)

public function Sample1008() 
{ 
    var player1:Object = {name:"wayne",level:70}; 
    var player2:Object = {name:"tom",level:69}; 
    var player3:Object = {name:"jacky",level:70}; 
    var player4:Object = {name:"andy",level:68}; 
    var player5:Object = {name:"bill",level:70}; 
     
    var playerList:Array = [player1,player2,player3,player4,player5]; 
     
    for(var i:int = 0; i<playerList.length; i++) 
    { 
        trace("player"+(i+1)+"的所有属性是:"); 
        for(var attr:String  in  playerList[i]) 
        { 
            trace(attr+":"+playerList[i][attr]); 
        } 
    } 
     
   //为每个玩家添加新属性"声望值"
    var newArray:Array = playerList.map(AddNewAttribute); 
     
    trace("-----------------Map后的结果-----------------"); 
     
    for(var j:int = 0; j<newArray.length; j++) 
    { 
        trace("player"+(j+1)+"的所有属性是:"); 
        for(var attr2:String  in  newArray[j]) 
        { 
            trace(attr2+":"+newArray[j][attr2]); 
        } 
    } 
} 
private function AddNewAttribute(item:*,index:int,arr:Array):Object 
{ 
    var tmpPlayer:Object = {}; 
    tmpPlayer.name = item.name; 
    tmpPlayer.level = item.level; 
    tmpPlayer.repute = 99; 
    return tmpPlayer; 
}

some

判断数组里的每个元素是否满足某些条件，只要有一个满足就返回true

public function Sample1008() 
{ 
   //只要队伍里有一个人声望达到140以上，则全队可以进副本 
   var player1:Object = {name:"wayne",level:70,repute:100}; 
    var player2:Object = {name:"tom",level:70,repute:190}; 
    var player3:Object = {name:"jacky",level:70,repute:50}; 
    var player4:Object = {name:"andy",level:70,repute:230}; 
    var player5:Object = {name:"bill",level:70,repute:120}; 
     
    var playerList:Array = [player1,player2,player3,player4,player5]; 
     
    if(playerList.some(CheckRepute)) 
    { 
        trace("可以进入副本"); 
    } 
    else 
    { 
        trace("队伍里没有成员声望达到140，无法进入副本"); 
    } 
} 
private function CheckRepute(item:*,index:int,arr:Array):Boolean 
{ 
    if(item.repute>=140) 
    { 
        return true; 
    } 
    return false; 
}

filter

将数组里满足特定条件的元素提取出来，生成一个新数组

public function Sample1008() 
{ 
   //得到队伍里所有声望达到要求的成员 
   var player1:Object = {name:"wayne",level:70,repute:100}; 
    var player2:Object = {name:"tom",level:70,repute:190}; 
    var player3:Object = {name:"jacky",level:70,repute:50}; 
    var player4:Object = {name:"andy",level:70,repute:230}; 
    var player5:Object = {name:"bill",level:70,repute:120}; 
     
    var playerList:Array = [player1,player2,player3,player4,player5]; 
     
    var newArray:Array = playerList.filter(CheckRepute); 
     
    for(var i:int=0; i<newArray.length; i++) 
    { 
        for(var attr:String  in  newArray[i]) 
        { 
            trace(attr+":"+newArray[i][attr]); 
        } 
    } 
} 
private function CheckRepute(item:*,index:int,arr:Array):Boolean 
{ 
    if(item.repute>=140) 
    { 
        return true; 
    } 
    return false; 
}

forEach

对数组里的元素逐个进行操作，实际改变了数组(不同于map)

public function Sample1008() 
{ 
   //在每个玩家名字前面加上公会名称 
   var player1:Object = {name:"wayne",level:70,repute:100}; 
    var player2:Object = {name:"tom",level:70,repute:190}; 
    var player3:Object = {name:"jacky",level:70,repute:50}; 
    var player4:Object = {name:"andy",level:70,repute:230}; 
    var player5:Object = {name:"bill",level:70,repute:120}; 
     
    var playerList:Array = [player1,player2,player3,player4,player5]; 
     
    playerList.forEach(BuildName); 
     
    for(var i:int=0; i<playerList.length; i++) 
    { 
        for(var attr:String  in  playerList[i]) 
        { 
            trace(attr+":"+playerList[i][attr]); 
        } 
    } 
} 
private function BuildName(item:*,index:int,arr:Array):void 
{ 
    item.name = "暗界--"+item.name; 
}

复制去Google翻译翻译结果