JavaScript数组相关（一）之数组的创建方式以及数组的部分方法

创建数组的方式

1. 数组字面量的方式创建

    var arr = [1,2,3,4];

使用字面量创建数组的方法还可以创建稀松数组。（稀松数组会在之后进行讨论）

    var arr = [1,,,2,3,,];
    console.log(arr);       //[1, empty*2, 2, 3, empty]
    //IE8及以前版本可能会输出[1, empty*2, 2, 3, empty*2]

2. 通过实例化构造函数来创建

    var arr = new Array(1,2,3);
    console.log(arr);       //[1, 2, 3]

如果是 使用实例化构造函数的方法来创建数组，同时只传递一个参数 的情况下 需要特别注意：

当传入的参数是数字类型的时侯，会创建一个长度为参数的空（每个索引上的数值为空）数组，如果打印数组中的某项，输出的是undefined。

    var arr = new Array(2);
    console.log(arr);       //[empty * 2](Chrome中)
    console.log(arr[0]);    //undefined

当传入的参数是其他类型的时候

    var arr = new Array('a');
    console.log(arr);       //['a'];
    
    var arr = new Array({name:'xu'});
    console.log(arr);       //[{name:'xu'}];

使用Array构造函数声明数组的话还可以省略new关键字。

数组的检测方法

1. arr instanceof Array

通过检测 Array.prototype是否在arr的原型链上来判断是不是数组。

    var arr = [1,2,3];
    console.log(arr instanceOf Array);      //true
    
    var obj = {};
    console.log(obj instanceof Array);      //false

2. Array.isArray(arr)

ES5新增的方法，用以检测参数是不是数组

    var arr = [1,2,3];
    console.log(Array.isArray(arr));    //true

3. Object.prototype.toString.call(arr)

通过判断这个方法的返回值是否等于"[object Array]"来判断是否是数组

    var arr = [1,2,3],
        obj = {name:'xu'},
        toStr = {}.toStirng;
    console.log(toStr.call(arr));       //'[object Array]'
    console.log(toStr.call(obj));       //'[object Object]'

数组的转换方法

1. arr.toString()， 返回的是字符串

调用 toString 方法会返回数组中每个元素直接拼接上','（逗号）连接成的字符串

    var arr = [1,2,3];
    console.log(arr.toString());        //'1,2,3'
    
    arr = [1,2,{name:'xu'}];
    console.log(arr.toString);          //'1,2,[object Object]'
    //此处 隐式调用了对象的 toString 方法
    
    arr = [1,2,[3,4]];
    console.log(arr.toString());        //'1,2,3,4'
    
    arr = [1,null,[3,undefined,4]];
    console.log(arr.toString());        //'1,,3,,4' 
    //如果调用toString 方法的数组中有 null 和 undefined 的话，
    //那么再返回结果中将以空字符表示

2. arr.valueOf()，返回的还是数组

    var arr = [1, 2, 3];
    console.log(arr.valueOf());             //[1,2,3]
    console.log(arr.valueOf() === arr);     //true

数组的栈和队列方法

1. 数组的栈方法（实现类似栈的方法）

首先，什么是栈？
**栈是一种LIFO（Last-In-First-Out,后进先出）的数据结构**, 换句话说就是后进入的先出去。
每次操作的数据都是栈顶部的那个数据。

push方法

可以传递一至多个参数，将他们添加到数组的末尾，并且返回添加后数组的长度

pop方法

调用pop方法可以移除数组的最后一项，同时返回被移除的那一项。

    var arr = [];
    console.log(arr);                   //[]
    
    var pushResult = arr.push('a');
    console.log(arr);                   //['a']
    console.log(pushResult);            //1
    
    
    var pushResult = arr.push('b','c');
    console.log(arr);                   //['a','b','c']
    console.log(pushResult);            //3
    
    var popResult = arr.pop();
    console.log(popResult);             //'c'
    console.log(arr);                   //['a','b']

2. 数组的队列方法

栈数据结构的访问规则是 LIFO（后进先出）,而队列数据结构的访问规则是 FIFO（First-In-First-Out，先进先出）。

shift方法

调用shift方法可以移出数组中的第一项，返回值是被移除的这一项。
结合push方法可以实现类似队列的效果。

unshift方法

调用unshift方法可以传递一至多个参数并将其添加到数组的起始位置，同时返回添加后数组的长度。

    var arr = ['a','b','c'];
    
    var shiftResult = arr.shift();
    console.log(arr);                   //['b','c']
    console.log(shiftResult);           //'a'
    
    var unshiftResult = arr.unshift(0,'a');
    console.log(arr);                   //[0,'a','b','c']
    console.log(unshiftResult);         //4

数组的重排序方法

数组的重排序方法会改变原数组

1. arr.reverse()

将数组中的元素反转后返回。

    var arr = [1,2,3];
    console.log(arr.reverse());             //[3,2,1]
    console.log(arr);                       //[3,2,1]

2. arr.sort()

默认情况下，sort方法是按照升序进行排列的，为了实现排序，sort方法会调用每个数组项的toString()方法，然后对得到的字符串进行比较，比较的是每个位置上的ASCII编码。所以默认情况的这种排序方法大多数情况下都不是我们想要的。
由于sort方法可以接收一个比较函数作为参数，我们正好可以利用这一点。

以下是JavaScript高级程序设计中的参数介绍：

比较函数接收两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等，则返回 0，如果第一个参数应该位于第二个之后则返回一个正数。

换一种更好理解的说法，比较函数的两个参数分别对应要比较的前后两个数，如果前一个数大于后一个数的话就返回正数，如果前一个数小于后一个数的话就返回负数，相等的话返回0。
如果是正数那么按照升序排列，如果是负数那么按照降序排列，如果是0的话则不改变。

    var arr = [2,1,4,5,11];
    function compare(value1, value2) {
        if (value1 < value2) {
            return -1;
        } else if (value1 > value2) {
            return 1;
        } else {
            return 0;
        }
    }
    console.log(arr.sort(compare));             //[1,2,4,5,11]

简化写法：

    var arr = [2,1,4,5,11];
    function compare(value1, value2) {
       return value1-value2;                
    }
    console.log(arr.sort(compare));             //[1,2,4,5,11]
    console.log(arr);                           //[1,2,4,5,11]

如果要降序排列的话，交换return的表达式中的参数顺序即可（value2-value1）。

数组的操作方法

1. concat()

首先，不会改变原数组。
其次，返回值是新构建的数组。

这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。
在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。如果传递给 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

2. slice()

首先，不会改变原数组。
其次，返回值是截取的项。

这个方法能够基于当前数组中的一或多个项创建一个新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项，但不包括结束位置的项。

    var colors = ["red", "green", "blue", "yellow", "purple"];
    var colors2 = colors.slice(1);
    var colors3 = colors.slice(1,4);
    alert(colors2);         //green,blue,yellow,purple
    alert(colors3);         //green,blue,yellow
    
    var colors4 = colors.slice(-2,-1);
    alert(colors4);         //yellow  

如果 slice()方法的参数中有一个负数，则用数组长度加上该数来确定相应的位置。例如，在一个包含 5 项的数组上调用 slice(-2,-1)与调用 slice(3,4)得到的结果相同。如果结束位置小于起始位置，则返回空数组。

如上面代码中的最后一个，-1代表最后一个，-2代表最后一个的前一个。截取的是倒数第二个到倒数第一个，但不包括倒数第一个。

3. splice()

splice方法是数组方法中最强大的一个了，主要用途是在数组中插入项，但是除此之外又有其他用途。以下方法的介绍引用自JavaScript高级程序设计，因为简洁明了，所以我就不自己在复述了。

3.1 插入

可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、0（要删除的项数）和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项。

   var arr = [1,2,3];
   var spliceResult =  arr.splice(1,0,4);
   console.log(spliceResult);           //[]
   console.log(arr);                    //[1,4,2,3]

利用这个特性可以用splice方法实现unshift，push，concat。

3.1 删除

可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。
例如，splice(0,2)会删除数组中的前两项。

   var arr = [1,2,3];
   var spliceResult =  arr.splice(0,2);
   console.log(spliceResult);           //[1,2]
   console.log(arr);                    //[3]

同理利用这个特性可以实现shift，pop。

3.1 替换

可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。
例如，splice (2,1,"red","green")会删除当前数组位置 2 的项，然后再从位置 2 开始插入字符串"red"和"green"。

   var arr = [1,2,3];
   var spliceResult =  arr.splice(0,1,4);
   console.log(spliceResult);           //[1]
   console.log(arr);                    //[4,2,3]

数组的位置方法

1.indexOf()

2.lastIndexOf()

这两个方法都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中，indexOf()方法从数组的开头（位置 0）开始向后查找，lastIndexOf()方法则从数组的末尾开始向前查找。同样的如果又第二个参数的话，就相对于第二个参数向后查找（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 = [person];
    
    alert(people.indexOf(person));               //-1   
    //找不到是因为people数组中的对象虽然和person内容一样，但是两个仍然是不同的对象。
    //所以不满足全等条件，所以找不到。
    
    alert(morePeople.indexOf(person));           //0

end！