一、数组Array:

创建方式一：

var a = Array(3)
a  //(3) [empty × 3]

a.__proto__ === Array.prototype //true

内存图分析

创建方式二：

var a = Array(3,3)
a  //(2) [3, 3] 0:3,1:3,length:2

效果图

加不加new对Array都一样

---

基本类型number, string, boolean
如果不加new ，Number()得到基本类型
如果加new，new Number()得到对象
加不加new，得到的 结果不一样

复杂类型Object(Array, function)
加不加new都是一样的，比如：

var a = new Array(1,2,3)
var a = [1,2,3]

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

---

具名函数
function f(){ 
  return
}
匿名函数
function(){}

Function
new Function('x', 'y', 'x+y')

数组就是由Array构造出来的对象。

示意图

理解：

var a = [1,2,3]
var obj = {0:1,1:2,2:3}

图解

伪数组：原型链中没有Array.prototype，就是伪数组。

//伪数组
var obj = {0:1,1:2,2:3,length:3}

js中的伪数组，arguments

function f(){
  console.dir(arguments)
}
f(1,2,3)
//Arguments(3)...__proto__:Object

发现里边直接有toString()方法，但是没有push()等方法，所以就是伪数组

二、数组的API

foreach()必须接受一个函数，函数要有两个参数

a = ['a','b','c']
a.forEach(function(x,y){
  console.log('value',x)
  console.log('key',y)
})
/*value a
  key 0
  value b
  key 1
  value c
  key 2
*/

理解函数接受一个函数：

第一次
function f(fn){
  console.log('接受了函数')
}
f( function(){})
//接受了函数

第二次
function x(y){
  if(typeof y !== 'function'){
    console.log('滚')
    return false
  }else{
    console.log('接受到函数')
    return true
  }
}
x(1)   //滚
x(function(){})  //接受到函数

第三次
function x(y){
  if(typeof y !== 'function'){
    console.log('滚')
    return false
  }else{
    console.log('接受到函数')
　y()
    console.log('并且执行了这个函数')
    return true
  }
}
x(function(){console.log('执行的是我')})  //接受到函数　执行的是我　并且执行了这个函数

第四个
function x(y){
  y(666)
}
x(function(){
  console.log(arguments)
}) //666

利用 forEach()

function forEach(array, x){
  for(let i=0;i<array.length;i++){
    x(array[i], i)
  }
}
forEach(['a','b','c'],function(value,key){
  console.log(value, key)
})
//a 0 b 1 c 2

a.forEach是一个函数，需要两个参数，像刚才写的function forEach(array, x){...}
但是这里为什么直接使用a.forEach( function(){} )就可以用呢？
a.forEach( function(){} )与a.forEach.call(a, function(){})，实际上帮你将参数传进去，用this获取。（在调用forEach，想谁在调用我，就将调用它的设置为this，然后完成）

obj.forEach = function(x){
    for(let i=0;i<this.length;i++){
  x(this[i],i)
    }
}
obj.forEach(function(value,key){console.log(value,key)})

a.sort()

a.sort()默认从小到大，会改变自身

a = [5,6,3,4,1,2]
a.sort() //1,2,3,4,5,6
a //[1,2,3,4,5,6]
a.sort(function(x,y){return x-y}) //1,2,3,4,5,6
a.sort(function(x,y){return y-x})  //6,5,4,3,2,1

其他

数组变字符串join()

a=[1,2,3]
a.join(',')//"1,2,3"
a.join() //"1,2,3"默认

连接concat()

var a=[1,2]
var b=[3,4]
a.concat(b)  //1,2,3,4

var a=[1,2,3]
var b=a.concat( [] ) //复制[1,2,3]

map()和forEach()类似，不同的是forEach不返回，map返回操作后的值

a.forEach(function(){}) //undefined
a.map(function(){})  //(3) [undefined, undefined, undefined]
a.map(value => value*10) //[10,20,30]

过滤filter()（只有sort改变原数组，其他不改变），

a.filter(function(value,key){
  return value>=2
})

reduce()

数组中的每个元素（从左到右）应用一个函数，将其简化为单个值。

a.reduce(function(sum,n){
  return sum + n
},0)

利用reduce标示map
a.reduce(function(arr,n){
  arr.push(n*2)
  return arr
},[]) //[2,4,6]

利用reduce标示filter
a.reduce(function(arr,n){
  if(n % 2 === 0){
    arr.push(n)
  }
  return arr
},[]) //2