02纯函数和lodash

纯函数

概念

• 相同的输入永远会得到相同的输出，而且没有任何可观察副作用
  • 类似数学函数（用来描述输入与输出关系）

slice和splice分别为纯函数和不纯函数

• slice返回（或截取）数组中指定部分，不会改变原数组
• splice对数组进行操作，再返回原数组，可以理解为对数组的操作，会改变原数组；

演示案例

// 纯函数和不纯的函数
// slice / splice
let array = [1,2,3,4,5,6]
// 三次输出相同，说明slice是纯函数
console.log(array.slice(0,3))
console.log(array.slice(0,3))
console.log(array.slice(0,3))
// 三次调用结果不相同，说明会改变原数组，不纯函数
console.log(array.splice(0,3))
console.log(array.splice(0,3))
console.log(array.splice(0,3))
// 纯函数
function getSum(n1,n2) {
    return n1 + n2;
}
// 多次调用都是3，说明是纯函数
console.log(getSum(1,2))
console.log(getSum(1,2))
console.log(getSum(1,2))

• 函数式编程中不会保留中间的结果，所以变量是不可变得（无状态的）
• 可以把一个函数的执行结果交给另一个函数执行

好处

• 可缓存
  • 因为纯函数对相同的输入始终有相同结果，所以可以把纯函数的结果缓存起来
• 可测试
  • 纯函数让测试更方便
• 方便并行处理
  • 多线程环境下并行操作共享内存时会出现意外情况
  • 纯函数不需要访问共享的内存数据，所以在并行环境下运行任意纯函数

// 计算圆面积，演示如何缓存结果
const _ = require('lodash');
 function getArea (r) {
     console.log(r)
     return Math.PI * r * r;
 }
 
// memoize记忆函数,接受一个纯函数内部会缓存结果,并且返回一个带有记忆功能函数
let getAreaWithMemory = _.memoize(getArea)
console.log(getAreaWithMemory(4))
console.log(getAreaWithMemory(4))
console.log(getAreaWithMemory(4))

模拟memoize

调用时会接受一个函数，并返回一个函数；
函数内部定义一个对象，将函数执行结果缓存起来；
function memoize(f) {
	let cache = {}
	return function() {
        let key = JOSN.stringify(arguments)
        // 如果有值，将值直接返回，如果没值，则调用f函数
        // 需要将arguments参数展开传递给f
        cache[key] = cache[key] || f.apply(f,arguments);
        return cache[key]
	}
}
// 测试
let getAreaWithMemory = memoize(getArea)
console.log(getAreaWithMemory(4))
console.log(getAreaWithMemory(4))
console.log(getAreaWithMemory(4))

Lodash

Javascript 库

• 安装

  npm init -y
  npm i lodash 

• 使用

  const _ = require('lodash');

演示

first / head , last , toUpper , reverse, each , includes, find , findIndex****等都是纯函数

代码演示：

const _ require('lodash');
const array = ['jack','tom','lucy','kate'];
console.log(_.first(array))
console.log(_.last(array))
// 数组中第一个元素转换成大写
console.log(_.toUpper(_.first(array)))
// 翻转数组
console.log(_.reverse(array))
// 遍历数组
const r = _.each(array,(item,index)=>{
    console.log(item,index)
})
console.log(r)

副作用

​ 让一个函数变得不纯，纯函数根据相同输出返回相同输出，如果函数依赖于外部状态就无法保证输出相同，就会带来副作用；

// 不纯的
let mini = 18
function checkAge (age) {
  return age >= mini
}
// 纯的(有硬编码，后续可以通过柯里化解决)
function checkAge (age) {
  let mini = 18
  return age >= mini
}

来源

• 配置文件
• 数据库
• 获取用户输入
• …

所有外部交互都有可能产生副作用，副作用

​ 所有的外部交互都有可能带来副作用，副作用也使得方法通用性下降不适合扩展和可重用性，同时副作 用会给程序中带来安全隐患给程序带来不确定性，但是副作用不可能完全禁止，尽可能控制它们在可控 范围内发生。

柯里化

解决硬编码问题

// 判断用户输入年龄是否大于基准值
function checkAge(min) {
    let min = 18;
    return age >= min
}
// 普通纯函数
function checkAge(min,age) {
    return age >= min;
}
console.log(checkAge(18,20))
console.log(checkAge(18,24))
console.log(checkAge(22,24))
// 改进优化18多次重复问题
fucntion checkAge(min) {
    return function(age) {
        return age >= min;
    }
}
// 通过checkAge返回一些新的函数，根据不同标准返回不同函数
let checkAge18 = checkAge(18);
let checkAge20 = checkAge(20);
// 这种形式就是柯里化
console.log(checkAge18(24))
console.log(checkAge20(24))

总结：当函数有多个参数，可以对这个函数进行改造，可以调用一个函数只传入部分函数，并且让这个函数返回一个新函数来接受剩余参数，最终生成结果；

箭头
let checkAge = min => (age => age >= min)

lodash中柯里化

_.currry(func)

• 功能：创建一个函数，该函数接受一个或多个func函数，如果func所需要的参数都被提供则执行func并返回执行结果，否则继续返回该函数，并且等待剩余参数
• 参数：需要柯里化的函数
• 返回值：柯里化后的函数

const _ = require('lodash)
function getSum(a,b,c) {
    return a + b +c
}
柯里化能把任意元的函数转换成一元函数；
const currried = _.curry(getSum);
console.log(curried(1,2,3))
console.log(curried(1)(2,3))
console.log(curried(1,2)(3))

案例

// 提取字符串中所有空白字符
''.match(/\s+/g)
// 提取字符串中所有数字
''.match(/\d+/g)
function match (reg, str) {
    return str.match(reg)
}
// 柯里化改造
const _ = require('lodash)
function match (reg, str) {
    return str.match(reg)
}
const match = _.curry(function  (reg, str) {
    return str.match(reg)
})
const havaSpace = match(/\s+/g);
const havaNumber = match(/\d+/g);
console.log(havaSpace('hello word'))
console.log(havaNumber('123 word'))
// 找到数组中所有空白元素
const filter = _.curry(function (func,array) {
	return array.filter(func)
})
// 改造
const filter = _.curry((func,array) => array.filter(func))
console.log(filter(havaSpace,['ass dd','sdd_ss']));
const findSpace = filter(havaSpace);
console.log(findSpace(['ass dd','sdd_ss']));

柯里化原理

模拟_.curry

// 定义一个函数，传递一个需要柯里化函数；
// 需要几个参数就传递几个参数，如果参数相同则直接返回这个函数，如果不等则返回一个新函数，来接受剩余函数
function curry (func) {
  return function curriedFn(...args) {
    // 判断实参和形参的个数
    // 如果args个数小于func个数则返回一个新函数
    if (args.length < func.length) {
      return function () {
        // Array.from 将伪数组转变成真正数组
        // 将已传入实参合并，返回一个新函数
        return curriedFn(...args.concat(Array.from(arguments)))
      }
    }
    return func(...args) // 或者 return func.apply(this,arg)
  }
}
// 测试
const filter = curry((func,array) => array.filter(func))
console.log(filter(havaSpace,['ass dd','sdd_ss']));
const findSpace = filter(havaSpace);
console.log(findSpace(['ass dd','sdd_ss']));

总结：

• 可以让我们生成一个新函数，并且这个函数已经记住了某些固定参数
• 使用闭包对函数参数缓存
• 让函数更灵活，让函数粒度更小
• 可以把多元函数转成一元函数，可以组合成更强大函数