NO Dead 大厂面石

Node

 Node是什么？

// 1.Node是开源的js运行环境

node对于js代码的处理是只有一个线程，但其并不是单线程的还有其他线程是用来处理IO的

2.是 基于事件驱动和非阻塞IO的模型，在运行时处理大量的并发连接

//非阻塞IO:node对于js代码的处理是只有一个线程，但其并不是单线程的还有其他线程是用来处理IO的
具体的做法就是把所有耗时的任务全部作异步处理打包成一个请求对象放到异步模块里面
异步对象有结果后会放到事件循环里面等待执行，当调用栈清空时会按照特定的顺序去执行事件队列里面的
异步请求

事件驱动：就是以事件驱动去处理异步IO,
// 同步任务会直接放到调用栈里面去执行
// node中的异步API的分类
// 1.定时器（定时器队列）
// 2.IO:文件读写，网络请求，数据库操作等（Poll队列）
// 3.process.nextTick(),setimmediate（check队列）
// 同步任务会直接放到调用栈去执行，异步任务会放到异步模块等待执行
// 调用栈被清空后没有事件执行的时候指针会指向事件循环队列的Poll，(始终优先处理IO（当定时器和io同时执行回调时）)
// node里面还有一个特殊的任务队列nextTick,它有限于定时器和IO,check
// 微任务队列在定时器前面nextTick后面执行,它有限于定时器和IO,check
// 总的来说：就是当调用栈执行完毕后，异步模块有没有已经加载完的任务有的话按照
// nextTick()->微任务->定时器——>IO->check

2.Node异常处理

// 4.node异常处理
// 同步代码可以用trycatch处理
// 异步代码promise使用promise的.catch捕获异常
// 异步代码里里面async/await使用try catch捕获
// node自带的捕获未处理异常的方法process.on('uncaughtException')

3.Eventemitter（观察者模式）

// 核心方法EventEmitter类（属于观察者模式）
// stream就是eventemitter的实例
// 所有流都是EventEmitter的实例
// on方法用于注册监听器，once方法注册一次性监听器，emit触发事件，
// removeListener方法移除某个事件的监听器
const { EventEmitter } = require('events')
const Em = new EventEmitter()
Em.on('pross', (params) => {
  console.log(1);
})
Em.on('pross', (params) => {
  console.log(2);
})
Em.on('pross', (params) => {
  console.log(3);
})
//有一些类似一数组的操作方法
// 把方法插入到数组的最前方
Em.prependListener('pross', (par) => {
  console.log(par);
})
Em.emit('pross', '程序员小郭')

4.什么是buffer?

// 什么是buffer?
// 在node中用于存放缓存数据的地方:
// 当发送速率大于接收速率时buffer可以暂存多余的数据,直到接收方准备好了
// 新建一个buffer对象使用 buffer.alloc(size,[fill],[enconding]) fill填充到缓冲区的值,enconding(fill的编码格式)
// 1.初始化缓冲区
const buffer = Buffer.alloc(5)
// console.log(buffer); <Buffer 00 00 00 00 00 >
// 写入值
buffer.write("hellow!")
// 超出长度的值将不会被输出
// console.log(buffer); <Buffer 68 65 6c 6c 6f >
// 使用tostring方法转换成字符串
// console.log(buffer.toString());hello
//将字符串转换成一个类数组
const buffers = Buffer.from('字符串', 'utf8')
console.log(buffers);//229
// 也可以进行tostring,silce

5.复习异步编程模式

// 5.异步编程和流程控制
// 1.回调函数
const { promises } = require('dns');
const fs = require('fs')
fs.readFile('../两数之和.js', 'utf8', (err, data) => {
  if (err) return
  console.log(data);
})
fs.readFile('../url提取.js', 'utf8', (err, data) => {
  if (err) return
  console.log(data);
})
fs.readFile('../白屏时间长怎么优化.js', 'utf8', (err, data) => {
  if (err) return
  console.log(data);
})
// 这种方法出来的结果顺序时不确定的
// 为了保证顺序就要回调函数层层嵌套,是的代码可维护可读性变差,产后了回调地狱
fs.readFile('../两数之和.js', 'utf8', (err, data) => {
  if (err) return
  console.log(data);
  fs.readFile('../url提取.js', 'utf8', (err, data) => {
    if (err) return
    console.log(data);
    fs.readFile('../白屏时间长怎么优化.js', 'utf8', (err, data) => {
      if (err) return
      console.log(data);
    })
  })
})
//2.为了解决在es6里面出来promise的链式调用
fs.promises.readFile('a.txt', 'utf8').then((data) => {
  console.log(data);
  return fs.promises.readFile('b.txt', 'utf8')
}).then((data) => {
  console.log(data);
  return fs.promises.readFile('c.txt', 'utf8')
}).then((data) => {
  console.log(data);
}).catch1(err => console.log(err))
// promise使得代码更加简介明了
// promise同时处理多个任务
const a = fs.promises.readFile('a.txt', 'utf8')
const b = fs.promises.readFile('b.txt', 'utf8')
const c = fs.promises.readFile('c.txt', 'utf8')
Promise.all([a, b, c]).then(data => {
  console.log(data);
}).catch(err => console.log(err))
// 3.async/await
async function ReadFile(param) {
  try {
    const a = await fs.promises.readFile('a.txt', 'utf8')
    console.log(a);
    const b = await fs.promises.readFile('b.txt', 'utf8')
    console.log(b);
    const c = await fs.promises.readFile('c.txt', 'utf8')
    console.log(c);
  } catch (error) { console.log(err); }
}