Array.isArray(obj)是不是数组，判断！

这是一个Array对象的一个静态函数，判断一个对象是不是数组的。

var a = []
undefined
var b = new Date()
undefined
console.log(Array.isArray(a))
 true
undefined
console.log(Array.isArray(b))
 false
undefined

.indexOf(element) / .lastIndexOf(element)查找一个值有木有在数组里

indexOf从头至尾搜索，lastIndexOf反向搜索。
查找到第一个后，返回其引索，没有找到返回-1。

var arr =[3,4,'hello','haha']
undefined
arr.indexOf('haha')
3
arr.indexOf('ha')
-1
arr.lastIndexOf('haha')
3
arr.splice(1,0,8,8,8,)
[]
arr
(7) [3, 8, 8, 8, 4, "hello", "haha"]
arr.indexOf(8)
1
arr.lastIndexOf(8)
3

如果没有这个函数命令，单独去自己写呢？

function hasWord(arr,item){
  for(var i =0;i<arr.length;i++){
    if( arr[i] === item)
          return i
} 
         return -1
}
hasWord(arr,8)
1

数组的遍历.forEach(element,index,array)

遍历是为了让每一个元素扩展性更强，操作性更方便，相当于放到函数角度看问题了。
遍历数组，参数为一个回调函数，回调函数有三个参数：

• 当前元素
• 当前元素索引值
• 整个数组
  用

arr.forEach(function(){
console.log(arguments)
})

可以知道forEach的三个参数的顺序：元素，位置，数组。

var arr =[3,4,'hello','haha']
arr.forEach(function(){
console.log(arguments)
})
 (3) [3, 0, Array(4), callee: function, Symbol(Symbol.iterator): function]
 (3) [4, 1, Array(4), callee: function, Symbol(Symbol.iterator): function]
 (3) ["hello", 2, Array(4), callee: function, Symbol(Symbol.iterator): function]
 (3) ["haha", 3, Array(4), callee: function, Symbol(Symbol.iterator): function]
arr.forEach(function(value,index){
        console.log(value + '' + value )
})
 33
 44
 hellohello
 hahahaha

用for循环呢？
for(var i=0;i<arr.length;i++){
      arr[i] = arr[i]+''+arr[i]
}
"hahahaha"
arr
(4) ["33", "44", "hellohello", "hahahaha"]

.every(function(element,index,array))/.some(function(element,index,array))数组中的元素满足什么条件，返回真或假

• every所有函数的每个回调函数都返回真才返回真，遇到假就终止执行返回假。
• some函数存在一个回调函数返回真才终止执行，返回真，否则返回假。

var arr =[3,4,-1,0,5]       //是否全是正数？
arr.every(function(element,i){
      if(arr[i]>0)  
      return true  
})
false
或者是：
arr.every(function(val){
       return val>0?true:false
})
false

如果我想知道数组里有木有正数？
arr.some(function(val){
      return val>0?true:false
})
true

.map(function(element))遍历数组，回调函数返回值组成新数组返回

新数组与原数组索引结构一样，原数组不变。

var arr =[1,2,3,4,5,6]     //我想要新数组是原数组的元素的平方
var a = arr.map(function(val){
  return val*val
})
a
(6) [1, 4, 9, 16, 25, 36]

.filter(function(element))数组的过滤

返回数组的一个子集，回调函数判断是否返回，返回true的元素加入到返回数组中，索引缺失的不包括在新数组中------原数组不变。

var arr=[3,5,6,-1,-2,-3]
var a =arr.filter(function(val){
    return val>0
})
a
(3) [3, 5, 6]
arr
(6) [3, 5, 6, -1, -2, -3]      //过滤正数

var students=[{
    name:'a',
    age:10
},
{
    name:'b',
      age:20
},
{
    name:'ce',
      age:8
},
{
      name:'dd',
        age:5
}
]                         //过滤出学生里年纪大于18的？
var stu18 =students.filter(function(val){
      return val.age>18
})
stu18
[{name:'b',  age:20}]  (length=1)//length值是在原数组中的值。

如果想要知道学生名字里有c的：
var namehasc =students.filter(function(val){
    return val.name.indexOf('c')>-1
})
namehasc
[{name:'ce',age:8}]  //这里的indexOf用的是字符串那里的搜索，不是这里的。

reduce(function(v1,v2),value)/reduceRight(function(v1,v2),value)元素作用后得到新元素，新元素再跟下一个原数组的元素继续作用

var arr =[3,4,5]    //我想要一个累加的结果
arr.reduce(function(v1,v2){
      return v1+v2                             
})
12

刚开始，遍历，v1=3,v2=4,得到7；
再遍历，v1=7,v2=5,得12。
这里有一个初始值参数value——

arr.reduce(function(v1,v2){
    return v1+v2
},100)
112    //刚开始v1=100,v2=3,然后以此类推，，，

如何手写，实现reduce的功能呢？

var arr=[3,4,5,6]
function reduce(arr,fn,initval){
}
var result=reduce(arr,function(){
          v1+v2
},10)
先不去管初始值：
function reduce(arr,fn){
      var arr2=arr
  while(arr2.length>1){
              console.log(arr2)
              arr2.splice(0,2,fn(arr2[0],arr2[1]))
}
return arr2[0]
}

var arr=[3,4,5,6]

var result=reduce(arr,function(v1,v2){
        return  v1+v2
})
 (4) [3, 4, 5, 6]
(3) [7, 5, 6]
 (2) [12, 6]

console.log(result)
 18       //但是原数组改变了，不是我想要的。这时候arr2=arr.concat([]),深拷贝。

如果有初始值呢？就相当于arr2=[initvalue,3,4,5,6]——

function reduce(arr,fn，initValue){
      var arr2=arr.concat([])
if(initValue !== undefined){
    arr2.unshift(initValue)
}                                            //判断初始值有木有：不要直接写if(initValue),如果是0或者null,也是false。
  while(arr2.length>1){
              console.log(arr2)
              arr2.splice(0,2,fn(arr2[0],arr2[1]))
}
return arr2[0]
}
var arr=[3,4,5,6]
var result=reduce(arr,function(v1,v2){
        return  v1+v2
},10)


console.log(result)

把一个数组给拍平

var arr=[3,['4,5',7,[1]],[2,10]]
function flat(){
}
var arr2 = flat(arr)
console.log(arr2)     //[3,'4,5',7,1,2,10]就是这个意思，拍平。那怎么办呢？
递归：
function flat(arr){
  var arr2=[]
 arr.forEach(function(val){
      if(Array.isArray(val)){
          arr2 = arr2.concat(flat(val))
}else{
        arr2.push(val)
}                
})
return  arr2
}
var arr2=flat(arr)
arr2
(6) [3, "4,5", 7, 1, 2, 10]

另一种思路：flat就是把value变成一个值。
function flatten(arr){
var newArr=[]
function flat(arr){
    arr.forEach(val>={
      if(Array.isArray(val)){
          flat(val)     
}else{
        newArr.push(val)
}
})
}
flat(arr)
return newArr
}

还有一个方法：
function flatten2(arr){
    return arr.reduce(function(initArr,curentArr){
      return initArr.concat(Array.isArray(currentArr)flatten2(currentArr):currentArr)
},[])
}
//这里是一项一项地去合并，如果是数组拍平再合并。

反正基本思路，肯定是要用递归把嵌套的拍平的，然后拍平后，如何结合，各凭本事了哦。