高阶组件（React）

高阶组件

高阶组件 （HOC） 是 React 中用于复用组件逻辑的一种高级技巧。HOC自身不是 React API 的一部分，它是一种基于 React 的组合特性而形成的设计模式。
具体来说，告诫在徐建是参数为组件，返回值为新组件的函数。
const EnhancedComponent = higherOrderComponent(WrappedComponent);
组件是将 props 转化为 UI 而高阶组件是将组件转化为另一个组件。
HOC 在 React 的第三方库中很常见，例如 Reduc 的 connect 和 Relay 的 createFragmentContainer 。

使用 HOC 解决横切关注点问题

注意

我们之间建议使用 mixins 用于解决横切关注点相关的问题。但我们已经意识到 mixins 会产生更多麻烦。以了解我们为什么要抛弃 mixins 以及如何转换现有组件。

组件是 React 中代码复用的基本单元。但你会发现某些模式并不合适传统组件。
例如，假设有一个 CommentList 组件，它订阅尾部数据源，用以渲染评论列表：

class CommentList extends React.Component {
	constructor(porps)P{
		super(props);
		this.handleChange = this.handleChange.bind(this);
		this.state = {
			//假设 “DataSource” 是个全局范围内的数据源变量
			comments：DataSource.getComments()
		};
	}
		
	componentDidMount() {
		// 订阅更改
		DataSource.addChangeListener(this.handleChange);	
	}
		
	componentWillUnmount() {
		// 清除订阅
		DataSource.removeChangeListener(this.handleChange);	
	}
	
	handleChange() {
		//当数据源更新时，更新组件状态
		this.setState({
			comments:DataSource.getCommments()	
		});
	}

	render() {
		return(
			<div>
				{this.state.comments.map((comment) => (
					<Comment comment={comment} key={comment.id}>
				))}
			</div>	
		);
	}
}

稍后，编写了一个用于订阅单个博客帖子的组件，该帖子遵循类似的模式：

class BlogPost extends React.Component {
	constructor(porps) {
		super(porps);
		this.handleChange = this.handleChange.bind(this);
		this.state = {
			blogPost: DataSource.getBlogPost(porps.id)	
		};	
	}
	
	componentDidMount() {
		DataSource.addChangeListener(this.handleChange);
	}
	
	componentWillUnmount() {
		DataSource.removeChangeListener(this.handleChange);	
	}
		
	handleChange(){
		this.setState({
			blogPost: DataSource.getBlogPost(this.props.id)
		});
	}
	
	render() {
		return <TextBlock text={this.state.blogPost} />;	
	}
}

CommentList 和 BlogPost 不同， 它们在 DataSource 上调用不同的方法，且渲染不同的结果。但它们的大部分实现都是一样的：

• 在挂载时，向 DataSource 添加一个更改侦听器。
• 在侦听器内部，当数据源发生变化时，调用 setState 。
• 在卸载时，删除侦听器。

你可以想象，在一个大型应用程序中，这种订阅 DataSource 和调用 setState 的模式将一次又一次的发生。我们需要一个抽象，允许我们在以一个地方定义这个逻辑，并在许多组件之间共享它。这正是高阶组件擅长的地方。

对于订阅了 DataSource 的组件，比如 CommentList 和 BlogPost ，我们可以编写一个创建组件函数。该函数将接受一个子组件作为它的其中一个参数，该子组件将订阅数据作为 prop。让我们调用函数 withSubscription：

const CommentListWithSubscription  = withSubscription(
	CommentList,
	(DataSource) => DataSource.getComents()
);

const BlogPostWithSubscription = withSubscription(
	BlogPost,
	(DataSource,props) => DataSource.getBlogPost(prop.id)
);

第一个参数是被包装组件。第二个参数通过 DataSource 和当前的 props 返回我们需要的数据。

当渲染 CommentListWillSubscription 和 BlogPostWithSubscription 时，CommentList 和 BlogPost 将传递一个 data prop，其中包含从 DataSource 检索到的最新数据：

//此函数接受一个组件
function withSubscription (WrappedComponent,selectData) {
	//	...并返回另一个组件...
	return class extends Rwact.Component {
		constructor(props){
			super(porps);
			this.handleChange = this.handleChange.bind(this);
			this.state ={
				data: selectData(DataSource,props)	
			};	
		}
		
	componentDidMount() {
		// ...负责订阅相关的操作...
		DataSource.addChangeListener(this.handleChange);	
	}
		
	componentWillUnmount(){
		DataSource.removeChangeListener(this.handleChange);
	}
		
	handleChange() {
		this.setState({
			data:selectData(DataSource,this.props)	
		});	
	}
	render(){
		// ...并使用新数据渲染被包装的组件！
		// 请注意，我们可能还会传递其他属性
		return <WrappedComponent data={this.state.data} {...this.porps} />;	
	}		
	};
}

请注意，HOC 不会修改传入的组件，也不会使用继承来复制其行为。相反，HOC通过将组件包装在容器组件中来组成新组件。HOC是纯函数，没有副作用。

被包装组件接受来自容器组件的所有 prop ，同时也接受一个新的用于 render 的 data prop。 HOC 不需要关心数据的使用方式或原因，而被包装组件也不需要关心数据是怎么来的。

因为 withSubscription 是一个普通函数，你可以更具需要对参数进行添加或者删除。例如，您可能希望使 data prop的名称可配置，以进一步将 HOC 与包装组件隔离开来。或者你可以接受一个配置 shouldComponentUpdate 的参数，或者一个配置数据源的参数。因为 HOC 可以控制组件的定义方式，这一切都变得有可能。

与组件一样， withSubscription 和包装组件之间的契约完全基于之间转递的props 。这种依赖方式使得替换 HOC 变的容易，只要它们为包装的组件提供相同的 prop 即可。例如你需要改用其他库来获取数据的时候，这就很有用。

不改变原始组件。使用组合。

不要试图在 HOC 中修改组件原型（或以其他方式改变它）。

function logProps(InputComponent) {
	InputComponent.portotype.componentWillReceiveProps = function(nextProps){
		console.log('current props: ',this.porps);
		console.log('Next porps: ',nextProps);
	};
	//返回原始的 input 组件，暗示它已经被修改。
	return InputComponent;
}

//每次调用 logProps 时，增强组件都会有 log 输出。
const EnhancedCompopnent = logProps(InputComponent);

这样坐会产生一些不良后果。其一是输入组件再也无法像 HOC 增强之前那样使用了。更重要的是，如果你再用拎一个同样会修改 componentWillReceiveProps 的 HOC 增强它，那么前面的 HOC 就会失效！同时，这个 HOC 也无法应用于没有生命周期的函数组件。

修改传入组件的 HOC 是一种糟糕的抽象方式。调用者必须知道他们是如何实现的，以避免与其他 HOC 发生冲突。

HOC 不应该修改传入组件，而应该使用组合的方式，通过将组件包装在容器组件中实现功能：

function logProps(WrappedComponent) {
	return class extends React.Component {
		componentWillReceiveProps(nextProps) {
			console.log('Current porps: ',this.props);
			console.log('Next props: ',nextProps);	
		}	
			
		render() {
			//将 input 组件包装在容器中，而不对其进行修改
			return <WrappedComponent {...this.props} />;	
		}
	}
}

该 HOC 与上文中修改传入组件的 HOC 功能相同，同时避免了出现冲突的情况。它同样适用于 class 组件和函数组件。而且因为它是一个纯函数，它可以与其他 HOC 组合，甚至可以与其自身组合。

你可能已经注意到 HOC 与容器组件模式之间有相似之处。容器组件担任分离将高层和低层关注的责任，由容器管理订阅和状态，并将 prop 传递给处理渲染 UI 。HOC 使用容器作为其实现的一部风，你可以将 HOC 视为参数化容器组件。

约定：将不相关的 props 传递给被包裹的组件

HOC 为组件添加特性。自身不应该大幅改变约定。HOC返回的组件与原组件应保持类似的接口。

HOC应该透传与自身无关的 props 。大多数 HOC 都应该包含一个类似于下面的 render 方法：

render() {
	//过滤掉不是这个 HOC 额外的 props ，且不要进行透传
	const { extraProp, ...passThroughProps } = this.props;
		
	// 将 props 注入到被包装的组件中。
	// 通常为 state 的值或者实例方法。
	const injectedProp = someStateOrInstanceMethod;
	
	// 将 props 传递给被包装组件
	return (
		<WrappedComponent
			injectedProp={injectedProp}
			{...passThroughProps}
		/>	
	);
}

这种约定保证了 HOC 的灵活性以及可复用性。

约定：最大化可组合性

并不是所有的 HOC 都一样。有时候它仅接受一个参数，也就是被包裹的组件：

const NavbarWithRouter = withRouter(Navbar);

HOC 通常可以接受多个参数。比如在 Relay 中，HOC 额外接受了一个配置对象用于指定组件的数据依赖：

const CommentWithRelay = Relay.createContainer(Comment,config);

最常见的 HOC 签名如下：

// React Redux 的 ’connect‘函数
const ConnectedComment = connect(commentSelector，commentActios)(CommentList);

看不懂的话解释一下：

// connect 是一个函数，它的返回值为另一个函数。
const enhance = connect(commentListSelector,commentListActions);
// 返回值为 HOC ，它会返回已经连接 Redux store 的组件
const ConnectedComment = enhance(CommentList);

换句话说，connect 是一个返回高阶组件的高阶函数！

这种形式可能看起来令人困惑或不必要，但它有一个有用的属性。像 connect 函数返回的单参数 HOC 具有签名 Component => Component 。 输出类型于输入类型相同的函数很容易组合在一起。

// 而不是这样...
const EnhancedComponent = withRouter(connect(commentSelector)(WrappedComponent))

// ... 你可以编写组合工具函数
// compose(f,g,h)等同于 (...args) => f(g(h(...args)))
const enhance = compose(
	// 这些都是但参数的 HOC
	withRouter,connect(commentSelector)
)
const EnhancedComponent = enhance(WrappedComponent)

（同样的属性也允许 connect 和其他 HOC 承担装饰器的角色，装饰器是一个实验性的 javascript 提案。）

许多第三方库都提供了 compose 工具函数，包括 lodash （比如lodash.flowRight），Redux 和 Ramda。

约定：包装显示名称以便轻松调式

HOC 创建的容器组件会与任何其他组件一样，会显示在 React Developer Tools中。为了方便调式，请选择一个显示名称，以表明它是 HOC 的产物。

最常见的方式是用 HOC 包住被包装组件的显示名称，比如高阶组件名为 withSubscription，并且被包装组件的显示名称为 ==CommentList ==，显示名称应该为 WithSubscription（CommentList）：

function withSubscription(WrappedComponent) {
	class WithSubscription.displayName = `withSubscription(${getDisplayName(WrappedComponent)})`;
	return WithSubscription;
}

function getDisplayName(WrappedComponent) {
	return WrappedComponent.displayName ||WrappedComponent.name || 'Component';
}

注意事项

高阶组件有一些需要注意的地方，对于 React 新手来说可能并不容易发现。

不要再 render 方法中使用 HOC

React 的 diff 算法（称为协调） 使用组件标识来确定它是应该更新现有子树还是将其丢弃并挂载子树。如果从 render 返回的组件与前一个渲染中的组件相同（ === ）则 React 通过将子树与新子树进行区分来递归更新子树。如果它们不相等，则完全卸载前一个子树。
通常，你不需要考虑这个。但对 HOC 来说很重要，因为这代表你不应该在组件的 render 方法中对一个组件应用 HOC：

render(){
	//每次调用render 函数都会创建一个新的EnhancedComponent 
	//EnhancedComponent1 !== EnhancedComponent2
	const EnhancedComponent = enhance(MyComponent);
	//这将导致子树每次渲染都会进行卸载。和重新挂载的操作！
	return <EnhancedComponent />; 
}

这不仅仅是性能问题-重新挂载租价回导致该组件及其所有子组件的状态丢失。

如果在组件之外创建 HOC ，这样一来组件只会创建一次。因此，每次 render 时都会时同一个组件。一般来说，这跟你的与其表现是一致的。

在极少树情况下，你需要动态调用 HOC ，你可以在组件的生命周期方法或其构造函数中进行调用。

务必赋值静态方法

有时在 React 组件上定义静态方法很有用。例如，Relay 容器暴露了一个静态方法 getFragment 以方便组合 GraphQL 片段。

但是，当你将 HOC 应用于组件时，原始组件将使用容器组件进行包装。这意味着新组件没有原始组件的任何静态方法。

//定义静态函数
WrappedComponent.staticMethod = function() {/*...*/}
// 现在使用 HOC
const EnhancedComponent = enhance(WrappedComponent);

//增强组件没有 staticMethod 
typeof EnchancedComponent.staticMethod === 'undefined' // true

解决这个问题，可以在返回之前把这些方法拷贝到容器组件上：

function enhance(WrappedComponent) {
	class Enhance extends React.Component {/*...*/}
	// 必须准确知道应该拷贝那些方法
	Enhance.staticMethod = WrappedComponent.staticMethod;
	return Enhance;
}

但要这样做，需要知道那些方法应该被拷贝。你可以使用 hoist-non-react-statics 自动拷贝所有非 React 静态方法:

import hoistNonReactStatic from 'hoist-non-react-statics';
function enhance(wrappedComponent){
	class Enhance extends React.Component {/*..*/}
	hoistNonReactStataic(Enhance,WrappedComponent);
	return Enhance;
}

除了导出组件，另一个可行的方案是再额外导出这个静态方法。

//使用这种方式代替 ...
MyComponent.someFuntion = someFunction;
report default MyComponent;

// ...单独导出该方法...
export { someFunction };

// ...并在要使用的组件中，import 它们
import MyComponent，{ someFunction } from './MyComponent.js';