纯函数-函数柯里化-组合函数

纯函数

定义:当一个函数在相同的输入值事,产生相同的输出并且函数不会产生副作用，比如修改了全局变量,修改参数或者改变外部的存储;
var names=[“a”,“b”,“c”]
var newNamenames.slice(0,3) 不会改变原数组 slice ->this 就是一个纯函数
splice(2)调用时 改变了原数组,就不是一个纯函数

作用：1，防止输入的内容被任意篡改,并且自己确定的输入,一定有确定的输出

javascript柯里化

定义:只传递给函数一部分参数来调用它，让它返回一个函数去处理剩余的参数，这个过程就叫做柯里化

function sum1(x)
{ 
return function(y)
{
 return function(z)
 {
 reuturn x+y+z
 }
 ]
 }

var result=sum1(10)(20)(30)
console.log(result)
为什么需要柯里化: 当我们希望一个函数处理的问题尽可能的单一,而不是将一大堆的处理过程交给一个函数来处理

// 手写函数柯里化
function hyCarrying(fn) {
function carried(…args) {
if (args.length >= fn.length) {
return fn.apply(this,args)
}else{
function carried2(…args2){
return carried.apply(this,[…args,…args2])
}
return carried2
}
}
return carried

}
var newsFn=hyCarrying(add)
console.log(newsFn(10)(50,40));

组合函数:
(1)
function double(num) {
return num + 2
}

function square(num) {
return num ** 2
}
var result=square(double(10))
console.log(result);
(2)
function compensens(m,n){
return function(count)
{
return n(m(count))
}
}
var ls=compensens(double,square)
var res=ls(10)
console.log(res,‘res’);
(3)

function double(num) {
return num + 2
}
function square(num) {
return num ** 2
}
function compFall(…fns) {
var length = fns.length
for (var i = 0; i < length; i++) {
if (typeof fns[i] !== ‘function’) {
throw new TypeError(‘必须为函数’)
}

function compose(...args) {
  var index = 0
  var result = length ? fns[index].apply(this, args) : args
  while (++index < length) {
    var result = fns[index].call(this, result)
  }
  return result
}
return compose

}
}
var result = compFall(double, square)
var res = result(10)
console.log(res, ‘res’);