1.react源码解析（二）时间管理大师fiber
2.react源码解析8.render阶段
3.preact源码解析，码结从preact中理解react原理
4.尝试全解React（一）
5.React源码 | 1. 基础：ReactElement
6.React事件机制的码结源码分析和思考
react源码解析（二）时间管理大师fiber
React的渲染和对比流程在面对大规模节点时，会消耗大量资源，码结影响用户体验。码结为了改进这一情况，码结React引入了Fiber机制，码结肌肤检测源码成为时间管理大师，码结平衡了浏览器任务和用户交互的码结响应速度。 Fiber的码结中文翻译为纤程，是码结一种内部更新机制，支持不同优先级的码结任务管理，具备中断与恢复功能。码结每个任务对应于React Element的码结Fiber节点。Fiber允许在每一帧绘制时间（约.7ms）内，码结合理分配计算资源，码结优化性能。 相比于React，React引入了Scheduler调度器。当浏览器空闲时，Scheduler会决定是否执行任务。Fiber数据结构具备时间分片和暂停特性，更新流程从递归转变为可中断的循环，通过shouldYield判断剩余时间，灵活调整更新节奏。 Scheduler的关键实现是requestIdleCallback API，它用于高效地处理碎片化时间，提高用户体验。尽管部分浏览器已支持该API，React仍提供了requestIdleCallback polyfill，以确保跨浏览器兼容性。 在Fiber结构中，每个节点包含返回指针（而非直接的父级指针），这个设计使得子节点完成工作后能返回给父级节点。这种机制促进了任务的高效执行。 Fiber的遍历遵循深度优先原则，类似王朝继承制度，确保每一帧内合理分配资源。通过实现深度优先遍历算法，可以构建Fiber树结构，用于渲染和更新DOM元素。 为了深入了解Fiber，可以使用本地环境调试源码。通过创建React项目并配置调试环境，可以观察Fiber节点的结构和行为。了解Fiber的遍历流程和结构后，可以继续实现一个简单的Fiber实例，这有助于理解React渲染机制的核心。 Fiber架构是React的核心，通过时间管理机制优化了性能，使React能够在大规模渲染时保持流畅。了解Fiber的交互流程和遍历机制，有助于深入理解React渲染流程。未来，将详细分析优先级机制、断点续传和任务收集等关键功能，揭示React是如何高效地对比和更新DOM树的。 更多深入学习资源和讨论可参考以下链接： 《React技术揭秘》 《完全理解React Fiber》 《浅谈 React Fiber》 《React Fiber 源码解析》 《走进 React Fiber 的世界》react源码解析8.render阶段
本文深入解析React源码中的渲染阶段，带你掌握React高效学习的精髓。让我们一起探索React的源代码，从基础到进阶，实现深入理解。
1. 开篇介绍和面试题
从最基础开始，集成短信宝源码解读面试题背后的原理，为你的学习之旅铺垫。
2. React设计理念
了解React的核心理念，为何它在现代前端开发中独树一帜。
3. React源码架构
拆解React源码结构，理解其设计的精妙之处。
4. 源码目录结构与调试
掌握React源码的目录布局和调试技巧，提升代码阅读效率。
5. JSX与核心API
深入学习JSX语法与React核心API，构建高效、灵活的组件。
6. Legacy与Concurrent模式入口函数
比较Legacy和Concurrent模式，了解React性能优化之道。
7. Fiber架构
揭秘Fiber的运作机制，理解React渲染的高效实现。
8. Render阶段
重点解析Render阶段的核心工作，构建Fiber树与生成effectList。
9. Diff算法
深入了解React的Diff算法，高效计算组件更新。
. Commit阶段
探索Commit阶段的流程，将Fiber树转换为真实DOM。
. 生命周期
掌握React组件的生命周期，优化组件性能。
. 状态更新流程
分析状态更新的机制，实现组件响应式的开发。
. Hooks源码
深入Hooks源码，理解状态管理与函数组件的结合。
. 手写Hooks
实践动手编写Hooks，巩固理解。
. Scheduler与Lane
探讨React的调度机制与Lane概念，优化渲染性能。
. Concurrent模式
探索Concurrent模式下的React渲染流程，提高应用的交互流畅度。
. Context
学习Context的用法，简化组件间的数据传递。
. 事件系统
深入事件处理机制，实现组件间的交互。
. 手写迷你版React
实践构建一个简单的React框架，深化理解。
. 总结与面试题解答
回顾学习要点，解答面试常见问题，为面试做好充分准备。
. Demo
通过实际案例，直观展示React渲染流程与技巧。
本课程带你全面掌握React渲染阶段的关键知识与实战技能，从理论到实践，提升你的前端开发能力。
preact源码解析，从preact中理解react原理
基于preact.3.4版本进行分析，完整注释请参阅链接。阅读源码建议采用跳跃式阅读，遇到难以理解的部分先跳过，待熟悉整体架构后再深入阅读。如果觉得有价值，不妨为项目点个star。 一直对研究react源码抱有兴趣，但每次都半途而废，主要原因是react项目体积庞大，代码颗粒化且执行流程复杂，需要投入大量精力。因此，无锡培训系统源码转向研究preact，一个号称浓缩版react，体积仅有3KB。市面上已有对preact源码的解析，但大多存在版本过旧和分析重点不突出的问题，如为什么存在_nextDom？value为何不在diffProps中处理？这些都是解析代码中的关键点和收益点。一. 文件结构
二. 渲染原理 简单demo展示如何将App组件渲染至真实DOM中。 vnode表示节点描述对象。在打包阶段，babel的transform-react-jsx插件会将jsx语法编译为JS语法，即转换为React.createElement(type, props, children)形式。preact中需配置此插件，使React.createElement对应为h函数，编译后的jsx语法如下：h(App,null)。 执行render函数后，先调用h函数，然后通过createVNode返回虚拟节点。最终，h(App,null)的执行结果为{ type:App,props:null,key:null,ref:null}，该虚拟节点将被用于渲染真实DOM。 首次渲染时，旧虚拟节点基本为空。diff函数比较虚拟节点与真实DOM，创建挂载完成，执行commitRoot函数，该函数执行组件的did生命周期和setState回调。2. diff
diff过程包含diff、diffElementNodes、diffChildren、diffProps四个函数。diff主要处理函数型虚拟节点，非函数型节点调用diffElementNodes处理。判断虚拟节点是否存在_component属性，若无则实例化，执行组件生命周期，调用render方法，保存子节点至_children属性，进而调用diffChildren。 diffElementNodes处理HTML型虚拟节点，创建真实DOM节点，查找复用，若无则创建文本或元素节点。diffProps处理节点属性，如样式、事件监听等。diffChildren比较子节点并添加至当前DOM节点。 分析diff执行流程，render函数后调用diff比较虚拟节点，执行App组件生命周期和render方法，保存返回的虚拟节点至_children属性，调用diffChildren比较子节点。整体虚拟节点树如下： diffChildren遍历子节点，查找DOM节点，比较虚拟节点，返回真实DOM，追加至parentDOM或子节点后。三. 组件
1. component
Component构造函数设置状态、强制渲染、定义render函数和enqueueRender函数。 强制渲染通过设置_force标记，加入渲染队列并执行。源码搭建培训课_force为真时，diff渲染不会触发某些生命周期。 render函数默认为Fragment组件，返回子节点。 enqueueRender将待渲染组件加入队列，延迟执行process函数。process排序组件，渲染最外层组件，调用renderComponent渲染，更新DOM后执行所有组件的did生命周期和setState回调。2. context
使用案例展示跨组件传递数据。createContext创建context，包含Provider和Consumer组件。Provider组件跨组件传递数据，Consumer组件接收数据。 源码简单，createContext后返回context对象，包含Consumer与Provider组件。Consumer组件设置contextType属性，渲染时执行子节点，等同于类组件。 Provider组件创建函数，渲染到Provider组件时调用getChildContext获取ctx对象，diff时传递至子孙节点组件。组件设置contextType，通过sub函数订阅Provider组件值更新，值更新时渲染订阅组件。四. 解惑疑点
理解代码意图。支持Promise时，使用Promise处理，否则使用setTimeout。了解Promise.prototype.then.bind(Promise.resolve())最终执行的Promise.resolve().then。 虚拟节点用Fragment包装的原因是，避免直接调用diffElementNodes，以确保子节点正确关联至父节点DOM。 hydrate与render的区别在于，hydrate仅处理事件，不处理其他props，适用于服务器端渲染的HTML，客户端渲染使用hydrate提高首次渲染速度。 props中value与checked单独处理，diffProps不处理，处理在diffChildren中，找到原因。 在props中设置value为空的原因是，遵循W3C规定，不设置value时，文本内容作为value。为避免MVVM问题，需在子节点渲染后设置value为空，再处理元素value。 组件异常处理机制中，_processingException和_pendingError变量用于标记组件异常处理状态，确保不会重复跳过异常组件。 diffProps中事件处理机制，为避免重复添加事件监听器，只在事件函数变化时修改dom._listeners，触发事件时仅执行保存的监听函数，移除监听在onChange设置为空时执行。 理解_nextDom的使用，确保子节点与父节点关联，golang源码怎么用避免在函数型节点渲染时进行不必要的关联操作。尝试全解React（一）
今天开始尝试更加全面深入的了解React这个框架的构造及功能实现、源码分析，今天是第一篇，主要介绍基础概念。本文主要参考了GitHub中的《图解React源码系列》。
一、宏观包结构React的工程目录下共有个包（.0.2版本），其中比较重要的核心包有4个，他们分别是：
React基础包提供定义react组件（ReactElement）的必要函数，包括大部分常用的api。
React-dom渲染器可以将react-reconciler中的运行结果输出到web页面上，其中比较重要的入口函数包括ReactDOM.render(<App/>,document.getElementByID('root'))。
React-reconciler核心包主要用来管理react应用状态的输入和结果的输出，并且可以将输入信号最终转换成输出信号传递给渲染器。主要的过程如下：
通过scheduleUpdateOnFiber接受输入，封装fiber树的生成逻辑到一个回调函数中，其中会涉及到fiber的树形结构、fiber.updateQueue队列、调用及相关的算法。
利用scheduler对回调函数（performSyncWorkOnRoot或perfromConcurrentWorkOnRoot）进行调度。
scheduler控制回调函数执行的时机，在回调函户执行后形成全新的fiber树。
最后调用渲染器（react-dom、react-native等）将fiber树结构渲染到界面上。
scheduler是调度机制的核心实现，会控制react-reconciler送入回调函数的执行时机，并且在concurrent模式下可以实现任务分片。主要功能有两点：
执行回调（回调函数由react-reconciler提供）。
通过控制回调函数的执行时机，来实现任务分片、可中断渲染。
二、架构分层如果按照React应用整体结构来分，可以将整个应用分解为接口层和内核层两个部分。
接口层（api）包含平时开发所用的绝大多数api，如setState、dispatchAction等，但不包括全部。在react启动之后，可以改变渲染的有三个基本操作：
类组件中调用setState()；
函数组件中使用hooks，利用dispatchAction来改变hooks对象；
改变context，实际上也是前二者。
内核层（core）react的内核可以分成三个部分来看待，他们分别担任不同的功能：
scheduler（调度器）——指责是执行回调。会把react-reconciler提供的回调函数包装到任务对象中，并在内部维护一个任务队列（按照优先级排序），循环消费队列，直至队列清空。
react-reconciler（构造器）。首先它会装载渲染器，要求渲染器必须实现HostConfig协议，保证在需要时能够正确调用渲染器的api并生成相应的节点；接着会接收react-dom包和react包发起的更新请求；最后会把fiber树的构造过程封装进一个回调函数，并将其传入scheduler包等待调度。
react-dom（渲染器）。它会引导react应用的启动（通过render），并且实现HostConfig协议，重点是能够表现出fiber树，生成相对应的dom节点和字符串。
三、工作循环在不同的方向上看过react的核心包之后，我们可以发现其中有两个比较重要的工作循环，它们分别是任务调度循环和fiber构造循环，分别位于scheduler和react-reconciler两个核心包中。
任务调度循环位于scheduler中，主要作用是循环调用，控制所有的任务调度。
fiber构造循环位于react-reconciler中，主要是控制fiber树的构造，整体过程是一个深度优先遍历的过程。
两个工作循环的区别与联系任务调度循环数据结构为二叉树，循环执行堆的顶点，直到堆被清空；逻辑偏向宏观，调度的目标为每一个任务，具体任务就是执行相应的回调函数；
fiber构造循环数据结构为树，从上至下执行深度优先遍历；其逻辑偏向具体实现，只会负责任务的某一个部分，只负责fiber树的构造；
fiber构造循环可以看作是任务调度循环的一部分，它们类似从属关系，每个任务都会构造一个fiber树。
React主干逻辑了解了两个工作循环的区别与联系后，可以发现：React的运行主干逻辑其实就是任务调度循环负责调度每个任务，fiber构造循环负责具体实现任务，即输入转换为输出的核心步骤。
也可以总结如下：
输入：每一次节点需要更新就视作一次更新需求；
注册调度任务：react-reconciler接收到更新需求后，会去scheduler调度中心注册一个新的任务，把具体需求转换成一个任务；
执行调度任务（输出）：scheduler通过任务调度循环来执行具体的任务，此时执行具体过程在react-reconciler中。而后通过fiber构造循环构造出最新的fiber树，最后通过commitRoot把最新的fiber树渲染到页面上，此时任务才算完成。
四、高频对象接下来介绍一下从react启动到页面渲染过程中出现频率较高的各个包中的高频对象。
react包此包中包含react组件的必要函数以及一些api。其中，需要重点理解的是ReactElment对象，我们可以假设有一个入口函数：
ReactDOM.render(<App/>,document.getElementById('root'));可以认为，App及其所有子节点都是ReactElement对象，只是它们的type会有区别。
ReactElement对象。
可以认为所有采用JSX语法书写的节点都会被编译器编译成React.createElement(...)的形式，所以它们创建出来的也就是一个个ReactElment对象。其数据结构如下：
exporttypeReactElement={ |//辨别是否为ReactElement的标志$$typeof:any,//内部属性type:any,key:any,ref:any,props:any,//ReactFiber记录创建本对象的Fiber节点，未关联到Fiber树前为null_owner:any,//__DEV__dev环境下的额外信息_store:{ validated:boolean,...},_self:React$Element<any>,_shadowChildren:any,_source:Source,|}其中值得注意的有：
key：在reconciler阶段中会用到，所有ReactElment对象都有key属性，且默认值为null；
type：决定了节点的种类。它的值可以是字符串，函数或react内部定义的节点类型；在reconciler阶段会根据不同的type来执行不同的逻辑，如type为字符串类型则直接调用，是ReactComponent类型则调用其render方法获取子节点，是function类型则调用方法获取子节点等。
ReactComponent对象
这是type的一种类型，可以把它看作一种特殊的ReactElement。这里也引用原作者的一个简单例子：
classAppextendsReact.Component{ render(){ return(<divclassName="app"><header>header</header><Content/><footer>footer</footer></div>);}}classContentextendsReact.Component{ render(){ return(<React.Fragment><p>1</p><p>2</p><p>3</p></React.Fragment>);}}exportdefaultApp;我们可以观察它编译之后得到的代码，可以发现，createElement函数的第一个参数将作为创建ReactElement的type，而这个Content变量会被命名为App_Content，作为第一个参数传入createElement。
classApp_Appextendsreact_default.a.Component{ render(){ return/*#__PURE__*/react_default.a.createElement('div',{ className:'app',}/*#__PURE__*/,react_default.a.createElement('header',null,'header')/*#__PURE__*/,//此处直接将Content传入,是一个指针传递react_default.a.createElement(App_Content,null)/*#__PURE__*/,react_default.a.createElement('footer',null,'footer'),);}}classApp_Contentextendsreact_default.a.Component{ render(){ return/*#__PURE__*/react_default.a.createElement(react_default.a.Fragment,null/*#__PURE__*/,react_default.a.createElement('p',null,'1'),/*#__PURE__*/react_default.a.createElement('p',null,'2'),/*#__PURE__*/react_default.a.createElement('p',null,'3'),);}}自此，可以得出两点结论：
ReactComponent是class类型，继承父类Component，拥有特殊方法setState和forceUpdate，特殊属性context和updater等。
在reconciler阶段，会根据ReactElement对象的特征生成对应的fiber节点。
顺带也可以带出ReactElement的内存结构，很明显它应该是一种类似树形结构，但也具有链表的特征：
class和function类型的组件，子节点要在组件render后才生成；
父级对象和子对象之间是通过props.children属性进行关联的；
ReactElement生成过程自上而下，是所有组件节点的总和；
ReactElement树和fiber树是以props.children为单位先后交替生成的；
reconciler阶段会根据ReactElement的类型生成对应的fiber节点，但不是一一对应的，比如Fragment类型的组件在生成fiber节点的时候就会略过。
react-reconciler包react-reconciler连接渲染器和调度中心，同时自身也会负责fiber树的构造。
Fiber对象
Fiber对象是react中的数据核心，我们可以在ReactInternalTypes.js中找到其type的定义：
//一个Fiber对象代表一个即将渲染或者已经渲染的组件(ReactElement),一个组件可能对应两个fiber(current和WorkInProgress)//单个属性的解释在后文(在注释中无法添加超链接)exporttypeFiber={ |tag:WorkTag,//表示fiber类型key:null|string,//和ReactElement一致elementType:any,//一般来讲和ReactElement一致type:any,//一般和ReactElement一致，为了兼容热更新可能会进行一定的处理stateNode:any,//与fiber关联的局部状态节点return:Fiber|null,//指向父节点child:Fiber|null,//指向第一个子节点sibling:Fiber|null,//指向下一个兄弟节点index:number,//fiber在兄弟节点中的索引，如果是单节点则默认为0ref://指向ReactElement组件上设置的ref|null|(((handle:mixed)=>void)&{ _stringRef:?string,...})|RefObject,pendingProps:any,//从`ReactElement`对象传入的props.用于和`fiber.memoizedProps`比较可以得出属性是否变动memoizedProps:any,//上一次生成子节点时用到的属性,生成子节点之后保持在内存中updateQueue:mixed,//存储state更新的队列,当前节点的state改动之后,都会创建一个update对象添加到这个队列中.memoizedState:any,//用于输出的state,最终渲染所使用的statedependencies:Dependencies|null,//该fiber节点所依赖的(contexts,events)等mode:TypeOfMode,//二进制位Bitfield,继承至父节点,影响本fiber节点及其子树中所有节点.与react应用的运行模式有关(有ConcurrentMode,BlockingMode,NoMode等选项).//Effect副作用相关flags:Flags,//标志位subtreeFlags:Flags,//替代.x版本中的firstEffect,nextEffect.当设置了enableNewReconciler=true才会启用deletions:Array<Fiber>|null,//存储将要被删除的子节点.当设置了enableNewReconciler=true才会启用nextEffect:Fiber|null,//单向链表,指向下一个有副作用的fiber节点firstEffect:Fiber|null,//指向副作用链表中的第一个fiber节点lastEffect:Fiber|null,//指向副作用链表中的最后一个fiber节点//优先级相关lanes:Lanes,//本fiber节点的优先级childLanes:Lanes,//子节点的优先级alternate:Fiber|null,//指向内存中的另一个fiber,每个被更新过fiber节点在内存中都是成对出现(current和workInProgress)//性能统计相关(开启enableProfilerTimer后才会统计)//react-dev-tool会根据这些时间统计来评估性能actualDuration?:number,//本次更新过程,本节点以及子树所消耗的总时间actualStartTime?:number,//标记本fiber节点开始构建的时间selfBaseDuration?:number,//用于最近一次生成本fiber节点所消耗的时间treeBaseDuration?:number,//生成子树所消耗的时间的总和|};Update与UpdateQueue对象
在fiber对象中有一个属性fiber.updateQueue，是一个链式队列，一样来看一下源码：
exporttypeUpdate<State>={ |eventTime:number,//发起update事件的时间(.0.2中作为临时字段,即将移出)lane:Lane,//update所属的优先级tag:0|1|2|3,//payload:any,//载荷,根据场景可以设置成一个回调函数或者对象callback:(()=>mixed)|null,//回调函数next:Update<State>|null,//指向链表中的下一个,由于UpdateQueue是一个环形链表,最后一个update.next指向第一个update对象|};//===============UpdateQueue==============typeSharedQueue<State>={ |pending:Update<State>|null,//指向即将输入的queue队列，class组件调用setState后会将新的update对象添加到队列中来|};exporttypeUpdateQueue<State>={ |baseState:State,//队列的基础statefirstBaseUpdate:Update<State>|null,//指向基础队列的队首lastBaseUpdate:Update<State>|null,//指向基础队列的队尾shared:SharedQueue<State>,//共享队列effects:Array<Update<State>>|null,//用于保存有callback函数的update对象，commit后会依次调用这里的回调函数|};Hook对象
Hook主要用于函数组件中，能够保持函数组件的状态。常用的api有useState、useEffect、useCallback等。一样，我们来看看源码是如何定义Hook对象的数据结构的：
exporttypeHook={ |memoizedState:any,//内存状态，用于最终输出成fiber树baseState:any,//基础状态，会在Hook.update后更新baseQueue:Update<any,any>|null,//基础状态队列，会在reconciler阶段辅助状态合并queue:UpdateQueue<any,any>|null,//指向一个Update队列next:Hook|null,//指向该函数组件的下一个Hook对象，使多个Hook构成链表结构|};typeUpdate<S,A>={ |lane:Lane,action:A,eagerReducer:((S,A)=>S)|null,eagerState:S|null,next:Update<S,A>,priority?:ReactPriorityLevel,|};typeUpdateQueue<S,A>={ |pending:Update<S,A>|null,dispatch:(A=>mixed)|null,lastRenderedReducer:((S,A)=>S)|null,lastRenderedState:S|null,|};由此我们可以看出Hook和fiber的联系：在fiber对象中有一个属性fiber.memoizedState会指向fiber节点的内存状态。而在函数组件中，其会指向Hook队列。
scheduler包scheduler内部会维护一个任务队列，是一个最小堆数组，其中存储了任务task对象。
Task对象
task对象的类型定义不在scheduler中，而是直接定义在js代码中：
varnewTask={ id:taskIdCounter++,//位移标识callback,//task最核心的字段，指向react-reconciler包所提供的回调函数priorityLevel,//优先级startTime,//代表task开始的时间，包括创建时间+延迟时间expirationTime,//过期时间sortIndex:-1,//控制task队列中的次序，值越小越靠前};总结今天主要总结了react包中的宏观结构可以分成scheduler、react-reconciler以及react-dom三个部分、两大工作循环（任务调度循环、fiber构造循环）的区别与联系和一些高频对象的类型定义等，这些都将作为后面源码解读的敲门砖。最后补上整体的工作流程示意图，方便理解记忆～
©本总结教程版权归作者所有，转载需注明出处原文：/post/React源码 | 1. 基础：ReactElement
本文将深入探讨ReactElement的基础，重点关注JSX作为React的官方语法，以及其如何通过Babel转换为JavaScript。
JSX，全称为JavaScript XML，允许开发者在JavaScript中嵌入HTML代码，简化组件的创建与渲染。然而，浏览器无法直接解析JSX，因此需要一个转换器，Babel扮演这一角色，它将JSX代码编译成JavaScript文件，让浏览器能够解析。
Babel的转换规则相对简单。对于直接的JavaScript写法，无需转换，但为了兼容性，可能会将某些高版本的语法翻译成低版本。关注的重点在于HTML的处理方式。以这行代码为例：
通过Babel转换后，HTML语法转变成JavaScript语法，即最终将JSX转换为JavaScript。
接着，我们用复杂一点的例子来演示转换规则。React.createElement函数的使用表明，第一个参数表示节点类型，第二个参数是一个对象，包含属性如key：value，后面则是子节点。通过这个规则，我们了解到JSX语法不仅支持原生HTML节点，还包含大量自定义组件。
比如，自定义组件定义如下：
在此，React.createElement的第一个参数转变为变量形式，而非字符串。尝试将函数Comp首字母小写：
然而，React.createElement的第一个参数又变回字符串。这就解释了在React中自定义组件的首字母应大写的原因：Babel编译时将首字母小写的组件视作原生HTML节点，若将自定义组件首字母小写，后续程序将无法识别，最终报错。
Babel编译后的JavaScript代码中，React.createElement函数的调用频繁出现，其返回值为ReactElement。通过示例，我们可以看到ReactElement的结构，即一个简单的对象，包含三个或三类参数。编译后，JSX中的HTML节点转换为嵌套的ReactElement对象，这些对象对构建应用的树结构至关重要，且帮助React实现平台无关性。
React事件机制的源码分析和思考
本文探讨了React事件机制的实现原理及其与浏览器原生事件机制的异同。基于React版本.0.1，本文对比了与.8.6版本的不同之处，深入分析了React事件池、事件代理机制和事件触发过程。
在原生Web应用中，事件机制分为事件捕获和事件冒泡两种方式，以解决不同浏览器之间的兼容性问题。事件代理机制允许事件在根节点捕获，然后逐层冒泡，从而减少事件监听器的绑定，提升性能。
React引入事件池概念，以减少事件对象的创建和销毁，提高性能。然而，在React 中，这一概念被移除，事件对象不再复用。React内部维护了一个全局事件代理，通过在根节点上绑定所有浏览器原生事件的代理，实现了事件的捕获和冒泡过程。事件回调的执行顺序遵循捕获-冒泡的路径，而事件传播过程中，React合成事件对象与原生事件对象共用。
React合成事件对象支持阻止事件传播、阻止默认行为等功能。在React事件内调用`stopPropagation`方法可以阻止事件的传播，同时`preventDefault`方法可以阻止浏览器的默认行为。在实际应用中，需注意事件执行的顺序和阻止行为的传递。
文章最后讨论了React事件机制的优化和调整，强调了React对事件调度的优化，并提供了对不同事件优先级处理的指导。通过对比不同版本的React，本文为理解React事件机制提供了深入的见解。
React源码学习入门（二）React的render究竟返回的是什么？
深入解析React源码，首先关注核心问题：React的render究竟返回的是什么？理解这一问题，是进一步探索React源码的关键。
React的render函数返回类型被定义为ReactNode。ReactNode可以是多种类型，其中最重要且常见的类型是ReactElement。JSX扩展语法，是React团队早期引入的一种JavaScript语法，允许开发者以类似HTML标签的方式编写代码。
通过Babel编译器，JSX语法转化为React.createElement的调用，这是render函数实际返回的值。ReactElement是一个普通对象，包含type、props等关键属性，是React内部渲染返回的实际底层表示。
ReactElement封装了所有需要的信息，形式简单却极其重要，它相当于一个标记（token），是一种DSL（Domain Specific Language）。通过这一抽象表示，React构建了组件的嵌套树，即Virtual DOM。Virtual DOM允许React实现跨端跨平台的通用处理，且得益于高效的Diff算法，显著提升了整体更新性能，为SSR（Server-Side Rendering）开辟了可能。
React团队在年提出这一理念并实现，展现出前瞻性和创新性，引领了前端技术的新纪元。综上，React的render函数实质返回的是一种简单对象——ReactElement，这一对象通过构建Virtual DOM，实现了前端技术的革新。
源码级解析，搞懂 React 动态加载（上） —— React Loadable
本系列深入探讨SPA单页应用技术栈，首篇聚焦于React动态加载机制，解析当前流行方案的实现原理。
随着项目复杂度的提升和代码量的激增，如企业微信文档融合项目，代码量翻倍，性能和用户体验面临挑战。SPA的特性使得代码分割成为优化代码体积的关键策略。
code-splitting原理在于将大型bundle拆分为多个，实现按需加载和缓存，显著降低前端应用的加载体积。ES标准的import()函数提供动态加载支持，babel编译后，import将模块内容转换为ESM数据结构，通过promise返回，加载后在then中注册回调。
webpack检测到import()时，自动进行code-splitting，动态import的模块被打包到新bundle中。通过注释可自定义命名，如指定bar为动态加载bundle。
实现简易版动态加载方案，利用code-splitting和import，组件在渲染前加载，渲染完成前展示Loading状态，优化用户体验。然而，复杂场景如加载失败、未完成等需要额外处理。
引入React-loadable，动态加载任意模块的高阶组件，封装动态加载逻辑，支持多资源加载。通过传入参数如模块加载函数、Loading状态组件，统一处理动态加载成功与异常。
通过react-loadable改造组件，实现加载前渲染Loading状态，加载完成后更新组件。支持单资源或多资源Map动态加载，兼容多种场景。
Loadable核心是createLoadableComponent函数，采用策略模式，根据不同场景（单资源或多资源Map）加载模块。load方法封装加载状态与结果，loadMap方法加载多个loader，返回对象。
LoadableComponent高阶组件实现逻辑简单，通过注册加载完成与失败的回调，更新组件状态。默认渲染方法为React.createElement()，使用Loadable.Map时需显式传入渲染函数。
在服务端渲染（SSR）场景下，动态加载组件无法准确获取DOM结构，react-loadable提供解决方案，将异步加载转化为同步，支持SSR。
React loadable原始仓库不再维护，局限性体现在适用的webpack与babel版本、兼容性问题以及不支持现代React项目。针对此问题，@react-loadable/revised包提供基于Hooks与ts重构的解决方案。
React-loadable的实现原理与思路较为直观，下文将深入探讨React.lazy + Suspense的原生解决方案，理解Fiber架构中的动态加载，有助于掌握更深层次的知识。
