本文将探究 React API 的演变及其背后的心智模型。从 mixins 到 hooks，再到 RSCs，了解整个过程中的权衡。我们将对 React 的过去、现在和未来有一个更清晰的了解，便于深入研究遗留代码库并评估其他技术如何采用不同的方法并做出不同的权衡。

React API 简史
我们从面向对象的设计模式在 JS 生态系统中流行的时候开始，可以在早期的 React API 中看到这种影响。

Mixins
React.createClass API 是创建组件的原始方式。在 Javascript 支持原生类语法之前，React 就有自己的类表示。Mixins 是一种用于代码重用的通用 OOP 模式，下面是一个简化的例子：

function ShoppingCart() {
  this.items = [];
}

var orderMixin = {
  calculateTotal() {
    // 从 this.items 计算
  }
  // .. 其他方法
}

Object.assign(ShoppingCart.prototype, orderMixin)
var cart = new ShoppingCart()
cart.calculateTotal()

Javascript 不支持多重继承，因此 mixin 是重用共享行为和扩充类的一种方式。那该如何在使用 createClass 创建的组件之间共享逻辑呢？Mixins 是一种常用的模式，它可以访问组件的生命周期方法，允许我们组合逻辑、状态等：

var SubscriptionMixin = {
  getInitialState: function() {
    return {
      comments: DataSource.getComments()
    };
  },
  // 堆代码 duidaima.com
  // 当一个组件使用多个 mixin 时，React 会尝试合并多个mixin的生命周期方法，因此每个都会被调用
  componentDidMount: function() {
    console.log('do something on mount')
  },
  componentWillUnmount: function() {
    console.log('do something on unmount')
  },
}
// 将对象传递给 createClass
var CommentList = React.createClass({
  // 在 mixins 属性下定义它们
  mixins: [SubscriptionMixin, AnotherMixin, SomeOtherMixin],
  render: function() {
    var { comments, ...otherStuff } = this.state
    return (
      <div>
        {comments.map(function(comment) {
          return <Comment key={comment.id} comment={comment} />
        })}
      </div>
    )
  }
})

对于较小的应用，这种方式可以正常运行。但是，当 Mixin 应用到大型项目时，它们也有一些缺点：
1.名称冲突：Mixin 具有共享的命名空间，当多个 Mixin 使用同一个方法或状态的名称时，会发生冲突。
2.隐式依赖关系：确定哪个 Mixin 提供了哪些功能或状态比较麻烦。它们使用共享的属性键相互交互，从而创建隐式耦合。
3.难以理解和调试：Mixin 通常使组件更难以理解和调试。例如，上面多个 Mixin 都可以对 getInitialState 结果有影响，使得跟踪问题变得更加困难。
在感受到这些问题的痛苦之后，React 团队发布了“Mixins Considered Harmful”，不鼓励继续使用这种模式。

高阶组件
当 Javascript 中支持了原生类语法后，React 团队就在 v15.5 中弃用了 createClass API，支持原生类。在这个转变过程中，我们仍然按照类和生命周期的思路来思考，因此没有进行重大的心智模型转变。现在可以扩展包含生命周期方法的 Reacts Component 类：

class MyComponent extends React.Component {
  constructor(props) {
    // 在组件挂载到 DOM 之前运行
    // super 指的是父 Component 的构造函数
    super(props)
  }
  componentWillMount() {}
  componentDidMount(){}
  componentWillUnmount() {}
  componentWillUpdate() {}
  shouldComponentUpdate() {}
  componentWillReceiveProps() {}
  getSnapshotBeforeUpdate() {}
  componentDidUpdate() {}
  render() {}
}

考虑到 mixin 的缺陷，我们该如何以这种编写 React 组件的新方式来共享逻辑和副作用呢？这时候，高阶组件 (HOC) 就出现了，它的名字来源于高阶函数的函数式编程概念。它成为了替代 Mixin 的一种流行方式，并出现在像 Redux 这样的库的 API 中，例如它的 connect 函数，用于将组件连接到 Redux 存储。除此之外，还有 React Router 的 withRouter。

// 一个创建增强组件的函数，有一些额外的状态、行为或 props
const EnhancedComponent = myHoc(MyComponent);

// HOC 的简化示例
function myHoc(Component) {
  return class extends React.Component {
    componentDidMount() {
      console.log('do stuff')
    }
    render() {
      // 使用一些注入的 props 渲染原始组件
      return <Component {...this.props} extraProps={42} />
    }
  }
}

高阶组件对于在多个组件之间共享通用行为非常有用。它们使包装的组件保持解耦和通用性，以便可以重用。然而，HOC 遇到了与 mixin 类似的问题：
名称冲突：因为 HOC 需要转发和传播 ...this.props 到包装的组件中，所以嵌套的 HOC 相互覆盖可能会发生冲突。
难以静态类型检查：当多个嵌套的 HOC 将新的 props 注入到包装的组件中时，正确的 props 输入很难保证。
数据流模糊：对于 mixins，问题是“这个状态从哪里来？”；对于 HOC，问题是“这些 props 从哪里来？”。因为它们是在模块级别静态组合的，所以很难跟踪数据流。
除了这些陷阱之外，过度使用 HOC 还导致了深度嵌套和复杂的组件层次结构以及难以调试的性能问题。

Render props
render prop 模式作为 HOC 的替代品出现，这种模式由开源 API 如 React-Motion 和 downshift 以及构建 React Router 的开发人员推广普及。

<Motion style={{ x: 10 }}>
  {interpolatingStyle => <div style={interpolatingStyle} />}
</Motion>

主要思想就是将一个函数作为 props 传递给组件。然后组件会在内部调用该函数，并传递数据和方法，将控制反转回函数以继续渲染它们想要的内容。与 HOC 不同，组合发生在 JSX 内部的运行时，而不是静态模块范围内。它们没有名称冲突，因为很明确知道是从哪里来的，也更容易进行静态类型检查。

但是，当用作数据提供者时，它们可能会导致深度嵌套，创建一个虚假的组件层次结构：

<UserProvider>
  {user => (
    <UserPreferences user={user}>
      {userPreferences => (
        <Project user={user}>
          {project => (
            <IssueTracker project={project}>
              {issues => (
                <Notification user={user}>
                  {notifications => (
                    <TimeTracker user={user}>
                      {timeData => (
                        <TeamMembers project={project}>
                          {teamMembers => (
                            <RenderThangs renderItem={item => (
                                // ...
                            )}/>
                          )}
                        </TeamMembers>
                      )}
                    </TimeTracker>
                  )}
                </Notification>
              )}
            </IssueTracker>
          )}
        </Project>
      )}
    </UserPreferences>
  )}
</UserProvider>

这时，通常会将管理状态的组件与渲染 UI 的组件分开来处理。随着 Hooks 的出现，“容器”和“展示性”组件模式已经不再流行。但值得一提的是，这种模式在服务逇组件中有所复兴。目前，render props 仍然是创建可组合组件 API 的有效模式。

Hooks
Hooks 在 React 16.8 版本中成为了官方的重用逻辑的方式，巩固了将函数组件作为编写组件的推荐方式。Hooks 让在组件中重用和组合逻辑变得更加简单明了。相比于类组件，在其中封装并共享逻辑会更加棘手，因为它们可能分散在各种生命周期方法中的不同部分。

深度嵌套的结构可以被简化和扁平化。搭配 TypeScript，Hook 也很容易进行类型化。

function Example() {
  const user = useUser();
  const userPreferences = useUserPreferences(user);
  const project = useProject(user);
  const issues = useIssueTracker(project);
  const notifications = useNotification(user);
  const timeData = useTimeTracker(user);
  const teamMembers = useTeamMembers(project);
  return (
    <div>
      {/* 渲染内容 */}
    </div>
  );
}

权衡利弊
使用 Hooks 带来了很多好处，它们解决了类中的一些问题，但也需要付出一定的代价，下面来深入了解一下。

类 vs 函数
从组件消费者的角度来看，类组件到函数组件的转变并没有改变渲染 JSX 的方式。不过两种方式的思想是不同的：
1.类与有状态类的面向对象编程有着紧密联系。

2.函数则与函数式编程以及纯函数等概念有关联。

React 中的组件概念，以及使用 JavaScript 实现它的方式，以及我们试图使用现有术语来解释它，都增加了学习 React 的开发人员建立准确思维模型的困难度。对理解的漏洞会导致代码出现 bug。在这个过渡阶段中，一些常见的问题包括设置状态或获取数据时的无限循环，以及读取过时的 props 和 state。指令式响应事件和生命周期常常引入了不必要的状态副作用，我们可能并不需要它们。

开发者体验
在使用类组件时，有一套不同的术语，如 componenDid、componentWill、shouldComponent和将方法绑定到实例中。函数和 Hooks 通过移除外部类简化了这一点，使我们能够专注于渲染函数。每次渲染都会重新创建所有内容，因此需要能够在渲染周期之间保留一些内容。useCallback 和 useMemo 这样的 API 被引入就方便定义哪些内容应该在重新渲染之间保留下来。

在 Hooks 中需要明确管理依赖数组，再加上 hooks API 的语法复杂，对一些人来说富有挑战性。对其他人来说，hooks 大大简化了他们对 React 的思维模型和代码的理解。

实验性 React forget 旨在通过预编译 React 组件来改善开发者体验，从而消除手动记忆和管理依赖项数组，强调将事情明确化或尝试在幕后处理事情之间的权衡。

将状态和逻辑耦合到 React 中
许多状态管理库，如 Redux 或 MobX 将 React 应用的状态和视图分开处理。这与 React 最初作为MVC 中的“视图”标语保持一致。随着时间的推移，从全局的单块式存储向更多的位置迁移，特别是使用 render props 的“一切皆为组件”的想法，这也随着转向 hooks 得到了巩固。

React 演进背后的原则
我们可以从这些模式的演变中学到什么呢？哪些启发式可以指导我们做出有价值的权衡？

API 的用户体验
框架和库必须同时考虑开发者体验和最终用户体验。为开发者体验而牺牲用户体验是一种错误的做法，但有时候一个会优先于另一个。例如，CSS in JS库 styled-components，在处理大量动态样式时使用起来非常棒，但它们可能以最终用户体验为代价，我们需要对此进行权衡。

我们可以将 React 18 和 RSC 中的并发特性视为追求更好的最终用户体验的创新。这些就意味着更新用来实现组件的 API 和模式。函数的“snapshotting”属性（闭包）使得编写在并发模式下正常工作的代码变得更加容易，服务端的异步函数是表达服务端组件的好方法。

API 优于实现
上面讨论的 API 和模式都是从实现组件内部的角度出发的。虽然实现细节已经从 createClass 发展到了 ES6 类，再到有状态函数。但“组件”这个更高级别的API概念，它可以是有状态的并具有 effect，已经在整个演进过程中保持了稳定性：

return (
  <ImplementedWithMixins>
    <ComponentUsingHOCs>
      <ThisUsesHooks>
        <ServerComponentWoah />
      </ThisUsesHooks>
    </ComponentUsingHOCs>
  </ImplementedWithMixins>
)

专注于正确的原语
在React中，组件模型让我们可以用声明式的方式来编写代码，并且可以方便地在本地进行处理。这使得代码更加易于移植，可以更轻松地删除、移动、复制和粘贴代码，而不会意外破坏其中的任何隐藏的连接。遵循这个模型的架构和模式可以提供更好的可组合性，通常需要保持局部化，让组件捕获相关的关注点，并接受由此带来的权衡。与这个模型不符的抽象化会使数据流变得模糊，并使跟踪和调试变得难以理解和处理，从而增加了隐含的耦合。一个例子就是从类到 hooks 的转换，将分布在多个生命周期事件中的逻辑打包成可组合的函数，可以直接放置在组件中的相应位置。

小结
考虑 React 的一个好方法是将其视为一个库，它提供了一组可在其上构建的低级原语。React非常灵活，可以按照自己的方式来设计架构，这既是一种福音，也可能带来一些问题。这也解释了为什么像 Remix 和 Next 这样的高级应用框架如此受欢迎，它们会在React基础之上添加更强烈的设计意图和抽象化。