<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>React on EuDs&#39;s Blog</title>
    <link>https://euds.org/tags/react/</link>
    <follow_challenge>
      <feedId>55788057182175234</feedId>
      <userId>67186528297029632</userId>
    </follow_challenge>
    <description>Recent content in React on EuDs&#39;s Blog</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Tue, 08 Oct 2024 15:34:14 +0800</lastBuildDate><atom:link href="https://euds.org/tags/react/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>进一步学习ReactHook</title>
      <link>https://euds.org/2024/learn_react_hook/</link>
      <pubDate>Tue, 08 Oct 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/learn_react_hook/</guid>
      <description>从“生命周期和时间”的思维模式转变为“状态和与DOM的同步”的思维模式</description>
      <content:encoded><![CDATA[<h2 id="react-官方-hook">React 官方 Hook</h2>
<p>Hook 是 React 16.8 之后引入的一个特性，允许你在不使用类组件的情况下在函数组件中引入状态和其他 React 特性。</p>
<h3 id="usestate"><code>useState</code></h3>
<ul>
<li><code>useState</code> 允许在函数组件中引入局部状态。它的实现依赖于闭包和状态管理机制。</li>
<li>每次渲染时，React 通过维护一个 “hook 调用栈” 来保存每次调用 <code>useState</code> 后的状态。这些状态被保存在一个链表结构中，每次渲染时 React 都会按顺序遍历这些状态。</li>
</ul>
<h3 id="useeffect"><code>useEffect</code></h3>
<ul>
<li><code>useEffect</code> 允许在函数组件中执行副作用，比如数据请求、订阅、直接 DOM 操作等。- 它的实现原理是通过依赖数组来追踪变化，并在 DOM 完成更新后执行指定的副作用逻辑。如果某些依赖值发生变化，React 就会在下一次渲染后重新执行该副作用函数。</li>
</ul>
<h3 id="usecontext"><code>useContext</code></h3>
<p>wip</p>
<h3 id="usereducer"><code>useReducer</code></h3>
<p>wip</p>
<ul>
<li>参考: <a href="https://juejin.cn/post/7091180323123232782"  target="_blank" rel="noopener" >深入学习React Hook——useReducer - 掘金</a></li>
</ul>
<h2 id="useid">useId</h2>
<ul>
<li><a href="https://react.dev/reference/react/useId"  target="_blank" rel="noopener" >useId – React</a></li>
<li>generate a unique ID</li>
<li>A component may be rendered more than once on the page—but IDs have to be unique! Instead of hardcoding an ID, generate a unique ID with useId.</li>
</ul>
<hr>
<h3 id="hook-的顺序与规则">Hook 的顺序与规则</h3>
<ul>
<li>Hook 的使用顺序非常重要。React 需要在每次渲染时依赖 Hook 调用的顺序来关联正确的状态。所以，Hook 必须在顶层调用，不能放在条件或循环中。</li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/6891577820821061646"  target="_blank" rel="noopener" >React Hooks原理探究，看完不懂，你打我 - 掘金</a></li>
<li><a href="https://coderperson.com/2020/08/02/React%20Hooks%20%E8%A7%A3%E6%9E%90/"  target="_blank" rel="noopener" >React Hooks解析（看这一篇就够了） | 骚客</a></li>
<li><a href="https://incepter.github.io/how-react-works/docs/react-dom/how.hooks.work/#thenable"  target="_blank" rel="noopener" >How hooks work | How React Works</a></li>
<li><a href="https://github.com/z-memo/interview/issues/138"  target="_blank" rel="noopener" >react hooks 的原理是什么 · Issue #138 · z-memo/interview</a></li>
</ul>
<hr>
<h2 id="自定义hook">自定义hook</h2>
<h3 id="hook的理解">hook的理解</h3>
<ol>
<li>
<blockquote>
<p>在 React 中被调用的且以 use 开头命名的函数叫 Hook。</p>
</blockquote>
</li>
<li>Hooks 是一种范式转换，从“生命周期和时间”的思维模式转变为“状态和与DOM的同步”的思维模式</li>
</ol>
<blockquote>
<p>准确来说，应该是逻辑片段复用。</p>
<p>和组件化思维不同，这是另外一个粒度更细的代码复用思维。例如我们之前提到的，获取同样的数据。在组件化思维中，一个完整的组件，包括了这份数据，以及这份数据在页面上的展示结果。因此这是不同的复用思维。</p>
<p>处理获取数据过程中的公用逻辑，处理公用的登陆逻辑等。自定义hooks封装的大多数情况下不是一个完整的页面逻辑实现，而是其中的一个片段。 自定义hook能够跟随函数组件重复执行，并且每次都返回最新结果。因此，我们可以非常放心大胆的封装异步逻辑。</p>
</blockquote>
<ol start="3">
<li>自定义 Hook 是将逻辑封装为可重用的代码块。它实际上是一个普通的 JavaScript 函数，可以使用其他 Hook，并返回状态或副作用逻辑。自定义 Hook 让组件逻辑更加灵活和可重用。</li>
</ol>
<h3 id="自己的经历">自己的经历</h3>
<ol>
<li>
<p>在我写<a href="https://github.com/EuDs63/BookRecommend_Front"  target="_blank" rel="noopener" >EuDs63/BookRecommend_Front: 图书推荐系统</a>，就很经常需要从API获取数据。虽然这时候还没有自定义hook的概念，但很自然地封装了一个函数。在看了<a href="https://blog.skk.moe/post/why-you-should-not-fetch-data-directly-in-use-effect/"  target="_blank" rel="noopener" >为什么你不应该在 React 中直接使用 useEffect 从 API 获取数据 | Sukka&rsquo;s Blog</a>，了解到<a href="https://swr.vercel.app/zh-CN"  target="_blank" rel="noopener" >用于数据请求的 React Hooks 库 – SWR</a>。</p>
</li>
<li>
<p>发现了阿里巴巴开源的<a href="https://ahooks.js.org/"  target="_blank" rel="noopener" >ahooks - React Hooks Library - ahooks 3.0</a>,封装了常用的hook，代码量都不算很大，但都很巧妙，正在学习中。</p>
</li>
<li>
<p>看<a href="https://blog.saeloun.com/2022/02/17/how-to-integrate-react-app-with-google-analytics/"  target="_blank" rel="noopener" >How to integrate Google Analytics with React JS application? | Saeloun Blog</a> ,可以把ga给集成为hook,react-router-dom</p>
</li>
<li>
<p>读<a href="https://swr.vercel.app/zh-CN"  target="_blank" rel="noopener" >用于数据请求的 React Hooks 库 – SWR</a>，看上了<a href="https://swr.vercel.app/zh-CN/examples/subscription"  target="_blank" rel="noopener" >Subscription – SWR</a>，感觉能用来替代项目中使用的redux，但搜了圈，能找到的资料不多，算了。</p>
</li>
<li>
<p>发现<a href="https://usehooks.com/"  target="_blank" rel="noopener" >useHooks – The React Hooks Library</a>，可以学学</p>
</li>
</ol>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://mp.weixin.qq.com/s?__biz=MzI4NjE3MzQzNg==&amp;mid=2649865889&amp;idx=1&amp;sn=2549fb3da7608aa8e3cce0623fbd8d25"  target="_blank" rel="noopener" >超性感的React Hooks（五）：自定义hooks</a></li>
<li><a href="https://mp.weixin.qq.com/s/GPcwIPJBc9I_NtixyU-U4Q"  target="_blank" rel="noopener" >超性感的React Hooks（六）自定义hooks的思维方式</a></li>
<li><a href="https://blog.skk.moe/post/why-you-should-not-fetch-data-directly-in-use-effect/"  target="_blank" rel="noopener" >为什么你不应该在 React 中直接使用 useEffect 从 API 获取数据 | Sukka&rsquo;s Blog</a></li>
<li><a href="https://zh-hans.react.dev/warnings/invalid-hook-call-warning"  target="_blank" rel="noopener" >Hook 规则 – React 中文文档</a></li>
</ul>
<hr>
<h2 id="问题">问题</h2>
<h3 id="react-是如何把对-hook-的调用和组件联系起来的">React 是如何把对 Hook 的调用和组件联系起来的？</h3>
<p><a href="https://zh-hans.legacy.reactjs.org/docs/hooks-faq.html#under-the-hood"  target="_blank" rel="noopener" >Hooks FAQ – React</a></p>
<blockquote>
<p>React 保持对当前渲染中的组件的追踪。Hook 只会在 React 组件中被调用（或自定义 Hook —— 同样只会在 React 组件中被调用）。</p>
<p>每个组件内部都有一个「记忆单元格」列表。它们只不过是我们用来存储一些数据的 JavaScript 对象。当你用 useState() 调用一个 Hook 的时候，它会读取当前的单元格（或在首次渲染时将其初始化），然后把指针移动到下一个。这就是多个 useState() 调用会得到各自独立的本地 state 的原因。</p>
</blockquote>
<h3 id="为什么usestate是异步的">为什么useState是异步的</h3>
<p><code>useState</code> 的行为在<strong>某种程度</strong>上表现为异步，主要原因是为了优化 React 的渲染过程和性能。React 将多个状态更新合并到一起，并通过批量更新的方式避免不必要的重新渲染。具体原因如下：</p>
<ol>
<li><strong>批量更新机制</strong></li>
</ol>
<ul>
<li>React 在处理事件处理函数或生命周期方法（如 <code>useEffect</code>）中的 <code>setState</code> 调用时，通常不会立即应用状态更新，而是会将这些更新“批量”处理。在一次事件循环中，多个 <code>setState</code> 调用会被合并为一次更新。这种批量更新策略可以提高性能，避免在每次状态变化后都重新渲染组件。</li>
<li>示例：批量更新</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">MyComponent</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">count</span><span class="p">,</span> <span class="nx">setCount</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">handleClick</span> <span class="o">=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">setCount</span><span class="p">(</span><span class="nx">count</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span> <span class="c1">// 更新不会立即发生
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">setCount</span><span class="p">(</span><span class="nx">count</span> <span class="o">+</span> <span class="mi">2</span><span class="p">);</span> <span class="c1">// 也不会立即发生
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="o">&lt;</span><span class="nx">div</span><span class="o">&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="o">&lt;</span><span class="nx">p</span><span class="o">&gt;</span><span class="p">{</span><span class="nx">count</span><span class="p">}</span><span class="o">&lt;</span><span class="err">/p&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="o">&lt;</span><span class="nx">button</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{</span><span class="nx">handleClick</span><span class="p">}</span><span class="o">&gt;</span><span class="nx">Increment</span><span class="o">&lt;</span><span class="err">/button&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="o">&lt;</span><span class="err">/div&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>在这个例子中，虽然调用了两次 <code>setCount</code>，但 React 会将它们合并为一次更新。
2. 异步特性防止多次渲染</p>
<ul>
<li>
<p>如果 <code>useState</code> 是同步的，每次调用 <code>setState</code> 时都会导致组件重新渲染，这样会严重影响性能。想象在一次事件处理函数中调用多次 <code>setState</code>，如果每次都导致同步重新渲染，性能开销将非常高。</p>
</li>
<li>
<p>示例：同步更新的弊端</p>
</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">MyComponent</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">count</span><span class="p">,</span> <span class="nx">setCount</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">handleClick</span> <span class="o">=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">setCount</span><span class="p">(</span><span class="nx">count</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span> <span class="c1">// 如果是同步，组件将立即重新渲染
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">setCount</span><span class="p">(</span><span class="nx">count</span> <span class="o">+</span> <span class="mi">2</span><span class="p">);</span> <span class="c1">// 会导致多次无效渲染
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="o">&lt;</span><span class="nx">div</span><span class="o">&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="o">&lt;</span><span class="nx">p</span><span class="o">&gt;</span><span class="p">{</span><span class="nx">count</span><span class="p">}</span><span class="o">&lt;</span><span class="err">/p&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="o">&lt;</span><span class="nx">button</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{</span><span class="nx">handleClick</span><span class="p">}</span><span class="o">&gt;</span><span class="nx">Increment</span><span class="o">&lt;</span><span class="err">/button&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="o">&lt;</span><span class="err">/div&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>如果 <code>setCount</code> 是同步的，React 会在每次状态更新时都重新渲染组件，导致性能下降。为了避免这种情况，React 通过异步机制将多次更新合并到一次渲染中。</p>
<ol start="3">
<li>
<p>React Fiber 架构</p>
<ul>
<li>React 引入了新的 Fiber 架构，使其能够以分片的方式执行任务，将大任务切分成小的可中断的子任务。在此过程中，React 可能会推迟状态更新，直到它完成当前的渲染工作。这样可以确保用户界面始终保持流畅。</li>
<li>如果 <code>useState</code> 是同步的，React 就无法利用 Fiber 架构的优势来进行任务调度和批量更新。</li>
</ul>
</li>
<li>
<p>状态更新并不真正是异步的</p>
<ul>
<li>虽然 <code>useState</code> 的更新机制表现为异步，但从技术上讲，它并不是真正的异步操作，像 <code>Promise</code> 那样。实际上，它是在下一个渲染周期中同步更新的。React 将状态更新延迟到合适的时机，而不是立即应用。</li>
<li>示例：获取最新状态</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">MyComponent</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">count</span><span class="p">,</span> <span class="nx">setCount</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">handleClick</span> <span class="o">=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">setCount</span><span class="p">(</span><span class="nx">prevCount</span> <span class="p">=&gt;</span> <span class="nx">prevCount</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span> <span class="c1">// 使用回调函数获取最新的状态
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">setCount</span><span class="p">(</span><span class="nx">prevCount</span> <span class="p">=&gt;</span> <span class="nx">prevCount</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span> <span class="c1">// 这样可以确保多次更新正确执行
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="o">&lt;</span><span class="nx">div</span><span class="o">&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="o">&lt;</span><span class="nx">p</span><span class="o">&gt;</span><span class="p">{</span><span class="nx">count</span><span class="p">}</span><span class="o">&lt;</span><span class="err">/p&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="o">&lt;</span><span class="nx">button</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{</span><span class="nx">handleClick</span><span class="p">}</span><span class="o">&gt;</span><span class="nx">Increment</span><span class="o">&lt;</span><span class="err">/button&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="o">&lt;</span><span class="err">/div&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>通过回调函数 <code>prevCount</code>，我们可以确保每次更新都基于最新的状态值。这样即便 <code>setState</code> 是异步的，也能确保状态更新的正确性。</p>
</li>
</ol>
<h3 id="为什么hooks不能写在ifelse等语句里">为什么hooks不能写在if/else等语句里</h3>
<ol>
<li>
<p>Hooks 调用顺序的依赖</p>
<ul>
<li>React 使用一个内部的“链表”来跟踪组件中的每个 Hook 的调用。当 React 渲染组件时，Hooks 是按照定义的顺序被调用的。在后续渲染中，React 依赖这个顺序来确保同一个 Hook 对应的是之前的状态或副作用。</li>
<li>示例</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">MyComponent</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">count</span><span class="p">,</span> <span class="nx">setCount</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>  <span class="c1">// Hook 1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="p">[</span><span class="nx">name</span><span class="p">,</span> <span class="nx">setName</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">);</span>   <span class="c1">// Hook 2
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>                       <span class="c1">// Hook 3
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nb">document</span><span class="p">.</span><span class="nx">title</span> <span class="o">=</span> <span class="sb">`Count: </span><span class="si">${</span><span class="nx">count</span><span class="si">}</span><span class="sb">`</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">},</span> <span class="p">[</span><span class="nx">count</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">&lt;</span><span class="nt">div</span><span class="p">&gt;{</span><span class="nx">count</span><span class="p">}&lt;/</span><span class="nt">div</span><span class="p">&gt;;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>在每次渲染中，React 会按照调用顺序分配状态：</p>
<ol>
<li><code>useState(0)</code> 对应第一个状态 <code>count</code>。</li>
<li><code>useState('')</code> 对应第二个状态 <code>name</code>。</li>
<li><code>useEffect</code> 处理副作用。</li>
</ol>
<p>如果这个顺序保持一致，React 能够正确地追踪状态和副作用。</p>
</li>
<li>
<p>在条件语句中使用 Hooks的后果</p>
<ul>
<li>
<p>可能会导致 Hooks 的调用顺序在不同渲染中不一致</p>
</li>
<li>
<p>错误示例</p>
</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">MyComponent</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">count</span><span class="p">,</span> <span class="nx">setCount</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>  <span class="c1">// Hook 1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">count</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="p">[</span><span class="nx">name</span><span class="p">,</span> <span class="nx">setName</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">);</span>  <span class="c1">// Hook 2 （条件性调用）
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>                       <span class="c1">// Hook 3
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nb">document</span><span class="p">.</span><span class="nx">title</span> <span class="o">=</span> <span class="sb">`Count: </span><span class="si">${</span><span class="nx">count</span><span class="si">}</span><span class="sb">`</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">},</span> <span class="p">[</span><span class="nx">count</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="o">&lt;</span><span class="nx">div</span><span class="o">&gt;</span><span class="p">{</span><span class="nx">count</span><span class="p">}</span><span class="o">&lt;</span><span class="err">/div&gt;;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>如果 <code>count &gt; 0</code>，<code>name</code> 的 <code>useState</code> 会被调用。但如果 <code>count &lt;= 0</code>，该 <code>useState</code> 不会被调用。这导致：</p>
<ul>
<li>当 <code>count &gt; 0</code> 时，<code>useEffect</code> 是第三个 Hook。</li>
<li>当 <code>count &lt;= 0</code> 时，<code>useEffect</code> 是第二个 Hook。</li>
</ul>
<p>这样，React 无法知道哪个 Hook 应该关联到哪个状态，状态更新和副作用可能会错误地关联到不同的 Hook，导致不可预知的错误。</p>
</li>
<li>
<p>React 如何追踪 Hooks</p>
<ul>
<li>React 通过一个全局的“调用栈”来追踪每个组件中的 Hooks。当组件渲染时，React 会按顺序调用所有的 Hooks，并在内部记录这些调用。这样，每次渲染时，React 能够依赖这个顺序来关联状态。</li>
<li>如果在 <code>if/else</code> 中使用 Hooks，可能会导致某些 Hooks 在特定条件下被跳过，破坏这个顺序，从而导致错误的状态关联。</li>
</ul>
</li>
<li>
<p>报错提示</p>
<ul>
<li>
<blockquote>
<p>Rendered more hooks than during the previous render</p>
</blockquote>
</li>
<li>
<blockquote>
<p>Hooks can only be called inside the body of a function component.</p>
</blockquote>
</li>
</ul>
</li>
<li>
<p>参考</p>
<ul>
<li><a href="https://www.pipipi.net/28758.html"  target="_blank" rel="noopener" >为什么不能在if语句里面写hooks，HooKs链表写得清清楚楚🤣🤣🤣 - 码农之家</a></li>
<li><a href="https://zh-hans.react.dev/warnings/invalid-hook-call-warning"  target="_blank" rel="noopener" >Hook 规则 – React 中文文档</a></li>
<li><a href="https://overreacted.io/why-do-hooks-rely-on-call-order/"  target="_blank" rel="noopener" >Why Do React Hooks Rely on Call Order? — overreacted</a></li>
<li><a href="https://github.com/z-memo/interview/issues/138"  target="_blank" rel="noopener" >react hooks 的原理是什么 · Issue #138 · z-memo/interview</a></li>
</ul>
</li>
</ol>
<h3 id="hooks能实现类里面的所有生命周期吗">hooks能实现类里面的所有生命周期吗</h3>
<ul>
<li>&ldquo;Commit phase&quot;中的三个方法,Can work with DOM, run side effects, schedule updates：
<ol>
<li><code>componentDidMount</code> -&gt; the useEffect hook with the second argument of []</li>
<li><code>componentDidUpdate</code> -&gt; the useEffect hook with the second argument of [state]</li>
<li><code>componentWillUnmount</code> -&gt; <strong>return a function</strong> that runs on unmounting inside the useEffect function,例:</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl">    <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s2">&#34;Hello&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s2">&#34;Bye&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">};</span>
</span></span><span class="line"><span class="cl"><span class="p">},</span> <span class="p">[]);</span>
</span></span></code></pre></div></li>
<li>上面的类比只是类比，不能等同，原因：
<ol>
<li>实际原理不同</li>
<li>执行时机不同</li>
</ol>
</li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>React网页定制title</title>
      <link>https://euds.org/2024/add-specific-title-to-react-web-app/</link>
      <pubDate>Mon, 02 Sep 2024 00:20:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/add-specific-title-to-react-web-app/</guid>
      <description>变变变</description>
      <content:encoded><![CDATA[<h2 id="需求">需求</h2>
<p>一个使用react+react-router-dom的网页，希望不同的页面能有不同的title</p>
<h2 id="方法一--useeffect--documenttitle">方法一 : useEffect + document.title</h2>
<ul>
<li>主要思路: 监听url的变化，然后设置document.title,不同的写法差异主要在如何监听</li>
</ul>
<h3 id="写法一uselocation">写法一：useLocation()</h3>
<ul>
<li>简易的写法可以看<a href="https://stackoverflow.com/a/65709116"  target="_blank" rel="noopener" >Stack Overflow的这个回答</a></li>
<li>更进一步的写法可以看<a href="https://juejin.cn/post/7267409589079867450"  target="_blank" rel="noopener" >react-router-dom v6 路由实现动态修改document.title项目中需要在对应的路由界面 设置不同 - 掘金</a></li>
</ul>
<h3 id="写法二usematches">写法二：useMatches()</h3>
<ul>
<li>参考<a href="https://stackoverflow.com/a/78184012"  target="_blank" rel="noopener" >steinybot在Stack Overflow的这个回答</a></li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">matches</span> <span class="o">=</span> <span class="nx">useMatches</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">{</span> <span class="nx">handle</span><span class="p">,</span> <span class="nx">data</span> <span class="p">}</span> <span class="o">=</span> <span class="nx">matches</span><span class="p">[</span><span class="nx">matches</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">title</span> <span class="o">=</span> <span class="nx">handle</span> <span class="o">&amp;&amp;</span> <span class="nx">handle</span><span class="p">.</span><span class="nx">title</span><span class="p">(</span><span class="nx">data</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  
</span></span><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">title</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nb">document</span><span class="p">.</span><span class="nx">title</span> <span class="o">=</span> <span class="nx">title</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">},</span> <span class="p">[</span><span class="nx">title</span><span class="p">])</span>
</span></span></code></pre></div><ul>
<li><a href="https://reactrouter.com/en/main/hooks/use-matches"  target="_blank" rel="noopener" >useMatches v6.26.1 | React Router</a></li>
</ul>
<h2 id="方法二">方法二</h2>
<ul>
<li>使用<a href="https://www.npmjs.com/package/react-helmet-async"  target="_blank" rel="noopener" >react-helmet-async - npm</a></li>
<li>好处
<ol>
<li>代码修改小，只要在需要的地方加上就行</li>
<li>顺便能把seo也做了</li>
<li>还能支持Open Graph protocol等协议</li>
</ol>
</li>
<li>报错：<code>TypeError: Cannot read properties of undefined (reading 'add')</code>
<ul>
<li>问题其实出在我没加<code>&lt;HelmetProvider&gt;</code>,但这个报错太不友好了,有个建议优化报错信息的issue，<a href="https://github.com/staylor/react-helmet-async/issues/228"  target="_blank" rel="noopener" ><code>TypeError: Cannot read properties of undefined (reading 'add')</code> thrown when provider is missing · Issue #228 · staylor/react-helmet-async</a>，不过没被处理。</li>
</ul>
</li>
<li>参考
<ul>
<li><a href="https://www.freecodecamp.org/news/react-helmet-examples/"  target="_blank" rel="noopener" >How to Use React Helmet – With Example Use Case</a></li>
</ul>
</li>
</ul>
<h2 id="补充">补充</h2>
<h3 id="open-graph-protocol">Open Graph protocol</h3>
<p><a href="https://ogp.me/"  target="_blank" rel="noopener" >The Open Graph protocol</a></p>
<h3 id="twitter-cards">Twitter Cards</h3>
<p><a href="https://developer.x.com/en/docs/x-for-websites/cards/guides/getting-started"  target="_blank" rel="noopener" >Getting started with Cards | Docs | Twitter Developer Platform</a></p>
<h3 id="生成">生成</h3>
<p><a href="https://github.com/frostming/fxzhihu/tree/main"  target="_blank" rel="noopener" >frostming/fxzhihu: 为知乎生成可分享的卡片及 Instant View</a></p>
]]></content:encoded>
    </item>
    
    <item>
      <title>进一步学习useEffect</title>
      <link>https://euds.org/2024/learn_useeffect/</link>
      <pubDate>Sun, 04 Aug 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/learn_useeffect/</guid>
      <description>再次学习useEffect;再次学习useEffect;</description>
      <content:encoded><![CDATA[<h2 id="原因">原因</h2>
<p>最近还是发现自己在使用useEffect时有疑惑，深感有必要进一步去学习useEffect的使用。</p>
<hr>
<h2 id="疑惑一">疑惑一</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="kr">const</span> <span class="p">[</span><span class="nx">variable</span><span class="p">,</span><span class="nx">setVariable</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// 这样写有必要吗？
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">useEffect</span><span class="p">(</span><span class="nx">_</span> <span class="p">=&gt;{},[])</span>
</span></span></code></pre></div><ul>
<li>没必要，没意义</li>
</ul>
<hr>
<h2 id="疑惑二-依赖数组到底该写些啥">疑惑二: 依赖数组到底该写些啥</h2>
<h3 id="概念">概念:</h3>
<ul>
<li>依赖数组：用来告诉 React 这个 useEffect 何时应该运行。依赖数组中的每一项会被监控，当这些值发生变化时，副作用函数会重新运行。</li>
<li>依赖数组中的典型值
<ol>
<li>状态（state）：如果副作用依赖于某个 useState 的值，应该将其包含在依赖数组中。</li>
<li>props：当副作用依赖于某个 props，应该将其包含在依赖数组中。</li>
<li>函数或其他变量：如果副作用依赖于某个函数或者计算出来的变量，也应该包括在依赖数组中。</li>
</ol>
</li>
<li>依赖数组中尽量不要有<code>object</code>或<code>array</code>等引用变量</li>
</ul>
<h3 id="错误示范">错误示范:</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">ChatRoom</span><span class="p">({</span> <span class="nx">articleId</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">article</span><span class="p">,</span> <span class="nx">setArticle</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="kc">null</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="c1">// options 會在每次渲染時重新創建
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">options</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">serverUrl</span><span class="o">:</span> <span class="s1">&#39;https://localhost:1234&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="nx">articleId</span><span class="o">:</span> <span class="nx">articleId</span>
</span></span><span class="line"><span class="cl">  <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">data</span> <span class="o">=</span> <span class="nx">getArticle</span><span class="p">(</span><span class="nx">options</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="nx">setArticle</span><span class="p">(</span><span class="nx">data</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// options 每次渲染時值都不同，因此觸發 useEffect 執行
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="p">},</span> <span class="p">[</span><span class="nx">options</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="正确示范">正确示范:</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">ChatRoom</span><span class="p">({</span> <span class="nx">articleId</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">article</span><span class="p">,</span> <span class="nx">setArticle</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="kc">null</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">	  <span class="kr">const</span> <span class="nx">options</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">	    <span class="nx">serverUrl</span><span class="o">:</span> <span class="s1">&#39;https://localhost:1234&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">	    <span class="nx">articleId</span><span class="o">:</span> <span class="nx">articleId</span>
</span></span><span class="line"><span class="cl">	  <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">data</span> <span class="o">=</span> <span class="nx">getArticle</span><span class="p">(</span><span class="nx">options</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="nx">setArticle</span><span class="p">(</span><span class="nx">data</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="p">},</span> <span class="p">[</span><span class="nx">articleId</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="参考">参考</h3>
<ul>
<li><a href="https://betterprogramming.pub/stop-lying-to-react-about-missing-dependencies-10612e9aeeda"  target="_blank" rel="noopener" >Stop Lying to React About Missing Dependencies | by Jack Taylor | Better Programming</a></li>
<li><a href="https://juejin.cn/post/7327832105328574514"  target="_blank" rel="noopener" >&ldquo;React中useEffect的依赖数组：空数组与不写数组的区别&rdquo;- 掘金</a></li>
</ul>
<hr>
<h2 id="疑惑三-依赖数组为空和不传有区别吗">疑惑三: 依赖数组为空和不传有区别吗?</h2>
<h3 id="概念-1">概念</h3>
<ul>
<li>当依赖数组为空时（<code>[]</code>），useEffect中的回调函数<strong>只会在组件挂载和卸载时执行</strong>。这意味着它只会执行一次，类似于类组件中的<code>componentDidMount</code>和<code>componentWillUnmount</code>。</li>
<li>当<strong>不传入</strong>依赖数组时，useEffect中的回调函数会在每次组件渲染时都执行。这意味着它会在<strong>组件挂载、更新和卸载时</strong>都执行。</li>
</ul>
<h3 id="示例-依赖数组为空">示例: 依赖数组为空</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="c1">//10秒内连续点击按钮5次，控制台的输出结果是什么
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="p">[</span><span class="nx">count</span><span class="p">,</span> <span class="nx">setCount</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">setTimeout</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">count</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">},</span> <span class="mi">10</span> <span class="o">*</span> <span class="mi">1000</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="p">},[])</span> 
</span></span><span class="line"><span class="cl">  <span class="c1">//控制台只会输出一个0
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="c1">//因为count更新只是组件状态更新，而此时的useeffect只在组件加载和卸载时候执行只执行一次
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  
</span></span><span class="line"><span class="cl">   <span class="o">&lt;</span><span class="nx">button</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{()</span> <span class="p">=&gt;{</span><span class="nx">setCount</span><span class="p">(</span><span class="nx">count</span><span class="o">+</span><span class="mi">1</span><span class="p">)}}</span><span class="o">&gt;</span><span class="nx">点击count加1</span><span class="o">&lt;</span><span class="err">/button&gt;</span>
</span></span></code></pre></div><h3 id="示例-不传入依赖数组">示例: 不传入依赖数组</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="c1">//10秒内连续点击按钮5次，控制台的输出结果是什么
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="p">[</span><span class="nx">count</span><span class="p">,</span> <span class="nx">setCount</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">setTimeout</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">count</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">},</span> <span class="mi">10</span> <span class="o">*</span> <span class="mi">1000</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="p">})</span> 
</span></span><span class="line"><span class="cl">  <span class="c1">//控制台只会输出0，1，2，3，4，5
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="c1">//因为count更新，组件状态更新会重新渲染组件
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="c1">//而此时的useeffect在组件更新渲染的时候都会执行
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="c1">//所以会执行对应的点击次数
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="c1">//在控制台中打印对应的次数
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  
</span></span><span class="line"><span class="cl">   <span class="o">&lt;</span><span class="nx">button</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{()</span> <span class="p">=&gt;{</span><span class="nx">setCount</span><span class="p">(</span><span class="nx">count</span><span class="o">+</span><span class="mi">1</span><span class="p">)}}</span><span class="o">&gt;</span><span class="nx">点击count加1</span><span class="o">&lt;</span><span class="err">/button&gt;</span>
</span></span></code></pre></div><h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/7327832105328574514"  target="_blank" rel="noopener" >&ldquo;React中useEffect的依赖数组：空数组与不写数组的区别&rdquo;- 掘金</a></li>
</ul>
<hr>
<h2 id="疑惑四-依赖数组是怎么比较的">疑惑四: 依赖数组是怎么比较的</h2>
<h3 id="概念-2">概念</h3>
<ul>
<li>使用<code>Object.is</code>来进行比较,如果依赖数组中任意一值与前一次不用，就会重新执行</li>
<li><code>Object.is</code>和<code>===</code>的唯一区别在于它们处理带符号的 0 和 NaN 值的时候。=== 运算符（和 == 运算符）将数值 -0 和 +0 视为相等，但是会将 NaN 视为彼此不相等。</li>
<li><code>===</code> 不执行类型转换。它将验证被比较的变量是否具有相同的值和相同的类型。</li>
</ul>
<h3 id="实现usedeepcompareeffect">实现<code>useDeepCompareEffect</code></h3>
<ul>
<li>先用useRef取得前一次的值，然后再调用深比较函数对比前后的值</li>
<li>代码
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kr">import</span> <span class="p">{</span> <span class="nx">useRef</span> <span class="p">}</span> <span class="nx">from</span> <span class="s1">&#39;react&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">import</span> <span class="nx">type</span> <span class="p">{</span> <span class="nx">DependencyList</span><span class="p">,</span> <span class="nx">useEffect</span><span class="p">,</span> <span class="nx">useLayoutEffect</span> <span class="p">}</span> <span class="nx">from</span> <span class="s1">&#39;react&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">import</span> <span class="nx">isEqual</span> <span class="nx">from</span> <span class="s1">&#39;lodash/isEqual&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">type</span> <span class="nx">EffectHookType</span> <span class="o">=</span> <span class="k">typeof</span> <span class="nx">useEffect</span> <span class="o">|</span> <span class="k">typeof</span> <span class="nx">useLayoutEffect</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="nx">type</span> <span class="nx">CreateUpdateEffect</span> <span class="o">=</span> <span class="p">(</span><span class="nx">hook</span><span class="o">:</span> <span class="nx">EffectHookType</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">EffectHookType</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">depsEqual</span> <span class="o">=</span> <span class="p">(</span><span class="nx">aDeps</span><span class="o">:</span> <span class="nx">DependencyList</span> <span class="o">=</span> <span class="p">[],</span> <span class="nx">bDeps</span><span class="o">:</span> <span class="nx">DependencyList</span> <span class="o">=</span> <span class="p">[])</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">isEqual</span><span class="p">(</span><span class="nx">aDeps</span><span class="p">,</span> <span class="nx">bDeps</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">export</span> <span class="kr">const</span> <span class="nx">createDeepCompareEffect</span><span class="o">:</span> <span class="nx">CreateUpdateEffect</span> <span class="o">=</span> <span class="p">(</span><span class="nx">hook</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">(</span><span class="nx">effect</span><span class="p">,</span> <span class="nx">deps</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">ref</span> <span class="o">=</span> <span class="nx">useRef</span><span class="o">&lt;</span><span class="nx">DependencyList</span><span class="o">&gt;</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">signalRef</span> <span class="o">=</span> <span class="nx">useRef</span><span class="o">&lt;</span><span class="nx">number</span><span class="o">&gt;</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="c1">// 本地更新的依赖值与缓存的依赖深比较
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="k">if</span> <span class="p">(</span><span class="nx">deps</span> <span class="o">===</span> <span class="kc">undefined</span> <span class="o">||</span> <span class="o">!</span><span class="nx">depsEqual</span><span class="p">(</span><span class="nx">deps</span><span class="p">,</span> <span class="nx">ref</span><span class="p">.</span><span class="nx">current</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 将依赖保存一份
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">ref</span><span class="p">.</span><span class="nx">current</span> <span class="o">=</span> <span class="nx">deps</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 如果发现变更，则改变signalRef的值，是为了触发真正的useEffect
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">signalRef</span><span class="p">.</span><span class="nx">current</span> <span class="o">+=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="nx">hook</span><span class="p">(</span><span class="nx">effect</span><span class="p">,</span> <span class="p">[</span><span class="nx">signalRef</span><span class="p">.</span><span class="nx">current</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div></li>
</ul>
<hr>
<h2 id="报错useeffect-is-called-conditionally">报错：<code>useEffect</code> is called conditionally</h2>
<p>完整报错如下:</p>
<blockquote>
<p>React Hook &ldquo;useEffect&rdquo; is called conditionally. React Hooks must be called in the exact same order in every component render.  react-hooks/rules-of-hooks</p>
</blockquote>
<p>解决方法很简单，只需将useEffect调用移动到组件的顶层，并使用条件语句来决定是否执行其内部的逻辑即可。</p>
<hr>
<h2 id="useeffect-执行时机">useEffect 执行时机</h2>
<ol>
<li>當元件被加入時 (mount)，useEffect 會被第一次執行。</li>
<li>當每次元件重新渲染時，如果 dependencies 的值有改變，先將舊的 props 和 state 執行 cleanup function，再帶著新的 props 和 state 執行 setup function。</li>
<li>cleanup function 的程式碼，會在元件生命週期結束 (unmount) 時，執行最後一次。</li>
</ol>
<hr>
<h2 id="uselayouteffect">useLayoutEffect</h2>
<h3 id="概念-3">概念</h3>
<ul>
<li>执行时机: 在浏览器重绘 (repaints) 前執行,区别于<code>useEffect</code>,在浏览器完成布局与绘制之后，在一个延迟事件中被调用</li>
<li>可能會造成性能的問題。 因為在 useLayoutEffect 里的程序會阻礙瀏覽器重繪 (repaints) ，太頻繁使用可能會造成整個應用程式緩慢</li>
</ul>
<h3 id="示例">示例</h3>
<ul>
<li>代码
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kr">import</span> <span class="p">{</span> <span class="nx">useEffect</span><span class="p">,</span> <span class="nx">useLayoutEffect</span><span class="p">,</span> <span class="nx">useState</span> <span class="p">}</span> <span class="nx">from</span> <span class="s2">&#34;react&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">export</span> <span class="k">default</span> <span class="kd">function</span> <span class="nx">App</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">count</span><span class="p">,</span> <span class="nx">setCount</span><span class="p">]</span> <span class="o">=</span> <span class="nx">useState</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">count</span> <span class="o">===</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="kr">const</span> <span class="nx">randomNum</span> <span class="o">=</span> <span class="mi">1</span> <span class="o">+</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">random</span><span class="p">()</span> <span class="o">*</span> <span class="mi">1000</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">      <span class="nx">setCount</span><span class="p">(</span><span class="nx">randomNum</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">},</span> <span class="p">[</span><span class="nx">count</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="o">&lt;</span><span class="nx">div</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{()</span> <span class="p">=&gt;</span> <span class="nx">setCount</span><span class="p">(</span><span class="mi">0</span><span class="p">)}</span><span class="o">&gt;</span><span class="p">{</span><span class="nx">count</span><span class="p">}</span><span class="o">&lt;</span><span class="err">/div&gt;;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
<li>解释
<ul>
<li>原因是，當你每次點擊 div，此時 count 會被更新為 0，畫面會重新渲染變為 0，同時，因為 count 被更新，也會觸發 useEffect 執行。所以在重繪完成之後， useEffect 執行並把 count 更新為另一串隨機數字，畫面也會再渲染一次，因為兩次渲染時間很快，所以造成閃爍。</li>
<li>假設我們把上方程式碼的 useEffect 換成 useLayoutEffect，當你每次點擊 div，此時 count 會被更新為 0，但這時，畫面不會被重新渲染變為 0，而是先等待 useLayoutEffect 內的程式碼執行完畢之後，state 已經更新為新的隨機數字，這時畫面才進行重繪。</li>
</ul>
</li>
</ul>
<h3 id="使用场景">使用场景</h3>
<ul>
<li>
<p>設計一個工具提示元件 (tooltip)，它會依照不同條件出現在某元素的上方、下方或旁邊，這種設計條件代表說，我們會需要知道此元素準確的高度位置，才能判斷要將 tooltip 顯示在哪裡。</p>
</li>
<li>
<p>此时React的渲染步驟可以拆分為下</p>
<ol>
<li>在任何地方渲染 Tooltip (即使位置不正確)</li>
<li>測量元素的高度，並決定放置 Tooltip 的位置</li>
<li>重新渲染畫面，這時 Tooltip 的位置才會是正確的</li>
<li>如果是使用 useEffect 的話，Tooltip 的位置，可能是從 0 變到 10 的位置，這會造成畫面閃爍、使用者體驗不佳，如果是使用 useLayoutEffect，React 則會在重繪前，就重新計算正確的位置，才渲染畫面。</li>
</ol>
</li>
</ul>
<hr>
<h2 id="参考-2">参考</h2>
<ul>
<li><a href="https://overreacted.io/a-complete-guide-to-useeffect/"  target="_blank" rel="noopener" >A Complete Guide to useEffect — overreacted</a></li>
<li><a href="https://devpress.csdn.net/react/62f64ea5c6770329307fc5f1.html"  target="_blank" rel="noopener" >Source code interpretation of React useEffect_javascript_rAc-React</a></li>
<li><a href="https://www.explainthis.io/zh-hant/swe/use-effect-vs-use-layout-effect"  target="_blank" rel="noopener" >請解釋 useEffect？與 useLayoutEffect 的區別？｜ExplainThis</a></li>
<li><a href="https://juejin.cn/post/7240600121208504375"  target="_blank" rel="noopener" >源码级层面角度剖析React中useEffect - 掘金</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>React中的导入导出</title>
      <link>https://euds.org/2024/import-and-export-in-react/</link>
      <pubDate>Sun, 28 Apr 2024 00:20:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/import-and-export-in-react/</guid>
      <description>The requested module does not provide an export named</description>
      <content:encoded><![CDATA[<p><strong>之前对React中的import和export处在一知半解的情况，计划通过此篇来彻底弄清楚。</strong></p>
<h2 id="案例">案例</h2>
<p>在<code>src/components/Section</code>这个文件夹中有两个文件</p>
<pre tabindex="0"><code>ContextSection.jsx  
FileSection.jsx  
</code></pre><p>其中每个文件都类似于</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">export</span> <span class="k">default</span> <span class="kd">function</span> <span class="nx">ContextSection</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>我希望写一个<code>index.js</code>来统一export，一开始我的写法是</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">export</span> <span class="o">*</span> <span class="nx">from</span> <span class="s1">&#39;./ContextSection&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">export</span> <span class="o">*</span> <span class="nx">from</span> <span class="s1">&#39;./FileSection&#39;</span><span class="p">;</span>
</span></span></code></pre></div><p>我在<code>'/src/components/Session/index.js'</code>是这样import的</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">import</span> <span class="p">{</span> <span class="nx">ContextSession</span><span class="p">,</span> <span class="nx">FileSession</span> <span class="p">}</span> <span class="nx">from</span> <span class="s2">&#34;/src/components/Session&#34;</span><span class="p">;</span>
</span></span></code></pre></div><p>报错是：
Uncaught SyntaxError: The requested module &lsquo;/src/components/Session/index.js&rsquo; does not provide an export named &lsquo;ContextSession&rsquo;</p>
<p>我直接去谷歌报错信息,但查找到的内容都有点牛头不对马嘴。最后是靠好好地看了遍<a href="https://react.dev/learn/importing-and-exporting-components"  target="_blank" rel="noopener" >Importing and Exporting Components – React</a>才猛然意识到自己哪里错了。</p>
<table>
<thead>
<tr>
<th>Syntax</th>
<th>Export statement</th>
<th>Import statement</th>
</tr>
</thead>
<tbody>
<tr>
<td>Default</td>
<td><code>export default function Button() {}</code></td>
<td><code>import Button from './Button.js';</code></td>
</tr>
<tr>
<td>Named</td>
<td><code>export function Button() {}</code></td>
<td><code>import { Button } from './Button.js';</code></td>
</tr>
</tbody>
</table>
<p>最后我的解决方法是，修改<code>index.js</code>为</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">export</span> <span class="p">{</span> <span class="k">default</span> <span class="nx">as</span> <span class="nx">ContextSection</span> <span class="p">}</span> <span class="nx">from</span> <span class="s1">&#39;./ContextSection&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">export</span> <span class="p">{</span> <span class="k">default</span> <span class="nx">as</span> <span class="nx">FileSection</span> <span class="p">}</span> <span class="nx">from</span> <span class="s1">&#39;./FileSection&#39;</span><span class="p">;</span>
</span></span></code></pre></div><h2 id="进一步">进一步</h2>
<p><code>export { default as FileSection } from './FileSection';</code> 和<code>export FileSection  from './FileSection';</code>的区别在哪呢？以下是ChatGPT的回答：</p>
<p>这两种写法在导出默认导出时有所不同：</p>
<ol>
<li>
<p><code>export { default as FileSection } from './FileSection';</code></p>
<p>这种写法使用了命名导出（named export）的语法，并且指定了导出的名称为 <code>FileSection</code>。它将 <code>./FileSection</code> 中的默认导出（使用 <code>export default</code> 导出的内容）导出为 <code>FileSection</code>。在其他文件中引用时，需要使用相同的名称来导入，例如 <code>import { FileSection } from './FileSection';</code>。</p>
</li>
<li>
<p><code>export FileSection from './FileSection';</code></p>
<p>这种写法是 ES2021 的新语法，称为<strong>export from</strong>语法，它直接导出了 <code>./FileSection</code> 中的默认导出，而无需指定名称。在其他文件中引用时，可以使用任何名称来导入，例如 <code>import MyFileSection from './FileSection';</code>。在这种情况下，导入的名称不需要与导出的名称相同。</p>
</li>
</ol>
<p>综上所述，第一种写法强制使用指定的导出名称，而第二种写法更加灵活，允许导入时使用任意名称。</p>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://react.dev/learn/importing-and-exporting-components"  target="_blank" rel="noopener" >Importing and Exporting Components – React</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>React知识点整理</title>
      <link>https://euds.org/2024/react_points/</link>
      <pubDate>Fri, 08 Mar 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/react_points/</guid>
      <description>自己学习过程中整理的关于React的知识点</description>
      <content:encoded><![CDATA[<p><strong>本文记录了我学习过程中整理的关于React的知识点,以摘抄为主，绝大部分非原创。未能全部都标明出处，在此致歉</strong></p>
<h2 id="jsx">JSX</h2>
<ul>
<li>一种JavaScript的语法扩展（extension），也在很多地方称之为JavaScript XML，因为看起就是一段XML语法；</li>
<li>为什么React选择使用jsx？
<ul>
<li>React认为渲染逻辑本质上与其他UI逻辑存在内在耦合,他们之间是密不可分，所以React没有将标记分离到不同的文件中，而是将它们组合到了一起，这个地方就是组件（Component）</li>
</ul>
</li>
<li>本质
<ul>
<li>React.createElement(component, props, &hellip;children) 函数的语法糖</li>
<li>所有的jsx最终都会被转换成React.createElement的函数调用</li>
</ul>
</li>
<li>参考: <a href="https://www.cnblogs.com/yaopengfei/p/17299996.html"  target="_blank" rel="noopener" >第二节：jsx语法深度剖析和jsx本质的探究 - Yaopengfei - 博客园</a></li>
</ul>
<hr>
<h2 id="生命周期">生命周期</h2>
<h3 id="there-phases">there phases</h3>
<ol>
<li>mounting: initial render</li>
<li>updating: is triggered when the props are updated or when the state is updated</li>
<li>unmounting: when the component is removed from the DOM</li>
</ol>
<h3 id="methods">methods</h3>
<ul>
<li>Each phase has specific methods responsible for a particular stage in a component&rsquo;s lifecycle. These methods <strong>are technically particular to class-based components</strong> and not intended for functional components.</li>
<li><a href="https://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/"  target="_blank" rel="noopener" >React lifecycle methods diagram</a></li>
<li><code>shouldComponentUpdate</code> -&gt; <code>useMemo</code>、 <code>memo</code></li>
<li>&ldquo;Commit phase&quot;中的三个方法,Can work with DOM, run side effects, schedule updates：
<ol>
<li><code>componentDidMount</code> -&gt; the useEffect hook with the second argument of []</li>
<li><code>componentDidUpdate</code> -&gt; the useEffect hook with the second argument of [state]</li>
<li><code>componentWillUnmount</code> -&gt; <strong>return a function</strong> that runs on unmounting inside the useEffect function,例:</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl">    <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s2">&#34;Hello&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s2">&#34;Bye&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">};</span>
</span></span><span class="line"><span class="cl"><span class="p">},</span> <span class="p">[]);</span>
</span></span></code></pre></div></li>
<li>上面的类比只是类比，不能等同，原因：
<ol>
<li>实际原理不同</li>
<li>执行时机不同</li>
</ol>
</li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/7132786097922736164"  target="_blank" rel="noopener" >useEffect(fn, []) 不等于 componentDidMount() - 掘金</a></li>
<li><a href="https://retool.com/blog/the-react-lifecycle-methods-and-hooks-explained"  target="_blank" rel="noopener" >The React lifecycle: methods and hooks explained</a></li>
<li><a href="https://juejin.cn/post/6914112105964634119"  target="_blank" rel="noopener" >深入详解React生命周期 getSnapshotBe - 掘金</a></li>
</ul>
<hr>
<h2 id="react-组件的实现">React 组件的实现</h2>
<h3 id="函数组件">函数组件</h3>
<ul>
<li>
<p>概念</p>
<ul>
<li>函数组件是一个普通的 JavaScript 函数，它接受 props 作为参数并返回 React 元素树（JSX）。</li>
<li>React 会调用该函数并将返回的 JSX 虚拟 DOM 转换为真实的 DOM。</li>
<li>现代 React 推荐使用函数组件，因为它更简洁，且能够配合 Hook 使用。</li>
</ul>
</li>
<li>
<p>组件的生命周期</p>
<ul>
<li>虽然函数组件没有显式的生命周期方法，但通过 React Hook 可以为它们注入类似生命周期的功能。</li>
<li>类似 <code>useEffect</code> 可以让函数组件在 <code>componentDidMount</code>、<code>componentDidUpdate</code> 或 <code>componentWillUnmount</code> 这类阶段执行代码。</li>
</ul>
</li>
</ul>
<h3 id="类组件">类组件</h3>
<ul>
<li>概念
<ul>
<li>类组件是基于 <code>ES6 class</code> 的方式定义的，它继承自 <code>React.Component</code>。</li>
</ul>
</li>
<li>组件的生命周期
<ul>
<li>类组件有一系列内置的生命周期方法，如 <code>componentDidMount</code>、<code>componentDidUpdate</code>、<code>componentWillUnmount</code> 等，用于控制组件的生命周期。</li>
</ul>
</li>
</ul>
<h3 id="virtual-dom虚拟-dom和-reconciliation调和">Virtual DOM（虚拟 DOM）和 Reconciliation（调和）</h3>
<ul>
<li>React 中的每个组件返回的 JSX 会被转换为虚拟 DOM。虚拟 DOM 是实际 DOM 的轻量化表示，它的变化不会立即反映在真实的浏览器 DOM 上。</li>
<li>当组件的状态或 props 改变时，React 会创建新的虚拟 DOM，并通过 Diff 算法与旧的虚拟 DOM 进行对比，找出差异，然后仅更新需要更新的部分，这个过程称为 Reconciliation（调和）。</li>
</ul>
<hr>
<h2 id="虚拟dom-virtual-document-object-model">虚拟DOM （Virtual Document Object Model）</h2>
<p>在React中，当状态（state）发生变化时，React并不直接操作真实的DOM来更新页面，而是先在内存中构建一个虚拟DOM树，然后通过比较虚拟DOM树和之前渲染的虚拟DOM树之间的差异，最终计算出最小的DOM操作，并将这些操作批量应用到真实的DOM上。</p>
<h3 id="虚拟dom节点可能包含的详细信息">虚拟DOM节点可能包含的详细信息</h3>
<ol>
<li><strong>type</strong>：节点类型可以是元素节点、文本节点或者组件节点。</li>
<li><strong>props</strong>：节点可能包含一些属性，这些属性描述了节点的特征，比如元素节点的class、id、style等属性，以及事件处理函数等。chidren 是 props 中的一个属性，它存储了当前组件的孩子节点，可以是数组（多个孩子节点）或对象（只有一个孩子节点）</li>
<li><strong>key</strong>：用于在DOM的重渲染过程中标识节点的唯一性，有助于React在进行差异比较时准确找到对应的节点。</li>
<li><strong>ref</strong>：用于获取节点的引用，通常用于在组件中操作DOM节点。</li>
<li><strong>owner</strong>: 所属的Component</li>
<li>其他</li>
</ol>
<h3 id="diff算法">diff算法</h3>
<ul>
<li>比较当前的虚拟DOM树和状态变更将要重新渲染时生成的虚拟DOM树的算法。</li>
<li>关键：
<ol>
<li>深度优先</li>
<li>只对同一级别的元素进行比较</li>
</ol>
</li>
<li>三种diff
<ol>
<li>tree diff : 只是简单进行了删除和创建操作</li>
<li>component diff：
<ul>
<li>使用的是<code>===</code>严格相等。也就是&quot;引用相等性&rdquo;</li>
<li>不同类型 -&gt; 直接替换整个组件下的所有子节点，即销毁原组件，创建新组件。</li>
<li>同一类型 -&gt; 继续判断</li>
</ul>
</li>
<li>element diff: 针对同一层级的所有节点（包括元素节点和组件节点）的 diff 算法
<ul>
<li>三种操作：
<ol>
<li>insert_markup</li>
<li>move_existing</li>
<li>remove_node:</li>
</ol>
</li>
<li>涉及到列表元素顺序的动态变更时，不要用遍历的 index 作为节点的 key 属性值</li>
</ul>
</li>
</ol>
</li>
</ul>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://xie.infoq.cn/article/65e938d933cc751fcc008942d"  target="_blank" rel="noopener" >谈谈虚拟DOM，Diff算法与Key机制_React_beifeng1996_InfoQ写作社区</a></li>
</ul>
<hr>
<h2 id="组件间通信方式">组件间通信方式</h2>
<h3 id="通过-props-传递数据父传子组件通信">通过 Props 传递数据（父传子组件通信）</h3>
<ul>
<li><strong>适用场景</strong>：最常见的方式，适用于父组件向子组件传递数据。</li>
<li><strong>原理</strong>：父组件通过 <code>props</code> 将数据传递给子组件，子组件通过 <code>props</code> 接收并使用这些数据。</li>
</ul>
<h3 id="使用回调函数子传父组件通信">使用回调函数（子传父组件通信）</h3>
<ul>
<li><strong>适用场景</strong>：当子组件需要向父组件传递数据时。</li>
<li><strong>原理</strong>：父组件将一个回调函数作为 <code>props</code> 传递给子组件，子组件调用该函数，将数据传递回父组件。</li>
<li><strong>示例</strong>:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"> <span class="kd">function</span> <span class="nx">Parent</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">   <span class="kr">const</span> <span class="nx">handleData</span> <span class="o">=</span> <span class="p">(</span><span class="nx">data</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">     <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">data</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">   <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">   <span class="k">return</span> <span class="p">&lt;</span><span class="nt">Child</span> <span class="na">sendData</span><span class="o">=</span><span class="p">{</span><span class="nx">handleData</span><span class="p">}</span> <span class="p">/&gt;;</span>
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"> <span class="kd">function</span> <span class="nx">Child</span><span class="p">({</span> <span class="nx">sendData</span> <span class="p">})</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">   <span class="k">return</span> <span class="p">&lt;</span><span class="nt">button</span> <span class="na">onClick</span><span class="o">=</span><span class="p">{()</span> <span class="p">=&gt;</span> <span class="nx">sendData</span><span class="p">(</span><span class="s2">&#34;Hello from child!&#34;</span><span class="p">)}&gt;</span><span class="nx">Send</span> <span class="nx">Data</span><span class="p">&lt;/</span><span class="nt">button</span><span class="p">&gt;;</span>
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
<h3 id="通过-context-api">通过 Context API</h3>
<ul>
<li><strong>适用场景</strong>：适合深层次的组件树中需要共享的全局状态，避免层层传递 <code>props</code>（例如：主题、语言、用户信息等）。</li>
<li><strong>原理</strong>：创建一个 <code>Context</code>，并使用 <code>Provider</code> 组件来提供状态，任何深层的组件都可以通过 <code>Consumer</code> 或 <code>useContext</code> 钩子来访问。</li>
<li><strong>示例</strong>:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">MyContext</span> <span class="o">=</span> <span class="nx">React</span><span class="p">.</span><span class="nx">createContext</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">Parent</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">value</span> <span class="o">=</span> <span class="s2">&#34;Hello from context!&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="p">&lt;</span><span class="nt">MyContext.Provider</span> <span class="na">value</span><span class="o">=</span><span class="p">{</span><span class="nx">value</span><span class="p">}&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="p">&lt;</span><span class="nt">Child</span> <span class="p">/&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="p">&lt;/</span><span class="nt">MyContext.Provider</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">Child</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">contextValue</span> <span class="o">=</span> <span class="nx">React</span><span class="p">.</span><span class="nx">useContext</span><span class="p">(</span><span class="nx">MyContext</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">&lt;</span><span class="nt">div</span><span class="p">&gt;{</span><span class="nx">contextValue</span><span class="p">}&lt;/</span><span class="nt">div</span><span class="p">&gt;;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
<h3 id="通过-redux-或其他状态管理库">通过 Redux 或其他状态管理库</h3>
<ul>
<li><strong>适用场景</strong>：在需要管理全局状态或复杂状态时，Redux 是一个强大的工具。</li>
<li><strong>原理</strong>：全局状态存储在 Redux 的 <code>store</code> 中，任何组件都可以通过 <code>connect</code> 或 <code>useSelector</code> 访问状态，通过 <code>dispatch</code> 发送 action 来修改状态。</li>
<li><strong>示例</strong>:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"><span class="kr">import</span> <span class="p">{</span> <span class="nx">useSelector</span><span class="p">,</span> <span class="nx">useDispatch</span> <span class="p">}</span> <span class="nx">from</span> <span class="s1">&#39;react-redux&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">MyComponent</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">count</span> <span class="o">=</span> <span class="nx">useSelector</span><span class="p">(</span><span class="nx">state</span> <span class="p">=&gt;</span> <span class="nx">state</span><span class="p">.</span><span class="nx">counter</span><span class="p">.</span><span class="nx">value</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">dispatch</span> <span class="o">=</span> <span class="nx">useDispatch</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="p">&lt;</span><span class="nt">div</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="p">&lt;</span><span class="nt">span</span><span class="p">&gt;{</span><span class="nx">count</span><span class="p">}&lt;/</span><span class="nt">span</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="p">&lt;</span><span class="nt">button</span> <span class="na">onClick</span><span class="o">=</span><span class="p">{()</span> <span class="p">=&gt;</span> <span class="nx">dispatch</span><span class="p">({</span> <span class="nx">type</span><span class="o">:</span> <span class="s1">&#39;INCREMENT&#39;</span> <span class="p">})}&gt;</span><span class="nx">Increment</span><span class="p">&lt;/</span><span class="nt">button</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="p">&lt;/</span><span class="nt">div</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
<h3 id="使用全局事件eventemitter-或-custom-events">使用全局事件（EventEmitter 或 Custom Events）</h3>
<ul>
<li><strong>适用场景</strong>：组件之间没有明显的层级关系，适合不频繁的数据交换。</li>
<li><strong>原理</strong>：可以使用事件触发机制，例如 <code>EventEmitter</code>，让一个组件监听事件，另一个组件触发事件。</li>
<li><strong>示例</strong>:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"><span class="kr">import</span> <span class="p">{</span> <span class="nx">EventEmitter</span> <span class="p">}</span> <span class="nx">from</span> <span class="s1">&#39;events&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">eventEmitter</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">EventEmitter</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// In one component (sender)
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">eventEmitter</span><span class="p">.</span><span class="nx">emit</span><span class="p">(</span><span class="s1">&#39;message&#39;</span><span class="p">,</span> <span class="s1">&#39;Hello World&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// In another component (receiver)
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">eventEmitter</span><span class="p">.</span><span class="nx">on</span><span class="p">(</span><span class="s1">&#39;message&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">data</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">data</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span>
</span></span></code></pre></div></li>
</ul>
<h3 id="url-params--query-strings通过路由传递">URL Params / Query Strings（通过路由传递）</h3>
<ul>
<li><strong>适用场景</strong>：组件之间通过 URL 参数传递信息。</li>
<li><strong>原理</strong>：使用 React Router 来通过 URL 将信息从一个页面传递到另一个页面。可以通过 <code>useParams</code> 或 <code>useLocation</code> 钩子来读取。</li>
<li><strong>示例</strong>:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"><span class="kr">import</span> <span class="p">{</span> <span class="nx">useParams</span> <span class="p">}</span> <span class="nx">from</span> <span class="s1">&#39;react-router-dom&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">UserProfile</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">{</span> <span class="nx">userId</span> <span class="p">}</span> <span class="o">=</span> <span class="nx">useParams</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">&lt;</span><span class="nt">div</span><span class="p">&gt;</span><span class="nx">User</span> <span class="nx">ID</span><span class="o">:</span> <span class="p">{</span><span class="nx">userId</span><span class="p">}&lt;/</span><span class="nt">div</span><span class="p">&gt;;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
<h3 id="使用-web-storagelocalstoragesessionstorage">使用 Web Storage（LocalStorage/SessionStorage）</h3>
<ul>
<li><strong>适用场景</strong>：需要在页面刷新或不同组件间共享数据。</li>
<li><strong>原理</strong>：将数据存储在浏览器的 <code>localStorage</code> 或 <code>sessionStorage</code> 中，组件可以通过它们来读取和修改数据。</li>
<li><strong>示例</strong>:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">setData</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">localStorage</span><span class="p">.</span><span class="nx">setItem</span><span class="p">(</span><span class="s1">&#39;name&#39;</span><span class="p">,</span> <span class="s1">&#39;John&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">getData</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">name</span> <span class="o">=</span> <span class="nx">localStorage</span><span class="p">.</span><span class="nx">getItem</span><span class="p">(</span><span class="s1">&#39;name&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">&lt;</span><span class="nt">div</span><span class="p">&gt;{</span><span class="nx">name</span><span class="p">}&lt;/</span><span class="nt">div</span><span class="p">&gt;;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
<hr>
<h2 id="react-router">React Router</h2>
<ul>
<li>state
<ul>
<li>An object to store on location state. This is useful for state that doesn’t need to be in the URL but is associated with a route transition. Think of it like “post” data on a server.</li>
<li>可以用来实现: 用户被踢出后再登陆注册能返回被踢出时的页面</li>
</ul>
</li>
<li>replace的作用:
<blockquote>
<p>An example is when the user clicks a “purchase” button but needs to log in first, after they log in, you can replace the login screen with the checkout screen you wanted them to be at. Then when they click the back button they won’t see the login page again.</p>
<p>navigate(&quot;/some/where&quot;, { replace: true })</p>
</blockquote>
</li>
</ul>
<h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://reach.tech/router/api/navigate"  target="_blank" rel="noopener" >Reach Router - navigate(to, { state={}, replace=false })</a></li>
</ul>
<hr>
<h2 id="react-fiber">React Fiber</h2>
<h3 id="概念">概念</h3>
<ul>
<li>React 通过 Fiber 树对任务进行切片（time-slicing），分成多个小块任务，允许在渲染过程中将控制权交还给主线程，以避免阻塞浏览器的渲染和响应用户交互。</li>
</ul>
<h3 id="关键点">关键点：</h3>
<ol>
<li>
<p><strong>任务的可中断性</strong>
在传统的 React 16 之前的版本，渲染过程是同步的，一旦开始渲染，就会一直执行到整个更新完成。如果渲染复杂，用户交互（如点击、滚动）会被阻塞。而 Fiber 通过将渲染任务分解成多个小任务，可以在渲染的过程中暂停、打断和恢复，从而为高优先级任务（如用户输入）让路。</p>
</li>
<li>
<p><strong>优先级机制</strong>
React Fiber 引入了优先级调度，不同的更新任务可以根据优先级被安排执行。高优先级的任务会优先被调度执行，而低优先级任务会被延迟处理。这种机制大大提升了应用的响应性，避免了长时间的卡顿。</p>
</li>
<li>
<p><strong>双缓冲 Fiber 树</strong>
Fiber 使用两棵树来管理渲染过程：</p>
<ul>
<li><strong>Current Fiber Tree</strong>：当前已渲染的树。</li>
<li><strong>Work In Progress Fiber Tree</strong>：正在构建的树。</li>
</ul>
<p>React 在更新过程中会基于当前的 Fiber 树构建一个新的 Fiber 树，这个过程是渐进的，不会阻塞主线程。</p>
</li>
<li>
<p><strong>时间切片（Time Slicing）</strong>
通过时间切片，React Fiber 能够将渲染任务分割成多个小片段，在每个帧之间执行这些片段。每当有更高优先级的任务需要处理时，React Fiber 会暂停当前的渲染任务，执行完高优先级任务后再恢复。</p>
</li>
<li>
<p><strong>可恢复的工作单元</strong>
每个 Fiber 都是一个工作单元，它包含了组件的状态、props 和上下文信息。Fiber 架构允许在工作单元之间中断、恢复以及重新调度渲染。</p>
</li>
<li>
<p><strong>并发模式（Concurrent Mode）</strong>
React Fiber 是并发模式的基础，它能够在未来支持并发渲染，让 React 在后台渲染不重要的内容，并优先响应重要的更新。这一特性会进一步提升用户体验，尤其是在交互密集的应用中。</p>
</li>
</ol>
<h3 id="参考-3">参考</h3>
<ul>
<li><a href="https://www.velotio.com/engineering-blog/react-fiber-algorithm"  target="_blank" rel="noopener" >An Introduction to React Fiber - The Algorithm Behind React</a></li>
<li><a href="https://juejin.cn/post/7114132411499151373"  target="_blank" rel="noopener" >通俗易懂地理解React Fiber - 掘金</a></li>
</ul>
<hr>
<h2 id="错误捕获">错误捕获</h2>
<p>wip</p>
<h3 id="参考-4">参考</h3>
<ul>
<li><a href="https://zh-hans.react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary"  target="_blank" rel="noopener" >使用错误边界捕获渲染错误  – React 中文文档</a></li>
<li><a href="https://github.com/bvaughn/react-error-boundary"  target="_blank" rel="noopener" >bvaughn/react-error-boundary: Simple reusable React error boundary component</a></li>
</ul>
<hr>
<h2 id="优先级管理">优先级管理</h2>
<p>wip</p>
<h3 id="参考-5">参考</h3>
<ul>
<li><a href="https://7km.top/main/priority"  target="_blank" rel="noopener" >优先级管理</a></li>
</ul>
<hr>
<h2 id="参考-6">参考</h2>
<ul>
<li><a href="https://github.com/sudheerj/reactjs-interview-questions"  target="_blank" rel="noopener" >sudheerj/reactjs-interview-questions: List of top 500 ReactJS Interview Questions &amp; Answers&hellip;.Coding exercise questions are coming soon!!</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>记一次react报错排查</title>
      <link>https://euds.org/2024/a-react-debug-experience/</link>
      <pubDate>Thu, 07 Mar 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/a-react-debug-experience/</guid>
      <description>Failed to execute &amp;lsquo;removeChild&amp;rsquo; on &amp;lsquo;Node&amp;rsquo;</description>
      <content:encoded><![CDATA[<h2 id="场景">场景</h2>
<p>在<a href="https://github.com/EuDs63/postkid"  target="_blank" rel="noopener" >EuDs63/postkid: A lightweight tool offering key functionalities inspired by Postman.</a>,当我发送一次请求之后，再次发送时报错：</p>
<blockquote>
<p>NotFoundError: Failed to execute &lsquo;removeChild&rsquo; on &lsquo;Node&rsquo;: The node to be removed is not a child of this node.</p>
</blockquote>
<h2 id="排查">排查</h2>
<p>因为上一个版本并没有这个问题，于是我比较了这几次的commit记录，发现问题很可能出现在Prism的高亮，相关代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-typescript" data-lang="typescript"><span class="line"><span class="cl">  <span class="nx">useEffect</span><span class="p">(()</span> <span class="o">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">response</span> <span class="o">&amp;&amp;</span> <span class="nx">response</span><span class="p">.</span><span class="nx">data</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">Prism</span><span class="p">.</span><span class="nx">highlightAll</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">},</span> <span class="p">[</span><span class="nx">response</span><span class="p">]);</span>
</span></span></code></pre></div><p>当我将<code>Prism.highlightAll();</code>注释掉后，程序就不再报错了，但这显然不是我所希望的。几经查找后，发现了<a href="https://juejin.cn/post/6938321875298680845"  target="_blank" rel="noopener" >Failed to execute &lsquo;removeChild&rsquo; on &lsquo;Node&rsquo; - 掘金</a>解决了我的问题，在<code>pre code</code>外加一层<code>&lt;div&gt;</code>就解决了。</p>
<p>该篇文章也给出了一定的解释:</p>
<blockquote>
<p>经过分析发现是使用组件的问题，考虑DOM-DIff算法是比对不同的React节点，而该组件的渲染直接是第三方插件的代码，在componentDidMount阶段才进行DOM节点的挂载，在此之前是没有node节点的，故需要增加一个可识别的node节点。</p>
</blockquote>
<p>但对来说比较简略，我希望能彻底搞懂相关的概念，以下是我的笔记。</p>
<h2 id="lifecycle">Lifecycle</h2>
<h3 id="there-phases">there phases</h3>
<ol>
<li>mounting: initial render</li>
<li>updating: is triggered when the props are updated or when the state is updated</li>
<li>unmounting: when the component is removed from the DOM</li>
</ol>
<h3 id="methods">methods</h3>
<ul>
<li>Each phase has specific methods responsible for a particular stage in a component&rsquo;s lifecycle. These methods <strong>are technically particular to class-based components</strong> and not intended for functional components.</li>
<li><a href="https://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/"  target="_blank" rel="noopener" >React lifecycle methods diagram</a></li>
<li><code>shouldComponentUpdate</code> -&gt; <code>useMemo</code>、 <code>memo</code></li>
<li>&ldquo;Commit phase&quot;中的三个方法,Can work with DOM, run side effects, schedule updates：
<ol>
<li><code>componentDidMount</code> -&gt; the useEffect hook with the second argument of []</li>
<li><code>componentDidUpdate</code> -&gt; the useEffect hook with the second argument of [state]</li>
<li><code>componentWillUnmount</code> -&gt; <strong>return a function</strong> that runs on unmounting inside the useEffect function,例:</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl">    <span class="nx">useEffect</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s2">&#34;Hello&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s2">&#34;Bye&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">};</span>
</span></span><span class="line"><span class="cl"><span class="p">},</span> <span class="p">[]);</span>
</span></span></code></pre></div></li>
</ul>
<h2 id="虚拟dom-virtual-document-object-model">虚拟DOM （Virtual Document Object Model）</h2>
<p>在React中，当状态（state）发生变化时，React并不直接操作真实的DOM来更新页面，而是先在内存中构建一个虚拟DOM树，然后通过比较虚拟DOM树和之前渲染的虚拟DOM树之间的差异，最终计算出最小的DOM操作，并将这些操作批量应用到真实的DOM上。</p>
<h3 id="虚拟dom节点可能包含的详细信息">虚拟DOM节点可能包含的详细信息</h3>
<ol>
<li><strong>type</strong>：节点类型可以是元素节点、文本节点或者组件节点。</li>
<li><strong>props</strong>：节点可能包含一些属性，这些属性描述了节点的特征，比如元素节点的class、id、style等属性，以及事件处理函数等。chidren 是 props 中的一个属性，它存储了当前组件的孩子节点，可以是数组（多个孩子节点）或对象（只有一个孩子节点）</li>
<li><strong>key</strong>：用于在DOM的重渲染过程中标识节点的唯一性，有助于React在进行差异比较时准确找到对应的节点。</li>
<li><strong>ref</strong>：用于获取节点的引用，通常用于在组件中操作DOM节点。</li>
<li><strong>owner</strong>: 所属的Component</li>
<li>其他</li>
</ol>
<h3 id="diff算法">diff算法</h3>
<ul>
<li>比较当前的虚拟DOM树和状态变更将要重新渲染时生成的虚拟DOM树的算法。</li>
<li>参考<a href="https://xie.infoq.cn/article/65e938d933cc751fcc008942d"  target="_blank" rel="noopener" >谈谈虚拟DOM，Diff算法与Key机制_React_beifeng1996_InfoQ写作社区</a></li>
<li>关键：
<ol>
<li>深度优先</li>
<li>只对同一级别的元素进行比较</li>
</ol>
</li>
<li>三种diff
<ol>
<li>tree diff : 只是简单进行了删除和创建操作</li>
<li>component diff：
<ul>
<li>使用的是<code>===</code>严格相等。也就是&quot;引用相等性&rdquo;</li>
<li>不同类型 -&gt; 直接替换整个组件下的所有子节点，即销毁原组件，创建新组件。</li>
<li>同一类型 -&gt; 继续判断</li>
</ul>
</li>
<li>element diff: 针对同一层级的所有节点（包括元素节点和组件节点）的 diff 算法
<ul>
<li>三种操作：
<ol>
<li>insert_markup</li>
<li>move_existing</li>
<li>remove_node:</li>
</ol>
</li>
<li>涉及到列表元素顺序的动态变更时，不要用遍历的 index 作为节点的 key 属性值</li>
</ul>
</li>
</ol>
</li>
</ul>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://juejin.cn/post/6938321875298680845"  target="_blank" rel="noopener" >Failed to execute &lsquo;removeChild&rsquo; on &lsquo;Node&rsquo; - 掘金</a></li>
<li><a href="https://www.twilio.com/en-us/blog/react-choose-functional-components"  target="_blank" rel="noopener" >Understanding Functional Components vs. Class Components in React</a></li>
<li><a href="https://retool.com/blog/the-react-lifecycle-methods-and-hooks-explained"  target="_blank" rel="noopener" >The React lifecycle: methods and hooks explained</a></li>
<li><a href="https://xie.infoq.cn/article/65e938d933cc751fcc008942d"  target="_blank" rel="noopener" >React面试：谈谈虚拟DOM，Diff算法与Key机制_React_beifeng1996_InfoQ写作社区</a></li>
<li><a href="https://prin.pw/react-unstable-nested-components"  target="_blank" rel="noopener" >真的不可以在 React 组件内部嵌套定义子组件吗？ - PRIN BLOG</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>React学习经历</title>
      <link>https://euds.org/2023/learn_react/</link>
      <pubDate>Tue, 12 Sep 2023 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2023/learn_react/</guid>
      <description>记录学习React的经历，按日期进行排序，会比较乱</description>
      <content:encoded><![CDATA[<h2 id="2023年9月12日">2023年9月12日</h2>
<p>这两个多星期来几乎都是在写React，现在对它算是又爱又恨。</p>
<h3 id="爱">爱</h3>
<p>逻辑很舒服，虽然我新接触，但几乎就是很自然而然地就能开始写了。</p>
<h3 id="恨">恨</h3>
<p>说恨可能有点过了，但确实遇到了好些坑，耗了好些时间。</p>
<ol>
<li>
<p><code>useEffect</code></p>
<p>看了<a href="https://blog.skk.moe/post/why-you-should-not-fetch-data-directly-in-use-effect/"  target="_blank" rel="noopener" >为什么你不应该在 React 中直接使用 useEffect 从 API 获取数据 | Sukka&rsquo;s Blog</a>后转而使用封装好的useSWR,现在体验感很好。</p>
</li>
<li>
<p><code>useParams()</code>获取不到参数</p>
<p>这个是我没仔细看文档，想当然了.文档中说得很明白:</p>
<blockquote>
<p>Returns an object of key/value pairs of the dynamic params from the current URL that were matched by the route path.</p>
</blockquote>
<p>而我一开始是在Route之外去<code>useParams()</code>，最后的解决方式是，在原本的组件外套一层wrapper，这样来实现左右栏的效果</p>
</li>
<li>
<p><code>Rendered more hooks than during the previous render.</code></p>
<p>这也是个花了我许久的报错。最头疼的是不知道是代码哪里的问题。在<a href="https://stackoverflow.com/questions/55622768/uncaught-invariant-violation-rendered-more-hooks-than-during-the-previous-rende"  target="_blank" rel="noopener" >stackoverflow上的一个回答</a>的解释下，才明白可能问题出在return和useEffect执行顺序的问题。</p>
</li>
<li>
<p>Redux，虽然用起来了，但现在还是懵懵的，还是得再看文档</p>
</li>
</ol>
<h3 id="总结">总结</h3>
<p>因为要赶最后的ddl，所以比较偏向于急于求成，看了看用法和示例就开始写了，虽然最后确实能写出点东西，但总有种半生不熟的感觉。</p>
<p>这样做还有一个很大的弊端：我跟着示例文档和ai的提示，照猫画虎写出一个能用的东西，后面为了效率，我就会直接去复用这个东西，或者在其基础上稍微修改。</p>
<p>代码的可复用性当然是件好事。但问题是我最开始糊出来的那个其实不一定就是好的。但如果我能在了解、学习了一定基础上再去写，成品会好很多。</p>
<p>我感觉一个比较理想的状态是：先学百分五六十，然后再去用。用的过程同时也加深理解。</p>
<hr>
<h2 id="2023年9月14日">2023年9月14日</h2>
<p>看了<a href="https://react.dev/learn/thinking-in-react"  target="_blank" rel="noopener" >Thinking in React</a>,记录一下</p>
<ul>
<li>
<p>Which of these are state? Identify the ones that are not:</p>
<ol>
<li>Does it remain unchanged over time? If so, it isn’t state.</li>
<li>Is it passed in from a parent via props? If so, it isn’t state.</li>
<li>Can you compute it based on existing state or props in your component? If so, it definitely isn’t state!</li>
</ol>
<p><em>What’s left is probably state.</em></p>
</li>
<li>
<p>For each piece of state in your application:</p>
<ol>
<li>Identify every component that renders something based on that state.</li>
<li>Find their closest common parent component -&gt; a component above them all in the hierarchy.</li>
<li>Often, you can put the state directly into their common parent.</li>
<li>You can also put the state into some component above their common parent.</li>
<li>If you can’t find a component where it makes sense to own the state, create a new component solely for holding the state and add it somewhere in the hierarchy above the common parent component.</li>
</ol>
</li>
</ul>
<hr>
<h2 id="2024年2月28日">2024年2月28日</h2>
<p>最近的一个小玩具<a href="https://github.com/EuDs63/postkid"  target="_blank" rel="noopener" >EuDs63/postkid</a>有轻量级的状态管理需求，权衡下决定使用<a href="https://jotai.org/"  target="_blank" rel="noopener" >Jotai, primitive and flexible state management for React</a>,开始的体验很不错。</p>
<p>我先做好了<code>./work/page</code>这个组件。接下来我希望实现类似于Postman的多标签页。每个标签页都是用同样的组件，但它们互相独立。</p>
<p>本来这并不是件难事，但因为我之前偷懒，高度依赖jotai的atom来做状态管理,因此花了好些时间。</p>
<p>先尝试了<a href="https://github.com/jotaijs/jotai-scope"  target="_blank" rel="noopener" >jotaijs/jotai-scope</a>,它给的示例确实符合我的需求，但当标签切走再切回去的时候，原来的状态就被重置了，我找不到问题所在，放弃。</p>
<p>中途多次问ChatGPT和Gemini，都是一开始看着很可行，然后实际不行，再问就开始重复之前的回答了。</p>
<p>最后是靠<a href="https://devv.ai/zh"  target="_blank" rel="noopener" >Devv</a>解决的，它说<a href="https://jotai.org/docs/utilities/family"  target="_blank" rel="noopener" >Jotai的atomFamily</a>能解决。<code>atomFamily</code>允许创建一组相关的原子，并为每个实例提供一个唯一的标识符。一试,确实可行。</p>
<p>现在再看我的实现，感觉还是比较简陋的。每个标签页对应一个特定的<code>tagId</code>，然后<code>atomFamily</code>就是&quot;a Map whose key is a param and whose value is an atom config&quot;。</p>
<hr>
<h2 id="2024年3月4日">2024年3月4日</h2>
<ul>
<li>
<p><a href="https://react.dev/reference/react/useCallback"  target="_blank" rel="noopener" >useCallback – React</a></p>
<ol>
<li><code>useCallback</code> is a Hook, so you can only call it at the top level of your component or your own Hooks.</li>
<li><code>useCallback</code> caches a <strong>function</strong> between re-renders until its dependencies change</li>
<li>usage:Skipping re-rendering of components</li>
<li><code>useMemo</code> caches the <strong>result</strong> of calling your function</li>
<li>The only benefit to <code>useCallback</code> is that it lets you avoid writing an extra nested function inside. It doesn’t do anything else.</li>
</ol>
</li>
<li>
<p><a href="https://prin.pw/react-unstable-nested-components/"  target="_blank" rel="noopener" >真的不可以在 React 组件内部嵌套定义子组件吗？ - PRIN BLOG</a></p>
<ul>
<li>永远不要在 React 组件内部嵌套定义子组件。</li>
<li>「渲染函数」和「函数组件」的区别:
<ol>
<li>渲染函数虽然和组件一样都返回 JSX，但它不是组件；</li>
<li>渲染函数就是普通 JavaScript 函数，没有状态，也没有对应的 Fiber 节点；</li>
<li>渲染函数只是当前组件的一部分，对于 React 渲染来说没有额外开销；</li>
<li>渲染函数内部<strong>不能</strong>使用 Hooks，只有组件内部才能使用 Hooks；</li>
<li>渲染函数命名一般以 render 开头，首字母小写（否则容易和组件搞混）</li>
<li>调用方式</li>
</ol>
</li>
<li><a href="https://github.com/shuding/tilg"  target="_blank" rel="noopener" >shuding/tilg: A magical React Hook that helps you debug components.</a>可以用来展示组件生命周期。</li>
</ul>
</li>
<li>
<p>报错：<code>useEffect</code> is called conditionally</p>
<p>完整报错如下:</p>
<blockquote>
<p>React Hook &ldquo;useEffect&rdquo; is called conditionally. React Hooks must be called in the exact same order in every component render.  react-hooks/rules-of-hooks</p>
</blockquote>
<p>解决方法很简单，只需将useEffect调用移动到组件的顶层，并使用条件语句来决定是否执行其内部的逻辑即可。</p>
</li>
<li>
<p><a href="https://react.dev/learn/render-and-commit"  target="_blank" rel="noopener" >Render and Commit – React</a></p>
<ul>
<li>在 React 中，每次更新都分为 两个阶段：
<ol>
<li>在 渲染 阶段， React 调用你的组件来确定屏幕上应该显示什么。</li>
<li>在 提交 阶段， React 把变更应用于 DOM。</li>
</ol>
</li>
<li>Process of requesting and serving UI has three steps:
<ol>
<li>Triggering a render</li>
<li>Rendering</li>
<li>Committing to the DOM</li>
</ol>
</li>
<li>Two reasons for a component to render:
<ol>
<li>It’s the component’s initial render.</li>
<li>The component’s (or one of its ancestors’) state has been updated.</li>
</ol>
</li>
</ul>
</li>
</ul>
<hr>
<h2 id="2024年3月5日">2024年3月5日</h2>
<ul>
<li><a href="https://www.developerway.com/posts/components-composition-how-to-get-it-right"  target="_blank" rel="noopener" >Developer Way: React components composition: how to get it right</a>
<ul>
<li>The core React development and decomposition rules:
<ol>
<li>always start implementation from the top</li>
<li>extract components only when there is an actual need for it</li>
<li>always start from “simple” components, introduce other composition techniques only when there is an actual need for them</li>
</ol>
</li>
<li>A component should be described either as a “component that implements various stuff” or as a “component that composes various components together”, not both.</li>
<li>Extract Container components when there is a need to share some visual or behavioural logic that wraps elements that still need to be under “consumer” control</li>
<li>What makes a good component?
<ol>
<li>易读</li>
<li>命名清晰准确</li>
<li>doesn’t do things that are irrelevant to its declared purpose</li>
</ol>
</li>
</ul>
</li>
</ul>
<hr>
<h2 id="2024年3月6日">2024年3月6日</h2>
<ul>
<li>
<p><a href="https://legacy.reactjs.org/docs/composition-vs-inheritance.html#containment"  target="_blank" rel="noopener" >Composition vs Inheritance – React</a></p>
<ul>
<li>&ldquo;children&rdquo; is just a prop. The fancy “composition” pattern that we use is a syntax sugar.</li>
<li>Inheritance is not recommended. If you want to reuse non-UI functionality between components, we suggest <strong>extracting it into a separate JavaScript module</strong>. The components may import it and use that function, object, or class, without extending it.</li>
</ul>
</li>
<li>
<p><a href="https://www.developerway.com/posts/react-elements-children-parents"  target="_blank" rel="noopener" >Developer Way: The mystery of React Element, children, parents and re-renders</a></p>
<ul>
<li>Components that are passed as props don’t re-render.</li>
<li>If children are passed as a render function, they start re-rendering.</li>
</ul>
</li>
</ul>
<hr>
<h2 id="2024年3月7日">2024年3月7日</h2>
<ul>
<li>读<a href="https://zh-hans.react.dev/reference/react/Fragment"  target="_blank" rel="noopener" ><!-- raw HTML omitted --> (&lt;&gt;&hellip;&lt;/&gt;) – React 中文文档</a>，原来<code>&lt;&gt;</code>是<code>&lt;Fragment</code>的简写。</li>
</ul>
<hr>
<h2 id="2024年3月8日">2024年3月8日</h2>
<ul>
<li>
<p>受控组件 v.s 非受控组件</p>
<ul>
<li>参考<a href="https://muyunyun.cn/blog/56hn38ez"  target="_blank" rel="noopener" >重新认识受控与非受控组件</a></li>
<li>In a controlled component, form data is handled by a React component.</li>
<li>In a uncontrolled component, form data is handled by the DOM itself.</li>
<li>受控以及非受控组件的边界划分取决于当前组件对于子组件值的变更是否拥有控制权。</li>
</ul>
</li>
<li>
<p><a href="https://zh-hans.react.dev/reference/react-dom/components/input#my-input-caret-jumps-to-the-beginning-on-every-keystroke"  target="_blank" rel="noopener" >当我输入时，输入框光标会跳到开头– React 中文文档</a></p>
<blockquote>
<p>有可能是因为每次输入时输入框都从 DOM 中删除并重新添加。同样，如果在每次重新渲染时不小心 重置了 state，就会发生这种情况。例如，如果输入框或其祖先组件总是接收不同的 key，或者嵌套使用组件（这在 React 中是不允许的，并且会导致“内部”组件在每次渲染时重新挂载），就会发生这种情况。</p>
</blockquote>
<p>我在写<a href="https://github.com/EuDs63/postkid"  target="_blank" rel="noopener" >EuDs63/postkid</a>就遇到了这个问题，原来如此。</p>
</li>
</ul>
<hr>
<h2 id="2024年3月9日">2024年3月9日</h2>
<ul>
<li>
<p>redux</p>
</li>
<li>
<p>useContext的使用</p>
</li>
<li>
<p>自定义hook</p>
</li>
</ul>
<hr>
<h3 id="ref">ref</h3>
<ul>
<li>ref 是一个普通的 JavaScript 对象，具有可以被读取和修改的 current 属性。</li>
<li><a href="https://zh-hans.react.dev/learn/referencing-values-with-refs#differences-between-refs-and-state"  target="_blank" rel="noopener" >ref 和 state 的不同之处</a>
<ol>
<li>更改不会触发渲染</li>
<li>无set</li>
<li>可变 —— 你可以在渲染过程之外修改和更新 current 的值。</li>
<li>不应在渲染期间读取（或写入） current 值。</li>
</ol>
</li>
<li>使用时机
<ol>
<li>当一条信息仅被事件处理器需要，并且更改它不需要重新渲染时，使用 ref 可能会更高效。</li>
<li>你的组件需要“跳出” React 并与外部 API 通信时</li>
<li>存储和操作 DOM 元素</li>
<li>存储不需要被用来计算 JSX 的其他对象</li>
</ol>
</li>
<li><code>ref</code>回调函数
<ol>
<li>参考<a href="https://zh-hans.react.dev/reference/react-dom/components/common#ref-callback"  target="_blank" rel="noopener" >ref 回调函数 – React 中文文档</a></li>
<li>不要从 ref 回调函数中返回任何内容。</li>
<li>当回调函数被附加在 ref 属性后，触发回调时，该参数为对应的 DOM 节点。当 ref 被分离时值为 null。除非在每次渲染时都传递相同的函数引用作为 ref 回调，否则该回调将在组件的每次重新渲染期间被暂时分离和重新连接。</li>
</ol>
</li>
<li>默认情况下，React 不允许组件访问其他组件的 DOM 节点:可使用<code>forwardRef</code>,例：
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">MyInput</span> <span class="o">=</span> <span class="nx">forwardRef</span><span class="p">((</span><span class="nx">props</span><span class="p">,</span> <span class="nx">ref</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="o">&lt;</span><span class="nx">input</span> <span class="p">{...</span><span class="nx">props</span><span class="p">}</span> <span class="nx">ref</span><span class="o">=</span><span class="p">{</span><span class="nx">ref</span><span class="p">}</span> <span class="o">/&gt;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span>
</span></span></code></pre></div></li>
<li><a href="https://zh-hans.react.dev/learn/manipulating-the-dom-with-refs#exposing-a-subset-of-the-api-with-an-imperative-handle"  target="_blank" rel="noopener" >使用命令句柄暴露一部分 API</a></li>
<li>React 在提交阶段设置 <code>ref.current</code>。在更新 DOM 之前，React 将受影响的<code> ref.current</code>值设置为 null。更新 DOM 后，React 立即将它们设置到相应的 DOM 节点。</li>
</ul>
<hr>
<h2 id="2024年3月10日">2024年3月10日</h2>
<h3 id="fiber">Fiber</h3>
<ul>
<li>参考<a href="https://zhuanlan.zhihu.com/p/390409316"  target="_blank" rel="noopener" >React Fiber很难？六个问题助你理解 React Fiber - 知乎</a>
<ul>
<li>一套更新机制,让 React 的更新过程变得可控</li>
<li>栈递归 -&gt; 链表遍历</li>
</ul>
</li>
<li><a href="https://blog.logrocket.com/deep-dive-react-fiber/"  target="_blank" rel="noopener" >A deep dive into React Fiber - LogRocket Blog</a></li>
</ul>
<hr>
<h2 id="2024年3月14日">2024年3月14日</h2>
<ul>
<li>什么hooks不能写在if/else等语句里</li>
<li>你是怎么理解React的？（答得非常烂，建议从数据驱动 ui = f(state)、响应式 fiber + 异步可中断更新、组件化 component，hooks、跨平台 scheduler；reconciler；render；vdom，合成事件系统等方面答）</li>
<li>React18新特性（concurrent）</li>
<li>react有没有什么缺点（能没有缺点吗，死怼运行时，hooks凭啥不能写在if/else里，useXXX到底怎么个use法，过期闭包，依赖全得手动写，如果用eslint那么里面用过的都会要你加到依赖数组里）</li>
<li>react hooks为啥不能写在if/else里（底层实现就是个链表，一个有序的东西）</li>
<li>react hooks能实现类里面的所有生命周期吗</li>
<li>路由怎么做的 什么守卫</li>
</ul>
<hr>
<h2 id="2024年3月21日">2024年3月21日</h2>
<ul>
<li>组件间通信</li>
<li>自定义hook</li>
<li>react hook</li>
<li>react 组件传值</li>
<li>react父组件怎么获取子组件的值   useRef</li>
<li>react provider标签以及其使用原理</li>
<li>react 路由的两种模式</li>
<li>redux
<ul>
<li><a href="https://redux.js.org/tutorials/essentials/part-1-overview-concepts"  target="_blank" rel="noopener" >Redux Essentials, Part 1: Redux Overview and Concepts | Redux</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="2024年3月26日">2024年3月26日</h2>
<h3 id="自定义hook">自定义hook</h3>
<ul>
<li><a href="https://mp.weixin.qq.com/s?__biz=MzI4NjE3MzQzNg==&amp;mid=2649865889&amp;idx=1&amp;sn=2549fb3da7608aa8e3cce0623fbd8d25"  target="_blank" rel="noopener" >超性感的React Hooks（五）：自定义hooks</a></li>
</ul>
<blockquote>
<p>自定义hook能够跟随函数组件重复执行，并且每次都返回最新结果。因此，我们可以非常放心大胆的封装异步逻辑。</p>
</blockquote>
<ul>
<li>看<a href="https://mp.weixin.qq.com/s/GPcwIPJBc9I_NtixyU-U4Q"  target="_blank" rel="noopener" >超性感的React Hooks（六）自定义hooks的思维方式</a>，摘录其中一段</li>
</ul>
<blockquote>
<p>准确来说，应该是逻辑片段复用。</p>
<p>和组件化思维不同，这是另外一个粒度更细的代码复用思维。例如我们之前提到的，获取同样的数据。在组件化思维中，一个完整的组件，包括了这份数据，以及这份数据在页面上的展示结果。因此这是不同的复用思维。</p>
<p>处理获取数据过程中的公用逻辑，处理公用的登陆逻辑等。自定义hooks封装的大多数情况下不是一个完整的页面逻辑实现，而是其中的一个片段。</p>
</blockquote>
<hr>
<h2 id="2024年4月9日">2024年4月9日</h2>
<p>看<a href="https://dev.to/chandrapantachhetri/responsive-react-file-upload-component-with-drag-and-drop-4ef8"  target="_blank" rel="noopener" >Responsive React File Upload Component With Drag And Drop - DEV Community</a></p>
<p>尤其是“Why are we setting the title and value attribute to &ldquo;&quot;?”这段，之前我看别人的代码这样写还以为是错的，原来是有其独特作用的。</p>
<hr>
<h2 id="2024年4月28日">2024年4月28日</h2>
<ul>
<li><a href="https://juejin.cn/post/7132786097922736164"  target="_blank" rel="noopener" >useEffect(fn, []) 不等于 componentDidMount() - 掘金</a></li>
<li><a href="https://juejin.cn/post/7277917854430674959"  target="_blank" rel="noopener" >React 组件库都是怎么打包？ - 掘金</a></li>
<li><a href="https://react.dev/reference/react/useImperativeHandle"  target="_blank" rel="noopener" >useImperativeHandle – React</a></li>
</ul>
<p>这几篇打开来很久了，一直没看，记录下。</p>
<hr>
<h2 id="2024年5月20日">2024年5月20日</h2>
<ul>
<li>参考
<ul>
<li><a href="https://react.dev/reference/react/forwardRef"  target="_blank" rel="noopener" >forwardRef – React</a></li>
<li><a href="https://react.dev/reference/react/useImperativeHandle"  target="_blank" rel="noopener" >useImperativeHandle – React</a></li>
<li><a href="https://www.telerik.com/blogs/react-basics-how-to-use-forwardref"  target="_blank" rel="noopener" >React Basics: How to Use ForwardRef</a></li>
</ul>
</li>
<li>forwardRef lets your component expose a DOM node to parent component with a ref.</li>
<li>useImperativeHandle is a React Hook that lets you customize the handle exposed as a ref.
<code>useImperativeHandle(ref, createHandle, dependencies?)</code></li>
</ul>
<hr>
<h2 id="2024年9月21日">2024年9月21日</h2>
<ul>
<li><a href="https://blog.huli.tw/2024/03/13/from-react-to-vue/#%E5%9C%A8%E9%96%8B%E5%A7%8B%E4%B9%8B%E5%89%8D"  target="_blank" rel="noopener" >從 React 到 Vue 的心得感想 - Huli&rsquo;s blog</a></li>
</ul>
<hr>
<h2 id="2024年10月11日">2024年10月11日</h2>
<p>读<a href="https://github.com/paul-ll/my_book/blob/master/React%E5%AE%9E%E6%88%98%EF%BC%9A%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E5%92%8C%E6%9C%80%E4%BD%B3%E5%AE%9E%E8%B7%B5/%E7%BB%84%E4%BB%B6%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%EF%BC%882%EF%BC%89%EF%BC%9A%E9%AB%98%E9%98%B6%E7%BB%84%E4%BB%B6.md"  target="_blank" rel="noopener" >my_book/React实战：设计模式和最佳实践/组件设计模式（2）：高阶组件.md at master · paul-ll/my_book</a></p>
<p>摘录其中内容作为我的笔记</p>
<ul>
<li>
<p>高阶组件的定义:</p>
<ul>
<li>一个纯函数</li>
<li>接收组件作为参数</li>
<li>返回一个新的组件</li>
<li>高阶组件的命名一般都带 with 前缀，命名中后面的部分代表这个高阶组件的功能</li>
</ul>
</li>
<li>
<p>示例</p>
</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JSX" data-lang="JSX"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">withLoginAndLogout</span> <span class="o">=</span> <span class="p">(</span><span class="nx">ComponentForLogin</span><span class="p">,</span> <span class="nx">ComponentForLogout</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">NewComponent</span> <span class="o">=</span> <span class="p">(</span><span class="nx">props</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">getUserId</span><span class="p">())</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="p">&lt;</span><span class="nt">ComponentForLogin</span> <span class="p">{</span><span class="na">...props</span><span class="p">}</span> <span class="p">/&gt;;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="p">&lt;</span><span class="nt">ComponentForLogout</span><span class="p">{</span><span class="na">...props</span><span class="p">}</span> <span class="p">/&gt;;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">NewComponent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">TopButtons</span> <span class="o">=</span> <span class="nx">withLoginAndLogout</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">  <span class="nx">LogoutButton</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">LoginButton</span>
</span></span><span class="line"><span class="cl"><span class="p">);</span>
</span></span></code></pre></div><hr>
<h2 id="2024年10月17日">2024年10月17日</h2>
<p>react的单向数据流怎么理解，有什么好处？</p>
<ul>
<li>
<p>数据流：也就是数据在不同组件或节点之间的流动</p>
</li>
<li>
<p>单向:  react规定了数据的流向是从外层组件向内层组件进行传递和更新的，而内层组件是无法直接修改props影响外层的。</p>
</li>
<li>
<p>好处:</p>
<ol>
<li>如果内层的组件可以通过修改props来修改外层的数据，那么外层使用到这个数据或者其他使用到这个数据的地方都会造成数据更新，UI渲染也会改变，这会造成数据紊乱和不可控。所以为了<strong>更好的可控性</strong>，react设计了单向数据流。</li>
<li>所有的数据更新是单向的，那么出现问题的时候会更好溯源，因为修改数据的链路是确定的，排查起来顺着调用链就可以一层一层找到问题了。</li>
</ol>
</li>
<li>
<p>引申</p>
<ul>
<li>useContext</li>
<li>forwardRef, useImperativeHandle</li>
</ul>
</li>
<li>
<p>参考</p>
<ul>
<li><a href="https://www.nowcoder.com/feed/main/detail/04aee48cc23f4b09a04d0dba327f0c5d?sourceSSR=search"  target="_blank" rel="noopener" >70场面试，复盘我遇到的有趣问题（二）_牛客网</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://blog.skk.moe/post/why-you-should-not-fetch-data-directly-in-use-effect/"  target="_blank" rel="noopener" >为什么你不应该在 React 中直接使用 useEffect 从 API 获取数据 | Sukka&rsquo;s Blog</a></li>
<li><a href="https://stackoverflow.com/questions/55622768/uncaught-invariant-violation-rendered-more-hooks-than-during-the-previous-rende"  target="_blank" rel="noopener" >javascript - Uncaught Invariant Violation: Rendered more hooks than during the previous render - Stack Overflow</a></li>
<li><a href="https://jotai.org/"  target="_blank" rel="noopener" >Jotai, primitive and flexible state management for React</a></li>
<li><a href="https://prin.pw/react-unstable-nested-components/"  target="_blank" rel="noopener" >真的不可以在 React 组件内部嵌套定义子组件吗？ - PRIN BLOG</a></li>
<li><a href="https://react.dev/reference/react/useCallback"  target="_blank" rel="noopener" >useCallback – React</a></li>
<li><a href="https://blog.skk.moe/post/react-re-renders-101/"  target="_blank" rel="noopener" >React 为什么重新渲染 | Sukka&rsquo;s Blog</a></li>
<li><a href="https://react.dev/learn/render-and-commit"  target="_blank" rel="noopener" >Render and Commit – React</a></li>
<li><a href="https://zh-hans.react.dev/reference/react/Fragment"  target="_blank" rel="noopener" ><!-- raw HTML omitted --> (&lt;&gt;&hellip;&lt;/&gt;) – React 中文文档</a></li>
<li><a href="https://zh-hans.react.dev/learn/referencing-values-with-refs#differences-between-refs-and-state"  target="_blank" rel="noopener" >使用 ref 引用值 – React 中文文档</a></li>
</ul>
]]></content:encoded>
    </item>
    
  </channel>
</rss>
