Array 方法

chunk(array, [size=1])

1 .将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块

let arr=[1,2,3,4,7]

function chunk(arr,size){
    let result=[]
    let init=arr
    if(size===0)return
    while(init.length){
        let item=[]
        if(init.length>size){
            item.push(...init.splice(0,size))
            // 不加点返回的是一个数组，这样嵌套会很多
        }else{
            item.push(...init.splice(0,init.length))
        }
        result.push(item)
        console.log(result)
    }
}
chunk(arr,0)

difference(array, [values])

1 .创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。（注：即创建一个新数组，这个数组中的值，为第一个数字（array 参数）排除了给定数组中的值。）该方法使用 SameValueZero做相等比较。结果值的顺序是由第一个数组中的顺序确定
2 .返回新数组，新的数组里面不包含右边数组里面的项

function difference(arr,values){
    let result=arr.filter((e)=>{
        if(values.includes(e)){
            console.log(e)
            return false
        }else{
            return true
        }
    })
    return result
}

map(collection, [iteratee=_.identity])

1 .创建一个数组， value（值） 是 iteratee（迭代函数）遍历 collection（集合）中的每个元素后返回的结果。 iteratee（迭代函数）调用3个参数：
(value, index|key, collection)

function square(n){
    return n*n
}
function add(n,index){
    return n*n+index
}
function map(array,iteratee){
    let index=0
    const length=array==null?0:array.length
    const result=new Array(length)
    while(index<length){
        result[index]=iteratee(array[index],index,array)
        // 这里是多传入参数留着备用的吗？
        index++
    }
    return result
}

differenceBy(array, [values], [iteratee=_.identity])

1 .这个方法类似_.difference ，除了它接受一个 iteratee （注：迭代器）， 调用array 和 values 中的每个元素以产生比较的标准。 结果值是从第一数组中选择。iteratee 会调用一个参数：(value)。（注：首先使用迭代器分别迭代array 和 values中的每个元素，返回的值作为比较值）

function differenceBy(array,values,iteratee){
    let result=[]
    if(!array.length)return []
    result=array.filter((e)=>{
        let item=iteratee(e)
        for(let v of values){
            if(item===iteratee(v)){
                return false 
            }
        }
        return true
    })
    return result
}

differenceBy([1,2.123,3.3],[2,1.2],Math.floor)
// differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x')
// 迭代器不是一个函数怎么办？
// 那就自己写成一个函数形式算了
// differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }],(e)=>{return e['x']})

drop

function drop(array,start,end){
    array.splice(start,end-start)
    return array
}

drop([1,2,3,4],0,1)
// 切掉0，1索引的元素

flatten(array,depth)

1 .减少n级嵌套深度

function flatten(array,depth){
    let result=[]
    for(let v of array){
        if(Array.isArray(v)&&depth>0){
           let arr=flatten(v,depth-1)
           result.push(...arr)
        }else{
            result.push(v)
        }
    }
    return result
}

console.log(flatten([1,[2,3,[4,5,[6,7,[8,9,[10,11,[12,13]]]]]],14],8))

intersection([arrays])

1 .获取所有数组的交集

function intersection(){
    let result=[]
    for(let v of arguments){
        result.push(v)
    }
    let final=[]
    for(let i=1;i<result.length;i++){
        if(i===1){
            final=result[0]
        }
        let arr=[]
        final.map((e)=>{
            if(result[i].includes(e)){
                arr.push(e)
            }
        })
        if(arr.length===0){
            return []
        }else{
            final=arr
        }
    }
    return final
}
intersection([1,2],[2,4],[2,5])