函数式编程

什么是函数式编程

函数式编程就是对运算过程的一种抽象

其他的编程方案

面向过程编程

    const arr = [1,2,3,4,5,6]
    let sum = 0
    for(let i = 0;i<arr.length;i++){
        sum =+ arr[i]
    }

    console.log(sum)

面向对象编程

要维护对象和行为

   class Calc{
        constructor(){
            this.sum = 0
        }
        add(arr){
            for (let i = 0; i < arr.length; i++) {
                this.sum += arr[i]
                
            }
        }
    }
    const arr = [1,2,3,4,5,6]
    const calc = new Calc()
    calc.add(arr)

函数式编程的优势

1. 可维护性 函数式编程的程序通常更加简洁和可读，因为他们避免了状态变化和副作用。这使得代码更易于理解和维护
2. 可测试性 由于函数式编程通常是无副作用的，素以可以很容易对其进行单元测试
3. 并发性 函数式编程通常是无副作用的，所以可以很容易地并行地执行
4. 扩展性 函数式编程通常是纯函数，可以很容易地组合和重用
5. 可靠性 由于函数式编程通常是无副作用的，可以很容易地组合和重用

函数是一等公民

• 函数可以存储在变量中

    let x = function(){
        
    }
  

• 函数可以作为参数
• 函数可以作为返回值

高阶函数

一个函数的入参是函数 ，或者 函数的返回值是函数

• 入参是函数

    function(cb){

    }

• 返回值是函数

    function fn2(){
        return function(){

        }
    }

实战

封装 reduce 高阶函数

    Array.prototype.reduce=function(callback,startVal){
    // 如果传递了   
    let arr =  this
    // 谁调用我指向谁
    // 基础值
    let acc = typeof startVal == "undefined"?arr[0]:startVal
    //没传 第 0 个，传了就用传的
    // 开始索引
    let sIndex = typeof startVal == "undefined"?1:0
    for(let i = sIndex;i<arr.length;i++){
        acc = callback(acc,arr[i])
    }
    return acc
}

切片编程

AOP 对我们已有的逻辑进行扩展,但不破坏原有的逻辑

    function say(val){
        console.log(val)
    }
    Function.prototype.before=function(callback){

        return (...arg)=>{
            callback(...args)//先调用传入的函数,再调用自己的
            this(...args)
        }
    }
    say.before(()=>{//before是高阶函数
        console.log("beforeSay")
    })

    new say("我说了一句话")

函数缓存

点赞功能

点赞一次之后,重复点赞无效等

    function memoize(fn, resolver) {
    const cache = new Map()
    return function (...args) {
        const key = typeof resolver === "function" ? resolver(...arg) : args[0]
        let result = cache.get(key)
        if (result == undefined) {
            result = fn(...args)
            cache.set(key, result)
        }
        return result
    }
}

纯函数

相同的输入永远得到相同的输出,并且没有任何副作用
** 非纯函数 **

    let count = 0
    function counter(){
        count++//依赖外部状态,多次调用返回结果不同
        return count
    }

    let date = new Date()
    function getTime(){
        // 不同时间的调用,返回值不同
        return date.toLocalTimeString()
    }

函数的副作用

• 对全局变量或者静态变量的修改
• 对外部资源的访问(如文件,数据库,网络http请求)
• 对系统状态的修改(环境变量)
• 对共享内存的修改
• Dom访问,打印/log等
  ocalTimeString()
  }

### 函数的副作用
- 对全局变量或者静态变量的修改
- 对外部资源的访问(如文件,数据库,网络http请求)
- 对系统状态的修改(环境变量)
- 对共享内存的修改
- Dom访问,打印/log等