lodash已死？radash库方法介绍及源码解析 —— 函数柯里化 + Number篇

写在前面

tips：点赞 + 收藏 = 学会！

• 主页有更多其他篇章的方法，欢迎访问查看。
• 本篇我们继续介绍radash中函数柯里化和Number 相关的方法使用和源码解析。

函数柯里化

chain：创建一个函数链并依次执行

1. 使用说明
   1. 功能描述：用于创建一个函数链，该链依次执行一系列函数，每个函数的输出都是下一个函数的输入。这种模式常见于函数式编程，特别是在数据转换和流水线处理中。
   2. 参数：函数数组（或者说任意数量的函数）。
   3. 返回值：返回一个新的函数。
2. 使用代码示例

   import { chain } from 'radash'
   
   const add = (y: number) => (x: number) => x + y
   const mult = (y: number) => (x: number) => x * y
   const addFive = add(5)
   const double = mult(2)
   
   const chained = chain(addFive, double)
   
   chained(0) // => 10
   chained(7) // => 24
   

3. 源码解析

   // 定义一个名为 `chain` 的函数。
   export function chain(
     // `funcs` 是一个由函数组成的数组，这些函数将会被依次执行。
     // 每个函数都可以接受任意参数，并返回任何类型的值。
     ...funcs: ((...args: any[]) => any)[]
   ) {
     // `chain` 函数返回一个新的函数，这个新函数接受任意参数。
     return (...args: any[]) => {
       // 使用 `funcs` 数组中的第一个函数和传入的参数 `args` 来初始化累加器 `acc`。
       // 然后，使用 `reduce` 方法依次执行剩余的函数。
       return funcs.slice(1).reduce(
         // 在每个迭代中，将前一个函数的返回值作为下一个函数的输入。
         (acc, fn) => fn(acc),
         // 第一次迭代的初始值是 `funcs` 数组中第一个函数的执行结果。
         funcs[0](...args)
       )
     }
   }
   

   • 方法流程说明：
     1. chain 函数接受任意数量的函数作为参数，并返回一个新的函数。
     2. 当新函数被调用时，它首先使用传入的参数调用 funcs 数组中的第一个函数。
     3. 然后，它使用 reduce 方法依次执行 funcs 数组中剩余的函数，每个函数的返回值都被传递给下一个函数。
     4. 最终，返回最后一个函数的执行结果。

compose：依次执行传入的函数，每个函数的输出作为下一个函数的输入

1. 使用说明
   1. 功能描述：接受一系列函数作为参数，并返回一个新的函数。这个新函数将从右到左依次执行传入的函数，每个函数的输出作为下一个函数的输入。这是函数式编程中的组合（composition）模式。
   2. 参数：一系列函数（函数数组）。
   3. 返回值：一个新的函数。
2. 使用代码示例

   import { compose } from 'radash'
   
   const useZero = (fn: any) => () => fn(0)
   const objectize = (fn: any) => (num: any) => fn({ num })
   const increment = (fn: any) => ({ num }: any) => fn({ num: num + 1 })
   const returnArg = (arg: any) => (args: any) => args[arg]
   
   const composed = compose(
     useZero,
     objectize,
     increment,
     increment,
     returnArg('num')
   )
   
   composed() // => 2
   

3. 源码解析

   // 定义一个名为 `compose` 的函数。
   export function compose(
     // 使用展开运算符接收一个函数数组，每个函数可以接受任意参数并返回任何类型的值。
     ...funcs: ((...args: any[]) => any)[]
   ) {
     // `compose` 函数返回一个新的函数。
     return (...args: any[]) => {
       // 首先反转 `funcs` 数组，因为我们需要从右到左执行函数。
       // 然后使用 `reduce` 方法来组合这些函数。
       return funcs.reverse().reduce((acc, fn) => {
         // 在每次迭代中，将上一个函数的返回值（acc）作为当前函数（fn）的参数。
         return fn(acc);
       }, args); // 初始值 `args` 是传递给组合函数的参数。
     };
   }
   

   • 方法流程说明：
     1. 接受任意数量的函数作为参数。
     2. 返回一个新的函数，这个新函数接受任意参数。
     3. 当新函数被调用时，它首先反转 funcs 数组，以确保函数能够从右到左执行。
     4. 使用 reduce 方法应用每个函数，从最右边的函数开始，每个函数的返回值都作为下一个函数的输入。
     5. 最终，返回最左边函数的执行结果。

debounce：函数防抖

1. 使用说明
   1. 功能描述：创建一个防抖函数，该函数会在指定的延迟时间后执行。防抖（debouncing）是一种控制函数执行频率的技术，它确保函数只在最后一次被调用后的一段时间后执行，通常用于处理像窗口调整大小或键盘输入这样的连续事件。
   2. 参数：配置对象（包含delay——延时）、需要防抖的函数。
   3. 返回值：返回防抖后的函数。
2. 使用代码示例

   import { debounce } from 'radash'
   
   const makeSearchRequest = (event) => {
     api.movies.search(event.target.value)
   }
   
   input.addEventListener('change', debounce({ delay: 100 }, makeSearchRequest))
   

3. 源码解析

   // 定义一个泛型函数 `debounce`。
   export const debounce = <TArgs extends any[]>(
     // 第一个参数是一个对象，包含 `delay` 属性，它是函数延迟执行的毫秒数。
     { delay }: { delay: number },
     // 第二个参数 `func` 是需要被防抖的函数。
     func: (...args: TArgs) => any
   ) => {
     // 初始化一个变量 `timer` 用于保存 setTimeout 的返回值。
     let t