引用类型之Array类型

Array类型

ECMAScript数组与其它语言数组一样，都是数据的有序列表。但是ECMAScript数组的每一项可以保存任何类型的数据。而且，ECMAScript数组是可以动态调整的。

1.创建和修改数组

·创建数组

var colors=new Array(20);      //创建长度位20的数组
var colors=Array(20);             //可以省略new操作符
var colors=Array("red","blue","green");

//数组字面量表示法
var colors=["red","blue","green"];
var values=[1,2,3];

 ·修改数组

var colors=["red","blue","green"];
alert(colors[0]);                                 //显示第一项
colors[2]="black";                             //修改第三项
colors[3]="brown";                           //新增第四项

·数组的length活用

数组的length不是只读的，重新设置length可以移出项，修改项，新增项，修改数组的长度。

2.检测数组----Array.isArray()

3.转换方法

toString():返回以逗号隔开的字符串     丨     valueOf():返回的是数组       丨      alert():会在后台调用toString()方法，而不是toLocaleString()方法     丨      join():参数是符号，此符号将代替逗号隔开字符串

4.栈方法和队列方法

栈方法：push()：在末尾添加      pop():获得最后一项并移除

队列方法：shift():在首项移除       unshift():在首项添加

5.数组重排序

reverse()方法：反转数组的顺序     丨     sort()方法：按照传入的函数重新排序

比较函数：

function compare(value1,value2){
return value2-value1;
};

6.操作方法 

concat():先复制已有的数组，然后将参数添加到副本的末尾，如果参数是值，则直接添加，如果参数是数组，则将每一项都添加到副本的末尾。往一个数组后面加很多项用此方法。

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

slice():从原数组中截取某一部分用此方法

var colors=["red","blue","green","black","yellow"];
var colors2=colors.slice(1);                        //从第二个数到最后
var colors3=colors.slice(1,4);                      //从第二个数到第五个数，但是不包括第五个数
alert(colors2);                                     //blue,green,black,yellow
alert(colors3);                                     //blue,green,black
                                                    //如果参数里有负数，则用数组长度加上该数来确定相应的位置

splice():最强大的数组操作方法

/*spice()方法是最强大的数组方法，它有三个参数 ，依次为起始位置，要删除的项数，要添加的项*/
var colors=["red","green","blue"];
var removed=colors.splice(0,1);                        /*删除第一行*/
alert(colors);                                         /*green,blue*/
alert(removed);                                        /*red,返回的数组中只包含一项，即删除的那一项*/

removed=colors.splice(1,0,"yellow","orannge");        //从位置一开始插入两项
alert(colors);                                        //green,yellow,orange,blue注意，yellow在位置1
alert(removed);                                       //返回的是一个空数组

removed=colors.splice(1,1,"red","purple");            //插入两项，删除一项
alert(colors);                                        //green,red,purple,orange,blue
alert(removed);                                       //yellow,返回的数组中只包含一项
/*注意，splice（）返回的是删除的项，而不是改变后的原数组*/

 7.迭代方法

every():每一项运行函数，只有每一项都返回true，最后才返回true

some():每一项都运行函数，任一项返回true最后就会返回true

forEach():不会返回值，作用其实和for循环一样

filter():每一项运行函数，返回该函数会返回true的项组成的数组

map():每一项都运行函数，返回每次函数调用的结果组成的数组

/*every()和some()返回true或者false，不同的是，运行函数，every要求函数对每一项都返回true才会返回true，而some只要求任一项返回true就返回true*/
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

var someResult=numbers.some(function(item,index,array){
    return(item>2);
});
alert(someResult);             //true

/*filter()每一项运行函数，返回该函数会返回true的项组成的数组*/
var numbers=[1,2,3,4,5,4,3,2,1];
var filterResult=numbers.filter(function(item,index,array){
    return(item>2);
});
alert(filterResult);           //[3,4,5,4,3]

/*forEach()不返回值，作用其实for循环一样*/

/*map()方法：每一项运行函数，返回每次函数调用的结果组成的数组*/
var numbers=[1,2,3,4,5,4,3,2,1];
var mapNumbers=numbers.map(function(item,index,array){
    return item*2;
});
alert(mapNumbers);             //2,4,6,8,10,8,6,4,2

 

8.归并方法

reduce()和reduceRight()方法都会迭代数组的每一项，然后构建一个最终返回的值。reduce()正序，reduceRight()逆序。这两个方法都接收两个参数：在每一项上调用的函数和最为归并的初始值。而这个函数接收4个参数

前一个值，当前值，项的索引和数组对象。这个函数返回的任何值都会作为一个参数返回给下一项。第一次迭代发生在数组的第二项，因此，第一个参数是数组的第一项，第二个参数是数组的第二项。

var values=[1,2,3,4,5];
var sum=values.reduce(function(prev,cut,index,array){
    return prev+cut;
},5);
alert(sum);          //20
/*这两个方法都接收两个参数：一个在每一项上调用的函数和（可选）作为归并基础的初始值。传给reduce（）和reduceRight（）的函数接收4个参数
 前一个值，当前值，项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项。因此第一个参数是数组的第一项
 第二个参数是数组的第二项。
 * */

 

9.位置方法

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  从第五的数开始往后检索，所以第一个4并没有被检索到
alert(numbers.lastIndexOf(4,4));           //3  从倒数第五个数开始检索

var person={name:"Nicholas"};
var people=[{name:"Nicholas"}];

var morePeople=[person];

alert(people.indexOf(person));            //-1
alert(morePeople.indexOf(person));          //0