发帖
翼度科技»论坛 › 编程开发 › JavaScript › 查看内容

React运行机制超详细讲解

嗲猫

14

主题

14

帖子

42

积分

新手上路

Rank: 1

积分
42
显示全部楼层
适合人群

本文适合0.5~3年的react开发人员的进阶。
讲讲废话：
react的源码，的确是比vue的难度要深一些，本文也是针对初中级，本意了解整个react的执行过程。

写源码之前的必备知识点


JSX

首先我们需要了解什么是JSX。
网络大神的解释：React 使用 JSX 来替代常规的 JavaScript。JSX 是一个看起来很像 XML 的 JavaScript 语法扩展。
是的，JSX是一种js的语法扩展，表面上像HTML，本质上还是通过babel转换为js执行。再通俗的一点的说，jsx就是一段js，只是写成了html的样子，而我们读取他的时候，jsx会自动转换成vnode对象给我们，这里都由react-script的内置的babel帮助我们完成。
简单举个栗子：
  1. return (
  2.   <div>
  3.     Hello  Word  </div>
  4. )
  5. 实际上是：
  6. return React.createElement(
  7.   "div",
  8.   null,
  9.   "Hello"
  10. )
复制代码
JSX本质上就是转换为React.createElement在React内部构建虚拟Dom，最终渲染出页面。

虚拟Dom

这里说明一下react的虚拟dom。react的虚拟dom跟vue的大为不同。vue的虚拟dom是为了是提高渲染效率，而react的虚拟dom是一定需要。很好理解，vue的template本身就是html，可以直接显示。而jsx是js，需要转换成html，所以用到虚拟dom。
我们描述一下react的最简版的vnode：
  1. function createElement(type, props, ...children) {
  2.   props.children = children;
  3.   return {
  4.     type,
  5.     props,
  6.     children,
  7.   };
  8. }
复制代码
这里的vnode也很好理解，
type表示类型，如div,span，
props表示属性，如{id: 1, style:{color:red}},
children表示子元素
下边会在createElement继续讲解。

原理简介

我们写一个react的最简单的源码：
  1. import React from 'react'
  2. import ReactDOM from 'react-dom'
  3. function App(props){
  4.      return <div>你好</div>
  5. </div>
  6. }
  7. ReactDOM.render(<App/>,  document.getElementById('root'))
复制代码
React负责逻辑控制，数据 -> VDOM
首先，我们可以看到每一个js文件中，都一定会引入import React from ‘react’。但是我们的代码里边，根本没有用到React。但是你不引入他就报错了。
为什么呢？可以这样理解，在我们上述的js文件中，我们使用了jsx。但是jsx并不能给编译，所以，报错了。这时候，需要引入react，而react的作用，就是把jsx转换为“虚拟dom”对象。
JSX本质上就是转换为React.createElement在React内部构建虚拟Dom，最终渲染出页面。而引入React，就是为了时限这个过程。
ReactDom渲染实际DOM，VDOM -> DOM
理解好这一步，我们再看ReactDOM。React将jsx转换为“虚拟dom”对象。我们再利用ReactDom的虚拟dom通过render函数，转换成dom。再通过插入到我们的真是页面中。
这就是整个mini react的一个简述过程。相关参考视频讲解：进入学习

手写react过程


基本架子的搭建

react的功能化问题，暂时不考虑。例如，启动react，怎么去识别JSX，实现热更新服务等等，我们的重点在于react自身。我们借用一下一下react-scripts插件。
有几种种方式创建我们的基本架子：
利用 create-react-app zwz_react_origin快速搭建，然后删除原本的react,react-dom等文件。（zwz_react_origin是我的项目名称）
第二种，复制下边代码。新建package.json
  1.   {
  2.     "name": "zwz_react_origin",
  3.     "scripts": {
  4.       "start": "react-scripts start"
  5.     },
  6.     "version": "0.1.0",
  7.     "private": true,
  8.     "dependencies": {
  9.       "react-scripts": "3.4.1"
  10.     },
  11.   }
复制代码
然后新建public下边的index.html
  1.   <!DOCTYPE html>
  2.   <html lang="en">
  3.     <head>
  4.     </head>
  5.     <body>
  6.       <div id="root"></div>
  7.     </body>
  8.   </html>
复制代码
再新建src下边的index.js
这时候react-scripts会快速的帮我们定为到index.html以及引入index.js
  1.   import React from "react";
  2.   import ReactDOM from "react-dom";
  3.   let jsx = (
  4.     <div>
  5.       <div className="">react启动成功</div>
  6.     </div>
  7.   );
  8.   ReactDOM.render(jsx, document.getElementById("root"));
复制代码
这样，一个可以写react源码的轮子就出来了。

React的源码
  1. let obj = (
  2.   <div>
  3.     <div className="class_0">你好</div>
  4.   </div>
  5. );
  6. console.log(`obj=${ JSON.stringify( obj) }`);
复制代码
首先，我们上述代码，如果我们不import React处理的话，我们可以打印出：
‘React’ must be in scope when using JSX react/react-in-jsx-scope
是的，编译不下去，因为js文件再react-script，他已经识别到obj是jsx。该jsx却不能解析成虚拟dom, 此时我们的页面就会报错。通过资料的查阅，或者是源码的跟踪，我们可以知道，实际上，识别到jsx之后，会调用页面中的createElement转换为虚拟dom。
我们import React，看看打印出来什么？
  1. + import React from "react";
  2. let obj = (
  3.   <div>
  4.     <div className="class_0">你好</div>
  5.   </div>
  6. );
  7. console.log(`obj:${ JSON.stringify( obj) }`);
  8. 结果：
  9. jsx={"type":"div","key":null,"ref":null,"props":{"children":{"type":"div","key":null,"ref":null,"props":{"className":"class_0","children":"你好"},"_owner":null,"_store":{}}},"_owner":null,"_store":{}}
复制代码
由上边结论可以知道， babel会识别到我们的jsx,通过createElement并将其dom（html语法）转换为虚拟dom。从上述的过程，我们可以看到虚拟dom的组成，由type,key,ref,props组成。我们来模拟react的源码。
此时我们已经知道react中的createElement的作用是什么，我们可以尝试着自己来写一个createElement（新建react.js引入并手写下边代码）：
  1. function createElement() {
  2.   console.log("createElement", arguments);
  3. }
  4. export default {
  5.   createElement,
  6. };
复制代码
此时的打印结果：

我们可以看出对象传递的时候，dom的格式，先传入type, 然后props属性，我们根据原本react模拟一下这个对象转换的打印：
  1. function createElement(type, props, ...children) {
  2.   props.children = children;
  3.   return {
  4.     type,
  5.     props,
  6.   };
  7. }
复制代码
这样，我们已经把最简版的一个react实现，我们下边继续看看如何render到页面

ReactDom.render
  1. import React from "react";
  2. + import ReactDOM from "react-dom";
  3. let jsx = (
  4.   <div>
  5.     <div className="class_0">你好</div>
  6.   </div>
  7. );
  8. // console.log(`jsx=${ JSON.stringify( jsx) }`);
  9. + ReactDOM.render(jsx, document.getElementById("root"));
复制代码
如果此时，我们引入ReactDom，通过render到对应的元素，整个简版react的就已经完成，页面就会完成渲染。首先，jsx我们已经知道是一个vnode，而第二个元素即是渲染上页面的元素，假设我们的元素是一个html原生标签div。
我们新建一个reactDom.js引入。
  1. function render(vnode, container) {
  2.   mount(vnode, container);
  3. }
  4. function mount(vnode, container){
  5.     const { type, props } = vnode;
  6.     const node = document.createElement(type);//创建一个真实dom
  7.     const { children, ...rest } = props;
  8.     children.map(item => {//子元素递归
  9.         if (Array.isArray(item)) {
  10.           item.map(c => {
  11.             mount(c, node);
  12.           });
  13.         } else {
  14.           mount(item, node);
  15.         }
  16.     });
  17.     container.appendChild(node);
  18. }
  19. //主页：
  20. - import React from "react";
  21. - import ReactDOM from "react-dom";
  22. + import React from "./myReact/index.js";
  23. + import ReactDOM from "./myReact/reactDom.js";
  24. let jsx = (
  25.   <div>
  26.     <div className="class_0">你好</div>
  27.   </div>
  28. );
  29. ReactDOM.render(jsx, document.getElementById("root"));
复制代码
此时，我们可以看到页面，我们自己写的一个react渲染已经完成。我们优化一下。
首先，这个过程中， className="class_0"消失了。我们想办法渲染上页面。此时，虚拟dom的对象，没有办法，区分，哪些元素分别带有什么属性，我们在转义的时候优化一下mount。
  1. function mount(vnode, container){
  2.     const { type, props } = vnode;
  3.     const node = document.createElement(type);//创建一个真实dom
  4.     const { children, ...rest } = props;
  5.     children.map(item => {//子元素递归
  6.         if (Array.isArray(item)) {
  7.           item.map(c => {
  8.             mount(c, node);
  9.           });
  10.         } else {
  11.           mount(item, node);
  12.         }
  13.     });
  14.     // +开始
  15.     Object.keys(rest).map(item => {
  16.         if (item === "className") {
  17.           node.setAttribute("class", rest[item]);
  18.         }
  19.         if (item.slice(0, 2) === "on") {
  20.           node.addEventListener("click", rest[item]);
  21.         }
  22.       });
  23.     // +结束  
  24.     container.appendChild(node);
  25. }
复制代码
ReactDom.Component

看到这里，整个字符串render到页面渲染的过程已完成。此时入口文件已经解决了。对于原始标签div, h1已经兼容。但是对于自定义标签呢？或者怎么完成组件化呢。
我们先看react16+的两种组件化模式，一种是function组件化，一种是class组件化。
首先，我们先看看demo.
  1. import React, { Component } from "react";
  2. import ReactDOM from "react-dom";
  3. class MyClassCmp extends React.Component {
  4.   constructor(props) {
  5.     super(props);
  6.   }
  7.   render() {
  8.     return (
  9.     <div className="class_2" >MyClassCmp表示:{this.props.name}</div>
  10.     );
  11.   }
  12. }
  13. function MyFuncCmp(props) {
  14.   return <div className="class_1" >MyFuncCmp表示:{props.name}</div>;
  15. }
  16. let jsx = (
  17.   <div>
  18.     <h1>你好</h1>
  19.     <div className="class_0">前端小伙子</div>
  20.     <MyFuncCmp />
  21.     <MyClassCmp  />
  22.   </div>
  23. );
  24. ReactDOM.render(jsx, document.getElementById("root"));
复制代码
先看简单点一些的Function组件。暂不考虑传递值等问题,Function其实跟原本组件不一样的地方，在于他是个函数，而原本的jsx，是一个字符串。我们可以根据这个特点，将函数转换为字符串，那么Function组件即跟普通标签同一性质。
我们写一个方法：
  1. mountFunc(vnode, container);
  2. function mountFunc(vnode, container) {
  3.   const { type, props } = vnode;
  4.   const node = new type(props);
  5.   mount(node, container);
  6. }
复制代码
此时type即是函数体内容，我们只需要实例化一下，即可跟拿到对应的字符串，即是普通的vnode。再利用我们原来的vnode转换方法，即可实现。
按照这个思路，如果我们不考虑生命周期等相对复杂的东西。我们也相对简单，只需拿到类中的render函数即可。
  1. mountFunc(vnode, container);
  2. function mountClass(vnode, container) {
  3.   const { type, props } = vnode;
  4.   const node = new type(props);
  5.   mount(node.render(), container);
  6. }
复制代码
这里可能需注意，class组件,需要继承React.Component。截图一下react自带的Component

可以看到，Component统一封装了，setState，forceUpdate方法，记录了props，state,refs等。我们模拟一份简版为栗子：
  1. class Component {
  2.   static isReactComponent = true;
  3.   constructor(props) {
  4.     this.props = props;
  5.     this.state = {};
  6.   }
  7.   setState = () => {};
  8. }
复制代码
再添加一个标识，isReactComponent表示是函数数组件化。这样的话，我们就可以区分出：普通标签，函数组件标签，类组件标签。
我们可以重构一下createElement方法，多定义一个vtype属性，分别表示

  • 普通标签
  • 函数组件标签
  • 类组件标签
根据上述标记，我们可改造为：
  1. function createElement(type, props, ...children) {
  2.   props.children = children;
  3.   let vtype;
  4.   if (typeof type === "string") {
  5.     vtype = 1;
  6.   }
  7.   if (typeof type === "function") {
  8.     vtype = type.isReactComponent ? 2 : 3;
  9.   }
  10.   return {
  11.     vtype,
  12.     type,
  13.     props,
  14. };
复制代码
那么，我们处理时：
  1. function mount(vnode, container) {
  2.   const { vtype } = vnode;
  3.   if (vtype === 1) {
  4.     mountHtml(vnode, container); //处理原生标签
  5.   }
  6.   if (vtype === 2) {
  7.     //处理class组件
  8.     mountClass(vnode, container);
  9.   }
  10.   if (vtype === 3) {
  11.     //处理函数组件
  12.     mountFunc(vnode, container);
  13.   }
  14. }
复制代码
至此，我们已经完成一个简单可组件化的react源码。不过，此时有个bug，就是文本元素的时候异常，因为文本元素不带标签。我们优化一下。
  1. function mount(vnode, container) {
  2.   const { vtype } = vnode;
  3.   if (!vtype) {
  4.     mountTextNode(vnode, container); //处理文本节点
  5.   }
  6.   //vtype === 1
  7.   //vtype === 2
  8.   // ....
  9. }
  10. //处理文本节点
  11. function mountTextNode(vnode, container) {
  12.   const node = document.createTextNode(vnode);
  13.   container.appendChild(node);
  14. }
复制代码
简单源码

package.json：
  1. {
  2.   "name": "zwz_react_origin",
  3.   "version": "0.1.0",
  4.   "private": true,
  5.   "dependencies": {
  6.     "react": "^16.10.2",
  7.     "react-dom": "^16.10.2",
  8.     "react-scripts": "3.2.0"
  9.   },
  10.   "scripts": {
  11.     "start": "react-scripts start",
  12.     "build": "react-scripts build",
  13.     "test": "react-scripts test",
  14.     "eject": "react-scripts eject"
  15.   },
  16.   "eslintConfig": {
  17.     "extends": "react-app"
  18.   },
  19.   "browserslist": {
  20.     "production": [
  21.       ">0.2%",      "not dead",      "not op_mini all"    ],    "development": [      "last 1 chrome version",      "last 1 firefox version",      "last 1 safari version"    ]  }}
复制代码
index.js
  1. import React from "./wzReact/";
  2. import ReactDOM from "./wzReact/ReactDOM";
  3. class MyClassCmp extends React.Component {
  4.   constructor(props) {
  5.     super(props);
  6.   }
  7. render() {
  8.     return (
  9.     <div className="class_2" >MyClassCmp表示:{this.props.name}</div>
  10.     );
  11.   }
  12. }
  13. function MyFuncCmp(props) {
  14.   return <div className="class_1" >MyFuncCmp表示:{props.name}</div>;
  15. }
  16. let jsx = (
  17.   <div>
  18.     <h1>你好</h1>
  19.     <div className="class_0">前端小伙子</div>
  20.     <MyFuncCmp name="真帅" />
  21.     <MyClassCmp name="还有钱" />
  22.   </div>
  23. );
  24. ReactDOM.render(jsx, document.getElementById("root"));
复制代码
/wzReact/index.js
  1. function createElement(type, props, ...children) {  console.log("createElement", arguments);  props.children = children;  let vtype;  if (typeof type === "string") {    vtype = 1;  }  if (typeof type === "function") {    vtype = type.isReactComponent ? 2 : 3;  }  return {    vtype,    type,    props,  };}class Component {
  2.   static isReactComponent = true;
  3.   constructor(props) {
  4.     this.props = props;
  5.     this.state = {};
  6.   }
  7.   setState = () => {};
  8. }export default {  Component,  createElement,};
复制代码
/wzReact/ReactDOM.js
  1. function render(vnode, container) {
  2.   console.log("render", vnode);
  3.   //vnode-> node
  4.   mount(vnode, container);
  5.   // container.appendChild(node)
  6. }
  7. // vnode-> node
  8. function mount(vnode, container) {
  9.   const { vtype } = vnode;
  10.   if (!vtype) {
  11.     mountTextNode(vnode, container); //处理文本节点
  12.   }
  13.   if (vtype === 1) {
  14.     mountHtml(vnode, container); //处理原生标签
  15.   }
  16.   if (vtype === 3) {
  17.     //处理函数组件
  18.     mountFunc(vnode, container);
  19.   }
  20.   if (vtype === 2) {
  21.     //处理class组件
  22.     mountClass(vnode, container);
  23.   }
  24. }
  25. //处理文本节点
  26. function mountTextNode(vnode, container) {
  27.   const node = document.createTextNode(vnode);
  28.   container.appendChild(node);
  29. }
  30. //处理原生标签
  31. function mountHtml(vnode, container) {
  32.   const { type, props } = vnode;
  33.   const node = document.createElement(type);
  34.   const { children, ...rest } = props;
  35.   children.map(item => {
  36.     if (Array.isArray(item)) {
  37.       item.map(c => {
  38.         mount(c, node);
  39.       });
  40.     } else {
  41.       mount(item, node);
  42.     }
  43.   });
  44.   Object.keys(rest).map(item => {
  45.     if (item === "className") {
  46.       node.setAttribute("class", rest[item]);
  47.     }
  48.     if (item.slice(0, 2) === "on") {
  49.       node.addEventListener("click", rest[item]);
  50.     }
  51.   });
  52.   container.appendChild(node);
  53. }
  54. function mountFunc(vnode, container) {
  55.   const { type, props } = vnode;
  56.   const node = new type(props);
  57.   mount(node, container);
  58. }
  59. function mountClass(vnode, container) {
  60.   const { type, props } = vnode;
  61.   const cmp = new type(props);
  62.   const node = cmp.render();
  63.   mount(node, container);
  64. }
  65. export default {
  66.   render,
  67. };
复制代码
到此这篇关于React运行机制超详细讲解的文章就介绍到这了,更多相关React运行机制内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源:https://www.jb51.net/article/266742.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x

上一篇: 使用JavaScript实现按钮的涟漪效果实例代码

下一篇: React深入分析useEffect源码

发表于 2023-1-2 12:05:11

举报 回复 使用道具

返回列表 发新帖

Archiver|手机版|小黑屋|翼度科技

Copyright © 2001-2020, Tencent Cloud.　Powered by Discuz! X3.4