diff --git a/01.计算机网络.md b/01.计算机网络.md
new file mode 100644
index 0000000..98e4cb9
--- /dev/null
+++ b/01.计算机网络.md
@@ -0,0 +1,694 @@
+# HTTP 和 HTTPS
+
+
+### HTTP 的基本概念
+
+http: 是互联网上应用最为广泛的一种网络协议，是一个客户端和服务器端`请求和应答的标准（TCP）`，用于从 WWW 服务器传输超文本到本地浏览器的`超文本传输协议`。
+
+
+### HTTP工作原理
+
+HTTP协议定义Web客户端如何从Web服务器请求Web页面，以及服务器如何把Web页面传送给客户端。客户端向服务器发送一个请求报文，服务器以一个状态行作为响应。
+
+
+### HTTP请求/响应的步骤
+
+- 1.客户端连接到Web服务器
+- 2.发送HTTP请求
+- 3.服务器接受请求并返回HTTP响应
+- 4.释放TCP连接
+- 5.客户端（浏览器）解析HTML内容
+
+>记忆口诀：连接发送加响应，释放解析整过程。
+
+
+### HTTP 的 5 种方法
+
+- GET---获取资源
+- POST---传输资源
+- PUT---更新资源
+- DELETE---删除资源
+- HEAD---获取报文首部
+
+
+### GET与POST的区别
+
+**1.浏览器回退表现不同** GET在浏览器回退时是无害的，而POST会再次提交请求
+**2.浏览器对请求地址的处理不同** GET请求地址会被浏览器主动缓存，而POST不会，除非手动设置
+**3.浏览器对响应的处理不同**GET请求参数会被完整的保留在浏览器历史记录里，而POST中的参数不会被保留
+**4.参数大小不同.** GET请求在URL中传送的参数是有长度的限制，而POST没有限制
+**5.安全性不同.** GET参数通过URL传递，会暴露，不安全；POST放在Request Body中，相对更安全
+**6.针对数据操作的类型不同**.GET对数据进行查询，POST主要对数据进行增删改！简单说，GET是只读，POST是写。
+
+
+### HTTP报文的组成成分
+
+请求报文{ 请求行、请求头、空行、请求体 } 请求行：{http方法、页面地址、http协议、http版本} 响应报文{ 状态行、响应头、空行、响应体 }
+
+**Request Header:**
+
+1. **GET /sample.Jsp HTTP/1.1**  //请求行
+2. **Host:**  www.uuid.online/ //请求的目标域名和端口号
+3. **Origin:** http://localhost:8081/  //请求的来源域名和端口号 （跨域请求时，浏览器会自动带上这个头信息）
+4. **Referer:** https://localhost:8081/link?query=xxxxx //请求资源的完整URI
+5. **User-Agent:** Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36 //浏览器信息
+6. **Cookie:**  BAIDUID=FA89F036:FG=1; BD_HOME=1; sugstore=0  //当前域名下的Cookie
+7. **Accept:** text/html,image/apng  //代表客户端希望接受的数据类型是html或者是png图片类型 
+8. **Accept-Encoding:** gzip, deflate  //代表客户端能支持gzip和deflate格式的压缩
+9. **Accept-Language:** zh-CN,zh;q=0.9  //代表客户端可以支持语言zh-CN或者zh(值得一提的是q(0~1)是优先级权重的意思，不写默认为1，这里zh-CN是1，zh是0.9)
+10. **Connection:** keep-alive  //告诉服务器，客户端需要的tcp连接是一个长连接
+
+**Response Header:**
+
+1. **HTTP/1.1 200 OK**  // 响应状态行
+2. **Date:**  Mon, 30 Jul 2018 02:50:55 GMT  //服务端发送资源时的服务器时间
+3. **Expires:**  Wed, 31 Dec 1969 23:59:59 GMT //比较过时的一种验证缓存的方式，与浏览器（客户端）的时间比较，超过这个时间就不用缓存（不和服务器进行验证），适合版本比较稳定的网页
+4. **Cache-Control:**  no-cache  // 现在最多使用的控制缓存的方式，会和服务器进行缓存验证，具体见[博文”Cache-Control“](https://www.cnblogs.com/amiezhang/p/9389537.html)
+5. **etag:**  "fb8ba2f80b1d324bb997cbe188f28187-ssl-df"  // 一般是[Nginx静态服务器](http://www.t086.com/article/5207)发来的静态文件签名，浏览在没有“Disabled cache”情况下，接收到etag后，同一个url第二次请求就会自动带上“If-None-Match”
+6. **Last-Modified:**  Fri, 27 Jul 2018 11:04:55 GMT //是服务器发来的当前资源最后一次修改的时间，下次请求时，如果服务器上当前资源的修改时间大于这个时间，就返回新的资源内容
+7. **Content-Type:**  text/html; charset=utf-8  //如果返回是流式的数据，我们就必须告诉浏览器这个头，不然浏览器会下载这个页面，同时告诉浏览器是utf8编码，否则可能出现乱码
+8. **Content-Encoding:**  gzip  //告诉客户端，应该采用gzip对资源进行解码
+9. **Connection:**  keep-alive  //告诉客户端服务器的tcp连接也是一个长连接
+
+
+### https 的基本概念
+
+https:是以安全为目标的 HTTP 通道，即 HTTP 下 加入 SSL 层进行加密。 
+
+https 协议的作用：建立一个信息安全通道，来确保数据的传输，确保网站的真实性。
+
+
+### http 和 https 的区别？
+
+- http 是超文本传输协议，信息是明文传输，https 则是具有安全性的 ssl 加密传输协议。
+- Https 协议需要 ca 证书，费用较高。 
+- 使用不同的链接方式，端口也不同，一般，http 协议的端口为 80，https 的端口为 443。
+- http 的连接很简单，是无状态的。
+
+>记忆口诀：明文传输超文本，安全等级各不同。CA证书费用高，无状连接端难同。
+
+
+#### https 协议的工作原理
+
+![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c42bc6f45451457fa6d614fb27534516~tplv-k3u1fbpfcp-watermark.image?)
+
+客户端在使用 HTTPS 方式与 Web 服务器通信时有以下几个步骤：
+1. 客户端使用 https url 访问服务器，则要求 web 服务器`建立 ssl 链接`。
+2. web 服务器接收到客户端的请求之后，会`将网站的证书（证书中包含了公钥），传输给客户端`。
+3. 客户端和 web 服务器端开始`协商 SSL 链接的安全等级`，也就是加密等级。
+4. 客户端浏览器通过双方协商一致的安全等级，`建立会话密钥`，然后通过网站的公钥来加密会话密钥，并传送给网站。
+5. web 服务器`通过自己的私钥解密出会话密钥`。
+6. web 服务器`通过会话密钥加密与客户端之间的通信`。
+
+>记忆口诀：一连二传三协商，四建五得六使用。
+
+
+#### https 协议的优缺点
+- HTTPS 协议要比 http 协议`安全`，可防止数据在传输过程中被窃取、改变，确保数据的完整性。
+- https 握手阶段比较`费时`，会使页面加载时间延长 50%，增加 10%~20%的耗电。 
+- https `缓存`不如 http 高效，会增加数据开销。 
+- SSL 证书也需要钱，功能越强大的`证书费`用越高。 
+- SSL 证书需要绑定 `IP`，不能再同一个 ip 上绑定多个域名，ipv4 资源支持不了这种消耗。
+
+
+### TCP/IP网络模型
+
+TCP/IP模型是互联网的基础，它是一系列网络协议的总称。这些协议可以划分为四层，分别为链路层、网络层、传输层和应用层。
+
+-   链路层：负责封装和解封装IP报文，发送和接受ARP/RARP报文等。
+-   网络层：负责路由以及把分组报文发送给目标网络或主机。
+-   传输层：负责对报文进行分组和重组，并以TCP或UDP协议格式封装报文。
+-   应用层：负责向用户提供应用程序，比如HTTP、FTP、Telnet、DNS、SMTP等。
+
+![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2fa80b3b48a84bd18d8e708c56a1dc22~tplv-k3u1fbpfcp-watermark.image)
+
+
+### TCP三次握手
+
+![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/baf3d5df95a74f47a1d779ee50c3411f~tplv-k3u1fbpfcp-watermark.image?)
+
+1.  第一次握手：`建立连接时，客户端发送syn包（syn=j）到服务器，并进入SYN_SENT状态，等待服务器确认`；SYN：同步序列编号（Synchronize Sequence Numbers）。
+1.  第二次握手：`服务器收到syn包并确认客户的SYN`（ack=j+1），`同时也发送一个自己的SYN包`（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
+1.  第三次握手：`客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1）`，此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。
+
+```
+握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。
+```
+
+
+### TCP 四次挥手
+
+1.  `客户端进程发出连接释放报文`，并且停止发送数据。释放数据报文首部，FIN=1，其序列号为seq=u（等于前面已经传送过来的数据的最后一个字节的序号加1），此时，客户端进入FIN-WAIT-1（终止等待1）状态。 TCP规定，FIN报文段即使不携带数据，也要消耗一个序号。
+
+2）`服务器收到连接释放报文，发出确认报文`，ACK=1，ack=u+1，并且带上自己的序列号seq=v，此时，服务端就进入了CLOSE-WAIT（关闭等待）状态。TCP服务器通知高层的应用进程，客户端向服务器的方向就释放了，这时候处于半关闭状态，即客户端已经没有数据要发送了，但是服务器若发送数据，客户端依然要接受。这个状态还要持续一段时间，也就是整个CLOSE-WAIT状态持续的时间。
+
+3）客户端收到服务器的确认请求后，此时，客户端就进入FIN-WAIT-2（终止等待2）状态，等待服务器发送连接释放报文（在这之前还需要接受服务器发送的最 后的数据）。
+
+4）`服务器将最后的数据发送完毕后，就向客户端发送连接释放报文`，FIN=1，ack=u+1，由于在半关闭状态，服务器很可能又发送了一些数据，假定此时的序列号为seq=w，此时，服务器就进入了LAST-ACK（最后确认）状态，等待客户端的确认。
+
+5）`客户端收到服务器的连接释放报文后，必须发出确认`，ACK=1，ack=w+1，而自己的序列号是seq=u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。
+
+6）服务器只要收到了客户端发出的确认，立即进入CLOSED状态。同样，撤销TCB后，就结束了这次的TCP连接。可以看到，服务器结束TCP连接的时间要比客户端早一些。
+
+
+### TCP和UDP的区别
+
+1. TCP是面向`连接`的，而UDP是面向无连接的。
+
+2. TCP仅支持`单播传输`，UDP 提供了单播，多播，广播的功能。
+
+3. TCP的三次握手保证了连接的`可靠性`; UDP是无连接的、不可靠的一种数据传输协议，首先不可靠性体现在无连接上，通信都不需要建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收。
+
+4. UDP的`头部开销`比TCP的更小，数据`传输速率更高`，`实时性更好`。
+
+
+### HTTP 请求跨域问题
+
+1. 跨域的原理
+
+    **跨域**，是指浏览器不能执行其他网站的脚本。它是由浏览器的`同源策略`造成的。\
+    **同源策略**,是浏览器对 JavaScript 实施的安全限制，只要`协议、域名、端口`有任何一个不同，都被当作是不同的域。\
+    **跨域原理**，即是通过各种方式，`避开浏览器的安全限制`。
+    
+2. 解决方案
+
+    最初做项目的时候，使用的是jsonp，但存在一些问题，使用get请求不安全，携带数据较小，后来也用过iframe，但只有主域相同才行，也是存在些问题，后来通过了解和学习发现使用代理和proxy代理配合起来使用比较方便，就引导后台按这种方式做下服务器配置，在开发中使用proxy，在服务器上使用nginx代理，这样开发过程中彼此都方便，效率也高；现在h5新特性还有 windows.postMessage()
+
+    - **JSONP**：\
+        ajax 请求受同源策略影响，不允许进行跨域请求，而 script 标签 src 属性中的链 接却可以访问跨域的 js 脚本，利用这个特性，服务端不再返回 JSON 格式的数据，而是 返回一段调用某个函数的 js 代码，在 src 中进行了调用，这样实现了跨域。
+    
+        步骤：
+        1. 去创建一个script标签
+        2. script的src属性设置接口地址
+        3. 接口参数，必须要带一个自定义函数名，要不然后台无法返回数据
+        4. 通过定义函数名去接受返回的数据
+    
+        ```js
+        //动态创建 script
+        var script = document.createElement('script');
+
+        // 设置回调函数
+        function getData(data) {
+            console.log(data);
+        }
+
+        //设置 script 的 src 属性，并设置请求地址
+        script.src = 'http://localhost:3000/?callback=getData';
+
+        // 让 script 生效
+        document.body.appendChild(script);
+        ```
+    
+        **JSONP 的缺点**:\
+        JSON 只支持 get，因为 script 标签只能使用 get 请求； JSONP 需要后端配合返回指定格式的数据。
+
+    - **document.domain**  基础域名相同 子域名不同
+    - **window.name** 利用在一个浏览器窗口内，载入所有的域名都是共享一个 window.name
+    - **CORS** CORS(Cross-origin resource sharing)跨域资源共享 服务器设置对CORS的支持原理：服务器设置Access-Control-Allow-Origin HTTP响应头之后，浏览器将会允许跨域请求
+    - **proxy代理** 目前常用方式
+    - **window.postMessage()**  利用h5新特性 window.postMessage()
+    - **Websocket**
+
+
+### Cookie、sessionStorage、localStorage 的区别
+
+**相同点**：
+
+- 存储在客户端
+
+**不同点**：
+
+- cookie数据大小不能超过4k；sessionStorage和localStorage的存储比cookie大得多，可以达到5M+
+- cookie设置的过期时间之前一直有效；localStorage永久存储，浏览器关闭后数据不丢失除非主动删除数据；sessionStorage数据在当前浏览器窗口关闭后自动删除
+- cookie的数据会自动的传递到服务器；sessionStorage和localStorage数据保存在本地
+
+
+### HTTP状态码及常见状态码
+
+#### HTTP状态码
+- 1xx：指示信息类，表示请求已接受，继续处理
+- 2xx：指示成功类，表示请求已成功接受
+- 3xx：指示重定向，表示要完成请求必须进行更近一步的操作
+- 4xx：指示客户端错误，请求有语法错误或请求无法实现
+- 5xx：指示服务器错误，服务器未能实现合法的请求
+
+#### 常见状态码
+
+- 200 OK：客户端请求成功
+- 301 Moved Permanently：所请求的页面已经永久重定向至新的URL
+- 302 Found：所请求的页面已经临时重定向至新的URL
+- 304 Not Modified 未修改。
+- 403 Forbidden：对请求页面的访问被禁止
+- 404 Not Found：请求资源不存在
+- 500 Internal Server Error：服务器发生不可预期的错误原来缓冲的文档还可以继续使用
+- 503 Server Unavailable：请求未完成，服务器临时过载或宕机，一段时间后可恢复正常
+
+- 1xx（临时响应）表示临时响应并需要请求者继续执行操作的状态码
+    - 100 - 继续 请求者应当继续提出请求。服务器返回此代码表示已收到请求的第一部分，正在等待其余部分
+    - 101 - 切换协议 请求者已要求服务器切换协议，服务器已确认并准备切换
+
+- 2xx（成功）表示成功处理了请求的状态码
+    - `200` - 成功 服务器已经成功处理了请求。通常，这表示服务器提供了请求的网页
+    - 201 - 已创建 请求成功并且服务器创建了新的资源
+    - 202 - 已接受 服务器已接受请求，但尚未处理
+    - 203 - 非授权信息 服务器已经成功处理了请求，但返回的信息可能来自另一来源
+    - 204 - 无内容 服务器成功处理了请求，但没有返回任何内容
+    - 205 - 重置内容 服务器成功处理了请求，但没有返回任何内容
+
+- 3xx（重定向）表示要完成请求，需要进一步操作；通常，这些状态代码用来重定向
+    - 300 - 多种选择 针对请求，服务器可执行多种操作。服务器可根据请求者（user agent）选择一项操作，或提供操作列表供请求者选择
+    - `301` - 永久移动 请求的网页已永久移动到新位置。服务器返回此响应（对GET或HEAD请求的响应）时，会自动将请求者转到新位置
+    - `302` - 临时移动 服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求
+    - 303 - 查看其它位置 请求者应当对不同的位置使用单独的GET请求来检索响应时，服务器返回此代码
+    - `304` - 未修改 自上次请求后，请求的网页未修改过。服务器返回此响应，不会返回网页的内容
+    - 305 - 使用代理 请求者只能使用代理访问请求的网页。如果服务器返回此响应，还表示请求者应使用代理
+    - `307` - 临时性重定向 服务器目前从不同位置的网页响应请求，但请求者应继续使用原有的位置来进行以后的请求
+
+- 4xx（请求错误）这些状态码表示请求可能出错，妨碍了服务器的处理
+    - `400` - 错误请求 服务器不理解请求的语法
+    - `401` - 未授权 请求要求身份验证。对于需要登录的网页，服务器可能返回此响应
+    - `403` - 禁止 服务器拒绝请求
+    - `404` - 未找到 服务器找不到请求的网页
+    - 405 - 方法禁用 禁用请求中指定的方法
+    - 406 - 不接受 无法使用请求的内容特性响应请求的网页
+    - `407` - 需要代理授权 此状态码与401（未授权）类似，但指定请求者应当授权使用代理
+    - `408` - 请求超时 服务器等候请求时发生超时
+    - 410 - 已删除 如果请求的资源已永久删除，服务器就会返回此响应
+    - `413` - 请求实体过大 服务器无法处理请求，因为请求实体过大，超出了服务器的处理能力
+    - `414` - 请求的URI过长 请求的URI（通常为网址）过长，服务器无法处理
+ 
+
+- 5xx（服务器错误）这些状态码表示服务器在尝试处理请求时发生内部错误。这些错误可能是服务器本身的错误，而不是请求出错
+    - `500` - 服务器内部错误 服务器遇到错误，无法完成请求
+    - 501 - 尚未实施 服务器不具备完成请求的功能。例如，服务器无法识别请求方法时可能会返回此代码
+    - `502` - 错误网关 服务器作为网关或代理，从上游服务器无法收到无效响应
+    - `503` - 服务器不可用 服务器目前无法使用（由于超载或者停机维护）。通常，这只是暂时状态
+    - `504` - 网关超时 服务器作为网关代理，但是没有及时从上游服务器收到请求
+    - 505 - HTTP版本不受支持 服务器不支持请求中所用的HTTP协议版本
+
+
+### 介绍下304过程
+- a. 浏览器请求资源时首先命中资源的Expires 和 Cache-Control，Expires 受限于本地时间，如果修改了本地时间，可能会造成缓存失效，可以通过Cache-control: max-age指定最大生命周期，状态仍然返回200，但不会请求数据，在浏览器中能明显看到from cache字样。
+
+- b. 强缓存失效，进入协商缓存阶段，首先验证ETagETag可以保证每一个资源是唯一的，资源变化都会导致ETag变化。服务器根据客户端上送的If-None-Match值来判断是否命中缓存。
+
+- c. 协商缓存Last-Modify/If-Modify-Since阶段，客户端第一次请求资源时，服务服返回的header中会加上Last-Modify，Last-modify是一个时间标识该资源的最后修改时间。再次请求该资源时，request的请求头中会包含If-Modify-Since，该值为缓存之前返回的Last-Modify。服务器收到If-Modify-Since后，根据资源的最后修改时间判断是否命中缓存。
+
+
+### 浏览器的缓存机制 强制缓存 && 协商缓存
+
+浏览器与服务器通信的方式为应答模式，即是：浏览器发起HTTP请求 – 服务器响应该请求。那么浏览器第一次向服务器发起该请求后拿到请求结果，会根据响应报文中HTTP头的缓存标识，决定是否缓存结果，是则将请求结果和缓存标识存入浏览器缓存中，简单的过程如下图：
+
+![图片](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/05b3fe9c411f4881a8b22fe37eae170b~tplv-k3u1fbpfcp-zoom-1.image)
+
+由上图我们可以知道：
+
+-   浏览器每次发起请求，都会`先在浏览器缓存中查找该请求的结果以及缓存标识`
+-   浏览器每次拿到返回的请求结果都会`将该结果和缓存标识存入浏览器缓存中`
+
+以上两点结论就是浏览器缓存机制的关键，他确保了每个请求的缓存存入与读取，只要我们再理解浏览器缓存的使用规则，那么所有的问题就迎刃而解了。为了方便理解，这里根据是否需要向服务器重新发起HTTP请求将缓存过程分为两个部分，分别是`强制缓存`和`协商缓存`。
+
+-   **强制缓存**
+
+    `强制缓存就是向浏览器缓存查找该请求结果，并根据该结果的缓存规则来决定是否使用该缓存结果的过程。`当浏览器向服务器发起请求时，服务器会将缓存规则放入HTTP响应报文的HTTP头中和请求结果一起返回给浏览器，控制强制缓存的字段分别是 `Expires` 和 `Cache-Control`，其中Cache-Control优先级比Expires高。
+
+    强制缓存的情况主要有三种(暂不分析协商缓存过程)，如下：
+
+    1.  不存在该缓存结果和缓存标识，强制缓存失效，则直接向服务器发起请求（跟第一次发起请求一致）。
+    1.  存在该缓存结果和缓存标识，但该结果已失效，强制缓存失效，则使用协商缓存。
+    1.  存在该缓存结果和缓存标识，且该结果尚未失效，强制缓存生效，直接返回该结果
+
+-   **协商缓存**
+
+    `协商缓存就是强制缓存失效后，浏览器携带缓存标识向服务器发起请求，由服务器根据缓存标识决定是否使用缓存的过程`，同样，协商缓存的标识也是在响应报文的HTTP头中和请求结果一起返回给浏览器的，控制协商缓存的字段分别有：`Last-Modified / If-Modified-Since` 和 `Etag / If-None-Match`，其中Etag / If-None-Match的优先级比Last-Modified / If-Modified-Since高。协商缓存主要有以下两种情况：
+
+    1.  协商缓存生效，返回304
+    1.  协商缓存失效，返回200和请求结果结果
+
+![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5e0ce991db4847b98d9f049f9ffa5c93~tplv-k3u1fbpfcp-watermark.image)
+
+传送门 ☞ [# 彻底理解浏览器的缓存机制](https://juejin.cn/post/6992843117963509791 "https://juejin.cn/post/6992843117963509791")
+
+
+### HTTP 请求跨域问题
+
+1.  跨域的原理
+
+    **跨域**，是指浏览器不能执行其他网站的脚本。它是由浏览器的`同源策略`造成的。跨域访问是被各大浏览器所默认禁止的。\
+    **同源策略**,是浏览器对 JavaScript 实施的安全限制，只要`协议、域名、端口`有任何一个不同，都被当作是不同的域。\
+    **跨域原理**，即是通过各种方式，`避开浏览器的安全限制`。
+
+1.  解决方案
+
+    最初做项目的时候，使用的是jsonp，但存在一些问题，使用get请求不安全，携带数据较小，后来也用过iframe，但只有主域相同才行，也是存在些问题，后来通过了解和学习发现使用代理和proxy代理配合起来使用比较方便，就引导后台按这种方式做下服务器配置，在开发中使用proxy，在服务器上使用nginx代理，这样开发过程中彼此都方便，效率也高；现在h5新特性还有 windows.postMessage()
+
+    -   **JSONP**：\
+        ajax 请求受同源策略影响，不允许进行跨域请求，而 script 标签 src 属性中的链 接却可以访问跨域的 js 脚本，利用这个特性，服务端不再返回 JSON 格式的数据，而是 返回一段调用某个函数的 js 代码，在 src 中进行了调用，这样实现了跨域。
+
+        步骤：
+
+        1.  去创建一个script标签
+        1.  script的src属性设置接口地址
+        1.  接口参数，必须要带一个自定义函数名，要不然后台无法返回数据
+        1.  通过定义函数名去接受返回的数据
+
+        ```js
+        //动态创建 script
+        var script = document.createElement('script');
+
+        // 设置回调函数
+        function getData(data) {
+            console.log(data);
+        }
+
+        //设置 script 的 src 属性，并设置请求地址
+        script.src = 'http://localhost:3000/?callback=getData';
+
+        // 让 script 生效
+        document.body.appendChild(script);
+        ```
+
+        **JSONP 的缺点**:\
+        JSON 只支持 get，因为 script 标签只能使用 get 请求； JSONP 需要后端配合返回指定格式的数据。
+
+    -   **document.domain** 基础域名相同 子域名不同
+
+    -   **window.name** 利用在一个浏览器窗口内，载入所有的域名都是共享一个window.name
+
+    -   **CORS** 
+    CORS(Cross-origin resource sharing)跨域资源共享 是一种机制，是目前主流的跨域解决方案，它使用额外的 HTTP 头来告诉浏览器 让运行在一个 origin (domain) 上的Web应用被准许访问来自不同源服务器上的指定的资源。服务器设置对CORS的支持原理：服务器设置Access-Control-Allow-Origin HTTP响应头之后，浏览器将会允许跨域请求
+        
+        1.浏览器端会自动向请求头添加origin字段，表明当前请求来源。\
+        2.服务器设置Access-Control-Allow-Origin、Access-Control-Allow-Methods、Access-Control-Allow-Headers等 HTTP响应头字段之后，浏览器将会允许跨域请求。
+
+        **预检**
+
+        但是还有复杂一点的请求，我们需要先发OPTIONS请求，a.com想请求b.com它需要发一个自定义的Headers：X-ABC和content-type，这个时候就不是简单请求了， a.com要给b.com 发一个options请求，它其实在问b.com我用post行不行，还想在Headers中带X-ABC和content-type；并不是所有的headers都发这个OPTIONS请求，因为X-ABC是自定义的，所以需要发；b.com看到OPTIONS请求，先不会返回数据，先检查自己的策略，看看能不能支持这次请求，如果支持就返回200。
+
+        OPTIONS请求返回以下报文
+
+        HTTP/2.0 20 OK
+        Access-Control-Allow-Origin:https://a.com
+        Access-Control-Allow-Methods:POST,GET,OPTIONS
+        Access-Control-Allow-Headers:X-ABC,Content-Type
+            Access-Control-Max-Age:86400 // 告诉浏览器这个策略生效时间为一个小时，在一个小时之内发送类似的请求，不用在问服务端了，相当于缓存了
+        浏览器收到了OPTIONS的返回，会在发一次，这一次才是真正的请求数据，这次headers会带上X-ABC、contentType。
+
+        整体的过程cors将请求分为2种，简单请求和复杂请求，需不需要发送OPTIONS浏览器说的算，浏览器判断是简单请求还是复杂请求，cors是非常广泛的跨域手段 这里的缺点是OPTIONS请求也是一次请求，消耗带宽，真正的请求也会延迟。
+
+
+    - 最方便的跨域方案 **proxy代理+ Nginx**
+        nginx是一款极其强大的web服务器，其优点就是轻量级、启动快、高并发。
+
+        跨域问题的产生是因为浏览器的同源政策造成的，但是服务器与服务器之间的数据交换是没有这个限制。
+
+        反向代理就是采用这种方式，建立一个虚拟的代理服务器来接收 internet 上的链接请求，然后转发给内部网络上的服务器，并将从服务器上得到的结果，返回给 internet 上请求链接的客户端。现在的新项目中nginx几乎是首选，我们用node或者java开发的服务通常都需要经过nginx的反向代理。
+
+    -   **window.postMessage()** 利用h5新特性window.postMessage()
+
+跨域传送门 ☞ [# 跨域，不可不知的基础概念](https://juejin.cn/post/7003232769182547998)
+
+
+### 粘包问题分析与对策
+
+TCP粘包是指发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。
+
+**粘包出现原因**
+
+简单得说，在流传输中出现，UDP不会出现粘包，因为它有**消息边界**
+
+粘包情况有两种，一种是`粘在一起的包都是完整的数据包`，另一种情况是`粘在一起的包有不完整的包`。
+
+为了**避免粘包**现象，可采取以下几种措施：
+
+（1）对于发送方引起的粘包现象，用户可通过编程设置来避免，`TCP提供了强制数据立即传送的操作指令push`，TCP软件收到该操作指令后，就立即将本段数据发送出去，而不必等待发送缓冲区满；
+
+（2）对于接收方引起的粘包，则可通过优化程序设计、精简接收进程工作量、`提高接收进程优先级等措施`，使其及时接收数据，从而尽量避免出现粘包现象；
+
+（3）由接收方控制，将一包数据按结构字段，人为控制分多次接收，然后合并，通过这种手段来避免粘包。`分包多发`。
+
+以上提到的三种措施，都有其不足之处。
+
+（1）第一种编程设置方法虽然可以避免发送方引起的粘包，但它关闭了优化算法，降低了网络发送效率，影响应用程序的性能，一般不建议使用。
+
+（2）第二种方法只能减少出现粘包的可能性，但并不能完全避免粘包，当发送频率较高时，或由于网络突发可能使某个时间段数据包到达接收方较快，接收方还是有可能来不及接收，从而导致粘包。
+
+（3）第三种方法虽然避免了粘包，但应用程序的效率较低，对实时应用的场合不适合。
+
+> 一种比较周全的对策是：接收方创建一预处理线程，对接收到的数据包进行预处理，将粘连的包分开。实验证明这种方法是高效可行的。
+
+
+### 客户端与服务端长连接的几种方式
+
+1. **ajax 轮询**
+    **实现原理**：ajax 轮询指客户端每间隔一段时间向服务端发起请求，保持数据的同步。
+
+    **优点**：可实现基础（指间隔时间较短）的数据更新。
+
+    **缺点**：这种方法也只是尽量的模拟即时传输，但并非真正意义上的即时通讯，很有可能出现客户端请求时，服务端数据并未更新。或者服务端数据已更新，但客户端未发起请求。导致多次请求资源浪费，效率低下。【`数据更新不及时，效率低下`】
+
+2. **long poll 长轮询**
+
+    **实现原理**：
+    long poll 指的是客户端发送请求之后，如果没有数据返回，服务端会将请求挂起放入队列（不断开连接）处理其他请求，直到有数据返回给客户端。然后客户端再次发起请求，以此轮询。在 HTTP1.0 中客户端可以设置请求头 Connection:keep-alive，服务端收到该请求头之后知道这是一个长连接，在响应报文头中也添加 Connection:keep-alive。客户端收到之后表示长连接建立完成，可以继续发送其他的请求。在 HTTP1.1 中默认使用了 Connection:keep-alive 长连接。
+
+    **优点**：减少客户端的请求，降低无效的网络传输，保证每次请求都有数据返回，不会一直占用线程。
+
+    **缺点**：无法处理高并发，当客户端请求量大，请求频繁时对服务器的处理能力要求较高。服务器一直保持连接会消耗资源，需要同时维护多个线程，服务器所能承载的 TCP 连接数是有上限的，这种轮询很容易把连接数顶满。每次通讯都需要客户端发起，服务端不能主动推送。【`无法处理高并发，消耗服务器资源严重，服务端不能主动推送`】
+
+3. **iframe 长连接**
+
+    **实现原理：**\
+    在网页上嵌入一个 iframe 标签，该标签的 src 属性指向一个长连接请求。这样服务端就可以源源不断地给客户端传输信息。保障信息实时更新。
+
+    **优点**：消息及时传输。
+
+    **缺点**：`消耗服务器资源`。
+
+4. **WebSocket**
+
+    **实现原理**：
+    Websocket 实现了客户端与服务端的双向通信，只需要连接一次，就可以相互传输数据，很适合实时通讯、数据实时更新等场景。
+
+    Websocket 协议与 HTTP 协议没有关系，它是一个建立在 TCP 协议上的全新协议，为了兼容 HTTP 握手规范，在握手阶段依然使用 HTTP 协议，握手完成之后，数据通过 TCP 通道进行传输。
+
+    Websoket 数据传输是通过 frame 形式，一个消息可以分成几个片段传输。这样大数据可以分成一些小片段进行传输，不用考虑由于数据量大导致标志位不够的情况。也可以边生成数据边传递消息，提高传输效率。
+
+    **优点**：
+    双向通信。客户端和服务端双方都可以主动发起通讯。
+    没有同源限制。客户端可以与任意服务端通信，不存在跨域问题。
+    数据量轻。第一次连接时需要携带请求头，后面数据通信都不需要带请求头，减少了请求头的负荷。
+    传输效率高。因为只需要一次连接，所以数据传输效率高。
+    
+    **缺点**：
+    长连接需要后端处理业务的代码更稳定，推送消息相对复杂；\
+    长连接受网络限制比较大，需要处理好重连。\
+    兼容性，WebSocket 只支持 IE10 及其以上版本。\
+    服务器长期维护长连接需要一定的成本，各个浏览器支持程度不一；\
+    成熟的 HTTP 生态下有大量的组件可以复用，WebSocket 则没有，遇到异常问题难以快速定位快速解决。【需要后端代码稳定，受网络限制大，兼容性差，维护成本高，生态圈小】
+
+
+### 利用Socket建立网络连接的步骤
+
+建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。
+
+套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。
+
+　　1、服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。
+
+　　2、客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。
+
+　　为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。
+
+　　3、连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式建立连接。
+
+而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。
+
+
+### 非对称加密RSA
+
+简介： 
+1. 对称加密算法又称现代加密算法。 
+2. 非对称加密是计算机通信安全的基石，保证了加密数据不会被破解。 
+3. 非对称加密算法需要两个密钥：公开密钥(publickey) 和私有密(privatekey) 
+4. 公开密钥和私有密钥是一对
+
+如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。 
+如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。
+
+特点： 
+算法强度复杂，安全性依赖于算法与密钥。 
+加密解密速度慢。
+
+与对称加密算法的对比： 
+对称加密只有一种密钥，并且是非公开的，如果要解密就得让对方知道密钥。 
+非对称加密有两种密钥，其中一个是公开的。
+
+RSA应用场景： 
+由于RSA算法的加密解密速度要比对称算法速度慢很多，在实际应用中，通常采取 
+数据本身的加密和解密使用对称加密算法(AES)。 用RSA算法加密并传输对称算法所需的密钥。
+
+
+### HTTP1、HTTP2、HTTP3
+
+HTTP/2 相比于 HTTP/1.1，可以说是大幅度提高了网页的性能，只需要升级到该协议就可以减少很多之前需要做的性能优化工作，虽如此但HTTP/2并非完美的，HTTP/3 就是为了解决 HTTP/2 所存在的一些问题而被推出来的。
+
+
+### **HTTP1.1 的缺陷**
+
+1.  高延迟 — 队头阻塞(Head-Of-Line Blocking)
+
+    `队头阻塞`是指当顺序发送的请求序列中的一个请求因为某种原因被阻塞时，在后面排队的所有请求也一并被阻塞，会导致客户端迟迟收不到数据。
+    
+    针对队头阻塞的解决办法:
+
+    -   `将同一页面的资源分散到不同域名下，提升连接上限`。 
+    -   `合并小文件减少资源数`，使用精灵图。
+    -   `内联(Inlining)资源`是另外一种防止发送很多小图请求的技巧，将图片的原始数据嵌入在CSS文件里面的URL里，减少网络请求次数。
+    -   `减少请求数量`，合并文件。
+
+2.  无状态特性 — 阻碍交互
+
+    `无状态是指协议对于连接状态没有记忆能力`。纯净的 HTTP 是没有 cookie 等机制的，每一个连接都是一个新的连接。
+
+    `Header里携带的内容过大，在一定程度上增加了传输的成本`。且请求响应报文里有大量字段值都是重复的。
+
+3.  明文传输 — 不安全性
+
+    HTTP/1.1在传输数据时，所有`传输的内容都是明文`，客户端和服务器端都无法验证对方的身份，无法保证数据的安全性。
+
+4.  不支持服务端推送
+
+>记忆口诀：队头阻塞高延迟，无状态阻交互，明文传输不安全，服务推送不支持。
+
+**HTTP 1.1 排队问题**
+
+HTTP 1.1多个文件共用一个TCP，这样可以减少tcp握手，这样3个文件就不用握手9次了，不过这样请求文件需要排队，请求和返回都需要排队， 如果第一个文件响应慢，会阻塞后面的文件，这样就产生了对头的等待问题。
+
+有的网站可能会有很多文件，浏览器处于对机器性能的考虑，它不可能让你无限制的发请求建连接，因为建立连接需要占用资源，浏览器不想把用户的网络资源都占用了，所以浏览器最多会建立6个tcp连接；如果有上百个文件可能都需要排队，http2.0正在解决这个问题。
+
+![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8ecdc60670194df7957ee59e1f56701f~tplv-k3u1fbpfcp-watermark.image?)
+
+
+
+### SPDY 协议与 HTTP/2 简介
+
+#### 1、HTTP/2 简介
+
+HTTP/2是现行HTTP协议（HTTP/1.x）的替代，但它不是重写。**HTTP/2基于SPDY，专注于性能，最大的一个目标是在用户和网站间只用一个连接（connection）** 。
+
+#### 2、HTTP/2 新特性
+
+#### 1、二进制传输
+
+`HTTP/2传输数据量的大幅减少,主要有两个原因:以二进制方式传输和Header 压缩`。我们先来介绍二进制传输,HTTP/2 采用二进制格式传输数据，而非HTTP/1.x 里纯文本形式的报文 ，二进制协议解析起来更高效。`HTTP/2 将请求和响应数据分割为更小的帧，并且它们采用二进制编码`。
+
+#### 2、Header 压缩
+
+HTTP/2并没有使用传统的压缩算法，而是开发了专门的"HPACK”算法，在客户端和服务器两端建立“字典”，用索引号表示重复的字符串，还采用哈夫曼编码来压缩整数和字符串，可以达到50%~90%的高压缩率。
+
+#### 3、多路复用
+
+在 HTTP/2 中引入了多路复用的技术。多路复用很好的解决了浏览器限制同一个域名下的请求数量的问题，同时也更容易实现全速传输。
+
+![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f756ad3403bc4fe18e970c56677c796e~tplv-k3u1fbpfcp-watermark.image?)
+
+#### 4、Server Push
+
+HTTP2还在一定程度上改变了传统的“请求-应答”工作模式，服务器不再是完全被动地响应请求，也可以新建“流”主动向客户端发送消息。减少等待的延迟，这被称为"`服务器推送`"（ Server Push，也叫 Cache push）
+
+#### 5、提高安全性
+
+出于兼容的考虑，HTTP/2延续了HTTP/1的“明文”特点，可以像以前一样使用明文传输数据，不强制使用加密通信，不过格式还是二进制，只是不需要解密。
+
+但由于HTTPS已经是大势所趋，而且主流的浏览器Chrome、Firefox等都公开宣布只支持加密的HTTP/2，**所以“事实上”的HTTP/2是加密的**。也就是说，互联网上通常所能见到的HTTP/2都是使用"https”协议名，跑在TLS上面。HTTP/2协议定义了两个字符串标识符：“h2"表示加密的HTTP/2，“h2c”表示明文的HTTP/2。
+
+#### 6、防止对头阻塞
+
+http1.1如果第一个文件阻塞，第二个文件也就阻塞了。
+
+![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b67bd1f793a3425d9e8a415cae9b7863~tplv-k3u1fbpfcp-watermark.image?)
+
+http2.0的解决，把3个请求打包成一个小块发送过去，即使第一个阻塞了，后面2个也可以回来；相当于3个文件同时请求，就看谁先回来谁后回来，阻塞的可能就后回来，对带宽的利用是最高的；但没有解决TCP的对头阻塞，如果TCP发过去的一个分包发丢了，他会重新发一次；http2.0的解决了大文件的阻塞。
+
+![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/77d8ae8e0de44f3aa693f0626a346d4c~tplv-k3u1fbpfcp-watermark.image?)
+
+一个分包请求3个文件，即使第一个阻塞了，第二个也能返回
+
+### HTTP/2 的缺点
+
+虽然 HTTP/2 解决了很多之前旧版本的问题，但它还是存在一个巨大的问题，**主要是底层支撑的 TCP 协议造成的**。HTTP/2的缺点主要有以下几点：
+
+1.  TCP 以及 TCP+TLS 建立连接时延时
+2.  TCP 的队头阻塞并没有彻底解决
+3.  多路复用导致服务器压力上升也容易 Timeout
+
+### HTTP/3 新特性
+
+#### 1、HTTP/3简介
+
+Google 在推SPDY的时候就搞了个基于 UDP 协议的“QUIC”协议，让HTTP跑在QUIC上而不是TCP上。而“HTTP over QUIC”就是HTTP/3，真正“完美”地解决了“队头阻塞”问题。
+
+QUIC 虽然基于 UDP，但是在原本的基础上新增了很多功能，接下来我们重点介绍几个QUIC新功能。
+
+#### 2、QUIC新功能
+
+QUIC基于UDP，而UDP是“无连接”的，根本就不需要“握手”和“挥手”，所以就比TCP来得快。此外QUIC也实现了可靠传输，保证数据一定能够抵达目的地。它还引入了类似HTTP/2的“流”和“多路复用”，单个“流"是有序的，可能会因为丢包而阻塞，但其他“流”不会受到影响。具体来说QUIC协议有以下特点：
+
+- **实现了类似TCP的流量控制、传输可靠性的功能**
+
+    虽然UDP不提供可靠性的传输，但QUIC在UDP的基础之上增加了一层来保证数据可靠性传输。它提供了数据包重传、拥塞控制以及其他一些TCP中存在的特性。
+
+- **实现了快速握手功能**
+
+    由于QUIC是基于UDP的，所以QUIC可以实现使用0-RTT或者1-RTT来建立连接，这意味着QUIC可以用最快的速度来发送和接收数据，这样可以大大提升首次打开页面的速度。**0RTT 建连可以说是 QUIC 相比 HTTP2 最大的性能优势**。
+
+- **集成了TLS加密功能**
+
+- **多路复用，彻底解决TCP中队头阻塞的问题**
+
+    和TCP不同，QUIC实现了在同一物理连接上可以有多个独立的逻辑数据流。实现了数据流的单独传输，就解决了TCP中队头阻塞的问题。
+
+- **连接迁移**
+
+    TCP 是按照 4 要素（客户端 IP、端口, 服务器 IP、端口）确定一个连接的。而 QUIC 则是让客户端生成一个 Connection ID （64 位）来区别不同连接。只要 Connection ID 不变，连接就不需要重新建立，即便是客户端的网络发生变化。由于迁移客户端继续使用相同的会话密钥来加密和解密数据包，QUIC 还提供了迁移客户端的自动加密验证。
+
+### 总结
+
+-   HTTP/1.1有两个主要的缺点：安全不足和性能不高。
+-   HTTP/2完全兼容HTTP/1，是“更安全的HTTP、更快的HTTPS"，二进制传输、头部压缩、多路复用、服务器推送等技术可以充分利用带宽，降低延迟，从而大幅度提高上网体验；
+-   QUIC 基于 UDP 实现，是 HTTP/3 中的底层支撑协议，该协议基于 UDP，又取了 TCP 中的精华，实现了即快又可靠的协议。
+
+
+### 理解xss，csrf，ddos攻击原理以及避免方式
+
+`XSS`(`Cross-Site Scripting`，**跨站脚本攻击**)是一种代码注入攻击。攻击者在目标网站上注入恶意代码，当被攻击者登陆网站时就会执行这些恶意代码，这些脚本可以读取 `cookie，session tokens`，或者其它敏感的网站信息，对用户进行钓鱼欺诈，甚至发起蠕虫攻击等。
+
+`CSRF`（`Cross-site request forgery`）**跨站请求伪造**：攻击者诱导受害者进入第三方网站，在第三方网站中，向被攻击网站发送跨站请求。利用受害者在被攻击网站已经获取的注册凭证，绕过后台的用户验证，达到冒充用户对被攻击的网站执行某项操作的目的。
+
+**XSS避免方式：**
+
+1.  `url`参数使用`encodeURIComponent`方法转义
+1.  尽量不是有`InnerHtml`插入`HTML`内容
+1.  使用特殊符号、标签转义符。
+
+`CSRF`避免方式：
+
+1.  添加验证码
+
+1.  使用token
+
+    -   服务端给用户生成一个token，加密后传递给用户
+    -   用户在提交请求时，需要携带这个token
+    -   服务端验证token是否正确
+
+`DDoS`又叫分布式拒绝服务，全称 `Distributed Denial of Service`，其原理就是利用大量的请求造成资源过载，导致服务不可用。
+
+**`DDos`避免方式：**
+
+1.  限制单IP请求频率。
+1.  防火墙等防护设置禁止`ICMP`包等
+1.  检查特权端口的开放
+
+
+[360技术：嗨，送你一张Web性能优化地图](https://mp.weixin.qq.com/s?__biz=MzkzNzI0MDMxNQ==&mid=2247487116&idx=1&sn=09187eeb7e45faa1bee86ff48ae14be1&source=41#wechat_redirect)
\ No newline at end of file
diff --git a/02.浏览器.md b/02.浏览器.md
new file mode 100644
index 0000000..069d1e6
--- /dev/null
+++ b/02.浏览器.md
@@ -0,0 +1,342 @@
+
+# 浏览器
+### 从输入URL到页面加载的全过程
+
+![从输入URL到页面加载的主干流程](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e44aa8a92602405db3c12161b71e2094~tplv-k3u1fbpfcp-zoom-1.image)
+
+1.  首先在浏览器中输入URL
+
+1.  查找缓存：浏览器先查看浏览器缓存-系统缓存-路由缓存中是否有该地址页面，如果有则显示页面内容。如果没有则进行下一步。
+
+    -   浏览器缓存：浏览器会记录DNS一段时间，因此，只是第一个地方解析DNS请求；
+    -   操作系统缓存:如果在浏览器缓存中不包含这个记录，则会使系统调用操作系统， 获取操作系统的记录(保存最近的DNS查询缓存)；
+    -   路由器缓存：如果上述两个步骤均不能成功获取DNS记录，继续搜索路由器缓存；
+    -   ISP缓存：若上述均失败，继续向ISP搜索。
+
+1.  DNS域名解析：浏览器向DNS服务器发起请求，解析该URL中的域名对应的IP地址。`DNS服务器是基于UDP的，因此会用到UDP协议`。
+
+1.  建立TCP连接：解析出IP地址后，根据IP地址和默认80端口，和服务器建立TCP连接
+
+1.  发起HTTP请求：浏览器发起读取文件的HTTP请求，，该请求报文作为TCP三次握手的第三次数据发送给服务器
+
+1.  服务器响应请求并返回结果：服务器对浏览器请求做出响应，并把对应的html文件发送给浏览器
+
+1.  关闭TCP连接：通过四次挥手释放TCP连接
+
+1.  浏览器渲染：客户端（浏览器）解析HTML内容并渲染出来，浏览器接收到数据包后的解析流程为：
+
+    -   构建DOM树：词法分析然后解析成DOM树（dom tree），是由dom元素及属性节点组成，树的根是document对象
+    -   构建CSS规则树：生成CSS规则树（CSS Rule Tree）
+    -   构建render树：Web浏览器将DOM和CSSOM结合，并构建出渲染树（render tree）
+    -   布局（Layout）：计算出每个节点在屏幕中的位置
+    -   绘制（Painting）：即遍历render树，并使用UI后端层绘制每个节点。
+
+    ![浏览器渲染流程图](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a90660027f0d4c559732519bad4c6323~tplv-k3u1fbpfcp-zoom-1.image)
+
+1.  JS引擎解析过程：调用JS引擎执行JS代码（JS的解释阶段，预处理阶段，执行阶段生成执行上下文，VO，作用域链、回收机制等等）
+
+    -   创建window对象：window对象也叫全局执行环境，当页面产生时就被创建，所有的全局变量和函数都属于window的属性和方法，而DOM Tree也会映射在window的doucment对象上。当关闭网页或者关闭浏览器时，全局执行环境会被销毁。
+    -   加载文件：完成js引擎分析它的语法与词法是否合法，如果合法进入预编译
+    -   预编译：在预编译的过程中，浏览器会寻找全局变量声明，把它作为window的属性加入到window对象中，并给变量赋值为'undefined'；寻找全局函数声明，把它作为window的方法加入到window对象中，并将函数体赋值给他（匿名函数是不参与预编译的，因为它是变量）。而变量提升作为不合理的地方在ES6中已经解决了，函数提升还存在。
+    -   解释执行：执行到变量就赋值，如果变量没有被定义，也就没有被预编译直接赋值，在ES5非严格模式下这个变量会成为window的一个属性，也就是成为全局变量。string、int这样的值就是直接把值放在变量的存储空间里，object对象就是把指针指向变量的存储空间。函数执行，就将函数的环境推入一个环境的栈中，执行完成后再弹出，控制权交还给之前的环境。JS作用域其实就是这样的执行流机制实现的。
+
+传送门 ☞ [# DNS域名解析过程](https://juejin.cn/post/7005468491067162655) ☞[# 浏览器的工作原理](https://juejin.cn/post/6992597760935460901)
+
+
+### 在浏览器中输入URL到显示页面经历哪些过程，涉及到哪些协议？
+浏览器要将URL解析为IP地址，解析域名就要用到DNS协议，首先主机会查询DNS的缓存，如果没有就给本地DNS发送查询请求。DNS查询分为两种方式，一种是递归查询，一种是迭代查询。如果是迭代查询，本地的DNS服务器，向根域名服务器发送查询请求，根域名服务器告知该域名的一级域名服务器，然后本地服务器给该一级域名服务器发送查询请求，然后依次类推直到查询到该域名的IP地址。`DNS服务器是基于UDP的，因此会用到UDP协议。`
+
+得到IP地址后，浏览器就要与服务器建立一个http连接。因此要用到http协议。http生成一个get请求报文，将该报文传给TCP层处理，所以还会用到TCP协议。如果采用https还会使用https协议先对http数据进行加密。TCP层如果有需要先将HTTP数据包分片，分片依据路径MTU和MSS。TCP的数据包然后会发送给IP层，用到IP协议。IP层通过路由选路，一跳一跳发送到目的地址。当然在一个网段内的寻址是通过以太网协议实现(也可以是其他物理层协议，比如PPP，SLIP)，以太网协议需要直到目的IP地址的物理地址，有需要ARP协议。
+
+其中：
+
+1、`DNS协议，http协议，https协议属于应用层`
+
+应用层是体系结构中的最高层。应用层确定进程之间通信的性质以满足用户的需要。这里的进程就是指正在运行的程序。应用层不仅要提供应用进程所需要的信息交换和远地操作，而且还要作为互相作用的应用进程的用户代理，来完成一些为进行语义上有意义的信息交换所必须的功能。应用层直接为用户的应用进程提供服务。
+
+2、`TCP/UDP属于传输层`
+
+传输层的任务就是负责主机中两个进程之间的通信。因特网的传输层可使用两种不同协议：即面向连接的传输控制协议TCP，和无连接的用户数据报协议UDP。面向连接的服务能够提供可靠的交付，但无连接服务则不保证提供可靠的交付，它只是“尽最大努力交付”。这两种服务方式都很有用，备有其优缺点。在分组交换网内的各个交换结点机都没有传输层。
+
+3、`IP协议，ARP协议属于网络层`
+
+网络层负责为分组交换网上的不同主机提供通信。在发送数据时，网络层将运输层产生的报文段或用户数据报封装成分组或包进行传送。在TCP/IP体系中，分组也叫作IP数据报，或简称为数据报。网络层的另一个任务就是要选择合适的路由，使源主机运输层所传下来的分组能够交付到目的主机。
+
+4、数据链路层
+
+当发送数据时，数据链路层的任务是将在网络层交下来的IP数据报组装成帧，在两个相邻结点间的链路上传送以帧为单位的数据。每一帧包括数据和必要的控制信息（如同步信息、地址信息、差错控制、以及流量控制信息等）。控制信息使接收端能够知道—个帧从哪个比特开始和到哪个比特结束。控制信息还使接收端能够检测到所收到的帧中有无差错。
+
+5、物理层
+
+物理层的任务就是透明地传送比特流。在物理层上所传数据的单位是比特。传递信息所利用的一些物理媒体，如双绞线、同轴电缆、光缆等，并不在物理层之内而是在物理层的下面。因此也有人把物理媒体当做第0层。
+
+### 浏览器的主要功能
+
+浏览器的主要功能就是向服务器发出请求，在浏览器窗口中展示您选择的网络资源。这里所说的资源一般是指 HTML 文档，也可以是 PDF、图片或其他的类型。资源的位置由用户使用 URI（统一资源标示符）指定。
+
+### 浏览器的工作原理
+渲染引擎一开始会从网络层获取请求文档的内容，内容的大小一般限制在 8000 个块以内。
+
+然后进行如下所示的基本流程：
+
+![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9ef6cb226b374e89914a2315e4ca9ba9~tplv-k3u1fbpfcp-zoom-1.image)
+
+图：渲染引擎的基本流程。
+
+渲染引擎将开始`解析 HTML 文档`，并将各标记逐个转化成“内容树”上的 [DOM](https://link.juejin.cn?target=https%3A%2F%2Fwww.html5rocks.com%2Fzh%2Ftutorials%2Finternals%2Fhowbrowserswork%2F%23DOM "https://www.html5rocks.com/zh/tutorials/internals/howbrowserswork/#DOM") 节点。同时也会`解析外部 CSS 文件以及样式元素中的样式数据`。HTML 中这些带有视觉指令的样式信息将用于创建另一个树结构：[`渲染树`](https://link.juejin.cn?target=https%3A%2F%2Fwww.html5rocks.com%2Fzh%2Ftutorials%2Finternals%2Fhowbrowserswork%2F%23Render_tree_construction "https://www.html5rocks.com/zh/tutorials/internals/howbrowserswork/#Render_tree_construction")。
+
+渲染树包含多个带有视觉属性（如颜色和尺寸）的矩形。这些矩形的排列顺序就是它们将在屏幕上显示的顺序。
+
+渲染树构建完毕之后，进入“[布局](https://link.juejin.cn?target=https%3A%2F%2Fwww.html5rocks.com%2Fzh%2Ftutorials%2Finternals%2Fhowbrowserswork%2F%23layout "https://www.html5rocks.com/zh/tutorials/internals/howbrowserswork/#layout")”处理阶段，也就是为每个节点分配一个应出现在屏幕上的确切坐标。下一个阶段是[绘制](https://link.juejin.cn?target=https%3A%2F%2Fwww.html5rocks.com%2Fzh%2Ftutorials%2Finternals%2Fhowbrowserswork%2F%23Painting "https://www.html5rocks.com/zh/tutorials/internals/howbrowserswork/#Painting") - 渲染引擎会遍历渲染树，由用户界面后端层将每个节点绘制出来。
+
+需要着重指出的是，这是一个渐进的过程。为达到更好的用户体验，渲染引擎会力求尽快将内容显示在屏幕上。它不必等到整个 HTML 文档解析完毕之后，就会开始构建呈现树和设置布局。在不断接收和处理来自网络的其余内容的同时，渲染引擎会将部分内容解析并显示出来。
+
+### 浏览器的主要组成部分是什么？
+
+1.  **用户界面** - 包括地址栏、前进/后退按钮、书签菜单等。除了浏览器主窗口显示的您请求的页面外，其他显示的各个部分都属于用户界面。
+1.  **浏览器引擎** - 在用户界面和呈现引擎之间传送指令。
+1.  **呈现引擎** - 负责显示请求的内容。如果请求的内容是 HTML，它就负责解析 HTML 和 CSS 内容，并将解析后的内容显示在屏幕上。
+1.  **网络** - 用于网络调用，比如 HTTP 请求。其接口与平台无关，并为所有平台提供底层实现。
+1.  **用户界面后端** - 用于绘制基本的窗口小部件，比如组合框和窗口。其公开了与平台无关的通用接口，而在底层使用操作系统的用户界面方法。
+1.  **JavaScript 解释器**。用于解析和执行 JavaScript 代码。
+1.  **数据存储**。这是持久层。浏览器需要在硬盘上保存各种数据，例如 Cookie。新的 HTML 规范 (HTML5) 定义了“网络数据库”，这是一个完整（但是轻便）的浏览器内数据库。
+![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f83cb61cb9de4a65abeb95e50608af48~tplv-k3u1fbpfcp-watermark.awebp)
+
+图：浏览器的主要组件。
+
+值得注意的是，和大多数浏览器不同，Chrome 浏览器的每个标签页都分别对应一个呈现引擎实例。每个标签页都是一个独立的进程。
+
+### 浏览器是如何渲染UI的？
+
+1.  浏览器获取HTML文件，然后对文件进行解析，形成DOM Tree
+1.  与此同时，进行CSS解析，生成Style Rules
+1.  接着将DOM Tree与Style Rules合成为 Render Tree
+1.  接着进入布局（Layout）阶段，也就是为每个节点分配一个应出现在屏幕上的确切坐标
+1.  随后调用GPU进行绘制（Paint），遍历Render Tree的节点，并将元素呈现出来
+
+![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/67b1336692f540c9a81756f93e82c2f5~tplv-k3u1fbpfcp-watermark.image)
+
+### DOM Tree是如何构建的？
+
+1.  转码: 浏览器将接收到的二进制数据按照指定编码格式转化为HTML字符串
+1.  生成Tokens: 之后开始parser，浏览器会将HTML字符串解析成Tokens
+1.  构建Nodes: 对Node添加特定的属性，通过指针确定 Node 的父、子、兄弟关系和所属 treeScope
+1.  生成DOM Tree: 通过node包含的指针确定的关系构建出DOM\
+    Tree
+
+![2019-06-22-11-48-00](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1dc0f577836c4705bb582b2ac15bc5d1~tplv-k3u1fbpfcp-zoom-1.image)
+
+### 浏览器重绘与重排的区别？
+
+-   `重排/回流（Reflow）`：当`DOM`的变化影响了元素的几何信息，浏览器需要重新计算元素的几何属性，将其安放在界面中的正确位置，这个过程叫做重排。表现为重新生成布局，重新排列元素。
+-   `重绘(Repaint)`: 当一个元素的外观发生改变，但没有改变布局,重新把元素外观绘制出来的过程，叫做重绘。表现为某些元素的外观被改变
+
+单单改变元素的外观，肯定不会引起网页重新生成布局，但当浏览器完成重排之后，将会重新绘制受到此次重排影响的部分
+
+重排和重绘代价是高昂的，它们会破坏用户体验，并且让UI展示非常迟缓，而相比之下重排的性能影响更大，在两者无法避免的情况下，一般我们宁可选择代价更小的重绘。
+
+『重绘』不一定会出现『重排』，『重排』必然会出现『重绘』。
+
+
+### 如何触发重排和重绘？
+
+任何改变用来构建渲染树的信息都会导致一次重排或重绘：
+
+-   添加、删除、更新DOM节点
+-   通过display: none隐藏一个DOM节点-触发重排和重绘
+-   通过visibility: hidden隐藏一个DOM节点-只触发重绘，因为没有几何变化
+-   移动或者给页面中的DOM节点添加动画
+-   添加一个样式表，调整样式属性
+-   用户行为，例如调整窗口大小，改变字号，或者滚动。
+
+### 如何避免重绘或者重排？
+
+1.  `集中改变样式`，不要一条一条地修改 DOM 的样式。
+
+1.  不要把 DOM 结点的属性值放在循环里当成循环里的变量。
+
+1.  为动画的 HTML 元件使用 `fixed` 或 `absoult` 的 `position`，那么修改他们的 CSS 是不会 reflow 的。
+
+1.  不使用 table 布局。因为可能很小的一个小改动会造成整个 table 的重新布局。
+
+1.  尽量只修改`position：absolute`或`fixed`元素，对其他元素影响不大
+
+1.  动画开始`GPU`加速，`translate`使用`3D`变化
+
+1.  提升为合成层
+
+    将元素提升为合成层有以下优点：
+
+    -   合成层的位图，会交由 GPU 合成，比 CPU 处理要快
+    -   当需要 repaint 时，只需要 repaint 本身，不会影响到其他的层
+    -   对于 transform 和 opacity 效果，不会触发 layout 和 paint
+
+    提升合成层的最好方式是使用 CSS 的 will-change 属性：
+
+    ```
+    #target {
+      will-change: transform;
+    }
+    ```
+
+    > 关于合成层的详解请移步[无线性能优化：Composite](https://link.juejin.cn?target=http%3A%2F%2Ftaobaofed.org%2Fblog%2F2016%2F04%2F25%2Fperformance-composite%2F "http://taobaofed.org/blog/2016/04/25/performance-composite/")
+
+
+
+
+### 介绍下304过程
+
+-   a. 浏览器请求资源时首先命中资源的Expires 和 Cache-Control，Expires 受限于本地时间，如果修改了本地时间，可能会造成缓存失效，可以通过Cache-control: max-age指定最大生命周期，状态仍然返回200，但不会请求数据，在浏览器中能明显看到from cache字样。
+-   b. 强缓存失效，进入协商缓存阶段，首先验证ETagETag可以保证每一个资源是唯一的，资源变化都会导致ETag变化。服务器根据客户端上送的If-None-Match值来判断是否命中缓存。
+-   c. 协商缓存Last-Modify/If-Modify-Since阶段，客户端第一次请求资源时，服务服返回的header中会加上Last-Modify，Last-modify是一个时间标识该资源的最后修改时间。再次请求该资源时，request的请求头中会包含If-Modify-Since，该值为缓存之前返回的Last-Modify。服务器收到If-Modify-Since后，根据资源的最后修改时间判断是否命中缓存。
+
+### 浏览器的缓存机制 强制缓存 && 协商缓存
+
+
+浏览器与服务器通信的方式为应答模式，即是：浏览器发起HTTP请求 – 服务器响应该请求。那么浏览器第一次向服务器发起该请求后拿到请求结果，会根据响应报文中HTTP头的缓存标识，决定是否缓存结果，是则将请求结果和缓存标识存入浏览器缓存中，简单的过程如下图：
+
+![图片](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/487144abaada4b9a8b34bc9375191ec7~tplv-k3u1fbpfcp-zoom-1.image)
+
+由上图我们可以知道：
+
+-   浏览器每次发起请求，都会`先在浏览器缓存中查找该请求的结果以及缓存标识`
+-   浏览器每次拿到返回的请求结果都会`将该结果和缓存标识存入浏览器缓存中`
+
+以上两点结论就是浏览器缓存机制的关键，他确保了每个请求的缓存存入与读取，只要我们再理解浏览器缓存的使用规则，那么所有的问题就迎刃而解了。为了方便理解，这里根据是否需要向服务器重新发起HTTP请求将缓存过程分为两个部分，分别是`强制缓存`和`协商缓存`。
+
+- **强制缓存**
+
+    `强制缓存就是向浏览器缓存查找该请求结果，并根据该结果的缓存规则来决定是否使用该缓存结果的过程。`当浏览器向服务器发起请求时，服务器会将缓存规则放入HTTP响应报文的HTTP头中和请求结果一起返回给浏览器，控制强制缓存的字段分别是 `Expires` 和 `Cache-Control`，其中Cache-Control优先级比Expires高。
+
+    强制缓存的情况主要有三种(暂不分析协商缓存过程)，如下：
+
+    1.  不存在该缓存结果和缓存标识，强制缓存失效，则直接向服务器发起请求（跟第一次发起请求一致）。
+     1.  存在该缓存结果和缓存标识，但该结果已失效，强制缓存失效，则使用协商缓存。
+     1.  存在该缓存结果和缓存标识，且该结果尚未失效，强制缓存生效，直接返回该结果
+
+- **协商缓存**
+
+    `协商缓存就是强制缓存失效后，浏览器携带缓存标识向服务器发起请求，由服务器根据缓存标识决定是否使用缓存的过程`，同样，协商缓存的标识也是在响应报文的HTTP头中和请求结果一起返回给浏览器的，控制协商缓存的字段分别有：`Last-Modified / If-Modified-Since` 和 `Etag / If-None-Match`，其中Etag / If-None-Match的优先级比Last-Modified / If-Modified-Since高。协商缓存主要有以下两种情况：
+
+    1. 协商缓存生效，返回304
+    2. 协商缓存失效，返回200和请求结果结果
+
+传送门 ☞ [# 彻底理解浏览器的缓存机制](https://juejin.cn/post/6992843117963509791)
+
+### Cookie、sessionStorage、localStorage 的区别
+
+**相同点**：
+
+-   存储在客户端
+
+**不同点**：
+
+-   cookie数据大小不能超过4k；sessionStorage和localStorage的存储比cookie大得多，可以达到5M+
+-   cookie设置的过期时间之前一直有效；localStorage永久存储，浏览器关闭后数据不丢失除非主动删除数据；sessionStorage数据在当前浏览器窗口关闭后自动删除
+-   cookie的数据会自动的传递到服务器；sessionStorage和localStorage数据保存在本地
+
+### 说下进程、线程和协程
+
+**进程**是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，`是操作系统进行资源分配和调度的一个独立单位`，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。
+
+**线程**是程序执行中一个单一的顺序控制流程，是`程序执行流的最小单元`，是处理器调度和分派的基本单位。一个进程可以有一个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。一个标准的线程由线程ID、当前指令指针(PC)、寄存器和堆栈组成。而进程由内存空间(代码、数据、进程空间、打开的文件)和一个或多个线程组成。
+
+**协程**，英文Coroutines，是一种`基于线程之上，但又比线程更加轻量级的存在`，这种由程序员自己写程序来管理的轻量级线程叫做『用户空间线程』，具有对内核来说不可见的特性。
+
+**进程和线程的区别与联系**
+
+【区别】：
+
+调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位；
+
+并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行；
+
+拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
+
+系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。但是进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个进程死掉就等于所有的线程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。
+
+【联系】：
+
+一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程；
+
+资源分配给进程，同一进程的所有线程共享该进程的所有资源；
+
+处理机分给线程，即真正在处理机上运行的是线程；
+
+线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
+
+传送门 ☞ [# 一文搞懂进程、线程、协程及JS协程的发展](https://juejin.cn/post/7005465381791875109)
+[☞了解更多](http://www.360doc.com/content/20/0417/14/32196507_906628857.shtml)
+
+关于浏览器传送门 ☞[# 深入了解现代 Web 浏览器](https://juejin.cn/post/6993095345576083486)
+
+
+### 进程间的通信方式
+
+`进程通信`：
+每个进程各自有不同的用户地址空间,任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程A把数据从用户空间拷到内核缓冲区,进程B再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信。
+
+进程间的通信方式：管道、有名管道、信号、消息队列、共享内存、信号量、socket
+
+`匿名管道( pipe )`： 管道是一种半双工的通信方式，数据只能**单向流动**，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指**父子进程关系**。
+
+`高级管道(popen)`：将另一个程序当做一个新的进程在当前程序进程中启动，则它算是当前程序的子进程，这种方式我们成为高级管道方式。
+
+`有名管道 (named pipe) `： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
+
+`消息队列( message queue )` ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
+
+`信号量( semophore )` ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
+
+`信号 ( sinal )` ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
+
+`共享内存( shared memory )` ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
+
+`套接字( socket ) 通信`： 套接口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同机器间的进程通信
+
+
+### 浏览器样式兼容
+
+#### 一、CSS初始化
+
+每个浏览器的css默认样式不尽相同，所以最简单有效的方式就是对其进行初始化（覆盖默认样式）
+
+> 常见 :  *{ margin: 0; padding: 0;}
+>
+> 库：normalize.css
+
+#### 二、**浏览器私有属性**
+
+> 常用的前缀有：
+>
+> firefox浏览器 ：-moz-
+>
+> chrome、safari ：-webkit-
+>
+> opera ：-o- / -xv-
+>
+> IE浏览器 ：-ms-（目前只有 IE 8+支持）
+#### **三、CSS hack（条件hack、属性级hack、选择符级hack）**
+
+
+### JS垃圾回收机制
+
+1.  项目中，如果存在大量不被释放的内存（堆/栈/上下文），页面性能会变得很慢。当某些代码操作不能被合理释放，就会造成内存泄漏。我们尽可能减少使用闭包，因为它会消耗内存。
+
+1.  浏览器垃圾回收机制/内存回收机制:
+
+    > 浏览器的`Javascript`具有自动垃圾回收机制(`GC:Garbage Collecation`)，垃圾收集器会定期（周期性）找出那些不在继续使用的变量，然后释放其内存。
+
+    **标记清除**:在`js`中，最常用的垃圾回收机制是标记清除：当变量进入执行环境时，被标记为“进入环境”，当变量离开执行环境时，会被标记为“离开环境”。垃圾回收器会销毁那些带标记的值并回收它们所占用的内存空间。\
+    **谷歌浏览器**：“查找引用”，浏览器不定时去查找当前内存的引用，如果没有被占用了，浏览器会回收它；如果被占用，就不能回收。\
+    **IE浏览器**：“引用计数法”，当前内存被占用一次，计数累加1次，移除占用就减1，减到0时，浏览器就回收它。
+
+1.  优化手段：内存优化 ; 手动释放：取消内存的占用即可。
+
+    （1）堆内存：fn = null 【null：空指针对象】
+
+    （2）栈内存：把上下文中，被外部占用的堆的占用取消即可。
+
+1.  内存泄漏
+
+    在 JS 中，常见的内存泄露主要有 4 种,全局变量、闭包、DOM 元素的引用、定时器
\ No newline at end of file
diff --git a/03.HTML && CSS.md b/03.HTML && CSS.md
new file mode 100644
index 0000000..28acc16
--- /dev/null
+++ b/03.HTML && CSS.md	
@@ -0,0 +1,389 @@
+## HTML && CSS
+
+### HTML5 新特性、语义化
+
+1.  **概念**：
+
+    HTML5的语义化指的是`合理正确的使用语义化的标签来创建页面结构`。【正确的标签做正确的事】
+
+1.  **语义化标签**：
+
+    header nav main article section aside footer
+
+1.  **语义化的优点**:
+
+    -   在`没CSS样式的情况下，页面整体也会呈现很好的结构效果`
+    -   `代码结构清晰`，易于阅读，
+    -   `利于开发和维护` 方便其他设备解析（如屏幕阅读器）根据语义渲染网页。
+    -   `有利于搜索引擎优化（SEO）`，搜索引擎爬虫会根据不同的标签来赋予不同的权重
+
+
+### HTML5新特性有哪些
+
+- 语义化标签
+- 音视频处理API(audio,video)
+- canvas / webGL
+- 拖拽释放(Drag and drop) API
+- history API
+- requestAnimationFrame
+- 地理位置(Geolocation)API
+- webSocket
+- web存储 localStorage、SessionStorage
+- 表单控件，calendar、date、time、email、url、search
+
+
+### CSS 选择器及优先级
+
+**选择器**
+
+-   id选择器(#myid)
+-   类选择器(.myclass)
+-   属性选择器(a[rel="external"])
+-   伪类选择器(a:hover, li:nth-child)
+-   标签选择器(div, h1,p)
+-   相邻选择器（h1 + p）
+-   子选择器(ul > li)
+-   后代选择器(li a)
+-   通配符选择器(*)
+
+**优先级：**
+
+-   `!important`
+-   内联样式（1000）
+-   ID选择器（0100）
+-   类选择器/属性选择器/伪类选择器（0010）
+-   元素选择器/伪元素选择器（0001）
+-   关系选择器/通配符选择器（0000）
+
+带!important 标记的样式属性优先级最高； 样式表的来源相同时：
+`!important > 行内样式>ID选择器 > 类选择器 > 标签 > 通配符 > 继承 > 浏览器默认属性`
+
+
+### 渐进增强与优雅降级的理解及区别
+
+**渐进增强（Progressive Enhancement）：**
+一开始就针对低版本浏览器进行构建页面，完成基本的功能，然后再针对高级浏览器进行效果、交互、追加功能达到更好的体验。
+
+**优雅降级（Graceful Degradation）：**
+一开始就构建站点的完整功能，然后针对浏览器测试和修复。比如一开始使用 CSS3 的特性构建了一个应用，然后逐步针对各大浏览器进行 hack 使其可以在低版本浏览器上正常浏览。
+**两者区别**
+1、广义：
+其实要定义一个基准线，在此之上的增强叫做渐进增强，在此之下的兼容叫优雅降级
+2、狭义：
+渐进增强一般说的是使用CSS3技术，在不影响老浏览器的正常显示与使用情形下来增强体验，而优雅降级则是体现html标签的语义，以便在js/css的加载失败/被禁用时，也不影响用户的相应功能。
+
+```css
+/* 例子 */
+.transition { /*渐进增强写法*/
+  -webkit-transition: all .5s;
+     -moz-transition: all .5s;
+       -o-transition: all .5s;
+          transition: all .5s;
+}
+.transition { /*优雅降级写法*/
+          transition: all .5s;
+       -o-transition: all .5s;
+     -moz-transition: all .5s;
+  -webkit-transition: all .5s;
+}
+
+```
+
+
+### 常见的兼容性问题
+
+1. 不同浏览器的标签默认的margin和padding不一样。*{margin:0;padding:0;}
+
+2. IE6双边距bug：块属性标签float后，又有横行的margin情况下，在IE6显示margin比设置的大。hack：display:inline;将其转化为行内属性。
+
+3. 设置较小高度标签（一般小于10px），在IE6，IE7中高度超出自己设置高度。hack：给超出高度的标签设置overflow:hidden;或者设置行高line-height 小于你设置的高度。
+
+4. Chrome 中文界面下默认会将小于 12px 的文本强制按照 12px 显示,可通过加入 CSS 属性 -webkit-text-size-adjust: none; 解决。
+
+5. 超链接访问过后hover样式就不出现了，被点击访问过的超链接样式不再具有hover和active了。解决方法是改变CSS属性的排列顺序:L-V-H-A ( love hate ): a:link {} a:visited {} a:hover {} a:active {}
+
+
+### CSS3新特性
+
+- 过渡
+```js
+/*所有属性从原始值到制定值的一个过渡，运动曲线ease,运动时间0.5秒*/ 
+transition：all,.5s
+```
+- 动画
+```js
+//animation：动画名称，一个周期花费时间，运动曲线（默认ease），动画延迟（默认0），播放次数（默认1），是否反向播放动画（默认normal），是否暂停动画（默认running）
+/*执行一次logo2-line动画，运动时间2秒，运动曲线为 linear*/
+animation: logo2-line 2s linear;
+```
+- 形状转换
+```js
+//transform:适用于2D或3D转换的元素
+//transform-origin：转换元素的位置（围绕那个点进行转换）。默认(x,y,z)：(50%,50%,0)
+transform:translate(30px,30px);
+transform:rotate(30deg);
+transform:scale(.8);
+```
+- 选择器:nth-of-type()
+
+- 阴影
+    文字阴影: text-shadow: 2px 2px 2px #000;(水平阴影，垂直阴影，模糊距离，阴影颜色) 盒子阴影: box-shadow: 10px 10px 5px #999
+- 边框 border-image: url(border.png);
+- 背景
+- 文字
+- 渐变
+- Filter（滤镜）
+- 弹性布局、栅格布局、多列布局
+- 媒体查询
+
+
+### position 属性的值有哪些及其区别
+
+**固定定位 fixed**： 元素的位置相对于浏览器窗口是固定位置，即使窗口是滚动的它也不会移动。Fixed 定 位使元素的位置与文档流无关，因此不占据空间。 Fixed 定位的元素和其他元素重叠。
+
+**相对定位 relative**： 如果对一个元素进行相对定位，它将出现在它所在的位置上。然后，可以通过设置垂直 或水平位置，让这个元素“相对于”它的起点进行移动。 在使用相对定位时，无论是 否进行移动，元素仍然占据原来的空间。因此，移动元素会导致它覆盖其它框。
+
+**绝对定位 absolute**： 绝对定位的元素的位置相对于最近的已定位父元素，如果元素没有已定位的父元素，那 么它的位置相对于。absolute 定位使元素的位置与文档流无关，因此不占据空间。 absolute 定位的元素和其他元素重叠。
+
+**粘性定位 sticky**： 元素先按照普通文档流定位，然后相对于该元素在流中的 flow root（BFC）和 containing block（最近的块级祖先元素）定位。而后，元素定位表现为在跨越特定阈值前为相对定 位，之后为固定定位。
+
+**默认定位 Static**： 默认值。没有定位，元素出现在正常的流中（忽略 top, bottom, left, right 或者 z-index 声 明）。 inherit: 规定应该从父元素继承 position 属性的值。
+
+### box-sizing属性
+
+box-sizing 规定两个并排的带边框的框，语法为 box-sizing：content-box/border-box/inherit
+
+**content-box**：宽度和高度分别应用到元素的内容框，在宽度和高度之外绘制元素的内边距和边框。【标准盒子模型】
+
+**border-box**：为元素设定的宽度和高度决定了元素的边框盒。【IE 盒子模型】
+
+**inherit**：继承父元素的 box-sizing 值。
+
+### CSS 盒子模型
+
+CSS 盒模型本质上是一个盒子，它包括：边距，边框，填充和实际内容。CSS 中的盒子模型包括 IE 盒子模型和标准的 W3C 盒子模型。\
+在标准的盒子模型中，`width 指 content 部分的宽度`。\
+在 IE 盒子模型中，`width 表示 content+padding+border 这三个部分的宽度`。
+
+故在计算盒子的宽度时存在差异：
+
+**标准盒模型：** 一个块的总宽度 = width+margin(左右)+padding(左右)+border(左右)
+
+**怪异盒模型：** 一个块的总宽度 = width+margin（左右）（既 width 已经包含了 padding 和 border 值）
+
+### BFC（块级格式上下文）
+
+**BFC的概念**
+
+`BFC` 是 ` Block Formatting Context  `的缩写，即块级格式化上下文。`BFC`是CSS布局的一个概念，是一个独立的渲染区域，规定了内部box如何布局， 并且这个区域的子元素不会影响到外面的元素，其中比较重要的布局规则有内部 box 垂直放置，计算 BFC 的高度的时候，浮动元素也参与计算。
+
+**BFC的原理布局规则**
+
+-   内部的Box会在`垂直方向`，一个接一个地放置
+-   Box`垂直方向的距离由margin决定`。属于同一个BFC的两个相邻Box的margin会发生重叠
+-   每个元素的margin box的左边， 与包含块border box的左边相接触(对于从左往右的格式化，否则相反
+-   BFC的区域`不会与float box重叠`
+-   BFC是一个独立容器，容器里面的`子元素不会影响到外面的元素`
+-   计算BFC的高度时，`浮动元素也参与计算高度`
+-   元素的类型和`display属性，决定了这个Box的类型`。不同类型的Box会参与不同的`Formatting Context`。
+
+**如何创建BFC？**
+
+-   根元素，即HTML元素
+-   float的值不为none
+-   position为absolute或fixed
+-   display的值为inline-block、table-cell、table-caption
+-   overflow的值不为visible
+
+**BFC的使用场景**
+
+-   去除边距重叠现象
+-   清除浮动（让父元素的高度包含子浮动元素）
+-   避免某元素被浮动元素覆盖
+-   避免多列布局由于宽度计算四舍五入而自动换行
+
+### 让一个元素水平垂直居中
+
+-   **水平居中**
+
+    -   对于 行内元素 : `text-align: center`;
+
+    -   对于确定宽度的块级元素：
+
+        （1）width和margin实现。`margin: 0 auto`;
+
+        （2）绝对定位和margin-left: -width/2, 前提是父元素position: relative
+
+    -   对于宽度未知的块级元素
+
+        （1）`table标签配合margin左右auto实现水平居中`。使用table标签（或直接将块级元素设值为 display:table），再通过给该标签添加左右margin为auto。
+
+        （2）inline-block实现水平居中方法。display：inline-block和text-align:center实现水平居中。
+
+        （3）`绝对定位+transform`，translateX可以移动本身元素的50%。
+
+        （4）flex布局使用`justify-content:center`
+
+-   **垂直居中**
+
+    1.  利用 `line-height` 实现居中，这种方法适合纯文字类
+    1.  通过设置父容器 相对定位 ，子级设置 `绝对定位`，标签通过margin实现自适应居中
+    1.  弹性布局 flex :父级设置display: flex; 子级设置margin为auto实现自适应居中
+    1.  父级设置相对定位，子级设置绝对定位，并且通过位移 transform 实现
+    1.  `table 布局`，父级通过转换成表格形式，`然后子级设置 vertical-align 实现`。（需要注意的是：vertical-align: middle使用的前提条件是内联元素以及display值为table-cell的元素）。
+
+
+传送门 ☞ [# 图解CSS水平垂直居中常见面试方法](https://juejin.cn/post/7008348524530106381)
+
+### 隐藏页面中某个元素的方法
+
+1.`opacity：0`，该元素隐藏起来了，但不会改变页面布局，并且，如果该元素已经绑定 一些事件，如click 事件，那么点击该区域，也能触发点击事件的
+
+2.`visibility：hidden`，该元素隐藏起来了，但不会改变页面布局，但是不会触发该元素已 经绑定的事件 ，隐藏对应元素，在文档布局中仍保留原来的空间（重绘）
+
+3.`display：none`，把元素隐藏起来，并且会改变页面布局，可以理解成在页面中把该元素。 不显示对应的元素，在文档布局中不再分配空间（回流+重绘）
+
+>该问题会引出 回流和重绘
+
+### 用CSS实现三角符号
+
+```css
+/*记忆口诀：盒子宽高均为零，三面边框皆透明。 */
+div:after{
+    position: absolute;
+    width: 0px;
+    height: 0px;
+    content: " ";
+    border-right: 100px solid transparent;
+    border-top: 100px solid #ff0;
+    border-left: 100px solid transparent;
+    border-bottom: 100px solid transparent;
+}
+```
+
+### 页面布局
+
+#### 1.Flex 布局
+
+布局的传统解决方案，基于盒状模型，依赖 display 属性 + position 属性 + float 属性。它对于那些特殊布局非常不方便，比如，垂直居中就不容易实现。
+
+Flex 是 Flexible Box 的缩写，意为"弹性布局",用来为盒状模型提供最大的灵活性。指定容器 display: flex 即可。 简单的分为容器属性和元素属性。
+
+容器的属性：
+
+-   flex-direction：决定主轴的方向（即子 item 的排列方法）flex-direction: row | row-reverse | column | column-reverse;
+-   flex-wrap：决定换行规则 flex-wrap: nowrap | wrap | wrap-reverse;
+-   flex-flow： .box { flex-flow: || ; }
+-   justify-content：对其方式，水平主轴对齐方式
+-   align-items：对齐方式，竖直轴线方向
+-   align-content
+
+项目的属性（元素的属性）：
+
+-   order 属性：定义项目的排列顺序，顺序越小，排列越靠前，默认为 0
+-   flex-grow 属性：定义项目的放大比例，即使存在空间，也不会放大
+-   flex-shrink 属性：定义了项目的缩小比例，当空间不足的情况下会等比例的缩小，如果 定义个 item 的 flow-shrink 为 0，则为不缩小
+-   flex-basis 属性：定义了在分配多余的空间，项目占据的空间。
+-   flex：是 flex-grow 和 flex-shrink、flex-basis 的简写，默认值为 0 1 auto。
+-   align-self：允许单个项目与其他项目不一样的对齐方式，可以覆盖
+-   align-items，默认属 性为 auto，表示继承父元素的 align-items 比如说，用 flex 实现圣杯布局
+
+#### 2.Rem 布局
+
+首先 Rem 相对于根(html)的 font-size 大小来计算。简单的说它就是一个相对单例 如:font-size:10px;,那么（1rem = 10px）了解计算原理后首先解决怎么在不同设备上设置 html 的 font-size 大小。其实 rem 布局的本质是等比缩放，一般是基于宽度。
+
+**优点**：可以快速适用移动端布局，字体，图片高度
+
+**缺点**：
+
+①目前 ie 不支持，对 pc 页面来讲使用次数不多；\
+②数据量大：所有的图片，盒子都需要我们去给一个准确的值；才能保证不同机型的适配；\
+③在响应式布局中，必须通过 js 来动态控制根元素 font-size 的大小。也就是说 css 样式和 js 代码有一定的耦合性。且必须将改变 font-size 的代码放在 css 样式之前。
+
+#### 3.百分比布局
+
+通过百分比单位 " % " 来实现响应式的效果。通过百分比单位可以使得浏览器中的组件的宽和高随着浏览器的变化而变化，从而实现响应式的效果。 直观的理解，我们可能会认为子元素的百分比完全相对于直接父元素，height 百分比相 对于 height，width 百分比相对于 width。 padding、border、margin 等等不论是垂直方向还是水平方向，都相对于直接父元素的 width。 除了 border-radius 外，还有比如 translate、background-size 等都是相对于自身的。
+
+**缺点**：
+
+（1）计算困难\
+（2）各个属性中如果使用百分比，相对父元素的属性并不是唯一的。造成我们使用百分比单位容易使布局问题变得复杂。
+
+#### 4.浮动布局
+
+浮动布局:当元素浮动以后可以向左或向右移动，直到它的外边缘碰到包含它的框或者另外一个浮动元素的边框为止。元素浮动以后会脱离正常的文档流，所以文档的普通流中的框就变的好像浮动元素不存在一样。
+
+**优点**
+
+这样做的优点就是在图文混排的时候可以很好的使文字环绕在图片周围。另外当元素浮动了起来之后，它有着块级元素的一些性质例如可以设置宽高等，但它与inline-block还是有一些区别的，第一个就是关于横向排序的时候，float可以设置方向而inline-block方向是固定的；还有一个就是inline-block在使用时有时会有空白间隙的问题
+
+**缺点**
+
+最明显的缺点就是浮动元素一旦脱离了文档流，就无法撑起父元素，`会造成父级元素高度塌陷`。
+
+### 如何使用rem或viewport进行移动端适配
+
+**rem适配原理：**
+
+改变了一个元素在不同设备上占据的css像素的个数
+
+rem适配的优缺点
+
+-   优点：没有破坏完美视口
+-   缺点：px值转换rem太过于复杂(下面我们使用less来解决这个问题)
+
+**viewport适配的原理**
+
+viewport适配方案中，每一个元素在不同设备上占据的css像素的个数是一样的。但是css像素和物理像素的比例是不一样的，等比的
+
+viewport适配的优缺点
+
+-   在我们设计图上所量取的大小即为我们可以设置的像素大小，即所量即所设
+-   缺点破坏完美视口
+
+### 清除浮动的方式
+
+-   添加额外标签
+
+```html
+<div class="parent">
+    //添加额外标签并且添加clear属性
+    <div style="clear:both"></div>
+    //也可以加一个br标签
+</div>
+```
+
+-   父级添加overflow属性，或者设置高度
+-   建立伪类选择器清除浮动
+
+```js
+//在css中添加:after伪元素
+.parent:after{
+    /* 设置添加子元素的内容是空 */
+    content: '';
+    /* 设置添加子元素为块级元素 */
+    display: block;
+    /* 设置添加的子元素的高度0 */
+    height: 0;
+    /* 设置添加子元素看不见 */
+    visibility: hidden;
+    /* 设置clear：both */
+    clear: both;
+}
+```
+
+
+### CSS预处理器Sass、Less、Stylus的区别
+
+什么事CSS预处理器?
+
+CSS预处理器是一种语言用来为CSS增加一些变成的特性，无需考虑浏览器兼容问题，例如你可以在CSS中使用变量，简单的程序逻辑、函数等在编程语言中的一些基本技巧，可以让CSS更加简洁，适应性更强，代码更直观等诸多好处
+基本语法区别
+
+Sass是以.sass为扩展名，Less是以.less为扩展名，Stylus是以.styl为扩展名
+变量的区别
+
+Sass 变量必须是以`$`开头的，然后变量和值之间使用冒号（：）隔开，和css属性是一样的。
+Less 变量是以` @ `开头的，其余sass都是一样的。
+Stylus 对变量是没有任何设定的，可以是以$开头或者任意字符，而且变量之间可以冒号，空格隔开，但是在stylus中不能用@开头
+三种预处理器都有：嵌套、运算符、颜色函数、导入、继承、混入。Stylus还有一些高级特性。例如循环、判断等
\ No newline at end of file
diff --git a/04.JavaScript.md b/04.JavaScript.md
new file mode 100644
index 0000000..e36acb4
--- /dev/null
+++ b/04.JavaScript.md
@@ -0,0 +1,336 @@
+## JavaScript
+
+
+### JS中的8种数据类型及区别
+
+包括值类型(基本对象类型)和引用类型(复杂对象类型)
+
+**基本类型(值类型)：** Number(数字),String(字符串),Boolean(布尔),Symbol(符号),null(空),undefined(未定义)在内存中占据固定大小，保存在栈内存中
+
+**引用类型(复杂数据类型)：** Object(对象)、Function(函数)。其他还有Array(数组)、Date(日期)、RegExp(正则表达式)、特殊的基本包装类型(String、Number、Boolean) 以及单体内置对象(Global、Math)等 引用类型的值是对象 保存在堆内存中，栈内存存储的是对象的变量标识符以及对象在堆内存中的存储地址。
+
+**使用场景：**
+
+Symbol：使用Symbol来作为对象属性名(key)  利用该特性，把一些不需要对外操作和访问的属性使用Symbol来定义
+
+BigInt：由于在 Number 与 BigInt 之间进行转换会损失精度，因而建议仅在值可能大于253 时使用 BigInt 类型，并且不在两种类型之间进行相互转换。
+
+传送门 ☞[# JavaScript 数据类型之 Symbol、BigInt](https://juejin.cn/post/7000754813801775111)
+### JS中的数据类型检测方案
+
+#### 1.typeof
+
+```js
+console.log(typeof 1);               // number
+console.log(typeof true);            // boolean
+console.log(typeof 'mc');            // string
+console.log(typeof function(){});    // function
+console.log(typeof console.log());   // function
+console.log(typeof []);              // object 
+console.log(typeof {});              // object
+console.log(typeof null);            // object
+console.log(typeof undefined);       // undefined
+```
+
+优点：能够快速区分基本数据类型
+
+缺点：不能将Object、Array和Null区分，都返回object
+
+#### 2.instanceof
+
+```js
+console.log(1 instanceof Number);                    // false
+console.log(true instanceof Boolean);                // false 
+console.log('str' instanceof String);                // false  
+console.log([] instanceof Array);                    // true
+console.log(function(){} instanceof Function);       // true
+console.log({} instanceof Object);                   // true
+```
+
+优点：能够区分Array、Object和Function，适合用于判断自定义的类实例对象
+
+缺点：Number，Boolean，String基本数据类型不能判断
+
+#### 3.Object.prototype.toString.call()
+
+```js
+var toString = Object.prototype.toString;
+console.log(toString.call(1));      //[object Number]
+console.log(toString.call(true));   //[object Boolean]
+console.log(toString.call('mc'));   //[object String]
+console.log(toString.call([]));     //[object Array]
+console.log(toString.call({}));     //[object Object]
+console.log(toString.call(function(){})); //[object Function]
+console.log(toString.call(undefined));  //[object Undefined]
+console.log(toString.call(null)); //[object Null]
+```
+
+优点：精准判断数据类型
+
+缺点：写法繁琐不容易记，推荐进行封装后使用
+
+### var && let && const
+
+ES6之前创建变量用的是var,之后创建变量用的是let/const
+
+**三者区别**：
+
+1.  var定义的变量，`没有块的概念，可以跨块访问`, 不能跨函数访问。\
+    let定义的变量，只能在块作用域里访问，不能跨块访问，也不能跨函数访问。\
+    const用来定义常量，使用时必须初始化(即必须赋值)，只能在块作用域里访问，且不能修改。
+1.  var可以`先使用，后声明`，因为存在变量提升；let必须先声明后使用。
+1.  var是允许在相同作用域内`重复声明同一个变量`的，而let与const不允许这一现象。
+1.  在全局上下文中，基于let声明的全局变量和全局对象GO（window）没有任何关系 ;\
+    var声明的变量会和GO有映射关系；
+1.  `会产生暂时性死区`：
+
+> 暂时性死区是浏览器的bug：检测一个未被声明的变量类型时，不会报错，会返回undefined\
+> 如：console.log(typeof a) //undefined\
+> 而：console.log(typeof a)//未声明之前不能使用\
+> let a
+
+6.  let /const/function会把当前所在的大括号(除函数之外)作为一个全新的块级上下文，应用这个机制，在开发项目的时候，遇到循环事件绑定等类似的需求，无需再自己构建闭包来存储，只要基于let的块作用特征即可解决
+
+
+### 作用域和作用域链
+
+创建函数的时候，已经声明了当前函数的作用域==>`当前创建函数所处的上下文`。如果是在全局下创建的函数就是`[[scope]]:EC(G)`，函数执行的时候，形成一个全新的私有上下文`EC(FN)`，供字符串代码执行(进栈执行)
+
+定义：简单来说作用域就是变量与函数的可访问范围，`由当前环境与上层环境的一系列变量对象组成`\
+1.全局作用域：代码在程序的任何地方都能被访问，window 对象的内置属性都拥有全局作用域。\
+2.函数作用域：在固定的代码片段才能被访问
+
+作用：作用域最大的用处就是`隔离变量`，不同作用域下同名变量不会有冲突。
+
+**作用域链参考链接**一般情况下，变量到 创建该变量 的函数的作用域中取值。但是如果在当前作用域中没有查到，就会向上级作用域去查，直到查到全局作用域，这么一个查找过程形成的链条就叫做作用域链。
+
+### 闭包的两大作用：保存/保护
+
+-   **闭包的概念**
+
+    函数执行时形成的私有上下文EC(FN)，正常情况下，代码执行完会出栈后释放;但是特殊情况下，如果当前私有上下文中的某个东西被上下文以外的事物占用了，则上下文不会出栈释放，从而形成不销毁的上下文。 函数执行函数执行过程中，会形成一个全新的私有上下文，可能会被释放，可能不会被释放，不论释放与否，他的作用是：
+
+（1）保护：划分一个独立的代码执行区域，在这个区域中有自己私有变量存储的空间，保护自己的私有变量不受外界干扰（操作自己的私有变量和外界没有关系）；
+
+（2）保存：如果当前上下文不被释放【只要上下文中的某个东西被外部占用即可】，则存储的这些私有变量也不会被释放，可以供其下级上下文中调取使用，相当于把一些值保存起来了；
+
+我们把函数执行形成私有上下文，来保护和保存私有变量机制称为`闭包`。
+
+> 闭包是指有权访问另一个函数作用域中的变量的函数--《JavaScript高级程序设计》
+
+**稍全面的回答**： 在js中变量的作用域属于函数作用域, 在函数执行完后,作用域就会被清理,内存也会随之被回收,但是由于闭包函数是建立在函数内部的子函数, 由于其可访问上级作用域,即使上级函数执行完, 作用域也不会随之销毁, 这时的子函数(也就是闭包),便拥有了访问上级作用域中变量的权限,即使上级函数执行完后作用域内的值也不会被销毁。
+
+-   **闭包的特性**：
+
+    -   1、内部函数可以访问定义他们外部函数的参数和变量。(作用域链的向上查找，把外围的作用域中的变量值存储在内存中而不是在函数调用完毕后销毁)设计私有的方法和变量，避免全局变量的污染。
+
+        1.1.闭包是密闭的容器，，类似于set、map容器，存储数据的
+
+        1.2.闭包是一个对象，存放数据的格式为 key-value 形式
+
+    -   2、函数嵌套函数
+
+    -   3、本质是将函数内部和外部连接起来。优点是可以读取函数内部的变量，让这些变量的值始终保存在内存中，不会在函数被调用之后自动清除
+
+-   **闭包形成的条件**：
+
+    1.  函数的嵌套
+    1.  内部函数引用外部函数的局部变量，延长外部函数的变量生命周期
+
+-   **闭包的用途**：
+
+    1.  模仿块级作用域
+    1.  保护外部函数的变量 能够访问函数定义时所在的词法作用域(阻止其被回收)
+    1.  封装私有化变量
+    1.  创建模块
+
+-   **闭包应用场景**
+
+    闭包的两个场景，闭包的两大作用：`保存/保护`。 在开发中, 其实我们随处可见闭包的身影, 大部分前端JavaScript 代码都是“事件驱动”的,即一个事件绑定的回调方法; 发送ajax请求成功|失败的回调;setTimeout的延时回调;或者一个函数内部返回另一个匿名函数,这些都是闭包的应用。
+
+-   **闭包的优点**：延长局部变量的生命周期
+-   **闭包缺点**：会导致函数的变量一直保存在内存中，过多的闭包可能会导致内存泄漏
+
+### JS 中 this 的五种情况
+
+1.  作为普通函数执行时，`this`指向`window`。
+1.  当函数作为对象的方法被调用时，`this`就会指向`该对象`。
+1.  构造器调用，`this`指向`返回的这个对象`。
+1.  箭头函数 箭头函数的`this`绑定看的是`this所在函数定义在哪个对象下`，就绑定哪个对象。如果有嵌套的情况，则this绑定到最近的一层对象上。
+1.  基于Function.prototype上的 ` apply 、 call 和 bind  `调用模式，这三个方法都可以显示的指定调用函数的 this 指向。`apply`接收参数的是数组，`call`接受参数列表，`` bind`方法通过传入一个对象，返回一个` this ` 绑定了传入对象的新函数。这个函数的  `this`指向除了使用`new `时会被改变，其他情况下都不会改变。若为空默认是指向全局对象window。
+
+### 原型 && 原型链
+
+**原型关系：**
+
+-   每个 class都有显示原型 prototype
+-   每个实例都有隐式原型 _ proto_
+-   实例的_ proto_指向对应 class 的 prototype
+
+‌ **原型:**  在 JS 中，每当定义一个对象（函数也是对象）时，对象中都会包含一些预定义的属性。其中每个`函数对象`都有一个`prototype` 属性，这个属性指向函数的`原型对象`。
+
+原型链：函数的原型链对象constructor默认指向函数本身，原型对象除了有原型属性外，为了实现继承，还有一个原型链指针__proto__,该指针是指向上一层的原型对象，而上一层的原型对象的结构依然类似。因此可以利用__proto__一直指向Object的原型对象上，而Object原型对象用Object.prototype.__ proto__ = null表示原型链顶端。如此形成了js的原型链继承。同时所有的js对象都有Object的基本防范
+
+**特点:**  `JavaScript`对象是通过引用来传递的，我们创建的每个新对象实体中并没有一份属于自己的原型副本。当我们修改原型时，与之相关的对象也会继承这一改变。
+
+### new运算符的实现机制
+
+1.  首先创建了一个新的`空对象`
+1.  `设置原型`，将对象的原型设置为函数的`prototype`对象。
+1.  让函数的`this`指向这个对象，执行构造函数的代码（为这个新对象添加属性）
+1.  判断函数的返回值类型，如果是值类型，返回创建的对象。如果是引用类型，就返回这个引用类型的对象。
+
+### EventLoop 事件循环
+
+`JS`是单线程的，为了防止一个函数执行时间过长阻塞后面的代码，所以会先将同步代码压入执行栈中，依次执行，将异步代码推入异步队列，异步队列又分为宏任务队列和微任务队列，因为宏任务队列的执行时间较长，所以微任务队列要优先于宏任务队列。微任务队列的代表就是，`Promise.then`，`MutationObserver`，宏任务的话就是`setImmediate setTimeout setInterval`
+
+JS运行的环境。一般为浏览器或者Node。 在浏览器环境中，有JS 引擎线程和渲染线程，且两个线程互斥。 Node环境中，只有JS 线程。 不同环境执行机制有差异，不同任务进入不同Event Queue队列。 当主程结束，先执行准备好微任务，然后再执行准备好的宏任务，一个轮询结束。
+
+#### **浏览器中的事件环（Event Loop)**
+
+事件环的运行机制是，先会执行栈中的内容，栈中的内容执行后执行微任务，微任务清空后再执行宏任务，先取出一个宏任务，再去执行微任务，然后在取宏任务清微任务这样不停的循环。
+
+-   eventLoop 是由JS的宿主环境（浏览器）来实现的；
+
+-   事件循环可以简单的描述为以下四个步骤:
+
+    1.  函数入栈，当Stack中执行到异步任务的时候，就将他丢给WebAPIs,接着执行同步任务,直到Stack为空；
+    1.  此期间WebAPIs完成这个事件，把回调函数放入队列中等待执行（微任务放到微任务队列，宏任务放到宏任务队列）
+    1.  执行栈为空时，Event Loop把微任务队列执行清空；
+    1.  微任务队列清空后，进入宏任务队列，取队列的第一项任务放入Stack(栈）中执行，执行完成后，查看微任务队列是否有任务，有的话，清空微任务队列。重复4，继续从宏任务中取任务执行，执行完成之后，继续清空微任务，如此反复循环，直至清空所有的任务。
+
+    ![事件循环流程](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/342e581223d2471d9484fc48beb9f8e1~tplv-k3u1fbpfcp-zoom-1.image)
+
+-   浏览器中的任务源(task):
+
+    -   `宏任务(macrotask)`：\
+        宿主环境提供的，比如浏览器\
+        ajax、setTimeout、setInterval、setTmmediate(只兼容ie)、script、requestAnimationFrame、messageChannel、UI渲染、一些浏览器api
+    -   `微任务(microtask)`：\
+        语言本身提供的，比如promise.then\
+        then、queueMicrotask(基于then)、mutationObserver(浏览器提供)、messageChannel 、mutationObersve
+
+传送门 ☞ [# 宏任务和微任务](https://juejin.cn/post/7001881781125251086)
+
+#### **Node 环境中的事件环（Event Loop)**
+
+`Node`是基于V8引擎的运行在服务端的`JavaScript`运行环境，在处理高并发、I/O密集(文件操作、网络操作、数据库操作等)场景有明显的优势。虽然用到也是V8引擎，但由于服务目的和环境不同，导致了它的API与原生JS有些区别，其Event Loop还要处理一些I/O，比如新的网络连接等，所以Node的Event Loop(事件环机制)与浏览器的是不太一样。
+
+![2020120317343116.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e362c1770f62428fbf3faabd99d2a64c~tplv-k3u1fbpfcp-zoom-1.image) 执行顺序如下：
+
+-   `timers`: 计时器，执行setTimeout和setInterval的回调
+-   `pending callbacks`: 执行延迟到下一个循环迭代的 I/O 回调
+-   `idle, prepare`: 队列的移动，仅系统内部使用
+-   `poll轮询`: 检索新的 I/O 事件;执行与 I/O 相关的回调。事实上除了其他几个阶段处理的事情，其他几乎所有的异步都在这个阶段处理。
+-   `check`: 执行`setImmediate`回调，setImmediate在这里执行
+-   `close callbacks`: 执行`close`事件的`callback`，一些关闭的回调函数，如：socket.on('close', ...)
+
+### setTimeout、Promise、Async/Await 的区别
+
+1.  setTimeout
+
+    settimeout的回调函数放到宏任务队列里，等到执行栈清空以后执行。
+
+1.  Promise
+
+    Promise本身是**同步的立即执行函数**， 当在executor中执行resolve或者reject的时候, 此时是异步操作， 会先执行then/catch等，当主栈完成后，才会去调用resolve/reject中存放的方法执行。
+
+    ```js
+    console.log('script start')
+    let promise1 = new Promise(function (resolve) {
+        console.log('promise1')
+        resolve()
+        console.log('promise1 end')
+    }).then(function () {
+        console.log('promise2')
+    })
+    setTimeout(function(){
+        console.log('settimeout')
+    })
+    console.log('script end')
+    // 输出顺序: script start->promise1->promise1 end->script end->promise2->settimeout
+    ```
+
+1.  async/await
+
+    async 函数返回一个 Promise 对象，当函数执行的时候，一旦遇到 await 就会先返回，等到触发的异步操作完成，再执行函数体内后面的语句。可以理解为，是让出了线程，跳出了 async 函数体。
+
+    ```js
+    async function async1(){
+       console.log('async1 start');
+        await async2();
+        console.log('async1 end')
+    }
+    async function async2(){
+        console.log('async2')
+    }
+
+    console.log('script start');
+    async1();
+    console.log('script end')
+
+    // 输出顺序：script start->async1 start->async2->script end->async1 end
+    ```
+传送门 ☞ [# JavaScript Promise 专题](https://juejin.cn/post/6999651011304357925)
+
+### Async/Await 如何通过同步的方式实现异步
+
+Async/Await就是一个**自执行**的generate函数。利用generate函数的特性把异步的代码写成“同步”的形式,第一个请求的返回值作为后面一个请求的参数,其中每一个参数都是一个promise对象.
+
+### 介绍节流防抖原理、区别以及应用
+
+`节流`：事件触发后，规定时间内，事件处理函数不能再次被调用。也就是说在规定的时间内，函数只能被调用一次，且是最先被触发调用的那次。
+
+`防抖`：多次触发事件，事件处理函数只能执行一次，并且是在触发操作结束时执行。也就是说，当一个事件被触发准备执行事件函数前，会等待一定的时间（这时间是码农自己去定义的，比如 1 秒），如果没有再次被触发，那么就执行，如果被触发了，那就本次作废，重新从新触发的时间开始计算，并再次等待 1 秒，直到能最终执行！
+
+`使用场景`：\
+节流：滚动加载更多、搜索框搜的索联想功能、高频点击、表单重复提交……\
+防抖：搜索框搜索输入，并在输入完以后自动搜索、手机号，邮箱验证输入检测、窗口大小 resize 变化后，再重新渲染。
+
+```js
+/**
+ * 节流函数 一个函数执行一次后，只有大于设定的执行周期才会执行第二次。有个需要频繁触发的函数，出于优化性能的角度，在规定时间内，只让函数触发的第一次生效，后面的不生效。
+ * @param fn要被节流的函数
+ * @param delay规定的时间
+ */
+function throttle(fn, delay) {
+    //记录上一次函数触发的时间
+    var lastTime = 0;
+    return function(){
+        //记录当前函数触发的时间
+        var nowTime = Date.now();
+        if(nowTime - lastTime > delay){
+            //修正this指向问题
+            fn.call(this);
+            //同步执行结束时间
+            lastTime = nowTime;
+        }
+    }
+}
+
+document.onscroll = throttle(function () {
+    console.log('scllor事件被触发了' + Date.now());
+}, 200); 
+
+/**
+ * 防抖函数  一个需要频繁触发的函数，在规定时间内，只让最后一次生效，前面的不生效
+ * @param fn要被节流的函数
+ * @param delay规定的时间
+ */
+function debounce(fn, delay) {
+    //记录上一次的延时器
+    var timer = null;
+    return function () {
+       //清除上一次的演示器
+        clearTimeout(timer);
+        //重新设置新的延时器
+        timer = setTimeout(function(){
+            //修正this指向问题
+            fn.apply(this);
+        }, delay); 
+    }
+}
+document.getElementById('btn').onclick = debounce(function () {
+    console.log('按钮被点击了' + Date.now());
+}, 1000);
+```
diff --git a/README.md b/README.md
index 7ae76b0..493c07c 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,26 @@
-# -
\ No newline at end of file
+html css javascript skill Statr
+
+# 简介
+面试是一件很主观很难的事情。 面试不通过不代表你就不合格，同样地即使面试通过也不意味着你就合格了。 作为候选人，通常会给你 45 分钟的时间来让你展示自己的技能。 作为一名面试官，同样难以在这么短的时间里评估这个人是否适合这项工作。 对于面试来说，没有任何一种标准能够适合所有人，面试官通常会覆盖某一个领域，但除此之外，他们会自行决定应该问哪些问题。
+
+准备面试题，我们不是照张全背，而是依据面试题去深入挖掘问题背后的原理，知其然知其所以然，都只是为了更好的实现 Coding 实现对未来的解码。每个阶段的发展技术的侧重点不同，主流面试范围也有所不同，即使业务有所不同的公司但对主流技术的要求大致相同。对于个人的要求也是要按照发展的顺序，有要求的让自我提升，从最基础的编码能力，完成工作任务，实现模块功能；到学会探究原理，从内在层面上去优化自己的代码，在编码过程中就有意识的去朝着更高要求的方向去思考；当思想有所转变了之后，接来下就会站在整个产品的角度去看待工作任务和功能模块，就要尝试着从整体的一个架构上去思考项目的搭建、配置、选型等等高层次的问题。随着这样一条线去学习，去实践，那么在面试的时候，也就不用过多的担心了。
+
+这里我整理的所有的面试题，都只是作为一个学习的资料，而不是面试的捷径，仅供大家参考，有需要补充和错误之处，还望留言，以便更好的维护，去帮助更多的人。
+
+# Job Model
+
+在面试之前大家应该都对自己有了一个定位，自己要面试的层级是什么样的， 需要什么的技能，有什么要求。这里没有针对问题去区分原理方面的还是表面上的，也是希望大家都能看的懂，有所了解，这样才会对你自身的提升有意义。
+
+Job Model 是 一个很重要的参考标准。 当然每个公司的 Job Model 都会不太一样， 大家可以根据自己心仪的公司的 Job Model 作为参考，自检一下。
+
+比如我想要面试的是 P7 的岗位，那么 P7 的 Job Model 是什么呢？我可能需要提前了解一下。 一般来说 P7 的岗位要求会有：
+
+基础扎实。计算机网络/设计模式/正则/安全等，并且要深入了解各项技术的原理和设计，而不只是使用。
+经验丰富。熟悉业内不同技术方案以及优缺点，并且能选择最切合当前业务的方案。
+技术驱动。探索新技术，将新技术带入团队，并赋能业务。
+软技能。协同能力强，带领团队或者跨团队完成目标的能力。 ...
+大家可以根据自己的期望层级，以及心仪公司的 Job Model 进行自测。
+
+我在这里画了一个简化版本的 Job Modal，大家可以根据自己的实际情况找自己的目标， 不同层级需要掌握的深度和广度是不一样的，大家根据自己的实际情况学习。
+
+![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a1b4706bdf274898ae08a6bc2524223d~tplv-k3u1fbpfcp-watermark.image?)
\ No newline at end of file