node课程宏任务队列举例队列：timer poll check

node事件循环：
清空微任务队列有两个时机

  • 在第一次同步代码执行完毕后
  • timer中所有宏任务执行完之后，会依次切换队列 timer —> poll —> check（比如：在切换为timer 切换为 poll 之前）
  • 判断这2个的执行时机：前提条件，node中，setTimeout(() => {}, 0) = setTimeout(() => {}, 1) ```javascript

setTimeout(() => {}, 0) setImmediate(() => {}) // event loop 启动需要时间，如果直接运行这两行代码，会得到不确定顺序，是因为，启动如果花了1ms，会进入第二轮循环执行setTimeout,再setImmediate；如果没有1ms，那还是停留在第一轮循环，所以进入check阶段执行setiImmediate,再第二轮循环setTimeout

  1. **浏览器事件循环：**<br />清空微任务队列有两个时机
  3. - 在第一个同步任务执行完毕后清空微任务队列
  4. - 在当前宏任务结束之后清空微任务队列
  5. - <br />
  7. 相同点：在同步代码执行完毕后都会去看一眼微任务队列是否有微任务<br />不同点:(其实它们没有什么可比性啊！！！)
  9. - node事件循环中nextTick的优先级高于promise的优先级
  12. 在基础讲解中学到的点
  14. - 会调试了
  15. - 写功能先写外层结构，先写需要方法名，再填充内容
  16. - 写一步测试一步
  17. - 学习源码的方法：先进入调试，再自己模拟实现，这样能加深印象，这也是快速了解一种新的API的方法，比拿着源码看有用多了
  18. - 学习源码就是要先会使用，再看源码
  19. - 边界条件应该放在独立功能的入口处
  21. <a name="zgm1h"></a>
  22. ## linkList实现
  23. ```javascript
  24. /* 
  25.   01 node + head + null 
  26.   02 head --->null 
  27.   03 size 
  29.   04 next element
  31.   05 增加 删除 修改 查询 清空 
  32. */
  34. class Node {
  35.   constructor(element, next) {
  36.       this.element = element
  37.     this.next = next
  38.   }
  39. }
  40. class _getNode(index) {
  41.   // second step: side condition
  42.   if (index < 0 || index >= this.size) {
  43.     throw new Error('cross the side')
  44.   }
  46.   // first step: main logic
  47.     let currentNode = this.head
  48.   for (let i = 0; i < index; i++) {
  49.       currentNode = currentNodex.next
  50.   }
  51. }
  52. class LinkList {
  53.     constructor(head, size) {
  54.       this.head = null
  55.     this.size = 0
  56.   }
  58.   add(index, element) {
  59.       if (arguments.length === 1) {
  60.         element = index
  61.       index = this.size
  62.     }
  64.     if (index < 0 || index > this.size) {
  65.         throw new Error('cross the border')
  66.     }
  68.     if (index === 0) {
  69.         let head = this.head
  70.       this.head = new Node(element, head)
  71.     } else {
  72.       let preNode = this._getNode(index-1)
  73.       preNode.next = new Node(element, preNode.next)
  74.     }
  75.     this.size++
  77.   }
  79.   remove(index) {
  80.     if (index === 0) {
  81.       // why can not head.next = head.next.next?
  82.         let head = this.head
  83.       this.head = head.next
  84.     } else {
  85.       let preNode = this._getNode(index-1)
  86.       preNode.next = preNode.next.next
  87.     }
  88.   }
  89.   set(index, element) {
  90.       let node = this._getNode(index)
  91.     node.element = element
  92.   }
  93.   get(index) {
  94.       return this._getNode(index)
  95.   }
  96.   clear() {
  97.       this.head = null
  98.     this.size = 0
  99.   }
  100. }
  102. // test
  103. const l1 = new LinkedList()
  104. l1.add('node1')
  105. console.log(l1)
  107. // result 
  108. LinkedList { head: Node { element: 'node1', next: null }, size: 1 }

require实现

  1. const { dir } = require('console')
  2. const fs = require('fs')
  3. const path = require('path')
  4. const vm = require('vm')
  6. function Module (id) {
  7.   this.id = id
  8.   this.exports = {}
  9.   console.log(1111)
  10. }
  12. Module._resolveFilename = function (filename) {
  13.   // 利用 Path 将 filename 转为绝对路径
  14.   let absPath = path.resolve(__dirname, filename)
  16.   // 判断当前路径对应的内容是否存在（）
  17.   if (fs.existsSync(absPath)) {
  18.     // 如果条件成立则说明 absPath 对应的内容是存在的
  19.     return absPath
  20.   } else {
  21.     // 文件定位
  22.     let suffix = Object.keys(Module._extensions)
  24.     for(var i=0; i<suffix.length; i++) {
  25.       let newPath = absPath + suffix[i]
  26.       if (fs.existsSync(newPath)) {
  27.         return newPath
  28.       }
  29.     }
  30.   }
  31.   throw new Error(`${filename} is not exists`)
  32. }
  34. Module._extensions = {
  35.   '.js'(module) {
  36.     // 读取
  37.     let content = fs.readFileSync(module.id, 'utf-8')
  39.     // 包装
  40.     content = Module.wrapper[0] + content + Module.wrapper[1] 
  42.     // VM 
  43.     let compileFn = vm.runInThisContext(content)
  45.     // 准备参数的值
  46.     let exports = module.exports
  47.     let dirname = path.dirname(module.id)
  48.     let filename = module.id
  50.     // 调用
  51.     compileFn.call(exports, exports, myRequire, module, filename, dirname)
  52.   },
  53.   '.json'(module) {
  54.     let content = JSON.parse(fs.readFileSync(module.id, 'utf-8'))
  56.     module.exports = content
  57.   }
  58. }
  60. Module.wrapper = [
  61.   "(function (exports, require, module, __filename, __dirname) {",
  62.   "})"
  63. ]
  65. Module._cache = {}
  67. Module.prototype.load = function () {
  68.   let extname = path.extname(this.id)
  70.   Module._extensions[extname](this)
  71. }
  73. function myRequire (filename) {
  74.   // 1 绝对路径
  75.   let mPath = Module._resolveFilename(filename)
  77.   // 2 缓存优先
  78.   let cacheModule = Module._cache[mPath]
  79.   if (cacheModule) return cacheModule.exports
  81.   // 3 创建空对象加载目标模块
  82.   let module = new Module(mPath)
  84.   // 4 缓存已加载过的模块
  85.   Module._cache[mPath] = module
  87.   // 5 执行加载（编译执行）
  88.   module.load()
  90.   // 6 返回数据
  91.   return module.exports
  92. }
  94. let obj = myRequire('./v')
  95. let obj2 = myRequire('./v')
  96. console.log(obj.age)

js中任务执行和node中任务执行对比

  1. // js中任务执行
  2. setTimeout(() => {
  3.   console.log('s1')
  4.   Promise.resolve().then(() => {
  5.     console.log('p2')
  6.   })
  7.   Promise.resolve().then(() => {
  8.     console.log('p3')
  9.   })
  10. })
  12. Promise.resolve().then(() => {
  13.   console.log('p1')
  14.   setTimeout(() => {
  15.     console.log('s2')
  16.   })
  17.   setTimeout(() => {
  18.     console.log('s3')
  19.   })
  20. })
  22. // p1 s1 p2 p3 s2 s3
  25. // node中任务执行
  26. setTimeout(() => {
  27.   console.log('s1')
  28.   Promise.resolve().then(() => {
  29.     console.log('p1')
  30.   })
  31.   process.nextTick(() => {
  32.     console.log('t1')
  33.   })
  34. })
  36. Promise.resolve().then(() => {
  37.   console.log('p2')
  38. })
  40. console.log('start')
  42. setTimeout(() => {
  43.   console.log('s2')
  44.   Promise.resolve().then(() => {
  45.     console.log('p3')
  46.   })
  47.   process.nextTick(() => {
  48.     console.log('t2')
  49.   })
  50. })
  52. console.log('end')
  54. // start, end， p2, s1, s2 , t1, t2, p1, p3

控制写入速度

  1. /**
  2.  * 需求：“拉勾教育” 写入指定的文件
  3.  * 01 一次性写入
  4.  * 02 分批写入
  5.  * 03 中文一次就是3位，我还疑惑为啥打印了4次
  6.  * 对比：
  7.  */
  8. let fs = require('fs')
  10. let ws = fs.createWriteStream('test.txt', {
  11.   highWaterMark: 3
  12. })
  14. // ws.write('拉勾教育')
  15. let source = "拉勾教育".split('')
  16. let num = 0
  17. let flag = true
  19. function executeWrite () {
  20.   flag = true
  21.   while(num !== 4 && flag) {
  22.     flag = ws.write(source[num])
  23.     num++
  24.   }
  25. }
  27. executeWrite()
  29. ws.on('drain', () => {
  30.   console.log('drain 执行了')
  31.   executeWrite()
  32. })
  34. // pipe
  36. // result
  37. drain 执行了
  38. drain 执行了
  39. drain 执行了
  40. drain 执行了

redis的由来

  • 因为mysql数据库的开发者不满足于性能，所以redidis一定是一款高性能的
  • remote dictionary server 远程字典服务器