目录

 前言

一、代码层面的优化

 1. **v-if 和 v-show 区分使用场景**

2. **computed 和 watch 区分使用场景**

 3. **v-for 遍历必须为 item 添加 key，且避免同时使用 v-if**

 4. **长列表性能优化**

5. **事件的销毁**

 6. **图片资源懒加载**

7. **路由懒加载**

 8. **第三方插件的按需引入**

 9. **优化无限列表性能**

10. **服务端渲染 SSR or 预渲染**

二、Webpack 层面的优化

2. **减少 ES6 转为 ES5 的冗余代码**

3. **提取公共代码**

4. **模板预编译**

5. **提取组件的 CSS**

 6. **优化 SourceMap**

 7. **构建结果输出分析**

 8. **Vue 项目的编译优化**

三、基础的 Web 技术优化

 1. **开启 gzip 压缩**

 2. **浏览器缓存**

 3. **CDN 的使用**

 4. **使用 Chrome Performance 查找性能瓶颈**

  一、CDN

 1. CDN的概念

 2. CDN的作用

 3. CDN的原理

**CDN的工作原理：**

 4. CDN的使用场景

## 二、懒加载

## 三、回流与重绘

 1. 回流与重绘的概念及触发条件

 2. 如何避免回流与重绘？

 3. 如何优化动画？

 4. documentFragment 是什么？用它跟直接操作 DOM 的区别是什么？

## 四、节流与防抖

 1. 对节流与防抖的理解

 2. 实现节流函数和防抖函数

五、图片优化

 1. 如何对项目中的图片进行优化？

 2. 常见的图片格式及使用场景

六、Webpack优化

 1. 如何提⾼webpack的打包速度?

（2）HappyPack

（3）DllPlugin

（4）代码压缩

 （5）其他

 2. 如何减少 Webpack 打包体积

（3）Tree Shaking

 3. 如何⽤webpack来优化前端性能？

 4. 如何提⾼webpack的构建速度？

前端工程化面试题

一、Git

 1. git 和 svn 的区别

 2. 经常使用的 git 命令？

 3. git pull 和 git fetch 的区别

 4. git rebase 和 git merge 的区别

二、Webpack

 1. webpack与grunt、gulp的不同？

 2. webpack、rollup、parcel优劣？

 3. 有哪些常⻅的Loader？

 4. 有哪些常⻅的Plugin？

 5. bundle，chunk，module是什么？

 6. Loader和Plugin的不同？

 7. webpack的构建流程

 8. 编写loader或plugin的思路？

原理：

⾸先要知道server端和client端都做了处理⼯作：

 10. 如何⽤webpack来优化前端性能？

 11. 如何提⾼webpack的打包速度?

 12. 如何提⾼webpack的构建速度？

 13. 怎么配置单⻚应⽤？怎么配置多⻚应⽤？

三、其他

 Babel的原理是什么?

一、浏览器安全

 1. 什么是 XSS 攻击？

 2. 如何防御 XSS 攻击？

 3. 什么是 CSRF 攻击？

 4. 如何防御 CSRF 攻击？

 5. 什么是中间人攻击？如何防范中间人攻击？

 6. 有哪些可能引起前端安全的问题?

 7. 网络劫持有哪几种，如何防范？

 二、进程与线程

 1. 进程与线程的概念

 2. 进程和线程的区别

 3. 浏览器渲染进程的线程有哪些

 4. 进程之前的通信方式

 5. 僵尸进程和孤儿进程是什么？

 6. 死锁产生的原因？ 如果解决死锁的问题？

 7. 如何实现浏览器内多个标签页之间的通信?

 8. 对Service Worker的理解

三、浏览器缓存

 1. 对浏览器的缓存机制的理解

 2. 浏览器资源缓存的位置有哪些？

 4. 为什么需要浏览器缓存？

 5. 点击刷新按钮或者按 F5、按 Ctrl+F5 （强制刷新）、地址栏回车有什么区别？

四、浏览器组成

 1. 对浏览器的理解

 2. 对浏览器内核的理解

 3. 常见的浏览器内核比较

 4. 常见浏览器所用内核

 5. 浏览器的主要组成部分

五、浏览器渲染原理

 1. 浏览器的渲染过程

 2. 浏览器渲染优化

 3. 渲染过程中遇到 JS 文件如何处理？

 4. 什么是文档的预解析？

 5. CSS 如何阻塞文档解析？

 6. 如何优化关键渲染路径？

 7. 什么情况会阻塞渲染？

六、浏览器本地存储

 1. 浏览器本地存储方式及使用场景

 2. Cookie有哪些字段，作用分别是什么

 3. Cookie、LocalStorage、SessionStorage区别

 4. 前端储存的⽅式有哪些？

 5. IndexedDB有哪些特点？

 七、浏览器同源策略

 1. 什么是同源策略

 2. 如何解决跨越问题

 3. 正向代理和反向代理的区别

 4. Nginx的概念及其工作原理

 八、浏览器事件机制

 1. 事件是什么？事件模型？

 2. 如何阻止事件冒泡

 3. 对事件委托的理解

 4. 事件委托的使用场景

 5. 同步和异步的区别

 6. 对事件循环的理解

 7. 宏任务和微任务分别有哪些

 8. 什么是执行栈

 9. Node 中的 Event Loop 和浏览器中的有什么区别？process.nextTick 执行顺序？

顺序

 10. 事件触发的过程是怎样的

九、浏览器垃圾回收机制

 1. V8的垃圾回收机制是怎样的

 2. 哪些操作会造成内存泄漏？

 一、HTTP协议

 1. GET和POST的请求的区别

 2. POST和PUT请求的区别

 3. 常见的HTTP请求头和响应头

 4. HTTP状态码304是多好还是少好

 5. 常见的HTTP请求方法

 6. OPTIONS请求方法及使用场景

 7. HTTP 1.0 和 HTTP 1.1 之间有哪些区别？

 8. HTTP 1.1 和 HTTP 2.0 的区别

 9. HTTP和HTTPS协议的区别

 10. GET方法URL长度限制的原因

 11. 当在浏览器中输入 Google.com 并且按下回车之后发生了什么？

 12. 对keep-alive的理解

 13. 页面有多张图片，HTTP是怎样的加载表现？

 14. HTTP2的头部压缩算法是怎样的？

 16. HTTP响应报文的是什么样的？

 17. HTTP协议的优点和缺点

 18. 说一下HTTP 3.0

 19. HTTP协议的性能怎么样

 20. URL有哪些组成部分

 21. 与缓存相关的HTTP请求头有哪些

 二、HTTPS协议

 1. 什么是HTTPS协议？

 2. TLS/SSL的工作原理

 3. 数字证书是什么？

 4. HTTPS通信（握手）过程

 5. HTTPS的特点

 6. HTTPS是如何保证安全的？

三、HTTP状态码

 1. 2XX (Success 成功状态码)

 2. 3XX (Redirection 重定向状态码)

 3. 4XX (Client Error 客户端错误状态码)

 4. 5XX (Server Error 服务器错误状态码)

 5. 总结

 6. 同样是重定向，307，303，302的区别？

四、DNS协议介绍

 1. DNS 协议是什么

 2. DNS同时使用TCP和UDP协议？

 3. DNS完整的查询过程

 4. 迭代查询与递归查询

 5. DNS 记录和报文

 五、网络模型

 1. OSI七层模型

 2. TCP/IP五层协议

六、TCP与UDP

 1. TCP 和 UDP的概念及特点

 2. TCP和UDP的区别

 3. TCP和UDP的使用场景

 4. UDP协议为什么不可靠？

 5. TCP的重传机制

 6. TCP的拥塞控制机制

 7. TCP的流量控制机制

 8. TCP的可靠传输机制

 9. TCP的三次握手和四次挥手

 10. TCP粘包是怎么回事，如何处理?

 11. 为什么udp不会粘包？

七、WebSocket

 1. 对 WebSocket 的理解

 2. 即时通讯的实现：短轮询、长轮询、SSE 和 WebSocket 间的区别？

一、异步&事件循环

 1. 代码输出结果

 2. 代码输出结果

 3. 代码输出结果

 4. 代码输出结果

 5. 代码输出结果

 6. 代码输出结果

 7. 代码输出结果

 8. 代码输出结果

 9. 代码输出结果

 10. 代码输出结果

 11. 代码输出结果

 12. 代码输出结果

二、this

 1. 代码输出结果

 三、作用域&变量提升&闭包

 四、原型&继承

一、JavaScript 基础

 1. 手写 Object.create

 2. 手写 instanceof 方法

 二、数据处理

 1. 实现日期格式化函数

 2. 交换a,b的值，不能用临时变量

 3. 实现数组的乱序输出

 5. 实现数组的扁平化

 三、场景应用

 1. 循环打印红黄绿

 2. 实现每隔一秒打印 1,2,3,4

 3. 小孩报数问题

 4. 用Promise实现图片的异步加载

 5. 实现发布-订阅模式

 6. 查找文章中出现频率最高的单词

 7. 封装异步的fetch，使用async await方式来使用

 8. 实现prototype继承所谓的原型链继承就是让新实例的原型等于父类的实例：

 9. 实现双向数据绑定

 10. 实现简单路由

 11. 实现斐波那契数列

 12. 字符串出现的不重复最长长度

 13. 使用 setTimeout 实现 setInterval

 14. 实现 jsonp

 15. 判断对象是否存在循环引用

 前言

Vue 框架通过数据双向绑定和虚拟 DOM 技术，帮我们处理了前端开发中最脏最累的 DOM 操作部分， 我们不再需要去考虑如何操作 DOM 以及如何最高效地操作 DOM；但 Vue 项目中仍然存在项目首屏优化、Webpack 编译配置优化等问题，所以我们仍然需要去关注 Vue 项目性能方面的优化，使项目具有更高效的性能、更好的用户体验。本文是作者通过实际项目的优化实践进行总结而来，希望读者读完本文，有一定的启发思考，从而对自己的项目进行优化起到帮助。本文内容分为以下三部分组成：

Vue 代码层面的优化；

webpack 配置层面的优化；

基础的 Web 技术层面的优化。

一、代码层面的优化

 1. **v-if 和 v-show 区分使用场景**

v-if 是 真正 的条件渲染，因为它会确保在切换过程中条件块内的事件监听器和子组件适当地被销毁和重建；也是惰性的：如果在初始渲染时条件为假，则什么也不做——直到条件第一次变为真时，才会开始渲染条件块。

v-show 就简单得多， 不管初始条件是什么，元素总是会被渲染，并且只是简单地基于 CSS 的 display 属性进行切换。

所以，v-if 适用于在运行时很少改变条件，不需要频繁切换条件的场景；v-show 则适用于需要非常频繁切换条件的场景。

2. **computed 和 watch 区分使用场景**

computed： 是计算属性，依赖其它属性值，并且 computed 的值有缓存，只有它依赖的属性值发生改变，下一次获取 computed 的值时才会重新计算 computed 的值；

watch： 更多的是「观察」的作用，类似于某些数据的监听回调 ，每当监听的数据变化时都会执行回调进行后续操作；

运用场景：

当我们需要进行数值计算，并且依赖于其它数据时，应该使用 computed，因为可以利用 computed 的缓存特性，避免每次获取值时，都要重新计算；

当我们需要在数据变化时执行异步或开销较大的操作时，应该使用 watch，使用 watch 选项允许我们执行异步操作 ( 访问一个 API )，限制我们执行该操作的频率，并在我们得到最终结果前，设置中间状态。这些都是计算属性无法做到的。

 3. **v-for 遍历必须为 item 添加 key，且避免同时使用 v-if**

（1）v-for 遍历必须为 item 添加 key

在列表数据进行遍历渲染时，需要为每一项 item 设置唯一 key 值，方便 Vue.js 内部机制精准找到该条列表数据。当 state 更新时，新的状态值和旧的状态值对比，较快地定位到 diff 。

（2）v-for 遍历避免同时使用 v-if

v-for 比 v-if 优先级高，如果每一次都需要遍历整个数组，将会影响速度，尤其是当之需要渲染很小一部分的时候，必要情况下应该替换成 computed 属性。

推荐：

     

        v-for="user in activeUsers"

        :key="user.id">

        {{ user.name }}

     

computed: {

  activeUsers: function () {

    return this.users.filter(function (user) {

   return user.isActive

    })

  }

}

不推荐：

     

        v-for="user in users"

        v-if="user.isActive"

        :key="user.id">

        {{ user.name }}

     

 4. **长列表性能优化**

Vue 会通过 Object.defineProperty 对数据进行劫持，来实现视图响应数据的变化，然而有些时候我们的组件就是纯粹的数据展示，不会有任何改变，我们就不需要 Vue 来劫持我们的数据，在大量数据展示的情况下，这能够很明显的减少组件初始化的时间，那如何禁止 Vue 劫持我们的数据呢？可以通过 Object.freeze 方法来冻结一个对象，一旦被冻结的对象就再也不能被修改了。

export default {

  data: () => ({

    users: {}

  }),

  async created() {

    const users = await axios.get("/api/users");

    this.users = Object.freeze(users);

  }

};

5. **事件的销毁**

Vue 组件销毁时，会自动清理它与其它实例的连接，解绑它的全部指令及事件监听器，但是仅限于组件本身的事件。如果在 js 内

created() {

  addEventListener('click', this.click, false)

},

beforeDestroy() {

  removeEventListener('click', this.click, false)

}

 6. **图片资源懒加载**

对于图片过多的页面，为了加速页面加载速度，所以很多时候我们需要将页面内未出现在可视区域内的图片先不做加载， 等到滚动到可视区域后再去加载。这样对于页面加载性能上会有很大的提升，也提高了用户体验。我们在项目中使用 Vue 的 vue-lazyload 插件：

（1）安装插件

npm install vue-lazyload --save-dev

（2）在入口文件 man.js 中引入并使用

import VueLazyload from 'vue-lazyload'

然后再 vue 中直接使用

Vue.use(VueLazyload)

或者添加自定义选项

Vue.use(VueLazyload, {

preLoad: 1.3,

error: 'dist/error.png',

loading: 'dist/loading.gif',

attempt: 1

})

（3）在 vue 文件中将 img 标签的 src 属性直接改为 v-lazy ，从而将图片显示方式更改为懒加载显示：

以上为 vue-lazyload 插件的简单使用，如果要看插件的更多参数选项，可以查看 vue-lazyload 的 github 地址。

7. **路由懒加载**

Vue 是单页面应用，可能会有很多的路由引入 ，这样使用 webpcak 打包后的文件很大，当进入首页时，加载的资源过多，页面会出现白屏的情况，不利于用户体验。如果我们能把不同路由对应的组件分割成不同的代码块，然后当路由被访问的时候才加载对应的组件，这样就更加高效了。这样会大大提高首屏显示的速度，但是可能其他的页面的速度就会降下来。

路由懒加载：

const Foo = () => import('./Foo.vue')

const router = new VueRouter({

  routes: [

    { path: '/foo', component: Foo }

  ]

})

 8. **第三方插件的按需引入**

我们在项目中经常会需要引入第三方插件，如果我们直接引入整个插件，会导致项目的体积太大，我们可以借助 babel-plugin-component ，然后可以只引入需要的组件，以达到减小项目体积的目的。以下为项目中引入 element-ui 组件库为例：

（1）首先，安装 babel-plugin-component ：

npm install babel-plugin-component -D

（2）然后，将 .babelrc 修改为：

{

  "presets": [["es2015", { "modules": false }]],

  "plugins": [

    [

      "component",

      {

        "libraryName": "element-ui",

        "styleLibraryName": "theme-chalk"

      }

    ]

  ]

}

（3）在 main.js 中引入部分组件：

import Vue from 'vue';

import { Button, Select } from 'element-ui';

 Vue.use(Button)

 Vue.use(Select)

 9. **优化无限列表性能**

如果你的应用存在非常长或者无限滚动的列表，那么需要采用 窗口化 的技术来优化性能，只需要渲染少部分区域的内容，减少重新渲染组件和创建 dom 节点的时间。你可以参考以下开源项目 vue-virtual-scroll-list 和 vue-virtual-scroller 来优化这种无限列表的场景的。

10. **服务端渲染 SSR or 预渲染**

服务端渲染是指 Vue 在客户端将标签渲染成的整个 html 片段的工作在服务端完成，服务端形成的 html 片段直接返回给客户端这个过程就叫做服务端渲染。

（1）服务端渲染的优点：

更好的 SEO：因为 SPA 页面的内容是通过 Ajax 获取，而搜索引擎爬取工具并不会等待 Ajax 异步完成后再抓取页面内容，所以在 SPA 中是抓取不到页面通过 Ajax 获取到的内容；而 SSR 是直接由服务端返回已经渲染好的页面（数据已经包含在页面中），所以搜索引擎爬取工具可以抓取渲染好的页面；

更快的内容到达时间（首屏加载更快）：SPA 会等待所有 Vue 编译后的 js 文件都下载完成后，才开始进行页面的渲染，文件下载等需要一定的时间等，所以首屏渲染需要一定的时间；SSR 直接由服务端渲染好页面直接返回显示，无需等待下载 js 文件及再去渲染等，所以 SSR 有更快的内容到达时间；

（2）服务端渲染的缺点：

更多的开发条件限制：例如服务端渲染只支持 beforCreate 和 created 两个钩子函数，这会导致一些外部扩展库需要特殊处理，才能在服务端渲染应用程序中运行；并且与可以部署在任何静态文件服务器上的完全静态单页面应用程序 SPA 不同，服务端渲染应用程序，需要处于 Node.js server 运行环境；

更多的服务器负载：在 Node.js 中渲染完整的应用程序，显然会比仅仅提供静态文件的 server 更加大量占用CPU 资源，因此如果你预料在高流量环境下使用，请准备相应的服务器负载，并明智地采用缓存策略。

如果你的项目的 SEO 和 首屏渲染是评价项目的关键指标，那么你的项目就需要服务端渲染来帮助你实现最佳的初始加载性能和 SEO，具体的 Vue SSR 如何实现。如果你的 Vue 项目只需改善少数营销页面（例如 /， /about， /contact 等）的 SEO，那么你可能需要预渲染，在构建时 (build time) 简单地生成针对特定路由的静态 HTML 文件。优点是设置预渲染更简单，并可以将你的前端作为一个完全静态的站点，具体你可以使用 prerender-spa-plugin 就可以轻松地添加预渲染 。

二、Webpack 层面的优化

 1. **Webpack 对图片进行压缩**

在 vue 项目中除了可以在 webpack.base.conf.js 中 url-loader 中设置 limit 大小来对图片处理，对小于 limit 的图片转化为 base64 格式，其余的不做操作。所以对有些较大的图片资源，在请求资源的时候，加载会很慢，我们可以用 image-webpack-loader来压缩图片：

（1）首先，安装 image-webpack-loader ：

npm install image-webpack-loader --save-dev

（2）然后，在 webpack.base.conf.js 中进行配置：

{

  test: /\.(png|jpe?g|gif|svg)(\?.*)?$/,

  use:[

    {

    loader: 'url-loader',

    options: {

      limit: 10000,

      name: utils.assetsPath('img/[name].[hash:7].[ext]')

      }

    },

    {

      loader: 'image-webpack-loader',

      options: {

        bypassOnDebug: true,

      }

    }

  ]

}

2. **减少 ES6 转为 ES5 的冗余代码**

Babel 插件会在将 ES6 代码转换成 ES5 代码时会注入一些辅助函数，例如下面的 ES6 代码：

class HelloWebpack extends Component{...}

这段代码再被转换成能正常运行的 ES5 代码时需要以下两个辅助函数：

babel-runtime/helpers/createClass  // 用于实现 class 语法

babel-runtime/helpers/inherits  // 用于实现 extends 语法

在默认情况下， Babel 会在每个输出文件中内嵌这些依赖的辅助函数代码，如果多个源代码文件都依赖这些辅助函数，那么这些辅助函数的代码将会出现很多次，造成代码冗余。为了不让这些辅助函数的代码重复出现，可以在依赖它们时通过 require(‘babel-runtime/helpers/createClass’) 的方式导入，这样就能做到只让它们出现一次。babel-plugin-transform-runtime 插件就是用来实现这个作用的，将相关辅助函数进行替换成导入语句，从而减小 babel 编译出来的代码的文件大小。

（1）首先，安装 babel-plugin-transform-runtime ：

npm install babel-plugin-transform-runtime --save-dev

（2）然后，修改 .babelrc 配置文件为：

"plugins": [

    "transform-runtime"

]

如果要看插件的更多详细内容，可以查看babel-plugin-transform-runtime 的 详细介绍。

3. **提取公共代码**

如果项目中没有去将每个页面的第三方库和公共模块提取出来，则项目会存在以下问题：

相同的资源被重复加载，浪费用户的流量和服务器的成本。

每个页面需要加载的资源太大，导致网页首屏加载缓慢，影响用户体验。

所以我们需要将多个页面的公共代码抽离成单独的文件，来优化以上问题 。Webpack 内置了专门用于提取多个Chunk 中的公共部分的插件 CommonsChunkPlugin，我们在项目中 CommonsChunkPlugin 的配置如下：

// 所有在 package.json 里面依赖的包，都会被打包进 vendor.js 这个文件中。

new webpack.optimize.CommonsChunkPlugin({

  name: 'vendor',

  minChunks: function(module, count) {

    return (

      module.resource &&

      /\.js$/.test(module.resource) &&

      module.resource.indexOf(

        path.join(__dirname, '../node_modules')

      ) === 0

    );

  }

}),

// 抽取出代码模块的映射关系

new webpack.optimize.CommonsChunkPlugin({

  name: 'manifest',

  chunks: ['vendor']

})

如果要看插件的更多详细内容，可以查看 CommonsChunkPlugin 的 详细介绍。

4. **模板预编译**

当使用 DOM 内模板或 JavaScript 内的字符串模板时，模板会在运行时被编译为渲染函数。通常情况下这个过程已经足够快了，但对性能敏感的应用还是最好避免这种用法。

预编译模板最简单的方式就是使用单文件组件——相关的构建设置会自动把预编译处理好，所以构建好的代码已经包含了编译出来的渲染函数而不是原始的模板字符串。

如果你使用 webpack，并且喜欢分离 JavaScript 和模板文件，你可以使用 vue-template-loader，它也可以在构建过程中把模板文件转换成为 JavaScript 渲染函数。

5. **提取组件的 CSS**

当使用单文件组件时，组件内的 CSS 会以 style 标签的方式通过 JavaScript 动态注入。这有一些小小的运行时开销，如果你使用服务端渲染，这会导致一段 “无样式内容闪烁 (fouc) ” 。将所有组件的 CSS 提取到同一个文件可以避免这个问题，也会让 CSS 更好地进行压缩和缓存。

查阅这个构建工具各自的文档来了解更多：

webpack + vue-loader ( vue-cli 的 webpack 模板已经预先配置好)

Browserify + vueify

Rollup + rollup-plugin-vue

 6. **优化 SourceMap**

我们在项目进行打包后，会将开发中的多个文件代码打包到一个文件中，并且经过压缩、去掉多余的空格、babel编译化后，最终将编译得到的代码会用于线上环境，那么这样处理后的代码和源代码会有很大的差别，当有 bug的时候，我们只能定位到压缩处理后的代码位置，无法定位到开发环境中的代码，对于开发来说不好调式定位问题，因此 sourceMap 出现了，它就是为了解决不好调式代码问题的。

SourceMap 的可选值如下（+ 号越多，代表速度越快，- 号越多，代表速度越慢, o 代表中等速度 ）

开发环境推荐：cheap-module-eval-source-map

生产环境推荐：cheap-module-source-map

原因如下：

cheap：源代码中的列信息是没有任何作用，因此我们打包后的文件不希望包含列相关信息，只有行信息能建立打包前后的依赖关系。因此不管是开发环境或生产环境，我们都希望添加 cheap 的基本类型来忽略打包前后的列信息；

module ：不管是开发环境还是正式环境，我们都希望能定位到bug的源代码具体的位置，比如说某个 Vue 文件报错了，我们希望能定位到具体的 Vue 文件，因此我们也需要 module 配置；

soure-map ：source-map 会为每一个打包后的模块生成独立的 soucemap 文件 ，因此我们需要增加source-map 属性；

eval-source-map：eval 打包代码的速度非常快，因为它不生成 map 文件，但是可以对 eval 组合使用 eval-source-map 使用会将 map 文件以 DataURL 的形式存在打包后的 js 文件中。在正式环境中不要使用 eval-source-map, 因为它会增加文件的大小，但是在开发环境中，可以试用下，因为他们打包的速度很快。 b

 7. **构建结果输出分析**

Webpack 输出的代码可读性非常差而且文件非常大，让我们非常头疼。为了更简单、直观地分析输出结果，社区中出现了许多可视化分析工具。这些工具以图形的方式将结果更直观地展示出来，让我们快速了解问题所在。接下来讲解我们在 Vue 项目中用到的分析工具：webpack-bundle-analyzer 。

我们在项目中 webpack.prod.conf.js 进行配置：

if (config.build.bundleAnalyzerReport) {

  var BundleAnalyzerPlugin =   require('webpack-bundle-analyzer').BundleAnalyzerPlugin;

  webpackConfig.plugins.push(new BundleAnalyzerPlugin());

}

执行 $ npm run build --report 后生成分析报告如下：

 8. **Vue 项目的编译优化**

如果你的 Vue 项目使用 Webpack 编译，需要你喝一杯咖啡的时间，那么也许你需要对项目的 Webpack 配置进行优化，提高 Webpack 的构建效率。

三、基础的 Web 技术优化

 1. **开启 gzip 压缩**

gzip 是 GNUzip 的缩写，最早用于 UNIX 系统的文件压缩。HTTP 协议上的 gzip 编码是一种用来改进 web 应用程序性能的技术，web 服务器和客户端（浏览器）必须共同支持 gzip。目前主流的浏览器，Chrome，firefox，IE等都支持该协议。常见的服务器如 Apache，Nginx，IIS 同样支持，gzip 压缩效率非常高，通常可以达到 70% 的压缩率，也就是说，如果你的网页有 30K，压缩之后就变成了 9K 左右

以下我们以服务端使用我们熟悉的 express 为例，开启 gzip 非常简单，相关步骤如下：

安装：

npm install compression --save 添加代码逻辑：

var compression = require('compression');

var app = express();

app.use(compression())

 2. **浏览器缓存**

为了提高用户加载页面的速度，对静态资源进行缓存是非常必要的，根据是否需要重新向服务器发起请求来分类，将 HTTP 缓存规则分为两大类（强制缓存，对比缓存）。

 3. **CDN 的使用**

浏览器从服务器上下载 CSS、js 和图片等文件时都要和服务器连接，而大部分服务器的带宽有限，如果超过限制，网页就半天反应不过来。而 CDN 可以通过不同的域名来加载文件，从而使下载文件的并发连接数大大增加，且CDN 具有更好的可用性，更低的网络延迟和丢包率 。

 4. **使用 Chrome Performance 查找性能瓶颈**

Chrome 的 Performance 面板可以录制一段时间内的 js 执行细节及时间。使用 Chrome 开发者工具分析页面性能的步骤如下。

打开 Chrome 开发者工具，切换到 Performance 面板

点击 Record 开始录制

刷新页面或展开某个节点

点击 Stop 停止录制

  一、CDN

 1. CDN的概念

CDN（Content Delivery Network，**内容分发网络**）是指一种通过互联网互相连接的电脑网络系统，利用最靠近每位用户的服务器，更快、更可靠地将音乐、图片、视频、应用程序及其他文件发送给用户，来提供高性能、可扩展性及低成本的网络内容传递给用户。

典型的CDN系统由下面三个部分组成：

- **分发服务系统：**最基本的工作单元就是Cache设备，cache（边缘cache）负责直接响应最终用户的访问请求，把缓存在本地的内容快速地提供给用户。同时cache还负责与源站点进行内容同步，把更新的内容以及本地没有的内容从源站点获取并保存在本地。Cache设备的数量、规模、总服务能力是衡量一个CDN系统服务能力的最基本的指标。 - **负载均衡系统：**主要功能是负责对所有发起服务请求的用户进行访问调度，确定提供给用户的最终实际访问地址。两级调度体系分为全局负载均衡（GSLB）和本地负载均衡（SLB）。**全局负载均衡**主要根据用户就近性原则，通过对每个服务节点进行“最优”判断，确定向用户提供服务的cache的物理位置。**本地负载均衡**主要负责节点内部的设备负载均衡 - **运营管理系统：**运营管理系统分为运营管理和网络管理子系统，负责处理业务层面的与外界系统交互所必须的收集、整理、交付工作，包含客户管理、产品管理、计费管理、统计分析等功能。

 2. CDN的作用

CDN一般会用来托管Web资源（包括文本、图片和脚本等），可供下载的资源（媒体文件、软件、文档等），应用程序（门户网站等）。使用CDN来加速这些资源的访问。

（1）在性能方面，引入CDN的作用在于：

- 用户收到的内容来自最近的数据中心，延迟更低，内容加载更快 - 部分资源请求分配给了CDN，减少了服务器的负载

（2）在安全方面，CDN有助于防御DDoS、MITM等网络攻击：

- 针对DDoS：通过监控分析异常流量，限制其请求频率 - 针对MITM：从源服务器到 CDN 节点到 ISP（Internet Service Provider），全链路 HTTPS 通信

除此之外，CDN作为一种基础的云服务，同样具有资源托管、按需扩展（能够应对流量高峰）等方面的优势。

 3. CDN的原理

CDN和DNS有着密不可分的联系，先来看一下DNS的解析域名过程，在浏览器输入 www.test.com 的解析过程如下：

（1） 检查浏览器缓存

（2）检查操作系统缓存，常见的如hosts文件

（3）检查路由器缓存

（4）如果前几步都没没找到，会向ISP(网络服务提供商)的LDNS服务器查询

（5）如果LDNS服务器没找到，会向根域名服务器(Root Server)请求解析，分为以下几步：

- 根服务器返回顶级域名(TLD)服务器如 `.com`，`.cn`，`.org`等的地址，该例子中会返回 `.com`的地址 - 接着向顶级域名服务器发送请求，然后会返回次级域名(SLD)服务器的地址，本例子会返回 `.test`的地址 - 接着向次级域名服务器发送请求，然后会返回通过域名查询到的目标IP，本例子会返回 `www.test.com`的地址 - Local DNS Server会缓存结果，并返回给用户，缓存在系统中

**CDN的工作原理：**

（1）用户未使用CDN缓存资源的过程：

1. 浏览器通过DNS对域名进行解析（就是上面的DNS解析过程），依次得到此域名对应的IP地址 2. 浏览器根据得到的IP地址，向域名的服务主机发送数据请求 3. 服务器向浏览器返回响应数据

（2）用户使用CDN缓存资源的过程：

1. 对于点击的数据的URL，经过本地DNS系统的解析，发现该URL对应的是一个CDN专用的DNS服务器，DNS系统就会将域名解析权交给CNAME指向的CDN专用的DNS服务器。 2. CND专用DNS服务器将CND的全局负载均衡设备IP地址返回给用户 3. 用户向CDN的全局负载均衡设备发起数据请求 4. CDN的全局负载均衡设备根据用户的IP地址，以及用户请求的内容URL，选择一台用户所属区域的区域负载均衡设备，告诉用户向这台设备发起请求 5. 区域负载均衡设备选择一台合适的缓存服务器来提供服务，将该缓存服务器的IP地址返回给全局负载均衡设备 6. 全局负载均衡设备把服务器的IP地址返回给用户 7. 用户向该缓存服务器发起请求，缓存服务器响应用户的请求，将用户所需内容发送至用户终端。

如果缓存服务器没有用户想要的内容，那么缓存服务器就会向它的上一级缓存服务器请求内容，以此类推，直到获取到需要的资源。最后如果还是没有，就会回到自己的服务器去获取资源。

CNAME（意为：别名）：在域名解析中，实际上解析出来的指定域名对应的IP地址，或者该域名的一个CNAME，然后再根据这个CNAME来查找对应的IP地址。

 4. CDN的使用场景

- **使用第三方的CDN服务：**如果想要开源一些项目，可以使用第三方的CDN服务 - **使用CDN进行静态资源的缓存：**将自己网站的静态资源放在CDN上，比如js、css、图片等。可以将整个项目放在CDN上，完成一键部署。 - **直播传送：**直播本质上是使用流媒体进行传送，CDN也是支持流媒体传送的，所以直播完全可以使用CDN来提高访问速度。CDN在处理流媒体的时候与处理普通静态文件有所不同，普通文件如果在边缘节点没有找到的话，就会去上一层接着寻找，但是流媒体本身数据量就非常大，如果使用回源的方式，必然会带来性能问题，所以流媒体一般采用的都是主动推送的方式来进行。

## 二、懒加载

 1. 懒加载的概念

懒加载也叫做延迟加载、按需加载，指的是在长网页中延迟加载图片数据，是一种较好的网页性能优化的方式。在比较长的网页或应用中，如果图片很多，所有的图片都被加载出来，而用户只能看到可视窗口的那一部分图片数据，这样就浪费了性能。

如果使用图片的懒加载就可以解决以上问题。在滚动屏幕之前，可视化区域之外的图片不会进行加载，在滚动屏幕时才加载。这样使得网页的加载速度更快，减少了服务器的负载。懒加载适用于图片较多，页面列表较长（长列表）的场景中。

 2. 懒加载的特点

- **减少无用资源的加载：**使用懒加载明显减少了服务器的压力和流量，同时也减小了浏览器的负担。 - **提升用户体验: **如果同时加载较多图片，可能需要等待的时间较长，这样影响了用户体验，而使用懒加载就能大大的提高用户体验。 - **防止加载过多图片而影响其他资源文件的加载 ：**会影响网站应用的正常使用。

 3. 懒加载的实现原理

图片的加载是由 `src`引起的，当对 `src`赋值时，浏览器就会请求图片资源。根据这个原理，我们使用HTML5 的 `data-xxx`属性来储存图片的路径，在需要加载图片的时候，将 `data-xxx`中图片的路径赋值给 `src`，这样就实现了图片的按需加载，即懒加载。

注意：`data-xxx` 中的 `xxx`可以自定义，这里我们使用 `data-src`来定义。

懒加载的实现重点在于确定用户需要加载哪张图片，在浏览器中，可视区域内的资源就是用户需要的资源。所以当图片出现在可视区域时，获取图片的真实地址并赋值给图片即可。

使用原生JavaScript实现懒加载：

**知识点：**

（1）`window.innerHeight` 是浏览器可视区的高度 `document.documentElement.clientHeight`

（2）`document.body.scrollTop || document.documentElement.scrollTop` 是浏览器滚动的过的距离

（3）`imgs.offsetTop` 是元素顶部距离文档顶部的高度（包括滚动条的距离）

（4）图片加载条件：`img.offsetTop < window.innerHeight + document.body.scrollTop;`

**代码实现：**

     vue.js webpack Vue项目的性能优化 第1张

     vue.js webpack Vue项目的性能优化 第1张

     vue.js webpack Vue项目的性能优化 第1张

     vue.js webpack Vue项目的性能优化 第1张

     vue.js webpack Vue项目的性能优化 第1张

     vue.js webpack Vue项目的性能优化 第1张

 4. 懒加载与预加载的区别

这两种方式都是提高网页性能的方式，两者主要区别是一个是提前加载，一个是迟缓甚至不加载。懒加载对服务器前端有一定的缓解压力作用，预加载则会增加服务器前端压力。

- **懒加载也叫延迟加载，指的是在长网页中延迟加载图片的时机，当用户需要访问时，再去加载**，这样可以提高网站的首屏加载速度，提升用户的体验，并且可以减少服务器的压力。它适用于图片很多，页面很长的电商网站的场景。懒加载的实现原理是，将页面上的图片的 src 属性设置为空字符串，将图片的真实路径保存在一个自定义属性中，当页面滚动的时候，进行判断，如果图片进入页面可视区域内，则从自定义属性中取出真实路径赋值给图片的 src 属性，以此来实现图片的延迟加载。 - **预加载指的是将所需的资源提前请求加载到本地，这样后面在需要用到时就直接从缓存取资源。**通过预加载能够减少用户的等待时间，提高用户的体验。我了解的预加载的最常用的方式是使用 js 中的 image 对象，通过为 image 对象来设置 scr 属性，来实现图片的预加载。

## 三、回流与重绘

 1. 回流与重绘的概念及触发条件

# （1）回流

当渲染树中部分或者全部元素的尺寸、结构或者属性发生变化时，浏览器会重新渲染部分或者全部文档的过程就称为**回流**。

下面这些操作会导致回流：

- 页面的首次渲染 - 浏览器的窗口大小发生变化 - 元素的内容发生变化 - 元素的尺寸或者位置发生变化 - 元素的字体大小发生变化 - 激活CSS伪类 - 查询某些属性或者调用某些方法 - 添加或者删除可见的DOM元素

在触发回流（重排）的时候，由于浏览器渲染页面是基于流式布局的，所以当触发回流时，会导致周围的DOM元素重新排列，它的影响范围有两种：

- 全局范围：从根节点开始，对整个渲染树进行重新布局 - 局部范围：对渲染树的某部分或者一个渲染对象进行重新布局

# （2）重绘

当页面中某些元素的样式发生变化，但是不会影响其在文档流中的位置时，浏览器就会对元素进行重新绘制，这个过程就是**重绘**。

下面这些操作会导致回流：

- color、background 相关属性：background-color、background-image 等 - outline 相关属性：outline-color、outline-width 、text-decoration - border-radius、visibility、box-shadow

注意： **当触发回流时，一定会触发重绘，但是重绘不一定会引发回流。**

 2. 如何避免回流与重绘？

**减少回流与重绘的措施：**

- 操作DOM时，尽量在低层级的DOM节点进行操作 - 不要使用 `table`布局， 一个小的改动可能会使整个 `table`进行重新布局 - 使用CSS的表达式 - 不要频繁操作元素的样式，对于静态页面，可以修改类名，而不是样式。 - 使用absolute或者fixed，使元素脱离文档流，这样他们发生变化就不会影响其他元素 - 避免频繁操作DOM，可以创建一个文档片段 `documentFragment`，在它上面应用所有DOM操作，最后再把它添加到文档中 - 将元素先设置 `display: none`，操作结束后再把它显示出来。因为在display属性为none的元素上进行的DOM操作不会引发回流和重绘。 - 将DOM的多个读操作（或者写操作）放在一起，而不是读写操作穿插着写。这得益于**浏览器的渲染队列机制**。

浏览器针对页面的回流与重绘，进行了自身的优化——**渲染队列**

**浏览器会将所有的回流、重绘的操作放在一个队列中，当队列中的操作到了一定的数量或者到了一定的时间间隔，浏览器就会对队列进行批处理。这样就会让多次的回流、重绘变成一次回流重绘。**

上面，将多个读操作（或者写操作）放在一起，就会等所有的读操作进入队列之后执行，这样，原本应该是触发多次回流，变成了只触发一次回流。

 3. 如何优化动画？

对于如何优化动画，我们知道，一般情况下，动画需要频繁的操作DOM，就就会导致页面的性能问题，我们可以将动画的 `position`属性设置为 `absolute`或者 `fixed`，将动画脱离文档流，这样他的回流就不会影响到页面了。

 4. documentFragment 是什么？用它跟直接操作 DOM 的区别是什么？

MDN中对 `documentFragment`的解释：

DocumentFragment，文档片段接口，一个没有父对象的最小文档对象。它被作为一个轻量版的 Document使用，就像标准的document一样，存储由节点（nodes）组成的文档结构。与document相比，最大的区别是DocumentFragment不是真实 DOM 树的一部分，它的变化不会触发 DOM 树的重新渲染，且不会导致性能等问题。

当我们把一个 DocumentFragment 节点插入文档树时，插入的不是 DocumentFragment 自身，而是它的所有子孙节点。在频繁的DOM操作时，我们就可以将DOM元素插入DocumentFragment，之后一次性的将所有的子孙节点插入文档中。和直接操作DOM相比，将DocumentFragment 节点插入DOM树时，不会触发页面的重绘，这样就大大提高了页面的性能。

## 四、节流与防抖

 1. 对节流与防抖的理解

- 函数防抖是指在事件被触发 n 秒后再执行回调，如果在这 n 秒内事件又被触发，则重新计时。这可以使用在一些点击请求的事件上，避免因为用户的多次点击向后端发送多次请求。 - 函数节流是指规定一个单位时间，在这个单位时间内，只能有一次触发事件的回调函数执行，如果在同一个单位时间内某事件被触发多次，只有一次能生效。节流可以使用在 scroll 函数的事件监听上，通过事件节流来降低事件调用的频率。

**防抖函数的应用场景：**

- 按钮提交场景：防⽌多次提交按钮，只执⾏最后提交的⼀次 - 服务端验证场景：表单验证需要服务端配合，只执⾏⼀段连续的输⼊事件的最后⼀次，还有搜索联想词功能类似⽣存环境请⽤lodash.debounce

**节流函数的适⽤场景：**

- 拖拽场景：固定时间内只执⾏⼀次，防⽌超⾼频次触发位置变动 - 缩放场景：监控浏览器resize - 动画场景：避免短时间内多次触发动画引起性能问题

 2. 实现节流函数和防抖函数

**函数防抖的实现：**```

function debounce(fn, wait) {

  var timer = null;

  return function() {

    var context = this,

      args = [...arguments];

    // 如果此时存在定时器的话，则取消之前的定时器重新记时

    if (timer) {

      clearTimeout(timer);

      timer = null;

    }

    // 设置定时器，使事件间隔指定事件后执行

    timer = setTimeout(() => {

      fn.apply(context, args);

    }, wait);

  };

}

**函数节流的实现：**

// 时间戳版

function throttle(fn, delay) {

  var preTime = Date.now();

  return function() {

    var context = this,

      args = [...arguments],

      nowTime = Date.now();

    // 如果两次时间间隔超过了指定时间，则执行函数。

    if (nowTime - preTime >= delay) {

      preTime = Date.now();

      return fn.apply(context, args);

    }

  };

}

// 定时器版

function throttle (fun, wait){

  let timeout = null

  return function(){

    let context = this

    let args = [...arguments]

    if(!timeout){

      timeout = setTimeout(() => {

        fun.apply(context, args)

        timeout = null 

      }, wait)

    }

  }

}

五、图片优化

 1. 如何对项目中的图片进行优化？

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

 2. 常见的图片格式及使用场景

（1）**BMP**是无损的、既支持索引色也支持直接色的点阵图。这种图片格式几乎没有对数据进行压缩，所以BMP格式的图片通常是较大的文件。

（2）**GIF**是无损的、采用索引色的点阵图。采用LZW压缩算法进行编码。文件小，是GIF格式的优点，同时，GIF格式还具有支持动画以及透明的优点。但是GIF格式仅支持8bit的索引色，所以GIF格式适用于对色彩要求不高同时需要文件体积较小的场景。

（3）**JPEG**是有损的、采用直接色的点阵图。JPEG的图片的优点是采用了直接色，得益于更丰富的色彩，JPEG非常适合用来存储照片，与GIF相比，JPEG不适合用来存储企业Logo、线框类的图。因为有损压缩会导致图片模糊，而直接色的选用，又会导致图片文件较GIF更大。

（4）**PNG-8**是无损的、使用索引色的点阵图。PNG是一种比较新的图片格式，PNG-8是非常好的GIF格式替代者，在可能的情况下，应该尽可能的使用PNG-8而不是GIF，因为在相同的图片效果下，PNG-8具有更小的文件体积。除此之外，PNG-8还支持透明度的调节，而GIF并不支持。除非需要动画的支持，否则没有理由使用GIF而不是PNG-8。

（5）**PNG-24**是无损的、使用直接色的点阵图。PNG-24的优点在于它压缩了图片的数据，使得同样效果的图片，PNG-24格式的文件大小要比BMP小得多。当然，PNG24的图片还是要比JPEG、GIF、PNG-8大得多。

（6）**SVG**是无损的矢量图。SVG是矢量图意味着SVG图片由直线和曲线以及绘制它们的方法组成。当放大SVG图片时，看到的还是线和曲线，而不会出现像素点。这意味着SVG图片在放大时，不会失真，所以它非常适合用来绘制Logo、Icon等。

（7）**WebP**是谷歌开发的一种新图片格式，WebP是同时支持有损和无损压缩的、使用直接色的点阵图。从名字就可以看出来它是为Web而生的，什么叫为Web而生呢？就是说相同质量的图片，WebP具有更小的文件体积。现在网站上充满了大量的图片，如果能够降低每一个图片的文件大小，那么将大大减少浏览器和服务器之间的数据传输量，进而降低访问延迟，提升访问体验。目前只有Chrome浏览器和Opera浏览器支持WebP格式，兼容性不太好。

- 在无损压缩的情况下，相同质量的WebP图片，文件大小要比PNG小26%； - 在有损压缩的情况下，具有相同图片精度的WebP图片，文件大小要比JPEG小25%~34%； - WebP图片格式支持图片透明度，一个无损压缩的WebP图片，如果要支持透明度只需要22%的格外文件大小。

六、Webpack优化

 1. 如何提⾼webpack的打包速度?

# （1）优化 Loader

对于 Loader 来说，影响打包效率首当其冲必属 Babel 了。因为 Babel 会将代码转为字符串生成 AST，然后对 AST 继续进行转变最后再生成新的代码，项目越大，**转换代码越多，效率就越低**。当然了，这是可以优化的。

首先我们**优化 Loader 的文件搜索范围**

module.exports = {

  module: {

    rules: [

      {

        // js 文件才使用 babel

        test: /\.js$/,

        loader: 'babel-loader',

        // 只在 src 文件夹下查找

        include: [resolve('src')],

        // 不会去查找的路径

        exclude: /node_modules/

      }

    ]

  }

}

对于 Babel 来说，希望只作用在 JS 代码上的，然后 `node_modules` 中使用的代码都是编译过的，所以完全没有必要再去处理一遍。

当然这样做还不够，还可以将 Babel 编译过的文件**缓存**起来，下次只需要编译更改过的代码文件即可，这样可以大幅度加快打包时间

loader: 'babel-loader?cacheDirectory=true'

（2）HappyPack

受限于 Node 是单线程运行的，所以 Webpack 在打包的过程中也是单线程的，特别是在执行 Loader 的时候，长时间编译的任务很多，这样就会导致等待的情况。

**HappyPack 可以将 Loader 的同步执行转换为并行的**，这样就能充分利用系统资源来加快打包效率了

module: {

  loaders: [

    {

      test: /\.js$/,

      include: [resolve('src')],

      exclude: /node_modules/,

      // id 后面的内容对应下面

      loader: 'happypack/loader?id=happybabel'

    }

  ]

},

plugins: [

  new HappyPack({

    id: 'happybabel',

    loaders: ['babel-loader?cacheDirectory'],

    // 开启 4 个线程

    threads: 4

  })

]

（3）DllPlugin

**DllPlugin 可以将特定的类库提前打包然后引入**。这种方式可以极大的减少打包类库的次数，只有当类库更新版本才有需要重新打包，并且也实现了将公共代码抽离成单独文件的优化方案。DllPlugin的使用方法如下：

// 单独配置在一个文件中

// webpack.dll.conf.js

const path = require('path')

const webpack = require('webpack')

module.exports = {

  entry: {

    // 想统一打包的类库

    vendor: ['react']

  },

  output: {

    path: path.join(__dirname, 'dist'),

    filename: '[name].dll.js',

    library: '[name]-[hash]'

  },

  plugins: [

    new webpack.DllPlugin({

      // name 必须和 output.library 一致

      name: '[name]-[hash]',

      // 该属性需要与 DllReferencePlugin 中一致

      context: __dirname,

      path: path.join(__dirname, 'dist', '[name]-manifest.json')

    })

  ]

}

然后需要执行这个配置文件生成依赖文件，接下来需要使用 `DllReferencePlugin` 将依赖文件引入项目中

// webpack.conf.js

module.exports = {

  // ...省略其他配置

  plugins: [

    new webpack.DllReferencePlugin({

      context: __dirname,

      // manifest 就是之前打包出来的 json 文件

      manifest: require('./dist/vendor-manifest.json'),

    })

  ]

}

（4）代码压缩

在 Webpack3 中，一般使用 `UglifyJS` 来压缩代码，但是这个是单线程运行的，为了加快效率，可以使用 `webpack-parallel-uglify-plugin` 来并行运行 `UglifyJS`，从而提高效率。

在 Webpack4 中，不需要以上这些操作了，只需要将 `mode` 设置为 `production` 就可以默认开启以上功能。代码压缩也是我们必做的性能优化方案，当然我们不止可以压缩 JS 代码，还可以压缩 HTML、CSS 代码，并且在压缩 JS 代码的过程中，我们还可以通过配置实现比如删除 `console.log` 这类代码的功能。

 （5）其他

可以通过一些小的优化点来加快打包速度

- `resolve.extensions`：用来表明文件后缀列表，默认查找顺序是 `['.js', '.json']`，如果你的导入文件没有添加后缀就会按照这个顺序查找文件。我们应该尽可能减少后缀列表长度，然后将出现频率高的后缀排在前面 - `resolve.alias`：可以通过别名的方式来映射一个路径，能让 Webpack 更快找到路径 - `module.noParse`：如果你确定一个文件下没有其他依赖，就可以使用该属性让 Webpack 不扫描该文件，这种方式对于大型的类库很有帮助

 2. 如何减少 Webpack 打包体积

 （1）按需加载

在开发 SPA 项目的时候，项目中都会存在很多路由页面。如果将这些页面全部打包进一个 JS 文件的话，虽然将多个请求合并了，但是同样也加载了很多并不需要的代码，耗费了更长的时间。那么为了首页能更快地呈现给用户，希望首页能加载的文件体积越小越好，**这时候就可以使用按需加载，将每个路由页面单独打包为一个文件**。当然不仅仅路由可以按需加载，对于 `loadash` 这种大型类库同样可以使用这个功能。

按需加载的代码实现这里就不详细展开了，因为鉴于用的框架不同，实现起来都是不一样的。当然了，虽然他们的用法可能不同，但是底层的机制都是一样的。都是当使用的时候再去下载对应文件，返回一个 `Promise`，当 `Promise` 成功以后去执行回调。

 （2）Scope Hoisting

**Scope Hoisting 会分析出模块之间的依赖关系，尽可能的把打包出来的模块合并到一个函数中去。**

比如希望打包两个文件：

// test.js

export const a = 1

// index.js

import { a } from './test.js'

对于这种情况，打包出来的代码会类似这样：

[

  /* 0 */

  function (module, exports, require) {

    //...

  },

  /* 1 */

  function (module, exports, require) {

    //...

  }

]

但是如果使用 Scope Hoisting ，代码就会尽可能的合并到一个函数中去，也就变成了这样的类似代码：

[

  /* 0 */

  function (module, exports, require) {

    //...

  }

]

这样的打包方式生成的代码明显比之前的少多了。如果在 Webpack4 中你希望开启这个功能，只需要启用 `optimization.concatenateModules` 就可以了：

module.exports = {

  optimization: {

    concatenateModules: true

  }

}

（3）Tree Shaking

**Tree Shaking 可以实现删除项目中未被引用的代码**，比如：

// test.js

export const a = 1

export const b = 2

// index.js

import { a } from './test.js'

对于以上情况，`test` 文件中的变量 `b` 如果没有在项目中使用到的话，就不会被打包到文件中。

如果使用 Webpack 4 的话，开启生产环境就会自动启动这个优化功能。

 3. 如何⽤webpack来优化前端性能？

⽤webpack优化前端性能是指优化webpack的输出结果，让打包的最终结果在浏览器运⾏快速⾼效。

- **压缩代码**：删除多余的代码、注释、简化代码的写法等等⽅式。可以利⽤webpack的 UglifyJsPlugin 和 ParallelUglifyPlugin 来压缩JS⽂件， 利⽤ cssnano （css-loader?minimize）来压缩css - **利⽤CDN加速**: 在构建过程中，将引⽤的静态资源路径修改为CDN上对应的路径。可以利⽤webpack对于 output 参数和各loader的 publicPath 参数来修改资源路径 - **Tree Shaking**: 将代码中永远不会⾛到的⽚段删除掉。可以通过在启动webpack时追加参数 --optimize-minimize 来实现 - **Code Splitting**: 将代码按路由维度或者组件分块(chunk),这样做到按需加载,同时可以充分利⽤浏览器缓存 - **提取公共第三⽅库**: SplitChunksPlugin插件来进⾏公共模块抽取,利⽤浏览器缓存可以⻓期缓存这些⽆需频繁变动的公共代码

 4. 如何提⾼webpack的构建速度？

1. 多⼊⼝情况下，使⽤ CommonsChunkPlugin 来提取公共代码 2. 通过 externals 配置来提取常⽤库 3. 利⽤ DllPlugin 和 DllReferencePlugin 预编译资源模块 通过 DllPlugin 来对那些我们引⽤但是绝对不会修改的npm包来进⾏预编译，再通过 DllReferencePlugin 将预编译的模块加载进来。 4. 使⽤ Happypack 实现多线程加速编译 5. 使⽤ webpack-uglify-parallel 来提升 uglifyPlugin 的压缩速度。 原理上 webpack-uglify-parallel 采⽤了多核并⾏压缩来提升压缩速度 6. 使⽤ Tree-shaking 和 Scope Hoisting 来剔除多余代码

前端工程化面试题

一、Git

 1. git 和 svn 的区别

- git 和 svn 最大的区别在于 git 是分布式的，而 svn 是集中式的。因此我们不能再离线的情况下使用 svn。如果服务器出现问题，就没有办法使用 svn 来提交代码。 - svn 中的分支是整个版本库的复制的一份完整目录，而 git 的分支是指针指向某次提交，因此 git 的分支创建更加开销更小并且分支上的变化不会影响到其他人。svn 的分支变化会影响到所有的人。 - svn 的指令相对于 git 来说要简单一些，比 git 更容易上手。 - GIT把内容按元数据方式存储，而SVN是按文件：因为git目录是处于个人机器上的一个克隆版的版本库，它拥有中心版本库上所有的东西，例如标签，分支，版本记录等。 - GIT分支和SVN的分支不同：svn会发生分支遗漏的情况，而git可以同一个工作目录下快速的在几个分支间切换，很容易发现未被合并的分支，简单而快捷的合并这些文件。 - GIT没有一个全局的版本号，而SVN有 - GIT的内容完整性要优于SVN：GIT的内容存储使用的是SHA-1哈希算法。这能确保代码内容的完整性，确保在遇到磁盘故障和网络问题时降低对版本库的破坏

 2. 经常使用的 git 命令？

``` git init                     // 新建 git 代码库 git add                      // 添加指定文件到暂存区 git rm                       // 删除工作区文件，并且将这次删除放入暂存区 git commit -m [message]      // 提交暂存区到仓库区 git branch                   // 列出所有分支 git checkout -b [branch]     // 新建一个分支，并切换到该分支 git status                   // 显示有变更文件的状态

```

 3. git pull 和 git fetch 的区别

- git fetch 只是将远程仓库的变化下载下来，并没有和本地分支合并。 - git pull 会将远程仓库的变化下载下来，并和当前分支合并。

 4. git rebase 和 git merge 的区别

git merge 和 git rebase 都是用于分支合并，关键**在** **commit 记录的处理上不同**：

- git merge 会新建一个新的 commit 对象，然后两个分支以前的 commit 记录都指向这个新 commit 记录。这种方法会保留之前每个分支的 commit 历史。 - git rebase 会先找到两个分支的第一个共同的 commit 祖先记录，然后将提取当前分支这之后的所有 commit 记录，然后将这个 commit 记录添加到目标分支的最新提交后面。经过这个合并后，两个分支合并后的 commit 记录就变为了线性的记录了。

二、Webpack

 1. webpack与grunt、gulp的不同？

**Grunt****、Gulp是基于任务运⾏的⼯具**： 它们会⾃动执⾏指定的任务，就像流⽔线，把资源放上去然后通过不同插件进⾏加⼯，它们包含活跃的社区，丰富的插件，能⽅便的打造各种⼯作流。

**Webpack是基于模块化打包的⼯具:** ⾃动化处理模块，webpack把⼀切当成模块，当 webpack 处理应⽤程序时，它会递归地构建⼀个依赖关系图 (dependency graph)，其中包含应⽤程序需要的每个模块，然后将所有这些模块打包成⼀个或多个 bundle。

因此这是完全不同的两类⼯具,⽽现在主流的⽅式是⽤npm script代替Grunt、Gulp，npm script同样可以打造任务流。

 2. webpack、rollup、parcel优劣？

- webpack适⽤于⼤型复杂的前端站点构建: webpack有强⼤的loader和插件⽣态,打包后的⽂件实际上就是⼀个⽴即执⾏函数，这个⽴即执⾏函数接收⼀个参数，这个参数是模块对象，键为各个模块的路径，值为模块内容。⽴即执⾏函数内部则处理模块之间的引⽤，执⾏模块等,这种情况更适合⽂件依赖复杂的应⽤开发。 - rollup适⽤于基础库的打包，如vue、d3等: Rollup 就是将各个模块打包进⼀个⽂件中，并且通过 Tree-shaking 来删除⽆⽤的代码,可以最⼤程度上降低代码体积,但是rollup没有webpack如此多的的如代码分割、按需加载等⾼级功能，其更聚焦于库的打包，因此更适合库的开发。 - parcel适⽤于简单的实验性项⽬: 他可以满⾜低⻔槛的快速看到效果,但是⽣态差、报错信息不够全⾯都是他的硬伤，除了⼀些玩具项⽬或者实验项⽬不建议使⽤。

 3. 有哪些常⻅的Loader？

- file-loader：把⽂件输出到⼀个⽂件夹中，在代码中通过相对 URL 去引⽤输出的⽂件 - url-loader：和 file-loader 类似，但是能在⽂件很⼩的情况下以 base64 的⽅式把⽂件内容注⼊到代码中去 - source-map-loader：加载额外的 Source Map ⽂件，以⽅便断点调试 - image-loader：加载并且压缩图⽚⽂件 - babel-loader：把 ES6 转换成 ES5 - css-loader：加载 CSS，⽀持模块化、压缩、⽂件导⼊等特性 - style-loader：把 CSS 代码注⼊到 JavaScript 中，通过 DOM 操作去加载 CSS。 - eslint-loader：通过 ESLint 检查 JavaScript 代码

**注意：在Webpack中，loader的执行顺序是从右向左**执行的。因为webpack选择了**compose这样的函数式编程方式**，这种方式的表达式执行是从右向左的。

 4. 有哪些常⻅的Plugin？

- define-plugin：定义环境变量 - html-webpack-plugin：简化html⽂件创建 - uglifyjs-webpack-plugin：通过 UglifyES 压缩 ES6 代码 - webpack-parallel-uglify-plugin: 多核压缩，提⾼压缩速度 - webpack-bundle-analyzer: 可视化webpack输出⽂件的体积 - mini-css-extract-plugin: CSS提取到单独的⽂件中，⽀持按需加载

 5. bundle，chunk，module是什么？

- bundle：是由webpack打包出来的⽂件； - chunk：代码块，⼀个chunk由多个模块组合⽽成，⽤于代码的合并和分割； - module：是开发中的单个模块，在webpack的世界，⼀切皆模块，⼀个模块对应⼀个⽂件，webpack会从配置的 entry中递归开始找出所有依赖的模块。

 6. Loader和Plugin的不同？

不同的作⽤:

- Loader直译为"加载器"。Webpack将⼀切⽂件视为模块，但是webpack原⽣是只能解析js⽂件，如果想将其他⽂件也打包的话，就会⽤到 loader 。 所以Loader的作⽤是让webpack拥有了加载和解析⾮JavaScript⽂件的能⼒。 - Plugin直译为"插件"。Plugin可以扩展webpack的功能，让webpack具有更多的灵活性。 在 Webpack 运⾏的⽣命周期中会⼴播出许多事件，Plugin 可以监听这些事件，在合适的时机通过 Webpack 提供的 API 改变输出结果。

不同的⽤法:

- Loader在 module.rules 中配置，也就是说他作为模块的解析规则⽽存在。 类型为数组，每⼀项都是⼀个 Object ，⾥⾯描述了对于什么类型的⽂件（ test ），使⽤什么加载( loader )和使⽤的参数（ options ） - Plugin在 plugins 中单独配置。 类型为数组，每⼀项是⼀个 plugin 的实例，参数都通过构造函数传⼊。

 7. webpack的构建流程

Webpack 的运⾏流程是⼀个串⾏的过程，从启动到结束会依次执⾏以下流程：

1. 初始化参数：从配置⽂件和 Shell 语句中读取与合并参数，得出最终的参数； 2. 开始编译：⽤上⼀步得到的参数初始化 Compiler 对象，加载所有配置的插件，执⾏对象的 run ⽅法开始执⾏编译； 3. 确定⼊⼝：根据配置中的 entry 找出所有的⼊⼝⽂件； 4. 编译模块：从⼊⼝⽂件出发，调⽤所有配置的 Loader 对模块进⾏翻译，再找出该模块依赖的模块，再递归本步骤直到所有⼊⼝依赖的⽂件都经过了本步骤的处理； 5. 完成模块编译：在经过第4步使⽤ Loader 翻译完所有模块后，得到了每个模块被翻译后的最终内容以及它们之间的依赖关系； 6. 输出资源：根据⼊⼝和模块之间的依赖关系，组装成⼀个个包含多个模块的 Chunk，再把每个 Chunk 转换成⼀个单独的⽂件加⼊到输出列表，这步是可以修改输出内容的最后机会； 7. 输出完成：在确定好输出内容后，根据配置确定输出的路径和⽂件名，把⽂件内容写⼊到⽂件系统。

在以上过程中，Webpack 会在特定的时间点⼴播出特定的事件，插件在监听到感兴趣的事件后会执⾏特定的逻辑，并且插件可以调⽤ Webpack 提供的 API 改变 Webpack 的运⾏结果。

 8. 编写loader或plugin的思路？

Loader像⼀个"翻译官"把读到的源⽂件内容转义成新的⽂件内容，并且每个Loader通过链式操作，将源⽂件⼀步步翻译成想要的样⼦。

编写Loader时要遵循单⼀原则，每个Loader只做⼀种"转义"⼯作。 每个Loader的拿到的是源⽂件内容（source），可以通过返回值的⽅式将处理后的内容输出，也可以调⽤ this.callback() ⽅法，将内容返回给webpack。 还可以通过this.async() ⽣成⼀个 callback 函数，再⽤这个callback将处理后的内容输出出去。 此外 webpack 还为开发者准备了开发loader的⼯具函数集——loader-utils 。

相对于Loader⽽⾔，Plugin的编写就灵活了许多。 webpack在运⾏的⽣命周期中会⼴播出许多事件，Plugin 可以监听这些事件，在合适的时机通过 Webpack 提供的 API 改变输出结果。

 9. webpack的热更新是如何做到的？说明其原理？

webpack的热更新⼜称热替换（Hot Module Replacement），缩写为HMR。 这个机制可以做到不⽤刷新浏览器⽽将新变更的模块替换掉旧的模块。

原理：

⾸先要知道server端和client端都做了处理⼯作：

1. 第⼀步，在 webpack 的 watch 模式下，⽂件系统中某⼀个⽂件发⽣修改，webpack 监听到⽂件变化，根据配置⽂件对模块重新编译打包，并将打包后的代码通过简单的 JavaScript 对象保存在内存中。 2. 第⼆步是 webpack-dev-server 和 webpack 之间的接⼝交互，⽽在这⼀步，主要是 dev-server 的中间件 webpack-dev-middleware 和 webpack 之间的交互，webpack-dev-middleware 调⽤ webpack 暴露的 API对代码变化进⾏监 控，并且告诉 webpack，将代码打包到内存中。 3. 第三步是 webpack-dev-server 对⽂件变化的⼀个监控，这⼀步不同于第⼀步，并不是监控代码变化重新打包。当我们在配置⽂件中配置了devServer.watchContentBase 为 true 的时候，Server 会监听这些配置⽂件夹中静态⽂件的变化，变化后会通知浏览器端对应⽤进⾏ live reload。注意，这⼉是浏览器刷新，和 HMR 是两个概念。 4. 第四步也是 webpack-dev-server 代码的⼯作，该步骤主要是通过 sockjs（webpack-dev-server 的依赖）在浏览器端和服务端之间建⽴⼀个 websocket ⻓连接，将 webpack 编译打包的各个阶段的状态信息告知浏览器端，同时也包括第三步中 Server 监听静态⽂件变化的信息。浏览器端根据这些 socket 消息进⾏不同的操作。当然服务端传递的最主要信息还是新模块的 hash 值，后⾯的步骤根据这⼀ hash 值来进⾏模块热替换。 5. webpack-dev-server/client 端并不能够请求更新的代码，也不会执⾏热更模块操作，⽽把这些⼯作⼜交回给了webpack，webpack/hot/dev-server 的⼯作就是根据 webpack-dev-server/client 传给它的信息以及 dev-server 的配置决定是刷新浏览器呢还是进⾏模块热更新。当然如果仅仅是刷新浏览器，也就没有后⾯那些步骤了。 6. HotModuleReplacement.runtime 是客户端 HMR 的中枢，它接收到上⼀步传递给他的新模块的 hash 值，它通过JsonpMainTemplate.runtime 向 server 端发送 Ajax 请求，服务端返回⼀个 json，该 json 包含了所有要更新的模块的 hash 值，获取到更新列表后，该模块再次通过 jsonp 请求，获取到最新的模块代码。这就是上图中 7、8、9 步骤。 7. ⽽第 10 步是决定 HMR 成功与否的关键步骤，在该步骤中，HotModulePlugin 将会对新旧模块进⾏对⽐，决定是否更新模块，在决定更新模块后，检查模块之间的依赖关系，更新模块的同时更新模块间的依赖引⽤。 8. 最后⼀步，当 HMR 失败后，回退到 live reload 操作，也就是进⾏浏览器刷新来获取最新打包代码。

大概流程是我们用webpack-dev-server启动一个服务之后，浏览器和服务端是通过websocket进行长连接，webpack内部实现的watch就会监听文件修改，只要有修改就webpack会重新打包编译到内存中，然后webpack-dev-server依赖中间件webpack-dev-middleware和webpack之间进行交互，每次热更新都会请求一个携带hash值的json文件和一个js，websocker传递的也是hash值，内部机制通过hash值检查进行热更新， 至于内部原理，因为水平限制，目前还看不懂。

 10. 如何⽤webpack来优化前端性能？

⽤webpack优化前端性能是指优化webpack的输出结果，让打包的最终结果在浏览器运⾏快速⾼效。

- **压缩代码**：删除多余的代码、注释、简化代码的写法等等⽅式。可以利⽤webpack的 UglifyJsPlugin 和 ParallelUglifyPlugin 来压缩JS⽂件， 利⽤ cssnano （css-loader?minimize）来压缩css - **利⽤CDN加速**: 在构建过程中，将引⽤的静态资源路径修改为CDN上对应的路径。可以利⽤webpack对于 output 参数和各loader的 publicPath 参数来修改资源路径 - **Tree Shaking**: 将代码中永远不会⾛到的⽚段删除掉。可以通过在启动webpack时追加参数 --optimize-minimize 来实现 - **Code Splitting**: 将代码按路由维度或者组件分块(chunk),这样做到按需加载,同时可以充分利⽤浏览器缓存 - **提取公共第三⽅库**: SplitChunksPlugin插件来进⾏公共模块抽取,利⽤浏览器缓存可以⻓期缓存这些⽆需频繁变动的公共代码

 11. 如何提⾼webpack的打包速度?

- happypack: 利⽤进程并⾏编译loader,利⽤缓存来使得 rebuild 更快,遗憾的是作者表示已经不会继续开发此项⽬,类似的替代者是thread-loader - 外部扩展(externals): 将不怎么需要更新的第三⽅库脱离webpack打包，不被打⼊bundle中，从⽽减少打包时间，⽐如jQuery⽤script标签引⼊ - dll: 采⽤webpack的 DllPlugin 和 DllReferencePlugin 引⼊dll，让⼀些基本不会改动的代码先打包成静态资源，避免反复编译浪费时间 - 利⽤缓存: webpack.cache 、babel-loader.cacheDirectory、 HappyPack.cache 都可以利⽤缓存提⾼rebuild效率缩⼩⽂件搜索范围: ⽐如babel-loader插件,如果你的⽂件仅存在于src中,那么可以 include: path.resolve(__dirname,‘src’) ,当然绝⼤多数情况下这种操作的提升有限，除⾮不⼩⼼build了node_modules⽂件

 12. 如何提⾼webpack的构建速度？

1. 多⼊⼝情况下，使⽤ CommonsChunkPlugin 来提取公共代码 2. 通过 externals 配置来提取常⽤库 3. 利⽤ DllPlugin 和 DllReferencePlugin 预编译资源模块 通过 DllPlugin 来对那些我们引⽤但是绝对不会修改的npm包来进⾏预编译，再通过 DllReferencePlugin 将预编译的模块加载进来。 4. 使⽤ Happypack 实现多线程加速编译 5. 使⽤ webpack-uglify-parallel 来提升 uglifyPlugin 的压缩速度。 原理上 webpack-uglify-parallel 采⽤了多核并⾏压缩来提升压缩速度 6. 使⽤ Tree-shaking 和 Scope Hoisting 来剔除多余代码

 13. 怎么配置单⻚应⽤？怎么配置多⻚应⽤？

单⻚应⽤可以理解为webpack的标准模式，直接在 entry 中指定单⻚应⽤的⼊⼝即可，这⾥不再赘述多⻚应⽤的话，可以使⽤webpack的 AutoWebPlugin 来完成简单⾃动化的构建，但是前提是项⽬的⽬录结构必须遵守他预设的规范。 多⻚应⽤中要注意的是：

- 每个⻚⾯都有公共的代码，可以将这些代码抽离出来，避免重复的加载。⽐如，每个⻚⾯都引⽤了同⼀套css样式表 - 随着业务的不断扩展，⻚⾯可能会不断的追加，所以⼀定要让⼊⼝的配置⾜够灵活，避免每次添加新⻚⾯还需要修改构建配置

三、其他

 Babel的原理是什么?

babel 的转译过程也分为三个阶段，这三步具体是：

- **解析 Parse**: 将代码解析⽣成抽象语法树（AST），即词法分析与语法分析的过程； - **转换 Transform**: 对于 AST 进⾏变换⼀系列的操作，babel 接受得到 AST 并通过 babel-traverse 对其进⾏遍历，在此过程中进⾏添加、更新及移除等操作； - **⽣成 Generate**: 将变换后的 AST 再转换为 JS 代码, 使⽤到的模块是 babel-generator。

一、浏览器安全

 1. 什么是 XSS 攻击？

# （1）概念

XSS 攻击指的是跨站脚本攻击，是一种代码注入攻击。攻击者通过在网站注入恶意脚本，使之在用户的浏览器上运行，从而盗取用户的信息如 cookie 等。

XSS 的本质是因为网站没有对恶意代码进行过滤，与正常的代码混合在一起了，浏览器没有办法分辨哪些脚本是可信的，从而导致了恶意代码的执行。

攻击者可以通过这种攻击方式可以进行以下操作：

- 获取页面的数据，如DOM、cookie、localStorage； - DOS攻击，发送合理请求，占用服务器资源，从而使用户无法访问服务器； - 破坏页面结构； - 流量劫持（将链接指向某网站）；

# （2）攻击类型

XSS 可以分为存储型、反射型和 DOM 型：

- 存储型指的是恶意脚本会存储在目标服务器上，当浏览器请求数据时，脚本从服务器传回并执行。 - 反射型指的是攻击者诱导用户访问一个带有恶意代码的 URL 后，服务器端接收数据后处理，然后把带有恶意代码的数据发送到浏览器端，浏览器端解析这段带有 XSS 代码的数据后当做脚本执行，最终完成 XSS 攻击。 - DOM 型指的通过修改页面的 DOM 节点形成的 XSS。

**1）存储型** **XSS** **的攻击步骤：**

1. 攻击者将恶意代码提交到⽬标⽹站的数据库中。 2. ⽤户打开⽬标⽹站时，⽹站服务端将恶意代码从数据库取出，拼接在 HTML 中返回给浏览器。 3. ⽤户浏览器接收到响应后解析执⾏，混在其中的恶意代码也被执⾏。 4. 恶意代码窃取⽤户数据并发送到攻击者的⽹站，或者冒充⽤户的⾏为，调⽤⽬标⽹站接⼝执⾏攻击者指定的操作。

这种攻击常⻅于带有⽤户保存数据的⽹站功能，如论坛发帖、商品评论、⽤户私信等。

**2）反射型** **XSS** **的攻击步骤：**

1. 攻击者构造出特殊的 URL，其中包含恶意代码。 2. ⽤户打开带有恶意代码的 URL 时，⽹站服务端将恶意代码从 URL 中取出，拼接在 HTML 中返回给浏览器。 3. ⽤户浏览器接收到响应后解析执⾏，混在其中的恶意代码也被执⾏。 4. 恶意代码窃取⽤户数据并发送到攻击者的⽹站，或者冒充⽤户的⾏为，调⽤⽬标⽹站接⼝执⾏攻击者指定的操作。

反射型 XSS 跟存储型 XSS 的区别是：存储型 XSS 的恶意代码存在数据库⾥，反射型 XSS 的恶意代码存在 URL ⾥。

反射型 XSS 漏洞常⻅于通过 URL 传递参数的功能，如⽹站搜索、跳转等。 由于需要⽤户主动打开恶意的 URL 才能⽣效，攻击者往往会结合多种⼿段诱导⽤户点击。

**3）DOM** **型** **XSS** **的攻击步骤：**

1. 攻击者构造出特殊的 URL，其中包含恶意代码。 2. ⽤户打开带有恶意代码的 URL。 3. ⽤户浏览器接收到响应后解析执⾏，前端 JavaScript 取出 URL 中的恶意代码并执⾏。 4. 恶意代码窃取⽤户数据并发送到攻击者的⽹站，或者冒充⽤户的⾏为，调⽤⽬标⽹站接⼝执⾏攻击者指定的操作。

DOM 型 XSS 跟前两种 XSS 的区别：DOM 型 XSS 攻击中，取出和执⾏恶意代码由浏览器端完成，属于前端JavaScript ⾃身的安全漏洞，⽽其他两种 XSS 都属于服务端的安全漏洞。

 2. 如何防御 XSS 攻击？

可以看到XSS危害如此之大， 那么在开发网站时就要做好防御措施，具体措施如下：

- 可以从浏览器的执行来进行预防，一种是使用纯前端的方式，不用服务器端拼接后返回（不使用服务端渲染）。另一种是对需要插入到 HTML 中的代码做好充分的转义。对于 DOM 型的攻击，主要是前端脚本的不可靠而造成的，对于数据获取渲染和字符串拼接的时候应该对可能出现的恶意代码情况进行判断。

- 使用 CSP ，CSP 的本质是建立一个白名单，告诉浏览器哪些外部资源可以加载和执行，从而防止恶意代码的注入攻击。

  > 1. CSP 指的是内容安全策略，它的本质是建立一个白名单，告诉浏览器哪些外部资源可以加载和执行。我们只需要配置规则，如何拦截由浏览器自己来实现。   > 2. 通常有两种方式来开启 CSP，一种是设置 HTTP 首部中的 Content-Security-Policy，一种是设置 meta 标签的方式 ``

- 对一些敏感信息进行保护，比如 cookie 使用 http-only，使得脚本无法获取。也可以使用验证码，避免脚本伪装成用户执行一些操作。

 3. 什么是 CSRF 攻击？

# （1）概念

CSRF 攻击指的是**跨站请求伪造攻击**，攻击者诱导用户进入一个第三方网站，然后该网站向被攻击网站发送跨站请求。如果用户在被攻击网站中保存了登录状态，那么攻击者就可以利用这个登录状态，绕过后台的用户验证，冒充用户向服务器执行一些操作。

CSRF 攻击的**本质是利用 cookie 会在同源请求中携带发送给服务器的特点，以此来实现用户的冒充。**

# （2）攻击类型

常见的 CSRF 攻击有三种：

- GET 类型的 CSRF 攻击，比如在网站中的一个 img 标签里构建一个请求，当用户打开这个网站的时候就会自动发起提交。 - POST 类型的 CSRF 攻击，比如构建一个表单，然后隐藏它，当用户进入页面时，自动提交这个表单。 - 链接类型的 CSRF 攻击，比如在 a 标签的 href 属性里构建一个请求，然后诱导用户去点击。

 4. 如何防御 CSRF 攻击？

**CSRF 攻击可以使用以下方法来防护：**

- **进行同源检测**，服务器根据 http 请求头中 origin 或者 referer 信息来判断请求是否为允许访问的站点，从而对请求进行过滤。当 origin 或者 referer 信息都不存在的时候，直接阻止请求。这种方式的缺点是有些情况下 referer 可以被伪造，同时还会把搜索引擎的链接也给屏蔽了。所以一般网站会允许搜索引擎的页面请求，但是相应的页面请求这种请求方式也可能被攻击者给利用。（Referer 字段会告诉服务器该网页是从哪个页面链接过来的） - **使用 CSRF Token 进行验证**，服务器向用户返回一个随机数 Token ，当网站再次发起请求时，在请求参数中加入服务器端返回的 token ，然后服务器对这个 token 进行验证。这种方法解决了使用 cookie 单一验证方式时，可能会被冒用的问题，但是这种方法存在一个缺点就是，我们需要给网站中的所有请求都添加上这个 token，操作比较繁琐。还有一个问题是一般不会只有一台网站服务器，如果请求经过负载平衡转移到了其他的服务器，但是这个服务器的 session 中没有保留这个 token 的话，就没有办法验证了。这种情况可以通过改变 token 的构建方式来解决。 - **对Cookie 进行双重验证**，服务器在用户访问网站页面时，向请求域名注入一个Cookie，内容为随机字符串，然后当用户再次向服务器发送请求的时候，从 cookie 中取出这个字符串，添加到 URL 参数中，然后服务器通过对 cookie 中的数据和参数中的数据进行比较，来进行验证。使用这种方式是利用了攻击者只能利用 cookie，但是不能访问获取 cookie 的特点。并且这种方法比 CSRF Token 的方法更加方便，并且不涉及到分布式访问的问题。这种方法的缺点是如果网站存在 XSS 漏洞的，那么这种方式会失效。同时这种方式不能做到子域名的隔离。 - **在设置 cookie 属性的时候设置 Samesite ，限制 cookie 不能作为被第三方使用**，从而可以避免被攻击者利用。Samesite 一共有两种模式，一种是严格模式，在严格模式下 cookie 在任何情况下都不可能作为第三方 Cookie 使用，在宽松模式下，cookie 可以被请求是 GET 请求，且会发生页面跳转的请求所使用。

 5. 什么是中间人攻击？如何防范中间人攻击？

中间⼈ (Man-in-the-middle attack, MITM) 是指攻击者与通讯的两端分别创建独⽴的联系, 并交换其所收到的数据, 使通讯的两端认为他们正在通过⼀个私密的连接与对⽅直接对话, 但事实上整个会话都被攻击者完全控制。在中间⼈攻击中，攻击者可以拦截通讯双⽅的通话并插⼊新的内容。

攻击过程如下:

- 客户端发送请求到服务端，请求被中间⼈截获 - 服务器向客户端发送公钥 - 中间⼈截获公钥，保留在⾃⼰⼿上。然后⾃⼰⽣成⼀个**伪造的**公钥，发给客户端 - 客户端收到伪造的公钥后，⽣成加密hash值发给服务器 - 中间⼈获得加密hash值，⽤⾃⼰的私钥解密获得真秘钥,同时⽣成假的加密hash值，发给服务器 - 服务器⽤私钥解密获得假密钥,然后加密数据传输给客户端

 6. 有哪些可能引起前端安全的问题?

- 跨站脚本 (Cross-Site Scripting, XSS): ⼀种代码注⼊⽅式, 为了与 CSS 区分所以被称作 XSS。早期常⻅于⽹络论坛, 起因是⽹站没有对⽤户的输⼊进⾏严格的限制, 使得攻击者可以将脚本上传到帖⼦让其他⼈浏览到有恶意脚本的⻚⾯, 其注⼊⽅式很简单包括但不限于 JavaScript / CSS / Flash 等； - iframe的滥⽤: iframe中的内容是由第三⽅来提供的，默认情况下他们不受控制，他们可以在iframe中运⾏JavaScirpt脚本、Flash插件、弹出对话框等等，这可能会破坏前端⽤户体验； - 跨站点请求伪造（Cross-Site Request Forgeries，CSRF）: 指攻击者通过设置好的陷阱，强制对已完成认证的⽤户进⾏⾮预期的个⼈信息或设定信息等某些状态更新，属于被动攻击 - 恶意第三⽅库: ⽆论是后端服务器应⽤还是前端应⽤开发，绝⼤多数时候都是在借助开发框架和各种类库进⾏快速开发，⼀旦第三⽅库被植⼊恶意代码很容易引起安全问题。

 7. 网络劫持有哪几种，如何防范？

⽹络劫持分为两种:

（1）**DNS劫持**: (输⼊京东被强制跳转到淘宝这就属于dns劫持)

- DNS强制解析: 通过修改运营商的本地DNS记录，来引导⽤户流量到缓存服务器 - 302跳转的⽅式: 通过监控⽹络出⼝的流量，分析判断哪些内容是可以进⾏劫持处理的,再对劫持的内存发起302跳转的回复，引导⽤户获取内容

（2）**HTTP劫持**: (访问⾕歌但是⼀直有贪玩蓝⽉的⼴告),由于http明⽂传输,运营商会修改你的http响应内容(即加⼴告)

DNS劫持由于涉嫌违法，已经被监管起来，现在很少会有DNS劫持，⽽http劫持依然⾮常盛⾏，最有效的办法就是全站HTTPS，将HTTP加密，这使得运营商⽆法获取明⽂，就⽆法劫持你的响应内容。

 二、进程与线程

 1. 进程与线程的概念

从本质上说，进程和线程都是 CPU 工作时间片的一个描述：

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

**进程是资源分配的最小单位，线程是CPU调度的最小单位。**

一个进程就是一个程序的运行实例。详细解释就是，启动一个程序的时候，操作系统会为该程序创建一块内存，用来存放代码、运行中的数据和一个执行任务的主线程，我们把这样的一个运行环境叫**进程**。**进程是运行在虚拟内存上的，虚拟内存是用来解决用户对硬件资源的无限需求和有限的硬件资源之间的矛盾的。从操作系统角度来看，虚拟内存即交换文件；从处理器角度看，虚拟内存即虚拟地址空间。**

如果程序很多时，内存可能会不够，操作系统为每个进程提供一套独立的虚拟地址空间，从而使得同一块物理内存在不同的进程中可以对应到不同或相同的虚拟地址，变相的增加了程序可以使用的内存。

进程和线程之间的关系有以下四个特点：

（1）进程中的任意一线程执行出错，都会导致整个进程的崩溃。

（2）线程之间共享进程中的数据。

（3）当一个进程关闭之后，操作系统会回收进程所占用的内存，**当一个进程退出时，操作系统会回收该进程所申请的所有资源；即使其中任意线程因为操作不当导致内存泄漏，当进程退出时，这些内存也会被正确回收。

（4）进程之间的内容相互隔离。**进程隔离就是为了使操作系统中的进程互不干扰，每一个进程只能访问自己占有的数据，也就避免出现进程 A 写入数据到进程 B 的情况。正是因为进程之间的数据是严格隔离的，所以一个进程如果崩溃了，或者挂起了，是不会影响到其他进程的。如果进程之间需要进行数据的通信，这时候，就需要使用用于进程间通信的机制了。

最新的 Chrome 浏览器包括：

- 1 个浏览器主进程 - 1 个 GPU 进程 - 1 个网络进程 - 多个渲染进程 - 多个插件进程

这些进程的功能：

- **浏览器进程**：主要负责界面显示、用户交互、子进程管理，同时提供存储等功能。 - **渲染进程**：核心任务是将 HTML、CSS 和 JavaScript 转换为用户可以与之交互的网页，排版引擎 Blink 和 JavaScript 引擎 V8 都是运行在该进程中，默认情况下，Chrome 会为每个 Tab 标签创建一个渲染进程。出于安全考虑，渲染进程都是运行在沙箱模式下。 - **GPU 进程**：其实， GPU 的使用初衷是为了实现 3D CSS 的效果，只是随后网页、Chrome 的 UI 界面都选择采用 GPU 来绘制，这使得 GPU 成为浏览器普遍的需求。最后，Chrome 在其多进程架构上也引入了 GPU 进程。 - **网络进程**：主要负责页面的网络资源加载，之前是作为一个模块运行在浏览器进程里面的，直至最近才独立出来，成为一个单独的进程。 - **插件进程**：主要是负责插件的运行，因插件易崩溃，所以需要通过插件进程来隔离，以保证插件进程崩溃不会对浏览器和页面造成影响。

所以，**打开一个网页，最少需要四个进程**：1 个网络进程、1 个浏览器进程、1 个 GPU 进程以及 1 个渲染进程。如果打开的页面有运行插件的话，还需要再加上 1 个插件进程。

虽然多进程模型提升了浏览器的稳定性、流畅性和安全性，但同样不可避免地带来了一些问题：

- **更高的资源占用**：因为每个进程都会包含公共基础结构的副本（如 JavaScript 运行环境），这就意味着浏览器会消耗更多的内存资源。 - **更复杂的体系架构**：浏览器各模块之间耦合性高、扩展性差等问题，会导致现在的架构已经很难适应新的需求了。

 2. 进程和线程的区别

- 进程可以看做独立应用，线程不能 - 资源：进程是cpu资源分配的最小单位（是能拥有资源和独立运行的最小单位）；线程是cpu调度的最小单位（线程是建立在进程的基础上的一次程序运行单位，一个进程中可以有多个线程）。 - 通信方面：线程间可以通过直接共享同一进程中的资源，而进程通信需要借助 进程间通信。 - 调度：进程切换比线程切换的开销要大。线程是CPU调度的基本单位，线程的切换不会引起进程切换，但某个进程中的线程切换到另一个进程中的线程时，会引起进程切换。 - 系统开销：由于创建或撤销进程时，系统都要为之分配或回收资源，如内存、I/O 等，其开销远大于创建或撤销线程时的开销。同理，在进行进程切换时，涉及当前执行进程 CPU 环境还有各种各样状态的保存及新调度进程状态的设置，而线程切换时只需保存和设置少量寄存器内容，开销较小。

 3. 浏览器渲染进程的线程有哪些

浏览器的渲染进程的线程总共有五种：

**（1）GUI渲染线程**

负责渲染浏览器页面，解析HTML、CSS，构建DOM树、构建CSSOM树、构建渲染树和绘制页面；当界面需要**重绘**或由于某种操作引发**回流**时，该线程就会执行。

注意：GUI渲染线程和JS引擎线程是互斥的，当JS引擎执行时GUI线程会被挂起，GUI更新会被保存在一个队列中等到JS引擎空闲时立即被执行。

**（2）JS引擎线程**

JS引擎线程也称为JS内核，负责处理Javascript脚本程序，解析Javascript脚本，运行代码；JS引擎线程一直等待着任务队列中任务的到来，然后加以处理，一个Tab页中无论什么时候都只有一个JS引擎线程在运行JS程序；

注意：GUI渲染线程与JS引擎线程的互斥关系，所以如果JS执行的时间过长，会造成页面的渲染不连贯，导致页面渲染加载阻塞。

**（3）事件触发线程**

**事件触发线程**属于浏览器而不是JS引擎，用来控制事件循环；当JS引擎执行代码块如setTimeOut时（也可是来自浏览器内核的其他线程,如鼠标点击、AJAX异步请求等），会将对应任务添加到事件触发线程中；当对应的事件符合触发条件被触发时，该线程会把事件添加到待处理队列的队尾，等待JS引擎的处理；

注意：由于JS的单线程关系，所以这些待处理队列中的事件都得排队等待JS引擎处理（当JS引擎空闲时才会去执行）；

**（4）定时器触发进程**

**定时器触发进程**即setInterval与setTimeout所在线程；浏览器定时计数器并不是由JS引擎计数的，因为JS引擎是单线程的，如果处于阻塞线程状态就会影响记计时的准确性；因此使用单独线程来计时并触发定时器，计时完毕后，添加到事件队列中，等待JS引擎空闲后执行，所以定时器中的任务在设定的时间点不一定能够准时执行，定时器只是在指定时间点将任务添加到事件队列中；

注意：W3C在HTML标准中规定，定时器的定时时间不能小于4ms，如果是小于4ms，则默认为4ms。

**（5）异步http请求线程**

- XMLHttpRequest连接后通过浏览器新开一个线程请求； - 检测到状态变更时，如果设置有回调函数，异步线程就产生状态变更事件，将回调函数放入事件队列中，等待JS引擎空闲后执行；

 4. 进程之前的通信方式

**（1）管道通信**

管道是一种最基本的进程间通信机制。**管道就是操作系统在内核中开辟的一段缓冲区，进程1可以将需要交互的数据拷贝到这段缓冲区，进程2就可以读取了。**

管道的特点：

- 只能单向通信 - 只能血缘关系的进程进行通信 - 依赖于文件系统 - 生命周期随进程 - 面向字节流的服务 - 管道内部提供了同步机制

**（2）消息队列通信**

消息队列就是一个消息的列表。用户可以在消息队列中添加消息、读取消息等。消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。 每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。可以通过发送消息来避免命名管道的同步和阻塞问题。但是消息队列与命名管道一样，每个数据块都有一个最大长度的限制。

使用消息队列进行进程间通信，可能会收到数据块最大长度的限制约束等，这也是这种通信方式的缺点。如果频繁的发生进程间的通信行为，那么进程需要频繁地读取队列中的数据到内存，相当于间接地从一个进程拷贝到另一个进程，这需要花费时间。

**（3）信号量通信**

共享内存最大的问题就是多进程竞争内存的问题，就像类似于线程安全问题。我们可以使用信号量来解决这个问题。信号量的本质就是一个计数器，用来实现进程之间的互斥与同步。例如信号量的初始值是 1，然后 a 进程来访问内存1的时候，我们就把信号量的值设为 0，然后进程b 也要来访问内存1的时候，看到信号量的值为 0 就知道已经有进程在访问内存1了，这个时候进程 b 就会访问不了内存1。所以说，信号量也是进程之间的一种通信方式。

**（4）信号通信**

信号（Signals ）是Unix系统中使用的最古老的进程间通信的方法之一。操作系统通过信号来通知进程系统中发生了某种预先规定好的事件（一组事件中的一个），它也是用户进程之间通信和同步的一种原始机制。

**（5）共享内存通信**

共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问（使多个进程可以访问同一块内存空间）。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。

**（6）套接字通信**

上面我们说的共享内存、管道、信号量、消息队列，他们都是多个进程在一台主机之间的通信，那两个相隔几千里的进程能够进行通信吗？答是必须的，这个时候 Socket 这家伙就派上用场了，例如我们平时通过浏览器发起一个 http 请求，然后服务器给你返回对应的数据，这种就是采用 Socket 的通信方式了。

 5. 僵尸进程和孤儿进程是什么？

- **孤儿进程**：父进程退出了，而它的一个或多个进程还在运行，那这些子进程都会成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。 - **僵尸进程**：子进程比父进程先结束，而父进程又没有释放子进程占用的资源，那么子进程的进程描述符仍然保存在系统中，这种进程称之为僵死进程。

 6. 死锁产生的原因？ 如果解决死锁的问题？

所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

系统中的资源可以分为两类：

- 可剥夺资源，是指某进程在获得这类资源后，该资源可以再被其他进程或系统剥夺，CPU和主存均属于可剥夺性资源； - 不可剥夺资源，当系统把这类资源分配给某进程后，再不能强行收回，只能在进程用完后自行释放，如磁带机、打印机等。

**产生死锁的原因：**

**（1）竞争资源**

- 产生死锁中的竞争资源之一指的是**竞争不可剥夺资源**（例如：系统中只有一台打印机，可供进程P1使用，假定P1已占用了打印机，若P2继续要求打印机打印将阻塞） - 产生死锁中的竞争资源另外一种资源指的是**竞争临时资源**（临时资源包括硬件中断、信号、消息、缓冲区内的消息等），通常消息通信顺序进行不当，则会产生死锁

**（2）进程间推进顺序非法**

若P1保持了资源R1，P2保持了资源R2，系统处于不安全状态，因为这两个进程再向前推进，便可能发生死锁。例如，当P1运行到P1：Request（R2）时，将因R2已被P2占用而阻塞；当P2运行到P2：Request（R1）时，也将因R1已被P1占用而阻塞，于是发生进程死锁

**产生死锁的必要条件：**

- 互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。 - 请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。 - 不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。 - 环路等待条件：在发生死锁时，必然存在一个进程——资源的环形链。

**预防死锁的方法：**

- 资源一次性分配：一次性分配所有资源，这样就不会再有请求了（破坏请求条件） - 只要有一个资源得不到分配，也不给这个进程分配其他的资源（破坏请保持条件） - 可剥夺资源：即当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源（破坏不可剥夺条件） - 资源有序分配法：系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反（破坏环路等待条件）

 7. 如何实现浏览器内多个标签页之间的通信?

实现多个标签页之间的通信，本质上都是通过中介者模式来实现的。因为标签页之间没有办法直接通信，因此我们可以找一个中介者，让标签页和中介者进行通信，然后让这个中介者来进行消息的转发。通信方法如下：

- **使用 websocket 协议**，因为 websocket 协议可以实现服务器推送，所以服务器就可以用来当做这个中介者。标签页通过向服务器发送数据，然后由服务器向其他标签页推送转发。 - **使用 ShareWorker 的方式**，shareWorker 会在页面存在的生命周期内创建一个唯一的线程，并且开启多个页面也只会使用同一个线程。这个时候共享线程就可以充当中介者的角色。标签页间通过共享一个线程，然后通过这个共享的线程来实现数据的交换。 - **使用 localStorage 的方式**，我们可以在一个标签页对 localStorage 的变化事件进行监听，然后当另一个标签页修改数据的时候，我们就可以通过这个监听事件来获取到数据。这个时候 localStorage 对象就是充当的中介者的角色。 - **使用 postMessage 方法**，如果我们能够获得对应标签页的引用，就可以使用postMessage 方法，进行通信。

 8. 对Service Worker的理解

Service Worker 是运行在浏览器背后的**独立线程**，一般可以用来实现缓存功能。使用 Service Worker的话，传输协议必须为 **HTTPS**。因为 Service Worker 中涉及到请求拦截，所以必须使用 HTTPS 协议来保障安全。

Service Worker 实现缓存功能一般分为三个步骤：首先需要先注册 Service Worker，然后监听到 `install` 事件以后就可以缓存需要的文件，那么在下次用户访问的时候就可以通过拦截请求的方式查询是否存在缓存，存在缓存的话就可以直接读取缓存文件，否则就去请求数据。以下是这个步骤的实现：

// index.js

if (navigator.serviceWorker) {

  navigator.serviceWorker

    .register('sw.js')

    .then(function(registration) {

      console.log('service worker 注册成功')

    })

    .catch(function(err) {

      console.log('servcie worker 注册失败')

    })

}

// sw.js

// 监听 `install` 事件，回调中缓存所需文件

self.addEventListener('install', e => {

  e.waitUntil(

    caches.open('my-cache').then(function(cache) {

      return cache.addAll(['./index.html', './index.js'])

    })

  )

})

// 拦截所有请求事件

// 如果缓存中已经有请求的数据就直接用缓存，否则去请求数据

self.addEventListener('fetch', e => {

  e.respondWith(

    caches.match(e.request).then(function(response) {

      if (response) {

        return response

      }

      console.log('fetch source')

    })

  )

})

打开页面，可以在开发者工具中的 `Application` 看到 Service Worker 已经启动了：

在 Cache 中也可以发现所需的文件已被缓存

三、浏览器缓存

 1. 对浏览器的缓存机制的理解

**浏览器缓存的全过程：**

- 浏览器第一次加载资源，服务器返回 200，浏览器从服务器下载资源文件，并缓存资源文件与 response header，以供下次加载时对比使用； - 下一次加载资源时，由于强制缓存优先级较高，先比较当前时间与上一次返回 200 时的时间差，如果没有超过 cache-control 设置的 max-age，则没有过期，并命中强缓存，直接从本地读取资源。如果浏览器不支持HTTP1.1，则使用 expires 头判断是否过期； - 如果资源已过期，则表明强制缓存没有被命中，则开始协商缓存，向服务器发送带有 If-None-Match 和 If-Modified-Since 的请求； - 服务器收到请求后，优先根据 Etag 的值判断被请求的文件有没有做修改，Etag 值一致则没有修改，命中协商缓存，返回 304；如果不一致则有改动，直接返回新的资源文件带上新的 Etag 值并返回 200； - 如果服务器收到的请求没有 Etag 值，则将 If-Modified-Since 和被请求文件的最后修改时间做比对，一致则命中协商缓存，返回 304；不一致则返回新的 last-modified 和文件并返回 200；

![img](https://bingjs.com:8008/img/llq/llq5.png)

很多网站的资源后面都加了版本号，这样做的目的是：每次升级了 JS 或 CSS 文件后，为了防止浏览器进行缓存，强制改变版本号，客户端浏览器就会重新下载新的 JS 或 CSS 文件 ，以保证用户能够及时获得网站的最新更新。

 2. 浏览器资源缓存的位置有哪些？

资源缓存的位置一共有 3 种，按优先级从高到低分别是：

1. **Service Worker**：**Service Worker 运行在 JavaScript 主线程之外，虽然由于脱离了浏览器窗体无法直接访问 DOM，但是它可以完成离线缓存、消息推送、网络代理等功能。它可以让我们自由控制**缓存哪些文件、如何匹配缓存、如何读取缓存，并且**缓存是持续性的**。当 Service Worker 没有命中缓存的时候，需要去调用 `fetch `函数获取 数据。也就是说，如果没有在 Service Worker 命中缓存，会根据缓存查找优先级去查找数据。**但是不管是从 Memory Cache 中还是从网络请求中获取的数据，浏览器都会显示是从 Service Worker 中获取的内容。** 2. **Memory Cache**：Memory Cache 就是内存缓存，它的效率最快，但是内存缓存虽然读取高效，可是缓存持续性很短，会随着进程的释放而释放。一旦我们关闭 Tab 页面，内存中的缓存也就被释放了。 3. **Disk Cache**：Disk Cache 也就是存储在硬盘中的缓存，读取速度慢点，但是什么都能存储到磁盘中，比之 Memory Cache 胜在容量和存储时效性上。在所有浏览器缓存中，Disk Cache 覆盖面基本是最大的。它会根据 HTTP Herder 中的字段判断哪些资源需要缓存，哪些资源可以不请求直接使用，哪些资源已经过期需要重新请求。**并且即使在跨站点的情况下，相同地址的资源一旦被硬盘缓存下来，就不会再次去请求数据。**

**Disk Cache**：Push Cache 是 HTTP/2 中的内容，当以上三种缓存都没有命中时，它才会被使用。并且缓存时间也很短暂，只在会话（Session）中存在，一旦会话结束就被释放。其具有以下特点：

- 所有的资源都能被推送，但是 Edge 和 Safari 浏览器兼容性不怎么好 - 可以推送 `no-cache` 和 `no-store` 的资源 - 一旦连接被关闭，Push Cache 就被释放 - 多个页面可以使用相同的 HTTP/2 连接，也就是说能使用同样的缓存 - Push Cache 中的缓存只能被使用一次 - 浏览器可以拒绝接受已经存在的资源推送 - 可以给其他域名推送资源

 3. 协商缓存和强缓存的区别

# （1）强缓存

使用强缓存策略时，如果缓存资源有效，则直接使用缓存资源，不必再向服务器发起请求。

强缓存策略可以通过两种方式来设置，分别是 http 头信息中的 Expires 属性和 Cache-Control 属性。

（1）服务器通过在响应头中添加 Expires 属性，来指定资源的过期时间。在过期时间以内，该资源可以被缓存使用，不必再向服务器发送请求。这个时间是一个绝对时间，它是服务器的时间，因此可能存在这样的问题，就是客户端的时间和服务器端的时间不一致，或者用户可以对客户端时间进行修改的情况，这样就可能会影响缓存命中的结果。

（2）Expires 是 http1.0 中的方式，因为它的一些缺点，在 HTTP 1.1 中提出了一个新的头部属性就是 Cache-Control 属性，它提供了对资源的缓存的更精确的控制。它有很多不同的值，

`Cache-Control`可设置的字段：

- `public`：设置了该字段值的资源表示可以被任何对象（包括：发送请求的客户端、代理服务器等等）缓存。这个字段值不常用，一般还是使用max-age=来精确控制； - `private`：设置了该字段值的资源只能被用户浏览器缓存，不允许任何代理服务器缓存。在实际开发当中，对于一些含有用户信息的HTML，通常都要设置这个字段值，避免代理服务器(CDN)缓存； - `no-cache`：设置了该字段需要先和服务端确认返回的资源是否发生了变化，如果资源未发生变化，则直接使用缓存好的资源； - `no-store`：设置了该字段表示禁止任何缓存，每次都会向服务端发起新的请求，拉取最新的资源； - `max-age=`：设置缓存的最大有效期，单位为秒； - `s-maxage=`：优先级高于max-age=，仅适用于共享缓存(CDN)，优先级高于max-age或者Expires头； - `max-stale[=]`：设置了该字段表明客户端愿意接收已经过期的资源，但是不能超过给定的时间限制。

一般来说只需要设置其中一种方式就可以实现强缓存策略，当两种方式一起使用时，Cache-Control 的优先级要高于 Expires。

**no-cache和no-store很容易混淆：**

- no-cache 是指先要和服务器确认是否有资源更新，在进行判断。也就是说没有强缓存，但是会有协商缓存； - no-store 是指不使用任何缓存，每次请求都直接从服务器获取资源。

# （2）协商缓存

如果命中强制缓存，我们无需发起新的请求，直接使用缓存内容，如果没有命中强制缓存，如果设置了协商缓存，这个时候协商缓存就会发挥作用了。

上面已经说到了，命中协商缓存的条件有两个：

- `max-age=xxx` 过期了 - 值为 `no-cache`

使用协商缓存策略时，会先向服务器发送一个请求，如果资源没有发生修改，则返回一个 304 状态，让浏览器使用本地的缓存副本。如果资源发生了修改，则返回修改后的资源。

协商缓存也可以通过两种方式来设置，分别是 http 头信息中的 **Etag** 和 **Last-Modified** 属性。

（1）服务器通过在响应头中添加 Last-Modified 属性来指出资源最后一次修改的时间，当浏览器下一次发起请求时，会在请求头中添加一个 If-Modified-Since 的属性，属性值为上一次资源返回时的 Last-Modified 的值。当请求发送到服务器后服务器会通过这个属性来和资源的最后一次的修改时间来进行比较，以此来判断资源是否做了修改。如果资源没有修改，那么返回 304 状态，让客户端使用本地的缓存。如果资源已经被修改了，则返回修改后的资源。使用这种方法有一个缺点，就是 Last-Modified 标注的最后修改时间只能精确到秒级，如果某些文件在1秒钟以内，被修改多次的话，那么文件已将改变了但是 Last-Modified 却没有改变，这样会造成缓存命中的不准确。

（2）因为 Last-Modified 的这种可能发生的不准确性，http 中提供了另外一种方式，那就是 Etag 属性。服务器在返回资源的时候，在头信息中添加了 Etag 属性，这个属性是资源生成的唯一标识符，当资源发生改变的时候，这个值也会发生改变。在下一次资源请求时，浏览器会在请求头中添加一个 If-None-Match 属性，这个属性的值就是上次返回的资源的 Etag 的值。服务接收到请求后会根据这个值来和资源当前的 Etag 的值来进行比较，以此来判断资源是否发生改变，是否需要返回资源。通过这种方式，比 Last-Modified 的方式更加精确。

当 Last-Modified 和 Etag 属性同时出现的时候，Etag 的优先级更高。使用协商缓存的时候，服务器需要考虑负载平衡的问题，因此多个服务器上资源的 Last-Modified 应该保持一致，因为每个服务器上 Etag 的值都不一样，因此在考虑负载平衡时，最好不要设置 Etag 属性。

**总结：**

强缓存策略和协商缓存策略在缓存命中时都会直接使用本地的缓存副本，区别只在于协商缓存会向服务器发送一次请求。它们缓存不命中时，都会向服务器发送请求来获取资源。在实际的缓存机制中，强缓存策略和协商缓存策略是一起合作使用的。浏览器首先会根据请求的信息判断，强缓存是否命中，如果命中则直接使用资源。如果不命中则根据头信息向服务器发起请求，使用协商缓存，如果协商缓存命中的话，则服务器不返回资源，浏览器直接使用本地资源的副本，如果协商缓存不命中，则浏览器返回最新的资源给浏览器。

 4. 为什么需要浏览器缓存？

对于浏览器的缓存，主要针对的是前端的静态资源，最好的效果就是，在发起请求之后，拉取相应的静态资源，并保存在本地。如果服务器的静态资源没有更新，那么在下次请求的时候，就直接从本地读取即可，如果服务器的静态资源已经更新，那么我们再次请求的时候，就到服务器拉取新的资源，并保存在本地。这样就大大的减少了请求的次数，提高了网站的性能。这就要用到浏览器的缓存策略了。

所谓的**浏览器缓存**指的是浏览器将用户请求过的静态资源，存储到电脑本地磁盘中，当浏览器再次访问时，就可以直接从本地加载，不需要再去服务端请求了。

使用浏览器缓存，有以下优点：

- 减少了服务器的负担，提高了网站的性能 - 加快了客户端网页的加载速度 - 减少了多余网络数据传输

 5. 点击刷新按钮或者按 F5、按 Ctrl+F5 （强制刷新）、地址栏回车有什么区别？

- 点击刷新按钮或者按 F5：浏览器直接对本地的缓存文件过期，但是会带上If-Modifed-Since，If-None-Match，这就意味着服务器会对文件检查新鲜度，返回结果可能是 304，也有可能是 200。 - 用户按 Ctrl+F5（强制刷新）：浏览器不仅会对本地文件过期，而且不会带上 If-Modifed-Since，If-None-Match，相当于之前从来没有请求过，返回结果是 200。 - 地址栏回车： 浏览器发起请求，按照正常流程，本地检查是否过期，然后服务器检查新鲜度，最后返回内容。

四、浏览器组成

 1. 对浏览器的理解

浏览器的主要功能是将用户选择的 web 资源呈现出来，它需要从服务器请求资源，并将其显示在浏览器窗口中，资源的格式通常是 HTML，也包括 PDF、image 及其他格式。用户用 URI（Uniform Resource Identifier 统一资源标识符）来指定所请求资源的位置。

HTML 和 CSS 规范中规定了浏览器解释 html 文档的方式，由 W3C 组织对这些规范进行维护，W3C 是负责制定 web 标准的组织。但是浏览器厂商纷纷开发自己的扩展，对规范的遵循并不完善，这为 web 开发者带来了严重的兼容性问题。

浏览器可以分为两部分，shell 和 内核。其中 shell 的种类相对比较多，内核则比较少。也有一些浏览器并不区分外壳和内核。从 Mozilla 将 Gecko 独立出来后，才有了外壳和内核的明确划分。

- shell 是指浏览器的外壳：例如菜单，工具栏等。主要是提供给用户界面操作，参数设置等等。它是调用内核来实现各种功能的。 - 内核是浏览器的核心。内核是基于标记语言显示内容的程序或模块。

 2. 对浏览器内核的理解

浏览器内核主要分成两部分：

- 渲染引擎的职责就是渲染，即在浏览器窗口中显示所请求的内容。默认情况下，渲染引擎可以显示 html、xml 文档及图片，它也可以借助插件显示其他类型数据，例如使用 PDF 阅读器插件，可以显示 PDF 格式。 - JS 引擎：解析和执行 javascript 来实现网页的动态效果。

最开始渲染引擎和 JS 引擎并没有区分的很明确，后来 JS 引擎越来越独立，内核就倾向于只指渲染引擎。

 3. 常见的浏览器内核比较

- **Trident**：这种浏览器内核是 IE 浏览器用的内核，因为在早期 IE 占有大量的市场份额，所以这种内核比较流行，以前有很多网页也是根据这个内核的标准来编写的，但是实际上这个内核对真正的网页标准支持不是很好。但是由于 IE 的高市场占有率，微软也很长时间没有更新 Trident 内核，就导致了 Trident 内核和 W3C 标准脱节。还有就是 Trident 内核的大量 Bug 等安全问题没有得到解决，加上一些专家学者公开自己认为 IE 浏览器不安全的观点，使很多用户开始转向其他浏览器。 - **Gecko**：这是 Firefox 和 Flock 所采用的内核，这个内核的优点就是功能强大、丰富，可以支持很多复杂网页效果和浏览器扩展接口，但是代价是也显而易见就是要消耗很多的资源，比如内存。 - **Presto**：Opera 曾经采用的就是 Presto 内核，Presto 内核被称为公认的浏览网页速度最快的内核，这得益于它在开发时的天生优势，在处理 JS 脚本等脚本语言时，会比其他的内核快3倍左右，缺点就是为了达到很快的速度而丢掉了一部分网页兼容性。 - **Webkit**：Webkit 是 Safari 采用的内核，它的优点就是网页浏览速度较快，虽然不及 Presto 但是也胜于 Gecko 和 Trident，缺点是对于网页代码的容错性不高，也就是说对网页代码的兼容性较低，会使一些编写不标准的网页无法正确显示。WebKit 前身是 KDE 小组的 KHTML 引擎，可以说 WebKit 是 KHTML 的一个开源的分支。 - **Blink**：谷歌在 Chromium Blog 上发表博客，称将与苹果的开源浏览器核心 Webkit 分道扬镳，在 Chromium 项目中研发 Blink 渲染引擎（即浏览器核心），内置于 Chrome 浏览器之中。其实 Blink 引擎就是 Webkit 的一个分支，就像 webkit 是KHTML 的分支一样。Blink 引擎现在是谷歌公司与 Opera Software 共同研发，上面提到过的，Opera 弃用了自己的 Presto 内核，加入 Google 阵营，跟随谷歌一起研发 Blink。

 4. 常见浏览器所用内核

（1） IE 浏览器内核：Trident 内核，也是俗称的 IE 内核；

（2） Chrome 浏览器内核：统称为 Chromium 内核或 Chrome 内核，以前是 Webkit 内核，现在是 Blink内核；

（3） Firefox 浏览器内核：Gecko 内核，俗称 Firefox 内核；

（4） Safari 浏览器内核：Webkit 内核；

（5） Opera 浏览器内核：最初是自己的 Presto 内核，后来加入谷歌大军，从 Webkit 又到了 Blink 内核；

（6） 360浏览器、猎豹浏览器内核：IE + Chrome 双内核；

（7） 搜狗、遨游、QQ 浏览器内核：Trident（兼容模式）+ Webkit（高速模式）；

（8） 百度浏览器、世界之窗内核：IE 内核；

（9） 2345浏览器内核：好像以前是 IE 内核，现在也是 IE + Chrome 双内核了；

（10）UC 浏览器内核：这个众口不一，UC 说是他们自己研发的 U3 内核，但好像还是基于 Webkit 和 Trident ，还有说是基于火狐内核。

 5. 浏览器的主要组成部分

- **用户界面** - 包括地址栏、前进/后退按钮、书签菜单等。除了浏览器主窗⼝显示的您请求的⻚⾯外，其他显示的各个部分都属于⽤户界⾯。 - **浏览器引擎** - 在⽤户界⾯和呈现引擎之间传送指令。 - **呈现引擎** - 负责显示请求的内容。如果请求的内容是 HTML，它就负责解析 HTML 和 CSS 内容，并将解析后的内容显示在屏幕上。 - **网络 **- ⽤于⽹络调⽤，⽐如 HTTP 请求。其接⼝与平台⽆关，并为所有平台提供底层实现。 - **用户界面后端** - ⽤于绘制基本的窗⼝⼩部件，⽐如组合框和窗⼝。其公开了与平台⽆关的通⽤接⼝，⽽在底层使⽤操作系统的⽤户界⾯⽅法。 - **JavaScript解释器**。⽤于解析和执⾏ JavaScript 代码。 - **数据存储** - 这是持久层。浏览器需要在硬盘上保存各种数据，例如 Cookie。新的 HTML 规范 (HTML5) 定义了“⽹络数据库”，这是⼀个完整（但是轻便）的浏览器内数据库。

值得注意的是，和⼤多数浏览器不同，Chrome 浏览器的每个标签⻚都分别对应⼀个呈现引擎实例。每个标签⻚都是⼀个独⽴的进程。

五、浏览器渲染原理

 1. 浏览器的渲染过程

浏览器渲染主要有以下步骤：

- 首先解析收到的文档，根据文档定义构建一棵 DOM 树，DOM 树是由 DOM 元素及属性节点组成的。 - 然后对 CSS 进行解析，生成 CSSOM 规则树。 - 根据 DOM 树和 CSSOM 规则树构建渲染树。渲染树的节点被称为渲染对象，渲染对象是一个包含有颜色和大小等属性的矩形，渲染对象和 DOM 元素相对应，但这种对应关系不是一对一的，不可见的 DOM 元素不会被插入渲染树。还有一些 DOM元素对应几个可见对象，它们一般是一些具有复杂结构的元素，无法用一个矩形来描述。 - 当渲染对象被创建并添加到树中，它们并没有位置和大小，所以当浏览器生成渲染树以后，就会根据渲染树来进行布局（也可以叫做回流）。这一阶段浏览器要做的事情是要弄清楚各个节点在页面中的确切位置和大小。通常这一行为也被称为“自动重排”。 - 布局阶段结束后是绘制阶段，遍历渲染树并调用渲染对象的 paint 方法将它们的内容显示在屏幕上，绘制使用 UI 基础组件。

**注意**：这个过程是逐步完成的，为了更好的用户体验，渲染引擎将会尽可能早的将内容呈现到屏幕上，并不会等到所有的html 都解析完成之后再去构建和布局 render 树。它是解析完一部分内容就显示一部分内容，同时，可能还在通过网络下载其余内容。

 2. 浏览器渲染优化

**（1）针对JavaScript**：JavaScript既会阻塞HTML的解析，也会阻塞CSS的解析。因此我们可以对JavaScript的加载方式进行改变，来进行优化：

（1）尽量将JavaScript文件放在body的最后

（2） body中间尽量不要写 `

服务端返回如下（返回时即执行全局函数）：

handleCallback({"success": true, "user": "admin"})

2）Vue axios实现：

this.$http = axios;

this.$http.jsonp('http://www.domain2.com:8080/login', {

    params: {},

    jsonp: 'handleCallback'

}).then((res) => {

    console.log(res); 

})

后端node.js代码：

var querystring = require('querystring');

var http = require('http');

var server = http.createServer();

server.on('request', function(req, res) {

    var params = querystring.parse(req.url.split('?')[1]);

    var fn = params.callback;

    // jsonp返回设置

    res.writeHead(200, { 'Content-Type': 'text/javascript' });

    res.write(fn + '(' + JSON.stringify(params) + ')');

    res.end();

});

server.listen('8080');

console.log('Server is running at port 8080...');

**JSONP的缺点：**

- 具有局限性， 仅支持get方法 - 不安全，可能会遭受XSS攻击

# （3）postMessage 跨域

postMessage是HTML5 XMLHttpRequest Level 2中的API，且是为数不多可以跨域操作的window属性之一，它可用于解决以下方面的问题：

- 页面和其打开的新窗口的数据传递 - 多窗口之间消息传递 - 页面与嵌套的iframe消息传递 - 上面三个场景的跨域数据传递

用法：postMessage(data,origin)方法接受两个参数：

- **data**： html5规范支持任意基本类型或可复制的对象，但部分浏览器只支持字符串，所以传参时最好用JSON.stringify()序列化。 - **origin**： 协议+主机+端口号，也可以设置为"*"，表示可以传递给任意窗口，如果要指定和当前窗口同源的话设置为"/"。

1）a.html：(domain1.com/a.html)

2）b.html：(domain2.com/b.html)

# （4）nginx代理跨域

nginx代理跨域，实质和CORS跨域原理一样，通过配置文件设置请求响应头Access-Control-Allow-Origin…等字段。

1）nginx配置解决iconfont跨域

浏览器跨域访问js、css、img等常规静态资源被同源策略许可，但iconfont字体文件(eot|otf|ttf|woff|svg)例外，此时可在nginx的静态资源服务器中加入以下配置。

location / {

  add_header Access-Control-Allow-Origin *;

}

2）nginx反向代理接口跨域

跨域问题：同源策略仅是针对浏览器的安全策略。服务器端调用HTTP接口只是使用HTTP协议，不需要同源策略，也就不存在跨域问题。

实现思路：通过Nginx配置一个代理服务器域名与domain1相同，端口不同）做跳板机，反向代理访问domain2接口，并且可以顺便修改cookie中domain信息，方便当前域cookie写入，实现跨域访问。

nginx具体配置：

#proxy服务器

server {

    listen       81;

    server_name  www.domain1.com;

    location / {

        proxy_pass   http://www.domain2.com:8080;  #反向代理

        proxy_cookie_domain www.domain2.com www.domain1.com; #修改cookie里域名

        index  index.html index.htm;

        # 当用webpack-dev-server等中间件代理接口访问nignx时，此时无浏览器参与，故没有同源限制，下面的跨域配置可不启用

        add_header Access-Control-Allow-Origin http://www.domain1.com;  #当前端只跨域不带cookie时，可为*

        add_header Access-Control-Allow-Credentials true;

    }

}

# （5）nodejs 中间件代理跨域

node中间件实现跨域代理，原理大致与nginx相同，都是通过启一个代理服务器，实现数据的转发，也可以通过设置cookieDomainRewrite参数修改响应头中cookie中域名，实现当前域的cookie写入，方便接口登录认证。

**1）非vue框架的跨域**

使用node + express + http-proxy-middleware搭建一个proxy服务器。

- 前端代码：

#proxy服务器

server {

    listen       81;

    server_name  www.domain1.com;

    location / {

        proxy_pass   http://www.domain2.com:8080;  #反向代理

        proxy_cookie_domain www.domain2.com www.domain1.com; #修改cookie里域名

        index  index.html index.htm;

        # 当用webpack-dev-server等中间件代理接口访问nignx时，此时无浏览器参与，故没有同源限制，下面的跨域配置可不启用

        add_header Access-Control-Allow-Origin http://www.domain1.com;  #当前端只跨域不带cookie时，可为*

        add_header Access-Control-Allow-Credentials true;

    }

}

- 中间件服务器代码：

var express = require('express');

var proxy = require('http-proxy-middleware');

var app = express();

app.use('/', proxy({

    // 代理跨域目标接口

    target: 'http://www.domain2.com:8080',

    changeOrigin: true,

    // 修改响应头信息，实现跨域并允许带cookie

    onProxyRes: function(proxyRes, req, res) {

        res.header('Access-Control-Allow-Origin', 'http://www.domain1.com');

        res.header('Access-Control-Allow-Credentials', 'true');

    },

    // 修改响应信息中的cookie域名

    cookieDomainRewrite: 'www.domain1.com'  // 可以为false，表示不修改

}));

app.listen(3000);

console.log('Proxy server is listen at port 3000...');

**2）vue框架的跨域**

node + vue + webpack + webpack-dev-server搭建的项目，跨域请求接口，直接修改webpack.config.js配置。开发环境下，vue渲染服务和接口代理服务都是webpack-dev-server同一个，所以页面与代理接口之间不再跨域。

webpack.config.js部分配置：

module.exports = {

    entry: {},

    module: {},

    ...

    devServer: {

        historyApiFallback: true,

        proxy: [{

            context: '/login',

            target: 'http://www.domain2.com:8080',  // 代理跨域目标接口

            changeOrigin: true,

            secure: false,  // 当代理某些https服务报错时用

            cookieDomainRewrite: 'www.domain1.com'  // 可以为false，表示不修改

        }],

        noInfo: true

    }

}

# （6）document.domain + iframe跨域

此方案仅限主域相同，子域不同的跨域应用场景。实现原理：两个页面都通过js强制设置document.domain为基础主域，就实现了同域。

1）父窗口：(domain.com/a.html)

2）子窗口：(child.domain.com/a.html)

# （7）location.hash + iframe跨域

实现原理：a欲与b跨域相互通信，通过中间页c来实现。 三个页面，不同域之间利用iframe的location.hash传值，相同域之间直接js访问来通信。

具体实现：A域：a.html -> B域：b.html -> A域：c.html，a与b不同域只能通过hash值单向通信，b与c也不同域也只能单向通信，但c与a同域，所以c可通过parent.parent访问a页面所有对象。

1）a.html：(domain1.com/a.html)

2）b.html：(.domain2.com/b.html)

3）c.html：(`http://www.domain1.com/c.html`)

# （8）window.name + iframe跨域

window.name属性的独特之处：name值在不同的页面（甚至不同域名）加载后依旧存在，并且可以支持非常长的 name 值（2MB）。

1）a.html：(domain1.com/a.html)

var proxy = function(url, callback) {

    var state = 0;

    var iframe = document.createElement('iframe');

    // 加载跨域页面

    iframe.src = url;

    // onload事件会触发2次，第1次加载跨域页，并留存数据于window.name

    iframe.onload = function() {

        if (state === 1) {

            // 第2次onload(同域proxy页)成功后，读取同域window.name中数据

            callback(iframe.contentWindow.name);

            destoryFrame();

        } else if (state === 0) {

            // 第1次onload(跨域页)成功后，切换到同域代理页面

            iframe.contentWindow.location = 'http://www.domain1.com/proxy.html';

            state = 1;

        }

    };

    document.body.appendChild(iframe);

    // 获取数据以后销毁这个iframe，释放内存；这也保证了安全（不被其他域frame js访问）

    function destoryFrame() {

        iframe.contentWindow.document.write('');

        iframe.contentWindow.close();

        document.body.removeChild(iframe);

    }

};

// 请求跨域b页面数据

proxy('http://www.domain2.com/b.html', function(data){

    alert(data);

});

2）proxy.html：(domain1.com/proxy.html)

中间代理页，与a.html同域，内容为空即可。

3）b.html：(domain2.com/b.html)

通过iframe的src属性由外域转向本地域，跨域数据即由iframe的window.name从外域传递到本地域。这个就巧妙地绕过了浏览器的跨域访问限制，但同时它又是安全操作。

# （9）WebSocket协议跨域

WebSocket protocol是HTML5一种新的协议。它实现了浏览器与服务器全双工通信，同时允许跨域通讯，是server push技术的一种很好的实现。

原生WebSocket API使用起来不太方便，我们使用Socket.io，它很好地封装了webSocket接口，提供了更简单、灵活的接口，也对不支持webSocket的浏览器提供了向下兼容。

1）前端代码：

user input：

2）Nodejs socket后台：

var http = require('http');

var socket = require('socket.io');

// 启http服务

var server = http.createServer(function(req, res) {

    res.writeHead(200, {

        'Content-type': 'text/html'

    });

    res.end();

});

server.listen('8080');

console.log('Server is running at port 8080...');

// 监听socket连接

socket.listen(server).on('connection', function(client) {

    // 接收信息

    client.on('message', function(msg) {

        client.send('hello：' + msg);

        console.log('data from client: ---> ' + msg);

    });

    // 断开处理

    client.on('disconnect', function() {

        console.log('Client socket has closed.'); 

    });

});

 3. 正向代理和反向代理的区别

- 正向代理：

客户端想获得一个服务器的数据，但是因为种种原因无法直接获取。于是客户端设置了一个代理服务器，并且指定目标服务器，之后代理服务器向目标服务器转交请求并将获得的内容发送给客户端。这样本质上起到了对真实服务器隐藏真实客户端的目的。实现正向代理需要修改客户端，比如修改浏览器配置。

- 反向代理：

服务器为了能够将工作负载分不到多个服务器来提高网站性能 (负载均衡)等目的，当其受到请求后，会首先根据转发规则来确定请求应该被转发到哪个服务器上，然后将请求转发到对应的真实服务器上。这样本质上起到了对客户端隐藏真实服务器的作用。

一般使用反向代理后，需要通过修改 DNS 让域名解析到代理服务器 IP，这时浏览器无法察觉到真正服务器的存在，当然也就不需要修改配置了。

两者区别如图示：

![img](https://bingjs.com:8008/img/llq/llq7.png)

正向代理和反向代理的结构是一样的，都是 client-proxy-server 的结构，它们主要的区别就在于中间这个 proxy 是哪一方设置的。在正向代理中，proxy 是 client 设置的，用来隐藏 client；而在反向代理中，proxy 是 server 设置的，用来隐藏 server。

 4. Nginx的概念及其工作原理

Nginx 是一款轻量级的 Web 服务器，也可以用于反向代理、负载平衡和 HTTP 缓存等。Nginx 使用异步事件驱动的方法来处理请求，是一款面向性能设计的 HTTP 服务器。

传统的 Web 服务器如 Apache 是 process-based 模型的，而 Nginx 是基于event-driven模型的。正是这个主要的区别带给了 Nginx 在性能上的优势。

Nginx 架构的最顶层是一个 master process，这个 master process 用于产生其他的 worker process，这一点和Apache 非常像，但是 Nginx 的 worker process 可以同时处理大量的HTTP请求，而每个 Apache process 只能处理一个。

 八、浏览器事件机制

 1. 事件是什么？事件模型？

事件是用户操作网页时发生的交互动作，比如 click/move， 事件除了用户触发的动作外，还可以是文档加载，窗口滚动和大小调整。事件被封装成一个 event 对象，包含了该事件发生时的所有相关信息（ event 的属性）以及可以对事件进行的操作（ event 的方法）。

事件是用户操作网页时发生的交互动作或者网页本身的一些操作，现代浏览器一共有三种事件模型：

- **DOM0 级事件模型**，这种模型不会传播，所以没有事件流的概念，但是现在有的浏览器支持以冒泡的方式实现，它可以在网页中直接定义监听函数，也可以通过 js 属性来指定监听函数。所有浏览器都兼容这种方式。直接在dom对象上注册事件名称，就是DOM0写法。 - **IE 事件模型**，在该事件模型中，一次事件共有两个过程，事件处理阶段和事件冒泡阶段。事件处理阶段会首先执行目标元素绑定的监听事件。然后是事件冒泡阶段，冒泡指的是事件从目标元素冒泡到 document，依次检查经过的节点是否绑定了事件监听函数，如果有则执行。这种模型通过attachEvent 来添加监听函数，可以添加多个监听函数，会按顺序依次执行。 - **DOM2 级事件模型**，在该事件模型中，一次事件共有三个过程，第一个过程是事件捕获阶段。捕获指的是事件从 document 一直向下传播到目标元素，依次检查经过的节点是否绑定了事件监听函数，如果有则执行。后面两个阶段和 IE 事件模型的两个阶段相同。这种事件模型，事件绑定的函数是addEventListener，其中第三个参数可以指定事件是否在捕获阶段执行。

 2. 如何阻止事件冒泡

- 普通浏览器使用：event.stopPropagation() - IE浏览器使用：event.cancelBubble = true;

 3. 对事件委托的理解

# 1）事件委托的概念

事件委托本质上是利用了**浏览器事件冒泡**的机制。因为事件在冒泡过程中会上传到父节点，父节点可以通过事件对象获取到目标节点，因此可以把子节点的监听函数定义在父节点上，由父节点的监听函数统一处理多个子元素的事件，这种方式称为事件委托（事件代理）。

使用事件委托可以不必要为每一个子元素都绑定一个监听事件，这样减少了内存上的消耗。并且使用事件代理还可以实现事件的动态绑定，比如说新增了一个子节点，并不需要单独地为它添加一个监听事件，它绑定的事件会交给父元素中的监听函数来处理。

# （2）事件委托的特点

- 减少内存消耗

如果有一个列表，列表之中有大量的列表项，需要在点击列表项的时候响应一个事件：

      

  • item 1

    •   

  • item 2

    •   

  • item 3

    •   ......

      

  • item n

如果给每个列表项一一都绑定一个函数，那对于内存消耗是非常大的，效率上需要消耗很多性能。因此，比较好的方法就是把这个点击事件绑定到他的父层，也就是 ul 上，然后在执行事件时再去匹配判断目标元素，所以事件委托可以减少大量的内存消耗，节约效率。

- 动态绑定事件

给上述的例子中每个列表项都绑定事件，在很多时候，需要通过 AJAX 或者用户操作动态的增加或者去除列表项元素，那么在每一次改变的时候都需要重新给新增的元素绑定事件，给即将删去的元素解绑事件；如果用了事件委托就没有这种麻烦了，因为事件是绑定在父层的，和目标元素的增减是没有关系的，执行到目标元素是在真正响应执行事件函数的过程中去匹配的，所以使用事件在动态绑定事件的情况下是可以减少很多重复工作的。

y在上述代码中， target 元素则是在 #list 元素之下具体被点击的元素，然后通过判断 target 的一些属性（比如：nodeName，id 等等）可以更精确地匹配到某一类 #list li 元素之上；

# （3）局限性

当然，事件委托也是有局限的。比如 focus、blur 之类的事件没有事件冒泡机制，所以无法实现事件委托；mousemove、mouseout 这样的事件，虽然有事件冒泡，但是只能不断通过位置去计算定位，对性能消耗高，因此也是不适合于事件委托的。

当然事件委托不是只有优点，它也是有**缺点**的，事件委托会影响页面性能，主要影响因素有：

- 元素中，绑定事件委托的次数； - 点击的最底层元素，到绑定事件元素之间的 `DOM`层数；

在必须使用事件委托的地方，可以进行如下的处理：

- 只在必须的地方，使用事件委托，比如：`ajax`的局部刷新区域 - 尽量的减少绑定的层级，不在 `body`元素上，进行绑定 - 减少绑定的次数，如果可以，那么把多个事件的绑定，合并到一次事件委托中去，由这个事件委托的回调，来进行分发。

 4. 事件委托的使用场景

场景：给页面的所有的a标签添加click事件，代码如下：

document.addEventListener("click", function(e) {

    if (e.target.nodeName == "A")

        console.log("a");

}, false);

但是这些a标签可能包含一些像span、img等元素，如果点击到了这些a标签中的元素，就不会触发click事件，因为事件绑定上在a标签元素上，而触发这些内部的元素时，e.target指向的是触发click事件的元素（span、img等其他元素）。

这种情况下就可以使用事件委托来处理，将事件绑定在a标签的内部元素上，当点击它的时候，就会逐级向上查找，知道找到a标签为止，代码如下：

document.addEventListener("click", function(e) {

    var node = e.target;

    while (node.parentNode.nodeName != "BODY") {

        if (node.nodeName == "A") {

            console.log("a");

            break;

        }

        node = node.parentNode;

    }

}, false);

 5. 同步和异步的区别

- **同步**指的是当一个进程在执行某个请求时，如果这个请求需要等待一段时间才能返回，那么这个进程会一直等待下去，直到消息返回为止再继续向下执行。 - **异步**指的是当一个进程在执行某个请求时，如果这个请求需要等待一段时间才能返回，这个时候进程会继续往下执行，不会阻塞等待消息的返回，当消息返回时系统再通知进程进行处理。

 6. 对事件循环的理解

因为 js 是单线程运行的，在代码执行时，通过将不同函数的执行上下文压入执行栈中来保证代码的有序执行。在执行同步代码时，如果遇到异步事件，js 引擎并不会一直等待其返回结果，而是会将这个事件挂起，继续执行执行栈中的其他任务。当异步事件执行完毕后，再将异步事件对应的回调加入到一个任务队列中等待执行。任务队列可以分为宏任务队列和微任务队列，当当前执行栈中的事件执行完毕后，js 引擎首先会判断微任务队列中是否有任务可以执行，如果有就将微任务队首的事件压入栈中执行。当微任务队列中的任务都执行完成后再去执行宏任务队列中的任务。

Event Loop 执行顺序如下所示：

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

 7. 宏任务和微任务分别有哪些

- 微任务包括： promise 的回调、node 中的 process.nextTick 、对 Dom 变化监听的 MutationObserver。 - 宏任务包括： script 脚本的执行、setTimeout ，setInterval ，setImmediate 一类的定时事件，还有如 I/O 操作、UI 渲染等。

 8. 什么是执行栈

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

![img](https://bingjs.com:8008/img/llq/llq1.gif)

当开始执行 JS 代码时，根据先进后出的原则，后执行的函数会先弹出栈，可以看到，`foo` 函数后执行，当执行完毕后就从栈中弹出了。

平时在开发中，可以在报错中找到执行栈的痕迹：

function foo() {

  throw new Error('error')

}

function bar() {

  foo()

}

bar()

可以看到报错在 `foo` 函数，`foo` 函数又是在 `bar` 函数中调用的。当使用递归时，因为栈可存放的函数是有**限制**的，一旦存放了过多的函数且没有得到释放的话，就会出现爆栈的问题

function bar() {

  bar()

}

bar()

 9. Node 中的 Event Loop 和浏览器中的有什么区别？process.nextTick 执行顺序？

Node 中的 Event Loop 和浏览器中的是完全不相同的东西。

Node 的 Event Loop 分为 6 个阶段，它们会按照**顺序**反复运行。每当进入某一个阶段的时候，都会从对应的回调队列中取出函数去执行。当队列为空或者执行的回调函数数量到达系统设定的阈值，就会进入下一阶段。

1）**Timers（计时器阶段）**：初次进入事件循环，会从计时器阶段开始。此阶段会判断是否存在过期的计时器回调（包含 setTimeout 和 setInterval），如果存在则会执行所有过期的计时器回调，执行完毕后，如果回调中触发了相应的微任务，会接着执行所有微任务，执行完微任务后再进入 Pending callbacks 阶段。

（2）**Pending callbacks**：执行推迟到下一个循环迭代的I / O回调（系统调用相关的回调）。

（3）**Idle/Prepare**：仅供内部使用。

（4）**Poll**（轮询阶段）：

- 当回调队列不为空时：会执行回调，若回调中触发了相应的微任务，这里的微任务执行时机和其他地方有所不同，不会等到所有回调执行完毕后才执行，而是针对每一个回调执行完毕后，就执行相应微任务。执行完所有的回调后，变为下面的情况。 - 当回调队列为空时（没有回调或所有回调执行完毕）：但如果存在有计时器（setTimeout、setInterval和setImmediate）没有执行，会结束轮询阶段，进入 Check 阶段。否则会阻塞并等待任何正在执行的I/O操作完成，并马上执行相应的回调，直到所有回调执行完毕。

（5）**Check（查询阶段）**：会检查是否存在 setImmediate 相关的回调，如果存在则执行所有回调，执行完毕后，如果回调中触发了相应的微任务，会接着执行所有微任务，执行完微任务后再进入 Close callbacks 阶段。

（6）**Close callbacks**：执行一些关闭回调，比如socket.on(‘close’, …)等。

下面来看一个例子，首先在有些情况下，定时器的执行顺序其实是**随机**的

setTimeout(() => {

    console.log('setTimeout')

}, 0)

setImmediate(() => {

    console.log('setImmediate')

})

对于以上代码来说，`setTimeout` 可能执行在前，也可能执行在后

- 首先 `setTimeout(fn, 0) === setTimeout(fn, 1)`，这是由源码决定的 - 进入事件循环也是需要成本的，如果在准备时候花费了大于 1ms 的时间，那么在 timer 阶段就会直接执行 `setTimeout `回调 - 那么如果准备时间花费小于 1ms，那么就是 `setImmediate `回调先执行了

当然在某些情况下，他们的执行顺序一定是固定的，比如以下代码：

const fs = require('fs')

fs.readFile(__filename, () => {

    setTimeout(() => {

        console.log('timeout');

    }, 0)

    setImmediate(() => {

        console.log('immediate')

    })

})

在上述代码中，`setImmediate` 永远**先执行**。因为两个代码写在 IO 回调中，IO 回调是在 poll 阶段执行，当回调执行完毕后队列为空，发现存在 `setImmediate` 回调，所以就直接跳转到 check 阶段去执行回调了。

上面都是 macrotask 的执行情况，对于 microtask 来说，它会在以上每个阶段完成前**清空** microtask 队列，下图中的 Tick 就代表了 microtask

setTimeout(() => {

  console.log('timer21')

}, 0)

Promise.resolve().then(function() {

  console.log('promise1')

})

对于以上代码来说，其实和浏览器中的输出是一样的，microtask 永远执行在 macrotask 前面。

最后来看 Node 中的 `process.nextTick`，这个函数其实是独立于 Event Loop 之外的，它有一个自己的队列，当每个阶段完成后，如果存在 nextTick 队列，就会**清空队列中的所有回调函数**，并且优先于其他 microtask 执行。

setTimeout(() => {

 console.log('timer1')

 Promise.resolve().then(function() {

   console.log('promise1')

 })

}, 0)

process.nextTick(() => {

 console.log('nextTick')

 process.nextTick(() => {

   console.log('nextTick')

   process.nextTick(() => {

     console.log('nextTick')

     process.nextTick(() => {

       console.log('nextTick')

     })

   })

 })

})

对于以上代码，永远都是先把 nextTick 全部打印出来。

顺序

//macro-task:script(全部的代码) setInterval setTimeout setImmediate I/O

//micro-task:process.nextTick  Promise

 10. 事件触发的过程是怎样的

事件触发有三个阶段：

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

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

// 以下会先打印冒泡然后是捕获

node.addEventListener(

  'click',

  event => {

    console.log('冒泡')

  },

  false

)

node.addEventListener(

  'click',

  event => {

    console.log('捕获 ')

  },

  true

)

通常使用 `addEventListener` 注册事件，该函数的第三个参数可以是布尔值，也可以是对象。对于布尔值 `useCapture` 参数来说，该参数默认值为 `false` ，`useCapture` 决定了注册的事件是捕获事件还是冒泡事件。对于对象参数来说，可以使用以下几个属性：

- `capture`：布尔值，和 `useCapture `作用一样 - `once`：布尔值，值为 `true `表示该回调只会调用一次，调用后会移除监听 - `passive`：布尔值，表示永远不会调用 `preventDefault`

一般来说，如果只希望事件只触发在目标上，这时候可以使用 `stopPropagation` 来阻止事件的进一步传播。通常认为 `stopPropagation` 是用来阻止事件冒泡的，其实该函数也可以阻止捕获事件。

`stopImmediatePropagation` 同样也能实现阻止事件，但是还能阻止该事件目标执行别的注册事件。

node.addEventListener(

  'click',

  event => {

    event.stopImmediatePropagation()

    console.log('冒泡')

  },

  false

)

// 点击 node 只会执行上面的函数，该函数不会执行

node.addEventListener(

  'click',

  event => {

    console.log('捕获 ')

  },

  true

)

九、浏览器垃圾回收机制

 1. V8的垃圾回收机制是怎样的

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

**（1）新生代算法**

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

在新生代空间中，内存空间分为两部分，分别为 From 空间和 To 空间。在这两个空间中，必定有一个空间是使用的，另一个空间是空闲的。新分配的对象会被放入 From 空间中，当 From 空间被占满时，新生代 GC 就会启动了。算法会检查 From 空间中存活的对象并复制到 To 空间中，如果有失活的对象就会销毁。当复制完成后将 From 空间和 To 空间互换，这样 GC 就结束了。

**（2）老生代算法**

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

先来说下什么情况下对象会出现在老生代空间中：

- 新生代中的对象是否已经经历过一次 Scavenge 算法，如果经历过的话，会将对象从新生代空间移到老生代空间中。 - To 空间的对象占比大小超过 25 %。在这种情况下，为了不影响到内存分配，会将对象从新生代空间移到老生代空间中。

老生代中的空间很复杂，有如下几个空间

enum AllocationSpace {

  // TODO(v8:7464): Actually map this space's memory as read-only.

  RO_SPACE,    // 不变的对象空间

  NEW_SPACE,   // 新生代用于 GC 复制算法的空间

  OLD_SPACE,   // 老生代常驻对象空间

  CODE_SPACE,  // 老生代代码对象空间

  MAP_SPACE,   // 老生代 map 对象

  LO_SPACE,    // 老生代大空间对象

  NEW_LO_SPACE,  // 新生代大空间对象

  FIRST_SPACE = RO_SPACE,

  LAST_SPACE = NEW_LO_SPACE,

  FIRST_GROWABLE_PAGED_SPACE = OLD_SPACE,

  LAST_GROWABLE_PAGED_SPACE = MAP_SPACE

};

在老生代中，以下情况会先启动标记清除算法：

- 某一个空间没有分块的时候 - 空间中被对象超过一定限制 - 空间不能保证新生代中的对象移动到老生代中

在这个阶段中，会遍历堆中所有的对象，然后标记活的对象，在标记完成后，销毁所有没有被标记的对象。在标记大型对内存时，可能需要几百毫秒才能完成一次标记。这就会导致一些性能上的问题。为了解决这个问题，2011 年，V8 从 stop-the-world 标记切换到增量标志。在增量标记期间，GC 将标记工作分解为更小的模块，可以让 JS 应用逻辑在模块间隙执行一会，从而不至于让应用出现停顿情况。但在 2018 年，GC 技术又有了一个重大突破，这项技术名为并发标记。该技术可以让 GC 扫描和标记对象时，同时允许 JS 运行。

清除对象后会造成堆内存出现碎片的情况，当碎片超过一定限制后会启动压缩算法。在压缩过程中，将活的对象向一端移动，直到所有对象都移动完成然后清理掉不需要的内存。

 2. 哪些操作会造成内存泄漏？

- 第一种情况是由于使用未声明的变量，而意外的创建了一个全局变量，而使这个变量一直留在内存中无法被回收。 - 第二种情况是设置了 setInterval 定时器，而忘记取消它，如果循环函数有对外部变量的引用的话，那么这个变量会被一直留在内存中，而无法被回收。 - 第三种情况是获取一个 DOM 元素的引用，而后面这个元素被删除，由于我们一直保留了对这个元素的引用，所以它也无法被回收。 - 第四种情况是不合理的使用闭包，从而导致某些变量一直被留在内存当中。

 一、HTTP协议

 1. GET和POST的请求的区别

Post 和 Get 是 HTTP 请求的两种方法，其区别如下：

- **应用场景：**GET 请求是一个幂等的请求，一般 Get 请求用于对服务器资源不会产生影响的场景，比如说请求一个网页的资源。而 Post 不是一个幂等的请求，一般用于对服务器资源会产生影响的情景，比如注册用户这一类的操作。 - **是否缓存：**因为两者应用场景不同，浏览器一般会对 Get 请求缓存，但很少对 Post 请求缓存。 - **发送的报文格式：**Get 请求的报文中实体部分为空，Post 请求的报文中实体部分一般为向服务器发送的数据。 - **安全性：**Get 请求可以将请求的参数放入 url 中向服务器发送，这样的做法相对于 Post 请求来说是不太安全的，因为请求的 url 会被保留在历史记录中。 - **请求长度：**浏览器由于对 url 长度的限制，所以会影响 get 请求发送数据时的长度。这个限制是浏览器规定的，并不是 RFC 规定的。 - **参数类型：**post 的参数传递支持更多的数据类型。

 2. POST和PUT请求的区别

- PUT请求是向服务器端发送数据，从而修改数据的内容，但是不会增加数据的种类等，也就是说无论进行多少次PUT操作，其结果并没有不同。（可以理解为是**更新数据**） - POST请求是向服务器端发送数据，该请求会改变数据的种类等资源，它会创建新的内容。（可以理解为是**创建数据**）

 3. 常见的HTTP请求头和响应头

**HTTP Request Header 常见的请求头：**

- Accept:浏览器能够处理的内容类型 - Accept-Charset:浏览器能够显示的字符集 - Accept-Encoding：浏览器能够处理的压缩编码 - Accept-Language：浏览器当前设置的语言 - Connection：浏览器与服务器之间连接的类型 - Cookie：当前页面设置的任何Cookie - Host：发出请求的页面所在的域 - Referer：发出请求的页面的URL - User-Agent：浏览器的用户代理字符串

**HTTP Responses Header 常见的响应头：**

- Date：表示消息发送的时间，时间的描述格式由rfc822定义 - server:服务器名称 - Connection：浏览器与服务器之间连接的类型 - Cache-Control：控制HTTP缓存 - content-type:表示后面的文档属于什么MIME类型

常见的 Content-Type 属性值有以下四种：

（1）application/x-www-form-urlencoded：浏览器的原生 form 表单，如果不设置 enctype 属性，那么最终就会以 application/x-www-form-urlencoded 方式提交数据。该种方式提交的数据放在 body 里面，数据按照 key1=val1&key2=val2 的方式进行编码，key 和 val 都进行了 URL转码。

（2）multipart/form-data：该种方式也是一个常见的 POST 提交方式，通常表单上传文件时使用该种方式。

（3）application/json：服务器消息主体是序列化后的 JSON 字符串。

（4）text/xml：该种方式主要用来提交 XML 格式的数据。

服务器向客户端发送数据格式类型：XML、HTML、JSON

 4. HTTP状态码304是多好还是少好

服务器为了提高网站访问速度，对之前访问的部分页面指定缓存机制，当客户端在此对这些页面进行请求，服务器会根据缓存内容判断页面与之前是否相同，若相同便直接返回304，此时客户端调用缓存内容，不必进行二次下载。

状态码304不应该认为是一种错误，而是对客户端**有缓存情况下**服务端的一种响应。

搜索引擎蜘蛛会更加青睐内容源更新频繁的网站。通过特定时间内对网站抓取返回的状态码来调节对该网站的抓取频次。若网站在一定时间内一直处于304的状态，那么蜘蛛可能会降低对网站的抓取次数。相反，若网站变化的频率非常之快，每次抓取都能获取新内容，那么日积月累，的回访率也会提高。

**产生较多304状态码的原因：**

- 页面更新周期长或不更新 - 纯静态页面或强制生成静态html

**304状态码出现过多会造成以下问题：**

- 网站快照停止； - 收录减少； - 权重下降。

 5. 常见的HTTP请求方法

- GET: 向服务器获取数据； - POST：将实体提交到指定的资源，通常会造成服务器资源的修改； - PUT：上传文件，更新数据； - DELETE：删除服务器上的对象； - HEAD：获取报文首部，与GET相比，不返回报文主体部分； - OPTIONS：询问支持的请求方法，用来跨域请求； - CONNECT：要求在与代理服务器通信时建立隧道，使用隧道进行TCP通信； - TRACE: 回显服务器收到的请求，主要⽤于测试或诊断。

 6. OPTIONS请求方法及使用场景

OPTIONS是除了GET和POST之外的其中一种 HTTP请求方法。

OPTIONS方法是用于请求获得由 `Request-URI`标识的资源在请求/响应的通信过程中可以使用的功能选项。通过这个方法，客户端可以**在采取具体资源请求之前，决定对该资源采取何种必要措施，或者了解服务器的性能**。该请求方法的响应不能缓存。

OPTIONS请求方法的**主要用途**有两个：

- 获取服务器支持的所有HTTP请求方法； - 用来检查访问权限。例如：在进行 CORS 跨域资源共享时，对于复杂请求，就是使用 OPTIONS 方法发送嗅探请求，以判断是否有对指定资源的访问权限。

 7. HTTP 1.0 和 HTTP 1.1 之间有哪些区别？

**HTTP 1.0和 HTTP 1.1** **有以下区别**：

- **连接方面**，http1.0 默认使用非持久连接，而 http1.1 默认使用持久连接。http1.1 通过使用持久连接来使多个 http 请求复用同一个 TCP 连接，以此来避免使用非持久连接时每次需要建立连接的时延。 - **资源请求方面**，在 http1.0 中，存在一些浪费带宽的现象，例如客户端只是需要某个对象的一部分，而服务器却将整个对象送过来了，并且不支持断点续传功能，http1.1 则在请求头引入了 range 头域，它允许只请求资源的某个部分，即返回码是 206（Partial Content），这样就方便了开发者自由的选择以便于充分利用带宽和连接。 - **缓存方面**，在 http1.0 中主要使用 header 里的 If-Modified-Since、Expires 来做为缓存判断的标准，http1.1 则引入了更多的缓存控制策略，例如 Etag、If-Unmodified-Since、If-Match、If-None-Match 等更多可供选择的缓存头来控制缓存策略。 - http1.1 中**新增了 host 字段**，用来指定服务器的域名。http1.0 中认为每台服务器都绑定一个唯一的 IP 地址，因此，请求消息中的 URL 并没有传递主机名（hostname）。但随着虚拟主机技术的发展，在一台物理服务器上可以存在多个虚拟主机，并且它们共享一个IP地址。因此有了 host 字段，这样就可以将请求发往到同一台服务器上的不同网站。 - http1.1 相对于 http1.0 还新增了很多**请求方法**，如 PUT、HEAD、OPTIONS 等。

 8. HTTP 1.1 和 HTTP 2.0 的区别

- **二进制协议：**HTTP/2 是一个二进制协议。在 HTTP/1.1 版中，报文的头信息必须是文本（ASCII 编码），数据体可以是文本，也可以是二进制。HTTP/2 则是一个彻底的二进制协议，头信息和数据体都是二进制，并且统称为"帧"，可以分为头信息帧和数据帧。 帧的概念是它实现多路复用的基础。 - **多路复用：**HTTP/2 实现了多路复用，HTTP/2 仍然复用 TCP 连接，但是在一个连接里，客户端和服务器都可以同时发送多个请求或回应，而且不用按照顺序一一发送，这样就避免了"队头堵塞"【1】的问题。 - **数据流：**HTTP/2 使用了数据流的概念，因为 HTTP/2 的数据包是不按顺序发送的，同一个连接里面连续的数据包，可能属于不同的请求。因此，必须要对数据包做标记，指出它属于哪个请求。HTTP/2 将每个请求或回应的所有数据包，称为一个数据流。每个数据流都有一个独一无二的编号。数据包发送时，都必须标记数据流 ID ，用来区分它属于哪个数据流。 - **头信息压缩：**HTTP/2 实现了头信息压缩，由于 HTTP 1.1 协议不带状态，每次请求都必须附上所有信息。所以，请求的很多字段都是重复的，比如 Cookie 和 User Agent ，一模一样的内容，每次请求都必须附带，这会浪费很多带宽，也影响速度。HTTP/2 对这一点做了优化，引入了头信息压缩机制。一方面，头信息使用 gzip 或 compress 压缩后再发送；另一方面，客户端和服务器同时维护一张头信息表，所有字段都会存入这个表，生成一个索引号，以后就不发送同样字段了，只发送索引号，这样就能提高速度了。 - **服务器推送：**HTTP/2 允许服务器未经请求，主动向客户端发送资源，这叫做服务器推送。使用服务器推送提前给客户端推送必要的资源，这样就可以相对减少一些延迟时间。这里需要注意的是 http2 下服务器主动推送的是静态资源，和 WebSocket 以及使用 SSE 等方式向客户端发送即时数据的推送是不同的。

**【1】队头堵塞：**

> 队头阻塞是由 HTTP 基本的“请求 - 应答”模型所导致的。HTTP 规定报文必须是“一发一收”，这就形成了一个先进先出的“串行”队列。队列里的请求是没有优先级的，只有入队的先后顺序，排在最前面的请求会被最优先处理。如果队首的请求因为处理的太慢耽误了时间，那么队列里后面的所有请求也不得不跟着一起等待，结果就是其他的请求承担了不应有的时间成本，造成了队头堵塞的现象。

 9. HTTP和HTTPS协议的区别

HTTP和HTTPS协议的主要区别如下：

- HTTPS协议需要CA证书，费用较高；而HTTP协议不需要； - HTTP协议是超文本传输协议，信息是明文传输的，HTTPS则是具有安全性的SSL加密传输协议； - 使用不同的连接方式，端口也不同，HTTP协议端口是80，HTTPS协议端口是443； - HTTP协议连接很简单，是无状态的；HTTPS协议是有SSL和HTTP协议构建的可进行加密传输、身份认证的网络协议，比HTTP更加安全。

 10. GET方法URL长度限制的原因

实际上HTTP协议规范并没有对get方法请求的url长度进行限制，这个限制是特定的浏览器及服务器对它的限制。

IE对URL长度的限制是2083字节(2K+35)。由于IE浏览器对URL长度的允许值是最小的，所以开发过程中，只要URL不超过2083字节，那么在所有浏览器中工作都不会有问题。

``` GET的长度值 = URL（2083）- （你的Domain+Path）-2（2是get请求中?=两个字符的长度）

```

下面看一下主流浏览器对get方法中url的长度限制范围：

- Microsoft Internet Explorer (Browser)：IE浏览器对URL的最大限制为2083个字符，如果超过这个数字，提交按钮没有任何反应。 - Firefox (Browser)：对于Firefox浏览器URL的长度限制为 65,536 个字符。 - Safari (Browser)：URL最大长度限制为 80,000 个字符。 - Opera (Browser)：URL最大长度限制为 190,000 个字符。 - Google (chrome)：URL最大长度限制为 8182 个字符。

主流的服务器对get方法中url的长度限制范围：

- Apache (Server)：能接受最大url长度为8192个字符。 - Microsoft Internet Information Server(IIS)：能接受最大url的长度为16384个字符。

根据上面的数据，可以知道，get方法中的URL长度最长不超过2083个字符，这样所有的浏览器和服务器都可能正常工作。

 11. 当在浏览器中输入 Google.com 并且按下回车之后发生了什么？

**（1）解析URL：**首先会对 URL 进行解析，分析所需要使用的传输协议和请求的资源的路径。如果输入的 URL 中的协议或者主机名不合法，将会把地址栏中输入的内容传递给搜索引擎。如果没有问题，浏览器会检查 URL 中是否出现了非法字符，如果存在非法字符，则对非法字符进行转义后再进行下一过程。

**（2）缓存判断：**浏览器会判断所请求的资源是否在缓存里，如果请求的资源在缓存里并且没有失效，那么就直接使用，否则向服务器发起新的请求。

**（3）DNS解析：**下一步首先需要获取的是输入的 URL 中的域名的 IP 地址，首先会判断本地是否有该域名的 IP 地址的缓存，如果有则使用，如果没有则向本地 DNS 服务器发起请求。本地 DNS 服务器也会先检查是否存在缓存，如果没有就会先向根域名服务器发起请求，获得负责的顶级域名服务器的地址后，再向顶级域名服务器请求，然后获得负责的权威域名服务器的地址后，再向权威域名服务器发起请求，最终获得域名的 IP 地址后，本地 DNS 服务器再将这个 IP 地址返回给请求的用户。用户向本地 DNS 服务器发起请求属于递归请求，本地 DNS 服务器向各级域名服务器发起请求属于迭代请求。

**（4）获取MAC地址：**当浏览器得到 IP 地址后，数据传输还需要知道目的主机 MAC 地址，因为应用层下发数据给传输层，TCP 协议会指定源端口号和目的端口号，然后下发给网络层。网络层会将本机地址作为源地址，获取的 IP 地址作为目的地址。然后将下发给数据链路层，数据链路层的发送需要加入通信双方的 MAC 地址，本机的 MAC 地址作为源 MAC 地址，目的 MAC 地址需要分情况处理。通过将 IP 地址与本机的子网掩码相与，可以判断是否与请求主机在同一个子网里，如果在同一个子网里，可以使用 ARP 协议获取到目的主机的 MAC 地址，如果不在一个子网里，那么请求应该转发给网关，由它代为转发，此时同样可以通过 ARP 协议来获取网关的 MAC 地址，此时目的主机的 MAC 地址应该为网关的地址。

**（5）TCP三次握手：**下面是 TCP 建立连接的三次握手的过程，首先客户端向服务器发送一个 SYN 连接请求报文段和一个随机序号，服务端接收到请求后向服务器端发送一个 SYN ACK报文段，确认连接请求，并且也向客户端发送一个随机序号。客户端接收服务器的确认应答后，进入连接建立的状态，同时向服务器也发送一个ACK 确认报文段，服务器端接收到确认后，也进入连接建立状态，此时双方的连接就建立起来了。

**（6）HTTPS握手：**如果使用的是 HTTPS 协议，在通信前还存在 TLS 的一个四次握手的过程。首先由客户端向服务器端发送使用的协议的版本号、一个随机数和可以使用的加密方法。服务器端收到后，确认加密的方法，也向客户端发送一个随机数和自己的数字证书。客户端收到后，首先检查数字证书是否有效，如果有效，则再生成一个随机数，并使用证书中的公钥对随机数加密，然后发送给服务器端，并且还会提供一个前面所有内容的 hash 值供服务器端检验。服务器端接收后，使用自己的私钥对数据解密，同时向客户端发送一个前面所有内容的 hash 值供客户端检验。这个时候双方都有了三个随机数，按照之前所约定的加密方法，使用这三个随机数生成一把秘钥，以后双方通信前，就使用这个秘钥对数据进行加密后再传输。

**（7）返回数据：**当页面请求发送到服务器端后，服务器端会返回一个 html 文件作为响应，浏览器接收到响应后，开始对 html 文件进行解析，开始页面的渲染过程。

**（8）页面渲染：**浏览器首先会根据 html 文件构建 DOM 树，根据解析到的 css 文件构建 CSSOM 树，如果遇到 script 标签，则判端是否含有 defer 或者 async 属性，要不然 script 的加载和执行会造成页面的渲染的阻塞。当 DOM 树和 CSSOM 树建立好后，根据它们来构建渲染树。渲染树构建好后，会根据渲染树来进行布局。布局完成后，最后使用浏览器的 UI 接口对页面进行绘制。这个时候整个页面就显示出来了。

**（9）TCP四次挥手：**最后一步是 TCP 断开连接的四次挥手过程。若客户端认为数据发送完成，则它需要向服务端发送连接释放请求。服务端收到连接释放请求后，会告诉应用层要释放 TCP 链接。然后会发送 ACK 包，并进入 CLOSE_WAIT 状态，此时表明客户端到服务端的连接已经释放，不再接收客户端发的数据了。但是因为 TCP 连接是双向的，所以服务端仍旧可以发送数据给客户端。服务端如果此时还有没发完的数据会继续发送，完毕后会向客户端发送连接释放请求，然后服务端便进入 LAST-ACK 状态。客户端收到释放请求后，向服务端发送确认应答，此时客户端进入 TIME-WAIT 状态。该状态会持续 2MSL（最大段生存期，指报文段在网络中生存的时间，超时会被抛弃） 时间，若该时间段内没有服务端的重发请求的话，就进入 CLOSED 状态。当服务端收到确认应答后，也便进入 CLOSED 状态。

 12. 对keep-alive的理解

HTTP1.0 中默认是在每次请求/应答，客户端和服务器都要新建一个连接，完成之后立即断开连接，这就是**短连接**。当使用Keep-Alive模式时，Keep-Alive功能使客户端到服务器端的连接持续有效，当出现对服务器的后继请求时，Keep-Alive功能避免了建立或者重新建立连接，这就是**长连接**。其使用方法如下：

- HTTP1.0版本是默认没有Keep-alive的（也就是默认会发送keep-alive），所以要想连接得到保持，必须手动配置发送 `Connection: keep-alive`字段。若想断开keep-alive连接，需发送 `Connection:close`字段； - HTTP1.1规定了默认保持长连接，数据传输完成了保持TCP连接不断开，等待在同域名下继续用这个通道传输数据。如果需要关闭，需要客户端发送 `Connection:close`首部字段。

Keep-Alive的**建立过程**：

- 客户端向服务器在发送请求报文同时在首部添加发送Connection字段 - 服务器收到请求并处理 Connection字段 - 服务器回送Connection:Keep-Alive字段给客户端 - 客户端接收到Connection字段 - Keep-Alive连接建立成功

**服务端自动断开过程（也就是没有keep-alive）**：

- 客户端向服务器只是发送内容报文（不包含Connection字段） - 服务器收到请求并处理 - 服务器返回客户端请求的资源并关闭连接 - 客户端接收资源，发现没有Connection字段，断开连接

**客户端请求断开连接过程**：

- 客户端向服务器发送Connection:close字段 - 服务器收到请求并处理connection字段 - 服务器回送响应资源并断开连接 - 客户端接收资源并断开连接

开启Keep-Alive的**优点：**

- 较少的CPU和内存的使⽤（由于同时打开的连接的减少了）； - 允许请求和应答的HTTP管线化； - 降低拥塞控制 （TCP连接减少了）； - 减少了后续请求的延迟（⽆需再进⾏握⼿）； - 报告错误⽆需关闭TCP连；

开启Keep-Alive的**缺点**：

- 长时间的Tcp连接容易导致系统资源无效占用，浪费系统资源。

 13. 页面有多张图片，HTTP是怎样的加载表现？

- 在 **HTTP 1**下，浏览器对一个域名下最大TCP连接数为6，所以会请求多次。可以用**多域名部署**解决。这样可以提高同时请求的数目，加快页面图片的获取速度。 - 在 **HTTP 2**下，可以一瞬间加载出来很多资源，因为，HTTP2支持多路复用，可以在一个TCP连接中发送多个HTTP请求。

 14. HTTP2的头部压缩算法是怎样的？

HTTP2的头部压缩是HPACK算法。在客户端和服务器两端建立“字典”，用索引号表示重复的字符串，采用哈夫曼编码来压缩整数和字符串，可以达到50%~90%的高压缩率。

具体来说:

- 在客户端和服务器端使用“首部表”来跟踪和存储之前发送的键值对，对于相同的数据，不再通过每次请求和响应发送； - 首部表在HTTP/2的连接存续期内始终存在，由客户端和服务器共同渐进地更新； - 每个新的首部键值对要么被追加到当前表的末尾，要么替换表中之前的值。

例如下图中的两个请求， 请求一发送了所有的头部字段，第二个请求则只需要发送差异数据，这样可以减少冗余数据，降低开销。

 15. HTTP请求报文的是什么样的？

请求报⽂有4部分组成:

- 请求⾏ - 请求头部 - 空⾏ - 请求体

**其中：**

（1）请求⾏包括：请求⽅法字段、URL字段、HTTP协议版本字段。它们⽤空格分隔。例如，GET /index.html HTTP/1.1。

（2）请求头部:请求头部由关键字/值对组成，每⾏⼀对，关键字和值⽤英⽂冒号“:”分隔

- User-Agent：产⽣请求的浏览器类型。 - Accept：客户端可识别的内容类型列表。 - Host：请求的主机名，允许多个域名同处⼀个IP地址，即虚拟主机。

（3）请求体: post put等请求携带的数据

 16. HTTP响应报文的是什么样的？

请求报⽂有4部分组成:

- 响应⾏ - 响应头 - 空⾏ - 响应体

- 响应⾏：由网络协议版本，状态码和状态码的原因短语组成，例如 HTTP/1.1 200 OK 。 - 响应头：响应部⾸组成 - 响应体：服务器响应的数据

 17. HTTP协议的优点和缺点

HTTP 是超文本传输协议，它定义了客户端和服务器之间交换报文的格式和方式，默认使用 80 端口。它使用 TCP 作为传输层协议，保证了数据传输的可靠性。

HTTP协议具有以下**优点**：

- 支持客户端/服务器模式 - **简单快速**：客户向服务器请求服务时，只需传送请求方法和路径。由于 HTTP 协议简单，使得 HTTP 服务器的程序规模小，因而通信速度很快。 - **无连接**：无连接就是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接，采用这种方式可以节省传输时间。 - **无状态**：HTTP 协议是无状态协议，这里的状态是指通信过程的上下文信息。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能会导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就比较快。 - **灵活**：HTTP 允许传输任意类型的数据对象。正在传输的类型由 Content-Type 加以标记。

HTTP协议具有以下**缺点**：

- **无状态**：HTTP 是一个无状态的协议，HTTP 服务器不会保存关于客户的任何信息。 - **明文传输**：协议中的报文使用的是文本形式，这就直接暴露给外界，不安全。 - **不安全**

（1）通信使用明文（不加密），内容可能会被窃听；

（2）不验证通信方的身份，因此有可能遭遇伪装；

（3）无法证明报文的完整性，所以有可能已遭篡改；

 18. 说一下HTTP 3.0

HTTP/3基于UDP协议实现了类似于TCP的多路复用数据流、传输可靠性等功能，这套功能被称为QUIC协议。

1. 流量控制、传输可靠性功能：QUIC在UDP的基础上增加了一层来保证数据传输可靠性，它提供了数据包重传、拥塞控制、以及其他一些TCP中的特性。 2. 集成TLS加密功能：目前QUIC使用TLS1.3，减少了握手所花费的RTT数。 3. 多路复用：同一物理连接上可以有多个独立的逻辑数据流，实现了数据流的单独传输，解决了TCP的队头阻塞问题。 4. 快速握手：由于基于UDP，可以实现使用0 ~ 1个RTT来建立连接。

 19. HTTP协议的性能怎么样

HTTP 协议是基于 TCP/IP，并且使用了**请求-应答**的通信模式，所以性能的关键就在这两点里。

- **长连接**

HTTP协议有两种连接模式，一种是持续连接，一种非持续连接。

（1）非持续连接指的是服务器必须为每一个请求的对象建立和维护一个全新的连接。

（2）持续连接下，TCP 连接默认不关闭，可以被多个请求复用。采用持续连接的好处是可以避免每次建立 TCP 连接三次握手时所花费的时间。

对于不同版本的采用不同的连接方式：

- 在HTTP/1.0 每发起一个请求，都要新建一次 TCP 连接（三次握手），而且是串行请求，做了无畏的 TCP 连接建立和断开，增加了通信开销。该版本使用的非持续的连接，但是可以在请求时，加上 Connection: keep-a live 来要求服务器不要关闭 TCP 连接。 - 在HTTP/1.1 提出了**长连接**的通信方式，也叫持久连接。这种方式的好处在于减少了 TCP 连接的重复建立和断开所造成的额外开销，减轻了服务器端的负载。该版本及以后版本默认采用的是持续的连接。目前对于同一个域，大多数浏览器支持同时建立 6 个持久连接。

- **管道网络传输**

HTTP/1.1 采用了长连接的方式，这使得管道（pipeline）网络传输成为了可能。

管道（pipeline）网络传输是指：可以在同一个 TCP 连接里面，客户端可以发起多个请求，只要第一个请求发出去了，不必等其回来，就可以发第二个请求出去，可以减少整体的响应时间。但是服务器还是按照顺序回应请求。如果前面的回应特别慢，后面就会有许多请求排队等着。这称为队头堵塞。

- **队头堵塞**

HTTP 传输的报文必须是一发一收，但是，里面的任务被放在一个任务队列中串行执行，一旦队首的请求处理太慢，就会阻塞后面请求的处理。这就是HTTP队头阻塞问题。

**队头阻塞的解决方案：**

（1）并发连接：对于一个域名允许分配多个长连接，那么相当于增加了任务队列，不至于一个队伍的任务阻塞其它所有任务。

（2）域名分片：将域名分出很多二级域名，它们都指向同样的一台服务器，能够并发的长连接数变多，解决了队头阻塞的问题。

 20. URL有哪些组成部分

以下面的URL为例：**http://www.aspxfans.com:8080/news/index.asp?boardID=5&ID=24618&page=1#name**

从上面的URL可以看出，一个完整的URL包括以下几部分：

- **协议部分**：该URL的协议部分为“http：”，这代表网页使用的是HTTP协议。在Internet中可以使用多种协议，如HTTP，FTP等等本例中使用的是HTTP协议。在"HTTP"后面的“//”为分隔符； - **域名部分**：该URL的域名部分为“www.aspxfans.com”。一个URL中，也可以使用IP地址作为域名使用 - **端口部分**：跟在域名后面的是端口，域名和端口之间使用“:”作为分隔符。端口不是一个URL必须的部分，如果省略端口部分，将采用默认端口（HTTP协议默认端口是80，HTTPS协议默认端口是443）； - **虚拟目录部分**：从域名后的第一个“/”开始到最后一个“/”为止，是虚拟目录部分。虚拟目录也不是一个URL必须的部分。本例中的虚拟目录是“/news/”； - **文件名部分**：从域名后的最后一个“/”开始到“？”为止，是文件名部分，如果没有“?”,则是从域名后的最后一个“/”开始到“#”为止，是文件部分，如果没有“？”和“#”，那么从域名后的最后一个“/”开始到结束，都是文件名部分。本例中的文件名是“index.asp”。文件名部分也不是一个URL必须的部分，如果省略该部分，则使用默认的文件名； - **锚部分**：从“#”开始到最后，都是锚部分。本例中的锚部分是“name”。锚部分也不是一个URL必须的部分； - **参数部分**：从“？”开始到“#”为止之间的部分为参数部分，又称搜索部分、查询部分。本例中的参数部分为“boardID=5&ID=24618&page=1”。参数可以允许有多个参数，参数与参数之间用“&”作为分隔符。

 21. 与缓存相关的HTTP请求头有哪些

强缓存：

- Expires - Cache-Control

协商缓存：

- Etag、If-None-Match - Last-Modified、If-Modified-Since

 二、HTTPS协议

 1. 什么是HTTPS协议？

超文本传输安全协议（Hypertext Transfer Protocol Secure，简称：HTTPS）是一种通过计算机网络进行安全通信的传输协议。HTTPS经由HTTP进行通信，利用SSL/TLS来加密数据包。HTTPS的主要目的是提供对网站服务器的身份认证，保护交换数据的隐私与完整性。

HTTP协议采用**明文传输**信息，存在**信息窃听**、**信息篡改**和**信息劫持**的风险，而协议TLS/SSL具有**身份验证**、**信息加密**和**完整性校验**的功能，可以避免此类问题发生。

安全层的主要职责就是**对发起的HTTP请求的数据进行加密操作** 和 **对接收到的HTTP的内容进行解密操作**。

 2. TLS/SSL的工作原理

**TLS/SSL**全称**安全传输层协议**（Transport Layer Security）, 是介于TCP和HTTP之间的一层安全协议，不影响原有的TCP协议和HTTP协议，所以使用HTTPS基本上不需要对HTTP页面进行太多的改造。

TLS/SSL的功能实现主要依赖三类基本算法：**散列函数hash**、**对称加密**、**非对称加密**。这三类算法的作用如下：

- 基于散列函数验证信息的完整性 - 对称加密算法采用协商的秘钥对数据加密 - 非对称加密实现身份认证和秘钥协商

# （1）散列函数hash

常见的散列函数有MD5、SHA1、SHA256。该函数的特点是单向不可逆，对输入数据非常敏感，输出的长度固定，任何数据的修改都会改变散列函数的结果，可以用于防止信息篡改并验证数据的完整性。

**特点**：在信息传输过程中，散列函数不能三都实现信息防篡改，由于传输是明文传输，中间人可以修改信息后重新计算信息的摘要，所以需要对传输的信息和信息摘要进行加密。

# （2）对称加密

对称加密的方法是，双方使用同一个秘钥对数据进行加密和解密。但是对称加密的存在一个问题，就是如何保证秘钥传输的安全性，因为秘钥还是会通过网络传输的，一旦秘钥被其他人获取到，那么整个加密过程就毫无作用了。 这就要用到非对称加密的方法。

常见的对称加密算法有AES-CBC、DES、3DES、AES-GCM等。相同的秘钥可以用于信息的加密和解密。掌握秘钥才能获取信息，防止信息窃听，其通讯方式是一对一。

**特点**：对称加密的优势就是信息传输使用一对一，需要共享相同的密码，密码的安全是保证信息安全的基础，服务器和N个客户端通信，需要维持N个密码记录且不能修改密码。

# （3）非对称加密

非对称加密的方法是，我们拥有两个秘钥，一个是公钥，一个是私钥。公钥是公开的，私钥是保密的。用私钥加密的数据，只有对应的公钥才能解密，用公钥加密的数据，只有对应的私钥才能解密。我们可以将公钥公布出去，任何想和我们通信的客户， 都可以使用我们提供的公钥对数据进行加密，这样我们就可以使用私钥进行解密，这样就能保证数据的安全了。但是非对称加密有一个缺点就是加密的过程很慢，因此如果每次通信都使用非对称加密的方式的话，反而会造成等待时间过长的问题。

常见的非对称加密算法有RSA、ECC、DH等。秘钥成对出现，一般称为公钥（公开）和私钥（保密）。公钥加密的信息只有私钥可以解开，私钥加密的信息只能公钥解开，因此掌握公钥的不同客户端之间不能相互解密信息，只能和服务器进行加密通信，服务器可以实现一对多的的通信，客户端也可以用来验证掌握私钥的服务器的身份。

**特点**：非对称加密的特点就是信息一对多，服务器只需要维持一个私钥就可以和多个客户端进行通信，但服务器发出的信息能够被所有的客户端解密，且该算法的计算复杂，加密的速度慢。

综合上述算法特点，TLS/SSL的工作方式就是客户端使用非对称加密与服务器进行通信，实现身份的验证并协商对称加密使用的秘钥。对称加密算法采用协商秘钥对信息以及信息摘要进行加密通信，不同节点之间采用的对称秘钥不同，从而保证信息只能通信双方获取。这样就解决了两个方法各自存在的问题。

 3. 数字证书是什么？

现在的方法也不一定是安全的，因为没有办法确定得到的公钥就一定是安全的公钥。可能存在一个中间人，截取了对方发给我们的公钥，然后将他自己的公钥发送给我们，当我们使用他的公钥加密后发送的信息，就可以被他用自己的私钥解密。然后他伪装成我们以同样的方法向对方发送信息，这样我们的信息就被窃取了，然而自己还不知道。为了解决这样的问题，可以使用数字证书。

首先使用一种 Hash 算法来对公钥和其他信息进行加密，生成一个信息摘要，然后让有公信力的认证中心（简称 CA ）用它的私钥对消息摘要加密，形成签名。最后将原始的信息和签名合在一起，称为数字证书。当接收方收到数字证书的时候，先根据原始信息使用同样的 Hash 算法生成一个摘要，然后使用公证处的公钥来对数字证书中的摘要进行解密，最后将解密的摘要和生成的摘要进行对比，就能发现得到的信息是否被更改了。

这个方法最要的是认证中心的可靠性，一般浏览器里会内置一些顶层的认证中心的证书，相当于我们自动信任了他们，只有这样才能保证数据的安全。

 4. HTTPS通信（握手）过程

HTTPS的通信过程如下：

1. 客户端向服务器发起请求，请求中包含使用的协议版本号、生成的一个随机数、以及客户端支持的加密方法。 2. 服务器端接收到请求后，确认双方使用的加密方法、并给出服务器的证书、以及一个服务器生成的随机数。 3. 客户端确认服务器证书有效后，生成一个新的随机数，并使用数字证书中的公钥，加密这个随机数，然后发给服 务器。并且还会提供一个前面所有内容的 hash 的值，用来供服务器检验。 4. 服务器使用自己的私钥，来解密客户端发送过来的随机数。并提供前面所有内容的 hash 值来供客户端检验。 5. 客户端和服务器端根据约定的加密方法使用前面的三个随机数，生成对话秘钥，以后的对话过程都使用这个秘钥来加密信息。

 5. HTTPS的特点

HTTPS的**优点**如下：

- 使用HTTPS协议可以认证用户和服务器，确保数据发送到正确的客户端和服务器； - 使用HTTPS协议可以进行加密传输、身份认证，通信更加安全，防止数据在传输过程中被窃取、修改，确保数据安全性； - HTTPS是现行架构下最安全的解决方案，虽然不是绝对的安全，但是大幅增加了中间人攻击的成本；

HTTPS的**缺点**如下：

- HTTPS需要做服务器和客户端双方的加密个解密处理，耗费更多服务器资源，过程复杂； - HTTPS协议握手阶段比较费时，增加页面的加载时间； - SSL证书是收费的，功能越强大的证书费用越高； - HTTPS连接服务器端资源占用高很多，支持访客稍多的网站需要投入更大的成本； - SSL证书需要绑定IP，不能再同一个IP上绑定多个域名。

 6. HTTPS是如何保证安全的？

先理解两个概念：

- 对称加密：即通信的双⽅都使⽤同⼀个秘钥进⾏加解密，对称加密虽然很简单性能也好，但是⽆法解决⾸次把秘钥发给对⽅的问题，很容易被⿊客拦截秘钥。 - ⾮对称加密：

1. 私钥 + 公钥= 密钥对 2. 即⽤私钥加密的数据,只有对应的公钥才能解密,⽤公钥加密的数据,只有对应的私钥才能解密 3. 因为通信双⽅的⼿⾥都有⼀套⾃⼰的密钥对,通信之前双⽅会先把⾃⼰的公钥都先发给对⽅ 4. 然后对⽅再拿着这个公钥来加密数据响应给对⽅,等到到了对⽅那⾥,对⽅再⽤⾃⼰的私钥进⾏解密

⾮对称加密虽然安全性更⾼，但是带来的问题就是速度很慢，影响性能。

**解决⽅案：**

结合两种加密⽅式，将对称加密的密钥使⽤⾮对称加密的公钥进⾏加密，然后发送出去，接收⽅使⽤私钥进⾏解密得到对称加密的密钥，然后双⽅可以使⽤对称加密来进⾏沟通。

此时⼜带来⼀个问题，中间⼈问题：

如果此时在客户端和服务器之间存在⼀个中间⼈,这个中间⼈只需要把原本双⽅通信互发的公钥,换成⾃⼰的公钥,这样中间⼈就可以轻松解密通信双⽅所发送的所有数据。

所以这个时候需要⼀个安全的第三⽅颁发证书（CA），证明身份的身份，防⽌被中间⼈攻击。 证书中包括：签发者、证书⽤途、使⽤者公钥、使⽤者私钥、使⽤者的HASH算法、证书到期时间等。

但是问题来了，如果中间⼈篡改了证书，那么身份证明是不是就⽆效了？这个证明就⽩买了，这个时候需要⼀个新的技术，数字签名。

数字签名就是⽤CA⾃带的HASH算法对证书的内容进⾏HASH得到⼀个摘要，再⽤CA的私钥加密，最终组成数字签名。当别⼈把他的证书发过来的时候,我再⽤同样的Hash算法,再次⽣成消息摘要，然后⽤CA的公钥对数字签名解密,得到CA创建的消息摘要,两者⼀⽐,就知道中间有没有被⼈篡改了。这个时候就能最⼤程度保证通信的安全了。

三、HTTP状态码

状态码的类别：

| **类别** | **原因**                  | **描述**        | | ------ | ----------------------- | ------------- | | 1xx    | Informational(信息性状态码)   | 接受的请求正在处理     | | 2xx    | Success(成功状态码)          | 请求正常处理完毕      | | 3xx    | Redirection(重定向状态码)     | 需要进行附加操作一完成请求 | | 4xx    | Client Error (客户端错误状态码) | 服务器无法处理请求     | | 5xx    | Server Error(服务器错误状态码)  | 服务器处理请求出错     |

 1. 2XX (Success 成功状态码)

状态码2XX表示请求被正常处理了。

# （1）200 OK

200 OK表示客户端发来的请求被服务器端正常处理了。

# （2）204 No Content

该状态码表示客户端发送的请求已经在服务器端正常处理了，但是没有返回的内容，响应报文中不包含实体的主体部分。一般在只需要从客户端往服务器端发送信息，而服务器端不需要往客户端发送内容时使用。

# （3）206 Partial Content

该状态码表示客户端进行了范围请求，而服务器端执行了这部分的 GET 请求。响应报文中包含由 Content-Range 指定范围的实体内容。

 2. 3XX (Redirection 重定向状态码)

3XX 响应结果表明浏览器需要执行某些特殊的处理以正确处理请求。

# （1）301 Moved Permanently

**永久重定向。**

该状态码表示请求的资源已经被分配了新的 URI，以后应使用资源指定的 URI。新的 URI 会在 HTTP 响应头中的 Location 首部字段指定。若用户已经把原来的URI保存为书签，此时会按照 Location 中新的URI重新保存该书签。同时，搜索引擎在抓取新内容的同时也将旧的网址替换为重定向之后的网址。

**使用场景：**

- 当我们想换个域名，旧的域名不再使用时，用户访问旧域名时用301就重定向到新的域名。其实也是告诉搜索引擎收录的域名需要对新的域名进行收录。 - 在搜索引擎的搜索结果中出现了不带www的域名，而带www的域名却没有收录，这个时候可以用301重定向来告诉搜索引擎我们目标的域名是哪一个。

# （2）302 Found

**临时重定向。**

该状态码表示请求的资源被分配到了新的 URI，希望用户（本次）能使用新的 URI 访问资源。和 301 Moved Permanently 状态码相似，但是 302 代表的资源不是被永久重定向，只是临时性质的。也就是说已移动的资源对应的 URI 将来还有可能发生改变。若用户把 URI 保存成书签，但不会像 301 状态码出现时那样去更新书签，而是仍旧保留返回 302 状态码的页面对应的 URI。同时，搜索引擎会抓取新的内容而保留旧的网址。因为服务器返回302代码，搜索引擎认为新的网址只是暂时的。

**使用场景：**

- 当我们在做活动时，登录到首页自动重定向，进入活动页面。 - 未登陆的用户访问用户中心重定向到登录页面。 - 访问404页面重新定向到首页。

# （3）303 See Other

该状态码表示由于请求对应的资源存在着另一个 URI，应使用 GET 方法定向获取请求的资源。

303 状态码和 302 Found 状态码有着相似的功能，但是 303 状态码明确表示客户端应当采用 GET 方法获取资源。

303 状态码通常作为 PUT 或 POST 操作的返回结果，它表示重定向链接指向的不是新上传的资源，而是另外一个页面，比如消息确认页面或上传进度页面。而请求重定向页面的方法要总是使用 GET。

注意：

- 当 301、302、303 响应状态码返回时，几乎所有的浏览器都会把 POST 改成GET，并删除请求报文内的主体，之后请求会再次自动发送。 - 301、302 标准是禁止将 POST 方法变成 GET方法的，但实际大家都会这么做。

# （4）304 Not Modified

浏览器缓存相关。

该状态码表示客户端发送附带条件的请求时，服务器端允许请求访问资源，但未满足条件的情况。304 状态码返回时，不包含任何响应的主体部分。304 虽然被划分在 3XX 类别中，但是和重定向没有关系。

带条件的请求（Http 条件请求）：使用 Get方法 请求，请求报文中包含（`if-match`、`if-none-match`、`if-modified-since`、`if-unmodified-since`、`if-range`）中任意首部。

状态码304并不是一种错误，而是告诉客户端有缓存，直接使用缓存中的数据。返回页面的只有头部信息，是没有内容部分的，这样在一定程度上提高了网页的性能。

# （5）307 Temporary Redirect

307表示临时重定向。该状态码与 302 Found 有着相同含义，尽管 302 标准禁止 POST 变成 GET，但是实际使用时还是这样做了。

307 会遵守浏览器标准，**不会从 POST 变成 GET**。但是对于处理请求的行为时，不同浏览器还是会出现不同的情况。规范要求浏览器继续向 Location 的地址 POST 内容。规范要求浏览器继续向 Location 的地址 POST 内容。

 3. 4XX (Client Error 客户端错误状态码)

4XX 的响应结果表明客户端是发生错误的原因所在。

# （1）400 Bad Request

该状态码表示请求报文中存在语法错误。当错误发生时，需修改请求的内容后再次发送请求。另外，浏览器会像 200 OK 一样对待该状态码。

# （2）401 Unauthorized

该状态码表示发送的请求需要有通过 HTTP 认证(BASIC 认证、DIGEST 认证)的认证信息。若之前已进行过一次请求，则表示用户认证失败

返回含有 401 的响应必须包含一个适用于被请求资源的 WWW-Authenticate 首部用以质询(challenge)用户信息。当浏览器初次接收到 401 响应，会弹出认证用的对话窗口。

以下情况会出现401：

- 401.1 - 登录失败。 - 401.2 - 服务器配置导致登录失败。 - 401.3 - 由于 ACL 对资源的限制而未获得授权。 - 401.4 - 筛选器授权失败。 - 401.5 - ISAPI/CGI 应用程序授权失败。 - 401.7 - 访问被 Web 服务器上的 URL 授权策略拒绝。这个错误代码为 IIS 6.0 所专用。

# （3）403 Forbidden

该状态码表明请求资源的访问被服务器拒绝了，服务器端没有必要给出详细理由，但是可以在响应报文实体的主体中进行说明。进入该状态后，不能再继续进行验证。该访问是永久禁止的，并且与应用逻辑密切相关。

IIS 定义了许多不同的 403 错误，它们指明更为具体的错误原因：

- 403.1 - 执行访问被禁止。 - 403.2 - 读访问被禁止。 - 403.3 - 写访问被禁止。 - 403.4 - 要求 SSL。 - 403.5 - 要求 SSL 128。 - 403.6 - IP 地址被拒绝。 - 403.7 - 要求客户端证书。 - 403.8 - 站点访问被拒绝。 - 403.9 - 用户数过多。 - 403.10 - 配置无效。 - 403.11 - 密码更改。 - 403.12 - 拒绝访问映射表。 - 403.13 - 客户端证书被吊销。 - 403.14 - 拒绝目录列表。 - 403.15 - 超出客户端访问许可。 - 403.16 - 客户端证书不受信任或无效。 - 403.17 - 客户端证书已过期或尚未生效 - 403.18 - 在当前的应用程序池中不能执行所请求的 URL。这个错误代码为 IIS 6.0 所专用。 - 403.19 - 不能为这个应用程序池中的客户端执行 CGI。这个错误代码为 IIS 6.0 所专用。 - 403.20 - Passport 登录失败。这个错误代码为 IIS 6.0 所专用。

# （4）404 Not Found

该状态码表明服务器上无法找到请求的资源。除此之外，也可以在服务器端拒绝请求且不想说明理由时使用。

以下情况会出现404：

- 404.0 -（无） – 没有找到文件或目录。 - 404.1 - 无法在所请求的端口上访问 Web 站点。 - 404.2 - Web 服务扩展锁定策略阻止本请求。 - 404.3 - MIME 映射策略阻止本请求。

# （5）405 Method Not Allowed

该状态码表示客户端请求的方法虽然能被服务器识别，但是服务器禁止使用该方法。GET 和 HEAD 方法，服务器应该总是允许客户端进行访问。客户端可以通过 OPTIONS 方法（预检）来查看服务器允许的访问方法, 如下

``` Access-Control-Allow-Methods: GET,HEAD,PUT,PATCH,POST,DELETE

```

 4. 5XX (Server Error 服务器错误状态码)

5XX 的响应结果表明服务器本身发生错误.

# （1）500 Internal Server Error

该状态码表明服务器端在执行请求时发生了错误。也有可能是 Web 应用存在的 bug 或某些临时的故障。

# （2）502 Bad Gateway

该状态码表明扮演网关或代理角色的服务器，从上游服务器中接收到的响应是无效的。注意，502 错误通常不是客户端能够修复的，而是需要由途经的 Web 服务器或者代理服务器对其进行修复。以下情况会出现502：

- 502.1 - CGI （通用网关接口）应用程序超时。 - 502.2 - CGI （通用网关接口）应用程序出错。

# （3）503 Service Unavailable

该状态码表明服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。如果事先得知解除以上状况需要的时间，最好写入 RetryAfter 首部字段再返回给客户端。

**使用场景：**

- 服务器停机维护时，主动用503响应请求； - nginx 设置限速，超过限速，会返回503。

# （4）504 Gateway Timeout

该状态码表示网关或者代理的服务器无法在规定的时间内获得想要的响应。他是HTTP 1.1中新加入的。

使用场景：代码执行时间超时，或者发生了死循环。

 5. 总结

**1）2XX 成功**

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

**（2）3XX 重定向**

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

**（3）4XX 客户端错误**

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

**（4）5XX 服务器错误**

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

 6. 同样是重定向，307，303，302的区别？

302是http1.0的协议状态码，在http1.1版本的时候为了细化302状态码⼜出来了两个303和307。 303明确表示客户端应当采⽤get⽅法获取资源，他会把POST请求变为GET请求进⾏重定向。 307会遵照浏览器标准，不会从post变为get。

四、DNS协议介绍

 1. DNS 协议是什么

**概念**： DNS 是域名系统 (Domain Name System) 的缩写，提供的是一种主机名到 IP 地址的转换服务，就是我们常说的域名系统。它是一个由分层的 DNS 服务器组成的分布式数据库，是定义了主机如何查询这个分布式数据库的方式的应用层协议。能够使人更方便的访问互联网，而不用去记住能够被机器直接读取的IP数串。

**作用**： 将域名解析为IP地址，客户端向DNS服务器（DNS服务器有自己的IP地址）发送域名查询请求，DNS服务器告知客户机Web服务器的 IP 地址。

 2. DNS同时使用TCP和UDP协议？

**DNS占用53号端口，同时使用TCP和UDP协议。**

（1）在区域传输的时候使用TCP协议

- 辅域名服务器会定时（一般3小时）向主域名服务器进行查询以便了解数据是否有变动。如有变动，会执行一次区域传送，进行数据同步。区域传送使用TCP而不是UDP，因为数据同步传送的数据量比一个请求应答的数据量要多得多。 - TCP是一种可靠连接，保证了数据的准确性。

（2）在域名解析的时候使用UDP协议

- 客户端向DNS服务器查询域名，一般返回的内容都不超过512字节，用UDP传输即可。不用经过三次握手，这样DNS服务器负载更低，响应更快。理论上说，客户端也可以指定向DNS服务器查询时用TCP，但事实上，很多DNS服务器进行配置的时候，仅支持UDP查询包。

 3. DNS完整的查询过程

DNS服务器解析域名的过程：

- 首先会在**浏览器的缓存**中查找对应的IP地址，如果查找到直接返回，若找不到继续下一步 - 将请求发送给**本地DNS服务器**，在本地域名服务器缓存中查询，如果查找到，就直接将查找结果返回，若找不到继续下一步 - 本地DNS服务器向**根域名服务器**发送请求，根域名服务器会返回一个所查询域的顶级域名服务器地址 - 本地DNS服务器向**顶级域名服务器**发送请求，接受请求的服务器查询自己的缓存，如果有记录，就返回查询结果，如果没有就返回相关的下一级的权威域名服务器的地址 - 本地DNS服务器向**权威域名服务器**发送请求，域名服务器返回对应的结果 - 本地DNS服务器将返回结果保存在缓存中，便于下次使用 - 本地DNS服务器将返回结果返回给浏览器

比如要查询 **www.baidu.com** 的 IP 地址，首先会在浏览器的缓存中查找是否有该域名的缓存，如果不存在就将请求发送到本地的 DNS 服务器中，本地DNS服务器会判断是否存在该域名的缓存，如果不存在，则向根域名服务器发送一个请求，根域名服务器返回负责 .com 的顶级域名服务器的 IP 地址的列表。然后本地 DNS 服务器再向其中一个负责 .com 的顶级域名服务器发送一个请求，负责 .com 的顶级域名服务器返回负责 .baidu 的权威域名服务器的 IP 地址列表。然后本地 DNS 服务器再向其中一个权威域名服务器发送一个请求，最后权威域名服务器返回一个对应的主机名的 IP 地址列表。

 4. 迭代查询与递归查询

实际上，DNS解析是一个包含迭代查询和递归查询的过程。

- **递归查询**指的是查询请求发出后，域名服务器代为向下一级域名服务器发出请求，最后向用户返回查询的最终结果。使用递归 查询，用户只需要发出一次查询请求。 - **迭代查询**指的是查询请求后，域名服务器返回单次查询的结果。下一级的查询由用户自己请求。使用迭代查询，用户需要发出 多次的查询请求。

一般我们向本地 DNS 服务器发送请求的方式就是递归查询，因为我们只需要发出一次请求，然后本地 DNS 服务器返回给我 们最终的请求结果。而本地 DNS 服务器向其他域名服务器请求的过程是迭代查询的过程，因为每一次域名服务器只返回单次 查询的结果，下一级的查询由本地 DNS 服务器自己进行。

 5. DNS 记录和报文

DNS 服务器中以资源记录的形式存储信息，每一个 DNS 响应报文一般包含多条资源记录。一条资源记录的具体的格式为

``` （Name，Value，Type，TTL）

```

其中 TTL 是资源记录的生存时间，它定义了资源记录能够被其他的 DNS 服务器缓存多长时间。

常用的一共有四种 Type 的值，分别是 A、NS、CNAME 和 MX ，不同 Type 的值，对应资源记录代表的意义不同：

- 如果 Type = A，则 Name 是主机名，Value 是主机名对应的 IP 地址。因此一条记录为 A 的资源记录，提供了标 准的主机名到 IP 地址的映射。 - 如果 Type = NS，则 Name 是个域名，Value 是负责该域名的 DNS 服务器的主机名。这个记录主要用于 DNS 链式 查询时，返回下一级需要查询的 DNS 服务器的信息。 - 如果 Type = CNAME，则 Name 为别名，Value 为该主机的规范主机名。该条记录用于向查询的主机返回一个主机名 对应的规范主机名，从而告诉查询主机去查询这个主机名的 IP 地址。主机别名主要是为了通过给一些复杂的主机名提供 一个便于记忆的简单的别名。 - 如果 Type = MX，则 Name 为一个邮件服务器的别名，Value 为邮件服务器的规范主机名。它的作用和 CNAME 是一 样的，都是为了解决规范主机名不利于记忆的缺点。

 五、网络模型

 1. OSI七层模型

`ISO`为了更好的使网络应用更为普及，推出了 `OSI`参考模型。

# （1）应用层

`OSI`参考模型中最靠近用户的一层，是为计算机用户提供应用接口，也为用户直接提供各种网络服务。我们常见应用层的网络服务协议有：`HTTP`，`HTTPS`，`FTP`，`POP3`、`SMTP`等。

- 在客户端与服务器中经常会有数据的请求，这个时候就是会用到 `http(hyper text transfer protocol)(超文本传输协议)`或者 `https`在后端设计数据接口时，我们常常使用到这个协议。 - `FTP`是文件传输协议，在开发过程中，个人并没有涉及到，但是我想，在一些资源网站，比如 **百度网盘 迅雷**应该是基于此协议的。 - `SMTP`是 `simple mail transfer protocol（简单邮件传输协议）`。在一个项目中，在用户邮箱验证码登录的功能时，使用到了这个协议。

# （2）表示层

表示层提供各种用于应用层数据的编码和转换功能,确保一个系统的应用层发送的数据能被另一个系统的应用层识别。如果必要，该层可提供一种标准表示形式，用于将计算机内部的多种数据格式转换成通信中采用的标准表示形式。数据压缩和加密也是表示层可提供的转换功能之一。

在项目开发中，为了方便数据传输，可以使用 `base64`对数据进行编解码。如果按功能来划分，`base64`应该是工作在表示层。

# （3）会话层

会话层就是负责建立、管理和终止表示层实体之间的通信会话。该层的通信由不同设备中的应用程序之间的服务请求和响应组成。

# （4）传输层

传输层建立了主机端到端的链接，传输层的作用是为上层协议提供端到端的可靠和透明的数据传输服务，包括处理差错控制和流量控制等问题。该层向高层屏蔽了下层数据通信的细节，使高层用户看到的只是在两个传输实体间的一条主机到主机的、可由用户控制和设定的、可靠的数据通路。我们通常说的，`TCP` `UDP`就是在这一层。端口号既是这里的“端”。

# （5）网络层

本层通过 `IP`寻址来建立两个节点之间的连接，为源端的运输层送来的分组，选择合适的路由和交换节点，正确无误地按照地址传送给目的端的运输层。就是通常说的 `IP`层。这一层就是我们经常说的 `IP`协议层。`IP`协议是 `Internet`的基础。我们可以这样理解，网络层规定了数据包的传输路线，而传输层则规定了数据包的传输方式。

# （6）数据链路层

将比特组合成字节,再将字节组合成帧,使用链路层地址 (以太网使用MAC地址)来访问介质,并进行差错检测。

网络层与数据链路层的对比，通过上面的描述，我们或许可以这样理解，网络层是规划了数据包的传输路线，而数据链路层就是传输路线。不过，在数据链路层上还增加了差错控制的功能。

# （7）物理层

实际最终信号的传输是通过物理层实现的。通过物理介质传输比特流。规定了电平、速度和电缆针脚。常用设备有（各种物理设备）集线器、中继器、调制解调器、网线、双绞线、同轴电缆。这些都是物理层的传输介质。

**OSI七层模型通信特点：对等通信**

对等通信，为了使数据分组从源传送到目的地，源端OSI模型的每一层都必须与目的端的对等层进行通信，这种通信方式称为对等层通信。在每一层通信过程中，使用本层自己协议进行通信。

 2. TCP/IP五层协议

`TCP/IP`五层协议和 `OSI`的七层协议对应关系如下：

![img](https://bingjs.com:8008/img/wl/wl9.png)

- **应用层 (application layer)**：直接为应用进程提供服务。应用层协议定义的是应用进程间通讯和交互的规则，不同的应用有着不同的应用层协议，如 HTTP协议（万维网服务）、FTP协议（文件传输）、SMTP协议（电子邮件）、DNS（域名查询）等。 - **传输层 (transport layer)**：有时也译为运输层，它负责为两台主机中的进程提供通信服务。该层主要有以下两种协议： - - **传输控制协议 (Transmission Control Protocol，TCP)**：提供面向连接的、可靠的数据传输服务，数据传输的基本单位是报文段（segment）；   - **用户数据报协议 (User Datagram Protocol，UDP)**：提供无连接的、尽最大努力的数据传输服务，但不保证数据传输的可靠性，数据传输的基本单位是用户数据报。 - **网络层 (internet layer)**：有时也译为网际层，它负责为两台主机提供通信服务，并通过选择合适的路由将数据传递到目标主机。 - **数据链路层 (data link layer)**：负责将网络层交下来的 IP 数据报封装成帧，并在链路的两个相邻节点间传送帧，每一帧都包含数据和必要的控制信息（如同步信息、地址信息、差错控制等）。 - **物理层 (physical Layer)**：确保数据可以在各种物理媒介上进行传输，为数据的传输提供可靠的环境。

从上图中可以看出，`TCP/IP`模型比 `OSI`模型更加简洁，它把 `应用层/表示层/会话层`全部整合为了 `应用层`。

在每一层都工作着不同的设备，比如我们常用的交换机就工作在数据链路层的，一般的路由器是工作在网络层的。

在每一层实现的协议也各不同，即每一层的服务也不同，下图列出了每层主要的传输协议：

同样，`TCP/IP`五层协议的通信方式也是对等通信：

六、TCP与UDP

 1. TCP 和 UDP的概念及特点

TCP 和 UDP都是传输层协议，他们都属于TCP/IP协议族：

**（1）UDP**

UDP的全称是**用户数据报协议**，在网络中它与TCP协议一样用于处理数据包，是一种无连接的协议。在OSI模型中，在传输层，处于IP协议的上一层。UDP有不提供数据包分组、组装和不能对数据包进行排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。

它的特点如下：

**1）面向无连接**

首先 UDP 是不需要和 TCP一样在发送数据前进行三次握手建立连接的，想发数据就可以开始发送了。并且也只是数据报文的搬运工，不会对数据报文进行任何拆分和拼接操作。

具体来说就是：

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

**2）有单播，多播，广播的功能**

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

**3）面向报文**

发送方的UDP对应用程序交下来的报文，在添加首部后就向下交付IP层。UDP对应用层交下来的报文，既不合并，也不拆分，而是保留这些报文的边界。因此，应用程序必须选择合适大小的报文

**4）不可靠性**

首先不可靠性体现在无连接上，通信都不需要建立连接，想发就发，这样的情况肯定不可靠。

并且收到什么数据就传递什么数据，并且也不会备份数据，发送数据也不会关心对方是否已经正确接收到数据了。

再者网络环境时好时坏，但是 UDP 因为没有拥塞控制，一直会以恒定的速度发送数据。即使网络条件不好，也不会对发送速率进行调整。这样实现的弊端就是在网络条件不好的情况下可能会导致丢包，但是优点也很明显，在某些实时性要求高的场景（比如电话会议）就需要使用 UDP 而不是 TCP。

**5）头部开销小，传输数据报文时是很高效的。**

![img](https://bingjs.com:8008/img/wl/wl11.png)

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

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

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

**（2）TCP**

TCP的全称是传输控制协议是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP 是面向连接的、可靠的流协议（流就是指不间断的数据结构）。

它有以下几个特点：

**1）面向连接**

面向连接，是指发送数据之前必须在两端建立连接。建立连接的方法是“三次握手”，这样能建立可靠的连接。建立连接，是为数据的可靠传输打下了基础。

**2）仅支持单播传输**

每条TCP传输连接只能有两个端点，只能进行点对点的数据传输，不支持多播和广播传输方式。

**3）面向字节流**

TCP不像UDP一样那样一个个报文独立地传输，而是在不保留报文边界的情况下以字节流方式进行传输。

**4）可靠传输**

对于可靠传输，判断丢包、误码靠的是TCP的段编号以及确认号。TCP为了保证报文传输的可靠，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收。然后接收端实体对已成功收到的字节发回一个相应的确认(ACK)；如果发送端实体在合理的往返时延(RTT)内未收到确认，那么对应的数据（假设丢失了）将会被重传。

**5）提供拥塞控制**

当网络出现拥塞的时候，TCP能够减小向网络注入数据的速率和数量，缓解拥塞。

**6）提供全双工通信**

TCP允许通信双方的应用程序在任何时候都能发送数据，因为TCP连接的两端都设有缓存，用来临时存放双向通信的数据。当然，TCP可以立即发送一个数据段，也可以缓存一段时间以便一次发送更多的数据段（最大的数据段大小取决于MSS）

 2. TCP和UDP的区别

|        | UDP                   | TCP                        | | ------ | --------------------- | -------------------------- | | 是否连接   | 无连接                   | 面向连接                       | | 是否可靠   | 不可靠传输，不使用流量控制和拥塞控制    | 可靠传输（数据顺序和正确性），使用流量控制和拥塞控制 | | 连接对象个数 | 支持一对一，一对多，多对一和多对多交互通信 | 只能是一对一通信                   | | 传输方式   | 面向报文                  | 面向字节流                      | | 首部开销   | 首部开销小，仅8字节            | 首部最小20字节，最大60字节            | | 适用场景   | 适用于实时应用，例如视频会议、直播     | 适用于要求可靠传输的应用，例如文件传输        |

 3. TCP和UDP的使用场景

- **TCP应用场景**： 效率要求相对低，但对准确性要求相对高的场景。因为传输中需要对数据确认、重发、排序等操作，相比之下效率没有UDP高。例如：文件传输（准确高要求高、但是速度可以相对慢）、接受邮件、远程登录。 - **UDP应用场景**： 效率要求相对高，对准确性要求相对低的场景。例如：QQ聊天、在线视频、网络语音电话（即时通讯，速度要求高，但是出现偶尔断续不是太大问题，并且此处完全不可以使用重发机制）、广播通信（广播、多播）。

 4. UDP协议为什么不可靠？

UDP在传输数据之前不需要先建立连接，远地主机的运输层在接收到UDP报文后，不需要确认，提供不可靠交付。总结就以下四点：

- 不保证消息交付：不确认，不重传，无超时 - 不保证交付顺序：不设置包序号，不重排，不会发生队首阻塞 - 不跟踪连接状态：不必建立连接或重启状态机 - 不进行拥塞控制：不内置客户端或网络反馈机制

 5. TCP的重传机制

由于TCP的下层网络（网络层）可能出现**丢失、重复或失序**的情况，TCP协议提供可靠数据传输服务。为保证数据传输的正确性，TCP会重传其认为已丢失（包括报文中的比特错误）的包。TCP使用两套独立的机制来完成重传，一是**基于时间**，二是**基于确认信息**。

TCP在发送一个数据之后，就开启一个定时器，若是在这个时间内没有收到发送数据的ACK确认报文，则对该报文进行重传，在达到一定次数还没有成功时放弃并发送一个复位信号。

 6. TCP的拥塞控制机制

TCP的拥塞控制机制主要是以下四种机制：

- 慢启动（慢开始） - 拥塞避免 - 快速重传 - 快速恢复

**（1）慢启动（慢开始）**

- 在开始发送的时候设置cwnd = 1（cwnd指的是拥塞窗口） - 思路：开始的时候不要发送大量数据，而是先测试一下网络的拥塞程度，由小到大增加拥塞窗口的大小。 - 为了防止cwnd增长过大引起网络拥塞，设置一个慢开始门限(ssthresh 状态变量) - - 当cnwd < ssthresh，使用慢开始算法   - 当cnwd = ssthresh，既可使用慢开始算法，也可以使用拥塞避免算法   - 当cnwd > ssthresh，使用拥塞避免算法

**（2）拥塞避免**

- 拥塞避免未必能够完全避免拥塞，是说在拥塞避免阶段将拥塞窗口控制为按线性增长，使网络不容易出现阻塞。 - 思路： 让拥塞窗口cwnd缓慢的增大，即每经过一个返回时间RTT就把发送方的拥塞控制窗口加一 - 无论是在慢开始阶段还是在拥塞避免阶段，只要发送方判断网络出现拥塞，就把慢开始门限设置为出现拥塞时的发送窗口大小的一半。然后把拥塞窗口设置为1，执行慢开始算法。如图所示:

![img](https://bingjs.com:8008/img/wl/wl12.png)

- 其中，判断网络出现拥塞的根据就是没有收到确认，虽然没有收到确认可能是其他原因的分组丢失，但是因为无法判定，所以都当做拥塞来处理。

**（3）快速重传**

- 快重传要求接收方在收到一个失序的报文段后就立即发出重复确认(为的是使发送方及早知道有报文段没有到达对方)。发送方只要连续收到三个重复确认就立即重传对方尚未收到的报文段，而不必继续等待设置的重传计时器时间到期。 - 由于不需要等待设置的重传计时器到期，能尽早重传未被确认的报文段，能提高整个网络的吞吐量

**（4）快速恢复**

- 当发送方连续收到三个重复确认时，就执行“乘法减小”算法，把ssthresh门限减半。但是接下去并不执行慢开始算法。 - 考虑到如果网络出现拥塞的话就不会收到好几个重复的确认，所以发送方现在认为网络可能没有出现拥塞。所以此时不执行慢开始算法，而是将cwnd设置为ssthresh的大小，然后执行拥塞避免算法。

 7. TCP的流量控制机制

一般来说，流量控制就是为了让发送方发送数据的速度不要太快，要让接收方来得及接收。TCP采用大小可变的**滑动窗口**进行流量控制，窗口大小的单位是字节。这里说的窗口大小其实就是每次传输的数据大小。

- 当一个连接建立时，连接的每一端分配一个缓冲区来保存输入的数据，并将缓冲区的大小发送给另一端。 - 当数据到达时，接收方发送确认，其中包含了自己剩余的缓冲区大小。（剩余的缓冲区空间的大小被称为窗口，指出窗口大小的通知称为窗口通告 。接收方在发送的每一确认中都含有一个窗口通告。） - 如果接收方应用程序读数据的速度能够与数据到达的速度一样快，接收方将在每一确认中发送一个正的窗口通告。 - 如果发送方操作的速度快于接收方，接收到的数据最终将充满接收方的缓冲区，导致接收方通告一个零窗口 。发送方收到一个零窗口通告时，必须停止发送，直到接收方重新通告一个正的窗口。

 8. TCP的可靠传输机制

TCP 的可靠传输机制是基于连续 ARQ 协议和滑动窗口协议的。

TCP 协议在发送方维持了一个发送窗口，发送窗口以前的报文段是已经发送并确认了的报文段，发送窗口中包含了已经发送但 未确认的报文段和允许发送但还未发送的报文段，发送窗口以后的报文段是缓存中还不允许发送的报文段。当发送方向接收方发 送报文时，会依次发送窗口内的所有报文段，并且设置一个定时器，这个定时器可以理解为是最早发送但未收到确认的报文段。 如果在定时器的时间内收到某一个报文段的确认回答，则滑动窗口，将窗口的首部向后滑动到确认报文段的后一个位置，此时如 果还有已发送但没有确认的报文段，则重新设置定时器，如果没有了则关闭定时器。如果定时器超时，则重新发送所有已经发送 但还未收到确认的报文段，并将超时的间隔设置为以前的两倍。当发送方收到接收方的三个冗余的确认应答后，这是一种指示， 说明该报文段以后的报文段很有可能发生丢失了，那么发送方会启用快速重传的机制，就是当前定时器结束前，发送所有的已发 送但确认的报文段。

接收方使用的是累计确认的机制，对于所有按序到达的报文段，接收方返回一个报文段的肯定回答。如果收到了一个乱序的报文 段，那么接方会直接丢弃，并返回一个最近的按序到达的报文段的肯定回答。使用累计确认保证了返回的确认号之前的报文段都 已经按序到达了，所以发送窗口可以移动到已确认报文段的后面。

发送窗口的大小是变化的，它是由接收窗口剩余大小和网络中拥塞程度来决定的，TCP 就是通过控制发送窗口的长度来控制报文 段的发送速率。

但是 TCP 协议并不完全和滑动窗口协议相同，因为许多的 TCP 实现会将失序的报文段给缓存起来，并且发生重传时，只会重 传一个报文段，因此 TCP 协议的可靠传输机制更像是窗口滑动协议和选择重传协议的一个混合体。

 9. TCP的三次握手和四次挥手

# （1）三次握手

![img](https://bingjs.com:8008/img/wl/wl13.png)

三次握手（Three-way Handshake）其实就是指建立一个TCP连接时，需要客户端和服务器总共发送3个包。进行三次握手的主要作用就是为了确认双方的接收能力和发送能力是否正常、指定自己的初始化序列号为后面的可靠性传送做准备。实质上其实就是连接服务器指定端口，建立TCP连接，并同步连接双方的序列号和确认号，交换TCP窗口大小信息。

刚开始客户端处于 Closed 的状态，服务端处于 Listen 状态。

- 第一次握手：客户端给服务端发一个 SYN 报文，并指明客户端的初始化序列号 ISN，此时客户端处于 SYN_SEND 状态。

> 首部的同步位SYN=1，初始序号seq=x，SYN=1的报文段不能携带数据，但要消耗掉一个序号。

- 第二次握手：服务器收到客户端的 SYN 报文之后，会以自己的 SYN 报文作为应答，并且也是指定了自己的初始化序列号 ISN。同时会把客户端的 ISN + 1 作为ACK 的值，表示自己已经收到了客户端的 SYN，此时服务器处于 SYN_REVD 的状态。

> 在确认报文段中SYN=1，ACK=1，确认号ack=x+1，初始序号seq=y

- 第三次握手：客户端收到 SYN 报文之后，会发送一个 ACK 报文，当然，也是一样把服务器的 ISN + 1 作为 ACK 的值，表示已经收到了服务端的 SYN 报文，此时客户端处于 ESTABLISHED 状态。服务器收到 ACK 报文之后，也处于 ESTABLISHED 状态，此时，双方已建立起了连接。

> 确认报文段ACK=1，确认号ack=y+1，序号seq=x+1（初始为seq=x，第二个报文段所以要+1），ACK报文段可以携带数据，不携带数据则不消耗序号。

**那为什么要三次握手呢？两次不行吗？**

- 为了确认双方的接收能力和发送能力都正常 - 如果是用两次握手，则会出现下面这种情况：

> 如客户端发出连接请求，但因连接请求报文丢失而未收到确认，于是客户端再重传一次连接请求。后来收到了确认，建立了连接。数据传输完毕后，就释放了连接，客户端共发出了两个连接请求报文段，其中第一个丢失，第二个到达了服务端，但是第一个丢失的报文段只是在某些网络结点长时间滞留了，延误到连接释放以后的某个时间才到达服务端，此时服务端误认为客户端又发出一次新的连接请求，于是就向客户端发出确认报文段，同意建立连接，不采用三次握手，只要服务端发出确认，就建立新的连接了，此时客户端忽略服务端发来的确认，也不发送数据，则服务端一致等待客户端发送数据，浪费资源。

**简单来说就是以下三步：**

- **第一次握手**：客户端向服务端发送连接请求报文段。该报文段中包含自身的数据通讯初始序号。请求发送后，客户端便进入 SYN-SENT 状态。 - **第二次握手**：服务端收到连接请求报文段后，如果同意连接，则会发送一个应答，该应答中也会包含自身的数据通讯初始序号，发送完成后便进入 SYN-RECEIVED 状态。 - **第三次握手**：当客户端收到连接同意的应答后，还要向服务端发送一个确认报文。客户端发完这个报文段后便进入 ESTABLISHED 状态，服务端收到这个应答后也进入 ESTABLISHED 状态，此时连接建立成功。

TCP 三次握手的建立连接的过程就是相互确认初始序号的过程，告诉对方，什么样序号的报文段能够被正确接收。 第三次握手的作用是客户端对服务器端的初始序号的确认。如果只使用两次握手，那么服务器就没有办法知道自己的序号是否 已被确认。同时这样也是为了防止失效的请求报文段被服务器接收，而出现错误的情况。

# （2）四次挥手

![img](https://bingjs.com:8008/img/wl/wl14.png)

刚开始双方都处于 ESTABLISHED 状态，假如是客户端先发起关闭请求。四次挥手的过程如下：

- 第一次挥手： 客户端会发送一个 FIN 报文，报文中会指定一个序列号。此时客户端处于 FIN_WAIT1 状态。

> 即发出连接释放报文段（FIN=1，序号seq=u），并停止再发送数据，主动关闭TCP连接，进入FIN_WAIT1（终止等待1）状态，等待服务端的确认。

- 第二次挥手：服务端收到 FIN 之后，会发送 ACK 报文，且把客户端的序列号值 +1 作为 ACK 报文的序列号值，表明已经收到客户端的报文了，此时服务端处于 CLOSE_WAIT 状态。

> 即服务端收到连接释放报文段后即发出确认报文段（ACK=1，确认号ack=u+1，序号seq=v），服务端进入CLOSE_WAIT（关闭等待）状态，此时的TCP处于半关闭状态，客户端到服务端的连接释放。客户端收到服务端的确认后，进入FIN_WAIT2（终止等待2）状态，等待服务端发出的连接释放报文段。

- 第三次挥手：如果服务端也想断开连接了，和客户端的第一次挥手一样，发给 FIN 报文，且指定一个序列号。此时服务端处于 LAST_ACK 的状态。

> 即服务端没有要向客户端发出的数据，服务端发出连接释放报文段（FIN=1，ACK=1，序号seq=w，确认号ack=u+1），服务端进入LAST_ACK（最后确认）状态，等待客户端的确认。

- 第四次挥手：客户端收到 FIN 之后，一样发送一个 ACK 报文作为应答，且把服务端的序列号值 +1 作为自己 ACK 报文的序列号值，此时客户端处于 TIME_WAIT 状态。需要过一阵子以确保服务端收到自己的 ACK 报文之后才会进入 CLOSED 状态，服务端收到 ACK 报文之后，就处于关闭连接了，处于 CLOSED 状态。

> 即客户端收到服务端的连接释放报文段后，对此发出确认报文段（ACK=1，seq=u+1，ack=w+1），客户端进入TIME_WAIT（时间等待）状态。此时TCP未释放掉，需要经过时间等待计时器设置的时间2MSL后，客户端才进入CLOSED状态。

那为什么需要四次挥手呢？

> 因为当服务端收到客户端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当服务端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉客户端，“你发的FIN报文我收到了”。只有等到我服务端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送，故需要四次挥手。

简单来说就是以下四步：

- **第一次挥手**：若客户端认为数据发送完成，则它需要向服务端发送连接释放请求。 - **第二次挥手**：服务端收到连接释放请求后，会告诉应用层要释放 TCP 链接。然后会发送 ACK 包，并进入 CLOSE_WAIT 状态，此时表明客户端到服务端的连接已经释放，不再接收客户端发的数据了。但是因为 TCP 连接是双向的，所以服务端仍旧可以发送数据给客户端。 - **第三次挥手**：服务端如果此时还有没发完的数据会继续发送，完毕后会向客户端发送连接释放请求，然后服务端便进入 LAST-ACK 状态。 - **第四次挥手**：客户端收到释放请求后，向服务端发送确认应答，此时客户端进入 TIME-WAIT 状态。该状态会持续 2MSL（最大段生存期，指报文段在网络中生存的时间，超时会被抛弃） 时间，若该时间段内没有服务端的重发请求的话，就进入 CLOSED 状态。当服务端收到确认应答后，也便进入 CLOSED 状态。

TCP 使用四次挥手的原因是因为 TCP 的连接是全双工的，所以需要双方分别释放到对方的连接，单独一方的连接释放，只代 表不能再向对方发送数据，连接处于的是半释放的状态。

最后一次挥手中，客户端会等待一段时间再关闭的原因，是为了防止发送给服务器的确认报文段丢失或者出错，从而导致服务器 端不能正常关闭。

 10. TCP粘包是怎么回事，如何处理?

默认情况下, TCP 连接会启⽤延迟传送算法 (Nagle 算法), 在数据发送之前缓存他们. 如果短时间有多个数据发送, 会缓冲到⼀起作⼀次发送 (缓冲大小见 socket.bufferSize ), 这样可以减少 IO 消耗提⾼性能.

如果是传输⽂件的话, 那么根本不⽤处理粘包的问题, 来⼀个包拼⼀个包就好了。但是如果是多条消息, 或者是别的⽤途的数据那么就需要处理粘包.

下面看⼀个例⼦, 连续调⽤两次 send 分别发送两段数据 data1 和 data2, 在接收端有以下⼏种常⻅的情况:

A. 先接收到 data1, 然后接收到 data2 .

B. 先接收到 data1 的部分数据, 然后接收到 data1 余下的部分以及 data2 的全部.

C. 先接收到了 data1 的全部数据和 data2 的部分数据, 然后接收到了 data2 的余下的数据.

D. ⼀次性接收到了 data1 和 data2 的全部数据.

其中的 BCD 就是我们常⻅的粘包的情况. ⽽对于处理粘包的问题, 常⻅的解决⽅案有:

- **多次发送之前间隔⼀个等待时间**：只需要等上⼀段时间再进⾏下⼀次 send 就好, 适⽤于交互频率特别低的场景. 缺点也很明显, 对于⽐较频繁的场景⽽⾔传输效率实在太低，不过⼏乎不⽤做什么处理. - **关闭Nagle算法**：关闭 Nagle 算法, 在 Node.js 中你可以通过 socket.setNoDelay() ⽅法来关闭 Nagle 算法, 让每⼀次 send 都不缓冲直接发送。该⽅法⽐较适⽤于每次发送的数据都⽐较⼤ (但不是⽂件那么⼤), 并且频率不是特别⾼的场景。如果是每次发送的数据量⽐较⼩, 并且频率特别⾼的, 关闭 Nagle 纯属⾃废武功。另外, 该⽅法不适⽤于⽹络较差的情况, 因为 Nagle 算法是在服务端进⾏的包合并情况, 但是如果短时间内客户端的⽹络情况不好, 或者应⽤层由于某些原因不能及时将 TCP 的数据 recv, 就会造成多个包在客户端缓冲从⽽粘包的情况。 (如果是在稳定的机房内部通信那么这个概率是⽐较⼩可以选择忽略的) - **进⾏封包/拆包**：封包/拆包是⽬前业内常⻅的解决⽅案了。即给每个数据包在发送之前, 于其前/后放⼀些有特征的数据, 然后收到数据的时 候根据特征数据分割出来各个数据包。

 11. 为什么udp不会粘包？

- TCP协议是⾯向流的协议，UDP是⾯向消息的协议。UDP段都是⼀条消息，应⽤程序必须以消息为单位提取数据，不能⼀次提取任意字节的数据 - UDP具有保护消息边界，在每个UDP包中就有了消息头（消息来源地址，端⼝等信息），这样对于接收端来说就容易进⾏区分处理了。传输协议把数据当作⼀条独⽴的消息在⽹上传输，接收端只能接收独⽴的消息。接收端⼀次只能接收发送端发出的⼀个数据包,如果⼀次接受数据的⼤⼩⼩于发送端⼀次发送的数据⼤⼩，就会丢失⼀部分数据，即使丢失，接受端也不会分两次去接收。

七、WebSocket

 1. 对 WebSocket 的理解

WebSocket是HTML5提供的一种浏览器与服务器进行**全双工通讯**的网络技术，属于应用层协议。它基于TCP传输协议，并复用HTTP的握手通道。浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接， 并进行双向数据传输。

WebSocket 的出现就解决了半双工通信的弊端。它最大的特点是：**服务器可以向客户端主动推动消息，客户端也可以主动向服务器推送消息。**

**WebSocket原理**：客户端向 WebSocket 服务器通知（notify）一个带有所有接收者ID（recipients IDs）的事件（event），服务器接收后立即通知所有活跃的（active）客户端，只有ID在接收者ID序列中的客户端才会处理这个事件。

**WebSocket 特点的如下：**

- 支持双向通信，实时性更强 - 可以发送文本，也可以发送二进制数据‘’ - 建立在TCP协议之上，服务端的实现比较容易 - 数据格式比较轻量，性能开销小，通信高效 - 没有同源限制，客户端可以与任意服务器通信 - 协议标识符是ws（如果加密，则为wss），服务器网址就是 URL - 与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。

**Websocket的使用方法如下：**

在客户端中：

// 在index.html中直接写WebSocket，设置服务端的端口号为 9999

let ws = new WebSocket('ws://localhost:9999');

// 在客户端与服务端建立连接后触发

ws.onopen = function() {

    console.log("Connection open."); 

    ws.send('hello');

};

// 在服务端给客户端发来消息的时候触发

ws.onmessage = function(res) {

    console.log(res);       // 打印的是MessageEvent对象

    console.log(res.data);  // 打印的是收到的消息

};

// 在客户端与服务端建立关闭后触发

ws.onclose = function(evt) {

  console.log("Connection closed.");

}; 

 2. 即时通讯的实现：短轮询、长轮询、SSE 和 WebSocket 间的区别？

短轮询和长轮询的目的都是用于实现客户端和服务器端的一个即时通讯。

**短轮询的基本思路**：浏览器每隔一段时间向浏览器发送 http 请求，服务器端在收到请求后，不论是否有数据更新，都直接进行响应。这种方式实现的即时通信，本质上还是浏览器发送请求，服务器接受请求的一个过程，通过让客户端不断的进行请求，使得客户端能够模拟实时地收到服务器端的数据的变化。这种方式的优点是比较简单，易于理解。缺点是这种方式由于需要不断的建立 http 连接，严重浪费了服务器端和客户端的资源。当用户增加时，服务器端的压力就会变大，这是很不合理的。

**长轮询的基本思路**：首先由客户端向服务器发起请求，当服务器收到客户端发来的请求后，服务器端不会直接进行响应，而是先将这个请求挂起，然后判断服务器端数据是否有更新。如果有更新，则进行响应，如果一直没有数据，则到达一定的时间限制才返回。客户端 JavaScript 响应处理函数会在处理完服务器返回的信息后，再次发出请求，重新建立连接。长轮询和短轮询比起来，它的优点是明显减少了很多不必要的 http 请求次数，相比之下节约了资源。长轮询的缺点在于，连接挂起也会导致资源的浪费。

**SSE 的基本思想**：服务器使用流信息向服务器推送信息。严格地说，http 协议无法做到服务器主动推送信息。但是，有一种变通方法，就是服务器向客户端声明，接下来要发送的是流信息。也就是说，发送的不是一次性的数据包，而是一个数据流，会连续不断地发送过来。这时，客户端不会关闭连接，会一直等着服务器发过来的新的数据流，视频播放就是这样的例子。SSE 就是利用这种机制，使用流信息向浏览器推送信息。它基于 http 协议，目前除了 IE/Edge，其他浏览器都支持。它相对于前面两种方式来说，不需要建立过多的 http 请求，相比之下节约了资源。

WebSocket 是 HTML5 定义的一个新协议议，与传统的 http 协议不同，该协议允许由服务器主动的向客户端推送信息。使用 WebSocket 协议的缺点是在服务器端的配置比较复杂。WebSocket 是一个全双工的协议，也就是通信双方是平等的，可以相互发送消息，而 SSE 的方式是单向通信的，只能由服务器端向客户端推送信息，如果客户端需要发送信息就是属于下一个 http 请求了。

**上面的四个通信协议，前三个都是基于HTTP协议的。**

对于这四种即使通信协议，从性能的角度来看：

**WebSocket > 长连接（SEE） > 长轮询 > 短轮询**

但是，我们如果考虑浏览器的兼容性问题，顺序就恰恰相反了：

**短轮询 > 长轮询 > 长连接（SEE） > WebSocket**

所以，还是要根据具体的使用场景来判断使用哪种方式。

# 代码输出面试题

 前言：

**代码输出结果**也是面试中常考的题目，一段代码中可能涉及到很多的知识点，这就考察到了应聘者的基础能力。在前端面试中，常考的代码输出问题主要涉及到以下知识点：**异步编程、事件循环、this指向、作用域、变量提升、闭包、原型、继承**等，这些知识点往往不是单独出现的，而是在同一段代码中包含多个知识点。所以，笔者将这些问题大致分为四类进行讨论。这里不会系统的阐述基础知识，而是通过面试例题的形式，来讲述每个题目的知识点以及代码的执行过程。如果会了这些例题，在前端面试中多数代码输出问题就可以轻而易举的解决了。

一、异步&事件循环

 1. 代码输出结果

const promise = new Promise((resolve, reject) => {

  console.log(1);

  console.log(2);

});

promise.then(() => {

  console.log(3);

});

console.log(4);

```

输出结果如下：

```

1 

2 

4

promise.then 是微任务，它会在所有的宏任务执行完之后才会执行，同时需要promise内部的状态发生变化，因为这里内部没有发生变化，一直处于pending状态，所以不输出3。

 2. 代码输出结果

const promise1 = new Promise((resolve, reject) => {

  console.log('promise1')

  resolve('resolve1')

})

const promise2 = promise1.then(res => {

  console.log(res)

})

console.log('1', promise1);

console.log('2', promise2);

```

输出结果如下：

```

promise1

1 Promise{: resolve1}

2 Promise{}

resolve1

需要注意的是，直接打印promise1，会打印出它的状态值和参数。

代码执行过程如下：

1. script是一个宏任务，按照顺序执行这些代码； 2. 首先进入Promise，执行该构造函数中的代码，打印 `promise1`； 3. 碰到 `resolve`函数, 将 `promise1`的状态改变为 `resolved`, 并将结果保存下来； 4. 碰到 `promise1.then`这个微任务，将它放入微任务队列； 5. `promise2`是一个新的状态为 `pending`的 `Promise`； 6. 执行同步代码1， 同时打印出 `promise1`的状态是 `resolved`； 7. 执行同步代码2，同时打印出 `promise2`的状态是 `pending`； 8. 宏任务执行完毕，查找微任务队列，发现 `promise1.then`这个微任务且状态为 `resolved`，执行它。

 3. 代码输出结果

const promise = new Promise((resolve, reject) => {

  console.log(1);

  setTimeout(() => {

    console.log("timerStart");

    resolve("success");

    console.log("timerEnd");

  }, 0);

  console.log(2);

});

promise.then((res) => {

  console.log(res);

});

console.log(4);

```

输出结果如下：

```

1

2

4

timerStart

timerEnd

success

代码执行过程如下：

- 首先遇到Promise构造函数，会先执行里面的内容，打印 1； - 遇到定时器 `steTimeout`，它是一个宏任务，放入宏任务队列； - 继续向下执行，打印出2； - 由于 `Promise`的状态此时还是 `pending`，所以 `promise.then`先不执行； - 继续执行下面的同步任务，打印出4； - 此时微任务队列没有任务，继续执行下一轮宏任务，执行 `steTimeout`； - 首先执行 `timerStart`，然后遇到了 `resolve`，将 `promise`的状态改为 `resolved`且保存结果并将之前的 `promise.then`推入微任务队列，再执行 `timerEnd`； - 执行完这个宏任务，就去执行微任务 `promise.then`，打印出 `resolve`的结果。

 4. 代码输出结果

Promise.resolve().then(() => {

  console.log('promise1');

  const timer2 = setTimeout(() => {

    console.log('timer2')

  }, 0)

});

const timer1 = setTimeout(() => {

  console.log('timer1')

  Promise.resolve().then(() => {

    console.log('promise2')

  })

}, 0)

console.log('start');

输出结果如下：

start

promise1

timer1

promise2

timer2

代码执行过程如下：

1. 首先，`Promise.resolve().then`是一个微任务，加入微任务队列 2. 执行timer1，它是一个宏任务，加入宏任务队列 3. 继续执行下面的同步代码，打印出 `start` 4. 这样第一轮宏任务就执行完了，开始执行微任务 `Promise.resolve().then`，打印出 `promise1` 5. 遇到 `timer2`，它是一个宏任务，将其加入宏任务队列，此时宏任务队列有两个任务，分别是 `timer1`、`timer2`； 6. 这样第一轮微任务就执行完了，开始执行第二轮宏任务，首先执行定时器 `timer1`，打印 `timer1`； 7. 遇到 `Promise.resolve().then`，它是一个微任务，加入微任务队列 8. 开始执行微任务队列中的任务，打印 `promise2`； 9. 最后执行宏任务 `timer2`定时器，打印出 `timer2`；

 5. 代码输出结果

const promise = new Promise((resolve, reject) => {

    resolve('success1');

    reject('error');

    resolve('success2');

});

promise.then((res) => {

    console.log('then:', res);

}).catch((err) => {

    console.log('catch:', err);

})

输出结果如下：

then：success1

这个题目考察的就是**Promise的状态在发生变化之后，就不会再发生变化**。开始状态由 `pending`变为 `resolve`，说明已经变为已完成状态，下面的两个状态的就不会再执行，同时下面的catch也不会捕获到错误。

 6. 代码输出结果

Promise.resolve(1)

  .then(2)

  .then(Promise.resolve(3))

  .then(console.log)

输出结果如下：

1

Promise {: undefined}

Promise.resolve方法的参数如果是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的Promise对象，状态为resolved，Promise.resolve方法的参数，会同时传给回调函数。

then方法接受的参数是函数，而如果传递的并非是一个函数，它实际上会将其解释为then(null)，这就会导致前一个Promise的结果会传递下面。

 7. 代码输出结果

const promise1 = new Promise((resolve, reject) => {

  setTimeout(() => {

    resolve('success')

  }, 1000)

})

const promise2 = promise1.then(() => {

  throw new Error('error!!!')

})

console.log('promise1', promise1)

console.log('promise2', promise2)

setTimeout(() => {

  console.log('promise1', promise1)

  console.log('promise2', promise2)

}, 2000)

输出结果如下：

promise1 Promise {}

promise2 Promise {}

Uncaught (in promise) Error: error!!!

promise1 Promise {: "success"}

promise2 Promise {: Error: error!!}

 8. 代码输出结果

Promise.resolve(1)

  .then(res => {

    console.log(res);

    return 2;

  })

  .catch(err => {

    return 3;

  })

  .then(res => {

    console.log(res);

  });

输出结果如下：

1   

2

Promise是可以链式调用的，由于每次调用 `.then` 或者 `.catch` 都会返回一个新的 promise，从而实现了链式调用, 它并不像一般任务的链式调用一样return this。

上面的输出结果之所以依次打印出1和2，是因为 `resolve(1)`之后走的是第一个then方法，并没有进catch里，所以第二个then中的res得到的实际上是第一个then的返回值。并且return 2会被包装成 `resolve(2)`，被最后的then打印输出2。

 9. 代码输出结果

Promise.resolve().then(() => {

  return new Error('error!!!')

}).then(res => {

  console.log("then: ", res)

}).catch(err => {

  console.log("catch: ", err)

})

输出结果如下：

"then: " "Error: error!!!"

返回任意一个非 promise 的值都会被包裹成 promise 对象，因此这里的 `return new Error('error!!!')`也被包裹成了 `return Promise.resolve(new Error('error!!!'))`，因此它会被then捕获而不是catch。

 10. 代码输出结果

const promise = Promise.resolve().then(() => {

  return promise;

})

promise.catch(console.err)

输出结果如下：

Uncaught (in promise) TypeError: Chaining cycle detected for promise #

这里其实是一个坑，`.then` 或 `.catch` 返回的值不能是 promise 本身，否则会造成死循环。

 11. 代码输出结果

Promise.resolve(1)

  .then(2)

  .then(Promise.resolve(3))

  .then(console.log)

输出结果如下：

1

看到这个题目，好多的then，实际上只需要记住一个原则：`.then` 或 `.catch` 的参数期望是函数，传入非函数则会发生**值透传**。

第一个then和第二个then中传入的都不是函数，一个是数字，一个是对象，因此发生了透传，将 `resolve(1)` 的值直接传到最后一个then里，直接打印出1。

 12. 代码输出结果

Promise.reject('err!!!')

  .then((res) => {

    console.log('success', res)

  }, (err) => {

    console.log('error', err)

  }).catch(err => {

    console.log('catch', err)

  })

输出结果如下：

error err!!!

我们知道，`.then`函数中的两个参数：

- 第一个参数是用来处理Promise成功的函数 - 第二个则是处理失败的函数

也就是说 `Promise.resolve('1')`的值会进入成功的函数，`Promise.reject('2')`的值会进入失败的函数。

在这道题中，错误直接被 `then`的第二个参数捕获了，所以就不会被 `catch`捕获了，输出结果为：`error err!!!'`

但是，如果是像下面这样：

Promise.resolve()

  .then(function success (res) {

    throw new Error('error!!!')

  }, function fail1 (err) {

    console.log('fail1', err)

  }).catch(function fail2 (err) {

    console.log('fail2', err)

  })

在 `then`的第一参数中抛出了错误，那么他就不会被第二个参数不活了，而是被后面的 `catch`捕获到。

 13. 代码输出结果

Promise.resolve('1')

  .then(res => {

    console.log(res)

  })

  .finally(() => {

    console.log('finally')

  })

Promise.resolve('2')

  .finally(() => {

    console.log('finally2')

    return '我是finally2返回的值'

  })

  .then(res => {

    console.log('finally2后面的then函数', res)

  })

输出结果如下：

1

finally2

finally

finally2后面的then函数 2

`.finally()`一般用的很少，只要记住以下几点就可以了：

- `.finally()`方法不管Promise对象最后的状态如何都会执行 - `.finally()`方法的回调函数不接受任何的参数，也就是说你在 `.finally()`函数中是无法知道Promise最终的状态是 `resolved`还是 `rejected`的 - 它最终返回的默认会是一个上一次的Promise对象值，不过如果抛出的是一个异常则返回异常的Promise对象。 - finally本质上是then方法的特例

`.finally()`的错误捕获：

Promise.resolve('1')

  .finally(() => {

    console.log('finally1')

    throw new Error('我是finally中抛出的异常')

  })

  .then(res => {

    console.log('finally后面的then函数', res)

  })

  .catch(err => {

    console.log('捕获错误', err)

  })

输出结果为：

'finally1'

'捕获错误' Error: 我是finally中抛出的异常

 14. 代码输出结果

function runAsync (x) {

    const p = new Promise(r => setTimeout(() => r(x, console.log(x)), 1000))

    return p

}

Promise.all([runAsync(1), runAsync(2), runAsync(3)]).then(res => console.log(res))

输出结果如下：

1

2

3

[1, 2, 3]

首先，定义了一个Promise，来异步执行函数runAsync，该函数传入一个值x，然后间隔一秒后打印出这个x。

之后再使用 `Promise.all`来执行这个函数，执行的时候，看到一秒之后输出了1，2，3，同时输出了数组[1, 2, 3]，三个函数是同步执行的，并且在一个回调函数中返回了所有的结果。并且结果和函数的执行顺序是一致的。

 15. 代码输出结果

function runAsync (x) {

  const p = new Promise(r => setTimeout(() => r(x, console.log(x)), 1000))

  return p

}

function runReject (x) {

  const p = new Promise((res, rej) => setTimeout(() => rej(`Error: ${x}`, console.log(x)), 1000 * x))

  return p

}

Promise.all([runAsync(1), runReject(4), runAsync(3), runReject(2)])

       .then(res => console.log(res))

       .catch(err => console.log(err))

输出结果如下：

可以看到。catch捕获到了第一个错误，在这道题目中最先的错误就是 `runReject(2)`的结果。如果一组异步操作中有一个异常都不会进入 `.then()`的第一个回调函数参数中。会被 `.then()`的第二个回调函数捕获。

 16. 代码输出结果

function runAsync (x) {

  const p = new Promise(r => setTimeout(() => r(x, console.log(x)), 1000))

  return p

}

Promise.race([runAsync(1), runAsync(2), runAsync(3)])

  .then(res => console.log('result: ', res))

  .catch(err => console.log(err))

输出结果如下：

then只会捕获第一个成功的方法，其他的函数虽然还会继续执行，但是不是被then捕获了。

 17. 代码输出结果

function runAsync(x) {

  const p = new Promise(r =>

    setTimeout(() => r(x, console.log(x)), 1000)

  );

  return p;

}

function runReject(x) {

  const p = new Promise((res, rej) =>

    setTimeout(() => rej(`Error: ${x}`, console.log(x)), 1000 * x)

  );

  return p;

}

Promise.race([runReject(0), runAsync(1), runAsync(2), runAsync(3)])

  .then(res => console.log("result: ", res))

  .catch(err => console.log(err));

输出结果如下：

0

Error: 0

1

2

3

可以看到在catch捕获到第一个错误之后，后面的代码还不执行，不过不会再被捕获了。

注意：`all`和 `race`传入的数组中如果有会抛出异常的异步任务，那么只有最先抛出的错误会被捕获，并且是被then的第二个参数或者后面的catch捕获；但并不会影响数组中其它的异步任务的执行。

 18. 代码输出结果

async function async1() {

  console.log("async1 start");

  await async2();

  console.log("async1 end");

}

async function async2() {

  console.log("async2");

}

async1();

console.log('start')

输出结果如下：

async1 start

async2

start

async1 end

代码的执行过程如下：

1. 首先执行函数中的同步代码 `async1 start`，之后遇到了 `await`，它会阻塞 `async1`后面代码的执行，因此会先去执行 `async2`中的同步代码 `async2`，然后跳出 `async1`； 2. 跳出 `async1`函数后，执行同步代码 `start`； 3. 在一轮宏任务全部执行完之后，再来执行 `await`后面的内容 `async1 end`。

这里可以理解为await后面的语句相当于放到了new Promise中，下一行及之后的语句相当于放在Promise.then中。

 19. 代码输出结果

async function async1() {

  console.log("async1 start");

  await async2();

  console.log("async1 end");

  setTimeout(() => {

    console.log('timer1')

  }, 0)

}

async function async2() {

  setTimeout(() => {

    console.log('timer2')

  }, 0)

  console.log("async2");

}

async1();

setTimeout(() => {

  console.log('timer3')

}, 0)

console.log("start")

输出结果如下：

async1 start

async2

start

async1 end

timer2

timer3

timer1

代码的执行过程如下：

1. 首先进入 `async1`，打印出 `async1 start`； 2. 之后遇到 `async2`，进入 `async2`，遇到定时器 `timer2`，加入宏任务队列，之后打印 `async2`； 3. 由于 `async2`阻塞了后面代码的执行，所以执行后面的定时器 `timer3`，将其加入宏任务队列，之后打印 `start`； 4. 然后执行`async2`后面的代码，打印出 `async1 end`，遇到定时器`timer1`，将其加入宏任务队列； 5. 最后，宏任务队列有三个任务，先后顺序为 `timer2`，`timer3`，`timer1`，没有微任务，所以直接所有的宏任务按照先进先出的原则执行。

 20. 代码输出结果

async function async1 () {

  console.log('async1 start');

  await new Promise(resolve => {

    console.log('promise1')

  })

  console.log('async1 success');

  return 'async1 end'

}

console.log('srcipt start')

async1().then(res => console.log(res))

console.log('srcipt end')

输出结果如下：

script start

async1 start

promise1

script end

这里需要注意的是在 `async1`中 `await`后面的Promise是没有返回值的，也就是它的状态始终是 `pending`状态，所以在 `await`之后的内容是不会执行的，包括 `async1`后面的 `.then`。

 21. 代码输出结果

async function async1 () {

  console.log('async1 start');

  await new Promise(resolve => {

    console.log('promise1')

    resolve('promise1 resolve')

  }).then(res => console.log(res))

  console.log('async1 success');

  return 'async1 end'

}

console.log('srcipt start')

async1().then(res => console.log(res))

console.log('srcipt end')

这里是对上面一题进行了改造，加上了resolve。

输出结果如下：

script start

async1 start

promise1

script end

promise1 resolve

async1 success

async1 end

22. 代码输出结果

async function async1() {

  console.log("async1 start");

  await async2();

  console.log("async1 end");

}

async function async2() {

  console.log("async2");

}

console.log("script start");

setTimeout(function() {

  console.log("setTimeout");

}, 0);

async1();

new Promise(resolve => {

  console.log("promise1");

  resolve();

}).then(function() {

  console.log("promise2");

});

console.log('script end')

输出结果如下：

script start

async1 start

async2

promise1

script end

async1 end

promise2

setTimeout

代码执行过程如下：

1. 开头定义了async1和async2两个函数，但是并未执行，执行script中的代码，所以打印出script start； 2. 遇到定时器Settimeout，它是一个宏任务，将其加入到宏任务队列； 3. 之后执行函数async1，首先打印出async1 start； 4. 遇到await，执行async2，打印出async2，并阻断后面代码的执行，将后面的代码加入到微任务队列； 5. 然后跳出async1和async2，遇到Promise，打印出promise1； 6. 遇到resolve，将其加入到微任务队列，然后执行后面的script代码，打印出script end； 7. 之后就该执行微任务队列了，首先打印出async1 end，然后打印出promise2； 8. 执行完微任务队列，就开始执行宏任务队列中的定时器，打印出setTimeout。

 23. 代码输出结果

async function async1 () {

  await async2();

  console.log('async1');

  return 'async1 success'

}

async function async2 () {

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

    console.log('async2')

    reject('error')

  })

}

async1().then(res => console.log(res))

输出结果如下：

async2

Uncaught (in promise) error

可以看到，如果async函数中抛出了错误，就会终止错误结果，不会继续向下执行。

如果想要让错误不足之处后面的代码执行，可以使用catch来捕获：

async function async1 () {

  await Promise.reject('error!!!').catch(e => console.log(e))

  console.log('async1');

  return Promise.resolve('async1 success')

}

async1().then(res => console.log(res))

console.log('script start')

这样的输出结果就是：

script start

error!!!

async1

async1 success

 24. 代码输出结果

const first = () => (new Promise((resolve, reject) => {

    console.log(3);

    let p = new Promise((resolve, reject) => {

        console.log(7);

        setTimeout(() => {

            console.log(5);

            resolve(6);

            console.log(p)

        }, 0)

        resolve(1);

    });

    resolve(2);

    p.then((arg) => {

        console.log(arg);

    });

}));

first().then((arg) => {

    console.log(arg);

});

console.log(4);

输出结果如下：

3

7

4

1

2

5

Promise{: 1}

代码的执行过程如下：

1. 首先会进入Promise，打印出3，之后进入下面的Promise，打印出7； 2. 遇到了定时器，将其加入宏任务队列； 3. 执行Promise p中的resolve，状态变为resolved，返回值为1； 4. 执行Promise first中的resolve，状态变为resolved，返回值为2； 5. 遇到p.then，将其加入微任务队列，遇到first().then，将其加入任务队列； 6. 执行外面的代码，打印出4； 7. 这样第一轮宏任务就执行完了，开始执行微任务队列中的任务，先后打印出1和2； 8. 这样微任务就执行完了，开始执行下一轮宏任务，宏任务队列中有一个定时器，执行它，打印出5，由于执行已经变为resolved状态，所以 `resolve(6)`不会再执行； 9. 最后 `console.log(p)`打印出 `Promise{: 1}`；

 25. 代码输出结果

const async1 = async () => {

  console.log('async1');

  setTimeout(() => {

    console.log('timer1')

  }, 2000)

  await new Promise(resolve => {

    console.log('promise1')

  })

  console.log('async1 end')

  return 'async1 success'

} 

console.log('script start');

async1().then(res => console.log(res));

console.log('script end');

Promise.resolve(1)

  .then(2)

  .then(Promise.resolve(3))

  .catch(4)

  .then(res => console.log(res))

setTimeout(() => {

  console.log('timer2')

}, 1000)

输出结果如下：

script start

async1

promise1

script end

1

timer2

timer1

代码的执行过程如下：

1. 首先执行同步带吗，打印出script start； 2. 遇到定时器timer1将其加入宏任务队列； 3. 之后是执行Promise，打印出promise1，由于Promise没有返回值，所以后面的代码不会执行； 4. 然后执行同步代码，打印出script end； 5. 继续执行下面的Promise，.then和.catch期望参数是一个函数，这里传入的是一个数字，因此就会发生值渗透，将resolve(1)的值传到最后一个then，直接打印出1； 6. 遇到第二个定时器，将其加入到微任务队列，执行微任务队列，按顺序依次执行两个定时器，但是由于定时器时间的原因，会在两秒后先打印出timer2，在四秒后打印出timer1。

 26. 代码输出结果

const p1 = new Promise((resolve) => {

  setTimeout(() => {

    resolve('resolve3');

    console.log('timer1')

  }, 0)

  resolve('resovle1');

  resolve('resolve2');

}).then(res => {

  console.log(res)  // resolve1

  setTimeout(() => {

    console.log(p1)

  }, 1000)

}).finally(res => {

  console.log('finally', res)

})

执行结果为如下：

resolve1

finally  undefined

timer1

Promise{: undefined}

 27. 代码输出结果

console.log('1');

setTimeout(function() {

    console.log('2');

    process.nextTick(function() {

        console.log('3');

    })

    new Promise(function(resolve) {

        console.log('4');

        resolve();

    }).then(function() {

        console.log('5')

    })

})

process.nextTick(function() {

    console.log('6');

})

new Promise(function(resolve) {

    console.log('7');

    resolve();

}).then(function() {

    console.log('8')

})

setTimeout(function() {

    console.log('9');

    process.nextTick(function() {

        console.log('10');

    })

    new Promise(function(resolve) {

        console.log('11');

        resolve();

    }).then(function() {

        console.log('12')

    })

})

输出结果如下：

1

7

6

8

2

4

3

5

9

11

10

12

**（1）第一轮事件循环流程分析如下：**

- 整体script作为第一个宏任务进入主线程，遇到 `console.log`，输出1。 - 遇到 `setTimeout`，其回调函数被分发到宏任务Event Queue中。暂且记为 `setTimeout1`。 - 遇到 `process.nextTick()`，其回调函数被分发到微任务Event Queue中。记为 `process1`。 - 遇到 `Promise`，`new Promise`直接执行，输出7。`then`被分发到微任务Event Queue中。记为 `then1`。 - 又遇到了 `setTimeout`，其回调函数被分发到宏任务Event Queue中，记为 `setTimeout2`。

| 宏任务Event Queue | 微任务Event Queue | | -------------- | -------------- | | setTimeout1    | process1       | | setTimeout2    | then1          |

上表是第一轮事件循环宏任务结束时各Event Queue的情况，此时已经输出了1和7。发现了 `process1`和 `then1`两个微任务：

- 执行 `process1`，输出6。 - 执行 `then1`，输出8。

第一轮事件循环正式结束，这一轮的结果是输出1，7，6，8。

**（2）第二轮时间循环从** `setTimeout1`**宏任务开始：**

- 首先输出2。接下来遇到了 `process.nextTick()`，同样将其分发到微任务Event Queue中，记为 `process2`。 - `new Promise`立即执行输出4，`then`也分发到微任务Event Queue中，记为 `then2`。

| 宏任务Event Queue | 微任务Event Queue | | -------------- | -------------- | | setTimeout2    | process2       | |                | then2          |

第二轮事件循环宏任务结束，发现有 `process2`和 `then2`两个微任务可以执行：

- 输出3。 - 输出5。

第二轮事件循环结束，第二轮输出2，4，3，5。

**（3）第三轮事件循环开始，此时只剩setTimeout2了，执行。**

- 直接输出9。 - 将 `process.nextTick()`分发到微任务Event Queue中。记为 `process3`。 - 直接执行 `new Promise`，输出11。 - 将 `then`分发到微任务Event Queue中，记为 `then3`。

| 宏任务Event Queue | 微任务Event Queue | | -------------- | -------------- | |                | process3       | |                | then3          |

第三轮事件循环宏任务执行结束，执行两个微任务 `process3`和 `then3`：

- 输出10。 - 输出12。

第三轮事件循环结束，第三轮输出9，11，10，12。

整段代码，共进行了三次事件循环，完整的输出为1，7，6，8，2，4，3，5，9，11，10，12。 28. 代码输出结果

console.log(1)

setTimeout(() => {

  console.log(2)

})

new Promise(resolve =>  {

  console.log(3)

  resolve(4)

}).then(d => console.log(d))

setTimeout(() => {

  console.log(5)

  new Promise(resolve =>  {

    resolve(6)

  }).then(d => console.log(d))

})

setTimeout(() => {

  console.log(7)

})

console.log(8)

输出结果如下：

1

3

8

4

2

5

6

7

代码执行过程如下：

1. 首先执行script代码，打印出1； 2. 遇到第一个定时器，加入到宏任务队列； 3. 遇到Promise，执行代码，打印出3，遇到resolve，将其加入到微任务队列； 4. 遇到第二个定时器，加入到宏任务队列； 5. 遇到第三个定时器，加入到宏任务队列； 6. 继续执行script代码，打印出8，第一轮执行结束； 7. 执行微任务队列，打印出第一个Promise的resolve结果：4； 8. 开始执行宏任务队列，执行第一个定时器，打印出2； 9. 此时没有微任务，继续执行宏任务中的第二个定时器，首先打印出5，遇到Promise，首选打印出6，遇到resolve，将其加入到微任务队列； 10. 执行微任务队列，打印出6； 11. 执行宏任务队列中的最后一个定时器，打印出7。 29. 代码输出结果

console.log(1);

  

setTimeout(() => {

  console.log(2);

  Promise.resolve().then(() => {

    console.log(3)

  });

});

new Promise((resolve, reject) => {

  console.log(4)

  resolve(5)

}).then((data) => {

  console.log(data);

})

setTimeout(() => {

  console.log(6);

})

console.log(7);

代码输出结果如下：

1

4

7

5

2

3

6

代码执行过程如下：

1. 首先执行scrip代码，打印出1； 2. 遇到第一个定时器setTimeout，将其加入到宏任务队列； 3. 遇到Promise，执行里面的同步代码，打印出4，遇到resolve，将其加入到微任务队列； 4. 遇到第二个定时器setTimeout，将其加入到红任务队列； 5. 执行script代码，打印出7，至此第一轮执行完成； 6. 指定微任务队列中的代码，打印出resolve的结果：5； 7. 执行宏任务中的第一个定时器setTimeout，首先打印出2，然后遇到 Promise.resolve().then()，将其加入到微任务队列； 8. 执行完这个宏任务，就开始执行微任务队列，打印出3； 9. 继续执行宏任务队列中的第二个定时器，打印出6。

 30. 代码输出结果

Promise.resolve().then(() => {

    console.log('1');

    throw 'Error';

}).then(() => {

    console.log('2');

}).catch(() => {

    console.log('3');

    throw 'Error';

}).then(() => {

    console.log('4');

}).catch(() => {

    console.log('5');

}).then(() => {

    console.log('6');

});

执行结果如下：

1 

3 

5 

6

在这道题目中，我们需要知道，无论是thne还是catch中，只要throw 抛出了错误，就会被catch捕获，如果没有throw出错误，就被继续执行后面的then。 31. 代码输出结果

setTimeout(function () {

  console.log(1);

}, 100);

new Promise(function (resolve) {

  console.log(2);

  resolve();

  console.log(3);

}).then(function () {

  console.log(4);

  new Promise((resove, reject) => {

    console.log(5);

    setTimeout(() =>  {

      console.log(6);

    }, 10);

  })

});

console.log(7);

console.log(8);

输出结果为：

2

3

7

8

4

5

6

1

代码执行过程如下：

1. 首先遇到定时器，将其加入到宏任务队列； 2. 遇到Promise，首先执行里面的同步代码，打印出2，遇到resolve，将其加入到微任务队列，执行后面同步代码，打印出3； 3. 继续执行script中的代码，打印出7和8，至此第一轮代码执行完成； 4. 执行微任务队列中的代码，首先打印出4，如遇到Promise，执行其中的同步代码，打印出5，遇到定时器，将其加入到宏任务队列中，此时宏任务队列中有两个定时器； 5. 执行宏任务队列中的代码，这里我们需要注意是的第一个定时器的时间为100ms，第二个定时器的时间为10ms，所以先执行第二个定时器，打印出6； 6. 此时微任务队列为空，继续执行宏任务队列，打印出1。

做完这道题目，我们就需要格外注意，每个定时器的时间，并不是所有定时器的时间都为0哦。

二、this

 1. 代码输出结果

function foo() {

  console.log( this.a );

}

function doFoo() {

  foo();

}

var obj = {

  a: 1,

  doFoo: doFoo

};

var a = 2; 

obj.doFoo()

输出结果：2

在Javascript中，this指向函数执行时的当前对象。在执行foo的时候，执行环境就是doFoo函数，执行环境为全局。所以，foo中的this是指向window的，所以会打印出2。 2. 代码输出结果

var a = 10

var obj = {

  a: 20,

  say: () => {

    console.log(this.a)

  }

}

obj.say() 

var anotherObj = { a: 30 } 

obj.say.apply(anotherObj) 

输出结果：10 10

我么知道，箭头函数时不绑定this的，它的this来自原其父级所处的上下文，所以首先会打印全局中的 a 的值10。后面虽然让say方法指向了另外一个对象，但是仍不能改变箭头函数的特性，它的this仍然是指向全局的，所以依旧会输出10。

但是，如果是普通函数，那么就会有完全不一样的结果：

var a = 10  

var obj = {  

  a: 20,  

  say(){

    console.log(this.a)  

  }  

}  

obj.say()   

var anotherObj={a:30}   

obj.say.apply(anotherObj)

输出结果：20 30

这时，say方法中的this就会指向他所在的对象，输出其中的a的值。

 3. 代码输出结果

function a() {

  console.log(this);

}

a.call(null);

打印结果：window对象

根据ECMAScript262规范规定：如果第一个参数传入的对象调用者是null或者undefined，call方法将把全局对象（浏览器上是window对象）作为this的值。所以，不管传入null 还是 undefined，其this都是全局对象window。所以，在浏览器上答案是输出 window 对象。要注意的是，在严格模式中，null 就是 null，undefined 就是 undefined：

'use strict';

function a() {

    console.log(this);

}

a.call(null); // null

a.call(undefined); // undefined

 4. 代码输出结果

var obj = { 

  name: 'cuggz', 

  fun: function(){ 

     console.log(this.name); 

  } 

} 

obj.fun()     // cuggz

new obj.fun() // undefined

 5. 代码输出结果

var obj = {

   say: function() {

     var f1 = () =>  {

       console.log("1111", this);

     }

     f1();

   },

   pro: {

     getPro:() =>  {

        console.log(this);

     }

   }

}

var o = obj.say;

o();

obj.say();

obj.pro.getPro();

输出结果：

1111 window对象

1111 obj对象

window对象

**解析：**

1. o()，o是在全局执行的，而f1是箭头函数，它是没有绑定this的，它的this指向其父级的this，其父级say方法的this指向的是全局作用域，所以会打印出window； 2. obj.say()，谁调用say，say 的this就指向谁，所以此时this指向的是obj对象； 3. obj.pro.getPro()，我们知道，箭头函数时不绑定this的，getPro处于pro中，而对象不构成单独的作用域，所以箭头的函数的this就指向了全局作用域window。

 6. 代码输出结果

var myObject = {

    foo: "bar",

    func: function() {

        var self = this;

        console.log(this.foo);  

        console.log(self.foo);  

        (function() {

            console.log(this.foo);  

            console.log(self.foo);  

        }());

    }

};

myObject.func();

输出结果：bar bar undefined bar

**解析：**

1. 首先func是由myObject调用的，this指向myObject。又因为var self = this;所以self指向myObject。 2. 这个立即执行匿名函数表达式是由window调用的，this指向window 。立即执行匿名函数的作用域处于myObject.func的作用域中，在这个作用域找不到self变量，沿着作用域链向上查找self变量，找到了指向 myObject对象的self。

 7. 代码输出问题

window.number = 2;

var obj = {

 number: 3,

 db1: (function(){

   console.log(this);

   this.number *= 4;

   return function(){

     console.log(this);

     this.number *= 5;

   }

 })()

}

var db1 = obj.db1;

db1();

obj.db1();

console.log(obj.number);     // 15

console.log(window.number);  // 40

这道题目看清起来有点乱，但是实际上是考察this指向的:

1. 执行db1()时，this指向全局作用域，所以window.number * 4 = 8，然后执行匿名函数， 所以window.number * 5 = 40； 2. 执行obj.db1();时，this指向obj对象，执行匿名函数，所以obj.numer * 5 = 15。

 8. 代码输出结果

var length = 10;

function fn() {

    console.log(this.length);

}

 

var obj = {

  length: 5,

  method: function(fn) {

    fn();

    arguments[0]();

  }

};

 

obj.method(fn, 1);

输出结果： 10 2

**解析：**

1. 第一次执行fn()，this指向window对象，输出10。 2. 第二次执行arguments0，相当于arguments调用方法，this指向arguments，而这里传了两个参数，故输出arguments长度为2。 9. 代码输出结果

var a = 1;

function printA(){

  console.log(this.a);

}

var obj={

  a:2,

  foo:printA,

  bar:function(){

    printA();

  }

}

obj.foo(); // 2

obj.bar(); // 1

var foo = obj.foo;

foo(); // 1

输出结果： 2 1 1

**解析：**

1. obj.foo()，foo 的this指向obj对象，所以a会输出2； 2. obj.bar()，printA在bar方法中执行，所以此时printA的this指向的是window，所以会输出1； 3. foo()，foo是在全局对象中执行的，所以其this指向的是window，所以会输出1；

 10. 代码输出结果

var x = 3;

var y = 4;

var obj = {

    x: 1,

    y: 6,

    getX: function() {

        var x = 5;

        return function() {

            return this.x;

        }();

    },

    getY: function() {

        var y = 7;

        return this.y;

    }

}

console.log(obj.getX()) // 3

console.log(obj.getY()) // 6

输出结果：3 6

**解析：**

1. 我们知道，匿名函数的this是指向全局对象的，所以this指向window，会打印出3； 2. getY是由obj调用的，所以其this指向的是obj对象，会打印出6。

 11. 代码输出结果

 var a = 10; 

 var obt = { 

   a: 20, 

   fn: function(){ 

     var a = 30; 

     console.log(this.a)

   } 

 }

 obt.fn();  // 20

 obt.fn.call(); // 10

 (obt.fn)(); // 20

输出结果： 20 10 20

**解析：**

1. obt.fn()，fn是由obt调用的，所以其this指向obt对象，会打印出20； 2. obt.fn.call()，这里call的参数啥都没写，就表示null，我们知道如果call的参数为undefined或null，那么this就会指向全局对象this，所以会打印出 10； 3. (obt.fn)()， 这里给表达式加了括号，而括号的作用是改变表达式的运算顺序，而在这里加与不加括号并无影响；相当于 obt.fn()，所以会打印出 20； 12. 代码输出结果

function a(xx){

  this.x = xx;

  return this

};

var x = a(5);

var y = a(6);

console.log(x.x)  // undefined

console.log(y.x)  // 6

输出结果： undefined 6

**解析：**

1. 最关键的就是var x = a(5)，函数a是在全局作用域调用，所以函数内部的this指向window对象。**所以 this.x = 5 就相当于：window.x = 5。**之后 return this，也就是说 var x = a(5) 中的x变量的值是window，这里的x将函数内部的x的值覆盖了。然后执行console.log(x.x)， 也就是console.log(window.x)，而window对象中没有x属性，所以会输出undefined。 2. 当指向y.x时，会给全局变量中的x赋值为6，所以会打印出6。 13. 代码输出结果

function foo(something){

    this.a = something

}

var obj1 = {

    foo: foo

}

var obj2 = {}

obj1.foo(2); 

console.log(obj1.a); // 2

obj1.foo.call(obj2, 3);

console.log(obj2.a); // 3

var bar = new obj1.foo(4)

console.log(obj1.a); // 2

console.log(bar.a); // 4

输出结果： 2 3 2 4

**解析：**

1. 首先执行obj1.foo(2); 会在obj中添加a属性，其值为2。之后执行obj1.a，a是右obj1调用的，所以this指向obj，打印出2； 2. 执行 obj1.foo.call(obj2, 3) 时，会将foo的this指向obj2，后面就和上面一样了，所以会打印出3； 3. obj1.a会打印出2； 4. 最后就是考察this绑定的优先级了，new 绑定是比隐式绑定优先级高，所以会输出4。 14. 代码输出结果

function foo(something){

    this.a = something

}

var obj1 = {}

var bar = foo.bind(obj1);

bar(2);

console.log(obj1.a); // 2

var baz = new bar(3);

console.log(obj1.a); // 2

console.log(baz.a); // 3

输出结果： 2 2 3

这道题目和上面题目差不多，主要都是考察this绑定的优先级。记住以下结论即可：**this绑定的优先级：****new绑定 > 显式绑定 > 隐式绑定 > 默认绑定。**

 三、作用域&变量提升&闭包

 1. 代码输出结果

(function(){

   var x = y = 1;

})();

var z;

console.log(y); // 1

console.log(z); // undefined

console.log(x); // Uncaught ReferenceError: x is not defined

这段代码的关键在于：var x = y = 1; 实际上这里是从右往左执行的，首先执行y = 1, 因为y没有使用var声明，所以它是一个全局变量，然后第二步是将y赋值给x，讲一个全局变量赋值给了一个局部变量，最终，x是一个局部变量，y是一个全局变量，所以打印x是报错。

 2. 代码输出结果

var a, b

(function () {

   console.log(a);

   console.log(b);

   var a = (b = 3);

   console.log(a);

   console.log(b);   

})()

console.log(a);

console.log(b);

输出结果：

undefined 

undefined 

3 

3 

undefined 

3

这个题目和上面题目考察的知识点类似，b赋值为3，b此时是一个全局变量，而将3赋值给a，a是一个局部变量，所以最后打印的时候，a仍旧是undefined。

 3. 代码输出结果

var friendName = 'World';

(function() {

  if (typeof friendName === 'undefined') {

    var friendName = 'Jack';

    console.log('Goodbye ' + friendName);

  } else {

    console.log('Hello ' + friendName);

  }

})();

输出结果：Goodbye Jack

我们知道，在 JavaScript中， Function 和 var 都会被提升（变量提升），所以上面的代码就相当于：

var friendName = 'World';

(function() {

  if (typeof friendName === 'undefined') {

    var friendName = 'Jack';

    console.log('Goodbye ' + friendName);

  } else {

    console.log('Hello ' + friendName);

  }

})();

这样，答案就一目了然了。

 4. 代码输出结果

function fn1(){

  console.log('fn1')

}

var fn2

 

fn1()

fn2()

 

fn2 = function() {

  console.log('fn2')

}

 

fn2()

输出结果：

fn1

Uncaught TypeError: fn2 is not a function

fn2

这里也是在考察变量提升，关键在于第一个fn2()，这时fn2仍是一个undefined的变量，所以会报错fn2不是一个函数。 5. 代码输出结果

function a() {

    var temp = 10;

    function b() {

        console.log(temp); // 10

    }

    b();

}

a();

function a() {

    var temp = 10;

    b();

}

function b() {

    console.log(temp); // 报错 Uncaught ReferenceError: temp is not defined

}

a();

在上面的两段代码中，第一段是可以正常输出，这个应该没啥问题，关键在于第二段代码，它会报错Uncaught ReferenceError: temp is not defined。这时因为在b方法执行时，temp 的值为undefined。

 6. 代码输出结果

 var a=3;

 function c(){

    alert(a);

 }

 (function(){

  var a=4;

  c();

 })();

js中变量的作用域链与定义时的环境有关，与执行时无关。执行环境只会改变this、传递的参数、全局变量等

 7. 代码输出问题

function fun(n, o) {

  console.log(o)

  return {

    fun: function(m){

      return fun(m, n);

    }

  };

}

var a = fun(0);  a.fun(1);  a.fun(2);  a.fun(3);

var b = fun(0).fun(1).fun(2).fun(3);

var c = fun(0).fun(1);  c.fun(2);  c.fun(3);

输出结果：

``` undefined  0  0  0 undefined  0  1  2 undefined  0  1  1

```

这是一道关于闭包的题目，对于fun方法，调用之后返回的是一个对象。我们知道，当调用函数的时候传入的实参比函数声明时指定的形参个数要少，剩下的形参都将设置为undefined值。所以 `console.log(o);` 会输出undefined。而a就是是fun(0)返回的那个对象。也就是说，函数fun中参数 n 的值是0，而返回的那个对象中，需要一个参数n，而这个对象的作用域中没有n，它就继续沿着作用域向上一级的作用域中寻找n，最后在函数fun中找到了n，n的值是0。了解了这一点，其他运算就很简单了，以此类推。

 8. 代码输出结果

f = function() {return true;};   

g = function() {return false;};   

(function() {   

   if (g() && [] == ![]) {   

      f = function f() {return false;};   

      function g() {return true;}  //在匿名函数内部发生函数提升 因此if判断中的g()返回true  

   }   

})();   

console.log(f());

输出结果： false

这里首先定义了两个变量f和g，我们知道变量是可以重新赋值的。后面是一个匿名自执行函数，在 if 条件中调用了函数 g()，由于在匿名函数中，又重新定义了函数g，就覆盖了外部定义的变量g，所以，这里调用的是内部函数 g 方法，返回为 true。第一个条件通过，进入第二个条件。

第二个条件是[] == ![]，先看 ![] ，在 JavaScript 中，当用于布尔运算时，比如在这里，对象的非空引用被视为 true，空引用 null 则被视为 false。由于这里不是一个 null, 而是一个没有元素的数组，所以 [] 被视为 true, 而 ![] 的结果就是 false 了。当一个布尔值参与到条件运算的时候，true 会被看作 1, 而 false 会被看作 0。现在条件变成了 [] == 0 的问题了，当一个对象参与条件比较的时候，它会被求值，求值的结果是数组成为一个字符串，[] 的结果就是 ‘’ ，而 ‘’ 会被当作 0 ，所以，条件成立。

两个条件都成立，所以会执行条件中的代码， f 在定义是没有使用var，所以他是一个全局变量。因此，这里会通过闭包访问到外部的变量 f, 重新赋值，现在执行 f 函数返回值已经成为 false 了。而 g 则不会有这个问题，这里是一个函数内定义的 g，不会影响到外部的 g 函数。所以最后的结果就是 false。

 四、原型&继承

 1. 代码输出结果

function Person(name) {

    this.name = name

}

var p2 = new Person('king');

console.log(p2.__proto__) //Person.prototype

console.log(p2.__proto__.__proto__) //Object.prototype

console.log(p2.__proto__.__proto__.__proto__) // null

console.log(p2.__proto__.__proto__.__proto__.__proto__)//null后面没有了，报错

console.log(p2.__proto__.__proto__.__proto__.__proto__.__proto__)//null后面没有了，报错

console.log(p2.constructor)//Person

console.log(p2.prototype)//undefined p2是实例，没有prototype属性

console.log(Person.constructor)//Function 一个空函数

console.log(Person.prototype)//打印出Person.prototype这个对象里所有的方法和属性

console.log(Person.prototype.constructor)//Person

console.log(Person.prototype.__proto__)// Object.prototype

console.log(Person.__proto__) //Function.prototype

console.log(Function.prototype.__proto__)//Object.prototype

console.log(Function.__proto__)//Function.prototype

console.log(Object.__proto__)//Function.prototype

console.log(Object.prototype.__proto__)//null

这道义题目考察原型、原型链的基础，记住就可以了。 2. 代码输出结果

// a

function Foo () {

 getName = function () {

   console.log(1);

 }

 return this;

}

// b

Foo.getName = function () {

 console.log(2);

}

// c

Foo.prototype.getName = function () {

 console.log(3);

}

// d

var getName = function () {

 console.log(4);

}

// e

function getName () {

 console.log(5);

}

Foo.getName();           // 2

getName();               // 4

Foo().getName();         // 1

getName();               // 1 

new Foo.getName();       // 2

new Foo().getName();     // 3

new new Foo().getName(); // 3

输出结果：2 4 1 1 2 3 3

**解析：**

1. **Foo.getName()**，Foo为一个函数对象，对象都可以有属性，b 处定义Foo的getName属性为函数，输出2； 2. **getName()**，这里看d、e处，d为函数表达式，e为函数声明，两者区别在于变量提升，函数声明的 5 会被后边函数表达式的 4 覆盖； 3. **Foo().getName()**，这里要看a处，在Foo内部将全局的getName重新赋值为 console.log(1) 的函数，执行Foo()返回 this，这个this指向window，Foo().getName() 即为window.getName()，输出 1； 4. **getName()**，上面3中，全局的getName已经被重新赋值，所以这里依然输出 1； 5. **new Foo.getName()**，这里等价于 new (Foo.getName())，先执行 Foo.getName()，输出 2，然后new一个实例； 6. **new Foo().getName()**，这里等价于 (new Foo()).getName(), 先new一个Foo的实例，再执行这个实例的getName方法，但是这个实例本身没有这个方法，所以去原型链__protot__上边找，实例.protot === Foo.prototype，所以输出 3； 7. **new new Foo().getName()**，这里等价于new (new Foo().getName())，如上述6，先输出 3，然后new 一个 new Foo().getName() 的实例。

 3. 代码输出结果

var F = function() {};

Object.prototype.a = function() {

  console.log('a');

};

Function.prototype.b = function() {

  console.log('b');

}

var f = new F();

f.a();

f.b();

F.a();

F.b()

输出结果：

a

Uncaught TypeError: f.b is not a function

a

b

**解析：**

1. f 并不是 Function 的实例，因为它本来就不是构造函数，调用的是 Function 原型链上的相关属性和方法，只能访问到 Object 原型链。所以 f.a() 输出 a ，而 f.b() 就报错了。 2. F 是个构造函数，而 F 是构造函数 Function 的一个实例。因为 F instanceof Object === true，F instanceof Function === true，由此可以得出结论：F 是 Object 和 Function 两个的实例，即 F 能访问到 a， 也能访问到 b。所以 F.a() 输出 a ，F.b() 输出 b。 4. 代码输出结果

function Foo(){

    Foo.a = function(){

        console.log(1);

    }

    this.a = function(){

        console.log(2)

    }

}

Foo.prototype.a = function(){

    console.log(3);

}

Foo.a = function(){

    console.log(4);

}

Foo.a();

let obj = new Foo();

obj.a();

Foo.a();

输出结果：4 2 1

**解析：**

1. Foo.a() 这个是调用 Foo 函数的静态方法 a，虽然 Foo 中有优先级更高的属性方法 a，但 Foo 此时没有被调用，所以此时输出 Foo 的静态方法 a 的结果：4 2. let obj = new Foo(); 使用了 new 方法调用了函数，返回了函数实例对象，此时 Foo 函数内部的属性方法初始化，原型链建立。 3. obj.a() ; 调用 obj 实例上的方法 a，该实例上目前有两个 a 方法：一个是内部属性方法，另一个是原型上的方法。当这两者都存在时，首先查找 ownProperty ，如果没有才去原型链上找，所以调用实例上的 a 输出：2 4. Foo.a() ; 根据第2步可知 Foo 函数内部的属性方法已初始化，覆盖了同名的静态方法，所以输出：1

 5. 代码输出结果

function Dog() {

  this.name = 'puppy'

}

Dog.prototype.bark = () => {

  console.log('woof!woof!')

}

const dog = new Dog()

console.log(Dog.prototype.constructor === Dog && dog.constructor === Dog && dog instanceof Dog)

输出结果：true

**解析：**

因为constructor是prototype上的属性，所以dog.constructor实际上就是指向Dog.prototype.constructor；constructor属性指向构造函数。instanceof而实际检测的是类型是否在实例的原型链上。

constructor是prototype上的属性，这一点很容易被忽略掉。constructor和instanceof 的作用是不同的，感性地来说，constructor的限制比较严格，它只能严格对比对象的构造函数是不是指定的值；而instanceof比较松散，只要检测的类型在原型链上，就会返回true。

 6. 代码输出结果

var A = {n: 4399};

var B =  function(){this.n = 9999};

var C =  function(){var n = 8888};

B.prototype = A;

C.prototype = A;

var b = new B();

var c = new C();

A.n++

console.log(b.n);

console.log(c.n);

输出结果：9999 4400

**解析：**

1. console.log(b.n)，在查找b.n是首先查找 b 对象自身有没有 n 属性，如果没有会去原型（prototype）上查找，当执行var b = new B()时，函数内部this.n=9999(此时this指向 b) 返回b对象，b对象有自身的n属性，所以返回 9999。 2. console.log(c.n)，同理，当执行var c = new C()时，c对象没有自身的n属性，向上查找，找到原型 （prototype）上的 n 属性，因为 A.n++(此时对象A中的n为4400)， 所以返回4400。

 7. 代码输出问题

function A(){

}

function B(a){

　　this.a = a;

}

function C(a){

　　if(a){

this.a = a;

　　}

}

A.prototype.a = 1;

B.prototype.a = 1;

C.prototype.a = 1;

 

console.log(new A().a);

console.log(new B().a);

console.log(new C(2).a);

输出结果：1 undefined 2

**解析：**

1. console.log(new A().a)，new A()为构造函数创建的对象，本身没有a属性，所以向它的原型去找，发现原型的a属性的属性值为1，故该输出值为1； 2. console.log(new B().a)，ew B()为构造函数创建的对象，该构造函数有参数a，但该对象没有传参，故该输出值为undefined; 3. console.log(new C(2).a)，new C()为构造函数创建的对象，该构造函数有参数a，且传的实参为2，执行函数内部，发现if为真，执行this.a = 2,故属性a的值为2。 8. 代码输出问题

function Parent() {

    this.a = 1;

    this.b = [1, 2, this.a];

    this.c = { demo: 5 };

    this.show = function () {

        console.log(this.a , this.b , this.c.demo );

    }

}

function Child() {

    this.a = 2;

    this.change = function () {

        this.b.push(this.a);

        this.a = this.b.length;

        this.c.demo = this.a++;

    }

}

Child.prototype = new Parent();

var parent = new Parent();

var child1 = new Child();

var child2 = new Child();

child1.a = 11;

child2.a = 12;

parent.show();

child1.show();

child2.show();

child1.change();

child2.change();

parent.show();

child1.show();

child2.show();

输出结果：

parent.show(); // 1  [1,2,1] 5

child1.show(); // 11 [1,2,1] 5

child2.show(); // 12 [1,2,1] 5

parent.show(); // 1 [1,2,1] 5

child1.show(); // 5 [1,2,1,11,12] 5

child2.show(); // 6 [1,2,1,11,12] 5

这道题目值得审题，他涉及到的知识点很多，例如**this的指向、原型、原型链、类的继承、数据类型**等。

**解析**：

1. parent.show()，可以直接获得所需的值，没啥好说的； 2. child1.show()，`Child`的构造函数原本是指向 `Child`的，题目显式将 `Child`类的原型对象指向了 `Parent`类的一个实例，需要注意 `Child.prototype`指向的是 `Parent`的实例 `parent`，而不是指向 `Parent`这个类。 3. child2.show()，这个也没啥好说的； 4. parent.show()，`parent`是一个 `Parent`类的实例，`Child.prorotype`指向的是 `Parent`类的另一个实例，两者在堆内存中互不影响，所以上述操作不影响 `parent`实例，所以输出结果不变； 5. child1.show()，`child1`执行了 `change()`方法后，发生了怎样的变化呢? 6. - this.b.push(this.a)，由于this的动态指向特性，this.b会指向 `Child.prototype`上的b数组,this.a会指向 `child1`的a属性,所以 `Child.prototype.b`变成了**[1,2,1,11]**;    - this.a = this.b.length，这条语句中 `this.a`和 `this.b`的指向与上一句一致，故结果为 `child1.a`变为4;    - this.c.demo = this.a++，由于 `child1`自身属性并没有c这个属性，所以此处的 `this.c`会指向 `Child.prototype.c`，`this.a`值为4，为原始类型，故赋值操作时会直接赋值，`Child.prototype.c.demo`的结果为4，而 `this.a`随后自增为5(4 + 1 = 5)。 7. `child2`执行了 `change()`方法, 而 `child2`和 `child1`均是 `Child`类的实例，所以他们的原型链指向同一个原型对象 `Child.prototype`,也就是同一个 `parent`实例，所以 `child2.change()`中所有影响到原型对象的语句都会影响 `child1`的最终输出结果。 8. - this.b.push(this.a)，由于this的动态指向特性，this.b会指向 `Child.prototype`上的b数组,this.a会指向 `child2`的a属性,所以 `Child.prototype.b`变成了**[1,2,1,11,12]**;    - this.a = this.b.length，这条语句中 `this.a`和 `this.b`的指向与上一句一致，故结果为 `child2.a`变为5;    - this.c.demo = this.a++，由于 `child2`自身属性并没有c这个属性，所以此处的 `this.c`会指向 `Child.prototype.c`，故执行结果为 `Child.prototype.c.demo`的值变为 `child2.a`的值5，而 `child2.a`最终自增为6(5 + 1 = 6)。 9. 代码输出结果

输出结果：true

实际上，这段代码就是在实现原型链继承，SubType继承了SuperType，本质是重写了SubType的原型对象，代之以一个新类型的实例。SubType的原型被重写了，所以instance.constructor指向的是SuperType。具体如下：

一、JavaScript 基础

 1. 手写 Object.create

思路：将传入的对象作为原型

function create(obj) {

  function F() {}

  F.prototype = obj

  return new F()

}

 2. 手写 instanceof 方法

instanceof 运算符用于判断构造函数的 prototype 属性是否出现在对象的原型链中的任何位置。

实现步骤：

1. 首先获取类型的原型 2. 然后获得对象的原型 3. 然后一直循环判断对象的原型是否等于类型的原型，直到对象原型为 null，因为原型链最终为 null具体实现：

function myInstanceof(left, right) {

  let proto = Object.getPrototypeOf(left), // 获取对象的原型

      prototype = right.prototype; // 获取构造函数的 prototype 对象

  // 判断构造函数的 prototype 对象是否在对象的原型链上

  while (true) {

    if (!proto) return false;

    if (proto === prototype) return true;

    proto = Object.getPrototypeOf(proto);

  }

}

 3. 手写 new 操作符

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

（1）首先创建了一个新的空对象

（2）设置原型，将对象的原型设置为函数的 prototype 对象。

（3）让函数的 this 指向这个对象，执行构造函数的代码（为这个新对象添加属性）

（4）判断函数的返回值类型，如果是值类型，返回创建的对象。如果是引用类型，就返回这个引用类型的对象。

function objectFactory() {

  let newObject = null;

  let constructor = Array.prototype.shift.call(arguments);

  let result = null;

  // 判断参数是否是一个函数

  if (typeof constructor !== "function") {

    console.error("type error");

    return;

  }

  // 新建一个空对象，对象的原型为构造函数的 prototype 对象

  newObject = Object.create(constructor.prototype);

  // 将 this 指向新建对象，并执行函数

  result = constructor.apply(newObject, arguments);

  // 判断返回对象

  let flag = result && (typeof result === "object" || typeof result === "function");

  // 判断返回结果

  return flag ? result : newObject;

}

// 使用方法

objectFactory(构造函数, 初始化参数);

 4. 手写 Promise

const PENDING = "pending";

const RESOLVED = "resolved";

const REJECTED = "rejected";

function MyPromise(fn) {

  // 保存初始化状态

  var self = this;

  // 初始化状态

  this.state = PENDING;

  // 用于保存 resolve 或者 rejected 传入的值

  this.value = null;

  // 用于保存 resolve 的回调函数

  this.resolvedCallbacks = [];

  // 用于保存 reject 的回调函数

  this.rejectedCallbacks = [];

  // 状态转变为 resolved 方法

  function resolve(value) {

    // 判断传入元素是否为 Promise 值，如果是，则状态改变必须等待前一个状态改变后再进行改变

    if (value instanceof MyPromise) {

      return value.then(resolve, reject);

    }

    // 保证代码的执行顺序为本轮事件循环的末尾

    setTimeout(() => {

      // 只有状态为 pending 时才能转变，

      if (self.state === PENDING) {

        // 修改状态

        self.state = RESOLVED;

        // 设置传入的值

        self.value = value;

        // 执行回调函数

        self.resolvedCallbacks.forEach(callback => {

          callback(value);

        });

      }

    }, 0);

  }

  // 状态转变为 rejected 方法

  function reject(value) {

    // 保证代码的执行顺序为本轮事件循环的末尾

    setTimeout(() => {

      // 只有状态为 pending 时才能转变

      if (self.state === PENDING) {

        // 修改状态

        self.state = REJECTED;

        // 设置传入的值

        self.value = value;

        // 执行回调函数

        self.rejectedCallbacks.forEach(callback => {

          callback(value);

        });

      }

    }, 0);

  }

  // 将两个方法传入函数执行

  try {

    fn(resolve, reject);

  } catch (e) {

    // 遇到错误时，捕获错误，执行 reject 函数

    reject(e);

  }

}

MyPromise.prototype.then = function(onResolved, onRejected) {

  // 首先判断两个参数是否为函数类型，因为这两个参数是可选参数

  onResolved =

    typeof onResolved === "function"

      ? onResolved

      : function(value) {

          return value;

        };

  onRejected =

    typeof onRejected === "function"

      ? onRejected

      : function(error) {

          throw error;

        };

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

      // 如果是等待状态，则将函数加入对应列表中

      if (this.state === PENDING) {

        this.resolvedCallbacks.push(onResolved);

        this.rejectedCallbacks.push(onRejected);

      }

      // 如果状态已经凝固，则直接执行对应状态的函数

      if (this.state === RESOLVED) {

        try{

          let res = onResolved(this.val)

          if(res instanceof MyPromsie){

            res.then(v => {

              resolve(v)

            },error => {

              reject(error)

            })

          }

        }catch(error){

          reject(error)

        }

      }

      if (this.state === REJECTED) {

        onRejected(this.value);

      }

    };

})

 5. 手写 Promise.then

`then` 方法返回一个新的 `promise` 实例，为了在 `promise` 状态发生变化时（`resolve` / `reject` 被调用时）再执行 `then` 里的函数，我们使用一个 `callbacks` 数组先把传给then的函数暂存起来，等状态改变时再调用。

**那么，怎么保证后一个** `then` **里的方法在前一个** `then`**（可能是异步）结束之后再执行呢？**

我们可以将传给 `then` 的函数和新 `promise` 的 `resolve` 一起 `push` 到前一个 `promise` 的 `callbacks` 数组中，达到承前启后的效果：

- 承前：当前一个 `promise `完成后，调用其 `resolve `变更状态，在这个 `resolve `里会依次调用 `callbacks `里的回调，这样就执行了 `then `里的方法了 - 启后：上一步中，当 `then `里的方法执行完成后，返回一个结果，如果这个结果是个简单的值，就直接调用新 `promise `的 `resolve`，让其状态变更，这又会依次调用新 `promise `的 `callbacks `数组里的方法，循环往复。如果返回的结果是个 `promise`，则需要等它完成之后再触发新 `promise `的 `resolve`，所以可以在其结果的 `then `里调用新 `promise `的 `resolve`

then(onFulfilled, onReject){

    // 保存前一个promise的this

    const self = this; 

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

      // 封装前一个promise成功时执行的函数

      let fulfilled = () => {

        try{

          const result = onFulfilled(self.value); // 承前

          return result instanceof MyPromise? result.then(resolve, reject) : resolve(result); //启后

        }catch(err){

          reject(err)

        }

      }

      // 封装前一个promise失败时执行的函数

      let rejected = () => {

        try{

          const result = onReject(self.reason);

          return result instanceof MyPromise? result.then(resolve, reject) : reject(result);

        }catch(err){

          reject(err)

        }

      }

      switch(self.status){

        case PENDING: 

          self.onFulfilledCallbacks.push(fulfilled);

          self.onRejectedCallbacks.push(rejected);

          break;

        case FULFILLED:

          fulfilled();

          break;

        case REJECT:

          rejected();

          break;

      }

    })

   }

**注意：**

- 连续多个 `then `里的回调方法是同步注册的，但注册到了不同的 `callbacks `数组中，因为每次 `then `都返回新的 `promise `实例（参考上面的例子和图） - 注册完成后开始执行构造函数中的异步事件，异步完成之后依次调用 `callbacks `数组中提前注册的回调

 6. 手写 Promise.all

**1) 核心思路**

1. 接收一个 Promise 实例的数组或具有 Iterator 接口的对象作为参数 2. 这个方法返回一个新的 promise 对象， 3. 遍历传入的参数，用Promise.resolve()将参数"包一层"，使其变成一个promise对象 4. 参数所有回调成功才是成功，返回值数组与参数顺序一致 5. 参数数组其中一个失败，则触发失败状态，第一个触发失败的 Promise 错误信息作为 Promise.all 的错误信息。

**2）实现代码**

一般来说，Promise.all 用来处理多个并发请求，也是为了页面数据构造的方便，将一个页面所用到的在不同接口的数据一起请求过来，不过，如果其中一个接口失败了，多个请求也就失败了，页面可能啥也出不来，这就看当前页面的耦合程度了

function promiseAll(promises) {

  return new Promise(function(resolve, reject) {

    if(!Array.isArray(promises)){

        throw new TypeError(`argument must be a array`)

    }

    var resolvedCounter = 0;

    var promiseNum = promises.length;

    var resolvedResult = [];

    for (let i = 0; i < promiseNum; i++) {

      Promise.resolve(promises[i]).then(value=>{

        resolvedCounter++;

        resolvedResult[i] = value;

        if (resolvedCounter == promiseNum) {

            return resolve(resolvedResult)

          }

      },error=>{

        return reject(error)

      })

    }

  })

}

// test

let p1 = new Promise(function (resolve, reject) {

    setTimeout(function () {

        resolve(1)

    }, 1000)

})

let p2 = new Promise(function (resolve, reject) {

    setTimeout(function () {

        resolve(2)

    }, 2000)

})

let p3 = new Promise(function (resolve, reject) {

    setTimeout(function () {

        resolve(3)

    }, 3000)

})

promiseAll([p3, p1, p2]).then(res => {

    console.log(res) // [3, 1, 2]

})

 7. 手写 Promise.race

该方法的参数是 Promise 实例数组, 然后其 then 注册的回调方法是数组中的某一个 Promise 的状态变为 fulfilled 的时候就执行. 因为 Promise 的状态**只能改变一次**, 那么我们只需要把 Promise.race 中产生的 Promise 对象的 resolve 方法, 注入到数组中的每一个 Promise 实例中的回调函数中即可.

Promise.race = function (args) {

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

    for(let i = 0; i < args.length; i++){

      Promise.resolve(args[i]).then(resolve,reject)

    }

  })

}

 8. 手写防抖函数函数防抖是指在事件被触发 n 秒后再执行回调，如果在这 n 秒内事件又被触发，则重新计时。这可以使用在一些点击请求的事件上，避免因为用户的多次点击向后端发送多次请求。

// 函数防抖的实现

function debounce(fn, wait) {

  let timer = null;

  return function() {

    let context = this,

        args = arguments;

    // 如果此时存在定时器的话，则取消之前的定时器重新记时

    if (timer) {

      clearTimeout(timer);

      timer = null;

    }

    // 设置定时器，使事件间隔指定事件后执行

    timer = setTimeout(() => {

      fn.apply(context, args);

    }, wait);

  };

}

 9. 手写节流函数函数节流是指规定一个单位时间，在这个单位时间内，只能有一次触发事件的回调函数执行，如果在同一个单位时间内某事件被触发多次，只有一次能生效。节流可以使用在 scroll 函数的事件监听上，通过事件节流来降低事件调用的频率。

// 函数节流的实现;

function throttle(fn, delay) {

  let curTime = Date.now();

  return function() {

    let context = this,

        args = arguments,

        nowTime = Date.now();

    // 如果两次时间间隔超过了指定时间，则执行函数。

    if (nowTime - curTime >= delay) {

      curTime = Date.now();

      return fn.apply(context, args);

    }

  };

}

function throttle(fn,wait){

  let timer = null

  return function(){

    let context = this, args = arguments

    if(!timer){

      timer = setTimeOut(()=>{

        fn.apply(context,args)

        timer = null

      },wait)

    }

  }

}

 10. 手写类型判断函数

function getType(value) {

  // 判断数据是 null 的情况

  if (value === null) {

    return value + "";

  }

  // 判断数据是引用类型的情况

  if (typeof value === "object") {

    let valueClass = Object.prototype.toString.call(value),

      type = valueClass.split(" ")[1].split("");

    type.pop();

    return type.join("").toLowerCase();

  } else {

    // 判断数据是基本数据类型的情况和函数的情况

    return typeof value;

  }

}

 11. 手写 call 函数

call 函数的实现步骤：

1. 判断调用对象是否为函数，即使我们是定义在函数的原型上的，但是可能出现使用 call 等方式调用的情况。 2. 判断传入上下文对象是否存在，如果不存在，则设置为 window 。 3. 处理传入的参数，截取第一个参数后的所有参数。 4. 将函数作为上下文对象的一个属性。 5. 使用上下文对象来调用这个方法，并保存返回结果。 6. 删除刚才新增的属性。 7. 返回结果。

// call函数实现

Function.prototype.myCall = function(context) {

  // 判断调用对象

  if (typeof this !== "function") {

    console.error("type error");

  }

  // 获取参数

  let args = [...arguments].slice(1),

      result = null;

  // 判断 context 是否传入，如果未传入则设置为 window

  context = context || window;

  // 将调用函数设为对象的方法

  context.fn = this;

  // 调用函数

  result = context.fn(...args);

  // 将属性删除

  delete context.fn;

  return result;

};

 12. 手写 apply 函数

apply 函数的实现步骤：

1. 判断调用对象是否为函数，即使我们是定义在函数的原型上的，但是可能出现使用 call 等方式调用的情况。 2. 判断传入上下文对象是否存在，如果不存在，则设置为 window 。 3. 将函数作为上下文对象的一个属性。 4. 判断参数值是否传入 5. 使用上下文对象来调用这个方法，并保存返回结果。 6. 删除刚才新增的属性 7. 返回结果

// apply 函数实现

Function.prototype.myApply = function(context) {

  // 判断调用对象是否为函数

  if (typeof this !== "function") {

    throw new TypeError("Error");

  }

  let result = null;

  // 判断 context 是否存在，如果未传入则为 window

  context = context || window;

  // 将函数设为对象的方法

  context.fn = this;

  // 调用方法

  if (arguments[1]) {

    result = context.fn(...arguments[1]);

  } else {

    result = context.fn();

  }

  // 将属性删除

  delete context.fn;

  return result;

};

 13. 手写 bind 函数

bind 函数的实现步骤：

1. 判断调用对象是否为函数，即使我们是定义在函数的原型上的，但是可能出现使用 call 等方式调用的情况。 2. 保存当前函数的引用，获取其余传入参数值。 3. 创建一个函数返回 4. 函数内部使用 apply 来绑定函数调用，需要判断函数作为构造函数的情况，这个时候需要传入当前函数的 this 给 apply 调用，其余情况都传入指定的上下文对象。

// bind 函数实现

Function.prototype.myBind = function(context) {

  // 判断调用对象是否为函数

  if (typeof this !== "function") {

    throw new TypeError("Error");

  }

  // 获取参数

  var args = [...arguments].slice(1),

      fn = this;

  var bound = function() {

    // 根据调用方式，传入不同绑定值

    return fn.apply(

      this instanceof Fn ? this : context,

      args.concat(...arguments)

    );

  };

  f = Function() {}

  f.prototype = fn.prototype

  bound.prototype = new f();

  return bound;

};

 14. 函数柯里化的实现

函数柯里化指的是一种将使用多个参数的一个函数转换成一系列使用一个参数的函数的技术。

function curry(fn, args) {

  // 获取函数需要的参数长度

  let length = fn.length;

  args = args || [];

  return function() {

    let subArgs = args.slice(0);

    // 拼接得到现有的所有参数

    for (let i = 0; i < arguments.length; i++) {

      subArgs.push(arguments[i]);

    }

    // 判断参数的长度是否已经满足函数所需参数的长度

    if (subArgs.length >= length) {

      // 如果满足，执行函数

      return fn.apply(this, subArgs);

    } else {

      // 如果不满足，递归返回科里化的函数，等待参数的传入

      return curry.call(this, fn, subArgs);

    }

  };

}

// es6 实现

function curry(fn, ...args) {

  return fn.length <= args.length ? fn(...args) : curry.bind(null, fn, ...args);

}

 15. 实现AJAX请求

AJAX是 Asynchronous JavaScript and XML 的缩写，指的是通过 JavaScript 的 异步通信，从服务器获取 XML 文档从中提取数据，再更新当前网页的对应部分，而不用刷新整个网页。

创建AJAX请求的步骤：

- **创建一个 XMLHttpRequest 对象**。 - 在这个对象上**使用 open 方法创建一个 HTTP 请求**，open 方法所需要的参数是请求的方法、请求的地址、是否异步和用户的认证信息。 - 在发起请求前，可以为这个对象**添加一些信息和监听函数**。比如说可以通过 setRequestHeader 方法来为请求添加头信息。还可以为这个对象添加一个状态监听函数。一个 XMLHttpRequest 对象一共有 5 个状态，当它的状态变化时会触发onreadystatechange 事件，可以通过设置监听函数，来处理请求成功后的结果。当对象的 readyState 变为 4 的时候，代表服务器返回的数据接收完成，这个时候可以通过判断请求的状态，如果状态是 2xx 或者 304 的话则代表返回正常。这个时候就可以通过 response 中的数据来对页面进行更新了。 - 当对象的属性和监听函数设置完成后，最后**调用 sent 方法来向服务器发起请求**，可以传入参数作为发送的数据体。

const SERVER_URL = "/server";

let xhr = new XMLHttpRequest();

// 创建 Http 请求

xhr.open("GET", SERVER_URL, true);

// 设置状态监听函数

xhr.onreadystatechange = function() {

  if (this.readyState !== 4) return;

  // 当请求成功时

  if (this.status === 200) {

    handle(this.response);

  } else {

    console.error(this.statusText);

  }

};

// 设置请求失败时的监听函数

xhr.onerror = function() {

  console.error(this.statusText);

};

// 设置请求头信息

xhr.responseType = "json";

xhr.setRequestHeader("Accept", "application/json");

// 发送 Http 请求

xhr.send(null);

 16. 使用Promise封装AJAX请求

// promise 封装实现：

function getJSON(url) {

  // 创建一个 promise 对象

  let promise = new Promise(function(resolve, reject) {

    let xhr = new XMLHttpRequest();

    // 新建一个 http 请求

    xhr.open("GET", url, true);

    // 设置状态的监听函数

    xhr.onreadystatechange = function() {

      if (this.readyState !== 4) return;

      // 当请求成功或失败时，改变 promise 的状态

      if (this.status === 200) {

        resolve(this.response);

      } else {

        reject(new Error(this.statusText));

      }

    };

    // 设置错误监听函数

    xhr.onerror = function() {

      reject(new Error(this.statusText));

    };

    // 设置响应的数据类型

    xhr.responseType = "json";

    // 设置请求头信息

    xhr.setRequestHeader("Accept", "application/json");

    // 发送 http 请求

    xhr.send(null);

  });

  return promise;

}

 17. 实现浅拷贝

浅拷贝是指，一个新的对象对原始对象的属性值进行精确地拷贝，如果拷贝的是基本数据类型，拷贝的就是基本数据类型的值，如果是引用数据类型，拷贝的就是内存地址。如果其中一个对象的引用内存地址发生改变，另一个对象也会发生变化。

# （1）Object.assign()

`Object.assign()`是ES6中对象的拷贝方法，接受的第一个参数是目标对象，其余参数是源对象，用法：`Object.assign(target, source_1, ···)`，该方法可以实现浅拷贝，也可以实现一维对象的深拷贝。

**注意：**

- 如果目标对象和源对象有同名属性，或者多个源对象有同名属性，则后面的属性会覆盖前面的属性。 - 如果该函数只有一个参数，当参数为对象时，直接返回该对象；当参数不是对象时，会先将参数转为对象然后返回。 - 因为 `null `和 `undefined` 不能转化为对象，所以第一个参数不能为 `null`或 `undefined`，会报错。

let target = {a: 1};

let object2 = {b: 2};

let object3 = {c: 3};

Object.assign(target,object2,object3);  

console.log(target);  // {a: 1, b: 2, c: 3}

# （2）扩展运算符

使用扩展运算符可以在构造字面量对象的时候，进行属性的拷贝。语法：`let cloneObj = { ...obj };`

let obj1 = {a:1,b:{c:1}}

let obj2 = {...obj1};

obj1.a = 2;

console.log(obj1); //{a:2,b:{c:1}}

console.log(obj2); //{a:1,b:{c:1}}

obj1.b.c = 2;

console.log(obj1); //{a:2,b:{c:2}}

console.log(obj2); //{a:1,b:{c:2}}

# （3）数组方法实现数组浅拷贝

**1）Array.prototype.slice**

- `slice()`方法是JavaScript数组的一个方法，这个方法可以从已有数组中返回选定的元素：用法：`array.slice(start, end)`，该方法不会改变原始数组。 - 该方法有两个参数，两个参数都可选，如果两个参数都不写，就可以实现一个数组的浅拷贝。

let arr = [1,2,3,4];

console.log(arr.slice()); // [1,2,3,4]

console.log(arr.slice() === arr); //false

**2）Array.prototype.concat**

- `concat()` 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。 - 该方法有两个参数，两个参数都可选，如果两个参数都不写，就可以实现一个数组的浅拷贝。

let arr = [1,2,3,4];

console.log(arr.concat()); // [1,2,3,4]

console.log(arr.concat() === arr); //false

# （4）手写实现浅拷贝

// 浅拷贝的实现;

function shallowCopy(object) {

  // 只拷贝对象

  if (!object || typeof object !== "object") return;

  // 根据 object 的类型判断是新建一个数组还是对象

  let newObject = Array.isArray(object) ? [] : {};

  // 遍历 object，并且判断是 object 的属性才拷贝

  for (let key in object) {

    if (object.hasOwnProperty(key)) {

      newObject[key] = object[key];

    }

  }

  Object.keys(object).forEach(key => {

    if(object.hasOwnProperty(key)){

      newObject[key] = object[key]

    }

  })

  return newObject;

}// 浅拷贝的实现;

function shallowCopy(object) {

  // 只拷贝对象

  if (!object || typeof object !== "object") return;

  // 根据 object 的类型判断是新建一个数组还是对象

  let newObject = Array.isArray(object) ? [] : {};

  // 遍历 object，并且判断是 object 的属性才拷贝

  for (let key in object) {

    if (object.hasOwnProperty(key)) {

      newObject[key] = object[key];

      //newObject[key] = typeof object[key] === 'object' ? deepCopy(object[key]) : object[key]

    }

  }

  return newObject;

}// 浅拷贝的实现;

function shallowCopy(object) {

  // 只拷贝对象

  if (!object || typeof object !== "object") return;

  // 根据 object 的类型判断是新建一个数组还是对象

  let newObject = Array.isArray(object) ? [] : {};

  // 遍历 object，并且判断是 object 的属性才拷贝

  for (let key in object) {

    if (object.hasOwnProperty(key)) {

      newObject[key] = object[key];

    }

  }

  return newObject;

}

 18. 实现深拷贝

- **浅拷贝**：浅拷贝指的是将一个对象的属性值复制到另一个对象，如果有的属性的值为引用类型的话，那么会将这个引用的地址复制给对象，因此两个对象会有同一个引用类型的引用。浅拷贝可以使用 Object.assign 和展开运算符来实现。 - **深拷贝**：深拷贝相对浅拷贝而言，如果遇到属性值为引用类型的时候，它新建一个引用类型并将对应的值复制给它，因此对象获得的一个新的引用类型而不是一个原有类型的引用。深拷贝对于一些对象可以使用 JSON 的两个函数来实现，但是由于 JSON 的对象格式比 js 的对象格式更加严格，所以如果属性值里边出现函数或者 Symbol 类型的值时，会转换失败

# （1）JSON.stringify()

- `JSON.parse(JSON.stringify(obj))`是目前比较常用的深拷贝方法之一，它的原理就是利用 `JSON.stringify` 将 `js`对象序列化（JSON字符串），再使用 `JSON.parse`来反序列化(还原)js对象。 - 这个方法可以简单粗暴的实现深拷贝，但是还存在问题，拷贝的对象中如果有函数，undefined，symbol，当使用过 `JSON.stringify()`进行处理之后，都会消失。

let obj1 = {  a: 0,

              b: {

                 c: 0

                 }

            };

let obj2 = JSON.parse(JSON.stringify(obj1));

obj1.a = 1;

obj1.b.c = 1;

console.log(obj1); // {a: 1, b: {c: 1}}

console.log(obj2); // {a: 0, b: {c: 0}}

# （2）函数库lodash的_.cloneDeep方法

该函数库也有提供_.cloneDeep用来做 Deep Copy

var _ = require('lodash');

var obj1 = {

    a: 1,

    b: { f: { g: 1 } },

    c: [1, 2, 3]

};

var obj2 = _.cloneDeep(obj1);

console.log(obj1.b.f === obj2.b.f);// false

# （3）手写实现深拷贝函数

// 深拷贝的实现

function deepCopy(object) {

  if (!object || typeof object !== "object") return;

  let newObject = Array.isArray(object) ? [] : {};

  for (let key in object) {

    if (object.hasOwnProperty(key)) {

      newObject[key] =

        typeof object[key] === "object" ? deepCopy(object[key]) : object[key];

    }

  }

  

  Object.keys(object).forEach(key => {

    if(object.hasOwnProperty(key)){

      newObject[key] = typeof object[key] === 'object' ? deepCopy(object[key]) : object[key]

    }

  })

  return newObject;

}

 二、数据处理

 1. 实现日期格式化函数

输入：

dateFormat(new Date('2020-12-01'), 'yyyy/MM/dd') // 2020/12/01

dateFormat(new Date('2020-04-01'), 'yyyy/MM/dd') // 2020/04/01

dateFormat(new Date('2020-04-01'), 'yyyy年MM月dd日') // 2020年04月01日

const dateFormat = (dateInput, format)=>{

    var day = dateInput.getDate() 

    var month = dateInput.getMonth() + 1  

    var year = dateInput.getFullYear()   

    format = format.replace(/yyyy/, year)

    format = format.replace(/MM/,month)

    format = format.replace(/dd/,day)

    return format

}

 2. 交换a,b的值，不能用临时变量

巧妙的利用两个数的和、差：

``` a = a + b b = a - b a = a - b

```

 3. 实现数组的乱序输出

主要的实现思路就是：

- 取出数组的第一个元素，随机产生一个索引值，将该第一个元素和这个索引对应的元素进行交换。 - 第二次取出数据数组第二个元素，随机产生一个除了索引为1的之外的索引值，并将第二个元素与该索引值对应的元素进行交换 - 按照上面的规律执行，直到遍历完成

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

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

  const randomIndex = Math.round(Math.random() * (arr.length - 1 - i)) + i;

  [arr[i], arr[randomIndex]] = [arr[randomIndex], arr[i]];

}

console.log(arr)

还有一方法就是倒序遍历：

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

let length = arr.length,

    randomIndex,

    temp;

  while (length) {

    randomIndex = Math.floor(Math.random() * length--);

    temp = arr[length];

    arr[length] = arr[randomIndex];

    arr[randomIndex] = temp;

  }

console.log(arr)

 4. 实现数组元素求和

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

let length = arr.length,

    randomIndex,

    temp;

  while (length) {

    randomIndex = Math.floor(Math.random() * length--);

    temp = arr[length];

    arr[length] = arr[randomIndex];

    arr[randomIndex] = temp;

  }

console.log(arr)

递归实现：

let arr = [1, 2, 3, 4, 5, 6] 

function add(arr) {

    if (arr.length == 1) return arr[0] 

    return arr[0] + add(arr.slice(1)) 

}

console.log(add(arr)) // 21

 5. 实现数组的扁平化

**（1）递归实现**普通的递归思路很容易理解，就是通过循环递归的方式，一项一项地去遍历，如果每一项还是一个数组，那么就继续往下遍历，利用递归程序的方法，来实现数组的每一项的连接：

let arr = [1, [2, [3, 4, 5]]];

function flatten(arr) {

  let result = [];

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

    if(Array.isArray(arr[i])) {

      result = result.concat(flatten(arr[i]));

    } else {

      result.push(arr[i]);

    }

  }

  return result;

}

flatten(arr);  //  [1, 2, 3, 4，5]

**（2）reduce 函数迭代**

从上面普通的递归函数中可以看出，其实就是对数组的每一项进行处理，那么其实也可以用reduce 来实现数组的拼接，从而简化第一种方法的代码，改造后的代码如下所示：

let arr = [1, [2, [3, 4]]];

function flatten(arr) {

    return arr.reduce(function(prev, next){

        return prev.concat(Array.isArray(next) ? flatten(next) : next)

    }, [])

}

console.log(flatten(arr));//  [1, 2, 3, 4，5]

**（3）扩展运算符实现**

这个方法的实现，采用了扩展运算符和 some 的方法，两者共同使用，达到数组扁平化的目的：

let arr = [1, [2, [3, 4]]];

function flatten(arr) {

    while (arr.some(item => Array.isArray(item))) {

        arr = [].concat(...arr);

    }

    return arr;

}

console.log(flatten(arr)); //  [1, 2, 3, 4，5]

**（4）split 和 toString**

可以通过 split 和 toString 两个方法来共同实现数组扁平化，由于数组会默认带一个 toString 的方法，所以可以把数组直接转换成逗号分隔的字符串，然后再用 split 方法把字符串重新转换为数组，如下面的代码所示：

let arr = [1, [2, [3, 4]]];

function flatten(arr) {

    return arr.toString().split(',');

}

console.log(flatten(arr)); //  [1, 2, 3, 4，5]

通过这两个方法可以将多维数组直接转换成逗号连接的字符串，然后再重新分隔成数组。

**（5）ES6 中的 flat**

我们还可以直接调用 ES6 中的 flat 方法来实现数组扁平化。flat 方法的语法：`arr.flat([depth])`

其中 depth 是 flat 的参数，depth 是可以传递数组的展开深度（默认不填、数值是 1），即展开一层数组。如果层数不确定，参数可以传进 Infinity，代表不论多少层都要展开：

let arr = [1, [2, [3, 4]]];

function flatten(arr) {

  return arr.flat(Infinity);

}

console.log(flatten(arr)); //  [1, 2, 3, 4，5]

可以看出，一个嵌套了两层的数组，通过将 flat 方法的参数设置为 Infinity，达到了我们预期的效果。其实同样也可以设置成 2，也能实现这样的效果。在编程过程中，如果数组的嵌套层数不确定，最好直接使用 Infinity，可以达到扁平化。

**（6）正则和 JSON 方法**

在第4种方法中已经使用 toString 方法，其中仍然采用了将 JSON.stringify 的方法先转换为字符串，然后通过正则表达式过滤掉字符串中的数组的方括号，最后再利用 JSON.parse 把它转换成数组：

let arr = [1, [2, [3, [4, 5]]], 6];

function flatten(arr) {

  let str = JSON.stringify(arr);

  str = str.replace(/(\[|\])/g, '');

  str = '[' + str + ']';

  return JSON.parse(str); 

}

console.log(flatten(arr)); //  [1, 2, 3, 4，5]

 6. 实现数组去重

给定某无序数组，要求去除数组中的重复数字并且返回新的无重复数组。ES6方法（使用数据结构集合）：

const array = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8];

Array.from(new Set(array)); // [1, 2, 3, 5, 9, 8]

ES5方法：使用map存储不重复的数字

const array = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8];

uniqueArray(array); // [1, 2, 3, 5, 9, 8]

function uniqueArray(array) {

  let map = {};

  let res = [];

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

    if(!map.hasOwnProperty([array[i]])) {

      map[array[i]] = 1;

      res.push(array[i]);

    }

  }

  return res;

}

 7. 实现数组的flat方法

function _flat(arr, depth) {

  if(!Array.isArray(arr) || depth <= 0) {

    return arr;

  }

  return arr.reduce((prev, cur) => {

    if (Array.isArray(cur)) {

      return prev.concat(_flat(cur, depth - 1))

    } else {

      return prev.concat(cur);

    }

  }, []);

}

 8. 实现数组的push方法

let arr = [];

Array.prototype.push = function() {

    for( let i = 0 ; i < arguments.length ; i++){

        this[this.length] = arguments[i] ;

    }

    return this.length;

}

 9. 实现数组的filter方法

Array.prototype._filter = function(fn) {

    if (typeof fn !== "function") {

        throw Error('参数必须是一个函数');

    }

    const res = [];

    for (let i = 0, len = this.length; i < len; i++) {

        fn(this[i]) && res.push(this[i]);

    }

    return res;

}

 10. 实现数组的map方法

Array.prototype._map = function(fn) {

   if (typeof fn !== "function") {

        throw Error('参数必须是一个函数');

    }

    const res = [];

    for (let i = 0, len = this.length; i < len; i++) {

        res.push(fn(this[i]));

    }

    return res;

}

 11. 实现字符串的repeat方法

输入字符串s，以及其重复的次数，输出重复的结果，例如输入abc，2，输出abcabc。

function repeat(s, n) {

    return (new Array(n + 1)).join(s);

}

递归：

function repeat(s, n) {

    return (n > 0) ? s.concat(repeat(s, --n)) : "";

}

 12. 实现字符串翻转

在字符串的原型链上添加一个方法，实现字符串翻转：

String.prototype._reverse = function(a){

    return a.split("").reverse().join("");

}

var obj = new String();

var res = obj._reverse ('hello');

console.log(res);    // olleh

需要注意的是，必须通过实例化对象之后再去调用定义的方法，不然找不到该方法。

 13. 将数字每千分位用逗号隔开

**数字有小数版本：**

let format = n => {

    let num = n.toString() // 转成字符串

    let decimals = ''

        // 判断是否有小数

    num.indexOf('.') > -1 ? decimals = num.split('.')[1] : decimals

    let len = num.length

    if (len <= 3) {

        return num

    } else {

        let temp = ''

        let remainder = len % 3

        decimals ? temp = '.' + decimals : temp

        if (remainder > 0) { // 不是3的整数倍

            return num.slice(0, remainder) + ',' + num.slice(remainder, len).match(/\d{3}/g).join(',') + temp

        } else { // 是3的整数倍

            return num.slice(0, len).match(/\d{3}/g).join(',') + temp 

        }

    }

}

format(12323.33)  // '12,323.33'

**数字无小数版本：**

let format = n => {

    let num = n.toString() 

    let len = num.length

    if (len <= 3) {

        return num

    } else {

        let remainder = len % 3

        if (remainder > 0) { // 不是3的整数倍

            return num.slice(0, remainder) + ',' + num.slice(remainder, len).match(/\d{3}/g).join(',') 

        } else { // 是3的整数倍

            return num.slice(0, len).match(/\d{3}/g).join(',') 

        }

    }

}

format(1232323)  // '1,232,323'

 14. 实现非负大整数相加

JavaScript对数值有范围的限制，限制如下：

Number.MAX_VALUE // 1.7976931348623157e+308

Number.MAX_SAFE_INTEGER // 9007199254740991

Number.MIN_VALUE // 5e-324

Number.MIN_SAFE_INTEGER // -9007199254740991

如果想要对一个超大的整数(`> Number.MAX_SAFE_INTEGER`)进行加法运算，但是又想输出一般形式，那么使用 + 是无法达到的，一旦数字超过 `Number.MAX_SAFE_INTEGER` 数字会被立即转换为科学计数法，并且数字精度相比以前将会有误差。

实现一个算法进行大数的相加：

function sumBigNumber(a, b) {

  let res = '';

  let temp = 0;

  

  a = a.split('');

  b = b.split('');

  

  while (a.length || b.length || temp) {

    temp += ~~a.pop() + ~~b.pop();

    res = (temp % 10) + res;

    temp  = temp > 9

  }

  return res.replace(/^0+/, '');

}

其主要的思路如下：

- 首先用字符串的方式来保存大数，这样数字在数学表示上就不会发生变化 - 初始化res，temp来保存中间的计算结果，并将两个字符串转化为数组，以便进行每一位的加法运算 - 将两个数组的对应的位进行相加，两个数相加的结果可能大于10，所以可能要仅为，对10进行取余操作，将结果保存在当前位 - 判断当前位是否大于9，也就是是否会进位，若是则将temp赋值为true，因为在加法运算中，true会自动隐式转化为1，以便于下一次相加 - 重复上述操作，直至计算结束

 15. 实现 add(1)(2)(3)

函数柯里化概念： 柯里化（Currying）是把接受多个参数的函数转变为接受一个单一参数的函数，并且返回接受余下的参数且返回结果的新函数的技术。

1）粗暴版

function add (a) {

return function (b) {

    return function (c) {

      return a + b + c;

    }

}

}

console.log(add(1)(2)(3)); // 6

2）柯里化解决方案

- 参数长度固定

var add = function (m) {

  var temp = function (n) {

    return add(m + n);

  }

  temp.toString = function () {

    return m;

  }

  return temp;

};

console.log(add(3)(4)(5)); // 12

console.log(add(3)(6)(9)(25)); // 43

对于add(3)(4)(5)，其执行过程如下：

1. 先执行add(3)，此时m=3，并且返回temp函数； 2. 执行temp(4)，这个函数内执行add(m+n)，n是此次传进来的数值4，m值还是上一步中的3，所以add(m+n)=add(3+4)=add(7)，此时m=7，并且返回temp函数 3. 执行temp(5)，这个函数内执行add(m+n)，n是此次传进来的数值5，m值还是上一步中的7，所以add(m+n)=add(7+5)=add(12)，此时m=12，并且返回temp函数 4. 由于后面没有传入参数，等于返回的temp函数不被执行而是打印，了解JS的朋友都知道对象的toString是修改对象转换字符串的方法，因此代码中temp函数的toString函数return m值，而m值是最后一步执行函数时的值m=12，所以返回值是12。

- 参数长度不固定

function add (...args) {

    //求和

    return args.reduce((a, b) => a + b)

}

function currying (fn) {

    let args = []

    return function temp (...newArgs) {

        if (newArgs.length) {

            args = [

                ...args,

                ...newArgs

            ]

            return temp

        } else {

            let val = fn.apply(this, args)

            args = [] //保证再次调用时清空

            return val

        }

    }

}

let addCurry = currying(add)

console.log(addCurry(1)(2)(3)(4, 5)())  //15

console.log(addCurry(1)(2)(3, 4, 5)())  //15

console.log(addCurry(1)(2, 3, 4, 5)())  //15

 16. 实现类数组转化为数组

类数组转换为数组的方法有这样几种：

- 通过 call 调用数组的 slice 方法来实现转换

Array.prototype.slice.call(arrayLike);

- 通过 call 调用数组的 splice 方法来实现转换

Array.prototype.splice.call(arrayLike, 0);

- 通过 apply 调用数组的 concat 方法来实现转换

Array.prototype.concat.apply([], arrayLike);

- 通过 Array.from 方法来实现转换

Array.from(arrayLike);

 17. 使用 reduce 求和

arr = [1,2,3,4,5,6,7,8,9,10]，求和

let arr = [1,2,3,4,5,6,7,8,9,10]

arr.reduce((prev, cur) => { return prev + cur }, 0)

arr = [1,2,3,[[4,5],6],7,8,9]，求和

let arr = [1,2,3,4,5,6,7,8,9,10]

arr.flat(Infinity).reduce((prev, cur) => { return prev + cur }, 0)

arr = [{a:1, b:3}, {a:2, b:3, c:4}, {a:3}]，求和

let arr = [{a:9, b:3, c:4}, {a:1, b:3}, {a:3}] 

arr.reduce((prev, cur) => {

    return prev + cur["a"];

}, 0)

 18. 将js对象转化为树形结构

// 转换前：

source = [{

            id: 1,

            pid: 0,

            name: 'body'

          }, {

            id: 2,

            pid: 1,

            name: 'title'

          }, {

            id: 3,

            pid: 2,

            name: 'div'

          }]

// 转换为: 

tree = [{

          id: 1,

          pid: 0,

          name: 'body',

          children: [{

            id: 2,

            pid: 1,

            name: 'title',

            children: [{

              id: 3,

              pid: 1,

              name: 'div'

            }]

          }

        }]

代码实现：

function jsonToTree(data) {

  // 初始化结果数组，并判断输入数据的格式

  let result = []

  if(!Array.isArray(data)) {

    return result

  }

  // 使用map，将当前对象的id与当前对象对应存储起来

  let map = {};

  data.forEach(item => {

    map[item.id] = item;

  });

  // 

  data.forEach(item => {

    let parent = map[item.pid];

    if(parent) {

      (parent.children || (parent.children = [])).push(item);

    } else {

      result.push(item);

    }

  });

  return result;

}

 19. 使用ES5和ES6求函数参数的和

ES5：

function sum() {

    let sum = 0

    Array.prototype.forEach.call(arguments, function(item) {

        sum += item * 1

    })

    return sum

}

ES6：

function sum(...nums) {

    let sum = 0

    nums.forEach(function(item) {

        sum += item * 1

    })

    return sum

}

 20. 解析 URL Params 为对象

let url = 'http://www.domain.com/?user=anonymous&id=123&id=456&city=%E5%8C%97%E4%BA%AC&enabled';

parseParam(url)

/* 结果

{ user: 'anonymous',

  id: [ 123, 456 ], // 重复出现的 key 要组装成数组，能被转成数字的就转成数字类型

  city: '北京', // 中文需解码

  enabled: true, // 未指定值得 key 约定为 true

}

*/

function parseParam(url) {

  const paramsStr = /.+\?(.+)$/.exec(url)[1]; // 将 ? 后面的字符串取出来

  const paramsArr = paramsStr.split('&'); // 将字符串以 & 分割后存到数组中

  let paramsObj = {};

  // 将 params 存到对象中

  paramsArr.forEach(param => {

    if (/=/.test(param)) { // 处理有 value 的参数

      let [key, val] = param.split('='); // 分割 key 和 value

      val = decodeURIComponent(val); // 解码

      val = /^\d+$/.test(val) ? parseFloat(val) : val; // 判断是否转为数字

      if (paramsObj.hasOwnProperty(key)) { // 如果对象有 key，则添加一个值

        paramsObj[key] = [].concat(paramsObj[key], val);

      } else { // 如果对象没有这个 key，创建 key 并设置值

        paramsObj[key] = val;

      }

    } else { // 处理没有 value 的参数

      paramsObj[param] = true;

    }

  })

  return paramsObj;

}

 三、场景应用

 1. 循环打印红黄绿

下面来看一道比较典型的问题，通过这个问题来对比几种异步编程方法：**红灯 3s 亮一次，绿灯 1s 亮一次，黄灯 2s 亮一次；如何让三个灯不断交替重复亮灯？**

三个亮灯函数：

function red() {

    console.log('red');

}

function green() {

    console.log('green');

}

function yellow() {

    console.log('yellow');

}

这道题复杂的地方在于**需要“交替重复”亮灯**，而不是“亮完一次”就结束了。

# （1）用 callback 实现

const task = (timer, light, callback) => {

    setTimeout(() => {

        if (light === 'red') {

            red()

        }

        else if (light === 'green') {

            green()

        }

        else if (light === 'yellow') {

            yellow()

        }

        callback()

    }, timer)

}

task(3000, 'red', () => {

    task(2000, 'green', () => {

        task(1000, 'yellow', Function.prototype)

    })

})

这里存在一个 bug：代码只是完成了一次流程，执行后红黄绿灯分别只亮一次。该如何让它交替重复进行呢？

上面提到过递归，可以递归亮灯的一个周期：

const step = () => {

    task(3000, 'red', () => {

        task(2000, 'green', () => {

            task(1000, 'yellow', step)

        })

    })

}

step()

**注意看黄灯亮的回调里又再次调用了 step 方法** 以完成循环亮灯。

# （2）用 promise 实现

const task = (timer, light) => 

    new Promise((resolve, reject) => {

        setTimeout(() => {

            if (light === 'red') {

                red()

            }

            else if (light === 'green') {

                green()

            }

            else if (light === 'yellow') {

                yellow()

            }

            resolve()

        }, timer)

    })

const step = () => {

    task(3000, 'red')

        .then(() => task(2000, 'green'))

        .then(() => task(2100, 'yellow'))

        .then(step)

}

step()

这里将回调移除，在一次亮灯结束后，resolve 当前 promise，并依然使用递归进行。

# （3）用 async/await 实现

const taskRunner =  async () => {

    await task(3000, 'red')

    await task(2000, 'green')

    await task(2100, 'yellow')

    taskRunner()

}

taskRunner()

 2. 实现每隔一秒打印 1,2,3,4

// 使用闭包实现

for (var i = 0; i < 5; i++) {

  (function(i) {

    setTimeout(function() {

      console.log(i);

    }, i * 1000);

  })(i);

}

// 使用 let 块级作用域

for (let i = 0; i < 5; i++) {

  setTimeout(function() {

    console.log(i);

  }, i * 1000);

}

 3. 小孩报数问题

有30个小孩儿，编号从1-30，围成一圈依此报数，1、2、3 数到 3 的小孩儿退出这个圈， 然后下一个小孩 重新报数 1、2、3，问最后剩下的那个小孩儿的编号是多少?

function childNum(num, count){

    let allplayer = [];  

    for(let i = 0; i < num; i++){

        allplayer[i] = i + 1;

    }

  

    let exitCount = 0;    // 离开人数

    let counter = 0;      // 记录报数

    let curIndex = 0;     // 当前下标

  

    while(exitCount < num - 1){

        if(allplayer[curIndex] !== 0) counter++;  

      

        if(counter == count){

            allplayer[curIndex] = 0;               

            counter = 0;

            exitCount++;  

        }

        curIndex++;

        if(curIndex == num){

            curIndex = 0             

        };         

    }  

    for(i = 0; i < num; i++){

        if(allplayer[i] !== 0){

            return allplayer[i]

        }    

    }

}

childNum(30, 3)

 4. 用Promise实现图片的异步加载

let imageAsync=(url)=>{

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

                let img = new Image();

                img.src = url;

                img.οnlοad=()=>{

                    console.log(`图片请求成功，此处进行通用操作`);

                    resolve(image);

                }

                img.οnerrοr=(err)=>{

                    console.log(`失败，此处进行失败的通用操作`);

                    reject(err);

                }

            })

        }

      

imageAsync("url").then(()=>{

    console.log("加载成功");

}).catch((error)=>{

    console.log("加载失败");

})

 5. 实现发布-订阅模式

class EventCenter{

  // 1. 定义事件容器，用来装事件数组

    let handlers = {}

  // 2. 添加事件方法，参数：事件名 事件方法

  addEventListener(type, handler) {

    // 创建新数组容器

    if (!this.handlers[type]) {

      this.handlers[type] = []

    }

    // 存入事件

    this.handlers[type].push(handler)

  }

  // 3. 触发事件，参数：事件名 事件参数

  dispatchEvent(type, params) {

    // 若没有注册该事件则抛出错误

    if (!this.handlers[type]) {

      return new Error('该事件未注册')

    }

    // 触发事件

    this.handlers[type].forEach(handler => {

      handler(...params)

    })

  }

  // 4. 事件移除，参数：事件名 要删除事件，若无第二个参数则删除该事件的订阅和发布

  removeEventListener(type, handler) {

    if (!this.handlers[type]) {

      return new Error('事件无效')

    }

    if (!handler) {

      // 移除事件

      delete this.handlers[type]

    } else {

      const index = this.handlers[type].findIndex(el => el === handler)

      if (index === -1) {

        return new Error('无该绑定事件')

      }

      // 移除事件

      this.handlers[type].splice(index, 1)

      if (this.handlers[type].length === 0) {

        delete this.handlers[type]

      }

    }

  }

}

 6. 查找文章中出现频率最高的单词

function findMostWord(article) {

  // 合法性判断

  if (!article) return;

  // 参数处理

  article = article.trim().toLowerCase();

  let wordList = article.match(/[a-z]+/g),

    visited = [],

    maxNum = 0,

    maxWord = "";

  article = " " + wordList.join("  ") + " ";

  // 遍历判断单词出现次数

  wordList.forEach(function(item) {

    if (visited.indexOf(item) < 0) {

      // 加入 visited 

      visited.push(item);

      let word = new RegExp(" " + item + " ", "g"),

        num = article.match(word).length;

      if (num > maxNum) {

        maxNum = num;

        maxWord = item;

      }

    }

  });

  return maxWord + "  " + maxNum;

}

 7. 封装异步的fetch，使用async await方式来使用

(async () => {

    class HttpRequestUtil {

        async get(url) {

            const res = await fetch(url);

            const data = await res.json();

            return data;

        }

        async post(url, data) {

            const res = await fetch(url, {

                method: 'POST',

                headers: {

                    'Content-Type': 'application/json'

                },

                body: JSON.stringify(data)

            });

            const result = await res.json();

            return result;

        }

        async put(url, data) {

            const res = await fetch(url, {

                method: 'PUT',

                headers: {

                    'Content-Type': 'application/json'

                },

                data: JSON.stringify(data)

            });

            const result = await res.json();

            return result;

        }

        async delete(url, data) {

            const res = await fetch(url, {

                method: 'DELETE',

                headers: {

                    'Content-Type': 'application/json'

                },

                data: JSON.stringify(data)

            });

            const result = await res.json();

            return result;

        }

    }

    const httpRequestUtil = new HttpRequestUtil();

    const res = await httpRequestUtil.get('http://golderbrother.cn/');

    console.log(res);

})();

 8. 实现prototype继承所谓的原型链继承就是让新实例的原型等于父类的实例：

//父方法

function SupperFunction(flag1){

    this.flag1 = flag1;

}

//子方法

function SubFunction(flag2){

    this.flag2 = flag2;

}

//父实例

var superInstance = new SupperFunction(true);

//子继承父

SubFunction.prototype = superInstance;

//子实例

var subInstance = new SubFunction(false);

//子调用自己和父的属性

subInstance.flag1;   // true

subInstance.flag2;   // false

 9. 实现双向数据绑定

let obj = {}

let input = document.getElementById('input')

let span = document.getElementById('span')

// 数据劫持

Object.defineProperty(obj, 'text', {

  configurable: true,

  enumerable: true,

  get() {

    console.log('获取数据了')

  },

  set(newVal) {

    console.log('数据更新了')

    input.value = newVal

    span.innerHTML = newVal

  }

})

// 输入监听

input.addEventListener('keyup', function(e) {

  obj.text = e.target.value

})

 10. 实现简单路由

// hash路由

class Route{

  constructor(){

    // 路由存储对象

    this.routes = {}

    // 当前hash

    this.currentHash = ''

    // 绑定this，避免监听时this指向改变

    this.freshRoute = this.freshRoute.bind(this)

    // 监听

    window.addEventListener('load', this.freshRoute, false)

    window.addEventListener('hashchange', this.freshRoute, false)

  }

  // 存储

  storeRoute (path, cb) {

    this.routes[path] = cb || function () {}

  }

  // 更新

  freshRoute () {

    this.currentHash = location.hash.slice(1) || '/'

    this.routes[this.currentHash]()

  }

}

 11. 实现斐波那契数列

// 递归

function fn (n){

    if(n==0) return 0

    if(n==1) return 1

    return fn(n-2)+fn(n-1)

}

// 优化

function fibonacci2(n) {

    const arr = [1, 1, 2];

    const arrLen = arr.length;

    if (n <= arrLen) {

        return arr[n];

    }

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

        arr.push(arr[i - 1] + arr[ i - 2]);

    }

    return arr[arr.length - 1];

}

// 非递归

function fn(n) {

    let pre1 = 1;

    let pre2 = 1;

    let current = 2;

    if (n <= 2) {

        return current;

    }

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

        pre1 = pre2;

        pre2 = current;

        current = pre1 + pre2;

    }

    return current;

}

 12. 字符串出现的不重复最长长度

用一个滑动窗口装没有重复的字符，枚举字符记录最大值即可。用 map 维护字符的索引，遇到相同的字符，把左边界移动过去即可。挪动的过程中记录最大长度：

var lengthOfLongestSubstring = function (s) {

    let map = new Map();

    let i = -1

    let res = 0

    let n = s.length

    for (let j = 0; j < n; j++) {

        if (map.has(s[j])) {

            i = Math.max(i, map.get(s[j]))

        }

        res = Math.max(res, j - i)

        map.set(s[j], j)

    }

    return res

};

 13. 使用 setTimeout 实现 setInterval

setInterval 的作用是每隔一段指定时间执行一个函数，但是这个执行不是真的到了时间立即执行，它真正的作用是每隔一段时间将事件加入事件队列中去，只有当当前的执行栈为空的时候，才能去从事件队列中取出事件执行。所以可能会出现这样的情况，就是当前执行栈执行的时间很长，导致事件队列里边积累多个定时器加入的事件，当执行栈结束的时候，这些事件会依次执行，因此就不能到间隔一段时间执行的效果。

针对 setInterval 的这个缺点，我们可以使用 setTimeout 递归调用来模拟 setInterval，这样我们就确保了只有一个事件结束了，我们才会触发下一个定时器事件，这样解决了 setInterval 的问题。

实现思路是使用递归函数，不断地去执行 setTimeout 从而达到 setInterval 的效果

function mySetInterval(fn, timeout) {

  // 控制器，控制定时器是否继续执行

  var timer = {

    flag: true

  };

  // 设置递归函数，模拟定时器执行。

  function interval() {

    if (timer.flag) {

      fn();

      setTimeout(interval, timeout);

    }

  }

  // 启动定时器

  setTimeout(interval, timeout);

  // 返回控制器

  return timer;

}

 14. 实现 jsonp

// 动态的加载js文件

function addScript(src) {

  const script = document.createElement('script');

  script.src = src;

  script.type = "text/javascript";

  document.body.appendChild(script);

}

addScript("http://xxx.xxx.com/xxx.js?callback=handleRes");

// 设置一个全局的callback函数来接收回调结果

function handleRes(res) {

  console.log(res);

}

// 接口返回的数据格式

handleRes({a: 1, b: 2});

 15. 判断对象是否存在循环引用

循环引用对象本来没有什么问题，但是序列化的时候就会发生问题，比如调用 `JSON.stringify()`对该类对象进行序列化，就会报错: `Converting circular structure to JSON.`下面方法可以用来判断一个对象中是否已存在循环引用：

const isCycleObject = (obj,parent) => {

    const parentArr = parent || [obj];

    for(let i in obj) {

        if(typeof obj[i] === 'object') {

            let flag = false;

            parentArr.forEach((pObj) => {

                if(pObj === obj[i]){

                    flag = true;

                }

            })

            if(flag) return true;

            flag = isCycleObject(obj[i],[...parentArr,obj[i]]);

            if(flag) return true;

        }

    }

    return false;

}

const a = 1;

const b = {a};

const c = {b};

const o = {d:{a:3},c}

o.c.b.aa = a;

console.log(isCycleObject(o)

查找有序二维数组的目标值：

var findNumberIn2DArray = function(matrix, target) {

    if (matrix == null || matrix.length == 0) {

        return false;

    }

    let row = 0;

    let column = matrix[0].length - 1;

    while (row < matrix.length && column >= 0) {

        if (matrix[row][column] == target) {

            return true;

        } else if (matrix[row][column] > target) {

            column--;

        } else {

            row++;

        }

    }

    return false;

};

二维数组斜向打印：

function printMatrix(arr){

let m = arr.length, n = arr[0].length

let res = []

// 左上角，从0 到 n - 1 列进行打印

for (let k = 0; k < n; k++) {

for (let i = 0, j = k; i < m && j >= 0; i++, j--) {

res.push(arr[i][j]);

}

}

// 右下角，从1 到 n - 1 行进行打印

for (let k = 1; k < m; k++) {

for (let i = k, j = n - 1; i < m && j >= 0; i++, j--) {

res.push(arr[i][j]);

}

}

return res

}

好文阅读

评论可见，请评论后查看内容，谢谢！！！评论后请刷新页面。