Javascript的Array对象是用于构造数组的全局对象。

基本语法

window.Array是全局对象（也是全局函数）

let f = ['a','b']
//等价于
let f = new Array('a','b')
//等价于
var f = Array('a','b')

var a = Array(3)//(3) [empty x 3]  只有length：3 

加不加new都是一样的。

Function 构造函数 创建一个新的Function对象。 在 JavaScript 中, 每个函数实际上都是一个Function对象。
和Array一样，加不加new是一样的。

var f = function(a,b){ return a+b }
//等价于
var f = new Function('a','b','return a+b')

这里注意区分function 和Function，前一个是关键字和if、let、var一样，后者是对象。

函数声明方式

具名函数

function f(x,y){
return x+y
}

匿名函数 + var

var f
f = function(x,y){return x+y}

具名函数 + var

var f1 
 f1= function f2(x,y){
     return x+y
 }

window.Function + var

var f = new Function('x','y','return x+y')

JS中数组的本质

数组就是原型链中有 Array.prototype 的对象

var a = Array(1,2,3)//(3) [1, 2, 3]
//0: 1 1: 2 2: 3 length: 3 __proto__: Array(0)
a.__proto__ === Array.prototype
true
Array.prototype.__proto__ === Object.prototype
true

var obj = {0:'1',1:'2',2:'3',length:3}//{0: "1", 1: "2", 2: "3", length: 3}
//0: "1" 1: "2" 2: "3" length: 3 __proto__: Object
obj.__proto__ === Array.prototype
false
obj.__proto__ === Object.prototype
true

上面代码可以看到，a.proto指向 Array.prototype这个数组的公共属性。
obj.proto指向Object.prototype这个公共属性，他的原型链中没有Array.prototype。
所以a是一个数组，obj不是。
记住一条公式：对象.proto === 对象的构造函数.prototype

伪数组

1. 有 0,1,2,3,4,5...n,length 这些 key 的对象
2. 原型链中没有 Array.prototype

目前知道的伪数组有：

1. arguments 对象 __proto__对应的是Object
   

   1551266679(1).jpg

2. document.querySelectAll('div') 返回的对象

遍历方式不关心你是不是数组

var obj = {
0:1,1:2,2:3,3:4,length:4
}
for(let i=0;i<obj.length;i++){
console.log(obj[i])
}//1 2 3 4 
for(let i in obj){
console.log(obj[i])
}//1 2 3 4 4 他把length也当成一个i

数组的API

1. 最常用的API：Array.prototype.forEach
   语法：arr.forEach(callback[, thisArg]);
callback为数组中每个元素执行的函数，可接受三个参数：
   currentValue正在处理的当前元素，也就是value
index（可选）正在处理的当前元素的索引,也就是key
array（可选）正在处理的当前数组本身

var a = ['a','b','c','d']
a.forEach( function(x,y,z){//x,y,z可以是任意变量，他对应的就是value，key，array本身
 console.log(x,y,z)
}
> "a" 0 Array ["a", "b", "c"]
> "b" 1 Array ["a", "b", "c"]
> "c" 2 Array ["a", "b", "c"]

2. Array.prototype.sort
   对数组的元素进行排序，并返回数组。

var a = [1,5,72,356,4,88,7]
a.sort()
//(7) [1, 356, 4, 5, 7, 72, 88]无法保证其排序顺序
a.sort(function(x,y){return x-y})
//(7) [1, 4, 5, 7, 72, 88, 356]
a.sort(function(x,y){return y-x})
//(7) [356, 88, 72, 7, 5, 4, 1]

后两个可以保证顺序，只有这两种写法，不是x-y就是y-x。

3. Array.prototype.join
   将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。

var a = [1,2,3]
a.join('xx')//"1xx2xx3"
a.join(',')//"1,2,3" 变字符串
a.join('')//"123"
//(),('+')都有不同的结果

4. Array.prototype.concat
   用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

var a = [1,2,3]
var b = [4,5,6]
a.concat(b)//(6) [1, 2, 3, 4, 5, 6]
//还可以用来复制一个数组，成为一个新数组
var a = [1,2,3]
b = a.concat([])//b = [1,2,3]  b!==a

5. Array.prototype.map
   创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。

var a = [1,2,3]
a.map(x => x*2)//(3) [2, 4, 6]
a.map(function(x){return x*2})//(3) [2, 4, 6]  这里的参数x对应value

6. Array.prototype.filter
   创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。 函数提供一个过滤条件。

var a = [356, 88, 72, 7, 5, 4, 1]
a.filter(function(x){
 return  x>50 
})//(3) [356, 88, 72]
var a = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present']
a.filter(x => x.length >6)//(3) ["exuberant", "destruction", "present"]

7. Array.prototype.reduece
   对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。简单来说就是求个数组元素总和+给的初始值。

var a = [1,2,3,4,5]
a.reduce(function(sum,n){
return sum+n},0)//15
a.reduce((sum,n) => sum+n)//15

a.reduce(function(sum,n){return sum+n},0)原理是把0作为sum的初始值，第一次加上a[0]得到1，把1作为新的sum，第二次加上a[1]得到3……一直累计到a[4]得到15。

总结

常用的数组API就这几个，更多的可以查看MDN