<?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>JavaScript on EuDs&#39;s Blog</title>
    <link>https://euds.org/tags/javascript/</link>
    <follow_challenge>
      <feedId>55788057182175234</feedId>
      <userId>67186528297029632</userId>
    </follow_challenge>
    <description>Recent content in JavaScript on EuDs&#39;s Blog</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Thu, 10 Oct 2024 00:56:14 +0800</lastBuildDate><atom:link href="https://euds.org/tags/javascript/index.xml" rel="self" type="application/rss+xml" />
    <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>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>函数式编程学习</title>
      <link>https://euds.org/2024/learn_functional_paradigm/</link>
      <pubDate>Thu, 26 Sep 2024 15:34:14 +0800</pubDate>
      
      <guid>https://euds.org/2024/learn_functional_paradigm/</guid>
      <description>自己学习过程中整理的关于函数式编程的知识点</description>
      <content:encoded><![CDATA[<h2 id="纯函数">纯函数</h2>
<p>以下内容摘自<a href="https://blog.orangex4.workers.dev/post/reversi/"  target="_blank" rel="noopener" >Reversi 黑白棋的前端界面与 AI 实现 | OrangeX4&rsquo;s Blog</a></p>
<blockquote>
<p>函数式编程有一个很重要的原则: 尽量使用纯函数 (pure function).</p>
<p>什么是纯函数? 纯函数就是, 给定相同的输入, 一定有相同的输出, 且没有任何副作用的函数. 数学函数就是真正的纯函数, 如三角函数 sin, 给定相同的输入 x, 一定会有相同的输出 y.</p>
<p>纯函数有什么好处呢? 可控, 没有副作用, 支持高并发, 可以很方便地缓存.</p>
<p>支持高并发是因为, 每个用户均有自己的数据, 他们不需要争夺对同一个数据的使用和修改权, 所以可以很方便地将纯函数部署到不同的服务器上, 而不用担心资源共享, 服务器通信和资源锁之类的麻烦问题.</p>
<p>而缓存就更为简单了, 这是一种用空间换时间的策略. 对于运算复杂耗时长的纯函数来说, 我们只需要, 在每一次运行这个函数时, 把 输入到输出的映射 记录在一个哈希表中, 下一次运行这个函数的时候, 可以先看看这个输入在不在哈希表中, 在的话, 直接使用表中的数据, 这就是缓存.</p>
</blockquote>
<p>缓存这个思路可运用的范围很广。</p>
<p>我还可以举一个例子，文生图网站的默认prompt,大部分新进用户如果想要尝试，很大可能会先直接使用默认参数进行生成，那么这默认的参数所生成的图片就可以缓存，后端直接发过去就是，而不用再生成。如果想更进一步节省成本，那可以将用户提供的参数进行hash，命中了就发对应的图片。</p>
<p>不少商用的大语言模型也提供了类似的选项。它会提供给用户是否使用缓存的选项，如果允许并且成功命中缓存，那么所需费用能大大节省。</p>
<hr>
<h2 id="偏函数">偏函数</h2>
<p>wip</p>
<hr>
<h2 id="柯里化curry">柯里化(curry)</h2>
<ul>
<li>把接收多参的函数转化成可以逐个调用单个参数并返回接收剩下参数的函数</li>
<li>JS实现
<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">curry</span><span class="p">(</span><span class="nx">func</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="nx">curried</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">if</span> <span class="nx">args</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;=</span> <span class="nx">func</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">// func.length：func的参数的数量
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>      <span class="c1">// 如果传入的 args 长度与原始函数所定义的（func.length）相同或者更长
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>      <span class="k">return</span> <span class="nx">func</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="k">this</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></span><span class="line"><span class="cl">    <span class="k">else</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">args2</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 重新应用 curried，将之前传入的参数与新的参数一起传入。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="k">return</span> <span class="nx">curried</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="nx">args</span><span class="p">.</span><span class="nx">concat</span><span class="p">(</span><span class="nx">args2</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></code></pre></div></li>
<li>上述代码的限制
<ol>
<li>函数具有固定数量的参数</li>
<li>使用 rest 参数的函数，例如 f(&hellip;args)，不能以这种方式进行柯里化</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">curry</span><span class="p">(</span><span class="nx">fn</span><span class="p">,..</span><span class="nx">bindArgs</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">args</span><span class="p">)=&gt;{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">allArgs</span> <span class="o">=</span> <span class="p">[...</span><span class="nx">bindArgs</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">if</span><span class="p">(</span><span class="nx">allArgs</span><span class="p">.</span><span class="nx">length</span><span class="o">&lt;</span><span class="nx">fn</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">// func.length：func的参数的数量
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>      <span class="c1">// 如果传入的 args 长度与原始函数所定义的（func.length）相同或者更长
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>      <span class="k">return</span> <span class="nx">curry</span><span class="p">(</span><span class="nx">fn</span><span class="p">,...</span><span class="nx">allArgs</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">fn</span><span class="p">(...</span><span class="nx">allArgs</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>实际使用：lodash 库的 _.curry</li>
<li>参考：<a href="https://zh.javascript.info/currying-partials"  target="_blank" rel="noopener" >柯里化（Currying）</a></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="c1">// 这里的withOne等函数应为纯函数
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kr">const</span> <span class="nx">X1</span> <span class="o">=</span> <span class="nx">withOne</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">X2</span> <span class="o">=</span> <span class="nx">withTwo</span><span class="p">(</span><span class="nx">X1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">X3</span> <span class="o">=</span> <span class="nx">withThree</span><span class="p">(</span><span class="nx">X2</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">SuperX</span> <span class="o">=</span> <span class="nx">X3</span><span class="p">;</span> <span class="c1">//最终的SuperX具备三个高阶组件的超能力
</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">SuperX</span> <span class="o">=</span> <span class="nx">withThree</span><span class="p">(</span><span class="nx">withTwo</span><span class="p">(</span><span class="nx">withOne</span><span class="p">(</span><span class="nx">X</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">hoc</span> <span class="o">=</span> <span class="nx">compose</span><span class="p">(</span><span class="nx">withThree</span><span class="p">,</span> <span class="nx">withTwo</span><span class="p">,</span> <span class="nx">withOne</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">SuperX</span> <span class="o">=</span> <span class="nx">hoc</span><span class="p">(</span><span class="nx">X</span><span class="p">);</span>
</span></span></code></pre></div></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="kr">export</span> <span class="k">default</span> <span class="kd">function</span> <span class="nx">compose</span><span class="p">(...</span><span class="nx">funcs</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="nx">funcs</span><span class="p">.</span><span class="nx">length</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="k">return</span> <span class="nx">arg</span> <span class="p">=&gt;</span> <span class="nx">arg</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">if</span> <span class="p">(</span><span class="nx">funcs</span><span class="p">.</span><span class="nx">length</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="k">return</span> <span class="nx">funcs</span><span class="p">[</span><span class="mi">0</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="nx">funcs</span><span class="p">.</span><span class="nx">reduce</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="p">=&gt;</span> <span class="p">(...</span><span class="nx">args</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">a</span><span class="p">(</span><span class="nx">b</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></span></code></pre></div><hr>
<h2 id="参考">参考</h2>
<ul>
<li><a href="https://llh911001.gitbooks.io/mostly-adequate-guide-chinese/content/"  target="_blank" rel="noopener" >Introduction · 函数式编程指北</a></li>
<li><a href="https://tech.meituan.com/2022/10/13/dive-into-functional-programming-01.html"  target="_blank" rel="noopener" >深入理解函数式编程（上） - 美团技术团队</a></li>
<li><a href="https://blog.orangex4.workers.dev/post/reversi/"  target="_blank" rel="noopener" >Reversi 黑白棋的前端界面与 AI 实现 | OrangeX4&rsquo;s Blog</a></li>
</ul>
]]></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>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>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>
    
  </channel>
</rss>
