函数式编程

函数式编程

纯函数

• 一个函数只依赖于它的参数，并且在执行过程中没有副作用（定义）

var a=1;
const foo=(b)=>a+b;
foo(2);

此时foo不是一个纯函数，因为它返回的值依赖于它的外部变量a，在不知道a的情况下，我们并不能保证foo(2)返回3

const a = 1
const foo = (x, b) => x + b

此时满足于纯函数第一个条件，只依赖于它的形参

const a = 1
const foo = (obj, b) => {
  obj.x = 2
  return obj.x + b
}
const counter = { x: 1 }
foo(counter, 2) // => 4
counter.x // => 2

foo在执行中对外部的counter产生了影响，因此此时不是纯函数

const foo = (b) => {
  const obj = { x: 1 }
  obj.x = 2
  return obj.x + b
}

此时虽然修改了obj，obj为函数内部对象，但是它对于外部没有产生可观察的外部变化，因此此时它为纯函数

总结

一个函数的返回结果只依赖于它的参数，并且在执行过程里面没有副作用，我们就把这个函数叫做纯函数。

柯里化

• 定义：是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术

//普通函数
function add(x,y){
 return x+y
}
//柯里化
function addCury(x){
 return function(y){
  return x+y
 }
}
add(1,2) //3
addCury(1)(2) //3

• 实际上就是把add函数的x，y两个参数变成了先用一个函数接收x然后返回一个函数去处理y参数。

柯里化优势

• 参数复用

//普通函数
function check(reg,txt){
 return reg.test(txt)
}
check(/\d+/g, 'test')       //false
check(/[a-z]+/g, 'test')    //true
//柯里化
function curCheck(reg){
 return function(txt){
  return reg.test(txt);
 }
}
var hasNumber = curCheck(/\d+/g)
var hasLetter = curCheck(/[a-z]+/g)
hasNumber('test1')      // true
hasNumber('testtest')   // false
hasLetter('21212')      // false

• 提前确认
• 延迟执行

面试题

// 实现一个add方法，使计算结果能够满足如下预期：
add(1)(2)(3) = 6;
add(1, 2, 3)(4) = 10;
add(1)(2)(3)(4)(5) = 15;
//函数
function add() {
     var _args=Array.prototype.slice.call(arguments);
     var _adder=function () {
      _args.push(...arguments);
      return _adder;
     }
     _adder.toString=function () {
       return _args.reduce(function (a,b) {
         return a+b;
       })
     }
     return _adder;
   }

函数式编程与面向对象编程

• 函数式编程

const state={
     Animal:0,
     DOG:1,
     speak:['makes a noise','barks']
   }
   const actions={
     of:function (name) {
       return function (speak) {
         speak(name)
       }
     },
     speak:function (kind) {
       return function (name) {
         console.log(name+state.speak[kind])
       }
     }
   }
   let aa=actions.of('Mitzie');
   aa(actions.speak(state.DOG)); //Mitziebarks

• 面向对象编程

class Animal{
     constructor(name){
       this.name=name;
     }
     speak(){
       console.log(this.name+' make a noise');
     }
   }
   class Dog extends Animal{
     constructor(name,sex){
       super(name);
       this.sex=sex;
     }

     speak(){
       console.log(this.name+' barks');//dog barks
       console.log(this.name+'的性别是：'+this.sex);//dog的性别是：公
     }
     parentSpeak(){
       super.speak();//dog make a noise
     }
   }
   let bb=new Dog('dog','公');
   bb.speak();
   bb.parentSpeak();