ES5数组扩展

Array.isArray(obj)

Array.isArray(obj)用来判断一个对象是不是数组

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

.indexOf(element)/.lastindexOf(element)

查找数组内制定元素位置
js实现indexOf查找效果

var arr =[3, 4, 'hello']
function hasword(item){
    for(var i = 0; i < arr.length; i++){
        if(arr[i] === item){
            return i
        }
    }return false
}
hasword('hello')

.indexOf直接查询

var arr =[3, 4, 'hello']
arr.indexOf('hello') //2 返回找到值的下标
arr.indexOf('hell') //-1 找不到返回-1

.lastindexOf(element),查找元素最后一次出现的位置

var arr =[3, 4, 3, 'hello']
arr.lastIndexOf(3) //2 从后往前，返回元素最后一次出现的位置
arr.lastIndexOf(5) //-1

.forEach遍历数组

特殊遍历方法
不知道函数arguments时，使用如下方法

var arr = [3, 4, 'hello', 'world']
arr.forEach(function(){
  console.log(arguments)
}) //查找arguments的参数

.forEach用法

var arr = [3, 4, 'hello', 'world']
arr.forEach(function(item,num){
  arr[num] = '' + item + item
})
console.log(arr) //["33", "44", "hellohello", "worldworld"]

.every(function(element, index, array)) / .some(function(element, index, array))

1. every是所有函数的每个回调函数都返回true的时候才会返回true，当遇到false的时候终止执行，返回false

2. some函数是“存在”有一个回调函数返回true的时候终止执行并返回true，否则返回false

var arr = [3, 4, -2, 0]
arr.every(function(val){
    return val>0?true:false
}) //false


var arr = [3, 4, 2, 0]
arr.every(function(val){
    return val>=0?true:false
}) //true


var arr = [3, 4, -2, 0]
arr.some(function(val){
    return val>0?true:false
}) //true


var arr = [-3, -4, -2,]
arr.some(function(val){
    return val>0?true:false
})//false

.map(function(element))

和forEach类似，遍历数组，回调函数返回值组成一个新的数组返回，新数组索引结构和原数组一致，原数组不便

var arr = [2, 4, 5, 7]
arr.map(function(val){
    return val * val
}) //[4, 16, 25, 49]
console.log(arr) //[2, 4, 5, 7]

.filter(function(element))

返回数组的一个子集，回调函数用于逻辑判断是否返回，返回true则把当前元素加入到返回数组中，false则不加
新数组只包含返回true的值，索引缺失的不包括，元数组保持不变

var arr = [3, 5, 6, -1, -3]
var arr2 = arr.filter(function(val){
    return val < 0
})
console.log(arr) //[3, 5, 6, -1, -3]
console.log(arr2) //[-1, -3]


var students = [
{
    name: 'ac',
    age: 11
},    
{
    name: 'va',
    age: 19
},
{
    name: 'bc',
    age: 21
},
]

var age18up = students.filter(function(student){
    return student.age > 18
})
console.log(age18up) //返回年龄大于18的学生
/*[[object Object] {
  age: 19,
  name: "va"
}, [object Object] {
  age: 21,
  name: "bc"
}]*/

var namehasc = students.filter(function(student){
    return student.name.indexOf('c') > -1
})
console.log(namehasc)  //返回名字带"c"的学生
/*[[object Object] {
  age: 11,
  name: "ac"
}, [object Object] {
  age: 21,
  name: "bc"
}]*/

.reduce(function(v1, v2), value) / .reduceRight(function(v1, v2), value)

遍历数组，调用回调函数，将数组元素组合成一个值，reduce从索引最小值开始，reduceRight反向，方法有两个参数

var arr = [3, 4, 5]
arr.reduce(function(v1, v2){
    return v1 + v2
}) //12


var arr = [3, 4, 5]
arr.reduce(function(v1, v2){
    return v1 + v2
},100) //112  设置v1初始值为100

用js实现.reduce

function reduce(arr, fn, initValue){
  var arr2 = (initValue !== undefined?[]:[initValue]).concat(arr)
  while(arr2.length > 1){
    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) //18

优雅的深拷贝（数组）

arr = [1, 2, 3]
arr2 = arr.concat([])
console.log(arr2) //[1, 2, 3]

面试题

写出函数实现拍平效果，返回如下结果

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]

写法一

var arr = [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)
console.log(arr2) //[3, "4,5", 7, 1, 2, 10]

写法二

function flatten2(arr){
  return arr.reduce(function(initArr, currentArr){return initArr.concat(Array.isArray(currentArr)?flatten2(currentArr):currentArr)},[])
}

console.log(flatten2(arr)) //[3, "4,5", 7, 1, 2, 10]