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