JavaScript Array

数组对象用来在单独的变量名中存储一系列的值。在JavaScript中我们有且仅能使用关键词 new 来创建数组对象。

一、仅有以下2种方式来创建数组

（1）先声明数组后赋值。

var myArray = new Array();
console.log(myArray.length); //输出0
myArray[0] = 'China';
myArray[1] = 'America';
myArray[2] = 'Japan';
//输出 [ 'China', 'America', 'Japan' ]

也可以使用一个整数来控制数组的容量：

var myArray = new Array(3);
console.log(myArray.length); //输出3
//输出 [ , , , ]
myArray[0] = 'China';
myArray[1] = 'America';
myArray[2] = 'Japan';
//输出 [ 'China', 'America', 'Japan' ]

（2）在声明数组时直接定义其初始值。

如果声明数组时括号内的变量不止一个或不是整数，那么就不是数组容量，而是直接定义数组内的变量了。
也可以直接使用方括号初始化数组变量。

var myArray1 = new Array(1,2,3);
//输出 [ 1, 2, 3 ]
var myArray2 = [1, 2, 3];
//输出 [ 1, 2, 3 ]
var myArray3 = new Array('1');
//输出 [ 1 ]

二、访问数组

通过指定数组名以及索引号码，你可以访问某个特定的元素。

即使数组下标越界也不会报错，只会返回 undefined。

var myArray = new Array(1,2,3); // [ 1, 2, 3 ]
myArray[0]; // 1
myArray[3]; // undefined, 在打印数组时会被显示为空串

三、修改数组中已有的值

如需修改已有数组中的值，只要向指定下标号添加一个新值即可。

JavaScript是弱类型的，数组中的所有变量类型都为var，所以在一个数组中可以同时出现诸如 “string” 和 “int”，之类不同类型的值。

如果下表越界，则会将超出部分至该位置之前的值全部定义为空（这里既不是undefined，也不是null，也不是”）。

var myArray = new Array('China', 'America', 'Japan'); 
myArray[0] = 0; 
myArray[4] = 4;
//输出 [ 0, 'America', 'Japan', , 4 ]

四、添加元素

（1）直接添加

var arr = [1,2,3];
arr[5] = 0;
console.log(arr);
//输出 [ 1, 2, 3, , , 0 ]

（2）push([item1 [item2 [… [itemN ]]]]) 将一个或多个新元素添加到数组结尾，并返回数组新长度。

var arr = [1,2,3];
arr.push('x', 'y', 'z');
//输出 6
console.log(arr);
//输出 [ 1, 2, 3, 'x', 'y', 'z' ]

（3）unshift([item1 [item2 [… [itemN ]]]]) 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度。

var arr = [1,2,3];
arr.unshift('x', 'y', 'z');
//输出 6
console.log(arr);
//输出 [ 'x', 'y', 'z', 1, 2, 3 ]

（4）splice(pos,count,[item1[, item2[, … [,itemN]]]]);//将零个、一个或多个新元素插入到数组的pos位置，同时删除插入位置后count个元素（包括原插入位置的元素），然后将插入位置的元素自动后移，返回被删除的数组。

var arr = [1,2,3,4,5];
arr.splice(1, 0, 'm');
//输出 []
console.log(arr);
//输出 [ 1, 'm', 2, 3, 4, 5 ]
arr.splice(1, 3, 'x', 'y', 'z');
//输出 [ 'm', '2', '3' ]
console.log(arr);
//输出 [ 1, 'x', 'y', 'z', 4, 5 ]

五、删除元素

（1）pop 移除最后一个元素并返回该元素值。

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

（2）shift 移除最前一个元素并返回该元素值，数组中元素自动前移。

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

（3）splice(pos,count,[item1[, item2[, … [,itemN]]]]);//将零个、一个或多个新元素插入到数组的pos位置，同时删除插入位置后count个元素（包括原插入位置的元素），然后将插入位置的元素自动后移，返回被删除的数组。

var arr = [1,2,3,4,5];
arr.splice(1, 1);
//输出 [ 2 ]
console.log(arr);
//输出 [ 1, 3, 4, 5 ]
arr.splice(1, 3, 'x', 'y', 'z');
//输出 [ 3, 4, 5 ]
console.log(arr);
//输出 [ 1, 'x', 'y', 'z' ]

六、for……in 循环输出数组中的元素

var myArray = new Array(1,2,3);
for(var value in myArray) {
    console.log(value);
}

七、将数组的元素组成字符串

使用 join( [ separator ] )，separator 默认为逗号(，)。
toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用

var myArray = new Array(1,2,3,undefined,4);
myArray.join();      //输出 '1,2,3,,4' 
myArray.join('-');   //输出 '1-2-3--4'
myArray.join('-*-'); //输出 '1-*-2-*-3-*--*-4'
myArray.toString();  //输出 1,2,3,,4
myArray.toLocaleString(); //输出 1,2,3,,4

八、合并两个数组

使用 arrayA.concat( arrayB ) 方法来合并两个数组，合并操作不会修改原数组。

var arrayA = new Array(1,2,3);
var arrayB = new Array();
arrayB[0] = 'a';
arrayB[1] = 'b';
arrayB[2] = 'c';
arrayA.concat(arrayB);
//输出 [ 1, 2, 3, 'a', 'b', 'c' ], 该操作只会生成一个新数组, 并不会修改原先的数组
//arrayA = [ 1, 2, 3]
//arrayB = [ 'a', 'b', 'c']

九、截取数组的一部分

slice(start, [end]) 以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素。

该操作返回一个新的数组，并不会修改原来的数组。

var arr = [ 1, 2, 3, 4, 5 ];
arr.slice(2);
//输出 [3, 4, 5 ]
arr.slice(2, 4);
//输出 [ 3, 4 ]
console.log(arr);
//输出 [ 1, 2, 3, 4, 5]

十、数组排序

使用 sort( [ function ] )，sort 默认按ASCII码进行排序。

sort 会直接改变数组中的元素排列方式

（1）纯数字的情况

var numArray = [1, 999, 123, 55, -30];
numArray.sort();
//输出 [ -30, 1, 123, 55, 999 ]
numArray.sort(function(a, b){
//在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
    return a-b;
});
//输出 [ -30, 1, 123, 55, 999 ]
numArray.sort(function(a, b){
    return b-a;
});
//输出 [ 999, 123, 55, 1, -30 ]

（2）混合基本变量的默认排序方式（前2个比较方式均是错误的）

var myArray = ['bob', 'America', , undefined, 'Tina', 'China', 1, '=', '3', true ];
myArray.sort(function(a, b){
//当不是数字时，根本无法适用于减号('-')操作符，所以返回0，不进行排序
    return a-b;
});
// 输出 ['bob', 'America', true, 'Tina', 'China', 1, '=', '3', undefined, ]
myArray.sort(function(a, b){
    return b-a;
});
// 输出 [ 'bob', 'America', true, 'Tina', 'China', 1, '=', '3', undefined, ]
myArray.sort();
// 输出 [ true, 1, '3', '=', 'America', 'China', 'Tina', 'bob', undefined, ], 两个不可比较的数字, JS默认会按照ASCII码进行排序。

（3）混合基本变量的自定义排序方式

var myArray = ['bob', 'America', undefined, , 'Tina', 'China', 1, '=', '3', true ];
var sortFunc = function(reverse) {
    return function(a, b) {
    /*
    根据我的测试,这一段可以不要,因为undefined和(空)根本不会进入比较。
        if(!a && !b) {
            return 0;
        }
        if(a && !b) {
        console.log('a && !b');
            return reverse ? -1 : 1;
        }
        if(!a && b) {
        console.log('!a && b');
            return reverse ? 1 : -1;
        }
    */
        if(typeof a === typeof b) {
            if(reverse) {
                return a > b ? -1 : 1;
            }
            return a < b ? -1 : 1;
        }
        if(reverse) {
            return typeof a > typeof b ? -1 : 1;
        }
        return typeof a < typeof b ? -1 : 1;
    };
};
myArray.sort(sortFunc(false));
//输出 [ true, 1, '3', '=', 'America', 'China', 'Tina', 'bob', undefined, ]
myArray.sort(sortFunc(true));
//输出 [ 'bob', 'Tina', 'China', 'America', '=', '3', '1', true, undefined, ]

（4）JSON对象的自定义排序方式

var employees=[]
employees[0]={name:"Bob", age:32}
employees[1]={name:"Tina", age:17}
employees[2]={name:"Bob", age:62}
employees[3]={name:"Tom", age:58}
var sortBy = function(major, minorFunc) {
    return function(a, b) {
        if(typeof a === 'object' && typeof b === 'object') {
            var nameA = a[major];
            var nameB = b[major];
            if(nameA === nameB) {
                return typeof minorFunc === 'function' ? minorFunc(a,b) : 0;
            }
            if(typeof nameA === typeof nameB) {
                return nameA < nameB ? -1:1;
            }
            return typeof nameA < typeof nameB ? -1 : 1;
        }
        return 0;
    };
};
employees.sort(sortBy('name',sortBy('age')));
/*
输出
[ { name: 'Bob', age: 32 },
  { name: 'Bob', age: 62 },
  { name: 'Tina', age: 17 },
  { name: 'Tom', age: 58 } ]
*/

十一、反转数组元素

reverse() 会直接修改数组中的元素排列方式

var arr = [1,2,3];
arr.reverse();
//输出 [ 3, 2, 1 ]