计算机网络编程知识笔记大全

real time

user time

sys time

超文本传输协议:  HTTP

文件传输协议: FTP<br>

简单邮件传输协议: SMTP

域名系统: DNS

安全外壳协议: SSH<br>

动态主机配置协议: DHCP

远程登录协议: TELNET

传输控制协议: TCP

用户数据报文协议: UDP<br>

网际协议: IP

地址转换协议: ARP

反向地址转换协议: RARP

中继器

集线器

网线

HUB

100 Continue ：表明到目前为止都很正常，客户端可以继续发送请求或者忽略这个响应。<br>

DNSz查找过程:浏览器缓存 => 路由器缓存 => DNS缓存<br>

支持长连接

支持只发送header不发送body

支持host字段

支持多路复用

支持服务端推送

压缩请求头

适用于https场景

1. 使用 HTTPS 协议可认证用户和服务器，确保数据发送到正确的客户机和服务器；<br>

2. HTTPS 协议是由 SSL + HTTP 协议构建的可进行加密传输、身份认证的网络协议，要比 HTTP 协议安全，可防止数据在传输过程中不被窃取、改变，确保数据的完整性；

3. HTTPS 是现行架构下最安全的解决方案，虽然不是绝对安全，但它大幅增加了中间人攻击的成本。

1. HTTPS 协议握手阶段比较费时，会使页面的加载时间延长近 50%，增加 10% 到 20% 的耗电；<br>

2. HTTPS 连接缓存不如 HTTP 高效，会增加数据开销和功耗，甚至已有的安全措施也会因此而受到影响；

3. SSL 证书需要钱，功能越强大的证书费用越高，个人网站、小网站没有必要一般不会用；

4. SSL 证书通常需要绑定 IP，不能在同一 IP 上绑定多个域名，IPv4 资源不可能支撑这个消耗；

5. HTTPS 协议的加密范围也比较有限，在黑客攻击、拒绝服务攻击、服务器劫持等方面几乎起不到什么作用。最关键的，SSL 证书的信用链体系并不安全，特别是在某些国家可以控制 CA 根证书的情况下，中间人攻击一样可行。

作用域是一组规则，它决定了在哪里和如何查找一个变量（标识符）。这种查询也许是为了向这个变量赋值，这时变量是一个LHS引用，或者是为取得它的值，这时变量是一个RHS引用。

编译器理论

词法作用域意味着作用域是由编写时函数被声明的位置的决策定义的。编译器的词法分析阶段实质上可以知道所有的标识符是在哪里和如何声明的，并如此在执行期间预测它们将如何被查询。

在JavaScript中有两种机制可以“欺骗”词法作用域：eval(..) 和 with 。前者可以通过对一个拥有一个或多个声明的“代码”字符串进行求值，来（在运行时）修改现存的词法作用域。后者实质上是通过将一个对象引用看作一个“作用域”，并将这个对象的属性看作作用域中的标识符，（同样，也是在运行时）创建一个全新的词法作用域。

这些机制的缺点是，它压制了引擎在作用域查询上进行编译期优化的能力，因为引擎不得不悲观地假定这样的优化是不合法的。这两种特性的结果就是代码将会运行的更慢。不要使用它们。

在JavaScript中函数是最常见的作用域单位。在另一个函数内部声明的变量和函数，实质上对任何外围“作用域”都是“隐藏的”，这是优秀软件的一个有意的设计原则。<br>

但是函数绝不是唯一的作用域单位。块儿作用域指的是这样一种想法：变量和函数可以属于任意代码块儿（一般来说，就是任意的 { .. } ），而不是仅属于外围的函数。<br>

从ES3开始，try/catch 结构在 catch 子句上拥有块儿作用域。<br>

在ES6中，引入了 let 关键字（ var 关键字的表兄弟）允许在任意代码块中声明变量。if (..) { let a = 2; }将会声明变量a，而它实质上劫持了 if 的 { .. } 块儿的作用域，并将自己附着在这里。<br>

虽然有些人对此深信不疑，但是块儿作用域不应当被认为是 var 函数作用域的一个彻头彻尾的替代品。两种机能是共存的，而且开发者们可以并且应当同时使用函数作用域和块儿作用域技术 —— 在它们各自可以产生更好，更易读/易维护代码的地方。

在一个作用域内的所有声明，不论它们出现在何处，都会在代码本身被执行前 首先 被处理。你可以将它可视化为声明（变量与函数）被“移动”到它们各自的作用域顶部，这就是我们所说的“提升”。

声明本身会被提升，但不是赋值，即便是函数表达式的赋值，也不会被提升。<br>

函数的提升是优先于变量的提升的，所以在进行重名赋值的时候需要注意。 <br>

闭包就是函数能够记住并访问它的词法作用域，即使当这个函数在它的词法作用域之外执行时。

模块要求两个关键性质：<br>

基本数据类型因为值的大小固定，所以直接保存在栈内存中。而引用数据类型因为值的大小不固定，所以保存在堆内存中，而堆内存是无法直接进行访问的，进而在栈内存当中又保存了指向堆内存中位置的指针。 <br>

复制时，基本数据类型是将原始值的副本赋值给新值，从而两个值之间并不会有任何影响，而引用数据类型则是将栈内存中保存的指向堆内存的指针赋值给新值，从而会互相影响。 <br>

最简单暴力的方法是： JSON.parse(JSON.stringify(obj)). 但是这样不能拷贝函数，并且会丢失原型链。<br>

较为完善的方法就是实现一个 extend 方法，递归调用 extend 方法。

=== 比较不同数据类型时，直接返回false。比较基本数据类型时比较的是数据类型以及值，在比较引用数据类型时是比较的是否指向同一块内存区域。<br>

== 在比较相同数据类型的值的时候与 === 相同，在比较不同数据类型时，会先对两边的数据类型进行转换再比较。

引用类型的值实际上是对其引用对象的一个指针。

这里严格的说，在和JAVA类似的语言中，已经没有了指针。在C里面，指针就是一个具有固定长度的类型(在大多数的C编译器里是2个字节)，但在JAVA类似的语言里，引用也有自己的属性和方法，只是你不能直接去访问和控制它，所以它从某种意义上也是一种对象，这种机制也很大程度的避免了内存泄露，术语称之为内存结构化访问机制。

内存区域小，垃圾回收频繁，大多数变量刚被声明的时候都先进入新生代区域。当新生代区域内存满的时候会进行一次清理。<br>

采用Scavenge算法进行回收，主要思想是将内存区分为 From 空间和 To 空间。变量一来时都先进入 From 空间，当开始清理的时候对 From 空间进行宽搜，将那些能够从ROOT节点搜索到的，并且还在新生代区域的变量放入 To 空间中，然后交换 From 和 To 空间。

默认情况下，64位环境下的V8引擎的新生代内存大小32MB,32位则减半<br>

在新生代区域进行回收的时候，查看这个变量是否已经经历过一次垃圾回收，如果已经经历过一次了就将它放入老生代区域。

对象从 From 空间复制到 To 空间时，如果To 空间已经被使用了超过(新生代)25%，那么这个对象直接被复制到老生代。

内存区域大，垃圾回收频率较低，保存的对象大多数是生存周期很长的甚至是常驻内存的对象。 <br>

采用Mark-Sweep（标记清除）与 Mark-Compact（标记整理）结合的算法进行回收，主要思想是进行宽搜，搜索过程当中对对象进行染色，最后如果一个对象没有被染色那么就是垃圾（这里其实和Scavenge寻找垃圾的思路是一致的，就是看一个对象能不能从ROOT节点搜索到）。然后进行对象的清除，当空间不足以分配从新生代晋升过来的对象时，才使用标记整理（其实就是内存页面的整理）。 <br>

默认64位,老生代内存大小为1400MB, 32位为700MB

1.全局变量<br>

2.闭包

3.事件监听<br>

4.其他原因<br>

重现内存泄漏情况

打印内存快照

对比内存快照找出泄漏位置

ESLint 检测代码检查非期望的全局变量。<br>

使用闭包的时候，得知道闭包了什么对象，还有引用闭包的对象何时清除闭包。最好可以避免写出复杂的闭包，因为复杂的闭包引起的内存泄漏，如果没有打印内存快照的话，是很难看出来的

绑定事件的时候，一定得在恰当的时候清除事件。在编写一个类的时候，推荐使用 init 函数对类的事件监听进行绑定和资源申请，然后 destroy 函数对事件和占用资源进行释放。

let 不会有作用域提升现象，所以使用 let 会有TDZ错误。<br>

let 一般与 {} 块联合使用，即在块中使用 let 声明的变量只在块中有效，在外面不能进行访问。<br>

let 与 for 联合使用的时候，因为 let 声明的变量只在块中有效，所以每一次循环当中都会声明一个新的循环变量。（这里还需要注意，for 循环当中，循环语句部分是一个父作用域，而循环体内部是一个单独的子作用域）<br>

let 不允许重复声明。<br>

=>函数体内的 this 对象，就是定义时所在的对象，而不是使用时所在的对象。<br>

=>不可以当做构造函数，也就是说，不可以使用 new 命令，否则会抛出错误。

=>不可以使用 arguments 对象，该对象在函数体内不存在。

=>不可以使用 yield 命令，因此箭头函数不能用作 Generator 函数。<br>

const 定义的 Array 中间元素能被修改，const 定义的变量只是持有 Array 的地址，这个变量只是本身不能修改，而对于存在于堆内存中的 Array 本身是可以修改的。<br>

对于 const 声明，只是它的赋值操作被冻结了，而值不会因为 const 而不变。主要是预防在coding过程中的coder因为疏忽对变量的意外修改。

Set： 感觉这个应该结合 [] 来谈，这个与数组的区别就是里面不存在重复的元素。结合 ... 可以直接转为数组，并且可以很方便的实现 并集、交集、差集。（这里的问题是 NaN 被判为同一种元素，但是 === 判NaN是不同的元素）

WeakSet： 对象成员版的 Set，里面的成员只能是对象。并且这里是对成员是弱引用，所以不具有 size 属性，也不具有循环操作。

Map： 这个与 {} 的区别是键值可以不只是字符串了，但是这里判断两个键一不一样的时候，对于引用数据来说是看他们是否指向同一块内存。

WeakMap： 对象键值版的 Map，里面的成员的键只能是对象，这边同样是弱引用。特征与 WeakSet 相似。

常规的私有化方法是使用闭包，只对外开放非私有化的部分。

symbol 是用来处理属性名的冲突。但是一个 symbol 属性作为键名时是不能被 Object.keys() 、 Object.getOwnPropertyNames() 获取，所以就造成了一种非私有的内部方法效果。symbol 是不能达到闭包那么好的效果的，因为通过 Symbol.for() 是可以获取同一个 Symbol 值的，获得以后一样是能够访问值。

在 class 中实现私有方法的办法是将方法声明在类外，然后在类中使用 .call() 进行引用。虽然通过这个类对象是不能访问这个方法，但是这个方法其实还是暴露在其他更大的作用域当中的，或者就是使用 symbol 作为方法名，这里的优缺点在 Symbol 中已经分析了。

目前，有一个提案，为class加了私有属性。方法是在属性名之前，使用#表示。

一种做法是在命名上加以区别, 例如以_开头

我们都知道JS是单线程的，那单线程是怎么实现异步的呢？

渲染进程

Event Loop

1. JS所谓的“单线程”只是指主线程只有一个，并不是整个运行环境都是单线程

2. JS的异步靠底层的多线程实现 <br>

3. 不同的异步API对应不同的实现线程 <br>

4. 异步线程与主线程通讯靠的是Event Loop <br>

5. 异步线程完成任务后将其放入任务队列 <br>

6. 主线程不断轮询任务队列，拿出任务执行 <br>

7. 任务队列有宏任务队列和微任务队列的区别 <br>

8. 微任务队列的优先级更高，所有微任务处理完后才会处理宏任务 <br>

9. Promise是微任务 <br>

10. Node.js的Event Loop跟浏览器的Event Loop不一样，他是分阶段的 <br>

11. setImmediate和setTimeout(fn, 0)哪个回调先执行，需要看他们本身在哪个阶段注册的，如果在定时器回调或者I/O回调里面，setImmediate肯定先执行。如果在最外层或者setImmediate回调里面，哪个先执行取决于当时机器状况。<br>

12. process.nextTick不在Event Loop的任何阶段，他是一个特殊API，他会立即执行，然后才会继续执行Event Loop <br>

string

list

hash

set

sortedSet

HyperLogLog

Geo

Pub/Sub

BloomFilter（布隆过滤器）<br>

RedisSearch<br>

Redis-ML<br>

scan命令

rpush

lpop

blpop

pub/sub

MQ

sortedSet

Redis是怎么持久化的？服务主从数据怎么交互的？

对方追问那如果突然机器掉电会怎样？

对方追问RDB的原理是什么？

主从同步<br>

从从同步

Redis Sentinal<br>

Redis Cluster

MULTI<br>

EXEC

事务中的错误

使用 check-and-set 操作实现乐观锁

Redis 脚本和事务

应对方法

缓存穿透我会在接口层增加校验，比如用户鉴权校验，参数做校验，不合法的参数直接代码Return，比如：id 做基础校验，id <=0的直接拦截等。

布隆过滤器（Bloom Filter）

设置热点数据永远不过期。或者加上互斥锁就能搞定了

完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。它的，数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)；<br>

数据结构简单，对数据操作也简单，Redis中的数据结构是专门进行设计的

采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；

使用多路I/O复用模型，非阻塞IO；

使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，Redis直接自己构建了VM 机制 ，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求；

哨兵集群sentinel<br>

定期删除

惰性删除<br>

内存淘汰机制<br>

最近最少使用LRU

最不常使用LFU

FIFO

分布式锁

串行化

队列

懒加载思想

高并发

超卖

恶意请求

连接暴露<br>

数据库

服务单一职责

秒杀连接加盐<br>

redis集群

nginx负载均衡<br>

前端资源静态化

按钮控制

限流,降级,熔断

库存预热

削峰填谷MQ

词法分析

语法分析

HASH<br>

B+TREE

平衡二叉树

b树

优点

缺点

第一范式：字段是最小的单元不可再分割

第二范式：满足第一范式,要有主键且表中的字段必须完全依赖于全部主键而非部分主键

第三范式：满足第二范式，非主键外的所有字段必须互不依赖(消除冗余)

drop

truncate<br>

delete

场景

ACID — 数据库事务正确执行的四个基本要素<br>

事务隔离级别

脏读<br>

不可重复读

幻读(虚读)

悲观锁

乐观锁

超键

候选键

主键

外键

NOT NULL(非空): 用于控制字段的内容一定不能为空（NULL）。

UNIQUE(唯一): 控件字段内容不能重复，一个表允许有多个 Unique 约束。

PRIMARY KEY(主键): 也是用于控件字段内容不能重复，但它在一个表只允许出现一个。

FOREIGN KEY(外键): 用于预防破坏表之间连接的动作，也能防止非法数据插入外键列，因为它必须是它指向的那个表中的值之一。

CHECK(检查): 用于控制字段的值范围。

在archivelog mode(归档模式)只要其归档日志文件不丢失，就可以有效地防止数据丢失。<br>

innodb<br>

MyIASM

MEMORY

使用 myisamchk 来修复

repair table

OPTIMIZE TABLE

行锁依赖于索引,如果没加索引则使用表锁

SQL优化

数据库结构优化<br>

服务器硬件优化

重试机制

接口幂等

事务的 ACID 特性（原子性、一致性、隔离性、持久性）

2pc（两段式提交）

3pc（三段式提交）

TCC（Try、Confirm、Cancel）

半消息/最终一致性（RocketMQ）

事件

通过 config/env 文件指定

通过 EGG_SERVER_ENV 环境变量指定运行环境

框架提供了变量 app.config.env 来表示应用当前的运行环境。<br><br>

koa：app.env

egg: app.config.env

使用平台管理配置，应用构建时将当前环境的配置放入包内，启动时指定该配置。但应用就无法一次构建多次部署，而且本地开发环境想使用配置会变的很麻烦。

使用平台管理配置，在启动时将当前环境的配置通过环境变量传入，这是比较优雅的方式，但框架对运维的要求会比较高，需要部署平台支持，同时开发环境也有相同痛点。

使用代码管理配置，在代码中添加多个环境的配置，在启动时传入当前环境的参数即可。但无法全局配置，必须修改代码。<br>

在应用中使用中间件<br>

在框架和插件中使用中间件<br>

router 中使用中间件<br>

框架默认中间件<br>

通用配置<br>