前端面试

客官°小女子只卖身不卖艺 2022-02-20 14:06 293阅读 0赞

## [前端面试之道][Link 1] ##

--------------------

### JS 基础知识点及常考面试题 ###

> 原始（Primitive）类型

面试题：原始类型有哪几种？null 是对象嘛？

在 JS 中，存在着 6 种原始值，分别是：

*  boolean
 *  null
 *  undefined
 *  number
 *  string
 *  symbol

首先原始类型存储的都是值，是没有函数可以调用的

> 对象（Object）类型

面试题：对象类型和原始类型的不同之处？函数参数是对象会发生什么问题？

在 JS 中，除了原始类型那么其他的都是对象类型了。对象类型和原始类型不同的是，原始类型存储的是值，对象类型存储的是地址。

*  首先，函数传参是传递对象指针的副本
 *  到函数内部修改参数的属性这步，我相信大家都知道，当前 p1 的值也被修改了
 *  但是当我们重新为了 person 分配了一个对象时就出现了分歧

> typeof vs instanceof

面试题：typeof 是否能正确判断类型？instanceof 能正确判断对象的原理是什么？

typeof 对于**原始类型**来说，除了 null 都可以显示正确的类型

typeof 对于对象来说，除了函数都会显示 object，所以说 typeof 并不能准确判断变量到底是什么类型

如果我们想判断一个**对象**的正确类型，这时候可以考虑使用 instanceof，因为内部机制是通过**原型链**来判断的

> 类型转换

面试题：该知识点常在笔试题中见到，熟悉了转换规则就不惧怕此类题目了。

首先我们要知道，在 JS 中类型转换只有三种情况，分别是：

*  转换为布尔值
 *  转换为数字
 *  转换为字符串

> this

面试题：如何正确判断 this？箭头函数的 this 是什么？

![006tNbRwly1fynwrmq5utj30ko0ermx8.jpg][]

> == vs ===

面试题：== 和 === 有什么区别？

![006tNbRwly1fynwzkitedj30rx0buglx.jpg][]

思考题：看完了上面的步骤，对于 \[\] == !\[\] 你是否能正确写出答案呢？

> 闭包

面试题：什么是闭包？

闭包的定义其实很简单：函数 A 内部有一个函数 B，函数 B 可以访问到函数 A 中的变量，那么函数 B 就是闭包。

在 JS 中，闭包存在的意义就是让我们可以间接访问函数内部的变量。

面试题，循环中使用闭包解决 `var` 定义函数的问题

// 首先因为 setTimeout 是个异步函数，所以会先把循环全部执行完毕，这时候 i 就是 6 了，所以会输出一堆 6。
    
    for (var i = 1; i <= 5; i++) { 
      setTimeout(function timer() { 
        console.log(i)
      }, i * 1000)
    }

// 解决办法有三种，第一种是使用闭包的方式
    
    for (var i = 1; i <= 5; i++) { 
      ;(function(j) { 
        setTimeout(function timer() { 
          console.log(j)
        }, j * 1000)
      })(i)
    }
    
    // 在上述代码中，我们首先使用了立即执行函数将 i 传入函数内部，这个时候值就被固定在了参数 j 上面不会改变，当下次执行 timer 这个闭包的时候，就可以使用外部函数的变量 j，从而达到目的。
    
    // 第二种就是使用 setTimeout 的第三个参数，这个参数会被当成 timer 函数的参数传入。
    
    for (var i = 1; i <= 5; i++) { 
      setTimeout(
        function timer(j) { 
          console.log(j)
        },
        i * 1000,
        i
      )
    }
    
    // 第三种就是使用 let 定义 i 了来解决问题了，这个也是最为推荐的方式
    
    for (let i = 1; i <= 5; i++) { 
      setTimeout(function timer() { 
        console.log(i)
      }, i * 1000)
    }

> 深浅拷贝

面试题：什么是浅拷贝？如何实现浅拷贝？什么是深拷贝？如何实现深拷贝？

> 原型

面试题：如何理解原型？如何理解原型链？

*  Object 是所有对象的爸爸，所有对象都可以通过 **proto** 找到它
 *  Function 是所有函数的爸爸，所有函数都可以通过 **proto** 找到它
 *  函数的 prototype 是一个对象
 *  对象的 **proto** 属性指向原型， **proto** 将对象和原型连接起来组成了原型链

--------------------

### [ES6 知识点及常考面试题][ES6] ###

> var、let 及 const 区别

面试题：什么是提升？什么是暂时性死区？var、let 及 const 区别？

*  **函数提升优先于变量提升**，函数提升会把整个函数挪到作用域顶部，变量提升只会把声明挪到作用域顶部
 *  var 存在**提升**，我们能在声明之前使用。let、const 因为暂时性死区的原因，不能在声明前使用
 *  var 在全局作用域下声明变量会导致变量挂载在 window 上，其他两者不会
 *  let 和 const 作用基本一致，但是后者声明的变量不能再次

> 原型继承和 Class 继承

面试题：原型如何实现继承？Class 如何实现继承？Class 本质是什么？

*  组合继承
 *  寄生组合继承
 *  Class 继承

> 模块化

面试题：为什么要使用模块化？都有哪几种方式可以实现模块化，各有什么特点？

使用一个技术肯定是有原因的，那么使用模块化可以给我们带来以下好处

*  解决命名冲突
 *  提供复用性
 *  提高代码可维护性

> Proxy

面试题：Proxy 可以实现什么功能？

> map, filter, reduce

面试题：map, filter, reduce 各自有什么作用？

map 作用是生成一个新数组，遍历原数组，将每个元素拿出来做一些变换然后放入到新的数组中。

// 把Array的所有数字转为字符串：
    
    [1, 2, 3, 4, 5, 6, 7, 8, 9].map(String)

filter 的作用也是生成一个新数组，在遍历数组的时候将返回值为 true 的元素放入新数组，我们可以利用这个函数删除一些不需要的元素

“筛选”函数

// 把一个Array中的空字符串删掉，可以这么写：
    
    var arr = ['A', '', 'B', null, undefined, 'C', ' '];
    var r = arr.filter(function (s) { 
        return s && s.trim(); // 注意：IE9以下的版本没有trim()方法
    });
    r; // ['A', 'B', 'C']

Array的reduce()把一个函数作用在这个Array的\[x1, x2, x3…\]上，这个函数必须接收两个参数，reduce()把结果继续和序列的下一个元素做累积计算，其效果就是：\[x1, x2, x3, x4\].reduce(f) = f(f(f(x1, x2), x3), x4)

// 比方说对一个Array求和，就可以用reduce实现
    
    var arr = [1, 3, 5, 7, 9];
    arr.reduce(function (x, y) { 
        return x + y;
    }); // 25

--------------------

### JS 异步编程及常考面试题 ###

> 并发（concurrency）和并行（parallelism）区别

面试题：并发与并行的区别？

*  并发是**宏观**概念，我分别有任务 A 和任务 B，在**一段时间内**通过任务间的切换完成了这两个任务，这种情况就可以称之为并发。
 *  并行是**微观**概念，假设 CPU 中存在两个核心，那么我就可以同时完成任务 A、B。同时完成多个任务的情况就可以称之为并行。

> 回调函数（Callback）

面试题：什么是回调函数？回调函数有什么缺点？如何解决回调地狱问题？

> Generator

面试题：你理解的 Generator 是什么？

当然，我们可以通过 Generator 函数解决回调地狱的问题，可以把之前的回调地狱例子改写为如下代码：

> Promise

面试题：Promise 的特点是什么，分别有什么优缺点？什么是 Promise 链？Promise 构造函数执行和 then 函数执行有什么区别？

Promise 翻译过来就是承诺的意思，这个承诺会在未来有一个确切的答复，并且该承诺有三种状态，分别是：

*  等待中（pending）
 *  完成了 （resolved）
 *  拒绝了（rejected）

当然了，Promise 也很好地解决了回调地狱的问题，可以把之前的回调地狱例子改写为如下代码：

> async 及 await

面试题：async 及 await 的特点，它们的优点和缺点分别是什么？await 原理是什么？

> 常用定时器函数

面试题：setTimeout、setInterval、requestAnimationFrame 各有什么特点？

--------------------

### 手写 Promise ###

[Promises/A+规范][Promises_A]

--------------------

### Event Loop ###

> 进程与线程

面试题：进程与线程区别？JS 单线程带来的好处？

JS 是单线程执行的

讲到线程，那么肯定也得说一下进程。本质上来说，两个名词都是 **CPU 工作时间片**的一个描述。

进程描述了 CPU 在**运行指令及加载和保存上下文所需的时间**，放在应用上来说就代表了一个程序。线程是进程中的更小单位，描述了**执行一段指令所需的时间**。

把这些概念拿到浏览器中来说，当你打开一个 Tab 页时，其实就是创建了一个进程，一个进程中可以有多个线程，比如渲染线程、JS 引擎线程、HTTP 请求线程等等。当你发起一个请求时，其实就是创建了一个线程，当请求结束后，该线程可能就会被销毁。

上文说到了 JS 引擎线程和渲染线程，大家应该都知道，在 JS 运行的时候可能会阻止 UI 渲染，这说明了两个线程是互斥的。这其中的原因是因为 JS 可以修改 DOM，如果在 JS 执行的时候 UI 线程还在工作，就可能导致不能安全的渲染 UI。这其实也是一个单线程的好处，得益于 JS 是单线程运行的，可以达到节省内存，节约上下文切换时间，没有锁的问题的好处。当然前面两点在服务端中更容易体现，对于锁的问题，形象的来说就是当我读取一个数字 15 的时候，同时有两个操作对数字进行了加减，这时候结果就出现了错误。解决这个问题也不难，只需要在读取的时候加锁，直到读取完毕之前都不能进行写入操作。

> 执行栈

面试题：什么是执行栈？

可以把执行栈认为是一个存储函数调用的栈结构，遵循先进后出的原则。

Call Stack ：函数调用（call）时进栈，函数返回（return）时出栈。

> 浏览器中的 Event Loop

面试题：异步代码执行顺序？解释一下什么是 Event Loop ？

当我们执行 JS 代码的时候其实就是往执行栈中放入函数，那么遇到异步代码的时候该怎么办？其实当遇到异步的代码时，会被挂起并在需要执行的时候加入到 Task（有多种 Task） 队列中。一旦执行栈为空，Event Loop 就会从 Task 队列中拿出需要执行的代码并放入执行栈中执行，所以本质上来说 JS 中的异步还是同步行为。

不同的任务源会被分配到不同的 Task 队列中，任务源可以分为 微任务（microtask） 和 宏任务（macrotask）。在 ES6 规范中，microtask 称为 jobs，macrotask 称为 task。

所以 Event Loop 执行顺序如下所示：

*  首先执行同步代码，这属于宏任务
 *  当执行完所有同步代码后，执行栈为空，查询是否有异步代码需要执行
 *  执行所有微任务
 *  当执行完所有微任务后，如有必要会渲染页面
 *  然后开始下一轮 Event Loop，执行宏任务中的异步代码，也就是 setTimeout 中的回调函数

微任务包括 process.nextTick ，promise ，MutationObserver。

宏任务包括 script ， setTimeout ，setInterval ，setImmediate ，I/O ，UI rendering。

> Node 中的 Event Loop

面试题：Node 中的 Event Loop 和浏览器中的有什么区别？process.nexttick 执行顺序？

--------------------

### JS 进阶知识点及常考面试题 ###

> 手写 call、apply 及 bind 函数

面试题：call、apply 及 bind 函数内部实现是怎么样的？

> new

面试题：new 的原理是什么？通过 new 的方式创建对象和通过字面量创建有什么区别？

在调用 new 的过程中会发生以上四件事情：

*  新生成了一个对象
 *  链接到原型
 *  绑定 this
 *  返回新对象

> instanceof 的原理

面试题：instanceof 的原理是什么？

instanceof 可以**正确的判断对象的类型**，因为内部机制是通过判断对象的原型链中是不是能找到类型的 prototype。

> 为什么 0.1 + 0.2 != 0.3

面试题：为什么 0.1 + 0.2 != 0.3？如何解决这个问题？

先说原因，因为 JS 采用 **IEEE 754 双精度版本（64位）**，并且只要采用 IEEE 754 的语言都有该问题。

> 垃圾回收机制

面试题：V8 下的垃圾回收机制是怎么样的？

V8 实现了准确式 GC，GC 算法采用了分代式垃圾回收机制。因此，V8 将内存（堆）分为新生代和老生代两部分。

> 新生代算法

新生代中的对象一般存活时间较短，使用 Scavenge GC 算法。

> 老生代算法

老生代中的对象一般存活时间较长且数量也多，使用了两个算法，分别是标记清除算法和标记压缩算法。

--------------------

### JS 思考题 ###

> 思考题一：JS 分为哪两大类型？都有什么各自的特点？你该如何判断正确的类型？

*  对于原始类型来说，你可以指出 null 和 number 存在的一些问题。对于对象类型来说，你可以从垃圾回收的角度去切入，也可以说一下对象类型存在深浅拷贝的问题。
 *  对于判断类型来说，你可以去对比一下 typeof 和 instanceof 之间的区别，也可以指出 instanceof 判断类型也不是完全准确的。

> 思考题二：你理解的原型是什么？

起码说出原型小节中的总结内容，然后还可以指出一些小点，比如并不是所有函数都有 prototype 属性，然后引申出原型链的概念，提出如何使用原型实现继承，继而可以引申出 ES6 中的 class 实现继承。

> 思考题三：bind、call 和 apply 各自有什么区别？

首先肯定是说出三者的不同，如果自己实现过其中的函数，可以尝试说出自己的思路。然后可以聊一聊 this 的内容，有几种规则判断 this 到底是什么，this 规则会涉及到 new，那么最后可以说下自己对于 new 的理解。

> 思考题四：ES6 中有使用过什么？

这边可说的实在太多，你可以列举 1 - 2 个点。比如说说 class，那么 class 又可以拉回到原型的问题；可以说说 promise，那么线就被拉到了异步的内容；可以说说 proxy，那么如果你使用过 Vue 这个框架，就可以谈谈响应式原理的内容；同样也可以说说 let 这些声明变量的语法，那么就可以谈及与 var 的不同，说到提升这块的内容。

> 思考题五：JS 是如何运行的？

这其实是很大的一块内容。你可以先说 JS 是单线程运行的，这里就可以说说你理解的线程和进程的区别。然后讲到执行栈，接下来的内容就是涉及 Eventloop 了，微任务和宏任务的区别，哪些是微任务，哪些又是宏任务，还可以谈及浏览器和 Node 中的 Eventloop 的不同，最后还可以聊一聊 JS 中的垃圾回收。

--------------------

### DevTools Tips ###

> Elements

*  Element 状态
 *  快速定位 Element
 *  DOM 断点
 *  查看事件
 *  找到之前查看过的 DOM 元素

> Debugging

*  给循环中的某次打断点

--------------------

### 浏览器 ###

> 事件机制

面试题：事件的触发过程是怎么样的？知道什么是事件代理嘛？

事件触发有三个阶段：

*  window 往事件触发处传播，遇到注册的捕获事件会触发
 *  传播到事件触发处时触发注册的事件
 *  从事件触发处往 window 传播，遇到注册的冒泡事件会触发

事件触发一般来说会按照上面的顺序进行，但是也有特例，如果给一个 body 中的子节点同时注册冒泡和捕获事件，事件触发会按照注册的顺序执行。

> 跨域

面试题：什么是跨域？为什么浏览器要使用同源策略？你有几种方式可以解决跨域问题？了解预检请求嘛？

因为浏览器出于**安全考虑**，有同源策略。也就是说，如果协议、域名或者端口有一个不同就是跨域，Ajax 请求会失败。

那么是出于什么安全考虑才会引入这种机制呢？ 其实主要是用来**防止 CSRF 攻击**的。简单点说，CSRF 攻击是利用用户的登录态发起恶意请求。

接下来我们将来学习几种常见的方式来解决跨域的问题

*  JSONP：JSONP 的原理很简单，就是利用

> 存储

面试题：有几种方式可以实现存储功能，分别有什么优缺点？什么是 Service Worker？

cookie，localStorage，sessionStorage，indexDB

Service Worker 是运行在浏览器背后的独立线程，一般可以用来实现缓存功能。使用 Service Worker的话，传输协议必须为 HTTPS。因为 Service Worker 中涉及到请求拦截，所以必须使用 HTTPS 协议来保障安全。当我们重新刷新页面可以发现我们缓存的数据是从 Service Worker 中读取的。

> 缓存机制

缓存可以说是性能优化中简单高效的一种优化方式了，它可以显著减少网络传输所带来的损耗。

*  缓存位置
    
    1.  Service Worker
    2.  Memory Cache
    3.  Disk Cache
    4.  Push Cache
    5.  网络请求
 *  缓存策略
    
    1.  强缓存
    2.  协商缓存
 *  实际场景应用缓存策略
    
    1.  频繁变动的资源
    2.  代码文件

> 渲染原理

首先，浏览器接收到 HTML 文件并转换为 DOM 树  
![006tNc79ly1fyvtu4uazvj30m203x749.jpg][]

其次，将 CSS 文件转换为 CSSOM 树  
![006tNc79ly1fyvtw94lh1j30lm04b3yi.jpg][]

最后，生成渲染树  
当我们生成 DOM 树和 CSSOM 树以后，就需要将这两棵树组合为渲染树。

*问题*：为什么操作 DOM 慢？

因为 DOM 是属于渲染引擎中的东西，而 JS 又是 JS 引擎中的东西。当我们通过 JS 操作 DOM 的时候，其实这个操作涉及到了**两个线程之间的通信**，那么势必会带来一些性能上的损耗。操作 DOM 次数一多，也就等同于一直在进行线程之间的通信，并且操作 DOM 可能还会带来重绘回流的情况，所以也就导致了性能上的问题。

*面试题*：插入几万个 DOM，如何实现页面不卡顿？

不能一次性把几万个 DOM 全部插入，这样肯定会造成卡顿，所以解决问题的重点应该是如何分批次部分渲染 DOM。大部分人应该可以想到通过 requestAnimationFrame 的方式去循环的插入 DOM，其实还有种方式去解决这个问题：虚拟滚动（virtualized scroller）。

这种技术的原理就是只渲染可视区域内的内容，非可见区域的那就完全不渲染了，当用户在滚动的时候就实时去替换渲染的内容。

*问题*：什么情况阻塞渲染？

首先渲染的前提是生成渲染树，所以 **HTML 和 CSS 肯定会阻塞渲染**。如果你想渲染的越快，你越应该降低一开始需要渲染的文件大小，并且扁平层级，优化选择器。

然后当浏览器在解析到 **script 标签**时，会暂停构建 DOM，完成后才会从暂停的地方重新开始。也就是说，如果你想首屏渲染的越快，就越不应该在首屏就加载 JS 文件，这也是都建议将 script 标签放在 body 标签底部的原因。

当然在当下，并不是说 script 标签必须放在底部，因为你可以给 script 标签添加 defer 或者 async 属性。

当 script 标签加上 defer 属性以后，表示该 JS 文件会并行下载，但是会放到 HTML 解析完成后顺序执行，所以对于这种情况你可以把 script 标签放在任意位置。

对于没有任何依赖的 JS 文件可以加上 async 属性，表示 JS 文件下载和解析不会阻塞渲染。

*问题*：减少重绘和回流？

重绘和回流会在我们设置节点样式时频繁出现，同时也会很大程度上影响性能。

重绘（Repaint）是当节点需要更改外观而不会影响布局的，比如改变 color 就叫称为重绘

回流（Reflow）是布局或者几何属性需要改变就称为回流。

回流必定会发生重绘，重绘不一定会引发回流。回流所需的成本比重绘高的多，改变父节点里的子节点很可能会导致父节点的一系列回流。

减少重绘和回流的方式：

*  使用 transform 替代 top
 *  使用 visibility 替换 display: none ，因为前者只会引起重绘，后者会引发回流（改变了布局）
 *  不要把节点的属性值放在一个循环里当成循环里的变量
 *  不要使用 table 布局，可能很小的一个小改动会造成整个 table 的重新布局
 *  动画实现的速度的选择，动画速度越快，回流次数越多，也可以选择使用 requestAnimationFrame
 *  CSS 选择符从右往左匹配查找，避免节点层级过多
 *  将频繁重绘或者回流的节点设置为图层，图层能够阻止该节点的渲染行为影响别的节点。比如对于 video 标签来说，浏览器会自动将该节点变为图层。设置节点为图层的方式有很多，我们可以通过以下几个常用属性可以生成新图层
    
     *  will-change
     *  video、iframe 标签

*思考题*：在不考虑缓存和优化网络协议的前提下，考虑可以通过哪些方式来最快的渲染页面，也就是常说的关键渲染路径，这部分也是性能优化中的一块内容。

提示如何加速：

*  从文件大小考虑
 *  从 script 标签使用上来考虑
 *  从 CSS、HTML 的代码书写上来考虑
 *  从需要下载的内容是否需要在首屏使用上来考虑

--------------------

### 安全防范知识点 ###

> XSS

面试题：什么是 XSS 攻击？如何防范 XSS 攻击？什么是 CSP？

攻击者想尽一切办法**将可以执行的代码注入到网页**中。

XSS 可以分为多种类型，但是总体上我认为分为两类：持久型和非持久型。

持久型也就是攻击的代码被服务端写入进数据库中，这种攻击危害性很大，因为如果网站访问量很大的话，就会导致大量正常访问页面的用户都受到攻击。

非持久型相比于前者危害就小的多了，一般通过修改 URL 参数的方式加入攻击代码，诱导用户访问链接从而进行攻击。

对于 XSS 攻击来说，通常有两种方式可以用来防御。

*  转义字符
 *  CSP（建立白名单）：开发者明确告诉浏览器哪些外部资源可以加载和执行。我们只需要配置规则，如何拦截是由浏览器自己实现的。

> CSRF

面试题：什么是 CSRF 攻击？如何防范 CSRF 攻击？

CSRF 中文名为跨站请求伪造。原理就是攻击者构造出一个**后端请求地址**，诱导用户点击或者通过某些途径自动发起请求。如果用户是在登录状态下的话，后端就以为是用户在操作，从而进行相应的逻辑。

如何防御？

*  SameSite
 *  验证 Referer
 *  Token

> 点击劫持

面试题：什么是点击劫持？如何防范点击劫持？

点击劫持是一种**视觉欺骗**的攻击手段。攻击者将需要攻击的网站通过 iframe 嵌套的方式嵌入自己的网页中，并将 iframe 设置为透明，在页面中透出一个按钮诱导用户点击。

对于这种攻击方式，推荐防御的方法有两种。

*  X-FRAME-OPTIONS
 *  JS 防御

> 中间人攻击

面试题：什么是中间人攻击？如何防范中间人攻击？

中间人攻击是攻击方**同时与服务端和客户端建立起了连接**，并让对方认为连接是安全的，但是实际上整个通信过程都被攻击者控制了。攻击者不仅能获得双方的通信信息，还能修改通信信息。

通常来说**不建议使用公共的 Wi-Fi**，因为很可能就会发生中间人攻击的情况。如果你在通信的过程中涉及到了某些敏感信息，就完全暴露给攻击方了。

当然防御中间人攻击其实并不难，只需要增加一个安全通道来传输信息。HTTPS 就可以用来防御中间人攻击，但是并不是说使用了 HTTPS 就可以高枕无忧了，因为如果你没有完全关闭 HTTP 访问的话，攻击方可以通过某些方式将 HTTPS 降级为 HTTP 从而实现中间人攻击。

--------------------

### 性能优化 ###

> 测试性能工具

*  可以通过 Audit 工具获得网站的多个指标的性能报告
 *  可以通过 Performance 工具了解网站的性能瓶颈

> JS 性能优化

*  可以通过 Performance API 具体测量时间
 *  为了减少编译时间，我们可以采用减少代码文件的大小或者减少书写嵌套函数的方式
 *  为了让 V8 优化代码，我们应该尽可能保证传入参数的类型一致。这也给我们带来了一个思考，这是不是也是使用 TypeScript 能够带来的好处之一

> 图片优化

*  计算图片大小
    
     *  减少像素点
     *  减少每个像素点能够显示的颜色
 *  图片加载优化
    
    1.  不用图片。很多时候会使用到很多修饰类图片，其实这类修饰图片完全可以用 CSS 去代替。
    2.  对于移动端来说，屏幕宽度就那么点，完全没有必要去加载原图浪费带宽。一般图片都用 CDN 加载，可以计算出适配屏幕的宽度，然后去请求相应裁剪好的图片。
    3.  小图使用 base64 格式
    4.  将多个图标文件整合到一张图片中（雪碧图）
    5.  选择正确的图片格式：
        
         *  对于能够显示 **WebP 格式**的浏览器尽量使用 WebP 格式。因为 WebP 格式具有更好的图像数据压缩算法，能带来更小的图片体积，而且拥有肉眼识别无差异的图像质量，缺点就是兼容性并不好
         *  **小图使用 PNG**，其实对于大部分图标这类图片，完全可以使用 SVG 代替
         *  **照片使用 JPEG**

> DNS 预解析

DNS 解析也是需要时间的，可以通过预解析的方式来预先获得域名所对应的 IP。

> 节流

考虑一个场景，**滚动事件**中会发起网络请求，但是我们并不希望用户在滚动过程中一直发起请求，而是隔一段时间发起一次，对于这种情况我们就可以使用节流。

> 防抖

考虑一个场景，有一个**按钮点击**会触发网络请求，但是我们并不希望每次点击都发起网络请求，而是当用户点击按钮一段时间后没有再次点击的情况才去发起网络请求，对于这种情况我们就可以使用防抖。

> 预加载

在开发中，可能会遇到这样的情况。有些资源不需要马上用到，但是希望尽早获取，这时候就可以使用预加载。

预加载可以一定程度上**降低首屏的加载时间**，因为可以将一些不影响首屏但重要的文件延后加载，唯一缺点就是兼容性不好。

> 预渲染

可以通过预渲染将下载的文件预先在后台渲染，可以使用以下代码开启预渲染

预渲染虽然可以提高页面的加载速度，但是要确保该页面大概率会被用户在之后打开，否则就是白白浪费资源去渲染。

> 懒执行

懒执行就是将某些逻辑延迟到使用时再计算。该技术可以用于**首屏优化**，对于某些耗时逻辑并不需要在首屏就使用的，就可以使用懒执行。懒执行需要唤醒，一般可以通过定时器或者事件的调用来唤醒。

> 懒加载

懒加载就是将不关键的资源延后加载。

懒加载的原理就是只加载自定义区域（通常是**可视区域**，但也可以是即将进入可视区域）内需要加载的东西。对于**图片**来说，先设置图片标签的 src 属性为一张占位图，将真实的图片资源放入一个自定义属性中，当进入自定义区域时，就将自定义属性替换为 src 属性，这样图片就会去下载资源，实现了图片懒加载。

懒加载不仅可以用于图片，也可以使用在别的资源上。比如进入可视区域才开始播放**视频**等等。

> CDN

CDN 的原理是尽可能的在各个地方分布机房缓存数据，这样即使我们的根服务器远在国外，在国内的用户也可以通过国内的机房迅速加载资源。

因此，我们可以将静态资源尽量使用 CDN 加载，由于浏览器对于单个域名有并发请求上限，可以考虑使用多个 CDN 域名。并且对于 CDN 加载静态资源需要注意 CDN 域名要与主站不同，否则每次请求都会带上主站的 Cookie，平白消耗流量。

> 减少 Webpack 打包时间

*  优化 Loader
 *  HappyPack：HappyPack 可以将 Loader 的同步执行转换为并行的，这样就能充分利用系统资源来加快打包效率了。
 *  DllPlugin：DllPlugin 可以将特定的类库提前打包然后引入。
 *  代码压缩

> 减少 Webpack 打包后的文件体积

*  按需加载
 *  Scope Hoisting：Scope Hoisting 会分析出模块之间的依赖关系，尽可能的把打包出来的模块合并到一个函数中去。
 *  Tree Shaking：可以实现删除项目中未被引用的代码

--------------------

### 实现小型打包工具 ###

*  将 ES6 转换为 ES5
 *  支持在 JS 文件中 import CSS 文件

--------------------

### Vue ###

*  生命周期钩子函数
 *  组件通信
 *  extend 能做什么
 *  mixin 和 mixins 区别
 *  computed 和 watch 区别
 *  keep-alive 组件有什么作用
 *  v-show 与 v-if 区别
 *  组件中 data 什么时候可以使用对象
 *  响应式原理
 *  编译过程
 *  NextTick 原理分析

--------------------

### React ###

*  生命周期
 *  setState
 *  性能优化
 *  通信
 *  HOC 是什么？相比 mixins 有什么优点？
 *  事件机制

--------------------

### React 和 Vue 两大框架之间的相爱相杀 ###

*  三大框架的通用架构设计
 *  Virtual DOM 是什么
 *  前端路由是如何跳转的
 *  React 和 Vue 之间的区别

> MVVM

面试题：什么是 MVVM？比之 MVC 有什么区别？

View 很简单，就是用户看到的视图

Model 同样很简单，一般就是本地数据和数据库中的数据

传统的 MVC 架构通常是使用控制器更新模型，视图从模型中获取数据去渲染。当用户有输入时，会通过控制器去更新模型，并且通知视图进行更新。

但是 MVC 有一个巨大的缺陷就是控制器承担的责任太大了，随着项目愈加复杂，控制器中的代码会越来越臃肿，导致出现不利于维护的情况。

在 MVVM 架构中，引入了 ViewModel 的概念。ViewModel 只关心数据和业务的处理，不关心 View 如何处理数据，在这种情况下，View 和 Model 都可以独立出来，任何一方改变了也不一定需要改变另一方，并且可以将一些可复用的逻辑放在一个 ViewModel 中，让多个 View 复用这个 ViewModel。

> Virtual DOM

面试题：什么是 Virtual DOM？为什么 Virtual DOM 比原生 DOM 快？

> 路由原理

面试题：前端路由原理？两种实现方式有什么区别？

前端路由实现起来其实很简单，本质就是监听 URL 的变化，然后匹配路由规则，显示相应的页面，并且无须刷新页面。

目前前端使用的路由就只有两种实现方式：

*  Hash 模式
 *  History 模式

> Vue 和 React 之间的区别

Vue 的表单可以使用 v-model 支持双向绑定，相比于 React 来说开发上更加方便，当然了 v-model 其实就是个语法糖，本质上和 React 写表单的方式没什么区别。

改变数据方式不同，Vue 修改状态相比来说要简单许多，React 需要使用 setState 来改变状态，并且使用这个 API 也有一些坑点。并且 Vue 的底层使用了依赖追踪，页面更新渲染已经是最优的了，但是 React 还是需要用户手动去优化这方面的问题。

React 16以后，有些钩子函数会执行多次，这是因为引入 Fiber 的原因，这在后续的章节中会讲到。

React 需要使用 JSX，有一定的上手成本，并且需要一整套的工具链支持，但是完全可以通过 JS 来控制页面，更加的灵活。Vue 使用了模板语法，相比于 JSX 来说没有那么灵活，但是完全可以脱离工具链，通过直接编写 render 函数就能在浏览器中运行。

在生态上来说，两者其实没多大的差距，当然 React 的用户是远远高于 Vue 的。

在上手成本上来说，Vue 一开始的定位就是尽可能的降低前端开发的门槛，然而 React 更多的是去改变用户去接受它的概念和思想，相较于 Vue 来说上手成本略高。

--------------------

### 监控 ###

前端监控一般分为三种，分别为页面埋点、性能监控以及异常监控。

***页面埋点***

*  PV / UV
 *  停留时长
 *  流量来源
 *  用户交互

--------------------

### UDP ###

> 面向无连接

首先 UDP 是不需要和 TCP 一样在发送数据前进行三次握手建立连接的，想发数据就可以开始发送了。

并且也只是数据报文的搬运工，不会对数据报文进行任何拆分和拼接操作。

具体来说就是：

*  在发送端，应用层将数据传递给传输层的 UDP 协议，UDP 只会给数据增加一个 UDP 头标识下是 UDP 协议，然后就传递给网络层了
 *  在接收端，网络层将数据传递给传输层，UDP 只去除 IP 报文头就传递给应用层，不会任何拼接操作

> 不可靠性

*  首先不可靠性体现在无连接上，通信都不需要建立连接，想发就发，这样的情况肯定不可靠。
 *  并且收到什么数据就传递什么数据，并且也不会备份数据，发送数据也不会关心对方是否已经正确接收到数据了。
 *  再者网络环境时好时坏，但是 UDP 因为没有拥塞控制，一直会以恒定的速度发送数据。即使网络条件不好，也不会对发送速率进行调整。这样实现的弊端就是在网络条件不好的情况下可能会导致丢包，但是优点也很明显，在某些实时性要求高的场景（比如电话会议）就需要使用 UDP 而不是 TCP。

> 高效

虽然 UDP 协议不是那么的可靠，但是正是因为它不是那么的可靠，所以也就没有 TCP 那么复杂了，需要保证数据不丢失且有序到达。

因此 UDP 的头部开销小，只有八字节，相比 TCP 的至少二十字节要少得多，在传输数据报文时是很高效的。

![006tNc79ly1g21beokr7cj31a209cq79.jpg][]

UDP 头部包含了以下几个数据

*  两个十六位的端口号，分别为源端口（可选字段）和目标端口
 *  整个数据报文的长度
 *  整个数据报文的检验和（IPv4 可选 字段），该字段用于发现头部信息和数据中的错误

> 传输方式

UDP 不止支持一对一的传输方式，同样支持一对多，多对多，多对一的方式，也就是说 UDP 提供了单播，多播，广播的功能。

> 适合使用的场景

UDP 虽然对比 TCP 有很多缺点，但是正是因为这些缺点造就了它高效的特性，在很多实时性要求高的地方都可以看到 UDP 的身影。

*  直播

TCP 会严格控制传输的正确性，一旦有某一个数据对端没有收到，就会停止下来直到对端收到这个数据。这种问题在网络条件不错的情况下可能并不会发生什么事情，但是在网络情况差的时候就会变成画面卡住，然后再继续播放下一帧的情况。

但是对于直播来说，用户肯定关注的是最新的画面，而不是因为网络条件差而丢失的老旧画面，所以 TCP 在这种情况下无用武之地，只会降低用户体验。

*  王者荣耀

首先对于王者荣耀来说，用户体量是相当大的，如果使用 TCP 连接的话，就可能会出现服务器不够用的情况，因为每台服务器可供支撑的 TCP 连接数量是有限制的。

再者，因为 TCP 会严格控制传输的正确性，如果因为用户网络条件不好就造成页面卡顿然后再传输旧的游戏画面是肯定不能接受的，毕竟对于这类实时性要求很高的游戏来说，最新的游戏画面才是最需要的，而不是老旧的画面，否则角色都不知道死多少次了。

> 小结

*  UDP 相比 TCP 简单的多，不需要建立连接，不需要验证数据报文，不需要流量控制，只会把想发的数据报文一股脑的丢给对端
 *  虽然 UDP 并没有 TCP 传输来的准确，但是也能在很多实时性要求高的地方有所作为

--------------------

### TCP ###

> 面试题：UDP 与 TCP 的区别是什么？

首先 UDP 协议是面向无连接的，也就是说不需要在正式传递数据之前先连接起双方。然后 UDP 协议只是数据报文的搬运工，不保证有序且不丢失的传递到对端，并且UDP 协议也没有任何控制流量的算法，总的来说 UDP 相较于 TCP 更加的轻便。

TCP 基本是和 UDP 反着来，建立连接断开连接都需要先需要进行握手。在传输数据的过程中，通过各种算法保证数据的可靠性，当然带来的问题就是相比 UDP 来说不那么的高效。

> 头部

![006tNc79ly1g21bg4pgutj31bg0gsak8.jpg][]

对于 TCP 头部来说，以下几个字段是很重要的

*  Sequence number，这个序号保证了 TCP 传输的报文都是有序的，对端可以通过序号顺序的拼接报文
 *  Acknowledgement Number，这个序号表示数据接收端期望接收的下一个字节的编号是多少，同时也表示上一个序号的数据已经收到
 *  Window Size，窗口大小，表示还能接收多少字节的数据，用于流量控制
 *  标识符
    
     *  URG=1：该字段为一表示本数据报的数据部分包含紧急信息，是一个高优先级数据报文，此时紧急指针有效。紧急数据一定位于当前数据包数据部分的最前面，紧急指针标明了紧急数据的尾部。
     *  ACK=1：该字段为一表示确认号字段有效。此外，TCP 还规定在连接建立后传送的所有报文段都必须把 ACK 置为一。
     *  PSH=1：该字段为一表示接收端应该立即将数据 push 给应用层，而不是等到缓冲区满后再提交。
     *  RST=1：该字段为一表示当前 TCP 连接出现严重问题，可能需要重新建立 TCP 连接，也可以用于拒绝非法的报文段和拒绝连接请求。
     *  SYN=1：当SYN=1，ACK=0时，表示当前报文段是一个连接请求报文。当SYN=1，ACK=1时，表示当前报文段是一个同意建立连接的应答报文。
     *  FIN=1：该字段为一表示此报文段是一个释放连接的请求报文。

> 状态机

TCP 的状态机是很复杂的，并且与建立断开连接时的握手息息相关，接下来就来详细描述下两种握手。

在这之前需要了解一个重要的性能指标 RTT。该指标表示发送端发送数据到接收端收到数据所需的往返时间。

> 建立连接三次握手

![006tNc79ly1g21bgvwchjj31100nowwx.jpg][]

第一次握手：客户端向服务端发送连接请求报文段。该报文段中包含自身的数据通讯初始序号。请求发送后，客户端便进入 SYN-SENT 状态。

第二次握手：服务端收到连接请求报文段后，如果同意连接，则会发送一个应答，该应答中也会包含自身的数据通讯初始序号，发送完成后便进入 SYN-RECEIVED 状态。

第三次握手：当客户端收到连接同意的应答后，还要向服务端发送一个确认报文。客户端发完这个报文段后便进入 ESTABLISHED 状态，服务端收到这个应答后也进入 ESTABLISHED 状态，此时连接建立成功。

> 面试题：为什么 TCP 建立连接需要三次握手，明明两次就可以建立起连接

因为这是为了防止出现失效的连接请求报文段被服务端接收的情况，从而产生错误。

> 断开链接四次握手

![006tNc79ly1g34k0q8tnjj31280twwkk.jpg][]

TCP 是全双工的，在断开连接时两端都需要发送 FIN 和 ACK。

第一次握手：若客户端 A 认为数据发送完成，则它需要向服务端 B 发送连接释放请求。

第二次握手：B 收到连接释放请求后，会告诉应用层要释放 TCP 链接。然后会发送 ACK 包，并进入 CLOSE\_WAIT 状态，此时表明 A 到 B 的连接已经释放，不再接收 A 发的数据了。但是因为 TCP 连接是双向的，所以 B 仍旧可以发送数据给 A。

第三次握手：B 如果此时还有没发完的数据会继续发送，完毕后会向 A 发送连接释放请求，然后 B 便进入 LAST-ACK 状态。

第四次握手：A 收到释放请求后，向 B 发送确认应答，此时 A 进入 TIME-WAIT 状态。该状态会持续 2MSL（最大段生存期，指报文段在网络中生存的时间，超时会被抛弃）时间，若该时间段内没有 B 的重发请求的话，就进入 CLOSED 状态。当 B 收到确认应答后，也便进入 CLOSED 状态。

> 为什么 A 要进入 TIME-WAIT 状态，等待 2MSL 时间后才进入 CLOSED 状态？

为了保证 B 能收到 A 的确认应答。若 A 发完确认应答后直接进入 CLOSED 状态，如果确认应答因为网络问题一直没有到达，那么会造成 B 不能正常关闭。

> ARQ 协议

ARQ 协议也就是超时重传机制。通过确认和超时机制保证了数据的正确送达，ARQ 协议包含停止等待 ARQ 和连续 ARQ 两种协议。

> 滑动窗口

在 TCP 中，两端其实都维护着窗口：分别为发送端窗口和接收端窗口。

发送端窗口包含已发送但未收到应答的数据和可以发送但是未发送的数据。

![006tNc79ly1g21bku1ig4j310o0ewwz2.jpg][]

发送端窗口是由接收窗口剩余大小决定的。接收方会把当前接收窗口的剩余大小写入应答报文，发送端收到应答后根据该值和当前网络拥塞情况设置发送窗口的大小，所以发送窗口的大小是不断变化的。

当发送端接收到应答报文后，会随之将窗口进行滑动

![006tNc79ly1g21bk7pvtlj310q0bowre.jpg][]

滑动窗口是一个很重要的概念，它帮助 TCP 实现了**流量控制**的功能。接收方通过报文告知发送方还可以发送多少数据，从而保证接收方能够来得及接收数据，防止出现接收方带宽已满，但是发送方还一直发送数据的情况。

*  Zero 窗口

在发送报文的过程中，可能会遇到对端出现零窗口的情况。在该情况下，发送端会停止发送数据，并启动 persistent timer 。该定时器会定时发送请求给对端，让对端告知窗口大小。在重试次数超过一定次数后，可能会中断 TCP 链接。

> 拥塞处理

流量控制是作用于接收方，保证接收方来得及接受数据。

拥塞处理是作用于网络，防止过多的数据拥塞网络，避免出现网络负载过大的情况。

拥塞处理包括了四个算法，分别为：慢开始，拥塞避免，快速重传，快速恢复。

> 小结

*  建立连接需要三次握手，断开连接需要四次握手
 *  滑动窗口解决了数据的丢包、顺序不对和流量控制问题
 *  拥塞窗口实现了对流量的控制，保证在全天候环境下最优的传递数据

--------------------

### HTTP 及 TLS ###

HTTP 请求由三部分构成，分别为：

*  请求行
 *  首部
 *  实体

> 面试题：Post 和 Get 的区别？

副作用指对服务器上的资源做改变，搜索是无副作用的，注册是副作用的。

幂等指发送 M 和 N 次请求（两者不相同且都大于 1），服务器上资源的状态一致，比如注册 10 个和 11 个帐号是不幂等的，对文章进行更改 10 次和 11 次是幂等的。因为前者是多了一个账号（资源），后者只是更新同一个资源。

在规范的应用场景上说，Get 多用于无副作用，幂等的场景，例如搜索关键字。Post 多用于副作用，不幂等的场景，例如注册。

在技术上说：

*  Get 请求能缓存，Post 不能
 *  Post 相对 Get 安全一点点，因为Get 请求都包含在 URL 里（当然你想写到 body 里也是可以的），且会被浏览器保存历史纪录。Post 不会，但是在抓包的情况下都是一样的。
 *  URL有长度限制，会影响 Get 请求，但是这个长度限制是浏览器规定的，不是 RFC 规定的
 *  Post 支持更多的编码类型且不对数据类型限制

> 首部

首部分为请求首部和响应首部，并且部分首部两种通用，接下来我们就来学习一部分的常用首部。

常见状态码：状态码表示了响应的一个状态，可以让我们清晰的了解到这一次请求是成功还是失败，如果失败的话，是什么原因导致的，当然状态码也是用于传达语义的。如果胡乱使用状态码，那么它存在的意义就没有了。

2XX 成功

*  200 OK，表示从客户端发来的请求在服务器端被正确处理
 *  204 No content，表示请求成功，但响应报文不含实体的主体部分
 *  205 Reset Content，表示请求成功，但响应报文不含实体的主体部分，但是与 204 响应不同在于要求请求方重置内容
 *  206 Partial Content，进行范围请求

3XX 重定向

*  301 moved permanently，永久性重定向，表示资源已被分配了新的 URL
 *  302 found，临时性重定向，表示资源临时被分配了新的 URL
 *  303 see other，表示资源存在着另一个 URL，应使用 GET 方法获取资源
 *  304 not modified，表示服务器允许访问资源，但因发生请求未满足条件的情况
 *  307 temporary redirect，临时重定向，和302含义类似，但是期望客户端保持请求方法不变向新的地址发出请求

4XX 客户端错误

*  400 bad request，请求报文存在语法错误
 *  401 unauthorized，表示发送的请求需要有通过 HTTP 认证的认证信息
 *  403 forbidden，表示对请求资源的访问被服务器拒绝
 *  404 not found，表示在服务器上没有找到请求的资源

5XX 服务器错误

*  500 internal sever error，表示服务器端在执行请求时发生了错误
 *  501 Not Implemented，表示服务器不支持当前请求所需要的某个功能
 *  503 service unavailable，表明服务器暂时处于超负载或正在停机维护，无法处理请求

> TLS

HTTPS 还是通过了 HTTP 来传输信息，但是信息通过 TLS 协议进行了加密。

TLS 协议位于传输层之上，应用层之下。首次进行 TLS 协议传输需要两个 RTT ，接下来可以通过 Session Resumption 减少到一个 RTT。

在 TLS 中使用了两种加密技术，分别为：对称加密和非对称加密。

*  对称加密

对称加密就是两边拥有相同的秘钥，两边都知道如何将密文加密解密。

这种加密方式固然很好，但是问题就在于如何让双方知道秘钥。因为传输数据都是走的网络，如果将秘钥通过网络的方式传递的话，一旦秘钥被截获就没有加密的意义的。

*  非对称加密

有公钥私钥之分，公钥所有人都可以知道，可以将数据用公钥加密，但是将数据解密必须使用私钥解密，私钥只有分发公钥的一方才知道。

这种加密方式就可以完美解决对称加密存在的问题。假设现在两端需要使用对称加密，那么在这之前，可以先使用非对称加密交换秘钥。

简单流程如下：首先服务端将公钥公布出去，那么客户端也就知道公钥了。接下来客户端创建一个秘钥，然后通过公钥加密并发送给服务端，服务端接收到密文以后通过私钥解密出正确的秘钥，这时候两端就都知道秘钥是什么了。

*  TLS 握手过程如下图

![006tNc79ly1g21bmkmf4oj312s0pytp1.jpg][]

> 小结

*  HTTP 经常考到的内容包括：请求方法、首部的作用以及状态码的含义
 *  TLS 中经常考到的内容包括：两种加密方式以及握手的流程

--------------------

### HTTP/2 及 HTTP/3 ###

> HTTP/2

HTTP/2 相比于 HTTP/1，可以说是大幅度提高了网页的性能。

在 HTTP/1 中，为了性能考虑，我们会引入雪碧图、将小图内联、使用多个域名等等的方式。这一切都是因为浏览器限制了同一个域名下的请求数量（Chrome 下一般是限制六个连接），当页面中需要请求很多资源的时候，**队头阻塞**（Head of line blocking）会导致在达到最大请求数量时，剩余的资源需要等待其他资源请求完成后才能发起请求。

在 HTTP/2 中引入了**多路复用**的技术，这个技术可以只通过一个 TCP 连接就可以传输所有的请求数据。多路复用很好的解决了浏览器限制同一个域名下的请求数量的问题，同时也间接更容易实现全速传输，毕竟新开一个 TCP 连接都需要慢慢提升传输速度。

*  多路复用

在 HTTP/2 中，有两个非常重要的概念，分别是帧（frame）和流（stream）。

帧代表着最小的数据单位，每个帧会标识出该帧属于哪个流，流也就是多个帧组成的数据流。

多路复用，就是在一个 TCP 连接中可以存在多条流。换句话说，也就是可以发送多个请求，对端可以通过帧中的标识知道属于哪个请求。通过这个技术，可以避免 HTTP 旧版本中的队头阻塞问题，极大的提高传输性能。

![006tNc79ly1g21bof15zlj310k098tab.jpg][]

*  二进制传输

HTTP/2 中所有加强性能的核心点在于此。在之前的 HTTP 版本中，我们是通过**文本**的方式传输数据。在 HTTP/2 中引入了新的编码机制，所有传输的数据都会被分割，并采用**二进制**格式编码。

![006tNc79ly1g21bnih84vj312i0kqgur.jpg][]

*  Header 压缩

在 HTTP/1 中，我们使用文本的形式传输 header，在 header 携带 cookie 的情况下，可能每次都需要重复传输几百到几千的字节。

在 HTTP /2 中，使用了 HPACK 压缩格式对传输的 header 进行编码，减少了 header 的大小。并在两端维护了索引表，用于记录出现过的 header，后面在传输过程中就可以传输已经记录过的 header 的键名，对端收到数据后就可以通过键名找到对应的值。

*  服务端 Push

在 HTTP/2 中，服务端可以在客户端某个请求后，主动推送其他资源。

可以想象以下情况，某些资源客户端是一定会请求的，这时就可以采取服务端 push 的技术，提前给客户端推送必要的资源，这样就可以相对减少一点延迟时间。当然在浏览器兼容的情况下你也可以使用 prefetch 。

> HTTP/3

虽然 HTTP/2 解决了很多之前旧版本的问题，但是它还是存在一个巨大的问题，虽然这个问题并不是它本身造成的，而是底层支撑的 TCP 协议的问题。

因为 HTTP/2 使用了多路复用，一般来说同一域名下只需要使用一个 TCP 连接。**当这个连接中出现了丢包的情况，那就会导致 HTTP/2 的表现情况反倒不如 HTTP/1 了**。

因为在出现丢包的情况下，整个 TCP 都要开始等待重传，也就导致了后面的所有数据都被阻塞了。但是对于 HTTP/1 来说，可以开启多个 TCP 连接，出现这种情况反到只会影响其中一个连接，剩余的 TCP 连接还可以正常传输数据。

那么可能就会有人考虑到去修改 TCP 协议，其实这已经是一件不可能完成的任务了。因为 TCP 存在的时间实在太长，已经充斥在各种设备中，并且这个协议是由操作系统实现的，更新起来不大现实。

基于这个原因，Google 就更起炉灶搞了一个基于 UDP 协议的 QUIC 协议，并且使用在了 HTTP/3 上，当然 HTTP/3 之前名为 HTTP-over-QUIC，从这个名字中我们也可以发现，HTTP/3 最大的改造就是使用了 QUIC，接下来我们就来学习关于这个协议的内容。

*  QUIC

之前我们学习过 UDP 协议的内容，知道这个协议虽然效率很高，但是并不是那么的可靠。QUIC 虽然基于 UDP，但是在原本的基础上新增了很多功能，比如多路复用、0-RTT、使用 TLS1.3 加密、流量控制、有序交付、重传等等功能。这里我们就挑选几个重要的功能学习下这个协议的内容。

*  多路复用

虽然 HTTP/2 支持了多路复用，但是 TCP 协议终究是没有这个功能的。QUIC 原生就实现了这个功能，并且传输的单个数据流可以保证有序交付且不会影响其他的数据流，这样的技术就解决了之前 TCP 存在的问题。

并且 QUIC 在移动端的表现也会比 TCP 好。因为 TCP 是基于 IP 和端口去识别连接的，这种方式在多变的移动端网络环境下是很脆弱的。但是 QUIC 是通过 ID 的方式去识别一个连接，不管你网络环境如何变化，只要 ID 不变，就能迅速重连上。

*  0-RTT

通过使用类似 TCP 快速打开的技术，缓存当前会话的上下文，在下次恢复会话的时候，只需要将之前的缓存传递给服务端验证通过就可以进行传输了。

*  纠错机制

假如说这次我要发送三个包，那么协议会算出这三个包的异或值并单独发出一个校验包，也就是总共发出了四个包。

当出现其中的非校验包丢包的情况时，可以通过另外三个包计算出丢失的数据包的内容。

当然这种技术只能使用在丢失一个包的情况下，如果出现丢失多个包就不能使用纠错机制了，只能使用重传的方式了。

> 小结

*  HTTP/2 通过多路复用、二进制流、Header 压缩等等技术，极大地提高了性能，但是还是存在着问题的
 *  QUIC 基于 UDP 实现，是 HTTP/3 中的底层支撑协议，该协议基于 UDP，又取了 TCP 中的精华，实现了即快又可靠的协议

--------------------

### 输入 URL 到页面渲染的整个流程 ###

*  首先是 **DNS 查询**，如果这一步做了智能 DNS 解析的话，会提供访问速度最快的 IP 地址回来，这部分的内容之前没有写过，所以就在这里讲解下。

DNS 的作用就是通过域名查询到具体的 IP。

因为 IP 存在数字和英文的组合（IPv6），很不利于人类记忆，所以就出现了域名。你可以把域名看成是某个 IP 的别名，DNS 就是去查询这个别名的真正名称是什么。

在 TCP 握手之前就已经进行了 DNS 查询，这个查询是操作系统自己做的。当你在浏览器中想访问 [www.google.com][] 时，会进行一下操作：

1.  操作系统会首先在本地缓存中查询 IP
2.  没有的话会去系统配置的 DNS 服务器中查询
3.  如果这时候还没得话，会直接去 DNS 根服务器查询，这一步查询会找出负责 com 这个一级域名的服务器
4.  然后去该服务器查询 google 这个二级域名
5.  接下来三级域名的查询其实是我们配置的，你可以给 www 这个域名配置一个 IP，然后还可以给别的三级域名配置一个 IP

以上介绍的是 DNS 迭代查询，还有种是递归查询，区别就是前者是由客户端去做请求，后者是由系统配置的 DNS 服务器做请求，得到结果后将数据返回给客户端。

PS：DNS 是基于 UDP 做的查询，大家也可以考虑下为什么之前不考虑使用 TCP 去实现。

*  接下来是 **TCP 握手**

1.  应用层会下发数据给传输层，
2.  这里 TCP 协议会指明两端的端口号，然后下发给网络层。
3.  网络层中的 IP 协议会确定 IP 地址，并且指示了数据传输中如何跳转路由器。
4.  然后包会再被封装到数据链路层的数据帧结构中，最后就是物理层面的传输了。

在这一部分中，可以详细说下 TCP 的握手情况以及 TCP 的一些特性。

*  当 TCP 握手结束后就会进行 **TLS 握手**，然后就开始正式的传输数据。

在这一部分中，可以详细说下 TLS 的握手情况以及两种加密方式的内容。

*  数据在进入服务端之前，可能还会先经过负责**负载均衡的服务器**，它的作用就是将请求合理的分发到多台服务器上，这时假设服务端会响应一个 HTML 文件。

首先浏览器会判断状态码是什么，如果是 200 那就继续解析，如果 400 或 500 的话就会报错，如果 300 的话会进行重定向，这里会有个重定向计数器，避免过多次的重定向，超过次数也会报错。

*  **浏览器开始解析文件**，如果是 gzip 格式的话会先解压一下，然后通过文件的编码格式知道该如何去解码文件。

1.  文件解码成功后会正式开始渲染流程，先会**根据 HTML 构建 DOM 树，有 CSS 的话会去构建 CSSOM 树**。如果遇到 script 标签的话，会判断是否存在 async 或者 defer ，前者会并行进行下载并执行 JS，后者会先下载文件，然后等待 HTML 解析完成后顺序执行。如果以上都没有，就会阻塞住渲染流程直到 JS 执行完毕。遇到文件下载的会去下载文件，这里如果使用 HTTP/2 协议的话会极大的提高多图的下载效率。
2.  CSSOM 树和 DOM 树构建完成后会开始**生成 Render 树**，这一步就是确定页面元素的布局、样式等等诸多方面的东西
3.  在生成 Render 树的过程中，浏览器就开始调用 **GPU 绘制**，合成图层，将内容显示在屏幕上了。

这一部分就是渲染原理中讲解到的内容，可以详细的说明下这一过程。并且在下载文件时，也可以说下通过 HTTP/2 协议可以解决队头阻塞的问题。

总的来说这一章节就是带着大家从 DNS 查询开始到渲染出画面完整的了解一遍过程，将之前学习到的内容连接起来。

--------------------

### 设计模式 ###

> 工厂模式

工厂模式分为好几种，这里就不一一讲解了，以下是一个简单工厂模式的例子

class Man { 
      constructor(name) { 
        this.name = name
      }
      alertName() { 
        alert(this.name)
      }
    }
    
    class Factory { 
      static create(name) { 
        return new Man(name)
      }
    }
    
    Factory.create('yck').alertName()

当然工厂模式并不仅仅是用来 new 出实例。

可以想象一个场景。假设有一份很复杂的代码需要用户去调用，但是用户并不关心这些复杂的代码，只需要你提供给我一个接口去调用，用户只负责传递需要的参数，至于这些参数怎么使用，内部有什么逻辑是不关心的，只需要你最后返回我一个实例。这个构造过程就是工厂。

工厂起到的作用就是隐藏了创建实例的复杂度，只需要提供一个接口，简单清晰。

> 单例模式

单例模式很常用，比如全局缓存、全局状态管理等等这些只需要一个对象，就可以使用单例模式。

单例模式的核心就是保证全局只有一个对象可以访问。因为 JS 是门无类的语言，所以别的语言实现单例的方式并不能套入 JS 中，我们只需要**用一个变量确保实例只创建一次**就行，以下是如何实现单例模式的例子

class Singleton { 
      constructor() { }
    }
    
    Singleton.getInstance = (function() { 
      let instance
      return function() { 
        if (!instance) { 
          instance = new Singleton()
        }
        return instance
      }
    })()
    
    let s1 = Singleton.getInstance()
    let s2 = Singleton.getInstance()
    console.log(s1 === s2) // true

> 适配器模式

适配器用来解决两个接口不兼容的情况，不需要改变已有的接口，通过包装一层的方式实现两个接口的正常协作。

class Plug { 
      getName() { 
        return '港版插头'
      }
    }
    
    class Target { 
      constructor() { 
        this.plug = new Plug()
      }
      getName() { 
        return this.plug.getName() + ' 适配器转二脚插头'
      }
    }
    
    let target = new Target()
    target.getName() // 港版插头 适配器转二脚插头

> 装饰模式

装饰模式不需要改变已有的接口，作用是给对象添加功能。就像我们经常需要给手机戴个保护套防摔一样，不改变手机自身，给手机添加了保护套提供防摔功能。

function readonly(target, key, descriptor) { 
      descriptor.writable = false
      return descriptor
    }
    
    class Test { 
      @readonly
      name = 'yck'
    }
    
    let t = new Test()
    
    t.yck = '111' // 不可修改

> 代理模式

代理是为了控制对对象的访问，不让外部直接访问到对象。在现实生活中，也有很多代理的场景。比如你需要买一件国外的产品，这时候你可以通过代购来购买产品。

在实际代码中其实代理的场景很多，也就不举框架中的例子了，比如事件代理就用到了代理模式。

<ul id="ul">
        <li>1</li>
        <li>2</li>
        <li>3</li>
        <li>4</li>
        <li>5</li>
    </ul>
    <script> let ul = document.querySelector('#ul') ul.addEventListener('click', (event) => { console.log(event.target); }) </script>

因为存在太多的 li，不可能每个都去绑定事件。这时候可以通过给父节点绑定一个事件，让父节点作为代理去拿到真实点击的节点。

> 发布-订阅模式

发布-订阅模式也叫做观察者模式。通过一对一或者一对多的依赖关系，当对象发生改变时，订阅方都会收到通知。在现实生活中，也有很多类似场景，比如我需要在购物网站上购买一个产品，但是发现该产品目前处于缺货状态，这时候我可以点击有货通知的按钮，让网站在产品有货的时候通过短信通知我。

在实际代码中其实发布-订阅模式也很常见，比如我们点击一个按钮触发了点击事件就是使用了该模式

<ul id="ul"></ul>
    <script> let ul = document.querySelector('#ul') ul.addEventListener('click', (event) => { console.log(event.target); }) </script>

> 外观模式

外观模式提供了一个接口，隐藏了内部的逻辑，更加方便外部调用。

举个例子来说，我们现在需要实现一个兼容多种浏览器的添加事件方法

function addEvent(elm, evType, fn, useCapture) { 
      if (elm.addEventListener) { 
        elm.addEventListener(evType, fn, useCapture)
        return true
      } else if (elm.attachEvent) { 
        var r = elm.attachEvent("on" + evType, fn)
        return r
      } else { 
        elm["on" + evType] = fn
      }
    }

对于不同的浏览器，添加事件的方式可能会存在兼容问题。如果每次都需要去这样写一遍的话肯定是不能接受的，所以我们将这些判断逻辑统一封装在一个接口中，外部需要添加事件只需要调用 addEvent 即可。

--------------------

### 常见数据结构 ###

> 时间复杂度

通常使用最差的时间复杂度来衡量一个算法的好坏。

常数时间 O(1) 代表这个操作和数据量没关系，是一个固定时间的操作，比如说四则运算。

对于一个算法来说，可能会计算出操作次数为 aN + 1，N 代表数据量。那么该算法的时间复杂度就是 O(N)。因为我们在计算时间复杂度的时候，数据量通常是非常大的，这时候低阶项和常数项可以忽略不计。

当然可能会出现两个算法都是 O(N) 的时间复杂度，那么对比两个算法的好坏就要通过对比低阶项和常数项了。

> 栈

栈是一个线性结构，在计算机中是一个相当常见的数据结构。

栈的特点是只能在某一端添加或删除数据，遵循先进后出的原则

> 队列

队列是一个线性结构，特点是在某一端添加数据，在另一端删除数据，遵循先进先出的原则。

这里会讲解两种实现队列的方式，分别是单链队列和循环队列。

> 链表

链表是一个线性结构，同时也是一个天然的递归结构。链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

> 树

*  二叉树

树拥有很多种结构，二叉树是树中最常用的结构，同时也是一个天然的递归结构。

二叉树拥有一个根节点，每个节点至多拥有两个子节点，分别为：左节点和右节点。树的最底部节点称之为叶节点，当一颗树的叶数量数量为满时，该树可以称之为满二叉树。

*  二分搜索树

二分搜索树也是二叉树，拥有二叉树的特性。但是区别在于二分搜索树每个节点的值都比他的左子树的值大，比右子树的值小。

这种存储方式很适合于数据搜索。如下图所示，当需要查找 6 的时候，因为需要查找的值比根节点的值大，所以只需要在根节点的右子树上寻找，大大提高了搜索效率。

> AVL 树

二分搜索树实际在业务中是受到限制的，因为并不是严格的 O(logN)，在极端情况下会退化成链表，比如加入一组升序的数字就会造成这种情况。

AVL 树改进了二分搜索树，在 AVL 树中**任意节点的左右子树的高度差都不大于 1**，这样保证了时间复杂度是严格的 O(logN)。基于此，对 AVL 树增加或删除节点时可能需要旋转树来达到高度的平衡。

> Trie

在计算机科学，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。

简单点来说，这个结构的作用大多是为了方便搜索字符串，该树有以下几个特点

*  根节点代表空字符串，每个节点都有 N（假如搜索英文字符，就有 26 条）条链接，每条链接代表一个字符
 *  节点不存储字符，只有路径才存储，这点和其他的树结构不同
 *  从根节点开始到任意一个节点，将沿途经过的字符连接起来就是该节点对应的字符串

![006tNc79ly1g217g1yoy8j30hs0go753.jpg][]

> 并查集

并查集是一种特殊的树结构，用于处理一些不交集的合并及查询问题。该结构中每个节点都有一个父节点，如果只有当前一个节点，那么该节点的父节点指向自己。

这个结构中有两个重要的操作，分别是：

*  Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
 *  Union：将两个子集合并成同一个集合。

![006tNc79ly1g217ifcprsj30wm0cq0vs.jpg][]

> 堆

堆通常是一个可以被看做一棵树的数组对象。

堆的实现通过构造二叉堆，实为二叉树的一种。这种数据结构具有以下性质。

*  任意节点小于（或大于）它的所有子节点
 *  堆总是一棵完全树。即除了最底层，其他层的节点都被元素填满，且最底层从左到右填入。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

优先队列也完全可以用堆来实现，操作是一模一样的。

实现大根堆

*  堆的每个节点的左边子节点索引是 i \* 2 + 1，右边是 i \* 2 + 2，父节点是 (i - 1) /2。
 *  堆有两个核心的操作，分别是 shiftUp 和 shiftDown 。前者用于添加元素，后者用于删除根节点。
 *  shiftUp 的核心思路是一路将节点与父节点对比大小，如果比父节点大，就和父节点交换位置。
 *  shiftDown 的核心思路是先将根节点和末尾交换位置，然后移除末尾元素。接下来循环判断父节点和两个子节点的大小，如果子节点大，就把最大的子节点和父节点交换。

--------------------

### 常考算法题解析 ###

> 位运算

*  左移 <<

10 << 1 // -> 20

左移就是将二进制全部往左移动，10 在二进制中表示为 1010 ，左移一位后变成 10100 ，转换为十进制也就是 20，所以基本可以把左移看成以下公式 a \* (2 ^ b)

*  右移 >>

10 >> 1 // -> 5

算数右移就是将二进制全部往右移动并去除多余的右边，10 在二进制中表示为 1010 ，右移一位后变成 101 ，转换为十进制也就是 5，所以基本可以把右移看成以下公式 int v = a / (2 ^ b)

右移很好用，比如可以用在二分算法中取中间值

13 >> 1 // -> 6

*  按位与

每一位都为 1，结果才为 1

8 & 7 // -> 0
    // 1000 & 0111 -> 0000 -> 0

*  按位或

其中一位为 1，结果就是 1

8 | 7 // -> 15
    // 1000 | 0111 -> 1111 -> 15

*  按位异或

8 ^ 7 // -> 15
    8 ^ 8 // -> 0
    // 1000 ^ 0111 -> 1111 -> 15
    // 1000 ^ 1000 -> 0000 -> 0

从以上代码中可以发现按位异或就是不进位加法

> 面试题：两个数不使用四则运算得出和

这道题中可以按位异或，因为按位异或就是不进位加法，8 ^ 8 = 0 如果进位了，就是 16 了，所以我们只需要将两个数进行异或操作，然后进位。那么也就是说两个二进制都是 1 的位置，左边应该有一个进位 1，所以可以得出以下公式 a + b = (a ^ b) + ((a & b) << 1) ，然后通过迭代的方式模拟加法

function sum(a, b) { 
        if (a == 0) return b
        if (b == 0) return a
        let newA = a ^ b
        let newB = (a & b) << 1
        return sum(newA, newB)
    }

> 排序

*  冒泡排序

冒泡排序的原理如下，从第一个元素开始，把当前元素和下一个索引元素进行比较。如果当前元素大，那么就交换位置，重复操作直到比较到最后一个元素，那么此时最后一个元素就是该数组中最大的数。下一轮重复以上操作，但是此时最后一个元素已经是最大数了，所以不需要再比较最后一个元素，只需要比较到 length - 2 的位置。

时间复杂度是 O(n \* n)

*  插入排序

插入排序的原理如下。第一个元素默认是已排序元素，取出下一个元素和当前元素比较，如果当前元素大就交换位置。那么此时第一个元素就是当前的最小数，所以下次取出操作从第三个元素开始，向前对比，重复之前的操作。

时间复杂度是 O(n \* n)

*  选择排序

选择排序的原理如下。遍历数组，设置最小值的索引为 0，如果取出的值比当前最小值小，就替换最小值索引，遍历完成后，将第一个元素和最小值索引上的值交换。如上操作后，第一个元素就是数组中的最小值，下次遍历就可以从索引 1 开始重复上述操作。

时间复杂度是 O(n \* n)

*  归并排序

归并排序的原理如下。递归的将数组两两分开直到最多包含两个元素，然后将数组排序合并，最终合并为排序好的数组。假设我有一组数组 \[3, 1, 2, 8, 9, 7, 6\]，中间数索引是 3，先排序数组 \[3, 1, 2, 8\] 。在这个左边数组上，继续拆分直到变成数组包含两个元素（如果数组长度是奇数的话，会有一个拆分数组只包含一个元素）。然后排序数组 \[3, 1\] 和 \[2, 8\] ，然后再排序数组 \[1, 3, 2, 8\] ，这样左边数组就排序完成，然后按照以上思路排序右边数组，最后将数组 \[1, 2, 3, 8\] 和 \[6, 7, 9\] 排序。

时间复杂度为 O(N \* logN)

*  快排

快排的原理如下。随机选取一个数组中的值作为基准值，从左至右取值与基准值对比大小。比基准值小的放数组左边，大的放右边，对比完成后将基准值和第一个比基准值大的值交换位置。然后将数组以基准值的位置分为两部分，继续递归以上操作。

时间复杂度为O(logN)

*  堆排序

堆排序利用了二叉堆的特性来做，二叉堆通常用数组表示，并且二叉堆是一颗完全二叉树（所有叶节点（最底层的节点）都是从左往右顺序排序，并且其他层的节点都是满的）。二叉堆又分为大根堆与小根堆。

1)大根堆是某个节点的所有子节点的值都比他小

2)小根堆是某个节点的所有子节点的值都比他大

堆排序的原理就是组成一个大根堆或者小根堆。以小根堆为例，某个节点的左边子节点索引是 i \* 2 + 1，右边是 i \* 2 + 2，父节点是 (i - 1) /2。

1)首先遍历数组，判断该节点的父节点是否比他小，如果小就交换位置并继续判断，直到他的父节点比他大  
2)重新以上操作 1，直到数组首位是最大值  
3)然后将首位和末尾交换位置并将数组长度减一，表示数组末尾已是最大值，不需要再比较大小  
4)对比左右节点哪个大，然后记住大的节点的索引并且和父节点对比大小，如果子节点大就交换位置  
5)重复以上操作 3 - 4 直到整个数组都是大根堆。

时间复杂度是 O(N\*logN)

> 链表

*  反转单向链表

> 树

*  二叉树的先序，中序，后序遍历

> 动态规划

动态规划背后的基本思想非常简单。就是将一个问题拆分为子问题，一般来说这些子问题都是非常相似的，那么我们可以通过只解决一次每个子问题来达到减少计算量的目的。

一旦得出每个子问题的解，就存储该结果以便下次使用。

*  斐波那契数列

斐波那契数列就是从 0 和 1 开始，后面的数都是前两个数之和

0，1，1，2，3，5，8，13，21，34，55，89…

那么显然易见，我们可以通过递归的方式来完成求解斐波那契数列

function fib(n) { 
      if (n < 2 && n >= 0) return n
      return fib(n - 1) + fib(n - 2)
    }
    fib(10)

以上代码已经可以完美的解决问题。但是以上解法却存在很严重的性能问题，当 n 越大的时候，需要的时间是指数增长的，这时候就可以通过动态规划来解决这个问题。

动态规划的本质其实就是两点

1)自底向上分解子问题

1.  通过变量存储已经计算过的解

根据上面两点，我们的斐波那契数列的动态规划思路也就出来了

1)斐波那契数列从 0 和 1 开始，那么这就是这个子问题的最底层

2)通过数组来存储每一位所对应的斐波那契数列的值

function fib(n) { 
      let array = new Array(n + 1).fill(null)
      array[0] = 0
      array[1] = 1
      for (let i = 2; i <= n; i++) { 
        array[i] = array[i - 1] + array[i - 2]
      }
      return array[n]
    }
    fib(10)

*  0 - 1背包问题

该问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。每个问题只能放入至多一次。

假设我们有以下物品

对于一个总容量为 5 的背包来说，我们可以放入重量 2 和 3 的物品来达到背包内的物品总价值最高。

对于这个问题来说，子问题就两个，分别是放物品和不放物品，可以通过以下表格来理解子问题

直接来分析能放三种物品的情况，也就是最后一行

1)当容量少于 3 时，只取上一行对应的数据，因为当前容量不能容纳物品 3  
2)当容量 为 3 时，考虑两种情况，分别为放入物品 3 和不放物品 3  
a)不放物品 3 的情况下，总价值为 10  
b)放入物品 3 的情况下，总价值为 12，所以应该放入物品 3  
3)当容量 为 4 时，考虑两种情况，分别为放入物品 3 和不放物品 3  
a)不放物品 3 的情况下，总价值为 10  
b)放入物品 3 的情况下，和放入物品 1 的价值相加，得出总价值为 15，所以应该放入物品 3  
4)当容量 为 5 时，考虑两种情况，分别为放入物品 3 和不放物品 3  
a)不放物品 3 的情况下，总价值为 10  
b)放入物品 3 的情况下，和放入物品 2 的价值相加，得出总价值为 19，所以应该放入物品 3

以下代码对照上表更容易理解

/** * @param {*} w 物品重量 * @param {*} v 物品价值 * @param {*} C 总容量 * @returns */
    function knapsack(w, v, C) { 
      let length = w.length
      if (length === 0) return 0
    
      // 对照表格，生成的二维数组，第一维代表物品，第二维代表背包剩余容量
      // 第二维中的元素代表背包物品总价值
      let array = new Array(length).fill(new Array(C + 1).fill(null))
    
      // 完成底部子问题的解
      for (let i = 0; i <= C; i++) { 
        // 对照表格第一行， array[0] 代表物品 1
        // i 代表剩余总容量
        // 当剩余总容量大于物品 1 的重量时，记录下背包物品总价值，否则价值为 0
        array[0][i] = i >= w[0] ? v[0] : 0
      }
    
      // 自底向上开始解决子问题，从物品 2 开始
      for (let i = 1; i < length; i++) { 
        for (let j = 0; j <= C; j++) { 
          // 这里求解子问题，分别为不放当前物品和放当前物品
          // 先求不放当前物品的背包总价值，这里的值也就是对应表格中上一行对应的值
          array[i][j] = array[i - 1][j]
          // 判断当前剩余容量是否可以放入当前物品
          if (j >= w[i]) { 
            // 可以放入的话，就比大小
            // 放入当前物品和不放入当前物品，哪个背包总价值大
            array[i][j] = Math.max(array[i][j], v[i] + array[i - 1][j - w[i]])
          }
        }
      }
      return array[length - 1][C]
    }

*  最长递增子序列

最长递增子序列意思是在一组数字中，找出最长一串递增的数字，比如

0, 3, 4, 17, 2, 8, 6, 10

对于以上这串数字来说，最长递增子序列就是 0, 3, 4, 8, 10，可以通过以下表格更清晰的理解

通过以上表格可以很清晰的发现一个规律，找出刚好比当前数字小的数，并且在小的数组成的长度基础上加一。

--------------------

### CSS 常考面试题 ###

*  [50道CSS基础面试题（附答案）][50_CSS]
 *  [《50道CSS基础面试题（附答案）》中的答案真的就只是答案吗？][50_CSS 1]
 *  [CSS 面试题总结][CSS]
 *  [front-end-interview-handbook][]

--------------------

### 如何写好一封简历 ###

简历其实就是**推销**自己，如果你的简历和别人千篇一律，没有亮点，用人方就不会对你产生兴趣。

以下是我经常给别人修改简历的意见：

*  简历页数控制在 **2 页**以下
 *  技术名词注意**大小写**
 *  突出个人亮点。比如在项目中如何找到 Bug，解决 Bug 的过程；比如如何发现的性能问题，如何解决性能问题，最终提升了多少性能；比如为何如此选型，目的是什么，较其他有什么优点等等。总体思路就是不写流水账，突出你在项目中具有不错的**解决问题的能力和独立思考的能力**
 *  **斟酌**熟悉、精通等字眼，不要给自己挖坑
 *  确保每一个写上去的技术点自己都能说出点什么，杜绝面试官问你一个技术点，你只能答出会用 API 这种减分的情况
 *  拿**事实**说话。你说你学习能力强，那么请列举你能力强的事实；你说你成绩好，那么请写出你专业的排名

做到以上内容，然后在投递简历的过程中加上一份**求职信**，对你的求职之路相信能帮上很多忙，当然了，一般来说我推荐尽量走**内推**通道投递简历。在网上多花点心思就能找到很多内推，比如 V2EX、脉脉等等。

--------------------

### 面试常用技巧 ###

> 尽早准备简历

简历应该是经常去更新的，隔几个月去更新一次简历，了解自己这几个月以来的成长在哪里，结果是什么。

> 分批投递简历

当我们准备投递简历的时候，应该先把想投递的几个公司分出几个档次。先投递档次最低的，就算失败了，也就当在攒经验。这样多面几次，把握大了就可以开始投递更加心仪的公司了，增加成功几率。

> 如何粗略判断公司是否靠谱

首先一家公司所涉足的行业是很重要的，如果你去一家做社交的公司，很大程度上会以失败而告终。我个人认为目前**教育、新能源、生鲜、医疗、数据**这几个行业前景不错，当然这只是个人观点仅做参考。

然后我们还得了解一家公司的情况，这里我推荐使用「**天眼查**」去查询一家公司的信息。在这里我们可以查询到一家公司的几个重要指标

*  具体的一个**融资**情况，一家公司好不好，拥有的资本肯定是重要的一块。一家不错的公司，往往前期融到的金额就很高
 *  **核心团队**的介绍，通过介绍我们可以了解到高管的一个教育背景，行业的经验等等
 *  公司涉及到了哪些**司法、经营上的风险**

然后还可以在网上查询一下这家公司是否有拖欠工资等等**负面的消息**。

> 如何回答问题

尽量不要止步于问题，也就是面试官问什么你答什么，而是**把回答的点发散出去，引导面试官提问，展示自己的水平**。

很推荐大家在准备面试的过程中，挖掘出自己擅长的技术内容，然后在面试的过程中，寻找机会引导面试官提问你擅长的技术点。

最后需要注意一点，如果你不能很好的理解面试官的提问，最好先**弄明白面试官到底想问什么**，而不是直接回答问题导致出现文不对题的情况。

> 如何应对可能答不好的题目

假如你遇到了一道不会的题目，但是稍微有一点想法，你可以先坦白说这道题目不怎么会，但是愿意尝试回答一下，这样即使回答错了，也不会有什么问题。

但是千万不要不懂装懂，弄巧成拙。

> 多反思

一场面试结束以后，尽快的将面试中遇到的问题记录下来，然后**复盘**整个面试。

> 谈钱

在和 HR 谈论工资的时候**提高百分之 10 - 15**的样子，便于别人压价，因为大部分人是没有谈判能力的。然后跳槽的薪资涨幅应该是你**当下的百分之 15 以上**，这样才能对冲跳槽带来的一个风险，当然如果你实在很想去这家公司的话，那么薪资就另谈了。

*  具体的工资（也就是合同上签订的工资），不要杂七杂八什么绩效加起来的那种
 *  五险一金缴纳的比例
 *  加班是否有加班工资或者调休
 *  是否是 996，我个人很不推荐 996 的公司
 *  加薪升职的情况
 *  其他各种福利，比如餐补、房补、交通补、节假日福利、另外的保险等等

--------------------

### [前方的路，让我们结伴同行][Link 2] ###

[Link 1]: https://juejin.im/book/5bdc715fe51d454e755f75ef
[006tNbRwly1fynwrmq5utj30ko0ermx8.jpg]: https://ws1.sinaimg.cn/large/006tNbRwly1fynwrmq5utj30ko0ermx8.jpg
[006tNbRwly1fynwzkitedj30rx0buglx.jpg]: https://ws4.sinaimg.cn/large/006tNbRwly1fynwzkitedj30rx0buglx.jpg
[ES6]: https://juejin.im/book/5bdc715fe51d454e755f75ef/section/5bdd0d83f265da615f76ba57
[Promises_A]: http://www.ituring.com.cn/article/66566
[006tNc79ly1fyvtu4uazvj30m203x749.jpg]: https://ws4.sinaimg.cn/large/006tNc79ly1fyvtu4uazvj30m203x749.jpg
[006tNc79ly1fyvtw94lh1j30lm04b3yi.jpg]: https://ws2.sinaimg.cn/large/006tNc79ly1fyvtw94lh1j30lm04b3yi.jpg
[006tNc79ly1g21beokr7cj31a209cq79.jpg]: https://ws1.sinaimg.cn/large/006tNc79ly1g21beokr7cj31a209cq79.jpg
[006tNc79ly1g21bg4pgutj31bg0gsak8.jpg]: https://ws2.sinaimg.cn/large/006tNc79ly1g21bg4pgutj31bg0gsak8.jpg
[006tNc79ly1g21bgvwchjj31100nowwx.jpg]: https://ws4.sinaimg.cn/large/006tNc79ly1g21bgvwchjj31100nowwx.jpg
[006tNc79ly1g34k0q8tnjj31280twwkk.jpg]: https://ws3.sinaimg.cn/large/006tNc79ly1g34k0q8tnjj31280twwkk.jpg
[006tNc79ly1g21bku1ig4j310o0ewwz2.jpg]: https://ws3.sinaimg.cn/large/006tNc79ly1g21bku1ig4j310o0ewwz2.jpg
[006tNc79ly1g21bk7pvtlj310q0bowre.jpg]: https://ws2.sinaimg.cn/large/006tNc79ly1g21bk7pvtlj310q0bowre.jpg
[006tNc79ly1g21bmkmf4oj312s0pytp1.jpg]: https://ws1.sinaimg.cn/large/006tNc79ly1g21bmkmf4oj312s0pytp1.jpg
[006tNc79ly1g21bof15zlj310k098tab.jpg]: https://ws1.sinaimg.cn/large/006tNc79ly1g21bof15zlj310k098tab.jpg
[006tNc79ly1g21bnih84vj312i0kqgur.jpg]: https://ws3.sinaimg.cn/large/006tNc79ly1g21bnih84vj312i0kqgur.jpg
[www.google.com]: http://www.google.com
[006tNc79ly1g217g1yoy8j30hs0go753.jpg]: https://ws2.sinaimg.cn/large/006tNc79ly1g217g1yoy8j30hs0go753.jpg
[006tNc79ly1g217ifcprsj30wm0cq0vs.jpg]: https://ws1.sinaimg.cn/large/006tNc79ly1g217ifcprsj30wm0cq0vs.jpg
[50_CSS]: https://segmentfault.com/a/1190000013325778
[50_CSS 1]: https://segmentfault.com/a/1190000013860482
[CSS]: https://funteas.com/topic/5ada8eac230d1e5e25e45b89
[front-end-interview-handbook]: https://github.com/yangshun/front-end-interview-handbook/blob/master/Translations/Chinese/questions/css-questions.md
[Link 2]: https://juejin.im/book/5bdc715fe51d454e755f75ef/section/5be91762f265da611b57e015