最近一段时间工作比较忙，加上近期离职了，手续比较多，期间一直有很多想写的，有时候稍微有一些灵感就记录下来了，以下就是我的一些学习笔记吧，写得很乱，大家将就着看一下

后面有时间会找几个有灵感的内容写成文章

强弱类型：声明的变量不能赋值为其它类型的变量 动态，静态语言：在编译之前确定所有变量的数据类型

可以通过ctrl+shift+m移动到括号外面

string list set zset hash

组标记 索引 偏移量

索引 有效位 组标记 偏移量

ACID

机密性、完整性，身份认证和不可否认

ArrayBuffer 抽象类 定义类 ArrayBufferView 具体实现类 Blob 大的二进制对象 底层由ArrayBufferView组成+一个options

墨菲定律 事情没有看起来简单 时间总会晚 会出错的事总会出错 如果你担心某件事的发生，那它很有可能发生

构造函数 initState didChangeDependencies build setState didChangeDependencies build didUpdateWidget deactive dispose

CommonJS: Nodejs AMD requireJS 依赖前置 CMD

Axios.prototype.request.bind(new Axios(defaultConfig))

instance = Axios.prototype.request.bind(new Axios(defaultConfig)) instance就是request方法 上面可以发ajax请求 原型对象都绑定到instance上 这样就可以使用new Axios 实例对象也都绑定到instance上 这样可以用使axios.get post等方法

第一次往返 Client Random Server Random Server Params

客户端也生成 Client Params 双方都有 Client Params、Server Params 用ECDHE 算 得出 Pre-Master

Client Random + Server Random + Pre-Master = Master Secret

映射表 -》 页表

20位页 12位偏移量 2^20 = 1048576‬ * 4 byte

5 每一个页表有2^5 = 32项 每项4个字节 128个字节 每一个页表需要128个字节 1个1级索引表

RTP RTCP

BFC body根元素 浮动 position absolute fixed display inline-block table-cell overflow

flex container flex-item

学生选课表，包含的属性有学号、姓名、课程名称、分数、系别和系主任

学生选课表 学号 课程名称 分数 Round Trip Time 这时只交换了两条消息，客户端和服务器就拿到了四个共享信息：Client Random和Server Random、Client Params和Server Params，两边就可以各自用 ECDHE 算出“Pre-Master”，再用 HKDF 生成主密钥“Master Secret”，效率比 TLS1.2 提高了一大截。

我的理解的是服务器返回的是证书链，然后浏览器就可以使用信任的根证书（根公钥）解析证书链的根证书得到一级证书的公钥+摘要验签，然后拿一级证书的公钥解密一级证书拿到二级证书的公钥和摘要验签，再然后拿二级证书的公钥解密二级证书得到服务器的公钥和摘要验签，验证过程就结束了。谢谢！

挂载阶段

constructor

static getDerivedStateFromProps

render

componentDidMount

更新阶段

static getDerivedStateFromProps

shouldComponentUpdate

render

getSnapshotBeforeUpdate

componentDidUpdate

卸载阶段

componentWillUnmount

确认机制 直接抛异常 自己重试 或者 事务补偿

从 Java 9 开始，采用 G1 作为默认垃圾收集器 比如在年轻代采用复制 - 整理算法，在年老代采用标记 - 清理算法

会话层 + 多个媒体层 媒体层 = 媒体流描述 + 网络描述 + 安全描述 + 服务质量描述

loader 的执行顺序是和配置顺序相反的

POSIX

如果 JS 是解释型语言那为什么会有变量提升（hoisting）？ JIT（及时编译）会做代码优化(同时创建代码的编译版本)；解释型语言无法做到这些。

JS是解释型语言 通过解释器可以直接执行语句 每个语句都要送入解释器 一个for循环要执行多少次就要送入解释器多少次 效率很低 如果一行代码执行了一次就是warm 随着执行越来越多 代码越来越Hot JIT会把代码送入编译器并保存一个编译后的版本 JIT会尝试更多的优化 比如变量类型和运行环境中值的假设

硬件优化 专用的加解密设备 软件优化 协议优化 升级 证书优化 在线认证

会话复用 会话票证 预共享密钥 0-RTT

重放攻击 中间人攻击 社会工程学

存储器 控制器 运算器 输入 输出

回测

统计学 就是根据数据 去了解客观规律 从而帮助我们去做决策和预测

朴素贝叶斯 朴素就是条件相互独立 不互相影响 朴素贝叶斯 先验概率和条件概率，推导出后验概率

linux权限 rwx 目录x是进入权限 setuid s权限位 以文件的属主来执行 setgid 用于目录 以文件的属组来执行 setbid /tmp目录 仅root和自己可以删除

定性/分类变量

函数嵌套函数时，内层函数引用了外层函数作用域下的变量，并且内层函数在全局环境下可访问，就形成了闭包。 WeakMap 用来记灵鸡的重量 非常好的例子 可以帮DOM添加属性 还可以实现私有属性

Vue组件间通信的方式 Prop + emit Event Bus Vuex provide inject attrs listeners inheritAttrs Ref实例通信

computed和watch有什么区别? computed是计算属性 更多是计算值的场景 具有缓存性 适合比较消耗性能的场景 watch更多是观察，某些数据的监听回调，用于观察props 无缓存性

diff算法 首、尾、旧尾新头、旧头新尾 React.PureComponent实现了shouldComponentUpdate的浅比较 非受控组件 数据存在refs里面 将真实数据存在DOM中

绝大部分消息丢失都是因为开发者没有正确使用和配置消息队列导致的 在保证消息可靠性上，各家产品的原理都是一样的

误区一 靠点击 误区二 点了不喜欢 还推荐 不聪明 误区三 信息茧房 不存在 误区四 可以洞察人性 误区五 没有技术壁垒

丢消息 发送阶段：发送时做异常捕获，重发消息 存储阶段：配置刷盘、集群同步到多个节点 消费阶段：先处理再确认

单子容器Container 多子容器Column/Row 层叠容器Stack/Positioned

speed-measure-webpack-plugin webpack-bundle-analyzer

交叉类型 联合类型

commonJS只允许一个顶级导出 es6 module允许两个顶端导出

UNIX BSD伯克利分支 商业派分支Solaris

Linux的发展得益于 UNIX的出现和发展 POSIX标准 MINIX操作系统 GNU

右派 重视国家权威 高过个人权利 左派 个人人权 自由

本地总线 前端总线 = 系统总线 I/O 总线 内存总线

192.0.2.12/30 HPACK算法

二进制“帧”（Frame） 用“HEADERS”帧存放头数据、“DATA”帧存放实体数据。 流 多路复用 h2c 相当于底层用的是“TLS1.25”。

它们分别是状态寄存器（Status Register）、 命令寄存器（Command Register）以及数据寄存器（Data Register），

ECMAScript

开放基因 知识体系 越来越复杂 浏览器地位 以不变应万变

GCM分组

不稳定（单独进程） 不流畅（单独进程） 不安全（沙箱）

早期多进程架构 主进程 渲染进程 插件进程

现代 主进程 渲染进程 插件进程 GPU进程 网络进程

面向服务架构

在消息的收发两端，我们的业务代码怎么和消息队列配合，达到一个最佳的性能。 生产端 增加并发 批量发送 消费端 扩容Consume同时增加分区 千万不能用内容队列 会丢消息

消息积压了该如何处理？ 扩容 关闭不需要的业务

ES 模块化与 CommonJS 规范不同，ES 模块不存在缓存机制，而是动态引用依赖的模块。

在批量更新操作时，行锁就很可能会升级为表锁。

system > const > eq_ref > ref > range > index > ALL eq_ref 唯一索引 ref 非唯一索引扫描 range 范围 index 索引全表扫描，此时遍历整个索引树。 ALL：表示全表扫描，需要遍历全表来找到对应的行。

不是以挣钱 而是以怎么侵占领市场为目的

bin/kafka-topics.sh –bootstrap-server broker_host:port –create –topic my_topic_name –partitions 1 –replication-factor 1

bin/kafka-topics.sh –bootstrap-server broker_host:port –alter –topic --partitions < 新分区数 > bin/kafka-configs.sh --zookeeper zookeeper_host:port --entity-type topics --entity-name --alter --add-config max.message.bytes=10485760 你只需要了解设置常规的主题级别参数zookeeper __consumer_offsets

完全锥型 NAT

编码完成 生产就绪 价值交付

AES加密算法

openssl genrsa -out private.pem 里面已经有了q p n d v openssl rsa -in private.pem -pubout -out public.pem PKI 公钥基础设施 有CA这个机构 会把用户个人身份和公钥关联在一起

Binary Large Object Blob 对象表示一个不可变、原始数据的类文件对象。 Blob对象被浏览器“视同文件”。

socket -> bind -> listen -> accept socket -> connect

AF address family 地址族 它表示使用什么样的方式对地址进行解释和保存

Hash 索引不能进行范围查询 Hash 索引不支持联合索引的最左侧原则 Hash 索引不支持 ORDER BY 排序

一个 HTTP/2 的流就等同于一个 HTTP/1 里的“请求 - 应答”

比如说，HTTP/2 在一个连接上使用多个流收发数据，那么它本身默认就会是长连接，所以永远不需要“Connection”头字段（keepalive 或 close）。

你可以再看一下 Wireshark 的抓包，里面发送了两个请求“/31-1”和“/favicon.ico”，始终用的是“56095<->8443”这个连接，对比一下第 8 讲，你就能够看出差异了。

SSD IOPS 1万 HDD 硬盘的 IOPS 通常也就在 100 左右

BDP 带宽时延积 BDP=100Mbps*0.04s=4Mb=0.5MB

Content-Security-Policy Strict-Transport-Security X-Content-Type-Options Cache-Control X-Frame-Options Access-Control-Allow-Origin Set-Cookie X-XSS-Protection

FMP FCP first contentful paint

意义 = 当前时间布局对象的数量 / max(1, 页面高度/屏幕高度) FMP = 意义值最大的一次布局变动之后的那个绘制（Paint）

柯里化 将多参数的函数转为单参数的函数 偏应用 解决柯里化参数顺序问题 组合、管道 compose

基于 Kubernetes 的应用管理，到底应该怎么做？ 不用重新打包 两个项目两个团队维护

自动化 自描述 “声明式”带来最大的好处，其实正是“自动化” 声明式 把简单交给用户，把复杂留给自己 终态

TCP 有重传 排序功能

消费组 消费一个主题下所有队列的消息 消费位置 消费组内部维护自己的一组消费位置 每个队列对应一个消费位置。 消费位置在服务端保存 消费位置和消费者是没有关系的

队列上是严格有序的

数据丢失 数据被覆盖 脏读 读到被回滚的数据 不可重复读 两次读的数据不同 幻读 读到别人插入的数据

悲观锁 for update 乐观锁 将某一字段作为版本号 数据库读一致性 锁机制 共享锁（S）和排他锁（X）

未提交读 修改加共享锁 已提交读

MVVC 避免了对数据重复加锁的过程，大大提高了读操作的性能。

record lock、gap lock 以及 next-key lock 如果不通过索引条件检索数据，行锁将会升级到表锁。

InnoDB 原子性 InnoDB 一致性

min(net.core.somaxconn， backlog = acceptCount) // 大概是100 maxConnections + acceptCount

bin/kafka-configs.sh –bootstrap-server kafka-host:port –entity-type brokers –entity-default –alter –add-config unclean.leader.election.enable=true Completed updating default config for brokers in the cluster,

bin/kafka-configs.sh –bootstrap-server kafka-host:port –entity-type brokers –entity-default –describe Default config for brokers in the cluster are: unclean.leader.election.enable=true sensitive=false synonyms={DYNAMIC_DEFAULT_BROKER_CONFIG:unclean.leader.election.enable=true}

bin/kafka-configs.sh –bootstrap-server kafka-host:port –entity-type brokers –entity-name 1 –alter –add-config unclean.leader.election.enable=false Completed updating config for broker: 1.

bin/kafka-configs.sh –bootstrap-server kafka-host:port –entity-type brokers –entity-name 1 –describe Configs for broker 1 are: unclean.leader.election.enable=false sensitive=false synonyms={DYNAMIC_BROKER_CONFIG:unclean.leader.election.enable=false, DYNAMIC_DEFAULT_BROKER_CONFIG:unclean.leader.election.enable=true, DEFAULT_CONFIG:unclean.leader.election.enable=false}

删除 cluster-wide 范围参数

$ bin/kafka-configs.sh –bootstrap-server kafka-host:port –entity-type brokers –entity-default –alter –delete-config unclean.leader.election.enable Completed updating default config for brokers in the cluster,

查看 Broker 1 上的动态参数配置

$ bin/kafka-configs.sh –bootstrap-server kafka-host:port –entity-type brokers –entity-name 1 –describe Configs for broker 1 are:

房间管理。即每个用户都要加入到一个具体的房间里，比如两个用户 A 与 B 要进行通话，那么它们必须加入到同一个房间里。 信令的交换。即在同一个房间里的用户之间可以相互发送信令。

函数式编程是一种编程范式 主要是利用函数把运算过程封装起来，通过组合各种函数来计算结果。 无副作用 透明引用 不可变变量 函数是一等公民 函数柯里化 函数组合

函子是一个普通对象，它实现了map函数，在遍历每一个对象的时候生成新的对象

int socket(int domain, int type, int protocol) bind(int fd, sockaddr * addr, socklen_t len) bind(int fd, void * addr, socklen_t len)

bind (sock, (struct sockaddr *) &name, sizeof (name) int listen (int socketfd, int backlog) int accept(int listensockfd, struct sockaddr *cliaddr, socklen_t *addrlen)

bind 函数只是让我们的套接字和地址关联

字段的数值有唯一性的限制，比如用户名

SELECT user_id, count(*) as num FROM product_comment group by user_id order by comment_time desc limit 100

// index(user_id, comment_time) SELECT DISTINCT(user_id) FROM product_comment

  1. 做多表 JOIN 连接操作时，创建索引需要注意以下的原则 连接表的数量尽量不要超过 3 张

队头阻塞 QUIC 是传输层协议

机械硬盘的 IOPS，大概只能做到每秒 100 次左右 磁道 悬臂 扇区 柱面 把几何扇区对准悬臂位置的时间 1s / 240 = 4.17ms 我们的悬臂定位到扇区的的时间 4-10ms

*脂肪堆积顺序：血液-器官-腰腹-臀部-四肢 四肢减的最快，腰腹和臀部减的最慢

terser-webpack-plugin 开启80s 不开启110s

分布Externals splitChunks每次都会对基础包进行分析 最好的方式就是预编译资源模块 vendorLibrary busiLibrary

二次构建非常快 加缓存 babel?cache=true terser harder-resource 缩小构建目标 减少文件搜索范围

ECDH

主进程 插件进程 渲染进程 GPU进程 网络进程

等待 TCP 队列

Listener GeustureDetector 手势竞技场 TapGestureRecognizer rejectGesture

GestureDetector Gesture Factory -> RawGestureDetector GestureRecognizer

需要 RawGestureDetector GestureFactory 还需要自定义一个手势识别器

MultipleTapGestureRecognizer: GestureRecognizerFactoryWithHandlers( () => MultipleTapGestureRecognizer(), (MultipleTapGestureRecognizer instance) {instance.onTap = () => print('parent tapped');}, )

善政 民主！=自由 古雅典判了苏格拉底死刑 因为苏格拉底的言论自由 独裁！=专制 罗马

索引覆盖 自增主键 前缀索引 防止索引失效

主分区 扩展分区 逻辑分区 先分区 再格式化mkfs.ext4 挂载 mkdir /mnt/sdc1 mount /dev/sdc1 /mnt/sdc1 持久化 /etc/fstab

计算机启动顺序 BIOS -> 读第一个扇区 = 读取最前面的512个字节 -> 分区表里面分项 每项16个字节 所以，一个硬盘最多只能分四个一级分区，又叫做”主分区” 只能有一个扩展分区 去读扩展分区里的第一个扇区 它里面也包含一张64字节的分区表，但是最多只有两项（也就是两个逻辑分区）。 计算机接着读取第二个逻辑分区的第一个扇区

xfs_quota 交换分区的创建 dd if=/dev/zero bs=4M count=1024 of=/swapfile

RAID 0 吞吐量 RAID 1 复制 RAID 5 3块硬盘

逻辑卷 3个分区变成3个物理卷 再用2个物理卷组成一个卷组 lvcreate -L 100M -n lv1 vg1

fdisk分区 /dev/sd?? pv vg1 lv1 xfs mount 就是为了实现可以逻辑扩缩容

所有目录都放在根上面 根挂载在同一个分区上

插入排序 下一个插入进来 选择排序 在剩下的里面选最小的一个

eden -> survivor1 -> survivor2

write send sendmsg

ssize_t write (int socketfd, const void *buffer, size_t size) ssize_t send (int socketfd, const void *buffer, size_t size, int flags) ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)

发送缓冲区 从应用程序中拷贝到操作系统内核的发送缓冲区中

页 16KB 如果是内存大小是4KB 区 16KB * 64 = 1MB 段 表空间

共享表空间和独立表空间

文件头 页头 最大最小记灵 用户记录 空闲空间 页目录 文件尾

new runnable blocked waiting timed_waiting terminator

transpileOnly ts-loader awesome-typescript-loader

DefinePlugin alias

大端法 0x12345678 前面的数值存在内存小的地址

网络、操作系统、Web

浏览器进程主要负责用户交互、子进程管理和文件储存等功能。 网络进程是面向渲染进程和浏览器进程等提供网络下载功能。

用户发出 URL 请求到页面开始解析的这个过程，就叫做导航 因为需要等待提交文档阶段，页面内容才会被替换。

根域名（例如，geekbang.org）加上协议 那么新页面会复用父页面的渲染进程 process-per-site-instance 这也就解释了为什么在浏览器的地址栏里面输入了一个地址后，之前的页面没有立马消失，而是要加载一会儿才会更新页面

CompletableFuture

InheritedWidget、Notification 和 EventBus

死锁

行锁的具体实现算法有三种：record lock、gap lock 以及 next-key lock。record lock 是专门对索引项加锁；gap lock 是对索引项之间的间隙加锁；next-key lock 则是前面两种的组合，对索引项以其之间的间隙加锁。

开多少个线程 (线程IO阻塞时间+线程CPU时间) / 线程CPU时间

bin/kafka-consumer-perf-test.sh –broker-list kafka-host:port –messages 10000000 –topic test-topic start.time, end.time, data.consumed.in.MB, MB.sec, data.consumed.in.nMsg, nMsg.sec, rebalance.time.ms, fetch.time.ms, fetch.MB.sec, fetch.nMsg.sec 2019-06-26 15:24:18:138, 2019-06-26 15:24:23:805, 9765.6202, 1723.2434, 10000000, 1764602.0822, 16, 5651, 1728.1225, 1769598.3012

bin/kafka-dump-log.sh –files ../data_dir/kafka_1/test-topic-1/00000000000000000000.log –deep-iteration –print-data-log

传输码率 网络传输速度的控制 5702Kbps / 8 = 712.75KB = 0.69MB 每秒播放0.69MB的数据量 降低码率 = 降分辨率 1 帧未压缩过的视频帧720 22Mb 减少帧率的方式就没有降低分辨率方式效果明显了。

checkpoint mysql> SELECT comment_id, product_id, comment_text, user_id FROM product_comment WHERE comment_id = 900001; mysql> SELECT comment_id, product_id, comment_text, user_id FROM product_comment WHERE comment_id BETWEEN 900001 AND 900100;

磨损均衡 FTL 这个闪存转换层。

渲染流程 渲染流水线 构建 DOM 树、样式计算、布局阶段、分层、绘制、分块、光栅化和合成

继承 层叠 ComputedStyle 布局

Selector Channel

路由管理或导航管理。

String Number Boolean undefined null Object Symbol

SELECT comment_id, product_id, comment_text, user_id FROM product_comment WHERE user_id between 100001 and 100100 SELECT comment_id, product_id, comment_text, user_id FROM product_comment WHERE user_id between 100001 and 100100

flex: flex-grow, flex-shrink, flex-Basis

组合 柯里化 函子 of maybe either ap函子 Monad函子

正则文法和有限自动机：纯手工打造词法分析器 age >= 45 int age = 40 2+3*5

letc=$(ls -l etc)

export unset

$? $$ $0

etcetera usr是 Universal System Resource 的缩写，这里存放的是一些非系统必须的资源，比如用户安装的应用程序。

lsof -i :8080

实际上加锁是为了保证数据的一致性

硬盘 DMA 读缓冲区 应用程序内存 Socket缓冲区 网卡

int 关键字、标识符、等号和表达式

additiveExpression : multiplicativeExpression | multiplicativeExpression Plus additiveExpression ;

multiplicativeExpression : IntLiteral | IntLiteral Star multiplicativeExpression ;

–>additiveExpression + multiplicativeExpression –>multiplicativeExpression + multiplicativeExpression –>IntLiteral + multiplicativeExpression –>IntLiteral + IntLiteral * multiplicativeExpression –>IntLiteral + IntLiteral * IntLiteral

showName() console.log(myname) var myname = ‘极客时间’ function showName() { console.log(‘函数 showName 被执行’); }

// console.log(‘函数 showName 被执行’); // undefined

dom树 cssom 布局树 分层树 绘制列表 -》合成线程 图块 栅格化 -》DrawQuad 浏览器进程生成页面，并显示到显示器上。

then 会在 Future 函数体执行完毕后立刻执行，无论是共用同一个事件循环还是进入下一个微任务。

f1 被取出并打印；然后到了 then。then 的执行体是个 future f2，于是放入 Event Queue。然后把 await 也放到 Event Queue 里。

基于微服务原理开发 以容器方式进行打包 运行于云基础设施之上 采用持续交付 devops

DOMContentLoaded 页面内容解析完成后

MAC下：Clang 背后的技术叫做 LLVM

事务版本号、行记录中的隐藏列和 Undo Log。 db_trx_id db_roll_ptr

理解 分解 卡壳 练习

执行上下文 = 变量环境 + 词法环境

char boolean byte short int long float double

内存池、后台线程以及存储文件

写传播 事务串行化 MESI

现在共6个大功能，4个功能已经确定，现在这样分工，看有没有问题 主会场（朱世璋）：瓜分孩宝币+公共头组件 放映室（梁泽源）：播放18个视频+书单 答题（梁泽源）：每天做5道题，得孩宝币 漂流包（陈巧婵）：拼团，邀请好友

页面工程优化和代码细节优化两大方向。

页目录项 页表项 页内偏移

开发流程的顺畅是生产优质软件的关键因素，只有这样才能最大程度地释放开发者的创造性和积极性。

优化流程、团队工程实践、个人工程实践以及文化和管理，就是我们提高研发效能需要关注的四个方面，也就是我们所说的研发效能模型。

00000011 11111100 补码 11111011 反码 = 补码 - 1 10000100 原码

10000011 11111100 反码 11111101 补码 = 反码 + 1 00000010 取返 = 2

血液-器官-腰腹-臀部-四肢

70MB 120s

70MB / 120 * 8 = 至少要 4.6Mbps

compile、make、build、seal、emit

exports.getAllBuilds = () => Object.keys(builds).map(genConfig(buildName) { config = { input: output } return config })

// 最后就是一个rollup的打包对象

genConfig(key)

‘web-runtime-cjs’: { entry: resolve(‘web/entry-runtime.js’), dest: resolve(‘dist/vue.runtime.common.js’), format: ‘cjs’, banner },

path.resolve(__dirname, ‘../src/platforms/web’),

entry: /src/platforms/web/entry-runtime.js dest: /dist/vue.runtime.common.js

initLifecycle(vm) initEvents(vm) initRender(vm) callHook(vm, ‘beforeCreate’) initInjections(vm) // resolve injections before data/props initState(vm) initProvide(vm) // resolve provide after data/props callHook(vm, ‘created’)

if (vm.$options.el) { vm.$mount(vm.$options.el) }

platforms/web/entry-runtime.js platforms/web/runtime/index.js core/index core/instance/index

beforeCreate created beforeMount

updateComponent = () => { vm._update(vm._render(), hydrating) }

( 1280000 * 0.8 ) / (86400 * 0.2 ) = 59 (QPS)

dom tree -> cssom tree -> render tree -> 分层树 -> 绘制列表 -> composite

合成层 绘制 图块 栅格化

慢查询、EXPLAIN 和 SHOW PROFILING。

EXPLAIN SELECT * FROM product_comment JOIN user WHERE product_comment.user_id = user.user_id

EXPLAIN SELECT comment_id, comment_text, user_id FROM product_comment WHERE comment_id = 500000

<% require(‘html!./test.html’ ) %>

目录项 inode block 超级块

效能怎么度量

提高团队绩效、提高计划精确度，以及寻找关键的待改进领域 只有一套度量指标

亲子游乐场（朱世璋） 会员轰趴馆（梁泽源） 兑换商城、实物奖优化、砍件广告位（陈巧婵）

fromEntries flatMap trimStart trimEnd

变量的查询本来应该按照函数栈来查找的 但js不是，js需要通过作用域链来查找 每个执行上下文的变量环境中 都有一个outer

词法作用域决定了作用域链 变量的查找是通过作用域链

了解全局 零拷贝技术 直接从PageCache中拷贝到Socket缓冲区，通过DMA

2阶段提交 3阶段提交 TCC事务补偿

Lag 滞后了多少消息，也就是积压了多少消息 Lead 消费者最新消费消息的位移与分区当前第一条消息位移的差值 意味着要丢消息了

IIFE就是利用了闭包

防抖 就是只触发一次 节流 就是像水龙头，固定频率

页面工程优化 图片优化 懒加载 雪碧图 设置缓存策略 prefetch preload tree shaking 代码细节优化 动画性能方向 操作 DOM 方向 浏览器加载、渲染性能方向 性能测量、监控方向

offsetHeight >= clientHeight scrollHeight >= clientHeight scrollTop offsetTop

hash 根据入口文件打包出 chunkhash 根据不同入口文件进行依赖分析 contenthash 根据内容的不同

location [ = | ~ | ~* | ^~ ] uri { … } location @name { … }

^~ 表示如果该符号后面的字符是最佳匹配，采用该规则，不再进行后续的查找。

proxy_pass 加了/ 就是绝对路径 rewrite [ last | break | return ]

describe secret $(kubectl get secret | grep admin-user) staffjoy-uat.local

保持对连接有效性的检测，是我们在实战中必须要注意的一个点。

定义一个时间段，在这个时间段内，如果没有任何连接相关的活动，TCP 保活机制会开始作用，每隔一个时间间隔，

x, y, z SELECT x, y, z FROM table WHERE y=2 AND x=1 AND z=3 SELECT x, y, z FROM table WHERE y>2 AND x=1 AND z=3

100g米饭大约是1452kj 100g辣条是604kj

准确度、速度、质量和个人效能 不要与绩效挂钩 目标驱动，度量对的事； 先从全局上找瓶颈，再深入细节； 通过主观的方式来评价、提高效能； 关注个人维度的指标提高效能。

jQuery.fn.init.prototype = jQuery.fn

anran.proto = an

缓存和多核 并行压缩js cache-loader或HardSourceWebpackPlugin happypack terser ugliyfy-parallel

从JavaScript执行上下文的视角讲清楚this

变量环境、词法环境、外部环境、this

改变this 通过call 通过对象调用方法 通过构造函数中设置 使用对象来调用其内部的一个方法，该方法的 this 是指向对象本身的。myObj.showThis.call(myObj) window.foo.call(window)

接收缓冲区 要增大一些才告诉发送方 不然交流太频繁 Nagle 算法