概论

对于js的垃圾回收，很多人的理解还停留在引用计数和标记清除的阶段。

有人会说，学习这个，对业务代码开发没啥作用。但是我想说，了解了这些基础的东西之后，才能更好地组织代码，在写代码的时候，才能做到心中能有个框架，知道浏览器到底发生了什么。

我也不是科班出身，很多东西不清不楚的。但我感觉计算机行业有个很好的地方，就是学了的知识很快就能得到验证，就能在生产上应用。这种成就感是我当年干机械的时候所无法体验到的。

前几天就有个报障说有个项目越用越卡，但是排查不出问题，我最近正好在学习垃圾回收内存泄漏，就立马能分析出来是不是内存不足产生的影响，就很开心。

本文我会采用图解的方式，尽量照着js垃圾回收的演变历史讲解。

一，什么是垃圾回收

GC 即 Garbage Collection，也就是我们常说的垃圾回收。

我们知道，js是v8引擎编译执行的，而代码的执行就需要内存的参与，内存往往是有限的，为了更好地利用内存资源，就需要把没用的内存回收，以便重新使用。

比如V8引擎在执行代码的过程中遇到了一个函数，那么我们会创建一个函数执行上下文环境并添加到调用栈顶部，函数的作用域里面包含了函数中所有的变量信息，在执行过程中我们分配内存创建这些变量，当函数执行完毕后函数作用域会被销毁，那么这个作用域包含的变量也就失去了作用，而销毁它们回收内存的过程，就叫做垃圾回收。

如下代码：

var testObj1={

    a:1

}

testObj1={

    b:2

}

对应的内存情况如下：

其中堆中的{a:1}就变成了垃圾，需要被GC回收掉。

在C / C++中，需要开发者跟踪内存的使用和管理内存。而js等高级语言，代码在执行期间，是V8引擎在为我们执行垃圾回收。

那么既然已经有v8引擎自动给我们回收垃圾了，为啥我们还需要了解V8引擎的垃圾回收机制呢？这是因为依据这个机制，还有些内存无法回收，会造成内存泄漏。具体的表现就是随着项目运行时间的变成，系统越来越卡滞，需要手动刷新浏览器才能恢复。

了解V8的垃圾回收机制，才能让我们更好地书写代码，规避不必要的内存泄漏。

二，内存的生命周期

如上所说，内存应该存在这样三个生命周期：

1. 
   

   分配所需要的内存：在js代码执行的时候，基本数据类型存储在栈空间，而引用数据类型存储在堆空间。

   
   


2. 
   

   使用分配的空间：可能对对应的值做一些修改。

   
   


3. 
   

   不需要时将其释放回收。

   
   

   如下代码：

   
   

   function fn(){
   
       //创建对象，分配空间
   
       var testObj={
   
           a:1
   
       }
   
       //修改内容
   
       testObj.a=2
   
   }
   
   fn()//调用栈执行完毕，垃圾回收
   
   

   
   

   对应的内存示意图：

   
   

三，垃圾回收的策略

当函数执行完毕，js引擎是通过移动ESP（ESP：记录当前执行状态的指针）来销毁函数保存在栈当中的执行上下文的，栈顶的空间会被自动回收，不需要V8引擎的垃圾回收机制出面。

然而，堆内存的大小是不固定的，那堆内存中的数据是如何回收的呢？

这就引出了垃圾回收的策略。

通常用采用的垃圾回收有两种方法：引用计数(reference counting)和标记清除（mark and sweep）。

3.1，引用计数(reference counting)

如上文第二节中所说，testObj对象存放在堆空间，我们想要使用的时候，都是通过指针来访问，那么是不是只要没有额外的指针指向它，就可以判定为它不再被使用呢？

基于这个想法，人们想出了引用计数的算法。

它工作原理是跟踪每个对象被引用的次数，当对象的引用次数变为 0 时，则判定该对象为无用对象, 可以被垃圾回收机制进行回收。

    function fn(){

        //创建对象，分配空间

        var testObj1={

            a:1

        }//引用数：1

        var testObj2=testObj1//引用数：2

        var testObj3=testObj1//引用数：3

        var testObj4={

            b:testObj1

        }//引用数：4

        testObj1=null//引用数：3

        testObj2=null//引用数：2

        testObj3=null//引用数：1

        testObj4=null//引用数：1

    }

    fn()//调用栈执行完毕，垃圾回收

如上代码，引用次数变成0后，堆内存中的对应内存就会被GC。

如下图，当testObj1-4都变成null后，原来的testObj4引用数变成0，而{a:1}这时候的引用数还为1（有一个箭头指向它），而{b:1002}被回收后，它的引用数就变成0，故而最后也被垃圾回收。

引用计数的优点：

引用计数看起来很简单，v8引擎只需要关注计数器即可，一旦对象的引用数变成0，就立即回收。

但是很明显的，引用计数存在两个缺点：

1，每个对象都需要维护一个计数器去记录它的引用数量。

2，如果存在相互循环引用的对象，因为各自的引用数量无法变成0（除非手动改变），因而无法被垃圾回收。

对于第二点，如下代码：

function fn(){

    //创建对象，分配空间

    var testObj1={

        a:testObj2

    }

    var testObj2={

        b:testObj1

    }

}

fn()

当fn执行完毕后的内存情况如下，因为两个对象相互引用，导致引用数到不了0，就无法被GC：

因为引用计数的弊端，后续的浏览器开始寻找新的垃圾回收机制，从2012年起，所有现代浏览器都使用了标记清除垃圾回收算法。所有对JavaScript垃圾回收算法的改进都是基于标记清除算法的改进。

3.2，标记清除（mark and sweep）

标记清除是另一种常见的垃圾回收机制。

它工作原理是找出所有活动对象并标记它们，然后清除所有未被标记的对象。

其实现步骤如下：

1. 根节点：垃圾回收机制的起点是一组称为根的对象(有很多根对象)，根通常是引擎内部全局变量的引用，或者是一组预定义的变量名，例如浏览器环境中的 Window 对象和 Document 对象。


2. 遍历标记：从根开始遍历引用的对象，将其标记为活动对象。每个活动对象的所有引用也必须被遍历并标记为活动对象。


3. 清除：垃圾回收器会清除所有未标记的对象，并使空间可用于后续使用。

因为能从根节点开始被遍历到的（有被使用到的），就是有用的活动对象，而剩余不能被链接到的则是无用的垃圾，需要被清除。

对于前文引用计数中循环引用的例子，就因为从根对象触发，无法遍历到堆空间中的那两个循环引用的对象，就会把它判定为垃圾对象，从而回收。

如下代码：

var obj1={

    a:{

        b:{

            c:3

        }

    }

}

var obj2={

    d:1

}

obj2=null

如下图，从根节点无法遍历到obj2了，就会把d垃圾回收。

按照这个思路，标记清除算法有一个很大的缺点，就是在清除之后，剩余的对象内存位置是不变的，会导致空闲内存空间是不连续的，出现了 内存碎片（如下图），并且由于剩余空闲内存不是一整块，它是由不同大小内存组成的内存列表，这就牵扯出了内存分配的问题：当新对象需要空间存储时，需要遍历空间以找到能够容纳对象大小size的区域：

这样效率比较低，因而又有了标记整理（Mark-Compact）算法 ，它的标记阶段和标记清除算法没有什么不同，只是标记结束后，标记整理算法会先将活动对象向内存的一端移动，然后再回收未标记的垃圾内存：

四，V8引擎的分代回收

如上文所说，在每次垃圾回收时都要检查内存中所有的对象，这样的话对于一些占用空间大、存活时间长的对象，要是和占用空间小、存活时间短的对象一起检查，那不是平白浪费很多不必要的检查资源嘛。

因为前者需要时间长并且不需要频繁进行清理，后者恰好相反，那怎么优化呢？

类似于信誉分，信誉分高的，检查力度就应该小一些嘛。把信誉分抽象一下，其实说的就是分层级管理，于是就有了弱分代假设。

4.1，弱分代假设（The Weak Generational Hypothesis）

1. 多数对象的生命周期短


2. 生命周期长的对象，一般是常驻对象

V8的GC也是基于假设将对象分为两代： 新生代和老生代。

对不同的分代执行不同的算法可以更有效的执行垃圾回收。

V8 的垃圾回收策略主要基于分代式垃圾回收机制，将堆内存分为新生代和老生代两区域，采用不同的策略来管理垃圾回收。

他们的内存大小如下：

4.2，新生代的垃圾回收策略

新生代对象是通过一个名为 Scavenge 的算法进行垃圾回收。

在JavaScript中，任何对象的声明分配到的内存，将会先被放置在新生代中，而因为大部分对象在内存中存活的周期很短，所以需要一个效率非常高的算法。Scavenge算法是一个典型的牺牲空间换取时间的复制算法，在占用空间不大的场景上非常适用。

Scavenge 算法中将新生代内存一分为二，Semi space From和Semi space To，新生区通常只支持 1～8M 的容量。这块区域使用副垃圾回收器来回收垃圾。

工作方式也很简单：

1，等From空间满了以后，垃圾回收器就会把活跃对象打上标记。

2，把From空间已经被标记的活动对象复制到To空间。

3，将From空间的所有对象垃圾回收。

4，两个空间交换，To空间变成From空间，From变成To空间。以此往复。

而判断是否是活跃对象的方法，还是利用的上文说的从根节点遍历，满足可达性则是活跃对象。

具体流程如下图所示，假设有蓝色指针指向的是From空间，没有蓝色指针指向的是To空间：

从上图可以明显地看到，这种方式解决了上文垃圾回收后内存碎片不连续的问题，相当于是利用空间换时间。

现在新生代空间的垃圾回收策略已经了解，那新生代空间中的对象又如何进入老生代空间呢？

4.3，新生代空间对象晋升老生代空间的条件

1，复制某个对象进入to区域时，如果发现内存占用超过to区域的25%，则将其晋升老生代空间。（因为互换空间后要留足够大的区域给新创建对象）

2，经过两次from和to互换后，还存活的对象，下次复制进to区域前，直接晋升老生代空间。

4.4，老生代空间的垃圾回收策略

老生代空间最初的回收策略很简单，这在我们上文也讲过，就是标记整理算法。

1，先根据可达性，给所有的老生代空间中的活动对象打上标记。

2，将活动对象向内存的一端移动，然后再回收未标记的垃圾内存。

这样看起来已经很完美了，但是我们知道js是个单线程的语言，就目前而言，我们的垃圾回收还是全停顿标记：js是运行在主线程上的，一旦垃圾回收生效，js脚本就会暂停执行，等到垃圾回收完成，再继续执行。

这样很容易造成页面无响应的情况，尤其是在多对象、大对象、引用层级过深的情况下。

于是在这基础上，又有了增量标记的优化。

五，V8优化

5.1，增量标记

前文所说，我们给老生代空间中的所有对象打上活动对象的标记，是从一组根节点出发，根据可达性遍历而得。这就是全量地遍历，一次性完成，

但因为js是单线程，为了避免标记导致主线程卡滞。于是人们想出来和分片一样的思路：主线程每次遍历一部分，就去干其他活，然后再接着遍历。如下图：

增量标记就是将一次 GC 标记的过程，分成了很多小步，每执行完一小步就让应用逻辑执行一会儿，这样交替多次后完成一轮 GC 标记，这样就算页面卡滞，因为时间很短，使用者也感受不到，体验就好了很多。

但是这又引发了一个新的问题：每次遍历一部分节点就停下来，下次继续怎么识别到停顿点，然后继续遍历呢？

V8又引入了三色标记法。

5.2，三色标记法

首先要明确初心：三色标记法要解决的问题是遍历节点的暂停与恢复。

使用两个标志位编码三种颜色：白色（00），灰色（10）和黑色（11）。

白色：指的是未被标记的对象，可以回收

灰色：指自身被标记，成员变量（该对象的引用对象）未被标记，即遍历到它了，但是它的下线还没遍历。不可回收

黑色：自身和成员变量都被标记了，是活动对象。不可回收

1，从已知对象开始，即roots(全局对象和激活函数), 将所有非root对象标记置为白色

2，将root对象变黑,同时将root的直接引用对象abc标记为灰色

3，将abc标记为黑色，同时将它们的直接引用对象标记为灰色

4，直到没有可标记灰色的对象时，开始回收所有白色的对象

如上图所示，如果第一次增量标记只标记到（2），下次开始时，只要找到灰色节点，继续遍历标记即可。

而遍历标记完成的标志就是内存中不再有灰色的。于是这时候就可以把白色的垃圾回收掉。

那这样就解决了遍历节点的暂停与恢复问题，同时支持增量标记。

（ps:其实这里我有个疑惑，暂停后重新开始的时候，不也要遍历寻找灰色节点嘛，每次恢复都要遍历找灰色节点，不是也耗时嘛？）

5.3，写屏障

按照上文对标记的描述，其实有一个前提条件：在标记期间，代码运行不会变更对象的引用情况。

比如说我采用的是增量标记，前脚刚做好的标记，后脚就被js脚本修改了引用关系，那不是会导致标记结果不可信嘛？如下图：

就像上图一样，D已经被判定成垃圾了，但是下一个分片的js又引用了它，这时候如果删除，必然不对，所以V8 增量使用 写屏障 (Write-barrier) 机制，即一旦有黑色对象引用白色对象，该机制会强制将引用的白色对象改为灰色，从而保证下一次增量 GC 标记阶段可以正确标记，这个机制也被称作 强三色不变性

那在我们上图的例子中，将对象 B 的指向由对象 C 改为对象 D 后，白色对象 D 会被强制改为灰色。

这样一来，就不会将D判定为垃圾 ，并且图中新增的垃圾C在本轮垃圾回收中也不会回收，而是在下一轮回收了。

5.4，惰性清理

上文的增量标记和三色标记法以及写屏障只是对标记方式的优化。目的是采用分片的思想将标记的流程碎片化。

而清理阶段同样可以利用这个思想。

V8的懒性清理，也称为惰性清理（Lazy Sweeping），是一种垃圾回收机制，用于延迟清理未标记对象所占用的内存空间，以减少垃圾回收期间的停顿时间。

当增量标记结束后，假如当前的可用内存足以让我们快速的执行代码，其实我们是没必要立即清理内存的，于是可以将清理的过程延迟一下，让JavaScript逻辑代码先执行；也无需一次性清理完所有非活动对象内存，垃圾回收器可以按需逐一进行清理，直到所有的页都清理完毕。

六，垃圾回收总结

6.1，初始的垃圾回收策略：从引用计数到标记清除

对于js的垃圾回收，最开始的时候，是采用引用计数的算法，但是因为引用计数存在循环引用导致垃圾无法清除，于是又引入了标记清除算法，而标记清除算法存在碎片空间问题，于是又优化成标记整理算法。

随着技术的发展，v8引擎的垃圾回收机制也在不断完善。

6.2，弱分代假设，划分新老生代空间采用不同策略

第一次完善是采用弱分代假设，为了让内存占用大、存活时间长的对象减少遍历，采用分代模型，分成了新分代和老分代空间，垃圾回收采取不同的策略。

新生代空间以空间换时间，拆分成from和to空间互换位置，解决垃圾回收后内存不连续的问题。

将满足条件的对象晋升到老生代空间。而老生代空间采用标记整理算法。

6.3，从全停顿到引入分片思想

因为js是单线程，如果垃圾回收耗时过长，就会阻塞页面响应。

为了解决标记阶段的全停顿问题，引入了增量标记算法。但是非黑即白的标记算法在下一次重新开始标记时无法找到上次的中断点，所以使用三色标记法。此外，为了避免增量标记过程中js脚本变更引用关系，v8又增加了写屏障。

同样的，为了解决清理阶段的全停顿问题，引入了惰性清理。

七，本系列其他文章

最近在整理js基础，下面是已经完成的文章：

js从编译到执行过程 - 掘金 (juejin.cn)

从异步到promise - 掘金 (juejin.cn)

从promise到await - 掘金 (juejin.cn)

浅谈异步编程中错误的捕获 - 掘金 (juejin.cn)

作用域和作用域链 - 掘金 (juejin.cn)

原型链和原型对象 - 掘金 (juejin.cn)

this的指向原理浅谈 - 掘金 (juejin.cn)

js的函数传参之值传递 - 掘金 (juejin.cn)

js的事件循环机制 - 掘金 (juejin.cn)

从作用域链和内存角度重新理解闭包 - 掘金 (juejin.cn)

八，本文参考文章：

「硬核JS」你真的了解垃圾回收机制吗 - 掘金 (juejin.cn)

一文带你快速掌握V8的垃圾回收机制 - 掘金 (juejin.cn)

[深入浅出]JavaScript GC 垃圾回收机制 - 掘金 (juej

前言

最近，在逛一些技术群时，看到有人在吐槽，这个video媒体标签设置autoplay属性怎么不生效。不生效就算了，为什么我在dom渲染完成时去获取video元素（假设获取到的元素为el），然后执行el.paly()也不生效，why？？？？

那为什么我通过控制台去执行这两行代码的时候，它又生效了！！！！？？？

带着满脸疑惑，我们来了解一下浏览器的自动播放策略。

1、浏览器的自动播放策略

以谷歌浏览器为例：

在某些特定的情况下，浏览器是允许自动播放的：

1. 
   

   静音状态下始终允许自动播放

   
   


2. 
   

   有声音自动播放时：

   
   
   
   
   • 用户进行了页面点击等与界面发生交互行为后。
   
   
   • 达到媒体参与指数, 也就是用户之前在本站播放过有声音的视频。
   
   
   • 用户将页面添加到移动设备的主屏幕上或者在PC上安装了PWA。
   
   
   
   


3. 
   

   主站可以将自动播放权限委托给它们的 iframe，以允许自动播放声音。

   
   

2、静音播放。

在静音状态下，浏览器是允许自动播放的，代码如下：

<video controls class="videoItem" width="100%" autoplay muted loop="loop" src="./tets.mp4"></video>

属性说明：

muted: 是否静音播放，默认为false。

autoplay：是否自动播放，默认为false。

control：控制器是否显示，默认为false（可不写）。

loop：是否循环播放，默认为false（可不写）。

唉，好像可以自动播放了，于是我拿去应付产品，产品给我泼了一盆冷水，说能让它播放起来有声音吗？
。
于是，又开始了我们的与非静音状态自动播放功能的探索。

3、非静音自动播放

我们在上面有了解到非静音自动播放有四种情况：

1. 用户进行了页面点击等与界面发生交互行为后。


2. 达到媒体参与指数MEI.


3. 用户将页面添加到移动设备的主屏幕上或者在PC上安装了PWA。


4. 主站可以将自动播放权限委托给它们的 iframe。

3.1 用户进行了页面交互行为

这个就可以理解成用户触碰了页面之后，我们就可以进行有声音的自动播放了。看代码

HTML部分：

<video controls class="videoItem" width="100%"  loop="loop" src="./tets.mp4"></video>

JS部分：

const vdo = document.querySelector('video')

// 播放函数

async function playAudio() {

    const res = await vdo.play()

}

// 监听用户点击

document.addEventListener('click',playAudio)

// 监听媒体播放

vdo.addEventListener('play', function () { //播放开始执行的函数

    console.log("开始播放");

    // 移除点击监听事件

    document.removeEventListener("click",playAudio)

})

这里我们就有很大的发挥空间了，比如说视频不完全在可见区，或者用户看视频前给他弹个框？

3.2 达到媒体参与指数MEI

MEI是浏览器根据我们对一些网站的浏览行为打分，越高，就表示我们喜欢观看这个网站的视频，可以通过about://media-engagement来查询，不可更改。
注意：该策略只对PC端浏览器有效。

3.3 用户将页面添加到移动设备的主屏幕上或者在PC上安装了PWA。

用户将页面添加到移动设备的主屏幕上或者在PC上安装了PWA，这个我们基本可以不用去考虑了，在国内是比较少见的，感兴趣的可以去百度。

3.4 主站可以将自动播放权限委托给它们的 iframe。

这个就是通过iframe来控制媒体的自动播放。代码如下：

    <!-- 允许自动播放 -->

    <iframe src="跨源地址" allow="autoplay">



    <!-- 允许自动播放和设置全屏 -->

    <iframe src="跨源地址" allow="autoplay; fullscreen">

需要注意的是，我们可能需要做一些本地代理，不然可能会出现跨域问题。

4 补充

上面还有一点是没有提到的，就是同源下点击页面跳转后可实现自动播放。

比如：我在http://www.bilibili.com页面点击一个视频跳转到了一个新页面，就可以实现自动播放（注意：不能打开新窗口，否则非

前言

这次的百度面试挺紧张的，在写算法题的时候脑子都有点空白，还是按照脑海中那点残存的算法技巧才写出来，不至于太尴尬，以及第一次面试百度这种级别的公司，难免出现了一些平常不至于出现的问题或没注意的缺点，在这里分享给大家。

百度一面

1. 如何用chatgpt提升前端开发效率

因为我嘴贱，平时习惯了使用chatgpt，然后自我介绍说了一句，由于之前面得公司都没问过，导致我没怎么往这方面准备，以至于答得时候牛头不对马嘴，所以说不愧是大厂啊。

1. 问题解答和指导：ChatGPT可以帮助回答与前端开发相关的问题。当你在编写代码的时候，当一时忘记了某个API怎么用，就可以向ChatGPT提问，并获得解答和指导，甚至还会给出一些更加深入且性能更好的应用。这可以帮助更快地解决问题和理解前端开发中的概念。


2. 代码片段和示例：ChatGPT可以帮助你生成常见的前端代码片段和示例。你可以描述你想要实现的功能或解决的问题，然后向ChatGPT请求相关代码片段。这样，您可以更快地获得一些基础代码，从而加快开发速度。


3. 自动生成文档：ChatGPT可以帮助你生成前端代码的文档。你可以描述一个函数、组件或类，并向ChatGPT请求生成相关的文档注释。这可以帮助您更轻松地为你的代码添加文档，提高代码的可读性和可维护性。


4. 问题排查和调试：在开发过程中，您可能会遇到问题或错误。您可以向ChatGPT描述您遇到的问题，或者直接把代码交给它，并请求帮助进行排查和调试。ChatGPT可以提供一些建议和指导，帮助您更快地找到问题的根本原因并解决它们。


5. 学习资源和最新信息：ChatGPT可以为你提供关于前端开发的学习资源和最新信息。你可以向ChatGPT询问关于前端开发的最佳实践、最新的框架或库、前端设计原则等方面的问题。这可以帮助我们不断学习和更新自己的前端开发知识，从而提高效率。

2. [1, 2, 3, 4, 5, 6, 7, 8, 9] => [[1, 2, 3],[4, 5, 6],[7, 8, 9]]，把一个一维数组变成三个三个的二维数组

在JavaScript中，可以使用数组的slice方法和一个循环来将一个一维数组转换为一个二维数组。下面是一个示例代码：

    function convertTo2DArray(arr, chunkSize) {

      var result = [];

      for (var i = 0; i < arr.length; i += chunkSize) {

        result.push(arr.slice(i, i + chunkSize));

      }

      return result;

    }



    var inputArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    var outputArray = convertTo2DArray(inputArray, 3);



    console.log(outputArray);

输出结果将是：

    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

slice 不会修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组，不信的话自己可以编译一下。

这段代码中的convertTo2DArray函数接受两个参数：arr表示输入的一维数组，chunkSize表示每个子数组的大小。它使用slice方法来从输入数组中提取每个子数组，并使用循环来遍历整个数组并构建输出二维数组。最后，它返回生成的二维数组。

3. 输出结果，为什么？

    const obj3 = {a: 1};

    const obj4 = {b: 2};

    console.log(obj3 == obj4);  // false

    console.log(obj3 === obj4); // false

结果：

false，false

原因：

在这段代码中，obj3和obj4分别是两个独立的对象，它们开辟的堆内存地址是完全不一样。==运算符用于比较两个操作数是否相等，而===运算符用于比较两个操作数是否严格相等。

根据对象的比较规则，当使用==运算符比较两个对象时，它们将会进行类型转换后再进行比较。由于obj3和obj4是不同的对象，即使它们的属性值相同，它们的引用也不同，因此在进行类型转换后，它们会被视为不相等的对象。因此，console.log(obj3 == obj4);的输出结果将会是false。

而在使用===运算符比较两个对象时，不会进行类型转换，而是直接比较两个操作数的值和类型是否完全相同。由于obj3和obj4是不同的对象，且类型也不同，即使它们的属性值相同，它们也不会被视为严格相等的对象。因此，console.log(obj3 === obj4);的输出结果同样会是false。

总结起来，无论是使用==运算符还是===运算符，obj3和obj4都不会被视为相等或严格相等的对象，因为它们是不同的对象。

4. this有关 输出结果，为什么？

    const obj1 = {

      fn: () => {

        return this

      }

    }

    const obj2 = {

      fn: function(){

        return this

      }

    }

    

    console.log(obj1.fn());

    console.log(obj2.fn());

输出结果：

1. window || undefined


2. obj2

原因是：

在箭头函数 fn 中的 this 关键字指向的是定义该函数的上下文，而不是调用该函数的对象。因此，当 obj1.fn() 被调用时，由于箭头函数没有它自己的this，当你调用fn()函数时，this指向会向上寻找，因此箭头函数中的 this 指向的是全局对象（在浏览器环境下通常是 window 对象），因此返回的是 undefined。

而在普通函数 fn 中的 this 关键字指向的是调用该函数的对象。在 obj2.fn() 中，函数 fn 是作为 obj2 的方法被调用的，所以其中的 this 指向的是 obj2 对象本身，因此返回的是 obj2。

需要注意的是，在严格模式下，普通函数中的 this 也会变为 undefined，因此即使是 obj2.fn() 也会返回 undefined。但在示例中没有明确指定使用严格模式，所以默认情况下运行在非严格模式下。

5. Promise有关输出结果，为什么？

    console.log('1');

    function promiseFn() {

      return new Promise((resolve, reject) => {

        setTimeout(()=> {

          console.log('2');

        })

        resolve('3');

        console.log('4')

      })

    }

    

    promiseFn().then(res => {

      console.log(res);

    });

输出结果： 1 4 3 2

原因是：

1. 首先，代码从上往下执行，把console.log('1')放入同步任务


2. 再调用promiseFn()，因为new Promise是同步任务，所以放入同步任务，继续执行


3. 遇到setTimout这个宏任务，放入宏任务队列中


4. 遇到resolve('3')，把res返回


5. 之后再执行.then()，因为promise.then是微任务，所以放入微任务队列


6. 代码是先执行同步任务，再执行微任务，之后再是宏任务


7. 所以输出结果为1 4 3 2

这里涉及到了EventLoop的执行机制，如果不是太清楚可以看看我的面试题：小男孩毕业之初次面试第二家公司第一题

6. 实现斐波那契的第N个值（从0开始），要求时间复杂度为O(n)

首先，说到斐波那契第一个想到的肯定是如下的算法，但这可是百度啊，如果只是这种程度的话如何能和同样面相同岗位的人竞争呢，所以我们得想到如下算法有什么缺点，然后如何优化

function fib(n) {

    if (n == 0 || n === 1) return 1;

    return fib(n - 1) + fib(n - 2);

};



console.log(fib(3)); // 5

console.log(fib(5)); // 8

单纯的使用递归看似没什么问题，也能运算出结果，但是里面有个致命的问题，首先，时间复杂度就不对，递归思想的复杂度为 O(2^n) ，它不为O(n)，然后还有会重复计算，比如计算n=3时，会计算fib(1) + fib(2)，再次计算fib(4)时，会先算fib(3) = fib(1) + fib(2)，然后再计算fib(4) = fib(1) + fib(2) + fib(3)，在这里，fib(1)和fib(2)重复计算了两次，对于性能损耗极大。此时的你如果对动态规划敏感的话，就会从中想到动态规划其中最关键的特征——重叠子问题

因此，使用动态规划来规避重复计算问题，算是比较容易想到较优的一种解法，并且向面试官展现了你算法能力中有动态规划的思想，对于在面试中的你加分是极大的。

以下是动态规划思路的算法，状态转移方程为dp[i] = dp[i-1] + dp[i-2]

function fibonacci(n) { 

    if (n <= 1) return n;

    let fib = [0, 1]; // 保存斐波那契数列的结果 

    for (let i = 2; i <= n; i++) { 

        fib[i] = fib[i - 1] + fib[i - 2]; // 计算第i个斐波那契数 

    } 

    return fib[n]; 

}

    

当然，你可能会说，在面试中怎么可能一下子就能想到动态规划，所以在面试前你需要背一背相关的状态转移方程，当你对算法问题分析到一定程度时，就能够记忆起这些状态转移方程，提高你写算法的速度。

在面试中，动态规划的常用状态转移方程可以根据问题的具体情况有所不同。以下是几个常见的动态规划问题和它们对应的状态转移方程示例：

1. 
   

   斐波那契数列（Fibonacci Sequence）：

   
   
   
   
   • dp[i] = dp[i-1] + dp[i-2]，其中 dp[i] 表示第 i 个斐波那契数。
   
   
   
   


2. 
   

   爬楼梯问题（Climbing Stairs）：

   
   
   
   
   • dp[i] = dp[i-1] + dp[i-2]，其中 dp[i] 表示爬到第 i 级楼梯的方法数。
   
   
   
   


3. 
   

   背包问题（Knapsack Problem）：

   
   
   
   
   • dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])，其中 dp[i][j] 表示在前 i 个物品中选择总重量不超过 j 的最大价值，weight[i] 表示第 i 个物品的重量，value[i] 表示第 i 个物品的价值。
   
   
   
   


4. 
   

   最长递增子序列（Longest Increasing Subsequence）：

   
   
   
   
   • dp[i] = max(dp[j] + 1, dp[i])，其中 dp[i] 表示以第 i 个元素结尾的最长递增子序列的长度，j 为 0 到 i-1 的索引，且 nums[i] > nums[j]。
   
   
   
   


5. 
   

   最大子数组和（Maximum Subarray Sum）：

   
   
   
   
   • dp[i] = max(nums[i], nums[i] + dp[i-1])，其中 dp[i] 表示以第 i 个元素结尾的最大子数组和。
   
   
   
   


6. 
   

   最长公共子序列（Longest Common Subsequence）：

   
   
   
   
   • 
     

     如果 str1[i] 等于 str2[j]，则 dp[i][j] = dp[i-1][j-1] + 1；

     
     
   
   
   • 
     

     否则，dp[i][j] = max(dp[i-1][j], dp[i][j-1])，其中 dp[i][j] 表示 str1 的前 i 个字符和 str2 的前 j 个字符的最长公共子序列的长度。

     
     
   
   
   
   


7. 
   

   编辑距离（Edit Distance）：

   
   
   
   
   • 
     

     如果 word1[i] 等于 word2[j]，则 dp[i][j] = dp[i-1][j-1]；

     
     
   
   
   • 
     

     否则，dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1，其中 dp[i][j] 表示将 word1 的前 i 个字符转换为 word2 的前 j 个字符所需的最少操作次数。

     
     
   
   
   
   


8. 
   

   打家劫舍（House Robber）：

   
   
   
   
   • dp[i] = max(dp[i-1], dp[i-2] + nums[i])，其中 dp[i] 表示前 i 个房屋能够获得的最大金额，nums[i] 表示第 i 个房屋中的金额。
   
   
   
   


9. 
   

   最大正方形（Maximal Square）：

   
   
   
   
   • 
     

     如果 matrix[i][j] 等于 1，则 dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1；

     
     
   
   
   • 
     

     否则，dp[i][j] = 0，其中 dp[i][j] 表示以 matrix[i][j] 为右下角的最大正方形的边长。

     
     
   
   
   
   

7. 手写EventBus

当需要手动实现一个简单的 EventBus 时，你可以创建一个全局的事件总线对象，并在该对象上定义事件的订阅和发布方法。

class EventBus {

  constructor() {

    this.events = {}; // 存储事件及其对应的回调函数列表

  }



  // 订阅事件

  subscribe(eventName, callback) {

    this.events[eventName] = this.events[eventName] || []; // 如果事件不存在，创建一个空的回调函数列表

    this.events[eventName].push(callback); // 将回调函数添加到事件的回调函数列表中

  }



  // 发布事件

  publish(eventName, data) {

    if (this.events[eventName]) {

     this.events[eventName].forEach(callback => {

        callback(data); // 执行回调函数，并传递数据作为参数

      });

    }

  }



  // 取消订阅事件

  unsubscribe(eventName, callback) {

    if (this.events[eventName]) {

      this.events[eventName] = this.events[eventName].filter(cb => cb !== callback); // 过滤掉要取消的回调函数

    }

  }

}

使用上述 EventBus 类，你可以执行以下操作：

// 创建全局事件总线对象

const eventBus = new EventBus();



const callback1 = data => {

  console.log('Callback 1:', data);

};



const callback2 = data => {

  console.log('Callback 2:', data);

};



// 订阅事件

eventBus.subscribe('event1', callback1);

eventBus.subscribe('event1', callback2);



// 发布事件

eventBus.publish('event1', 'Hello, world!');



// 输出：

// Callback 1: Hello, world!

// Callback 2: Hello, world!



// 取消订阅事件

eventBus.unsubscribe('event1', callback1);



// 发布事件

eventBus.publish('event1', 'Goodbye!');



// 输出：

// Callback 2: Goodbye!

在上述示例中，我们创建了一个 EventBus 类，该类具有 subscribe、publish 和 unsubscribe 方法。subscribe 方法用于订阅事件，publish 方法用于发布事件并触发相关的回调函数，unsubscribe 方法用于取消订阅事件。我们使用全局的 eventBus 对象来执行订阅和发布操作。

这个简单的 EventBus 实现允许你在不同的组件或模块之间发布和订阅事件，以实现跨组件的事件通信和数据传递。你可以根据需要对 EventBus 类进行扩展，添加更多的功能，如命名空间、一次订阅多个事件等。

当问到EventBus时，得预防面试官问到EvnetEmitter，不过当我在网上查找相关的资料时，发现很多人似乎都搞混了这两个概念，虽然我在这里的手写原理似乎也差不多，但在实际使用中，两者可能在细节上有所不同。因此，在具体场景中，你仍然需要根据需求和所选用的实现来查看相关文档或源码，以了解它们的具体实现和用法。

下面是一个简单的 EventEmitter 类实现的基本示例：

class EventEmitter {

  constructor() {

    this.events = {}; // 用于存储事件及其对应的回调函数列表

  }



  // 订阅事件

  on(eventName, callback) {

    this.events[eventName] = this.events[eventName] || []; // 如果事件不存在，创建一个空的回调函数列表

    this.events[eventName].push(callback); // 将回调函数添加到事件的回调函数列表中

  }



  // 发布事件

  emit(eventName, data) {

    if (this.events[eventName]) {

      this.events[eventName].forEach(callback => {

        callback(data); // 执行回调函数，并传递数据作为参数

      });

    }

  }



  // 取消订阅事件

  off(eventName, callback) {

    if (this.events[eventName]) {

      this.events[eventName] = this.events[eventName].filter(cb => cb !== callback); // 过滤掉要取消的回调函数

    }

  }

  

  // 添加一次性的事件监听器 

  once(eventName, callback) { 

      const onceCallback = data => { 

          callback(data); // 执行回调函数 

          this.off(eventName, onceCallback); // 在执行后取消订阅该事件 

      }; 

      this.on(eventName, onceCallback); 

  }

}

使用上述 EventEmitter 类，你可以执行以下操作：

    const emitter = new EventEmitter();



    const callback1 = data => {

      console.log('Callback 1:', data);

    };

   

    const callback2 = data => {

      console.log('Callback 2:', data);

    };

    

    // 添加一次性事件监听器 

    const onceCallback = data => { 

        console.log('Once Callback:', data); 

    };

    

    // 订阅事件

    emitter.on('event1', callback1);

    emitter.on('event1', callback2);

    emitter.once('event1', onceCallback);

    

    // 发布事件

    emitter.emit('event1', 'Hello, world!');



    // 输出：

    // Callback 1: Hello, world!

    // Callback 2: Hello, world!

    // Once Callback: Hello, world!

    

    // 取消订阅事件

    emitter.off('event1', callback1);



    // 发布事件

    emitter.emit('event1', 'Goodbye!');



    // 输出：

    // Callback 2: Goodbye!

在上述示例中，EventEmitter 类具有 on、emit 、 off和once 方法。on 方法用于订阅事件，emit 方法用于发布事件并触发相关的回调函数，off 方法用于取消订阅事件，once方法用于添加一次性的事件监听器。你可以根据需求对 EventEmitter 类进行扩展，添加更多的功能，比如一次订阅多个事件、取消所有事件订阅等。

eventBus,eventEmitter的区别

EventBus 和 EventEmitter 都是用于实现事件发布-订阅模式的工具，但它们在实现和使用上有一些区别。

1. 
   

   实现方式：

   
   
   
   
   • EventBus：EventBus 是一个全局的事件总线，通常是作为一个单例对象存在，用于在不同组件或模块之间传递事件和数据。在 Vue.js 中，Vue 实例可以充当 EventBus 的角色。
   
   
   • EventEmitter：EventEmitter 是一个基于类的模块，通常是作为一个实例对象存在，用于在单个组件或模块内部实现事件的发布和订阅。
   
   
   
   


2. 
   

   使用范围：

   
   
   
   
   • EventBus：EventBus 的作用范围更广泛，可以跨越不同组件、模块或文件进行事件的发布和订阅。它可以实现多个组件之间的通信和数据传递。
   
   
   • EventEmitter：EventEmitter 主要用于单个组件或模块内部，用于实现内部事件的处理和通信。
   
   
   
   


3. 
   

   依赖关系：

   
   
   
   
   • EventBus：EventBus 通常需要一个中央管理的实例，因此需要在应用程序的某个地方进行创建和管理。在 Vue.js 中，Vue 实例可以用作全局的 EventBus。
   
   
   • EventEmitter：EventEmitter 可以在需要的地方创建实例对象，并将其用于内部事件的发布和订阅。
   
   
   
   


4. 
   

   命名空间：

   
   
   
   
   • EventBus：EventBus 可以使用不同的事件名称来进行事件的区分和分类，可以使用命名空间来标识不同类型的事件。
   
   
   • EventEmitter：EventEmitter 通常使用字符串作为事件的名称，没有直接支持命名空间的概念。
   
   
   
   

总结起来，EventBus 主要用于实现跨组件或模块的事件通信和数据传递，适用于大型应用程序；而 EventEmitter 主要用于组件或模块内部的事件处理和通信，适用于小型应用程序或组件级别的事件管理。选择使用哪种工具取决于你的具体需求和应用场景。

8. （场景题）在浏览器中一天只能弹出一个弹窗，如何实现，说一下你的思路？

要在浏览器中实现一天只能弹出一个弹窗的功能，可以使用本地存储（localStorage）来记录弹窗状态。下面是一种实现方案：

1. 当页面加载时，检查本地存储中是否已存在弹窗状态的标记。


2. 如果标记不存在或者标记表示上一次弹窗是在前一天，则显示弹窗并更新本地存储中的标记为当前日期。


3. 如果标记存在且表示上一次弹窗是在当天，则不显示弹窗。

以下是示例代码：

    // 检查弹窗状态的函数

    function checkPopupStatus() {

      // 获取当前日期

      const currentDate = new Date().toDateString();



      // 从本地存储中获取弹窗状态标记

      const popupStatus = localStorage.getItem('popupStatus');



      // 如果标记不存在或者标记表示上一次弹窗是在前一天

      if (!popupStatus || popupStatus !== currentDate) {

        // 显示弹窗

        displayPopup();



        // 更新本地存储中的标记为当前日期

        localStorage.setItem('popupStatus', currentDate);

      }

    }



    // 显示弹窗的函数

    function displayPopup() {

      // 在这里编写显示弹窗的逻辑，可以是通过修改 DOM 元素显示弹窗，或者调用自定义的弹窗组件等

      console.log('弹出弹窗');

    }



    // 在页面加载时调用检查弹窗状态的函数

    checkPopupStatus();

在这个实现中，checkPopupStatus 函数会在页面加载时被调用。它首先获取当前日期，并从本地存储中获取弹窗状态的标记。如果标记不存在或者表示上一次弹窗是在前一天，就会调用 displayPopup 函数显示弹窗，并更新本地存储中的标记为当前日期。

通过这种方式，就可以确保在同一天只能弹出一个弹窗，而在后续的页面加载中不会重复弹窗。

9. 项目中的性能优化？

1. 
   

   对组件和图片进行懒加载：对暂时未使用的组件和图片使用懒加载可以显著地减少页面加载时间，比如在我的项目中路由配置中除了需要频繁切换的页面组件外，其他的组件都使用箭头函数引入组件进行懒加载，以及一些没有展现在界面的图片也进行了一个VueLazy的懒加载。

   
   


2. 
   

   减少HTTP请求数量：由于频繁的请求会对后端服务器造成极大的负担，所以应该减少不必要的请求，比如在我的项目中的搜索界面，对于搜索按钮增加了防抖功能

   
   


3. 
   

   使用缓存：使用浏览器缓存可以减少资源请求，从而提高页面加载速度。项目中我会把用户的一些需要持久化的信息存入本地存储。

   
   


4. 
   

   异步请求使用Promise.all：异步请求可以在后台加载资源，从而避免阻塞页面加载。在请求数据时，我会使用Promise.all一次性并行的请求类似的数据，而不需要一个一个的请求，较少了请求时间。

   
   


5. 
   

   图片优化：使用适当的图片格式和大小可以减少页面的资源请求和加载时间，项目中我会把图片转化成base64的格式和webp格式，这样可以使图片大小更小

   
   


6. 
   

   使用CDN加速：使用CDN可以提高资源的访问速度，从而加快页面加载速度。我项目中的一些第三方资源有时需要请求，因此我会使用CDN内容分发网络来提高访问速度。

   
   


7. 
   

   骨架屏（Skeleton Screen）：它可以提升用户感知的加载速度和用户体验。虽然骨架屏本身并不直接影响代码性能，但它可以改善用户对应用程序的感知，提供更好的用户体验。

   
   

10. 项目中遇到的难点，如何解决

1. 数据状态管理

前端登录状态管理

• 我在一个练手的项目中做前端登录功能的时候， 碰到了购物车需要登录判断的功能，比如用isLogin来判断有没有登录，当时由于没有深入了解vuex，所以我一开始想着把这个isLogin通过组件与组件的传值方法，把这个值传给相应的组件，然后在需要登录组件中进行判断，但后来发现这个方法太麻烦了


• 后来通过学习了解，使用了vuex这个全局状态管理的方法， 通过使用createStore这个vuex中的API创建了一个全局的登录状态，再通过actions mutations实现登录判断和登录状态共享

组件数据状态管理

• 我项目中一开始首页、详情页等其他页面越来越多的状态放在同一个store上，虽然感觉有点乱，但实现了数据流和组件开发的分离，使得我更能够专注于数据的管理


• 但随着数据的增多，感觉实在太乱了，然后得知vuex中可以使用 modules 来进行分模块，相应的页面放入相应的模块状态中，之后再用actions，mutations，state，getters这四件套， 更好的模块化管理数据，能够知道哪些状态是全局共享的（登录）， 哪些状态是模块共享的


• 然后在新的项目中，也就是现在简历上的项目里，尝试使用pinia来管理，因为我发现它更简单（没有mutations），模块化更好，让我对组件状态管理的更加得心应手，学习起来也更加的方便。

node的错误处理

• 一开始用node写后端的时候，一堆错误，比如路由没配置，数据库报错。使得后面的代码都无法运行，写着写着就感觉写不下去，经常一个错误就需要反复的在脑海中想最后依靠那一丝的灵光一闪才解决


• 之后我就在app.js这个后端入口文件的最后，添加一个统一的错误处理的中间件，向前端返回状态码和相应的信息后，直接使用next()向后继续执行，这样虽然服务器报了错，但仍然可以执行后续的代码。

跨域问题

• 在我写完前端项目的时候，想要提升一下自己，就转去学习了Koa，在搭建了大致的服务器，写了一个简单的接口并运行服务器后，我想当然的就在前端直接请求后端的端口，结果报了一个跨域的错误，由于当时初学后端，不怎么了解跨域，所以找了很多的解答并逐个在项目中进行尝试，比如跨域中的script，postMessage，html本身的Websocket


• 但发现最实用的还是在服务器中配置Access-Control-Allow-Origin来控制跨域请求的url地址，以及其他一些Access-Control-Allow头来控制跨域请求方法等，然后跨域请求url的白名单我放入了.env这个全局环境变量中。

axios响应拦截

• 在后端返回数据的时候，我返回数据有一个状态码以及添加到data这个需要返回的数据（代码如下），这导致我在获取接口里的数据时需要多.data(引用一层data)，当时我没意识到，结果一直获取不到数据。之后输出获取的数据才发现在数据外面包了一层，虽然这个时候解决了服务器那边数据返回的问题，但后面每次获取数据时都需要在往里再获取，非常的麻烦。


• 最后在学习了并在项目中使用axios进行请求和响应后，就在响应的时候设置一个拦截器，对响应进行一番处理之后就可以直接拿到后端接口返回的值，而不会导致接口返回的值不会有太多的嵌套了。

11. 如何学习前端的，学了几年？

这个就看个人情况了，但其中，你得展现出你的学习积极性和对前端的热爱，让面试官能够欣赏你

我大致说说我回答的，仅作参考

我从大二开始就对前端很感兴趣，当时正好学校也分了Web前端的方向，于是就跟着学校的课程开始学习基本的html，css，js三剑客，但之后感觉到老师教的很慢，就自己到B站上学习了，之后由于参加过一次蓝桥杯，就看到了蓝桥云课上有相关的基于html，css，js比较基础项目，接着我还学习了一些行内大牛写的一些博客文章，比如阮一峰，张鑫旭，廖雪峰等这些老师。之后又学习了vue并且在GitHub上学习相关的设计理念，根据GitHub上项目中不懂的东西又逐渐学习了各种UI组件库和数据请求方式，最后又学习了Nodejs中的Koa，用Vue和Koa仿写了一个全栈型项目，目前正在学习一些typescript的基本用法并尝试着运用到项目中，并在学习Vue的一些底层源码。

结语及吐槽

大厂的面试终归到底还是和我之前面的公司不一样，它们更加看重的是代码底层的实现和你的算法基础，终归到底，这次面试只是一次小尝试，想要知道自己的水平到底在哪里，并且能够借此完善自己的能力，努力的提升自己，希望能够给

展示效果

（因为掘金不能上传视频，所以转成动图之后分辨率比较低，还望多包涵）

展示都是基于 Slow 3G 弱网下的效果。

优化前

这种体验交较差，在图片下载完之前，本应该展示图片的区域会长时间空白。

优化后

图片下载过程中显示模糊的图片占位符，直到图片下载完成再切换展示。

原理

首先先贴出页面的代码 index.html:

<!DOCTYPE html>

<html lang="en">

  <head>

    <meta charset="UTF-8" />

    <meta name="viewport" content="width=device-width, initial-scale=1.0" />

    <title>Document</title>

  </head>

  <style>

    html,

    body {

      margin: 0;

      padding: 0;

    }



    @keyframes pulse {

      0% {

        opacity: 0;

      }

      50% {

        opacity: 0.1;

      }

      100% {

        opacity: 0;

      }

    }



    .container {

      width: 50vw;

      background-repeat: no-repeat;

      background-size: cover;

    }



    .container.loaded::before {

      animation: none;

      content: none;

    }



    .container::before {

      content: '';

      position: absolute;

      inset: 0;

      opacity: 0;

      animation: pulse 2.5s infinite;

      background-color: var(--text-color);

    }



    .container img,

    .container video {

      opacity: 0;

      transition: opacity 250ms ease-in-out;

    }



    .container.loaded img,

    .container.loaded video {

      opacity: 1;

    }

  </style>

  <body>

    <!-- container容器加载一个体积非常小的低分辨率图片 -->

    <div class="container" style="background-image: url(http://localhost:3000/uploads/10007/fox-small.jpeg);">

      <!-- 图片延时加载 loading: lazy -->

      <img

        src="http://localhost:3000/uploads/10007/fox.jpeg"

        loading="lazy"

        style="width: 50vw"

      />

    </div>

    

    <br/>



    <video

      id="video"

      autoplay

      controls="controls"

      style="width: 50vw"

      poster="http://localhost:3000/uploads/10007/big_buck_bunny-small.png"

      src="http://localhost:3000/uploads/10007/big_buck_bunny.mp4"

    ></video>

  </body>

  <script>

    const blurredImageDiv = document.querySelector('.container');

    const img = blurredImageDiv.querySelector('img');

    function loaded() {

      // 图片下载完之后 再展示

      blurredImageDiv.classList.add('loaded');

    }



    if (img.complete) {

      loaded();

    } else {

      img.addEventListener('load', loaded);

    }

    

    var poster = new Image();

    poster.onload = function () {

      // 加载完之后替换 poster url 不会重复请求

      const video = document.querySelector('#video');

      video.poster = 'http://localhost:3000/uploads/10007/big_buck_bunny.png';

    };

    poster.src = 'http://localhost:3000/uploads/10007/big_buck_bunny.png';

  </script>

</html>

其实原理就是基于原图片生成出一个低分辨率体积非常小的图片（因为体积小，下载会很快），然后作为占位符显示，直到原图片完全下载之后再替换展示原图片。

那么如何生成一个超低分辨率的占位图片呢，可以使用 ffmpeg，需要本地提前安装，我是用的MacOS系统，所以直接通过 brew install ffmpeg 安装了。

如果是服务使用 Docker 部署的话，可参考：

FROM node:16 AS deps

WORKDIR /app

COPY . .

RUN wget https://www.johnvansickle.com/ffmpeg/old-releases/ffmpeg-4.4.1-arm64-static.tar.xz &&\

    tar xvf ffmpeg-4.4.1-arm64-static.tar.xz &&\

    mv ffmpeg-4.4.1-arm64-static/ffmpeg /usr/bin/ &&\

    mv ffmpeg-4.4.1-arm64-static/ffprobe /usr/bin/ 

#RUN apt install -y ffmpeg

RUN yarn install

RUN yarn build

EXPOSE 3000

ENV PORT 3000

CMD [ "node", "dist/index.js" ]

ffmpeg -i sourcePath.jpg -vf scale=width:height outputPath.jpg

// 约束比例压缩

// width/height 为压缩之后图片的宽高 当其中一个值为 -1 的时候将保持原来的尺寸比例压缩

那么我们可以有如下命令：

ffmpeg -i sourcePath.jpg -vf scale=20:-1 outputPath.jpg

// 压缩之后生成 20 像素宽的图片用于做占位符展示

我们可以写个文件上传的服务，上传图片之后，服务端自动生成一个低分辨率的图片版本，然后将两者的地址url都返回过来。比如 Node 中我们可以使用 fluent-ffmpeg，那么以上命令就对应成代码：

import * as ffmpeg from 'fluent-ffmpeg';

import { FfmpegCommand } from 'fluent-ffmpeg';



export const runFfmpegCmd = (command: FfmpegCommand) =>

  new Promise<void>((resolve, reject) => {

    command

      .on('error', (error) => {

        reject(error);

      })

      .on('end', () => {

        resolve();

      })

      .run();

  });





public async uploadImage(user: User.UserInfo, file: Express.Multer.File) {

    console.log(file);

    const path = join(this.uploadPath, `${user.id}`, '/');



    await ensureDir(path);



    const { originalname, path: filePath } = file;

    const finalPath = path + originalname;

    const name = originalname.split('.');

    const smallPath = path + name[0] + '-small.' + name[1];

    console.log(smallPath);

    await rename(filePath, finalPath);



    // size 对应 scale=20:-1

    await runFfmpegCmd(ffmpeg(finalPath).size('20x?').output(smallPath));



    return {

      statusCode: HttpStatus.OK,

      data: {

        path: finalPath,

        smallPath,

      },

    };

  }

  

public async uploadVideo(user: User.UserInfo, file: Express.Multer.File) {

    console.log(file);

    const path = join(this.uploadPath, `${user.id}`, '/');



    await ensureDir(path);



    const { originalname, path: filePath } = file;

    const finalPath = path + originalname;

    const name = originalname.split('.');

    const shotName = name[0] + '.png';

    const smallName = name[0] + '-small.png';



    await rename(filePath, finalPath);



    // 生成两个不同分辨率的缩略图

    await Promise.all([

      runScreenShotCmd(

        ffmpeg(finalPath).screenshot({

          count: 1,

          filename: shotName,

          folder: path,

        }),

      ),

      runScreenShotCmd(

        ffmpeg(finalPath).screenshot({

          count: 1,

          filename: smallName,

          folder: path,

          size: '20x?',

        }),

      ),

    ]);



    return {

      statusCode: HttpStatus.OK,

      data: {

        path: finalPath,

        shotPath: path + shotName,

        smallPath: path + smallName,

      },

    };

  }

代码在自己的github上：im_server

自己本地的 swagger 界面的上传截图：

图片

视频

那么我们就可以得到一个超低分辨率的图片了，由于体积非常小，所以下载很快（特别是弱网情况下）。

补充

关于 img 标签的 lazy load 可参考：浏览器IMG图片原生懒加载loading=”lazy”实践指南

使用 img 的 srcset 属性可实现根据不同屏幕分辨率加载不同尺寸的图片，进一步提升用户体验，而且没必要在小屏幕中加载超大分辨率的图片：响应式图片

结论

通过使用超低分辨率的占位符图片可以优化用户体验，特别是一些图片素材网站，再结合 img 标签的 loading="lazy"