Js学习（6） 标准库-Array对象

Array是Js的原生对象，同时也是一个构造函数，可以用它生成新的数组

用不用new结果都一样

var arr = new Array(2);
// 等同于
var arr = Array(2);

但是Array作为构造函数，行为很不一致，因此不建议使用它生成新数组，直接使用数组字面量是更好的方法

静态方法　

Array.isArray():返回一个布尔值，表明参数是否为数组，可以弥补typeof运算符的不足

实例方法　

valueOf():所有对象都有的方法，表示对该对象求值，数组里的返回数组本身

toString():也是通用方法，数组中返回数组的字符串形式

push():在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度

pop():删除数组的最后一个元素，并返回该元素

push，pop   栈

对空数组使用pop方法，不会报错，而是返回undefined

shift():删除数组的第一个元素，并返回该元素。

shift()方法可以遍历并清空一个数组，前提是元素不为0或任何布尔值为false的元素

push,shift   队列

unshift():在数组的第一个位置添加元素，并返回添加新元素后的数组长度，可接受多个参数

join():以指定参数作为分隔符，将所有数组成员连接为一个字符串返回，如果不提供参数，默认用逗号分隔，如果数组成员是undefined或null或空位，会被转成空字符串。

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

a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"

[undefined, null].join('#')
// '#'

['a',, 'b'].join('-')
// 'a--b'

通过call方法，这个方法也可以用于字符串或类似数组的对象

Array.prototype.join.call('hello', '-')
// "h-e-l-l-o"

var obj = { 0: 'a', 1: 'b', length: 2 };
Array.prototype.join.call(obj, '-')
// 'a-b'

concat():用于多个数组的合并。将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变

除了数组作为参数，concat也接受其他类型的值作为参数，添加到目标数组尾部

[1, 2, 3].concat(4, 5, 6)
// [1, 2, 3, 4, 5, 6]

如果数组成员包括对象，concat方法返回当前数组的一个浅拷贝，即一个引用 所以更改原对象，也会带来新数组的改变

reverse():颠倒排列数组元素，返回改变后的数组

slice(start ,end):用于提取目标数组的一部分，返回一个新数组，原数组不变，左闭右开

start以0开始，end默认为最后一个

如果slice方法的参数是负数，则表示倒数计算的位置

var a = ['a', 'b', 'c'];
a.slice(-2) // ["b", "c"]
a.slice(-2, -1) // ["b"]
上面代码中，-2表示倒数计算的第二个位置，-1表示倒数计算的第一个位置。

如果第一个参数大于等于数组长度，或第二个参数小于第一个参数，返回空数组

slice方法的一个重要应用，是将类似数组的对象转为真正数组

Array.prototype.slice.call({ 0: 'a', 1: 'b', length: 2 })
// ['a', 'b']

Array.prototype.slice.call(document.querySelectorAll("div"));
Array.prototype.slice.call(arguments);
上面代码的参数都不是数组，但是通过call方法，在它们上面调用slice方法，就可以把它们转为真正的数组。

　

splice()方法用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是被删除的元素。该方法会

改变原数组。

使用如下：

arr.splice(start, count, addElement1, addElement2, ...);
//第一个参数是删除的起始位置（从0开始），然后是要删除元素的个数，接着的参数个数
//任意，为要插入数组的值

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2, 1, 2);                           //删除 ["e", "f"]，插入1,2
a                                                    // 结果["a", "b", "c", "d", 1, 2]

起始位置如果是负数，表示从倒数位置开始删除
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(-4, 2)                                                    // 删除["c", "d"]

如果只是单纯地插入元素，第二个参数可以设为0
如果只提供第一个参数，等于将原数组在指定位置拆分成两个数组

　　

sort()方法

对数组成员进行排序，默认按照字典顺序排序，排序后，原数组将被改变

如果想让sort方法按照自定义方式排序，可以传入一个函数作为参数

[10111, 1101, 111].sort(function (a, b) {
  return a - b;
})
//排序结果： [111, 1101, 10111]
//如果比较函数的返回值大于0，表示第一个成员排在第二个成员后面
//其他情况下，都是第一个元素排在第二个元素前面

　　

map函数()

将数组的所有成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回，原数组不变

var numbers = [1, 2, 3];

numbers.map(function (n) {
  return n + 1;
});
// 返回数组[2, 3, 4]

map方法还可以接受第二个参数，用来绑定回调函数内部的this变量
var arr = ['a', 'b', 'c'];

[1, 2].map(function (e) {
  return this[e];
}, arr)
// ['b', 'c']

map方法可以接受一个函数作为参数，该函数调用时，map方法向它传入三个参数：当前成员
当前位置和数组本身

[1, 2, 3].map(function(elem, index, arr) {
  return elem * index;
});
// [0, 2, 6]

map方法不会跳过undefined和null，但是会跳过空位

var f = function (n) { return 'a' };

[1, undefined, 2].map(f) // ["a", "a", "a"]
[1, null, 2].map(f) // ["a", "a", "a"]
[1, , 2].map(f) // ["a", , "a"]

　

forEach()方法

与map方法用法规则相似，但它不返回值，只用来操作数据，总会将所有成员遍历完

filter()方法

用于过滤数组成员，满足条件的成员组成一个新数组返回

用法和之前的函数类似，可以自定义筛选函数

参数函数可以有三个参数：元素，下标，数组

还可以接受第二个参数，用来绑定this变量

[1, 2, 3, 4, 5].filter(function (elem, index, arr) {
  return index % 2 === 0;
});
// [1, 3, 5]

var obj = { MAX: 3 };
var myFilter = function (item) {
  if (item > this.MAX) return true;
};
var arr = [2, 8, 3, 4, 1, 3, 2, 9];
arr.filter(myFilter, obj) // [8, 4, 9]

　

some(),every()　

返回一个布尔值，表示判断数组成员是否符合某种条件

接受一个函数作为参数，函数接受那三个参数，返回布尔值，还可以接受第二个参数，用法同上面几个函数

some是只要一个成员满足条件即为true

every是要求所有

对于空数组，some返回false，every返回true，回调函数都不会执行

var arr = [1, 2, 3, 4, 5];
arr.some(function (elem, index, arr) {
  return elem >= 3;
});
// true
arr.every(function (elem, index, arr) {
  return elem >= 3;
});
// false

reduce(),reduceRight()

依次处理数组的每个成员，最后累计为一个值

reduce是从左到右处理

reduceRight是从右到左处理

reduce方法第一个参数是一个函数，接受以下参数

累积变量，默认为数组的第一个成员

当前变量，默认为数组的第二个成员

当前位置（从0开始）

原数组　

第二个参数可以用来指定初值

[1, 2, 3, 4, 5].reduce(function (a, b) {
  return a + b;
}, 10);
// 25

　　

indexOf，lastIndexOf

indexOf方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1

lastIndexOf返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1

但这两个方法无法确定数组成员中NaN的位置

（因为函数内部用严格相等运算符===来进行比较，而NaN是唯一一个不等于自身的值）

可以链式使用这些数组方法