数组 | 人间一趟

Array创建实例

//用构造函数的方法
var colors=new Array();
var colors=new Array(20);
var colors=new Array("gray","green","red");
var colors=Array();//可以省略new

//用数组字面量表示法
var colors=["gray","green","red"];
var names=[];
var values=[1,2,];//不要这样，这样会创建一个包含2或3项的数组
var options=[,,,,,]//不要这样，这样会创建一个包含2或6项的数组

检测数组

Array.isArray()确定一个值到底是不是数组

转换方法

toString()：返回有由数组中每个值得字符串形式拼接而成的一个以逗号分隔的字符串。
valueOf()：直接返回数组

toLocaleString()：创建一个数组值的以逗号分隔的字符串。

var colors=["gray","green","red"];
alert(colors.toString());  //gray,green,red
alert(colors.valueOf());   //gray,green,red
alert(colors);             //gray,green,red
//最后一行将数组传给alert，alert要求接受字符串，所以后台自动调用头String（）

var person1={
    toLocaleString:function(){
        return "Nikolaos";
    },
    toString:function(){
        return "Nicholas";
    }
};
var person2={
    toLocaleString:function(){
        return "Grigorios";
    },
    toString:function(){
        return "Greg";
    }
};
var people=[person1,person2];
alert(people);                       //Nicholas,Greg
alert(people.toString());            //Nicholas,Greg
alert(people.toLocaleString());      //Nicholas,Grigorios

join()方法：可以用其他符号来分隔数组

1
2
3

var colors=["gray","green","red"];
alert(colors.join(","));     //gray,green,red
alert(solors.join("||"));    //gray||green||red

栈方法

push()方法可以接受任意数量的参数，把他们逐个添加到数组末尾，并返回修改后的数组的长度。

pop()方法则是从数组末尾移除最后一项，减少数组的length值，然后返回移除的项。

var colors=new Array();
var count=colors.push("red","green");
alert(count);            //2
count=colors.push("black");
alert(count);            //3
var item=color.pop();
alert(item);             //"black";
alert(colors.length);    //2
//可以将栈方法和其它数组方法连用
var colors=["red","blue"];
colors.push("brow");
colors.[3]="black";
alert(colors.length);    //4
var item=colors.pop();
alert(item);             //"black"

队列方法

shift()方法能够移除数组中的第一项，并且返回该项，同时将数组长度减1。

unshift()方法能在数组前段端添加任意个项并返回数组长度。

var colors=new Array();
var count=colors.push("red","green");
alert(count);            //2
var item=colors.shift();
alert(item);             //"red"
alert(colors.length);    //1
count=colors.unshift("black");
alert(count);            //2

排序

reverse()方法：反转数组项的顺序。返回值是数组。

sort()方法：按升序排列数字项。（比较的是字符串）返回值是数组。

var values=[1,2,3,4,5];
values.reverse();
alert(values);   //5,4,3,2,1

var values=[0,1,5,10,15];
values.sort();
alert(values);   //0,1,10,15,5
//在字符串进行比较的时候5是比10大的，这个时候我们经常让sort方法接受一个比较函数作为参考。
//比较函数（升序，改变大于和小于就能变成降序）
function campare(value1,value2){
    if(value1<value2)
        return -1;
    else if(value1>value2)
        return 1;
    else
        return 0;
}
var values=[0,1,5,10,15];
values.sort(campare);
alert(values);   //0,1,5,10,15

操作方法

concat()方法：创建一个新的数组。复制一遍数组并在末尾添上新的元素。

var colors=["gray","green","red"];
var colors2=colors.contac("yellow",["black","brown"]);
alert(colors);             //gray,green,red
alert(colors2);            //gray,green,red,yellow,black,brown

slice()方法：能够基于当前数组中的一或多个项创建一个新数组。
当有一个参数时：返回从该参数指定位置开始到当前数组末尾的所有项。
如果有两个参数时：返回起始和结束位置之间的项，但不包括结束为止的项。
splice()方法：主要用途是项数组中部插入项。（最强大的数组方法）
删除：需要两个参数，位置和删除项数。例：splice(0,2);删除数组中的前两项。
插入：需要三个参数，起始位置，0（删除的项数）和插入项。例：splice(2,0,"red,"green")从数组的位置2开始插入字符串”red”和”green”。
替换：需要三个参数，起始位置，要删除的的项数和要插入的任意数量的项。例：splice(2，1，"red","green")删除当前数组位置2的项，然后再从位置2开始插入字符串。

位置方法

indexOf()方法：从数组的开头开始向后查找。

lastIndexOf()方法：从数组的末尾开始向前查找。
两个方法都接收两个参数，要查找的项和开始查找的起始位置。没找到的情况返回-1，返回值是位置。

var numbers=[1,2,3,4,5,4,3,2,1];
alert(numbers.indexOf(4));              //3
alert(numbers.lastIndexOf(4));          //5

alert(numbers.indexOf(4，4));           //5
alert(numbers.lastIndexOf(4，4));       //3

var person={name:"Nicholas"};
var people=[{name:"Nicholas"}];
var morePeople=[people];
alert(people.indexOf(person));          //-1
alert(morePeople.indexOf(peoson));      //0

迭代方法

every():对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true，否则返回false。
filter():对数组中的每一项运行给定函数，返回该函数会返回true的项组成数组。
forEach():对数组中的每一项运行给定函数，这个方法没有返回值。
map():对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

some():对数组中的每一项运行给定函数，如果该函数对任意一项返回true，则返回true。
以上方法都不会修改数组中包含的值。都接收三个参数：数组项的值，该项在数组的位置，数组对象本身。

//every()
var numbers=[1,2,3,4,5,4,3,2,1];
var everyResult=numbers.every(function(item,index,array){
    return (item>2);
});
alert(everyResult);           //false
//some()
var numbers=[1,2,3,4,5,4,3,2,1];
var someResult=numbers.every(function(item,index,array){
    return (item>2);
});
alert(someResult);           //true
//filter()
var numbers=[1,2,3,4,5,4,3,2,1];
var filterResult=numbers.every(function(item,index,array){
    return (item>2);
});
alert(filterResult);           //[3,4,5,4,3]
//map()
var numbers=[1,2,3,4,5,4,3,2,1];
var mapResult=numbers.every(function(item,index,array){
    return item*2;
});
alert(mapResult);           //[2,4,6,8,10,8,6,4,2]
//forEach()
var numbers=[1,2,3,4,5,4,3,2,1];
numbers.forEach(function(item,index,array){
    //执行某些操作
});

归并方法

reduce():从数组的第一个开始，逐个遍历到最后。
reduceRight():从数组最后一个开始，逐个遍历到第一个。

这两个函数接收两个参数：一个在每一项上的调用的函数和（可选的）作为归并基础的初始值。
传给两个函数的函数接收四个参数：前一个值，当前值，项的索引，数组对象。

函数的返回值都会作为第一个参数自动传给下一项。

//reduce()正向
var values=[1,2,3,4,5];
var sum=values.reduce(function(prev,cur,index,array){
    return prev+cur;
});
alert(sum);          //15
//ruduceRight()反向
var values=[1,2,3,4,5];
var sum=values.reduceRight(function(prev,cur,index,array){
    return prev+cur;
});
alert(sum);          //15