font-main

1. 回调

2.promise

3.* yield

4. async await

1.pomise

2.async await 、 promise

执行栈

1.同步任务

2.异步任务

1. async await 你真的用对了吗？ https://www.cnblogs.com/kenkofox/

2. ES6 Async/Await 完爆Promise的6个原因 https://segmentfault.com/a/1190000009070711

3. 头条前端笔试题 - 实现一个带并发限制的promise异步调度器 https://blog.csdn.net/zz_jesse/article/details/107293743?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.compare&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.compare

4. js 多个异步 的并发控制 https://blog.csdn.net/anchu7971/article/details/101279805?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduend~default-1-101279805.nonecase&utm_term=js%E6%8E%A7%E5%88%B6%E5%BC%82%E6%AD%A5%E5%B9%B6%E5%8F%91%E6%95%B0%E9%87%8F&spm=1000.2123.3001.4430

5. https://blog.csdn.net/weixin_33928137/article/details/88754909?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.compare&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.compare

1. 图片碎片异步并发上传

2. gitchat 画正方形、 红绿灯

3. gitchat 异步并发数限制、promise.rate

4. gitchat 返回100本书籍

1. js实现并发请求控制 https://www.jianshu.com/p/be92059cd7f2

1. promisefy

2. code process

3. 链接

function Promise(executor) {
this.status = 'pending'
this.value = null
this.reason = null
this.onFulfilledArray = []
this.onRejectedArray = []

const resolve = value => {
if (value instanceof Promise) {
return value.then(resolve, reject)
}
setTimeout(() => {
if (this.status === 'pending') {
this.value = value
this.status = 'fulfilled'

this.onFulfilledArray.forEach(func => {
func(value)
})
}
})
}

const reject = reason => {
setTimeout(() => {
if (this.status === 'pending') {
this.reason = reason
this.status = 'rejected'

this.onRejectedArray.forEach(func => {
func(reason)
})
}
})
}


try {
executor(resolve, reject)
} catch(e) {
reject(e)
}
}

const resolvePromise = (promise2, result, resolve, reject) => {
// 当 result 和 promise2 相等时，也就是说 onfulfilled 返回 promise2 时，进行 reject
if (result === promise2) {
return reject(new TypeError('error due to circular reference'))
}

// 是否已经执行过 onfulfilled 或者 onrejected
let consumed = false
let thenable

if (result instanceof Promise) {
if (result.status === 'pending') {
result.then(function(data) {
resolvePromise(promise2, data, resolve, reject)
}, reject)
} else {
result.then(resolve, reject)
}
return
}

let isComplexResult = target => (typeof target === 'function' || typeof target === 'object') && (target !== null)
// 如果返回的是疑似 Promise 类型
if (isComplexResult(result)) {
try {
thenable = result.then
// 如果返回的是 Promise 类型，具有 then 方法
if (typeof thenable === 'function') {
thenable.call(result, function(data) {
if (consumed) {
return
}
consumed = true

return resolvePromise(promise2, data, resolve, reject)
}, function(error) {
if (consumed) {
return
}
consumed = true

return reject(error)
})
}
else {
return resolve(result)
}

} catch(e) {
if (consumed) {
return
}
consumed = true
return reject(e)
}
}
else {
return resolve(result)
}
}

Promise.prototype.then = function(onfulfilled, onrejected) {
// 如何实现 Promise 穿透呢
// 给 .then() 函数传递非函数值作为其参数时，实际上会被解析成 .then(null)，
// 这时候的表现应该是：上一个 promise 对象的结果进行“穿透”，
// 如果在后面链式调用仍存在第二个 .then() 函数时，将会获取被穿透下来的结果。
// 如果 onfulfilled 不是函数类型，则给一个默认值，该默认值是返回其参数的函数
onfulfilled = typeof onfulfilled === 'function' ? onfulfilled : data => data
onrejected = typeof onrejected === 'function' ? onrejected : error => {throw error}

// promise2 将作为 then 方法的返回值
let promise2

if (this.status === 'fulfilled') {
return promise2 = new Promise((resolve, reject) => {
setTimeout(() => {
try {
// 这个新的 promise2 resolved 的值为 onfulfilled 的执行结果
let result = onfulfilled(this.value)
resolvePromise(promise2, result, resolve, reject)
}
catch(e) {
reject(e)
}
})
})
}
if (this.status === 'rejected') {
return promise2 = new Promise((resolve, reject) => {
setTimeout(() => {
try {
// 这个新的 promise2 reject 的值为 onrejected 的执行结果
let result = onrejected(this.reason)
resolvePromise(promise2, result, resolve, reject)
}
catch(e) {
reject(e)
}
})
})
}
if (this.status === 'pending') {
return promise2 = new Promise((resolve, reject) => {
this.onFulfilledArray.push(value => {
try {
let result = onfulfilled(value)
resolvePromise(promise2, result, resolve, reject)
}
catch(e) {
return reject(e)
}
})

this.onRejectedArray.push(reason => {
try {
let result = onrejected(reason)
resolvePromise(promise2, result, resolve, reject)
}
catch(e) {
return reject(e)
}
})
})
}
}

Promise.prototype.catch = function(catchFunc) {
return this.then(null, catchFunc)
}

Promise.resolve = function(value) {
return new Promise((resolve, reject) => {
resolve(value)
})
}

Promise.reject = function(value) {
return new Promise((resolve, reject) => {
reject(value)
})
}

Promise.race = function(promiseArray) {
if (!Array.isArray(promiseArray)) {
throw new TypeError('The arguments should be an array!')
}
return new Promise((resolve, reject) => {
try {
const length = promiseArray.length
for (let i = 0; i <length; i++) {
promiseArray[i].then(resolve, reject)
}
}
catch(e) {
reject(e)
}
})
}

Promise.all = function(promiseArray) {
if (!Array.isArray(promiseArray)) {
throw new TypeError('The arguments should be an array!')
}
return new Promise((resolve, reject) => {
try {
let resultArray = []

const length = promiseArray.length

for (let i = 0; i <length; i++) {
promiseArray[i].then(data => {
resultArray.push(data)

if (resultArray.length === length) {
resolve(resultArray)
}
}, reject)
}
}
catch(e) {
reject(e)
}
})
}

http://www.ruanyifeng.com/blog/2013/10/event_loop.html

0. 这一次，彻底弄懂 JavaScript 执行机制https://juejin.cn/post/6844903512845860872

1. JavaScript 运行机制详解：再谈Event Loop http://www.ruanyifeng.com/blog/2014/10/event-loop.html

1. NodeJS 事件循环（第一部分）- 事件循环机制概述 https://zhuanlan.zhihu.com/p/37427130

2. 初探nodejs事件循环机制event loop https://www.cnblogs.com/zifayin/p/11419808.html

3. NodeJS 事件循环 https://zhuanlan.zhihu.com/p/37427130

4. 笔记 nodejs-第二章-第二节-nodejs事件循环(2-1) http://note.youdao.com/s/MbA6ISKq

5. Node.js 事件循环机制 https://www.cnblogs.com/onepixel/p/7143769.html

1.定义：map提供了“值---值”的对应，是一种更完善的hash结构，

2.属性、方法

3.遍历方法

4.Map转数组结构

5.数组转Map

6.Map 转为对象

8.Map 转为 JSON

7.对象转Map

9.JSON 转为 Map

1.定义

2. 属性和方法

3. 应用场景

1.定义

2. 用法

3.Set 实例的属性和方法

4.注意点

5. 数组和set相互转换

1.定义

2. 属性方法

3.应用

4.链接

1. Proxy 用于修改某些操作的默认行为，等同于在语言层面做出修改，
所以属于一种“元编程”（meta programming），即对编程语言进行编程。

2. Proxy 实际上重载（overload）了点运算符，即用自己的定义覆盖了语言的原始定义。

1. 创建一个可撤销的Proxy对象。

1. var proxy = new Proxy(target, handler);

2. handler是一个对象，里面是对应操作的函数

3. Proxy 实例也可以作为其他对象的原型对象。

4.  Proxy 支持的拦截操作

1. 实现new
function newFunc(...args) {
// 取出 args 数组第一个参数，即目标构造函数
const constructor = args.shift()

// 创建一个空对象，且这个空对象继承构造函数的 prototype 属性
// 即实现 obj.__proto__ === constructor.prototype
const obj = Object.create(constructor.prototype)

// 执行构造函数，得到构造函数返回结果
// 注意这里我们使用 apply，将构造函数内的 this 指向为 obj
const result = constructor.apply(obj, args)

// 如果造函数执行后，返回结果是对象类型，就直接返回，否则返回 obj 对象
return (typeof result === 'object' && result != null) ? result : obj
}

1.  apply:方法能劫持另外一个对象的方法，继承另外一个对象的属性.
Function.apply(obj,args)方法能接收两个参数
obj: 这个对象将代替Function类里面的this对象
args: 数组，它将作为参数传给Function（args -> arguments）

2. call 

3. bind

4.链接： apply方法详解 https://www.cnblogs.com/chenhuichao/p/8493095.html

1.JS在构造函数和实例化时涉及到的3种属性，
分别是静态属性、原型属性和实例属性。

分支主题

4.注意：只有声明的变量和函数才会进行提升，隐式全局变量不会提升

4.链接

5.为什么要进行变量和函数声明提升

作用域在预编译阶段确定，但是作用域链是在执行上下文的创建阶段完全生成的。因为函数在调用时，才会开始创建对应的执行上下文。执行上下文包括了：变量对象、作用域链以及 this 的指向

1.我们在执行一个函数时，如果这个函数又调用了另外一个函数，而这个“另外一个函数”也调用了“另外一个函数”，便形成了一系列的调用栈

2.正常来讲，在函数执行完毕并出栈时，函数内局部变量在下一个垃圾回收节点会被回收，该函数对应的执行上下文将会被销毁，这也正是我们在外界无法访问函数内定义的变量的原因。也就是说，只有在函数执行时，相关函数可以访问该变量，该变量在预编译阶段进行创建，在执行阶段进行激活，在函数执行完毕后，相关上下文被销毁。

借助闭包来绑定数据变量，可以保护这些数据变量的内存块在闭包存活时，始终不被垃圾回收机制回收

2.对比前述内容，我们知道正常情况下外界是无法访问函数内部变量的，函数执行完之后，上下文即被销毁。但是在（外层）函数中，如果我们返回了另一个函数，且这个返回的函数使用了（外层）函数内的变量，外界因而便能够通过这个返回的函数获取原（外层）函数内部的变量值。这就是闭包的基本原理。

分支主题

2.内存空间

3.内存泄漏

4. 链接

1.标记清除

2.引用计数

自由变量是指没有在相关函数作用域中声明，但是使用了的变量

1. const foo = (function() { var v = 0 return () =&gt; { return v++ } }()) for (let i = 0; i &lt; 10; i++) { foo() } console.log(foo()) 在循环执行时，执行 foo()，这样引用自由变量 10 次，v 自增 10 次，最后执行 foo 时，得到 10。

2. const foo = () =&gt; { var arr = [] var i for (i = 0; i &lt; 10; i++) { arr[i] = function () { console.log(i) } } return arr[0] } foo()() 答案：10，这时自由变量为 i，分析类似例题 1：foo() 执行返回的是 arr[0], arr[0] 此时是函数：

3.var fn = null const foo = () =&gt; { var a = 2 function innerFoo() { console.log(a) } fn = innerFoo } const bar = () =&gt; { fn() } foo() bar() 正常来讲，根据调用栈的知识，foo 函数执行完毕之后，其执行环境生命周期会结束，所占内存被垃圾收集器释放，上下文消失。但是通过 innerFoo 函数赋值给 fn，fn 是全局变量，这就导致了 foo 的变量对象 a 也被保留了下来。所以函数 fn 在函数 bar 内部执行时，依然可以访问这个被保留下来的变量对象，输出结果为 2。

4. var fn = null const foo = () =&gt; { var a = 2 function innerFoo() { console.log(c) console.log(a) } fn = innerFoo } const bar = () =&gt; { var c = 100 fn() } foo() bar() 在 bar 中执行 fn() 时，fn() 已经被复制为 innerFoo，变量 c 并不在其作用域链上，c 只是 bar 函数的内部变量。因此报错 ReferenceError: c is not defined。

5. 如何利用闭包实现单例模式

对象

1.两数之和

2.非波纳契数列

3.栈

4.队列

4.链表

5. 树

新布置

哈希表

位运算

1.二分思想

2.动态规划（动态递推）

3. 哈希表

4. 堆

5. 链表

6. 优先队列

7.练习