react高級特性

• 2019 年 10 月 6 日
• 筆記

• 程式碼分割
• Context
• 錯誤邊界
• Fragments
• Portals
• forwardRef
• 小結

用了那麼久的react, 竟不知道到原來react有那麼多高級特性. 假期沒事幹, 試用了下一些react高級特性. 下為試用記錄.

程式碼分割

將一個龐大的單頁應用打包成一個龐大的js, 首屏載入可能會非常糟糕, 這時可能會考慮做程式碼分割, 即根據模組或者路由分開打包js, 非同步按需載入組件.

藉助webpack和一些非同步組件庫(比如react-loadable, 也可以自己實現非同步組件)就能很方便的實現這一點. 比如像下面這樣:

// router.js  import React from 'react';  import Loadable from 'react-loadable';    const Loading = () => <div>Loading...</div>;    ///////////////頁面路由配置////////////////    const Routers = {      // 首頁      '/': Loadable({          loader: () => import(/* webpackChunkName: "index" */'./pages/Index.jsx'),          loading: Loading,        }),      // 首頁      '/index': Loadable({          loader: () => import(/* webpackChunkName: "index" */'./pages/Index.jsx'),          loading: Loading,      }),      '/404': Loadable({          loader: () => import(/* webpackChunkName: "404" */'./pages/404/index'),          loading: Loading,      })  }    export default Routers;    // App.js  import React, { Component } from 'react';  import { BrowserRouter as Router, Route, Link, Switch } from "react-router-dom";    import Routers from './router';    class App extends Component {    componentDidMount() {      }    render() {      return (        <Router>            <Switch>              <Route path="/" exact component={Routers["/"]} />              <Route path="/index" exact component={Routers["/index"]} />              <Route component={Routers['/404']} />            </Switch>        </Router>      );    }  }    export default App;

我們直接使用Loadable創建非同步組件, 在合適的時候使用, webpack會幫我做好程式碼分割, Loadable可以幫我們維護好非同步組件的狀態, 並且能夠支援定義載入中的組件. 上邊demo完整版參見web-test.

其實, react已經原生提供了非同步組件的支援, 其使用和Loadable大體相同, 但是看起來會更加優雅.

import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';  import React, { Suspense, lazy } from 'react';    const Home = lazy(() => import(/* webpackChunkName: "home" */'./pages/Home'));  const About = lazy(() => import(/* webpackChunkName: "about" */'./pages/About'));    const App = () => (    <Router>      <Suspense fallback={<div>Loading...</div>}>        <Switch>          <Route exact path="/" component={Home} />          <Route path="/about" component={About} />        </Switch>      </Suspense>    </Router>  );    export default App;

這裡我們使用React.lazy方法創建非同步組件, 和Loadable類似, 也是使用了import方法, webpack會幫我們處理好這個import. 不同的是他並不支援定義loading, loading的自定義可以使用Suspense組件. 在其fallback中可以創建自定義的loading組件. 這個demo的完整版可參考react-demo.

Context

第一次接觸Context是看redux源碼發現的, Context特性是redux實現的核心之一. Context可以讓很深的props的傳遞變得簡單優雅, 不再需要逐級傳遞.

假設有如下組件, D組件需要拿A組件中數據, 可能需要從A通過props 傳到B, 從B傳到C, 從C 在通過props傳到D. 非常麻煩.

<A>    <B>      <C>        <D>        </D>      </C>    </B>  </A>

看一下通過Context特性如何實現.

// MyContext.js  import React from 'react';    const MyContext = React.createContext("我是來自A的默認值");  export default MyContext;    // A.js  import React from 'react';  import B from './B';  import MyContext from './MyContext';  export default class A extends React.Component {      constructor(props) {          super(props);      }      render() {          return (              <div>                  <MyContext.Provider value={'我是來自A的數據'}>                      <B />                  </MyContext.Provider>              </div>          )      }  }    // B.js  import React from 'react';  import C from './C';  class B extends React.Component {      render() {          return (              <div>                  <h3>我是B組件</h3>                  <C />              </div>          );      }  }  export default B;    // C.js  import React from 'react';  import MyContext from './MyContext';  import D from './D';    function C() {      return (          <MyContext.Consumer>              {                  (value) => (                      <div>                          <h3>我是C組件</h3>                          <div>我是來自A的數據: {value}</div>                          <D />                      </div>                  )              }          </MyContext.Consumer>      )  }    export default C;    // D.js  import React from 'react';  import MyContext from './MyContext';    class D extends React.Component {      render() {          let context = this.context;          return (              <div>                  <h3>我是D組件</h3>                  <div>我拿到了A中傳遞過來的數據</div>                  {context}              </div>          );      }  }    D.contextType = MyContext;    export default D;

可以看到在C組件和D組件沒有通過任何props傳遞就拿到了A中的數據. 這個demo的完整版可參考react-demo. 這個例子可能看起來直接將需要共享的變數放到全局就可以了, 但是放到全局的當他變更後沒法setState重新渲染, 而Context中的數據可以通過setState引起重新渲染.

從上邊的Demo來看, Context的使用非常簡單

1. 使用React.createContext()創建Context
2. 在父組件使用Context.Provider傳值
3. 在子組件消費

• 對於class組件可以生命靜態變數contextType消費, 見D
• 對於函數是組件, 可以用Context.Consumer來消費, 見C

## 使用 PropTypes 進行類型檢查

一個被人調用的組件可以通過PropTypes對props參數類型進行校驗, 將類型問題及早通知給調用方. 通過給組件指定靜態屬性propTypes並結合prop-types庫可以很方便實現. prop-types需要單獨安裝.

如下是prop-types提供的一些校驗器, 來自react中文文檔

import PropTypes from 'prop-types';    MyComponent.propTypes = {    // 你可以將屬性聲明為 JS 原生類型，默認情況下    // 這些屬性都是可選的。    optionalArray: PropTypes.array,    optionalBool: PropTypes.bool,    optionalFunc: PropTypes.func,    optionalNumber: PropTypes.number,    optionalObject: PropTypes.object,    optionalString: PropTypes.string,    optionalSymbol: PropTypes.symbol,      // 任何可被渲染的元素（包括數字、字元串、元素或數組）    // (或 Fragment) 也包含這些類型。    optionalNode: PropTypes.node,      // 一個 React 元素。    optionalElement: PropTypes.element,      // 一個 React 元素類型（即，MyComponent）。    optionalElementType: PropTypes.elementType,      // 你也可以聲明 prop 為類的實例，這裡使用    // JS 的 instanceof 操作符。    optionalMessage: PropTypes.instanceOf(Message),      // 你可以讓你的 prop 只能是特定的值，指定它為    // 枚舉類型。    optionalEnum: PropTypes.oneOf(['News', 'Photos']),      // 一個對象可以是幾種類型中的任意一個類型    optionalUnion: PropTypes.oneOfType([      PropTypes.string,      PropTypes.number,      PropTypes.instanceOf(Message)    ]),      // 可以指定一個數組由某一類型的元素組成    optionalArrayOf: PropTypes.arrayOf(PropTypes.number),      // 可以指定一個對象由某一類型的值組成    optionalObjectOf: PropTypes.objectOf(PropTypes.number),      // 可以指定一個對象由特定的類型值組成    optionalObjectWithShape: PropTypes.shape({      color: PropTypes.string,      fontSize: PropTypes.number    }),      // An object with warnings on extra properties    optionalObjectWithStrictShape: PropTypes.exact({      name: PropTypes.string,      quantity: PropTypes.number    }),      // 你可以在任何 PropTypes 屬性後面加上 `isRequired` ，確保    // 這個 prop 沒有被提供時，會列印警告資訊。    requiredFunc: PropTypes.func.isRequired,      // 任意類型的數據    requiredAny: PropTypes.any.isRequired,      // 你可以指定一個自定義驗證器。它在驗證失敗時應返回一個 Error 對象。    // 請不要使用 `console.warn` 或拋出異常，因為這在 `onOfType` 中不會起作用。    customProp: function(props, propName, componentName) {      if (!/matchme/.test(props[propName])) {        return new Error(          'Invalid prop `' + propName + '` supplied to' +          ' `' + componentName + '`. Validation failed.'        );      }    },      // 你也可以提供一個自定義的 `arrayOf` 或 `objectOf` 驗證器。    // 它應該在驗證失敗時返回一個 Error 對象。    // 驗證器將驗證數組或對象中的每個值。驗證器的前兩個參數    // 第一個是數組或對象本身    // 第二個是他們當前的鍵。    customArrayProp: PropTypes.arrayOf(function(propValue, key, componentName, location, propFullName) {      if (!/matchme/.test(propValue[key])) {        return new Error(          'Invalid prop `' + propFullName + '` supplied to' +          ' `' + componentName + '`. Validation failed.'        );      }    })  };

也可以給props指定默認值

class Greeting extends React.Component {    render() {      return (        <h1>Hello, {this.props.name}</h1>      );    }  }    // 指定 props 的默認值：  Greeting.defaultProps = {    name: 'Stranger'  };    // 渲染出 "Hello, Stranger"：  ReactDOM.render(    <Greeting />,    document.getElementById('example')  );

檢驗和默認值也可以這樣寫

class Greeting extends React.Component {    static defaultProps = {      name: 'stranger'    }    static propTypes = {      name: PropTypes.string,    }    render() {      return (        <div>Hello, {this.props.name}</div>      )    }  }

錯誤邊界

錯誤邊界是一種 React 組件，這種組件可以捕獲並列印發生在其子組件樹任何位置的 JavaScript 錯誤，並且，它會渲染出備用 UI，而不是渲染那些崩潰了的子組件樹。錯誤邊界在渲染期間、生命周期方法和整個組件樹的構造函數中捕獲錯誤。

當子組件拋出錯誤時, 下邊的兩個生命周期會被觸發, 可以在這裡邊處理錯誤, 顯示降級UI, 向服務端上報錯誤.

錯誤邊界組件核心生命周期如下

static getDerivedStateFromError()  componentDidCatch()

下面是個小demo

// index.js    import React from 'react';  import ErrorComponent from './ErrorComponent';    export default class Home extends React.Component {      constructor(props) {          super(props);          this.state = {              hasError: false,          }      }        static getDerivedStateFromError() {          console.log('getDerivedStateFromError');          return { hasError: true };      }      componentDidCatch (error, info) {          console.log('componentDidCatch');          console.log({              error,              info,          })      }      render() {          if (this.state.hasError) {              return <div>發生了某種錯誤</div>          }          return (              <div>                  <h3>錯誤邊界測試</h3>                  <ErrorComponent />              </div>          )      }  }    // ErrorComponent.js  import React from 'react';    export default class Home extends React.Component {      state = {          showError: false,      }      componentDidMount() {      }      click = () => {          this.setState({              showError: true,          })      }      render() {          if (this.state.showError) {              throw new Error("拋出錯誤");          }          return (              <div onClick={this.click}>我是產生錯誤的組件</div>          )      }  }

我們可以在componentDidCatch(error, info) 獲取錯誤資訊, 錯誤資訊error.message, 錯誤堆棧error.stack, 組件堆棧info.componentStack, 這些資訊可以顯示給用戶, 也可以上報到伺服器. 可以在getDerivedStateFromError返回state, 渲染降級組件.

Fragments

Fragments解決了一個組件不能返回多個元素的問題, 沒有Fragments時一個組件沒法返回多個元素, 所以我們經常用個div包一下, 結果是增加了一個多餘的dom節點, 甚至產生不合法的dom, 比如下邊這樣的.

// 組件1  function Columns() {      return (          <div>              <td>第一列</td>              <td>第二列</td>          </div>      )  }  // 組件2  function Table() {    return (      <table>        <tr>          <Columns/>        </tr>      </table>    )  }

因為沒法返回多個元素, 所以在Columns組件中使用了div包裹兩個td, 然後在Table組件使用, 結果就產生了tr裡邊放td的錯誤結構. 使用Fragments特性可以很方便的解決這個問題. 如下. 只要用個<React.Fragment>包裝就可以了, 也可以寫成<>something</>.

function Columns() {      return (          <React.Fragment>              <td>第一列</td>              <td>第二列</td>          </React.Fragment>      )  }

Portals

Portal 提供了一種將子節點渲染到存在於父組件以外的 DOM 節點的方案. portal 的典型使用場景是當父組件有 overflow: hidden 或 z-index 樣式時，但你需要子組件能夠在視覺上「跳出」其容器。例如，對話框、懸浮卡以及提示框.

如下是一個toast組件 demo, 完整版參考react-demo

// Toast.js  import React from 'react';  import ReactDOM from 'react-dom';  import './Toast.css';    export default class Toast extends React.Component {    constructor(props) {      super(props);      this.el = document.querySelector('body');    }      render() {      return ReactDOM.createPortal(        (            <div className="toast">                <div className="toast-inner">                  {this.props.text}                </div>            </div>        ),        this.el,      );    }  }  // PortalTest.js  import React from 'react';  import Toast from './Toast';  export default class PortalTest extends React.Component {      render() {          return (              <div>                  <h1>PortalTest</h1>                  <Toast text="toast提示"/>              </div>          )      }  }

結果如圖

可以發現Toast這個組件不是在其父元素中, 而是跑到了我們期望的body裡邊. 這樣不管父組件寫overflow:hidden;還是其他都不會影響到這個toast.

forwardRef

forwardRef是一種將ref轉移到子組件的方式.

forwardRef 主要有兩種使用場景

• 希望對基礎組件做一些封裝, 但是希望基礎組件的實例的方法能被調用
• 高階組件中希望ref指向被包裹的組件而不是外層組件

1. 關於第一種場景

之前做ReactNative時有個FlatList組件, 希望對他封裝一層, 但是又希望調用方可以使用ref或則FlatList的實例, 方便調用上邊的方法. 這時就可以用forwardRef. 下面舉的是 input的例子, 我們希望封裝一下, 但讓調用方仍然可以通過ref獲取dom調用focus.

import React from 'react';    const LabelInput =      React.forwardRef((props, ref) => {          return <div>              <label>{props.label}</label>              <input ref={ref} className="input" style={{ border: '1px solid red' }} />          </div>      })    export default class Home extends React.Component {      constructor(props) {          super(props);          this.ref = React.createRef();      }        focus = () => {          try {              this.ref.current.focus();          } catch (e) {              console.log(e);          }      }      render() {          return (              <div>                  <h1>測試forwardRef</h1>                  <LabelInput ref={this.ref} label="手機號"/>                  <button onClick={this.focus}>點擊input可以獲取焦點</button>              </div>          )      }  }

在LabelInput組件裡邊將ref轉到了input上, 從而外邊的調用方可以直接掉focus方法. 如果不做轉發, 那麼ref將指向div, 再要找到裡邊的input就比較麻煩了, 而且破壞了組件的封裝性.

1. 關於第二種場景

import React from 'react';    function logProps(Component) {      class LogProps extends React.Component {          componentDidUpdate(prevProps) {              console.log('old props:', prevProps);              console.log('new props:', this.props);          }            render() {              const { forwardedRef, ...rest } = this.props;                // 將自定義的 prop 屬性 「forwardedRef」 定義為 ref              return <Component ref={forwardedRef} {...rest} />;          }      }        // 注意 React.forwardRef 回調的第二個參數 「ref」。      // 我們可以將其作為常規 prop 屬性傳遞給 LogProps，例如 「forwardedRef」      // 然後它就可以被掛載到被 LogPros 包裹的子組件上。      return React.forwardRef((props, ref) => {          return <LogProps {...props} forwardedRef={ref} />;      });  }    class InnerComp extends React.Component {      render() {          return <div id="InnerComp">              被包裹的組件-text={this.props.text}          </div>      }  }    const Comp = logProps(InnerComp);    export default class Home extends React.Component {      constructor(props) {          super(props);          this.ref = React.createRef();      }      click = () => {          console.log(this.ref.current);      }      render() {          return (              <div>                  <h1>測試forwardRef</h1>                  <Comp ref={this.ref} text="測試" />                  <button onClick={this.click}>點擊列印ref</button>              </div>          )      }  }

這裡點擊列印的是InnerComp組件, 如果去掉forwardRef則列印LogProps組件. 可見通過forwardRef可以成功將ref傳遞到被包裹的組件.

注意 函數組件不能給ref, 只有class組件可以. 測試發現的.

小結