数组集结号

准备把数组相关的方法和内容总结一下。

Array类型：数组的每一项可以保存任何类型的数据。

数组包含的属性和方法如下：

接下来我会一一总结。

1、创建数组的基本方式有三种：

1.1、使用Array构造函数

let arr1 = new Array()    // 创建一个空数组 []
let arr2 = new Array(3)  // 创建一个长度为3的空数组 
let arr3 = new Array('blue','green','yellow') // 创建一个['blue','green','yellow']的数组

在使用Array构造函数时，也可以不用new

let arr1 = Array()    // 创建一个空数组 []
let arr2 = Array(3)  // 创建一个长度为3的空数组 
let arr3 = Array('blue','green','yellow') // 创建一个['blue','green','yellow']的数组

1.2、使用数组字面量表示法

let arr4 = []    // 创建一个空数组 []
let arr5 = [,,,]  // 创建一个长度为3或者4的空数组  注：在IE8及IE8以下长度为4，其他浏览器为长度为3
let arr6 = ['blue','green','yellow'] // 创建一个['blue','green','yellow']的数组

1.3、使用Array.of()

Array.of方法用于将一组值，转换为数组。

Array.of(3, 11, 8) // [3,11,8]
Array.of() // 生成一个空数组 []
Array.of(3) // [3]      对比 Array(3) 创建一个长度为3的空数组
Array.of(3).length // 1

这个方法的主要目的，是弥补数组构造函数Array()的不足。因为参数个数的不同，会导致Array()的行为有差异。

2、检测数组：

2.1、使用instanceof操作符

[1,2,3] instanceof Array // true

instanceof适用于只有一个全局执行环境，如果网页中包含多个框架，那就存在多个执行环境，从而存在不同版本的Array的构造函数。为了解决这个问题，ES5新增了Array.isArray()。

2.2、使用Array.isArray()

这个方法的目的是最终确定某个值到底是不是数组，而不管它是在哪个环境创建的。

Array.isArray([1,2,3])// true

2.3、使用Object.prototype.toString

这个方法能够准确地判断一个值的数据类型，vue中的源码中就是用这种方法来判断数据类型的，也是我推荐并经常使用的。

let dataType = Object.prototype.toString.call([1,2,3])// [object Array]
dataType.slice(8,-1) //  Array

// 下面是vue源码中做数据判断的写法
  /**
   * Get the raw type string of a value, e.g., [object Object].  获取值的原始类型字符串，例如[object object]。
   */
var _toString = Object.prototype.toString;

function toRawType (value) {
  return _toString.call(value).slice(8, -1)
}

3、转换方法：

3.1、使用toString()

使用这个方法使数组转化为以逗号分割的字符串

[1,2,3].toString() // "1,2,3"

3.2、使用valueOf()

使用这个方法返回的还是数组本身

let array1 = [1,2,3]
array1 === array1.valueOf() // true

3.3、使用join()

使用这个方法把数组转化为字符串，是我们经常用到的一种方法，join(string)只接收一个参数，即用作分隔符的字符串，如果不传值或者传入的是undefined，则使用逗号作为分隔符。

[1,2,3].join() // "1,2,3"
[1,2,3].join(undefined) // "1,2,3"
[1,2,3].join("||") // "1||2||3"

如果数组中有一项的值是null或者是undefined，那么该值就在join()、toLocaleString()、toString()方法返回的结果中以空字符串表示，valueOf()还是返回自身。

[null,undefined,3].join() // ",,3"
[null,undefined,3].toString() // ",,3"
[null,undefined,3].valueOf()  // [null, undefined, 3]

4、栈方法：

栈是一种LIFO(Last-In-First-Out,后进先出)的数据结构，也就是最新添加的项最早被移除。而栈中项的插入（也叫推入）和移除（叫做弹出），只发生在一个位置----栈的顶部。数组中的push()和pop()，实现了类似栈的行为。

4.1、push()

push()方法可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回数组的长度，并且会改变数组本身。

let num = new Array();
let numLength = num.push(1,2,3,4,5,6,7,8,9) // 返回的是添加之后数组的长度，并且会改变数组本神
numLength // 9
num // [1, 2, 3, 4, 5, 6, 7, 8, 9]
let animals = ['dog']
animals.push('cat','bird')
animals  // ["dog", "cat", "bird"]

4.2、pop()

pop()方法没有参数，用于从数组末尾移除最后一项，减少数组的length值，然后返回移除的项，并且会改变数组本身。

let num = [1, 2, 3, 4, 5, 6];
let numItem = num.pop();
numItem // 6
num // [1, 2, 3, 4, 5]

let animals = ["dog", "cat", "bird"]
let animalsItem = animals.pop();
animalsItem // bird
animals // ["dog", "cat"]

5、队列方法：

队列数据结构的访问规则是FIFO(First-In-First-Out，先进先出)，队列在列表的末端添加项，从列表的前端移除项。push()是向数组末端添加项的方法，shift()是从数组前端取得项的方法，它能够移除数组中的第一项并返回该项，同时将数组长度减1。结合使用shift()和push()方法，可以像使用队列一样使用数组。

5.1、shift()

shift()方法没有参数，用于从数组前面移除第一项，减少数组的length值，然后返回移除的项，并且会改变数组本身。

let num = [1, 2, 3, 4, 5, 6];
let numItem = num.shift();
numItem // 1
num // [2, 3, 4, 5, 6]

let animals = ["dog", "cat", "bird"]
let animalsItem = animals.shift();
animalsItem // dog
animals // [cat", "bird"]

5.2、unshift()

unshift()与shift()用法相反
unshift()方法可以接收任意数量的参数，把它们整体添加到数组最前面，并返回数组的长度，并且会改变数组本身。

let num = [1, 2, 3, 4, 5, 6];
let numItem = num.unshift(7,8,9);
numItem // 9
num // [ 7, 8, 9, 1, 2, 3, 4, 5, 6]  这里请注意是把7，8，9整个加在了1，2，3，4，5，6的前面，而不是循环遍历加的。

let animals = ["dog", "cat", "bird"]
let animalsItem = animals.unshift('monkey','tiger');
animalsItem // 4
animals // ["monkey","tiger","dog","cat","bird"]  

6、重排序方法：

数组中的重排序方法是reverse()和sort()

6.1、reverse()

reverse()方法只是把数组的顺序倒着排列一下，没有做大小的排序，并且会改变原数组

let arr7 = [1,3,4,2,6,8,0]
arr7.reverse();
arr7 // [0, 8, 6, 2, 4, 3, 1]

6.2、sort()

因为reverse()不够灵活，所以才有了sort()这种排序方式。
在默认情况下，sort()方法按照生序方法排列数组，默认排序方式是从小到大。注意：sort()会改变原数组。

let arr8 = [1,8,9,2,7,4,3,-2,-4,-1,0]
arr8.sort();
arr8 // [-1, -2, -4, 0, 1, 2, 3, 4, 7, 8, 9]