如何判断数组类型和数组的常见方法

let arr = [];

1、Array.isArray(arr)

2、Object.prototype.toString.call(arr) === '[object Array]'

3、arr.constructor === Array

4、Array.prototype.isPrototypeOf(arr)

5、Object.getPrototypeOf(arr) === Array.prototype

6、arr instanceof Array

instanceof 假定只有一个全局执行环境，如果网页中包含多个框架的话，比如iframe,存在两个以上不同版本的Array构造函数。Array.isArray可以解决这个问题

instanceof 和isPrototypeOf 用来判断原型链

arr instanceof Object // true

Object.prototype.isPrototypeOf(arr) // true

数组的创建方法

1.构造函数方式

const arr = new Array('red', 'blue')
const arr = new Array(3) // 创建length为3的包含3个空位的数组
空位不是undefined, 一个位置的值等于undefined依然是有值的。空位是没有值的，in运算符可以说明这一点
0 in [undefined, undefined] // true
0 in [,] // false
可以省略new

2. 数组字面量
const arr = []

如果数组中某一项是unll和undefined, 那么该值在join(),toSting(),toLocalString(), valueOf()
返回结果以空字符串表示
[null, undefined, 1].join() // ',,1'

Array.of用于将一组值转换为数组

Array.of() // []
Array.of(3)// [3]

function ArrayOf() {
    return [].slice.call(arguemnts)
}

数组的includes和indexOf

indexOf内部执行严格相等

[NaN].indexOf(NaN) // -1

[NaN].includes(NaN) // true

检测当前环境是否支持includes

const contains = (() => {
    Array.prototype.includes
        ? (arr, value) => arr.includes(value)
        : (arr, value) => arr.some(el => el === value)
})()

contains(['foo', 'bar'], 'bar')

栈是一种LIFO(Last-In-First-Out)后进先出的数据结构。

队列数据结构是FIFO(First-In-First-Out, 先进先出)。

数组的push和unshift可以操作多项,返回数组的长度

pop取最后一项，shite取第一项。返回取的那一项。

改变原数组

重排序方法sort和reverse

sort默认升序排列，调用每个数组项的toString()转型方法，然后比较得到的字符串。

sort传入一个比较函数compare.
第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回0，如果第一个参数应该位于第二个参数之后则返回一个正数。

// 升序
function compare(value1, value2) {
    if(value1 < value2) {
        return -1;
    } else if{value1 > value2} {
        return 1;
    } else {
        return 0;
    }
}

// 降序 
function compare(value1, value2) {
   if(value1 > value2) {
        return 1;
    } else if(value1 < value2) {
        return -1;
    } else {
        return 0;
    }
}

对于数值类型或者其valueOf（）方法会返回数值类型的对象类型，可以使用一个简单的比较函数
// 降序
function compare(value1, value2) {
    return value1 - value2
}

数组的操作方法

concat创建当前数组的一个副本，然后将接受到的参数添加到这个副本的末尾，最后返回新创建的数组。

如果含有引用类型的值会改变原数组

const colors = ['red', 'blue'];
const colors2 = colors.concat('yellow', ['black'])

原先的值保持不变
colors // ['red', 'blue']
colors2 // ['red', 'blue', 'yellow', 'black']

slice()基于当前数组中的一或多个项创建一个新数组。slice()可以接受一或两个参数，既要返回项的起始和结束位置（不包括结束位置的项）。不影响原数组

参数中有负数，则用数组的长度加上该数。若起始位置小于结束位置则返回空数组。

const colors = ['red', 'blue','yellow'];
const colors2 = colors.slice(1) // ["blue", "yellow"]
const colors3 = colors.slice(1,2) // ["blue"]

splice(起始位置， 删除几项，一个或者多个添加项。。。)。会改变原数组，返回一个数组，包含从原始数组中删除的项（如果没有删除任何项，则返回一个空数组）

const colors = ['red', 'blue','yellow'];
const removed = colors.splice(1,1, 'black', 'green')

colors // ['red', 'black', 'green', 'yellow']
removed // ['blue']

位置方法

indexOf()和lastIndexOf()接收两个参数：要查找的项和（可选）表示查找起点位置的索引。返回查找的项在数组中的位置。使用全等操作符，没找到返回-1

IE9+,Firefox2+,Safari3+,Opera 9.5+和chrome

const numbers = [1,2,3,4]
numbers.indexOf(1) // 0

迭代方法

接受两个参数，每一项上运行的函数和（可选的）运行该函数的作用域对象--影响this的值，函数中三个参数：数组项的值，该项在数组的位置和数组对象本身。

every

filter 返回数组

forEach 没有返回值

map 返回数组 如果含有引用类型的值会改变原数组

some

es5对空位的处理不一致，大多数情况下都会跳过空位

forEach(),filter(),every(),some()都会跳过空位

map()会跳过空位，但会保留这个值

join()和toString()会将空位视为undefined,而undefined和null会被处理为控制符传

forEach
[, 'a'].forEach((x, i) => console.log(i)) // 1

filter
['a', , 'b'].filter(x => true) // ['a', 'b']

every
[, 'a'].every(x => x === 'a') // true

some
[, 'a'].some(x => x !== 'a') // false

map
[, 'a'].map(x => 1) // ['', 1]

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

toString
[, 'a', undefined, null].toString() // ',a,,'

ES6则是明确将空位转为undefined

Array.form(['a', , 'b']) 
// ['a', undefined, 'b']

扩展运算符（...）
[...['a',, 'b']]
// ['a', undefined, 'b']

copyWithin()会连空位一起复制。
[, 'a', 'b', ,].copyWithin(2, 0) // [, 'a',,'a']

fill会将空位视为正常的数组位置
new Array(3).fill('a') // ['a', 'a', 'a']

for...of也会遍历空位

entries(),keys(),values(),find(),findIndex()会将空位处理成undefined

[, 'a'].find(x => true) // undefined

[...[,'a'].entries()] // [[0, undefined], [1, 'a']]

归并方法

reduce()和reduceRight(),接收两个参数，一个在每一项上调用的函数和（可选的）作为归并并基础的初始值。

函数接受4个值，前一个值，当前值，项的索引和数组对象。

这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。

var value = [1,2,3,4,5]
var sum = value.reduce(function(prev, cur, index, array) {
    return prev + cur
})
// 15

slice,contact,join不影响原来数组

arr.concat(arr2)

影响原数组的方法

push,pop,unshift,shift, sort,splice, reverse