学习es7的Decorator(顺带写个react高阶组件)

时间 2019-11-06

标签学习 es7 decorator 顺带 react 高阶组件栏目 React 繁體版

原文原文链接

1. Decorator基本知识

在不少框架和库中看到它的身影，尤为是React和Redux，还有mobx中，那什么是装饰器呢。react

修饰器（Decorator）是一个函数，用来修改类的行为。不是很理解这种抽象概念，仍是看代码讲解实际些。git

//定义一个函数，也就是定义一个Decorator，target参数就是传进来的Class。
//这里是为类添加了一个静态属性
function addAge(target) {
  target.age = 2;
}

//在Decorator后面跟着Class，Decorator是函数的话，怎么不是addAge(MyGeekjcProject)这样写呢？
//我只能这样理解：由于语法就这样，只要Decorator后面是Class，默认就已经把Class当成参数隐形传进Decorator了(就是所谓的语法糖)。
@addAge
class MyGeekjcProject {}

console.log(MyGeekjcProject.age) // 2

1.1 传参修饰类

但上面这样只传了一个Class做为参数不够灵活怎么办？
咱们能够在外层套一个函数，只要最后返回的是一个Decorator便可，管你套多少个函数传多少个参数都无所谓。github

function addAge(age) {
  return function(target) {
    target.age = age;
  }
}

//注意这里，隐形传入了Class，语法相似于addAge(2)(MyGeekjcProject)
@testable(2)
class MyGeekjcProject {}
MyGeekjcProject.age // 2

@addAge(3)
class MyGeekjcProject {}
MyGeekjcProject.age // 3

1.2 修饰类的属性

下面是修改类的prototype对象编程

function description(target) {
  target.prototype.url = 'https://www.geekjc.com';
}

@description
class MyGeekjcProject {}

let geekjc = new MyGeekjcProject();
geekjc.url // https://www.geekjc.com

概念大概理解了，修饰器不只能够修饰类，还能够修饰类的属性redux

//假如修饰类的属性则传入三个参数，对应Object.defineProperty()里三个参数，具体不细说
//target为目标对象，对应为Class的实例
//name为所要修饰的属性名，这里就是修饰器紧跟其后的name属性
//descriptor为该属性的描述对象
//这里的Decorator做用是使name属性不可写，并返回修改后的descriptor
function readonly(target, name, descriptor){
  descriptor.writable = false;
  return descriptor;
}

class Person {
  @readonly
  name() { return `${this.first} ${this.last}` }
}

关于Object.defineProperty()能够看文章学习Object.defineProperty缓存

再看一个复杂的例子app

//定义一个Class并在其add上使用了修饰器
class Math {
  @log
  add(a, b) {
    return a + b;
  }
}

//定义一个修饰器
function log(target, name, descriptor) {
  //这里是缓存旧的方法，也就是上面那个add()原始方法
  var oldValue = descriptor.value;

  //这里修改了方法，使其做用变成一个打印函数
  //最后依旧返回旧的方法，真是巧妙
  descriptor.value = function() {
    console.log(`Calling "${name}" with`, arguments);
    return oldValue.apply(null, arguments);
  };

  return descriptor;
}

const math = new Math();
math.add(2, 4);

看完上面的代码就知道decorator有什么用了，修饰器不只能够修饰类的行为，还能够修饰类的属性。框架

2. react高阶组件

更通俗地描述为，高阶组件经过包裹（wrapped）被传入的React组件，通过一系列处理，最终返回一个相对加强（enhanced）的React组件，供其余组件调用。编程语言

3. 实现一个高阶组件

面咱们来实现一个最简单的高阶组件（函数），它接受一个React组件，包裹后而后返回。函数式编程

export default function withDescription(WrappedComponent) {
  return class HOC extends Component {
    render() {
      return <div>
        <div className="geekjc-description">
          极客教程(https://www.geekjc.com)致力于推广各类编程语言技术，也为了将来数字化世界，让人更容易找到操做数字化的方式，为了将来而生的编程学习平台，
          大部分资源是彻底免费的，而且会根据当前互联网的变化实时更新本站内容。
        </div>
        <WrappedComponent {...this.props}/>
      </div>
    }
  }
}

在其余组件里，咱们引用这个高阶组件，用来强化它。

@withDescription
export default class Geekjc extends Component {
  render() {
    return (
      <div>
        我是一个普通组件
      </div>
    );
  }
}

在这里使用了ES7里的decorator(能够看第一节的Decorator)，来提高写法上的优雅，可是实际上它只是一个语法糖，下面这种写法也是能够的。

const EnhanceDemo = withDescription(Geekjc);

随后，观察React组件树发生了什么变化，如图所示，能够发现Geekjc组件被HOC组件包裹起来了，符合了高阶组件的预期，即组件是层层包裹起来的，如同洋葱同样。

可是随之带来的问题是，若是这个高阶组件被使用了屡次，那么在调试的时候，将会看到一大堆HOC，因此这个时候须要作一点小优化，就是在高阶组件包裹后，应当保留其原有名称。

咱们改写一下上述的高阶组件代码，增长了getDisplayName函数以及静态属性displayName，此时再去观察DOM Tree。

function getDisplayName(component) {
  return component.displayName || component.name || 'Component';
}
export default function (WrappedComponent) {
  return class HOC extends Component {
    static displayName = `HOC(${getDisplayName(WrappedComponent)})`
    render() {
      return <div>
        <div className="geekjc-description">
          极客教程(https://www.geekjc.com)致力于推广各类编程语言技术，也为了将来数字化世界，让人更容易找到操做数字化的方式，为了将来而生的编程学习平台，
          大部分资源是彻底免费的，而且会根据当前互联网的变化实时更新本站内容。
        </div>
        <WrappedComponent {...this.props}/>
      </div>
    }
  }
}

此时，本来组件的名称正确地显示在了DOM Tree上。

这个简单的例子里高阶组件只作了一件事，那即是为被包裹的组件添加一个标题样式。这个高阶组件能够用到任何一个须要添加此逻辑的组件上，只须要被此高阶组件修饰便可。

由此能够看出，高阶组件的主要功能是封装并抽离组件的通用逻辑，让此部分逻辑在组件间更好地被复用。

4. 高阶组件的进阶用法

4.1 组件参数

仍是以上述例子为例，此高阶组件仅仅只是展现了关于网站的描述，可是为了更好的抽象，此描述应当能够被参数化，以下方式调用。

@withDescription('欢迎你们访问收藏(https://www.geekjc.com)') 
export default class Geekjc extends Component {
  render() {
    return (
      //...
    );
  }
}

withDescription须要被改写成以下形式，它接受一个参数，而后返回一个高阶组件（函数）。

export default function (description) {
  return function (WrappedComponent) {
    return class HOC extends Component {
      render() {
        return <div>
          <div className="geekjc-description">
            {description
              ?description
              : '我是描述'}
          </div>
          <WrappedComponent {...this.props}/>
        </div>
      }
    }
  }
}

使用ES6写法能够更加简洁。

export default(description) => (WrappedComponent) => class HOC extends Component {
  render() {
    return <div>
      <div className="geekjc-description">
        {description
          ? description
          : '我是描述'}
      </div>
      <WrappedComponent {...this.props}/>
    </div>
  }
}

如图能够看到，传入的参数已经反映在DOM Tree里了。

柯里化 Curry
概念：只传递函数的一部分参数来调用它，让它返回一个函数去处理剩下的参数。
函数签名：fun(params)(otherParams)
应用：在React里，经过柯里化，咱们能够经过传入不一样的参数来获得不一样的高阶组件。

4.2 基于属性代理的方式

属性代理是最多见的高阶组件的使用方式，上述描述的高阶组件就是这种方式。它经过作一些操做，将被包裹组件的props和新生成的props一块儿传递给此组件，这称之为属性代理。

export default function withHeader(WrappedComponent) {
  return class HOC extends Component {
    render() {
      const newProps = {
        test:'hoc'
      }
      // 透传props，而且传递新的newProps
      return <div>
        <WrappedComponent {...this.props} {...newProps}/>
      </div>
    }
  }
}

4.3 基于反向继承的方式

这种方式返回的React组件继承了被传入的组件，因此它可以访问到的区域、权限更多，相比属性代理方式，它更像打入组织内部，对其进行修改。具体的能够参考附录里提供的连接进行深刻学习。

export default function (WrappedComponent) {
  return class Inheritance extends WrappedComponent {
    componentDidMount() {
      // 能够方便地获得state，作一些更深刻的修改。
      console.log(this.state);
    }
    render() {
      return super.render();
    }
  }
}

4.4 组合多个高阶组件

上述高阶组件为React组件加强了一个功能，若是须要同时增长多个功能须要怎么作？这种场景很是常见，例如我既须要增长一个组件标题，又须要在此组件未加载完成时显示Loading。

@withDescription
@withLoading
class Demo extends Component{

}

使用compose能够简化上述过程，也能体现函数式编程的思想。

const enhance = compose(withHeader,withLoading);
@enhance
class Demo extends Component{

}

组合 Compose
compose能够帮助咱们组合任意个（包括0个）高阶函数，例如compose(a,b,c)返回一个新的函数d，函数d依然接受一个函数做为入参，只不过在内部会依次调用c,b,a，从表现层对使用者保持透明。
基于这个特性，咱们即可以很是便捷地为某个组件加强或减弱其特征，只须要去变动compose函数里的参数个数即可。
compose函数实现方式有不少种，这里推荐其中一个recompact.compose，详情见下方参考类库，也能够看我以前写的一篇文章 reduce与redux中compose函数

5. 与父组件区别

高阶组件做为一个函数，它能够更加纯粹地关注业务逻辑层面的代码，好比数据处理，数据校验，发送请求等，能够改善目前代码里业务逻辑和UI逻辑混杂在一块儿的现状。父组件则是UI层的东西，咱们先前常常把一些业务逻辑处理放在父组件里，这样会形成父组件混乱的状况。为了代码进一步解耦，能够考虑使用高阶组件这种模式。

6. 开源的高阶组件使用

6.1 recompact

recompact提供了一系列使用的高阶组件，能够加强组件的行为，能够利用此库学习高阶组件的写法。

import recompact from 'recompact'
import { pure, withProps } from 'recompact'

const enhance = recompact.compose(
  withProps({ className: 'beautiful' }),
  pure,
)
@enhance
class Demo extends Component{

}

6.2 React Sortable

经过使用此库提供的高阶组件，能够方便地让列表元素可拖动。

7. 参考

recompact：包含了一系列实用的高阶组件库
React Sortable：React拖动库
深刻理解 React 高阶组件：其中详细介绍了属性代理和反向继承的区别。