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数组的遍历.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.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)
},[])
}
//这里是一项一项地去合并，如果是数组拍平再合并。
反正基本思路，肯定是要用递归把嵌套的拍平的，然后拍平后，如何结合，各凭本事了哦。