JavaScript Array类型

JavaScript中，Array是最常用到的数据类型之一，属于引用类型中的一种。由于数组类型实在太常用而我记性又不是很好，就写一篇博文做个笔记。

数组特性：

可以通过以下方式来创建数组：

var students = new Array();    // 创建一个空数组
var students = new Array(5);   // 创建一个长度为5的数组
var students = new Array('paper', 'crane');  // 创建一个长度为2、初始值为paper，crane的数组
var students = Array(5);       // 创建一个长度为5的数组，也可省略初始长度
var students = Array('paper', 'crane');   // 创建一个长度为2、初始值为paper，crane的数组
// 使用数组字面量创建数组
var students = [];     // 创建空数组
var students = ['paper', 'crane'];   // 创建一个长度为2、初始值为paper、crane的数组

并且使用方括号来访问数组元素，而且，方括号里面的索引值不会有溢出的危险，当索引值实际大于数组长度，数组会自动新增，并将超出的数组元素的值设为undefined。同时，如果给一个超出数组范围的元素赋值，也不会报错，而是数组会扩展到相应的长度：

var arr = [0, 1, 2, 3];
alert(arr[0]);       // 0，通过方括号加索引值访问数组元素
alert(arr[5]);       // undefined，索引值超出数组长度范围
alert(arr.length);   // 4
arr[5] = 6;
alert(arr[5]);       // 6
alert(arr[4]);       // undefined
alert(arr.length);   // 6

至于检测数组的方法 点击这里查看

转换方法

所有的对象都具有toLocaleString()、toString()、valueOf()方法，不仅仅是数组对象。toString()方法返回一个由数组中的每个值拼接而成并且由逗号分隔的字符串，valueOf()返回的是一个数组，toLocaleString()返回的是由数组中每个元素的toLocaleString()方法返回的值拼接而成的并且由逗号分隔的字符串。join()方法接收一个参数，并以此参数作为分隔符来拼接数组元素的值，返回一个字符串，如果不传参数或参数为undefined，则以逗号分隔。

var colors = ['red', 'blue', 'green'];
alert(colors.toString());           // red,blue,green
alert(colors.toLocaleString());     // red,blue,green
alert(colors.valueOf());            // red,blue,green
alert(colors);                      // red,blue,green
alert(colors.join(','));            // red,blue,green
alert(colors.join('||'));           // red||blue||green
alert(colors.join());               // red,blue,green

排序方法

数组自带的排序方法为sort()；可以接收一个比较函数作为参数，如果省略参数，那么就会按照每个元素的toString()的返回值进行比较，所以结果总是不准确的。为了解决此问题，一般都会传入一个比较函数作为参数，但是在使用sort()方法的时候一定要确保调用的对象是数组，否则会报错。同时，数组还有一个reverse()方法，反转数组项顺序。

function compare(param1, param2) {
  // 若为正值，则返回真，此时需要交换两个数值的位置
  return param1 - param2;
}
var arr = [0, 7, 3, 9, 2, 8];
arr.sort(compare);
alert(arr);
arr.reverse();
alert(arr);

栈方法

push(param);往队尾添加param，该方法可接收0个或1至多个参数，返回数组的长度；

pop();此方法从队尾删除一项，返回被删除的项：

var arr = [0, 1];
arr.push(2, 3);
arr.push(5);
var temp = arr.push();
alert(temp);          // 5;
alert(arr)            // 0,1,2,3,5
temp = arr.pop();
alert(temp);          // 5
alert(arr);           // 0,1,2,3

队列方法

unshift(param); 此方法在数组前端推入参数param，可接收0至多个参数；

shift(); 此方法从数组前端删除一项，返回此项；

var arr = [0, 1];
arr.unshift(-2, -1);
arr.unshift(-3);
var temp = arr.unshift();
alert(temp);      // 5;
alert(arr);       // -3,-2,-1,0,1
temp = arr.shift();
alert(temp);      // -3
alert(arr);       // -2,-1,0,1

操作方法

concat(); 次方法可以基于当前数组中的所有项创建一个新的数组。具体来说，这个方法会先创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回这个新构建的数组。此方法不影响原数组。

slice(); 此方法可以接收一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。此方法不影响原数组。

splice();此方法可以接收0至多个参数。0个参数时，无操作；接收1个参数时，将索引为参数至数组末尾的项删除，若该参数为负数，则将其加上数组长度，加上数组长度依然负数时，将默认为0，若参数大于等于数组长度时，则无操作；接收两个参数时，第一个参数为开始删除的项，第二个参数（number类型）为需要删除的项的数目；接收多于两个参数的时（如果第二个参数是number类型，会执行第二步操作的同时），会将第三个参数及之后的参数插入第一个参数指定的位置。此方法会影响当前数组。

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

var colors3 = colors.slice(1);
var colors4 = colors.slice(1, 2);

alert(colors3);     // green,blue
alert(colors4);     // green

var removed = colors.splice(0, 1);
alert(colors);      // green,blue
alert(removed);     // red

removed = colors.splice(1, 0, 'yellow', 'orange');
alert(colors);      // green,yellow,orange,blue
alert(removed);     // 空数组

removed = colors.splice(1, 1, 'red', 'purple');
alert(colors);      // green,red,purple,orange,blue
alert(removed);     // yellow 此数组只包含一项

位置方法

indexOf(param);此方法从数组的开头（位置0开始向后查找param，也可传入第二个参数，作为指定开始向后查询的位置）；

lastIndexOf();此方法从数组的末尾开始向前查找。

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: 'paper_crane'};
var people = [{name: 'paper_crane'}];

var morePeople = [person];

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

迭代方法

every(); 对数组中的每一项运行给定的函数，如果该函数对每一项读返回true，则返回true。

filter(); 对数组中的每一项运行给定的函数，返回该函数会返回true的项组成的数组。

forEach(); 对数组中的每一项运行给定的函数，此方法没有返回值。

map(); 对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

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

var mapArr = numbers.map(function(item, index, array) {
  return index;
});

alert(mapArr);                 // 0,1,2,3,4,5,6,7,8

var filterArr = numbers.filter(function(item, index, array) {
  if (item > 2) {
    return item;
  }
});

alert(filterArr);              // 3,4,5,4,3

numbers.forEach(function(item, index, array) {
  item += 1;                   // 对原元素没有影响
  array[index] += 1;           // 数组中的每一元素加1
});

alert(numbers);                // 2,3,4,5,6,5,4,3,2

归并方法

reduce(); 此方法会迭代数组的所有项，然后构建一个最终返回的值，此方法是从数组的第一项开始逐步遍历到最后；

reduceRight(); 次方法和reduce()方法一样，但是是从末尾迭代到第一项。

var numbers = [1, 2, 3, 4, 5];

var sum1 = numbers.reduce(function(prev, cur, index, array) {
  return prev + cur;
});

alert(sum1);           // 15

var sum2 = numbers.reduceRight(function(prev, cur, index, array) {
  return prev + cur;
});

alert(sum2);