函数式编程基本概念

编程范式

函数式编程(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))