React高频面试题，值得珍藏！

浅浅的花香味﹌ 2023-06-25 02:12 20阅读 0赞

**说明+感悟：以下所有面试题在本人面试时基本都有出现，当初我在面试时和很多朋友一样，网上搜寻了大量的面试题，疯狂的背诵。说实话，很多面试题确实会被问道，你回答的可能也很标准，但不一定是面试官想要的答案。回答出面试官想要的答案尤为重要。本篇内容，我希望给大家带来的是知识而不是枯燥的背文**

## 前言：React 特点 ##

*  **1.声明式设计** −React采用声明范式，可以轻松描述应用。
 *  **2.高效** −React通过对DOM的模拟，最大限度地减少与DOM的交互。
 *  **3.灵活** −React可以与已知的库或框架很好地配合。
 *  **4.JSX** − JSX 是 JavaScript 语法的扩展。React 开发不一定使用 JSX ，但我们建议使用它。
 *  **5.组件** − 通过 React 构建组件，使得代码更加容易得到复用，能够很好的应用在大项目的开发中。
 *  **6.单向响应的数据流** − React 实现了单向响应的数据流，从而减少了重复代码，这也是它为什么比传统数据绑定更简单。

**问：React 的工作原理**  
     React 会创建一个虚拟 DOM(virtual DOM)。当一个组件中的状态改变时，React 首先会通过 "diffing" 算法来标记虚拟 DOM 中的改变，第二步是调节(reconciliation)，会用 diff 的结果来更新 DOM。

（如果有问到什么是react的工作原理，千万不能只回答这一句话。回答完这句话后分开谈虚拟dom,diff算法。回答的知识点越多证明了解越多，面试越有优势）

**问：react diff 原理（常考，大厂必考）**

1.  把树形结构按照层级分解，只比较同级元素。
2.  给列表结构的每个单元添加唯一的 key 属性，方便比较。
3.  React 只会匹配相同 class 的 component（这里面的 class 指的是组件的名字）
4.  合并操作，调用 component 的 setState 方法的时候, React 将其标记为 dirty.到每一个事件循环结束, React 检查所有标记 dirty 的 component 重新绘制.
5.  选择性子树渲染。开发人员可以重写 shouldComponentUpdate 提高 diff 的性能。

**问：为什么虚拟 dom 会提高性能?(必考)**  
      虚拟 dom 相当于在 js 和真实 dom 中间加了一个缓存，利用 dom diff 算法避免了没有必要的 dom 操作，从而提高性能。  
用 JavaScript 对象结构表示 DOM 树的结构；然后用这个树构建一个真正的 DOM 树，插到文档当中当状态变更的时候，重新构造一棵新的对象树。然后用新的树和旧的树进行比较，记录两棵树差异把 2 所记录的差异应用到步骤 1 所构建的真正的 DOM 树上，视图就更新了。

**问：当渲染一个列表时，何为 key？设置 key 的目的是什么？、**  
      Keys 会有助于 React 识别哪些 items 改变了，被添加了或者被移除了。Keys 应该被赋予数组内的元素以赋予(DOM)元素一个稳定的标识，选择一个 key 的最佳方法是使用一个字符串，该字符串能惟一地标识一个列表项。很多时候你会使用数据中的 IDs 作为 keys，当你没有稳定的 IDs 用于被渲染的 items 时，可以使用项目索引作为渲染项的 key，但这种方式并不推荐，如果 items 可以重新排序，就会导致 re-render 变慢。  
      render () \{  
          return (  
              <ul>  
                 \{this.state.todoItems.map((\{item, key\}) => \{  
                       return <li key=\{key\}>\{item\}</li>  
                   \})\}  
              </ul>  
           )  
        \}

（工作中一定要养成设置key的习惯）

**问：(组件的)状态(state)和属性(props)之间有何不同**  
    State 是一种数据结构，用于组件挂载时所需数据的默认值。State 可能会随着时间的推移而发生突变，但多数时候是作为用户事件行为的结果。可以用 this.setState()更新组件的状态。  
    Props 是 React 中属性的简写。它们是只读组件，必须保持纯，即不可变。它们总是在整个应用中从父组件传递到子组件。子组件永远不能将 prop 送回父组件。这有助于维护单向数据流，通常用于呈现动态生成的数据(Props是什么？)。Props(properties 的简写)则是组件的配置。props 由父组件传递给子组件，并且就子组件而言，props 是不可变的(immutable)。组件不能改变自身的 props，但是可以把其子组件的 props 放在一起(统一管理)。Props 也不仅仅是数据--回调函数也可以通过 props 传递。

**问：调用 setState 之后发生了什么？**  
     在代码中调用 setState 函数之后，React 会将传入的参数对象与组件当前的状态合并，然后触发所谓的调和过程。经过调和过程，React 会以相对高效的方式根据新的状态构建 React 元素树并且着手重新渲染整个 UI 界面。在 React 得到元素树之后，React 会自动计算出新的树与老树的节点差异，然后根据差异对界面进行最小化重渲染。在差异计算算法中，React 能够相对精确地知道哪些位置发生了改变以及应该如何改变，这就保证了按需更新，而不是全部重新渲染。

**问：使用 React 有何优点**  
        只需查看 render 函数就会很容易知道一个组件是如何被渲染的，JSX 的引入，使得组件的代码更加可读，也更容易看懂组件的布局，或者组件之间是如何互相引用的，支持服务端渲染，这可以改进 SEO 和性能，易于测试，React 只关注 View 层，所以可以和其它任何框架(如Backbone.js, Angular.js)一起使用。  
  
**问：展示组件(Presentational component)和容器组件(Container component)之间有何不同**  
      展示组件关心组件看起来是什么。展示专门通过 props 接受数据和回调，并且几乎不会有自身的状态，但当展示组件拥有自身的状态时，通常也只关心 UI 状态而不是数据的状态。  
      容器组件则更关心组件是如何运作的。容器组件会为展示组件或者其它容器组件提供数据和行为(behavior)，它们会调用 Flux actions，并将其作为回调提供给展示组件。容器组件经常是有状态的，因为它们是(其它组件的)数据源。  
  
**问：类组件(Class component)和函数式组件(Functional component)之间有何不同**  
      类组件不仅允许你使用更多额外的功能，如组件自身的状态和生命周期钩子，也能使组件直接访问 store 并维持状态，当组件仅是接收 props，并将组件自身渲染到页面时，该组件就是一个 '无状态组件(stateless component)'，可以使用一个纯函数来创建这样的组件。这种组件也被称为哑组件(dumb components)或展示组件。  
  
**问：指出(组件)生命周期方法的不同（生命周期必考）**  
    1.componentWillMount -- 多用于根组件中的应用程序配置  
    2.componentDidMount -- 在这可以完成所有没有 DOM 就不能做的所有配置，并开始获取所有你需要的数据；如果需要设置事件监听，也可以在这完成  
    3.omponentWillReceiveProps -- 这个周期函数作用于特定的 prop 改变导致的 state 转换  
    4.shouldComponentUpdate -- 如果你担心组件过度渲染，shouldComponentUpdate 是一个改善性能的地方，因为如果组件接收了新的 prop， 它可以阻止(组件)重新渲染。shouldComponentUpdate 应该返回一个布尔值来决定组件是否要重新渲染  
componentWillUpdate -- 很少使用。它可以用于代替组件的 componentWillReceiveProps 和 shouldComponentUpdate(但不能访问之前的 props)  
    5.componentDidUpdate -- 常用于更新 DOM，响应 prop 或 state 的改变  
    6.componentWillUnmount -- 在这你可以取消网络请求，或者移除所有与组件相关的事件监听器应该在 React 组件的何处发起 Ajax 请求  
    在 React 组件中，应该在 componentDidMount 中发起网络请求。这个方法会在组件第一次“挂载”(被添加到 DOM)时执行，在组件的生命周期中仅会执行一次。更重要的是，你不能保证在组件挂载之前 Ajax 请求已经完成，如果是这样，也就意味着你将尝试在一个未挂载的组件上调用 setState，这将不起作用。在 componentDidMount 中发起网络请求将保证这有一个组件可以更新了。

（回答生命周期问题时一定要注意其使用场景）  
  
**问：何为受控组件(controlled component)**  
     在 HTML 中，类似 <input>, <textarea> 和 <select> 这样的表单元素会维护自身的状态，并基于用户的输入来更新。当用户提交表单时，前面提到的元素的值将随表单一起被发送。但在 React 中会有些不同，包含表单元素的组件将会在 state 中追踪输入的值，并且每次调用回调函数时，如 onChange 会更新 state，重新渲染组件。一个输入表单元素，它的值通过 React 的这种方式来控制，这样的元素就被称为"受控元素"。  
  
**问：在 React 中，refs 的作用是什么**  
     Refs 可以用于获取一个 DOM 节点或者 React 组件的引用。何时使用 refs 的好的示例有管理焦点/文本选择，触发命令动画，或者和第三方 DOM 库集成。你应该避免使用 String 类型的 Refs 和内联的 ref 回调。Refs 回调是 React 所推荐的。

（面试官可能会问react中如何DOM节点）  
  
**问：何为高阶组件(higher order component)**  
     高阶组件是一个以组件为参数并返回一个新组件的函数。HOC 运行你重用代码、逻辑和引导抽象。最常见的可能是 Redux 的 connect 函数。除了简单分享工具库和简单的组合，HOC最好的方式是共享 React 组件之间的行为。如果你发现你在不同的地方写了大量代码来做同一件事时，就应该考虑将代码重构为可重用的 HOC。  
  
**问：使用箭头函数(arrow functions)的优点是什么**  
    1.作用域安全：在箭头函数之前，每一个新创建的函数都有定义自身的 this 值(在构造函数中是新对象；在严格模式下，函数调用中的 this 是未定义的；如果函数被称为“对象方法”，则为基础对象等)，但箭头函数不会，它会使用封闭执行上下文的 this 值。  
    2.简单：箭头函数易于阅读和书写  
    3.清晰：当一切都是一个箭头函数，任何常规函数都可以立即用于定义作用域。开发者总是可以查找 next-higher 函数语句，以查看 this 的值

**问：为什么建议传递给 setState 的参数是一个 callback 而不是一个对象**  
    因为 this.props 和 this.state 的更新可能是异步的，不能依赖它们的值去计算下一个 state。  
  
**问：除了在构造函数中绑定 this，还有其它方式吗？**  
     你可以使用属性初始值设定项(property initializers)来正确绑定回调，create-react-app 也是默认支持的。在回调中你可以使用箭头函数，但问题是每次组件渲染时都会创建一个新的回调。  
  
**问：怎么阻止组件的渲染？**  
    在组件的 render 方法中返回 null 并不会影响触发组件的生命周期方法  
  
**问：(在构造函数中)调用 super(props) 的目的是什么？**  
     在 super() 被调用之前，子类是不能使用 this 的，在 ES2015 中，子类必须在 constructor 中调用 super()。传递 props 给 super() 的原因则是便于(在子类中)能在 constructor 访问 this.props。  
  
**问：何为 JSX？**  
     JSX 是 JavaScript 语法的一种语法扩展，并拥有 JavaScript 的全部功能。JSX 生产 React "元素"，你可以将任何的 JavaScript 表达式封装在花括号里，然后将其嵌入到 JSX 中。在编译完成之后，JSX 表达式就变成了常规的 JavaScript 对象，这意味着你可以在 if 语句和 for 循环内部使用 JSX，将它赋值给变量，接受它作为参数，并从函数中返回它。  
  
  
**问：何为 Children？**  
     在JSX表达式中，一个开始标签(比如<a>)和一个关闭标签(比如</a>)之间的内容会作为一个特殊的属性props.children被自动传递给包含着它的组件。  
     这个属性有许多可用的方法，包括 React.Children.map，React.Children.forEach， React.Children.count， React.Children.only，React.Children.toArray。  
  
问：何为 redux(必问题)  
      Redux 的基本思想是整个应用的 state 保持在一个单一的 store 中。store 就是一个简单的 javascript 对象，而改变应用 state 的唯一方式是在应用中触发 actions，然后为这些 actions 编写 reducers 来修改 state。整个 state 转化是在 reducers 中完成，并且不应该有任何副作用。  
  
**问：在 Redux 中，何为 store**  
    Store 是一个 javascript 对象，它保存了整个应用的 state。与此同时，Store 也承担以下职责：  
    允许通过 getState() 访问 state  
    运行通过 dispatch(action) 改变 state  
    通过 subscribe(listener) 注册 listeners  
    通过 subscribe(listener) 返回的函数处理 listeners 的注销  
  
**问：何为 action**  
     Actions 是一个纯 javascript 对象，它们必须有一个 type 属性表明正在执行的 action 的类型。实质上，action 是将数据从应用程序发送到 store 的有效载荷。  
  
**问：何为 reducer  
     **一个 reducer 是一个纯函数，该函数以先前的 state 和一个 action 作为参数，并返回下一个 state。  
  
问：Redux Thunk 的作用是什么？  
     Redux thunk 是一个允许你编写返回一个函数而不是一个 action 的 actions creators 的中间件。如果满足某个条件，thunk 则可以用来延迟 action 的派发(dispatch)，这可以处理异步 action 的派发(dispatch)。  
  
问：何为纯函数(pure function)  
      一个纯函数是一个不依赖于且不改变其作用域之外的变量状态的函数，这也意味着一个纯函数对于同样的参数总是返回同样的结果。  
  
问：shouldComponentUpdate 是做什么的，（react 性能优化是哪个周期函数？）  
  
      shouldComponentUpdate 这个方法用来判断是否需要调用 render 方法重新描绘 dom。因为 dom 的描绘非常消耗性能，如果我们能在 shouldComponentUpdate 方法中能够写出更优化的 dom diff 算法，可以极大的提高性能。

问：React 中 refs 的作用是什么？  
  
    Refs 是 React 提供给我们的安全访问 DOM 元素或者某个组件实例的句柄。我们可以为元素添加 ref 属性然后在回调函数中接受该元素在 DOM 树中的句柄，该值会作为回调函数的第一个参数返回：  
class CustomForm extends Component \{  
  handleSubmit = () => \{  
    console.log("Input Value: ", this.input.value)  
  \}  
  render () \{  
    return (  
      <form onSubmit=\{this.handleSubmit\}>  
        <input  
          type='text'  
          ref=\{(input) => this.input = input\} />  
        <button type='submit'>Submit</button>  
      </form>  
    )  
  \}  
\}  
  
上述代码中的 input 域包含了一个 ref 属性，该属性声明的回调函数会接收 input 对应的 DOM 元素，我们将其绑定到 this 指针以便在其他的类函数中使用。另外值得一提的是，refs 并不是类组件的专属，函数式组件同样能够利用闭包暂存其值：  
  
function CustomForm (\{handleSubmit\}) \{  
  let inputElement  
  return (  
    <form onSubmit=\{() => handleSubmit(inputElement.value)\}>  
      <input  
        type='text'  
        ref=\{(input) => inputElement = input\} />  
      <button type='submit'>Submit</button>  
    </form>  
  )  
\}  
  
问：如果你创建了类似于下面的 Twitter 元素，那么它相关的类定义是啥样子的？  
  
<Twitter username='tylermcginnis33'>  
  \{(user) => user === null  
    ? <Loading />  
    : <Badge info=\{user\} />\}  
</Twitter>  
  
import React, \{ Component, PropTypes \} from 'react'  
import fetchUser from 'twitter'  
// fetchUser take in a username returns a promise  
// which will resolve with that username's data.  
class Twitter extends Component \{  
  // finish this  
\}  
  
如果你还不熟悉回调渲染模式（Render Callback Pattern），这个代码可能看起来有点怪。这种模式中，组件会接收某个函数作为其子组件，然后在渲染函数中以 props.children 进行调用：  
  
import React, \{ Component, PropTypes \} from 'react'  
import fetchUser from 'twitter'  
class Twitter extends Component \{  
  state = \{  
    user: null,  
  \}  
  static propTypes = \{  
    username: PropTypes.string.isRequired,  
  \}  
  componentDidMount () \{  
    fetchUser(this.props.username)  
      .then((user) => this.setState(\{user\}))  
  \}  
  render () \{  
    return this.props.children(this.state.user)  
  \}  
\}  
  
这种模式的优势在于将父组件与子组件解耦和，父组件可以直接访问子组件的内部状态而不需要再通过 Props 传递，这样父组件能够更为方便地控制子组件展示的 UI 界面。譬如产品经理让我们将原本展示的 Badge 替换为 Profile，我们可以轻易地修改下回调函数即可：  
  
<Twitter username='tylermcginnis33'>  
  \{(user) => user === null  
    ? <Loading />  
    : <Profile info=\{user\} />\}  
</Twitter>  
  
**问：为什么建议传递给 setState 的参数是一个 callback 而不是一个对象？**  
     因为 this.props 和 this.state 的更新可能是异步的，不能依赖它们的值去计算下一个 state。  
  
问：(在构造函数中)调用 super(props) 的目的是什么？  
     在 super() 被调用之前，子类是不能使用 this 的，在 ES2015 中，子类必须在 constructor 中调用 super()。传递 props 给 super() 的原因则是便于(在子类中)能在 constructor 访问 this.props。  
  
问：应该在 React 组件的何处发起 Ajax 请求？  
     在 React 组件中，应该在 componentDidMount 中发起网络请求。这个方法会在组件第一次“挂载”(被添加到 DOM)时执行，在组件的生命周期中仅会执行一次。更重要的是，你不能保证在组件挂载之前 Ajax 请求已经完成，如果是这样，也就意味着你将尝试在一个未挂载的组件上调用 setState，这将不起作用。在 componentDidMount 中发起网络请求将保证这有一个组件可以更新了。  
  
问：React 中有三种构建组件的方式？  
    React.createClass()、ES6 class 和无状态函数。  
问：react 组件的划分业务组件技术组件？

1.  根据组件的职责通常把组件分为 UI 组件和容器组件。
2.  UI 组件负责 UI 的呈现，容器组件负责管理数据和逻辑。
3.  两者通过 React-Redux 提供 connect 方法联系起来。

问：简述 flux 思想  
    lux 的最大特点，就是数据的"单向流动"。

1.  用户访问 View
2.  View 发出用户的 Action
3.  Dispatcher 收到 Action，要求 Store 进行相应的更新
4.  Store 更新后，发出一个"change"事件
5.  View 收到"change"事件后，更新页面

问：React 项目用过什么脚手架（本题是开放性题目）  
    creat-react-app Yeoman 等  
  
问：了解 redux 么，说一下 redux 吧  
     redux 是一个应用数据流框架，主要是解决了组件间状态共享的问题，原理是集中式管理，主要有三个核心方法，action，store，reducer，工作流程是 view 调用 store 的 dispatch 接收 action 传入 store，reducer 进行 state 操作，view 通过 store 提供的 getState 获取最新的数据，flux 也是用来进行数据操作的，有四个组成部分 action，dispatch，view，store，工作流程是 view 发出一个 action，派发器接收 action，让 store 进行数据更新，更新完成以后 store 发出 change，view 接受 change 更新视图。  
  
Redux 和 Flux 很像。主要区别在于 Flux 有多个可以改变应用状态的 store，在 Flux 中 dispatcher 被用来传递数据到注册的回调事件，但是在 redux 中只能定义一个可更新状态的 store，redux 把 store 和 Dispatcher 合并,结构更加简单清晰。  
  
新增 state,对状态的管理更加明确，通过 redux，流程更加规范了，减少手动编码量，提高了编码效率，同时缺点时当数据更新时有时候组件不需要，但是也要重新绘制，有些影响效率。一般情况下，我们在构建多交互，多数据流的复杂项目应用时才会使用它们。  
  
问：redux 有什么缺点？  
     一个组件所需要的数据，必须由父组件传过来，而不能像 flux 中直接从 store 取。  
当一个组件相关数据更新时，即使父组件不需要用到这个组件，父组件还是会重新 render，可能会有效率影响，或者需要写复杂的 shouldComponentUpdate 进行判断。  
  
问：什么是JSX？  
    JSX 是J avaScript XML 的简写。是 React 使用的一种文件，它利用 JavaScript 的表现力和类似 HTML 的模板语法。这使得 HTML 文件非常容易理解。此文件能使应用非常可靠，并能够提高其性能。下面是JSX的一个例子：  
render()\{  
    return(          
        <div>  
            <h1> Hello World from Edureka!!</h1>  
        </div>  
    );  
\}   
  
问：你了解 Virtual DOM 吗？解释一下它的工作原理。  
     Virtual DOM 是一个轻量级的 JavaScript 对象，它最初只是 real DOM 的副本。它是一个节点树，它将元素、它们的属性和内容作为对象及其属性。 React 的渲染函数从 React 组件中创建一个节点树。然后它响应数据模型中的变化来更新该树，该变化是由用户或系统完成的各种动作引起的。  
  
Virtual DOM 工作过程有三个简单的步骤。  
     1.每当底层数据发生改变时，整个 UI 都将在 Virtual DOM 描述中重新渲染。  
  
![format_png][]  
  
2.然后计算之前 DOM 表示与新表示的之间的差异。  
  
![format_png 1][]  
  
3.完成计算后，将只用实际更改的内容更新 real DOM。  
  
![format_png 2][]  
  
问：为什么浏览器无法读取JSX？  
  
浏览器只能处理 JavaScript 对象，而不能读取常规 JavaScript 对象中的 JSX。所以为了使浏览器能够读取 JSX，首先，需要用像 Babel 这样的 JSX 转换器将 JSX 文件转换为 JavaScript 对象，然后再将其传给浏览器。  
  
问：你怎样理解“在React中，一切都是组件”这句话。  
  
组件是 React 应用 UI 的构建块。这些组件将整个 UI 分成小的独立并可重用的部分。每个组件彼此独立，而不会影响 UI 的其余部分。  
  
问：怎样解释 React 中 render() 的目的。  
  
每个React组件强制要求必须有一个 render()。它返回一个 React 元素，是原生 DOM 组件的表示。如果需要渲染多个 HTML 元素，则必须将它们组合在一个封闭标记内，例如 <form>、<group>、<div> 等。此函数必须保持纯净，即必须每次调用时都返回相同的结果。  
  
  
  
问：React 中的箭头函数是什么？怎么用？  
  
箭头函数（=>）是用于编写函数表达式的简短语法。这些函数允许正确绑定组件的上下文，因为在 ES6 中默认下不能使用自动绑定。使用高阶函数时，箭头函数非常有用。  
  
问：React中的合成事件是什么？  
  
合成事件是围绕浏览器原生事件充当跨浏览器包装器的对象。它们将不同浏览器的行为合并为一个 API。这样做是为了确保事件在不同浏览器中显示一致的属性。  
  
问：如何模块化 React 中的代码？  
  
可以使用 export 和 import 属性来模块化代码。它们有助于在不同的文件中单独编写组件。  
  
问：如何在 React 中创建表单  
  
React 表单类似于 HTML 表单。但是在 React 中，状态包含在组件的 state 属性中，并且只能通过onChange事件用 setState() 更新。因此元素不能直接更新它们的状态，它们的提交是由 JavaScript 函数处理的。此函数可以完全访问用户输入到表单的数据。  
  
问：什么是受控组件和非受控组件区别是什么？  
  
我们要经常使用表单来搜集用户输入，例如<input><select><textearea>等元素都要绑定一个change事件，当表单的状态发生变化，就会触发onChange事件，更新组件的state。这种组件在React中被称为受控组件。  
  
如果一个表单组件没有value（单选和复选按钮对应的是checked ）时，就可以称为非受控组件。  
  
非受控组件-默认值  
在React的生命周期中，表单元素上的value属性将会覆盖DOM中的值。使用非受控组件时，通常你希望React可以为其制定初始值，但不再控制后续更新，解决这个问题的办法是你可以指定一个defaultValue属性而不是value。  
  
问：Redux遵循的三个原则是什么？

1.  单一事实来源：整个应用的状态存储在单个 store 中的对象/状态树里。单一状态树可以更容易地跟踪随时间的变化，并调试或检查应用程序。
2.  状态是只读的：改变状态的唯一方法是去触发一个动作。动作是描述变化的普通 JS 对象。就像 state 是数据的最小表示一样，该操作是对数据更改的最小表示。
3.  使用纯函数进行更改：为了指定状态树如何通过操作进行转换，你需要纯函数。纯函数是那些返回值仅取决于其参数值的函数。

问：你对“单一事实来源”有什么理解？  
  
Redux 使用 “Store” 将程序的整个状态存储在同一个地方。因此所有组件的状态都存储在 Store 中，并且它们从 Store 本身接收更新。单一状态树可以更容易地跟踪随时间的变化，并调试或检查程序。  
  
问：列出 Redux 的组件。  
  
Redux 由以下组件组成：  
  
Action – 这是一个用来描述发生了什么事情的对象。  
Reducer – 这是一个确定状态将如何变化的地方。  
Store – 整个程序的状态/对象树保存在Store中。  
View – 只显示 Store 提供的数据。  
  
问：数据如何通过 Redux 流动？  
  
![format_png 3][]  
  
问：如何在 Redux 中定义 Action？  
  
React 中的 Action 必须具有 type 属性，该属性指示正在执行的 ACTION 的类型。必须将它们定义为字符串常量，并且还可以向其添加更多的属性。在 Redux 中，action 被名为 Action Creators 的函数所创建。以下是 Action 和Action Creator 的示例：  
  
function addTodo(text) \{  
       return \{  
                type: ADD\_TODO,      
                 text  
    \}  
\}   
  
问：解释 Reducer 的作用。  
  
Reducers 是纯函数，它规定应用程序的状态怎样因响应 ACTION 而改变。Reducers 通过接受先前的状态和 action 来工作，然后它返回一个新的状态。它根据操作的类型确定需要执行哪种更新，然后返回新的值。如果不需要完成任务，它会返回原来的状态。  
  
问：Store 在 Redux 中的意义是什么？  
  
Store 是一个 JavaScript 对象，它可以保存程序的状态，并提供一些方法来访问状态、调度操作和注册侦听器。应用程序的整个状态/对象树保存在单一存储中。因此，Redux 非常简单且是可预测的。我们可以将中间件传递到 store 来处理数据，并记录改变存储状态的各种操作。所有操作都通过 reducer 返回一个新状态。  
  
问：Redux与Flux有何不同？

<table> 
 <thead> 
  <tr> 
   <th><strong>Flux</strong></th> 
   <th><strong>Redux</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1. Store 包含状态和更改逻辑</td> 
   <td>1. Store 和更改逻辑是分开的</td> 
  </tr> 
  <tr> 
   <td>2. 有多个 Store</td> 
   <td>2. 只有一个 Store</td> 
  </tr> 
  <tr> 
   <td>3. 所有 Store 都互不影响且是平级的</td> 
   <td>3. 带有分层 reducer 的单一 Store</td> 
  </tr> 
  <tr> 
   <td>4. 有单一调度器</td> 
   <td>4. 没有调度器的概念</td> 
  </tr> 
  <tr> 
   <td>5. React 组件订阅 store</td> 
   <td>5. 容器组件是有联系的</td> 
  </tr> 
  <tr> 
   <td>6. 状态是可变的</td> 
   <td>6. 状态是不可改变的</td> 
  </tr> 
 </tbody> 
</table>

问： Redux 有哪些优点？

1.  结果的可预测性 - 由于总是存在一个真实来源，即 store ，因此不存在如何将当前状态与动作和应用的其他部分同步的问题。
2.  可维护性 - 代码变得更容易维护，具有可预测的结果和严格的结构。
3.  服务器端渲染 - 你只需将服务器上创建的 store 传到客户端即可。这对初始渲染非常有用，并且可以优化应用性能，从而提供更好的用户体验。
4.  开发人员工具 - 从操作到状态更改，开发人员可以实时跟踪应用中发生的所有事情。
5.  社区和生态系统 - Redux 背后有一个巨大的社区，这使得它更加迷人。一个由才华横溢的人组成的大型社区为库的改进做出了贡献，并开发了各种应用。
6.  易于测试 - Redux 的代码主要是小巧、纯粹和独立的功能。这使代码可测试且独立。
7.  组织 - Redux 准确地说明了代码的组织方式，这使得代码在团队使用时更加一致和简单。

问：什么是React 路由？  
  
React 路由是一个构建在 React 之上的强大的路由库，它有助于向应用程序添加新的屏幕和流。这使 URL 与网页上显示的数据保持同步。它负责维护标准化的结构和行为，并用于开发单页 Web 应用。 React 路由有一个简单的API。  
  
问：为什么React Router v4中使用 switch 关键字 ？  
  
虽然 <div> 用于封装 Router 中的多个路由，当你想要仅显示要在多个定义的路线中呈现的单个路线时，可以使用 “switch” 关键字。使用时，<switch> 标记会按顺序将已定义的 URL 与已定义的路由进行匹配。找到\*\*\*个匹配项后，它将渲染指定的路径。从而绕过其它路线。  
  
问：为什么需要 React 中的路由？  
  
Router 用于定义多个路由，当用户定义特定的 URL 时，如果此 URL 与 Router 内定义的任何 “路由” 的路径匹配，则用户将重定向到该特定路由。所以基本上我们需要在自己的应用中添加一个 Router 库，允许创建多个路由，每个路由都会向我们提供一个独特的视图  
  
<switch>  
    <route exact path=’/’ component=\{Home\}/>  
    <route path=’/posts/:id’ component=\{Newpost\}/>  
    <route path=’/posts’   component=\{Post\}/>  
</switch>   
  
问：列出 React Router 的优点。

1.  就像 React 基于组件一样，在 React Router v4 中，API 是 'All About Components'。可以将 Router 可视化为单个根组件（<BrowserRouter>），其中我们将特定的子路由（<route>）包起来。
2.  无需手动设置历史值：在 React Router v4 中，我们要做的就是将路由包装在 <BrowserRouter> 组件中。
3.  包是分开的：共有三个包，分别用于 Web、Native 和 Core。这使我们应用更加紧凑。基于类似的编码风格很容易进行切换。

问：React Router与常规路由有何不同？

<table> 
 <thead> 
  <tr> 
   <th><strong>主题</strong></th> 
   <th><strong>常规路由</strong></th> 
   <th><strong>React 路由</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>参与的页面</strong></td> 
   <td>每个视图对应一个新文件</td> 
   <td>只涉及单个HTML页面</td> 
  </tr> 
  <tr> 
   <td><strong>URL 更改</strong></td> 
   <td>HTTP 请求被发送到服务器并且接收相应的 HTML 页面</td> 
   <td>仅更改历史记录属性</td> 
  </tr> 
  <tr> 
   <td><strong>体验</strong></td> 
   <td>用户实际在每个视图的不同页面切换</td> 
   <td>用户认为自己正在不同的页面间切换</td> 
  </tr> 
 </tbody> 
</table>

[format_png]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5sdWNrbG5rLmNvbS9maWxlc3BhdGgvaW1hZ2VzLzIwMTkwNzI1MTMzMTMzLnBuZw?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5sdWNrbG5rLmNvbS9maWxlc3BhdGgvaW1hZ2VzLzIwMTkwNzI1MTMzMjE3LnBuZw?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5sdWNrbG5rLmNvbS9maWxlc3BhdGgvaW1hZ2VzLzIwMTkwNzI1MTMzMjU4LnBuZw?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5sdWNrbG5rLmNvbS9maWxlc3BhdGgvaW1hZ2VzLzIwMTkwNzI1MTM1MzMwLnBuZw?x-oss-process=image/format,png