高阶函数

Part 1 · 什么是高阶函数？

高阶函数（Higher-order function）

• 可以把函数作为参数传递给另一个函数
• 可以把函数作为另一个函数的返回结果

Part 2 · 高阶函数-函数作为参数

示例: 演示把函数作为参数传递给另一个函数

let arr = [1, 3, 4, 7 ,8]
// 简单模拟forEach
function forEach(array, fn) {
    for (let i = 0; i < array.length; i++) {
        fn(array[i])
    }
}
// 测试forEach
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 
}
// 测试filter
let r = filter(arr, function(item) {
    return item % 2 === 0
})
console.log(r)
复制代码

总结：函数作为参数传递给函数，会使函数变得更加灵活

Part 3 · 高阶函数-函数作为返回值

语法：把函数作为另一个函数的返回值

function makeFn() { // 定义函数
    const msg = 'hello function'
    return function () {
        console.log(msg)
    }
}
makeFn()() //执行
复制代码

演示：一个有意义的函数封装，once（函数只执行一次）
场景：当用户在进行订单支付的时候，要求函数只执行一次

function once(fn) {
    let done = false // 标记传入的函数是否被执行过
    return function() { // 函数作为返回值
        if (!done){
            done = true
            return fn.apply(this, arguments) // arguments指return的匿名函数的传参
        }
    }
}

let pay = once(function(money) {
    console.log(`支付：${money} RMB`)
})

pay(5)
pay(5)
pay(5)
复制代码

Part 4 · 高阶函数-使用意义

首先明确函数式编程的核心思想：对运算过程进行抽象，抽象为函数，在任何地方使用
高阶函数-使用意义：

• 抽象可以帮我们屏蔽细节，只需关注我们的目标
• 高阶函数就是用来帮我们抽象一些通用的问题

举例方便理解：

// 面向过程的方式
let array = [1, 2, 3, 4]
for (let i = 0; i < array.length; i++) {
    console.log(array[i])
}
// 高阶高阶函数
let array = [1, 2, 3, 4]
forEach(array, item => { // 使用抽象的函数屏蔽细节实现，只关注目标
    console.log(item)
})
let r = filter(array, item => {
    return item % 2 === 0
})
复制代码

Part 5 · 常用的高阶函数

常用：forEach、map、filter、every、some、find/findIndex、reduce、sort …

// 模拟map
const map = (arr, fn) => {
    let results = []
    for (value of arr) {
        results.push(fn(value))
    }
    return results
}
// 测试
// let arr = [1, 2, 3]
// arr = map(arr, v => v * v)
// console.log(arr)

// 模拟every
const every = (arr, fn) => { 
    let result = true
    for (value of arr) { 
        result = fn(value)
        if(!result) break
    }
    return result
}
// 测试
// let arr = [15, 11]
// let r = every(arr, v => v > 10)
// console.log(r)

// 模拟some
const some = (arr, fn) => { 
    let result = false
    for (value of arr) { 
        result = fn(value)
        if(result) break
    }
    return result
}
// 测试
// let arr = [1, 2, 9, 7]
// let r = some(arr, v => v % 2 === 0)
// console.log(r)
复制代码

总结：通过将一个函数作为参数传递给另一个函数，可以让另一个函数变的更加灵活。