标准库-Array

• 静态方法

1. Array.isArray()
   Array.isArray()方法返回一个布尔值, 表示参数是否为数组. 它可以弥补typeof运算符的不足.

let arr = [1,2]
typeof arr // "object"
Array.isArray(arr) // true

上面例子中,typeof运算符只能显示数组的类型是object, 而Array.isArray()方法可以识别数组.

• 常用实例方法

1. join()
   join()方法以指定参数为分隔符, 将所有的数组成员连接成一个字符串返回. 如果不提供参数, 默认用逗号分隔.

let arr = [1,2,3]
arr.join(' ') // '1 2 3'
arr.join('|') // '1|2|3'
arr.join() // '1,2,3'

如果数组成员是undefined或null或空位, 会被转成空字符串.

[undefined,null].join('$') // '$'
['a',,'b'].join() // 'a,,b'

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

Array.prototype.join.call('hello', '-') // 'h-e-l-l-o'
let obj = {'0': 'a', '1': 'b', length: 2}
Array.prototype.join.call(obj, '-') // 'a-b'

2. concat()
   concat()方法用于多个数组的合并. 它将新数组的成员, 添加到原数组成员的后面, 然后返回一个新数组, 原数组不变.

['hello'].concat(['world']) // ['hello', 'world']
[1].concat([2], [3]) // [1,2,3]

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

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

如果数组成员包含对象, concat方法返回当前数组的一个浅拷贝, 浅拷贝指的就是新数组拷贝的是对象的引用.

let obj = {a: 0}
let arr = [obj]
let newArr = arr.concat()
obj.a = 1
newArr[0].a // 1

上面代码中, 原数组成员包含一个对象, concat方法生成新数组包含这个对象的引用. 所以, 改变原对象以后, 新数组成员跟着改变.

3. reverse()
   reverse方法用于翻转数组元素, 返回改变后的数组, 注意, 该方法改变原数组.

let a = ['a', 'b', 'c']
a.revere() // ['c', 'b', 'a']
a // ['c', 'b', 'a']

4. slice()
   slice方法用于提取目标数组的一部分, 返回一个新数组, 原数组不变.

arr.slice(start,end) // 含前不含后, start从0开始

注意, 如果省略第二个参数, 则一直返回到原数组的最后一个元素.

let arr = [1,2,3]
arr.slice(0) // [1,2,3]
arr.slice(1) // [2,3]
arr.slice(1,2) // [2]
arr.slice(2,6) // []
arr.slice() // [1,2,3]

上面代码中, 最后一个例子slice没有参数, 实际上等于返回一个原数组的拷贝.
如果第一个参数大于等于数组的长度, 或者第二个参数小于第一个参数, 则返回空数组.

let a = [1,2,3]
a.slice(4) // []
a.slice(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方法, 就可以把它们转为真正的数组.

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

arr.splice(start, count, addElement1, addElement2,...)

splice的第一个参数是删除的起始位置(从0开始), 第二个参数是被删除元素的个数. 如果后面还有更多的参数, 则表示这些就是在该位置被插入的新数组元素.

let arr = [1,2,3,4,5,6]
arr.splice(4,2) // [5,6]
arr // [1,2,3,4]

上面代码从原数组第5个位置开始, 删除两个数组元素.

let arr = [1,2,3,4,5,6]
arr.splice(4,2,1,1) // [5,6]
arr // [1,2,3,4,1,1]

上面代码中, 删除了两个数组元素, 同时还添加了两个新数组成员.

起始位置如果是负数, 就表示从倒数位置(倒数从-1开始)开始删除.

let arr = [1,2,3,4,5,6]
arr.splice(-4,2) // [3,4]
arr // [1,2,5,6]

如果只是单纯的插入元素, splice方法的第二个参数可以设为0.

let arr = [1,1,1]
arr.splice(1,0,2) // []
arr // [1,2,1,1]

如果只提供第一个参数, 等同于将原数组在指定位置拆成两个数组.

let arr = [1,2,3,4]
arr.splice(2) // [3,4]
arr // [1,2]

6.sort()
sort方法对数组成员进行排序, 默认按照字典顺序排序. 排序后, 原数组将被改变.

['d','c','b','a'].sort() // ['a','b','c','d']
[4,3,2,1].sort() // [1,2,3,4]
[11,101].sort() // [101,11]
[1011,1101,111].sort() // [1011,1101,111]

sort方法不是按照大小排序, 而是按照字典排序. 也就是说, 数值会先被转成字符串, 在按照字典顺序排序, 所以101排在11前面.

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

[10111,1101,111].sort((a,b) => a - b) // [111,1101,10111]

let arr = [{name: '1',age: 8},{name: '2', age: 7}]
  .sort((a,b) => a.age - b.age)
console.log(arr) // 按age大小排序

7. map()
   map方法将数组的所有成员依次传入参数函数, 然后把每一次的执行结果组成一个新数组返回.

let arr = [1,2,3]
arr.map(item => item*2) // [2,4,6]
arr // [1,2,3]

上面代码中, arr数组的所有成员依次执行参数函数, 运行结果组成一个新数组返回, 原数组没有变化.
map方法接受一个函数作为参数. 该函数调用时, map方法向它传入三个参数: 当前成员, 当前位置和数组本身

// map源码
Array.prototype.myMap = function(fn) {
  let newArr = []
  for(let i=0;i<this.length;i++){
    let result = fn(this[i],i,this)
    newArr[i] = result
  }
  return newArr
}
let a = [1,2,3].myMap(function(item,index) {
  return item*index
})
console.log(a) // [0,2,6]

map方法还可以接受第二个参数, 用来绑定回调函数内部的this变量.

let arr = ['a','b','c']
[1,2].map(item => this[item],arr) // ['b','c']

上面代码通过map方法的第二个参数, 将回调函数内部的this指向了arr数组.
如果数组有空位, map方法的回调函数在这个位置不会执行, 会跳过数组的空位.

let f = n => '#'
[1,undefined,2].map(f) // ['#','#','#']
[1,,2].map(f) // ['#',,'#']

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