函数式编程基本概念

编程范式

函数式编程(Function Programming, FP)是编程范式之一（还包括面向对象编程、面向过程编程）

• 面向对象编程方式：把现实事物抽象成程序世界类和对象，通过封装、继承和多态演示事物的联系，C++、JAVA等

• 面向过程编程方式：把事情拆分成一个个函数和数据，按照一定顺序，执行这些方法

• 函数式编程方式：把现实事物和事物之间联系抽象到程序世界，对运算过程进行抽象

函数式编程

• 程序本质：根据输入获取输出

• 数学中的函数：x -> f（联系、映射）-> y， y = f(x)

• 函数指的是数学中的函数，而不是程序中的函数，如y = sin(x)

• 相同的输入始终得到相同的输出（纯函数）

• 函数式编程用来描述数据（函数）之间的映射

• 函数式编程语言Haskell、lisp、Scheme等

• JS中的函数式编程

let b = 3
let sum = (a) => a + b
console.log(sum(2)) // 5

// 修改为函数式编程
let sum = (a, b) => a + b
console.log(sum(2, 3)) // 5

前置知识

函数是一等公民MDN

• 函数可以存储在变量中

• 函数可以作为参数

• 函数可以作为返回值

函数是一等公民是学习高阶函数、柯里化等的基础

高阶函数

以函数作为输入或者输出的函数被称为高阶函数

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

  // forEach
  function forEach(arr, fn) {
  for (let i of arr) {
      fn(i)
    }
  }
  

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

  function makeFn () {
   let msg = 'make function'
  return function () {
   console.log(msg)
  }
  }
  const fn = makeFn()
  fn()
  // once只会执行一次
  function once (fn) {
  let done = false
   return function () {
       if (!done) {
           done = true
         return fn.apply(this, arguments)
       }
  }
  }
  let pay = once((money) => {
  console.log(`支付，￥${money}元`)
  })
  
  pay(5)
  pay(5)
  

使用高阶函数意义

高阶函数就是定义抽象，屏蔽细节，只需要关注目标

• 命令式编程（注重如何做，注重过程）

  let arr = [1, 2, 3]
  for (let i =0; i < arr.length; i++) {
    console.log(arr[i])
  }
  

• 高阶函数抽象过程（注重做什么，注重结果）

  const forEach = function(arr, fn) {
    for (let i = 0; i < arr.length; i++) {
      fn(arr[i])
    }
  }
  let arr = [1, 2, 3]
  forEach(arr, (item) => {
    console.log(item)
  })
  

常用高阶函数

// map
const map = (arr, fn) => {
    let resule = []
  for (let item of arr) {
    resule.push(fn(item))
    }
    return result
}
// filter
const filter = (arr, fn) => {
    let result = []
  for (let item of arr) {
    fn(item) && result.push(item)
    }
    return result
}
let arr = [1, 2, 3]
filter(arr, (item) => item > 2)
// every
const every = (arr, fn) => {
    let isTrue = true
  for (let item of arr) {
    isTrue = isTrue && fn(item)
    }
    return isTrue
}
// some
const some = (arr, fn) => {
    let isTrue = false
  for (let item of arr) {
    isTrue = fn(item)
        if (isTrue) break
    }
    return isTrue
}
let arr = [-1, 3, false]
some(arr, (item) => item > 2)
// find
const find = (arr, fn) => {
  let result = ''
    for (let item of arr) {
    if (fn(item)) {
      result = item
            break
        }
    }
    return result
}
let arr = [-1, 3, false]
let result = find(arr, (item) => item > 2)
// reduce 待完善
// sort sort((a, b) => a - b)
const sort = (arr, fn) => {
  const len = arr.length - 1
  for (let i = 0; i < len; i++) {
    let flag = true
    for (let j = 0; j < len - i; j++) {
      if (fn(arr[j], arr[j + 1])) {
        flag = false
        let temp = arr[j]
        arr[j] = arr[j + 1]
        arr[j + 1] = temp
      }
    }
    // 如果一次交换都没有发生，说明已经排好序了，直接返回
    if (flag) {
        return arr
    }
  }
}
let arr = [12, 4, 43, 2, 12, 45]
let r = sort(arr, (a, b) => a - b > 0)

闭包

• 闭包：一个函数和对其周围状态（lexical environment，词法环境）的引用捆绑在一起（或者说函数被引用包围），这样的组合就是闭包；闭包可以在一个内层函数中访问到其外层函数的作用域什么是闭包？

• 特点：外部访问函数内部变量、避免使用全局变量、会造成内存泄漏

  // 函数作为返回值
  function makeFn () {
      let msg = 'Hello function'
      return function () {
        console.log(msg)
      }
  }
  const fn = makeFn()
  fn()
  

• 闭包的本质：函数执行会放在执行栈上，当函数执行完毕，会从执行栈上移除，但是堆上的作用域成员因为被外部引用不能释放，因此内部函数依然可以访问外部函数的成员

• 闭包案例

  function makePower(power) {
    return function(num) {
      return Math.pow(num, power)
    }
  }
  let power2 = makePower(2)
  console.log(power2(4))