2.函数式编程前置知识(高阶函数)

函数是一等公民

        函数可以存储在变量中

        函数作为参数

        函数作为返回值

在JavaScript中函数就是一个普通的对象（可以通过new function（）），我们可以把函数存储到变量/数组中，它还可以作为另一个函数的参数和返回值,甚至我们可以在程序进行的时候通过new function（‘alert（1）’）来构造一个新的函数

        1.把函数赋值成一个变量

        

//fn就是这个函数，并不是函数返回的值 后面就可以用fn来调用这个函数
let fn=function(){
    console.log('Hello！！！');
}
console.log(fn);
fn();

这就是一个函数或方法赋值给另一个函数

//原型
//一个对象（BlogController）里有好多方法,在方法中,index和它函数里面的index的函数方法和参数一样则可以进行精简
const BlogController={
    index(posts) {return Views.index(posts)},
    show(post) {return Views.show(post)},
    creat(attrs) {return Views.show(attrs)},
    update(post,attrs) {return Views.update(post,attrs)},
    destroy(post) {return Views.destroy(post)}
}

//优化
//即把一个函数或方法赋值给另一个方法，注意不是把函数的调用赋值给另一个方法
const BlogController={
    index: Views.index,      //应该方法赋给另一个方法所以rerun和方法参数都不要
    show:Views.show,
    creat: Views.show,
    update: Views.update,
    destroy: Views.destroy
}

高阶函数（higher-order function）

        可以把函数作为参数传递给另一个函数

        可以把函数作为另一个函数的返回结果（函数是一等公民的特性）

        可以把函数作为参数传递给另一个函数

//高阶函数
function forEach(array,fn){
    for(let i=0;i<array.length;i++)
    {
        fn(array[i])
    }
}


let arr=[1,2,3,5,6,7,8]
forEach(arr,function (item){
    console.log(item)
})

//filter函数过滤
function filter(array,fn){
    let result=[];
    for(let i=0;i<array.length;i++)
    {
        if(fn(array[i]))
        {
            result.push(array[i])
        }
    }
    return result
}

//测试
let arr=[1,2,3,5,6,7,8]
let re= filter(arr,function(item){
    //输出值为偶数
    return item%2===0
})
console.log(re)

可以把函数作为另一个函数的返回结果（函数是一等公民的特性）

//高阶函数-函数作为返回值
function makeFn(){
    let msg='Hello ZLW'
    return function(){
        console.log(msg)
    }
}

const fn=makeFn()
fn()

第二种调用方法

如果一个函数的返回结果是另外一个函数就可以用fn()()

//高阶函数-函数作为返回值
function makeFn(){
    let msg='Hello ZLW'
    return function(){
        console.log(msg)
    }
}

// const fn=makeFn()
// fn()

makeFn()()

只运行一次

//once
function once(fn){
    let done=false
    return function(){
        if(!done){
            done=true
            //this表示function,arguments表示arguments --> 0:"5"
            return fn.apply(this,arguments)
        }
    }
}

let pay=once(function(money){
    console.log('支付:'+money+'RMB')
})

pay(5)
pay(5)

使用高阶函数的意义

        抽象可以帮我们屏蔽细节，只需要关注与我们的目标

        高阶函数时用来抽象通用的问题

        使函数更加简捷

//高阶函数
function forEach(array,fn){
    for(let i=0;i<array.length;i++)
    {
        fn(array[i])
    }
}

let arr=[1,2,3,5,6,7,8]
forEach(arr,item=>{
    console.log(item)
})

//filter函数过滤
function filter(array,fn){
    let result=[];
    for(let i=0;i<array.length;i++)
    {
        if(fn(array[i]))
        {
            result.push(array[i])
        }
    }
    return result
}

//测试
let arr=[1,2,3,5,6,7,8]
let r=filter(arr,item=>{
    return item %2===0
})
console.log(r)

常用的高阶函数

forEach

map //对数组中每个数进行遍历,并对数进行处理，处理后的结果放在一个新的数组中返回

会让map函数变得更灵活

//map 对数组中每个数进行遍历,并对数进行处理，处理后的结果放在一个新的数组中返回
const map=(array,fn)=>{
    let result=[]
    for(let value of array){
        result.push(fn(value))
    }
    return result
}

//测试
let arr=[1,2,3,5,6]
arr =map(arr,v=>v*v)

console.log(arr)

filter

every  //用来匹配数组中的元素都匹配我们指定的条件

//every
const every=(array,fn)=>{
    let result=true
    for(let value of array){
        result =fn(value)
        if(!result){
            break
        }
    }
    return result
}

//测试
let arr=[11,10,5,6,9,20,13]
let r=every(arr,v=>v>1)
console.log(r)

some //用来匹配数组中的元素某一个能匹配我们指定的条件就行

const some=(array,fn)=>{
    let result=false
    for(let value of array){
        result =fn(value)
        if(result)
        {
            break
        }
    }
    return result
}

let arr=[11,10,5,6,9,20,13]
let r=some(arr,v=>v<20)
console.log(r)

find/findindex

reduce

sort

......