Write it at the front

currying , An interesting noun , I can't guess what it is literally ！？

Today, I'd like to share with you two ways to write Coriolis of functions , Understand thoroughly fn.length And fn.toString()

---

In computer science , currying （Currying） It is to transform a function that accepts multiple parameters into a single parameter ( First parameter of the original function ) Function of , And return the technique of taking the remaining arguments and returning the result of the new function . This technology was developed by Christopher Strachey With logicians Haskell Curry Named , Even though it is Moses Schnfinkel and Gottlob Frege Invented .【 From Baidu Encyclopedia 】

• for instance

let add1 = (a, b, c) => {
    
  return a + b + c
}

let add2 = (a) => {
    
  return b => {
    
    return c => {
    
      return a + b + c
    }
  }
}
console.log(add1(1, 2, 3));
console.log(add2(1)(2)(3));

• We put add1 It's written in add2 It's called the corellization of a function
• In general, Coriolis will get some parameters to generate a new function , Then use the new function to receive the remaining parameters
• such , We can fix some parameters , Generate some finer grained functions , This is more convenient for us to program ( Like functional programming )

Two ways of writing in curry

Some students saw the above code , Will say , Coritization is not easy , Just take it apart and write it .
however , If there are more and more parameters , The one above Terraced writing It is difficult to meet our needs , And it's cumbersome and not elegant enough

• therefore , For this cumbersome and repetitive step , We'll think about using recursive To achieve
• that , The problem is coming. , First we have to find the recursive exit of the function
  • Introduce a knowledge point fn.length Indicates the number of parameters required by a function , So we judge that the parameter is less than fn.length Just recursion , Otherwise, execute the function
• that , How to save the previous parameters ？
  • Our recursive function can use ES6 Medium rest Parameters To save the previous parameters
• that , How to get the parameters of the current function ？
  • Our recursive function will return a function , Of internal functions rest Parameters The parameters of the current function are
• therefore , The total parameter of our function is let _args=[...args,...params]（ It's used here ES6 The extension operator of ）

---

• Next question , What if the parameters of our corellized function are uncertain ？
  • fn.length Not sure , The previous method will not work
  • It's really a question , Simply put, by rewriting fn.toString() Get the result by implicit conversion

---

The following is divided into fn.length Known and unknown bring you two ways to write Coriolis

fn.length It is known that

• There are many known ways of writing described above
• 1. We used higher-order functions , In this way, you can get the previous parameters and the current parameters , So as to get all the current parameters
• 2. If the length of the current parameter is greater than or equal to fn.length, We will carry out fn function
  • We need to pass in the parameters and use apply, Because it didn't use this The pointer , The first parameter here is null
• 3. If the length of the current parameter is less than fn.length, We execute recursively _curry function
  • Again , We need to pass in parameters , Here, because the parameter passed in is not an array , So we use... In the form of parameter list call
• call and apply One difference is whether the second parameter is an array ！(call It's a list of parameters , Separate parameters one by one )
  • They can be converted by extension operator ！

fn.apply(null,_args)
fn.call(null,...args)
//  These two are the same 

---

function curry (fn, len = fn.length) {
    
  function _curry (fn, len, ...args) {
    
    return function (...params) {
    
      let _args = [...args, ...params]
      if (_args.length >= len) {
    
        return fn.apply(null, _args)
      } else {
    
        return _curry.call(null, fn, len, ..._args)
      }
    }
  }
  return _curry(fn, len)
}

function fn (a, b, c, d) {
    
  console.log(a, b, c, d);
}

let _fn = curry(fn)
_fn(1, 2, 3)(4)      // 1 2 3 4
_fn(4)(5, 6)(7, 8)   // 4 5 6 7 
_fn(4)(5,6)(7)(8)    //  Report errors 

Let's see the results

• The first coritization was successful
• The second one is also reflected in our code , We will not calculate the exceeded parameters
• The third one is wrong , Why? ？
  • The first three brackets , We end recursion , The next time you pass in parameters , Let's go up to the next floor return Is not a function , That's why I made a mistake
  • This actually belongs to fn.length Unknown category , So how do we deal with this situation ？ Keep looking down ！

fn.length Unknown

• In the unknown , If we want to save the transfer of parameters, we can only use recursive
• But because we don't have to judge when to call fn, We use closures to store our parameters
• So finally we return The result will be a Function function
  • The most magical place is here , We can judge res==15 The returned result is true,res The type of is a Function, The reason is that there is Implicit conversion
  • Say something simple. , Is to automatically call toString() Method , So we can rewrite toString() Method to solve fn.length Unknown problem
• We rewrite toString() function , Used reduce, This makes it easy to get all the parameters , Then we can write the logic

function add () {
    
  let args = [...arguments]
  let inner = function () {
    
    args.push(...arguments)
    return inner
  }
  inner.toString = () => {
    
    return args.reduce((pre, cur) => {
    
      return pre + cur
    })
  }
  return inner
}

const res = add(1)(2)(3)(4)(5)
console.log(res == 15);        // true
console.log(res.toString());   // 15

---

• It's addition , It can also be written as multiplication or other logic ！

Put a colored egg ！

• If the inner function of the second method is written as Anonymous functions What will happen ?
  • We often say ES6 Anonymous functions are convenient , Very elegant , Is there a problem with using it here ？

function add () {
    
  let args = [...arguments]
  let inner = () => {
            //  Changes have been made here , Change to anonymous function ！！！
    args.push(...arguments)
    return inner
  }
  inner.toString = () => {
    
    return args.reduce((pre, cur) => {
    
      return pre + cur
    })
  }
  return inner
}

---

• Although the anonymous function seems to write less code, it is very natural , But not here
• Write it as an anonymous function , result add(1)(2)(3)(4)(5)==5 It turned out to be wrong
  • Internal function push 了 arguments
  • Anonymous functions arguments It's a mess
  • If you don't believe it, look at the following function

function test () {
    
  console.log(arguments);
}
let test2 = () => {
    
  console.log(arguments[0]);
}
test()   //[Arguments] {}
test2()  // For a long , So want to use arguments Don't use anonymous functions ！