devbox
思考机器3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

react项目总结_react项目经验

作者：思考机器3 | 2024-01-29 09:22:31

赞

踩

react项目经验

本文章主要是源自实际项目开发项目的总结，一些思考是参考了看过的文章，做了一篇总结，demo是跑过的，可以放心食用。

目录

       一.组件通信

1.父组件向子组件通信

2.子组件向父组件通信

3.跨级组件通信

4.兄弟组件通信

5.无嵌套关系的组件通信

二、避免重复渲染

1.隔离独立渲染的子组件

2.与渲染无关的变量不用state来管理数据

3.批量更新state、合并state

4.class组件中使用shouldComponentUpdate

5.绑定事件尽量不使用箭头函数

三、代码优化

1.大量的props

2.不兼容的props

3.props经过处理变为state

4.使用枚举管理状态

5.自定义Hook

四、其他优化

1.使用React.Fragment减少额外标签

2.避免使用内联样式属性

3.优化条件渲染

五、懒加载

1.懒加载React组件、第三方依赖组件

2.不用React.lazy懒加载

一.组件通信

1.父组件向子组件通信

  • 向子组件传递props
  1. <ChildList list={this.state.list} />
  2. <ChildSettings {...this.state.options}  />
  • 父组件调用子组件中的方法

1）函数组件：父组件useRef()创建一个ref，通过ref属性附加到子组件上，子组件用forwardRef来获取传递给它的ref，配合useImperativeHandle使用可以自定义暴露给父组件的方法

  1. // 父组件
  2. import { useRef } from "react";
  3. const childRef = useRef();
  4.  
  5. useEffect(() => {
  6.     childRef.current.childFunc();
  7. }, []);
  8.  
  9. return (
  10.     <div>
  11.       <Child ref={childRef} />
  12.     </div>
  13. );
  14.  
  15. // 子组件
  16. import { forwardRef, useImperativeHandle } from "react";
  17.  
  18. const Child = forwardRef((props, ref) => {
  19.   useImperativeHandle(ref, () => ({
  20.     childFunc() {
  21.       return logChild();
  22.     },
  23.   }));
  24.   const logChild = () => {
  25.     console.log("---child-----");
  26.   };
  27.   return <div>child</div>;
  28. });
  29.  
  30. export default Child;

2）class组件：子组件通过调用父组件的props方法，将子组件本身暴露出去，父组件可直接使用子组件内的方法，不想暴露给父组件的方法可以用static关键字定义静态方法

  1. // 父组件
  2. export default class Parent extends React.Component {
  3.   onClick = () => {
  4.     this.childRef.childFunc();
  5.   };
  6.  
  7.   render() {
  8.     return (
  9.       <div>
  10.         <Child
  11.           onRef={(ref) => {
  12.             this.childRef = ref;
  13.           }}
  14.         />
  15.         <button onClick={this.onClick}>click</button>
  16.       </div>
  17.     );
  18.   }
  19. }
  20.  
  21. // 子组件
  22. class Child extends React.Component {
  23.   componentDidMount() {
  24.     this.props.onRef(this);
  25.   }
  26.    
  27.   static myFunc = () => {
  28.   	console.log('本方法不暴露给父组件');
  29.   };
  30.  
  31.   childFunc = () => {
  32.     console.log("---child-----");
  33.   };
  34.  
  35.   render() {
  36.     return <div>child</div>;
  37.   }
  38. }
  39. export default Child;

2.子组件向父组件通信

父组件向子组件传递props方法，子组件主动调用该方法，将需要的信息作为参数传递到父组件的作用域中

  1. // 父组件
  2. <ChildSelector 
  3.     value={this.state.selectedValue} 
  4.     onSelect={(selectedValue) => {
  5.         this.setState({
  6.         	selectedValue
  7.         })
  8.     }} 
  9. />
  10.  
  11. // 子组件
  12. onSelect = (value) => {
  13. 	this.props.onSelect(value);
  14. }

3.跨级组件通信

使用Context共享组件树上能够全局访问的数据。注：Child1为Child的子组件

1）React.createContext(defaultValue)创建Context对象，订阅了Context对象的组件会从组件树中找到离自身最近的Provider中读取到当前的context，Context对象会返回Provider组件，允许Consumer消费组件订阅context的变化

  1. // context/AppContext.js
  2. import { createContext } from "react";
  3.  
  4. export default createContext({
  5.   name: "",
  6.   changeName: () => {},
  7. });

2）函数组件：子组件使用useContext()，接收一个context对象，返回该context的当前值

  1. // 根组件
  2. import { useState } from "react";
  3. import Child from "./Child";
  4. import Context from "./context/AppContext";
  5.  
  6. const Parent = () => {
  7.   const [name, setName] = useState("defaultName");
  8.  
  9.   const changeName = (name) => {
  10.     setName(name);
  11.   };
  12.  
  13.   return (
  14.     <Context.Provider value={{ name, changeName }}>
  15.       <Child />
  16.     </Context.Provider>
  17.   );
  18. };
  19.  
  20. export default Parent;
  21.  
  22. // 子组件Child1
  23. import { useContext } from "react";
  24. import Context from "./context/AppContext";
  25.  
  26. const Child1 = () => {
  27.   const context = useContext(Context);
  28.  
  29.   return <div onClick={() => context.changeName("Child")}>{context.name}</div>;
  30. };
  31.  
  32. export default Child1;

3）class组件：子组件contextType属性会被重新赋值为一个由 React.createContext() 创建的 Context 对象

  1. // 根组件
  2. import Child from "./Child";
  3. import Context from "./context/AppContext";
  4.  
  5. export default class Parent extends React.Component {
  6.   state = {
  7.     name: "defaultName",
  8.   };
  9.  
  10.   changeName = (name) => {
  11.     this.setState({
  12.       name,
  13.     });
  14.   };
  15.  
  16.   render() {
  17.     return (
  18.       <Context.Provider
  19.         value={{ name: this.state.name, changeName: this.changeName }}
  20.       >
  21.         <Child />
  22.       </Context.Provider>
  23.     );
  24.   }
  25. }
  26.  
  27. // 子组件Child1
  28. import { Component } from "react";
  29. import Context from "./context/AppContext";
  30.  
  31. class Child1 extends Component {
  32.   static contextType = Context;
  33.  
  34.   render() {
  35.     return (
  36.       <div onClick={() => this.context.changeName("Child")}>
  37.         {this.context.name}
  38.       </div>
  39.       // 16.x版本后可写成，不需要定义contextType
  40.       <Context.Consumer>
  41.         {({ name, changeName }) => {
  42.           return <div onClick={() => changeName("Child")}>{name}</div>;
  43.         }}
  44.       </Context.Consumer>
  45.     );
  46.   }
  47. }
  48. export default Child1;

4.兄弟组件通信

利用useReducer和context实现，可模仿一个简单的redux，useReducer传入reducer和defaultState，返回当前state和dispatch，通过context传给各个子组件，让子组件共享state和修改state

  1. // types.js
  2. export const EXAMPLE_TEST = "EXAMPLE_TEST";
  3.  
  4. // reducer.js
  5. import * as Types from "./types";
  6.  
  7. export const defaultState = {
  8.   count: 0,
  9. };
  10.  
  11. export default (state, action) => {
  12.   switch (action.type) {
  13.     case Types.EXAMPLE_TEST:
  14.       return {
  15.         ...state,
  16.         count: action.count,
  17.       };
  18.     default: {
  19.       return state;
  20.     }
  21.   }
  22. };
  23.  
  24. // action.js
  25. import * as Types from "./types";
  26.  
  27. export const onChangeCount = (count) => ({
  28.   type: Types.EXAMPLE_TEST,
  29.   count: count + 1,
  30. });
  1. // 根组件
  2. import React, { useReducer } from "react";
  3. import Context from "./context";
  4. import reducer, { defaultState } from "./reducer";
  5. import Child from "./Child";
  6. import Child1 from "./Child1";
  7.  
  8. function ReducerCom() {
  9.   const [state, dispatch] = useReducer(reducer, defaultState);
  10.  
  11.   return (
  12.     <Context.Provider value={{ state, dispatch }}>
  13.       <Child />
  14.       <Child1 />
  15.     </Context.Provider>
  16.   );
  17. }
  18.  
  19. export default ReducerCom;
  20.  
  21. // Child.js
  22. import React, { useEffect, useContext } from "react";
  23. import { onChangeCount } from "./action";
  24. import Context from "./context";
  25.  
  26. const Child = () => {
  27.   const context = useContext(Context);
  28.  
  29.   useEffect(() => {
  30.     // 监听变化
  31.     console.log("变化执行啦");
  32.   }, [context.state.count]);
  33.  
  34.   return (
  35.     <button
  36.       onClick={() => context.dispatch(onChangeCount(context.state.count))}
  37.     >
  38.       点击加 1
  39.     </button>
  40.   );
  41. };
  42.  
  43. export default Child;
  44.  
  45. // Child1.js
  46. import React, { useContext } from "react";
  47. import Context from "./context";
  48.  
  49. const Child1 = () => {
  50.   const context = useContext(Context);
  51.  
  52.   return (
  53.     <div>
  54.       <p>{context.state.count}</p>
  55.     </div>
  56.   );
  57. };
  58.  
  59. export default Child1;

5.无嵌套关系的组件通信

  • 使用redux、mobx、flux等状态管理器
  • 使用发布-订阅模式
  1. // EventEmitter.js
  2. class EventEmitter {
  3.   constructor() {
  4.     this.subscribers = {};
  5.   }
  6.   on(type, fn) {
  7.     if (!this.subscribers[type]) {
  8.       this.subscribers[type] = [];
  9.     }
  10.  
  11.     this.subscribers[type].push(fn);
  12.   }
  13.   off(type, fn) {
  14.     let listeners = this.subscribers[type];
  15.     if (!listeners || !listeners.length) return;
  16.     this.subscribers[type] = listeners.filter((v) => v !== fn);
  17.   }
  18.   emit(type, ...args) {
  19.     let listeners = this.subscribers[type];
  20.     if (!listeners || !listeners.length) return;
  21.     listeners.forEach((fn) => fn(...args));
  22.   }
  23. }
  24.  
  25. export default new EventEmitter();
  1. // 组件1
  2. const Child = () => {
  3.   const [name, setName] = useState("defaultName");
  4.  
  5.   useEffect(() => {
  6.     EventEmitter.on("changeName", (name) => {
  7.       setName(name);
  8.     });
  9.     return EventEmitter.off();
  10.   }, []);
  11.  
  12.   return <div>{name}</div>;
  13. };
  14.  
  15. // 组件2
  16. const Child1 = () => {
  17.   const changeChildName = () => {
  18.     EventEmitter.emit("changeName", "change name from child2");
  19.   };
  20.  
  21.   return <button onClick={changeChildName}>click</button>;
  22. };

二、避免重复渲染

1.隔离独立渲染的子组件

用React.memo隔离组件形成独立的渲染单元，避免父组件重新渲染造成子组件也重新渲染，可以用于不依赖于父组件状态渲染的子组件，函数组件和class也可以用useMemo和pureComponent实现。

export default React.memo(Child);

1）函数组件：useMemo的第二个参数是依赖项数组，某个依赖项改变时才会重新渲染子组件。

  1. {useMemo(
  2. 	() => (
  3.     	<Child />
  4. 	),
  5. 	[]
  6. )}

2）class组件：用React.pureComponent

export default class Child extends React.PureComponent {}

2.与渲染无关的变量不用state来管理数据

触发this.setState或者useState，只要state改变就会触发渲染，与在render中是否引用无关，可以直接把数据绑定在this上，或者使用useRef做数据缓存。

1）函数组件

  1. const App = ({name}) => {
  2. 	const nameRef = useRef('defaultName');
  3.     
  4.     useEffect(() => {
  5.     	nameRef.current = name;
  6.     })
  7.     
  8.     return <div>hello world!</div>;
  9. }

2）class组件

  1. class App extends React.Component{
  2. 	name = 'defaultName';
  3.  
  4. 	componentDidMount() {
  5.     	this.name =  this.props.name;
  6.     }
  7.  
  8. 	render () {
  9. 		return <div>hello world!</div>;
  10.     }
  11. }

3.批量更新state、合并state

class组件如果在一个函数中setState了三次，会触发三次setState，但是不会渲染三次，因为react会合并成一次做批量更新，但是在异步函数中会多次渲染，批量更新失效。

demo如下：

  1. const Parent = () => {
  2.   const [a, setA] = useState(0);
  3.   const [b, setB] = useState(0);
  4.   const [c, setC] = useState(0);
  5.  
  6.   const handleClick = () => {
  7.     setA(a + 1);
  8.     setB(b + 1);
  9.     setC(c + 1);
  10.   };
  11.  
  12.   console.log("----render----");
  13.  
  14.   return (
  15.     <div>
  16.       {a}---{b}---{c}
  17.       <button onClick={handleClick}>click</button>
  18.     </div>
  19.   );
  20. };
  21.  
  22. export default Parent;

效果如下：点击三次，才会render三次

如果是异步的更改state

  1. const handleClick = () => {
  2.     setTimeout(() => {
  3.       setA(a + 1);
  4.       setB(b + 1);
  5.       setC(c + 1);
  6.     }, 0);
  7.   };

效果如下：点击一次，就会render三次，说明没有合并更新

解决方案：

1）手动批量更新可以用react-dom中的unstable_batchedUpdates，三次更新就会合并成一次

  1. import { unstable_batchedUpdates } from 'react-dom';
  2. const handleClick = () => {
  3.     setTimeout(() => {
  4.       unstable_batchedUpdates(() => {
  5.         setA(a + 1);
  6.         setB(b + 1);
  7.         setC(c + 1);
  8.       });
  9.     }, 0);
  10.   };

2）合并state：用一个setState改变多个state，或者一个useState保存多个state

4.class组件中使用shouldComponentUpdate

使用shouldComponentUpdate控制组件是否需要重新渲染

  1. shouldComponentUpdate(nextProps, nextState) {
  2.     if(nextState.id != this.state.id ) {
  3.       return true;
  4.     }
  5.     return false;
  6. }

5.绑定事件尽量不使用箭头函数

使用箭头函数每次渲染都会创建一个新的时间处理器，子组件每次都会被渲染。

1）函数组件：子组件使用React.memo配合父组件用useCallback包裹props方法，实现父组件渲染不影响子组件的渲染

  1. <Child onClick={handleClick} />
  2. // 如果用箭头函数绑定事件父组件还是会影响子组件的渲染
  3. <Child onClick={(value) => handleClick(value)} />
  4.  
  5. const handleClick = useCallback((value) => {
  6.     console.log(value);
  7.  }, []);

2）class组件：不用箭头函数，子组件用React.memo包裹即可

三、代码优化

1.大量的props

        如果需要将大量的props传递到一个组件中，那么可以思考以下几点：

1）该组件是否做了多件事，一个组件应该只做一件事，将该组件拆分成多个小组件是否会更合理；

2）组件是否可以被合成，如果组件中有很多不相干的逻辑，就可以考虑拆分再重新组合；

3）是否传递了很多配置有关的props，比如带分页配置的表格组件，可以将多个配置的props合成一个options，可以更好的控制组件选项，也更规范。

2.不兼容的props

        避免组件之间传递不兼容的props，例如有一个<Input/>组件功能是把输入的小写英文都转变成大写，过了一段时间，想将它用于电话号码的处理，虽然都是用的input元素，但是明显电话号码的处理用不上之前的功能，并且毫无关联，这时候也可以分割组件明确职责，如果有共享的逻辑可以放到hooks中

3.props经过处理变为state

        一般常规做法是，子组件内创建一个state，当props的值改变时再改变state，但是如果只是基于props通过计算得到新的state可以用useMemo来代替useState。

  1. const Child = ({ count }) => {
  2.   const formatCount = (value) => {
  3.     return value + 10;
  4.   };
  5.  
  6.   const formattedCount = useMemo(() => {
  7.     return formatCount(count);
  8.   }, [count]);
  9.     
  10.   //const [formattedCount, setFormattedCount] = useState(count);
  11.  
  12.   //useEffect(() => {
  13.   //  setFormattedCount(formatCount(count));
  14.   //}, [count]);
  15.  
  16.   return <div>{formattedCount}</div>;
  17. };
  18.  
  19. export default Child;

4.使用枚举管理状态

在编写组件时，很容易用很多个布尔值来表示组件当前的状态，比如isLoading、isFinished等等，虽然技术可行，但是很难推断组件当前处于什么状态，不容易维护，可以用一个枚举的状态来表示。

  1. function Component() {
  2.   const [isLoading, setIsLoading] = useState(false)
  3.   const [isFinished, setIsFinished] = useState(false)
  4.   const [hasError, setHasError] = useState(false)
  5.  
  6.   const fetchSomething = () => {
  7.     setIsLoading(true)
  8.  
  9.     fetch(url)
  10.       .then(() => {
  11.         setIsLoading(false)
  12.         setIsFinished(true)
  13.       })
  14.       .catch(() => {
  15.         setHasError(true)
  16.       })
  17.   }
  18.  
  19.   if (isLoading) return <Loader />
  20.   if (hasError) return <Error />
  21.   if (isFinished) return <Success />
  22.  
  23.   return <button onClick={fetchSomething} />
  24. }
  25.  
  26. // 改造后
  27. function Component() {
  28.   const [status, setStatus] = useState('loading')
  29.  
  30.   const fetchSomething = () => {
  31.     setStatus('loading')
  32.  
  33.     fetch(url)
  34.       .then(() => {
  35.         setStatus('finished')
  36.       })
  37.       .catch(() => {
  38.         setStatus('error')
  39.       })
  40.   }
  41.  
  42.   if (status === 'loading') return <Loading />
  43.   if (status === 'error') return <Error />
  44.   if (status === 'finished') return <Success />
  45.  
  46.   return <button onClick={fetchSomething} />
  47. }

5.自定义Hook

        组件具有相似逻辑、某个状态具有自己的复杂逻辑或者和生命周期有关的函数封装可以考虑自定义Hook，也可以使用封装好的Hook库，比如Umi Hooks--https://hooks.umijs.org/zh-CN/hooks/async

1）场景一：通用查询表格

        没有用自定义Hook提取可重用函数之前，每个页面的查询表格组件都要维护自己的loading/list/pageNo等状态，每个组件的逻辑都是默认请求列表，在请求列表前loading置为true，请求完毕置为false，设置list的数据，设置分页器，点击查询再根据查询条件请求列表，用自定义Hook可以将这些重复的逻辑封装起来，返回这些通用的state，减少重复的代码，让这些状态统一管理起来，比如默认分页数可以统一在一个地方控制。 
  1. const [list, setList] = useState([]);
  2. const [loading, setLoading] = useState(false);
  3. const [paginator, setPaginator] = useState({
  4.     page: 1,
  5.     pageSize: 20,
  6. });
  7.  
  8. const fetchList = (fetchStatus) => {
  9.     setLoading(true);
  10.     getList({
  11.       pageSize: paginator.pageSize,
  12.       pageNo: paginator.page,
  13.       name,
  14.     }).then((res) => {
  15.       setList(res.data);
  16.       setLoading(false);
  17.     }).catch(() => {
  18.     	setLoading(false);
  19.     });
  20. }; 
  21.  
  22. const handlePageSelect = (page, pageSize) => {
  23.     setPaginator({ ...paginator, page, pageSize });
  24. };
  25.  
  26. useEffect(() => {
  27.     fetchList();
  28. }, [paginator.page, paginator.pageSize]);
  29.  
  30. <Table rowMax={list && list.length} loading={loading} data={list} column={columns} />
  31. <Pagination  
  32.     prev 
  33.     next 
  34.     first 
  35.     last 
  36.     recordCount={total} 
  37.     pageSize={paginator.pageSize} 
  38.     activePage={paginator.page} 
  39.     onSelect={handlePageSelect} 
  40. />

自定义组件 useTable.js

输入：查询列表的接口、【除了分页器之外的参数】、【处理列表数据的函数】、【请求接口完毕的回调】

输出：list、loading、getData函数、分页的配置项

  1. import { useState, useEffect } from 'react';
  2.  
  3. const useTable = (getListData, extraParam = {}, handleData, callback) => {
  4.   const [paginator, setPaginator] = useState({
  5.     recordCount: 0,
  6.     pageSize: 20,
  7.     pageNo: 1,
  8.   });
  9.  
  10.   const [list, setList] = useState([]);
  11.   const [loading, setLoading] = useState(false);
  12.  
  13.   useEffect(() => {
  14.     getData();
  15.   }, [paginator.pageNo, paginator.pageSize]);
  16.  
  17.   const onSelect = (pageNo, pageSize) => {
  18.     if (!isNaN(pageNo)) {
  19.       const paginator = { ...paginator, pageSize, pageNo };
  20.       setPaginator(paginator);
  21.     }
  22.   };
  23.  
  24.   // 调用接口，获取数据
  25.   const getData = (pageNoParam, newParam) => {
  26.     // 搜索条件改变查询的时候，当前页数重置为1
  27.     const pageNo = !isNaN(pageNoParam) ? pageNoParam : paginator.pageNo;
  28.     const paginatorExtra = { pageNo, pageSize: paginator.pageSize };
  29.     setLoading(true);
  30.     const params = newParam || extraParam;
  31.     getListData &&
  32.       getListData({ ...params, ...paginatorExtra })
  33.         .then((res = { data: [] }) => {
  34.           const data = res.data;
  35.           const recordCount = res.total || res.count;
  36.           let list = [];
  37.           if (handleData) {
  38.             list = handleData(data);
  39.           } else {
  40.             list = data.map((item) => {
  41.               // 默认以id为key
  42.               return { key: item.id, ...item };
  43.             });
  44.           }
  45.           // 因为使用这个hook的地方可以手动调用getData，所以分页器在这里赋值
  46.           setPaginator({ ...paginatorExtra, recordCount });
  47.           setList(list);
  48.           setLoading(false);
  49.           callback && callback(list);
  50.         })
  51.         .catch((err) => {
  52.           setLoading(false);
  53.         });
  54.   };
  55.  
  56.   return {
  57.     list,
  58.     loading,
  59.     getData,
  60.     tableProps: {
  61.       prev: true,
  62.       next: true,
  63.       first: true,
  64.       last: true,
  65.       recordCount: paginator.recordCount,
  66.       pageSize: paginator.pageSize,
  67.       activePage: paginator.pageNo,
  68.       pageNo: paginator.pageNo,
  69.       onSelect,
  70.     },
  71.   };
  72. };
  73.  
  74. export default useTable;

使用useTable()

  1. const { list, tableProps, loading, getData } = useTable(
  2.   getList,
  3.   { teamId, productName, status },
  4.   (data) => {
  5.     return data.map((item) => {
  6.       return { ...item, id: item.uuid };
  7.     });
  8.   }
  9. );
  10.  
  11. <Button type="primary" onClick={() => getData(1)}>查询</Button>
  12. <Table border rowMax={list.length} data={list} loading={loading} column={columns} />
  13. <Pagination {...tableProps} />

2）场景二：封装useInterval代替setInterval

为什么不直接使用setInterval？

        如下面的例子，在组件加载时定义一个定时器，卸载组件时也清空定时器，但是useEffect只会执行一次，setInterval中拿到的始终是第一次渲染时拿到的count为1，所以界面上始终上显示的是2。

        为了解决这个问题，把useEffect的第二个参数改成[count]，这样就会每次拿到最新的count，但是每次count更改，定时器就会不停的新增和移除。

  1. funtion Counter() {
  2.   const [count, setCount] = useState(1);
  3.  
  4.   useEffect(() => {
  5.     const id = setInterval(() => {
  6.       console.log(count); // 此时的count始终是1
  7.       setCount(count + 1);
  8.     }, 1000);
  9.     return () => clearInterval(id);
  10.   }, []);
  11.  
  12.   return <div>{count}</div>;
  13. };

解决办法1：函数式更新，useState 中的set方法可接收函数，该函数将接收之前的state，返回一个更新后的值。这样定时器每次拿到的是最新的值。

setCount((count) => count + 1);

解决办法2：用useRef将定时器函数提取出来，每次定时器触发的时候，都能获取到最新的count。

  1. const myRef = useRef(null);
  2.   myRef.current = () => {
  3.     setCount(count + 1);
  4.   };
  5.   useEffect(() => {
  6.     const id = setInterval(() => {
  7.       myRef.current();
  8.     }, 1000);
  9.     return () => clearInterval(id);
  10.   }, []);

定义useInterval.js

  1. import { useEffect, useRef } from 'react';
  2.  
  3. const useInterval = (callback, delay) => {
  4.   const savedCallback = useRef();
  5.  
  6.   useEffect(() => {
  7.     savedCallback.current = callback;
  8.   }, [callback);
  9.  
  10.   useEffect(() => {
  11.     let id;
  12.     function tick() {
  13.         savedCallback.current(() => {
  14.           clearInterval(id);
  15.         });
  16.     }
  17.     if (!isNaN(delay)) {
  18.       id = setInterval(tick, delay);
  19.       return () => clearInterval(id);
  20.     }
  21.   }, [delay]);
  22. };
  23. export default useInterval;

使用useInterval.js

  1. useInterval((clear) => {
  2.     setCount(count + 1);
  3. }, 1000);

四、其他优化

1.使用React.Fragment减少额外标签

        每个组件都必须要唯一一个父标签，如果该标签只是为了当父标签，没有其他额外的用途，则可以用片段fragment包裹子元素，节省渲染器渲染额外的元素的工作量。

2.避免使用内联样式属性

        添加的内联样式是js对象不是真正的样式，需要花费更多的时间转换为等效的css样式属性，才会应用样式。

3.优化条件渲染

        安装和卸载 React 组件是昂贵的操作，所以用条件渲染减少安装和卸载组件。执行不同的if else语句切换渲染的组件，没有更改的部分不需要用条件控制，不必要每次改变state的时候都卸载并重新安装

五、懒加载

1.懒加载React组件、第三方依赖组件

    React16.6版本中，新增了React.lazy函数，可以动态加载React组件，配合webpack的code splitting，当用import()时，webpack监测到这个语法会自动进行代码分割，只有当组件被加载，对应的资源才会导入；Suspense组件可以指定在js加载完成之前的loading。适合路由懒加载、Tab切换、单个资源很大、第三方依赖组件很大的场景。

  1. import React, { Suspense, useState } from "react";
  2.  
  3. const App = () => {
  4.   const [showChild, setShowChild] = useState(false);
  5.  
  6.   const Child = React.lazy(() => import("./Child"));
  7.  
  8.   return (
  9.     <div>
  10.       <button
  11.         onClick={() => {
  12.           setTimeout(() => {
  13.             setShowChild(true);
  14.           }, 2000);
  15.         }}
  16.       >
  17.         click
  18.       </button>
  19.  
  20.       {showChild && (
  21.         <Suspense fallback={<div>loading...</div>}>
  22.           <Child />
  23.         </Suspense>
  24.       )}
  25.     </div>
  26.   );
  27. };

效果：2s后加载2.chunk.js

我们也可以指定这个js的名字

const Child = React.lazy(() => import(/* webpackChunkName: "child" */"./Child"));

因为网络问题或者组件内部错误导致资源加载失败时，可能会导致页面白屏，可以用Error Boundaries组件来优雅降级。

  1. class ErrorBoundary extends React.Component {
  2.   state = { hasError: false };
  3.   static getDerivedStateFromError(error) {
  4.     return { hasError: true };
  5.   }
  6.   componentDidCatch(error, errorInfo) {
  7.     console.log(error, errorInfo);
  8.   }
  9.   render() {
  10.     if (this.state.hasError) {
  11.       return <p>资源加载失败，请稍后重试</p>;
  12.     }
  13.     return this.props.children;
  14.   }
  15. }
  16.  
  17. // App组件
  18. {showChild && (
  19.     <ErrorBoundary>
  20.       <Suspense fallback={<div>loading...</div>}>
  21.         <Child />
  22.       </Suspense>
  23.     </ErrorBoundary>
  24. )}

2.不用React.lazy懒加载

  1. import React, { useState, Component } from "react";
  2. // 异步按需加载component
  3. const asyncComponent = (getComponent) => {
  4.   return class AsyncComponent extends Component {
  5.     static Component = null;
  6.     state = { Component: AsyncComponent.Component };
  7.  
  8.     componentDidMount() {
  9.       if (!this.state.Component) {
  10.         getComponent().then(({ default: Component }) => {
  11.           AsyncComponent.Component = Component;
  12.           this.setState({ Component });
  13.         });
  14.       }
  15.     }
  16.     render() {
  17.       const { Component } = this.state;
  18.       if (Component) {
  19.         return <Component {...this.props} />;
  20.       }
  21.       return <div>loading...</div>;
  22.     }
  23.   };
  24. };
  25.  
  26. const App = () => {
  27.   const [showChild, setShowChild] = useState(false);
  28.  
  29.   const Child = asyncComponent(() =>
  30.     import(/* webpackChunkName: "child" */ "./Child")
  31.   );
  32.  
  33.   return (
  34.     <div>
  35.       <button
  36.         onClick={() => {
  37.           setTimeout(() => {
  38.             setShowChild(true);
  39.           }, 2000);
  40.         }}
  41.       >
  42.         click
  43.       </button>
  44.  
  45.       {showChild && <Child />}
  46.     </div>
  47.   );
  48. };

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/blog/article/detail/42549
推荐阅读