1.reactԴ?码分????
2.preact源码解析，从preact中理解react原理
3.尝试全解React（一）
4.React源码分析4-深度理解diff算法
5.源码级解析，码分搞懂 React 动态加载（下） —— @loadable/component
6.React 弹窗组件用的码分 createPortal 是怎么实现的？
reactԴ?????
前言
本文将详细介绍React-Router的核心原理。重点关注Route组件和History库之间的码分关系，以及它们如何构建React路由系统。码分
简单示例
首先，码分fusionapp影视源码我们将构建一个简单的码分React-Router示例。利用create-react-app脚手架快速搭建项目环境。码分接下来，码分将安装react-router-dom，码分以获取更多的码分路由操作功能。
React-router-dom与React-router的码分区别
React-router-dom在React-router的基础上扩展了与DOM交互的API。它提供了Link组件来渲染链接，码分以及BrowserRouter和HashRouter组件，码分分别采用不同方式（pushState和hashchange）管理路由。码分
BrowserRouter组件
BrowserRouter组件是整个React-Router系统的核心，它依赖于history和react-router库。通过构造函数监听位置更改，确保组件正确响应路由变化。
源码分析
深入BrowserRouter组件源码，观察构造函数和生命周期方法，理解其如何与history库交互以管理路由状态。重点关注如何在组件卸载时取消监听。
历史对象（history）
历史对象包含多种方法，如push、replace、go等，用于管理浏览器历史栈。通过createBrowserHistory函数创建自定义历史管理器。
关键API
React-Router提供了丰富的API，包括Router、Switch、Route等。其中，Route组件用于声明路由映射，而Switch组件负责匹配路径并渲染对应的组件。同时，还介绍Prompt、Redirect和Lifecycle组件的用法。
核心流程
React-Router的执行流程包括监听URL变化、匹配路由路径、渲染匹配的组件以及处理路由跳转。通过window.addEventListener('popstate')监听浏览器状态变化，进而更新组件状态并重新渲染。
总结
本文深入分析了React-Router的实现原理，从组件结构到核心API，再到流程细节，旨在帮助开发者全面理解React路由系统。通过阅读本文，您将对React-Router有更深入的认识，从而更灵活地应用到实际项目中。
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方法，保存返回的溯源码燕窝019虚拟节点至_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的使用，确保子节点与父节点关联，避免在函数型节点渲染时进行不必要的关联操作。尝试全解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源码分析4-深度理解diff算法
React 每次更新，都会通过 render 阶段中的 reconcileChildren 函数进行 diff 过程。这个过程是 React 名声远播的优化技术，对新的 ReactElement 内容与旧的 fiber 树进行对比，从而构建新的 fiber 树，将差异点放入更新队列，对真实 DOM 进行渲染。简单来说，diff 算法是为了以最低代价将旧的 fiber 树转换为新的 fiber 树。
经典的 diff 算法在处理树结构转换时的时间复杂度为 O(n^3)，其中 n 是树中节点的个数。在处理包含 个节点的应用时，这种算法的性能将变得不可接受，需要进行优化。React 通过一系列策略，将 diff 算法的时间复杂度优化到了 O(n)，实现了高效的更新 virtual DOM。
React 的 diff 算法优化主要基于以下三个策略：tree diff、component diff 和 element diff。tree diff 策略采用深度优先遍历，仅比较同一层级的元素。当元素跨层级移动时，React 会将它们视为独立的更新，而不是直接合并。
component diff 策略判断组件类型是否一致，不一致则直接替换整个节点。这虽然在某些情况下可能牺牲一些性能，但考虑到实际应用中类型不一致且内容完全一致的情况较少，这种做法有助于简化 diff 算法，保持平均性能。
element diff 策略通过 key 对元素进行比较，识别稳定的渲染元素。对于同层级元素的比较，存在插入、删除和移动三种操作。这种策略能够有效管理 DOM 更新，确保性能。
结合源码的 diff 整体流程从 reconcileChildren 函数开始，根据当前 fiber 的存在与否决定是直接渲染新的 ReactElement 内容还是与当前 fiber 进行 Diff。主要关注的函数是 reconcileChildFibers，其中的细节与具体参数的处理方式紧密相关。不同类型的 ReactElement（如 REACT_ELEMENT_TYPE、纯文本类型和数组类型）将走不同的 diff 流程，实现更高效、针对性的处理。
diff 流程结束后，形成新的 fiber 链表树，链表树上的 fiber 标记了插入、删除、更新等副作用。在完成 unitWork 阶段后，React 构建了一个 effectList 链表，记录了需要进行真实 DOM 更新的 fiber。在 commit 阶段，根据 effectList 进行真实的 DOM 更新。下一章将深入探讨 commit 阶段的详细内容。
源码级解析，搞懂 React 动态加载（下） —— @loadable/component
源码级解析，探索 React 动态加载的实现与特性
本系列文章旨在深入探讨单页应用（SPA）技术栈，重点关注动态加载方案的实现原理。上篇中，我们已介绍了 react-loadable 和 React.lazy，其中后者几乎已覆盖所有使用场景，并在 React 版本中添加了 SSR 支持。今天，我们将聚焦于一款名为 @loadable/component 的新方案，探索其在动态加载领域的独特优势与实现机制。
根据官方说明，@loadable/component 不仅支持动态加载组件，还扩展了 prefetch、library 分割等特性，并提供简洁的 API。它允许用户在不依赖其他高阶组件的情况下，直接动态加载组件或库。
为了直观理解动态加载的实现原理，我们先从具体例子入手。通过改造开头的例子，我们展示了如何使用 @loadable/component 实现组件动态加载。
接下来，我们将深入探讨动态加载组件与库之间的区别，以及如何利用 loadable 和 loadable.lib 函数实现动态加载。通过分析源码，我们发现核心逻辑在于使用 createLoadable 工厂方法，该方法根据不同的加载方式（loadable 和 lazy）生成高阶组件 Loadable。
分析 loadable 和 lazy 的实现区别后，我们发现它们在加载模块时的流程相似，但在加载组件时有所差异。动态加载的 ref 属性转发机制也是动态加载组件与库的重要特性之一，通过分析 Loadable 组件内部的实现细节，我们揭示了 ref 属性的指向原理。
在服务端渲染场景下，@loadable/component 的动态加载机制与客户端有所不同，主要通过同步加载动态组件/库来确保渲染过程的流畅性。通过构造函数中的同步加载操作，我们实现了服务端与浏览器端的加载一致，进而保证了渲染时可以获取到动态资源。
总结对比不同动态加载方案，React.lazy + Suspense 提供了强大的异步渲染控制能力，而 react-loadable 和 @loadable/component 则通过高阶组件的形式，实现了组件与库的动态加载。在选择动态加载方案时，应根据项目需求和具体场景进行评估，考虑到不同的特性和限制。
React 弹窗组件用的 createPortal 是怎么实现的？
React 中弹窗组件的实现，往往依赖于 createPortal 这个 API。它能够将组件渲染到文档的任意位置，比如 antd 的 Modal 组件通常会直接挂在 body 下面。让我们通过源码分析来揭示这个功能的工作原理。
首先，React 的组件渲染过程包含 render（创建虚拟DOM）和 commit（实际更新DOM）两个阶段。当我们在jsx中定义弹窗组件时，React 会将其编译成 render function，生成的 React Element 是虚拟DOM的核心表示。
接下来，createPortal 函数的介入就显得尤为重要。当调用这个函数时，它会返回一个特殊的 React Element，类型为 REACT_PORTAL_TYPE。这个元素内部保存了容器信息（containerInfo），它是后续将组件挂载到指定位置的关键。
在 reconciliation 阶段，这个 REACT_PORTAL_TYPE 的 React Element 会转换成对应的 fiber 节点，并将 containerInfo 存储在 fiber.stateNode 中。这个操作允许React根据不同类型的 fiber 节点管理它们的私有数据，如状态信息。
到了 commit 阶段，React 会遍历 fiber 树并执行DOM操作。在处理 portal 的 fiber 节点时，它会调用插入或追加的方法，将组件实际插入到 body 中，从而实现了我们看到的弹窗组件直接挂载到文档主体的效果。
总结来说，createPortal 的使用使得React能够灵活地将组件渲染到任何指定位置，整个过程涉及到 render、reconciliation 和 commit 的协同工作，最终实现了弹窗组件的动态显示效果。
Expo 搭建 React-native 项目代码目录分析
创建React-native项目时，Expo提供了多种工具简化开发过程。根据项目需求，选择不同的模板：空白模板（blank）适合演示、组件预览和个人项目；带有底部tab菜单的模板（tabs）；需要直接控制原生代码时选择（minimal）；遇到未知问题则选择RN方式。[1] React Native的典型目录结构包括以下几个部分：[2]src：存放组件源代码，是项目开发的核心目录。
test：用于编写和运行组件的测试用例。
demo：包含一个独立的Expo项目，App.js是核心文件，通过引用src中的组件进行展示和开发。
其他文件如.eslintrc.js, babel.config.js, README.md, .gitignore, package.json等，分别负责代码风格规范、编译配置、项目介绍和版本管理。
引入Expo时，需注意src目录与demo目录的配置协调，以确保metro（打包工具）能够正确处理。首先安装Expo CLI，然后创建项目，通过yarn start预览组件。配置metro时，重点在于新版本的metro.config.js，用于添加providesModuleNodeModules，解决src目录依赖的解析问题。[3] 总结起来，开发过程中App.js是关键，负责组件的集成和展示。app.json和package.json分别用于设置应用配置和依赖管理。assets存放资源文件，babel.config.js用于代码转换，index.js是应用入口，metro.config.js负责项目打包，而yarn.lock则保证了依赖版本的一致性。eas.json则提供了EAS平台的云构建和部署选项。每个文件都有其特定的功能，共同构建React-native项目的开发流程。[4]React事件机制的源码分析和思考
本文探讨了React事件机制的实现原理及其与浏览器原生事件机制的异同。基于React版本.0.1，本文对比了与.8.6版本的不同之处，深入分析了React事件池、事件代理机制和事件触发过程。
在原生Web应用中，事件机制分为事件捕获和事件冒泡两种方式，以解决不同浏览器之间的兼容性问题。事件代理机制允许事件在根节点捕获，然后逐层冒泡，从而减少事件监听器的绑定，提升性能。
React引入事件池概念，以减少事件对象的创建和销毁，提高性能。然而，在React 中，这一概念被移除，事件对象不再复用。React内部维护了一个全局事件代理，通过在根节点上绑定所有浏览器原生事件的代理，实现了事件的捕获和冒泡过程。事件回调的执行顺序遵循捕获-冒泡的路径，而事件传播过程中，React合成事件对象与原生事件对象共用。
React合成事件对象支持阻止事件传播、阻止默认行为等功能。在React事件内调用`stopPropagation`方法可以阻止事件的传播，同时`preventDefault`方法可以阻止浏览器的默认行为。在实际应用中，需注意事件执行的顺序和阻止行为的传递。
文章最后讨论了React事件机制的优化和调整，强调了React对事件调度的优化，并提供了对不同事件优先级处理的指导。通过对比不同版本的React，本文为理解React事件机制提供了深入的见解。
