JavaScript权威指南之数组

创建数组

1.数组字面量

var arr = [1,2,3];

2.使用构造函数Array（创建的数组是稀疏数组，后面解释）

var arr = new Array(10);

数组元素的读和写

1.数组是属于特殊对象。
2.如果属性是数组的索引，那么数组将会更新其length。
3.如果使用非数字或者负数来索引数组，那么数值会转换为非数组索引，当做常规对象的属性。
4.数组的索引属于对象属性名的一种特殊形式。

a[-1.23] = true;  //数组拥有"-1.23"这个属性
a["1000"] = 0;    //数组的索引
a[1.0000] = 0;    //等同于a[1]

稀疏数组

1.稀疏数组就是索引从0开始不连续的数组。
2.可以通过new Array(n)来创建稀疏数组。
3.可以通过delete数组某个索引得到稀疏数组。

empty代表不存在的值

var arr = [,,,];  //(3) [empty × 3]
var arr1 = new Array(3);  //(3) [empty × 3]
0 in arr; //false
0 in arr1; //false

var arr2 = [undefined, undefined, undefined]  //(3) [undefined, undefined, undefined]
0 in arr2; //true

所以值不存在和值为undefined是不一样的。
重点：如果对索引数组进行遍历，不存在的索引不会被遍历到。

数组长度

数组有length属性，代表数组的元素个数。
稀疏数组，数组的length大于数组元素的个数。

var arr = [1,2,3];
Object.defineProperty(arr, 'length', {
		writable: false
	}
);		

改变数组的length，那么就不能对数组进行增删，只能改变已有元素的值。

数组元素的增删

增加元素：push，unshift，返回的数组的长度

var arr = [];
arr.push(10);   //返回1（数组长度） 
arr.unshift(20);   //返回2 (数组长度）

删除元素：pop，shift，返回的被删除元素

var arr = [1,10,100];
arr.pop();   //返回100        
arr.shift();   //返回1

当然，数组也是对象，也可以使用delete操作符对数组元素进行删除，但是和上面两个方法不同的是，删除后数组长度不变，相当于变成稀疏数组。
splice方法也能够删除元素，请接着往下看。

多维数组

数组中元素也是数组

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

数组方法

1.Array.join()：不改变原数组
参数：传入作为字符串为分隔符，默认为“，”

var arr = [1,2,3]
arr.join(); //"1,2,3"
arr.join("-"); //"1-2-3"

Strings.split()的逆向操作；
2.Array.reverse() ：会改变原数组

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

var arr = ['a','b','c'];
arr.reverse(); //["c","b","a"]

3.Array.sort()：会改变原数组
当参数为空的时候，按照字母表顺序来排序
当参数为函数的时候，返回大于0是升序，返回小于是降序

var arr = [2,1,3];
arr.sort(); //[1,2,3]

arr.sort((a,b) => a-b);  //[1,2,3]
arr.sort((a,b) => b-a);  //[3,2,1]

4.Array.concat()：不会改变原数组

var arr = [1,2,3];
arr.concat(4,5);  //[1,2,3,4,5]
arr.concat(6,7]); //[1,2,3,4,5,6,7]

5.Array.slice()：不会改变原数组
参数：起始索引，结束索引(如果索引为负数，那就加上数组的length）
返回子数组

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

5.Array.splice()：会改变原数组
第一个参数表示插入或者删除元素的索引
第二个参数表示从指定索引删除多少个元素
后续参数表示从指定索引插入传入的参数

var arr = [1,2,3,4,5];
arr.splice(1,2,'a','b'); //[1,'a', 'b', 4, 5]

6.toString()方法
将每个元素转换为字符串，(如有必要将调用每个元素的toString方法）并且输出用逗号分隔的字符串列表。

[1,2,3].toString(); //1,2,3
[1,[2,3],4].toString(); //1,2,3,4

ES5数组方法

1.forEach()
参数：函数（数组元素，数组元素索引，数组本身）

var arr = ['a', 'b', 'c'];
arr.forEach((item, index, self) => {});

forEach方法无法在所有元素传递给调用函数之前提前终止。
2.map()
参数：函数（数组元素，数组元素索引，数组本身）
传入的参数函数必须要有返回值
返回的新数组和原数组的长度相同

var arr = [1,2,3];
arr.map((item, index, self) => item * 2); //[2,4,6]

如果数组是稀疏数组，那么返回的数组也是稀疏数组
3.filter()
参数：函数（数组元素，数组元素索引，数组本身）
传入的参数函数返回true或者false,将返回的true的值过滤出来返回一个新数组

var arr = [1,2,3,4];
arr.filter((item, index, self) => item > 2); //[3,4]

4.every()
参数：函数（数组元素，数组元素索引，数组本身）
当且仅当所有元素传入函数并且能够返回true才会返回true，如果一旦有一个返回false，那就返回false
如果一旦某个元素返回false，那么就停止遍历后面的元素

var arr = [1,2,3,4];
arr.every(item => item > 0);  //true
arr.every(item => item > 1);  //false

5.some()
参数：函数（数组元素，数组元素索引，数组本身）
当有元素传入函数并且能够返回true就会返回true，如果全部元素传入函数都返回false，那就返回false
如果一旦某个元素返回true，那么就停止遍历后面的元素

var arr = [1,2,3,4];
arr.some(item => item > 3);  //true
arr.some(item => item > 4);  //false
arr.every(item => item > 1);  //false

5.reduce()和reduceRight()
第一个参数：函数，函数参数（默认值，第一个元素，第一个元素索引，数组本身）
第二个参数：传入第一个函数第一个参数的默认值

如果第二个参数没给，那默认值就是数组第一个元素
函数参数为（第一个元素，第二个元素，第二个元素索引，数组本身）
函数返回的值将作为下一个遍历的默认值

var arr = [1,2,3,4];
arr.reduce((res,item) => res + item), 5); //15

reduceRight()和reduce()的区别就是数组索引从高到低处理。
6.indexOf()和lastIndex0f()
indexOf正向搜索给定的值，如果存在返回匹配到第一个元素的索引，否则返回-1。
lastIndexOf()反向搜索。

判断是否为数组

Array.isArray(arr);

//isArray函数本质上内部就是这么判断
Object.prototype.toString.call(arr) === '[object Array]'

类数组对象

.类数组对象不能直接使用Array.prototype上的方法
1.将类数组对象转换为数组，那就可以使用数组原型上的方法
2.改变数组原型上方法this的指向
Array.prototype.slice.call(arr);

作为数组的字符串

var str = 'xiaoming';
str[1] = 'i';
str.charAt(1); //'i'

字符串虽然可以像数组一样用索引访问元素，但是没有数组原型上的方法。