【前端知识体系-NodeJS相关】NodeJS高频前端面试题整理

1. 为什么JavaScript是单线程？

• 防止DOM渲染冲突的问题；
• Html5中的Web Worker可以实现多线程

2.什么是任务队列？

任务队列"是一个先进先出的数据结构，排在前面的事件，优先被主线程读取。主线程的读取过程基本上是自动的，只要执行栈一清空，"任务队列"上第一位的事件就自动进入主线程。

2.1 同步和异步任务

1. 同步任务指的是，在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务；
2. 异步任务指的是，不进入主线程、而进入"任务队列"（task queue）的任务，只有"任务队列"通知主线程，某个异步任务可以执行了，该任务才会进入主线程执行。

2.2 执行流程

1. 所有同步任务都在主线程上执行，形成一个执行栈（execution context stack）。
2. 主线程之外，还存在一个"任务队列"（task queue）。只要异步任务有了运行结果，就在"任务队列"之中放置一个事件。
3. 一旦"执行栈"中的所有同步任务执行完毕，系统就会读取"任务队列"，看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入执行栈，开始执行。
4. 主线程不断重复上面的第三步。

3. 什么是事件循环（EventLoop）？

主线程从"任务队列"中读取事件，这个过程是循环不断的，所以整个的这种运行机制又称为Event Loop（事件循环）。

3.1 定时器函数的基本使用方法对比？

• setTimeout ： 只是将事件插入了"任务队列"，必须等到当前代码（执行栈）执行完，主线程才会去执行它指定的回调函数
• process.nextTick ： 在当前"执行栈"的尾部----下一次Event Loop（主线程读取"任务队列"）之前----触发回调函数。（所有的异步任务被触发之前执行）
• setImmediate：在当前"任务队列"的尾部添加事件，也就是说，它指定的任务总是在下一次Event Loop时执行，这与setTimeout(fn, 0)很像。

3.2 setImmediate和setTimeout 哪个回调函数先执行呢？

setImmediate(function (){
setImmediate(function A() {
  console.log(1);
  setImmediate(function B(){console.log(2);});
});

setTimeout(function timeout() {
  console.log('TIMEOUT FIRED');
}, 0);
});
// 1
// TIMEOUT FIRED
// 2

[!NOTE]
上面代码中，setImmediate和setTimeout被封装在一个setImmediate里面，它的运行结果总是1--TIMEOUT FIRED--2，这时函数A一定在timeout前面触发。至于2排在TIMEOUT FIRED的后面（即函数B在timeout后面触发），是因为setImmediate总是将事件注册到下一轮Event Loop，所以函数A和timeout是在同一轮Loop执行，而函数B在下一轮Loop执行。

3.3 process.nextTick和setImmediate的区别？

多个process.nextTick语句总是在当前"执行栈"一次执行完，多个setImmediate可能则需要多次loop才能执行完。

4. 说一下NodeJS的运行机制？

1. V8引擎解析JavaScript脚本。
2. 解析后的代码，调用Node API。
3. libuv库负责Node API的执行。它将不同的任务分配给不同的线程，形成一个Event Loop（事件循环），以异步的方式将任务的执行结果返回给V8引擎。
4. V8引擎再将结果返回给用户。

5. Node创建线程的方法和区别？

5.1 Node的单线程

1. Node.js 是以单线程的模式运行的，但它使用的是事件驱动来处理并发，这样有助于我们在多核 cpu 的系统上创建多个子进程，从而提高性能。

2. 每个子进程总是带有三个流对象：child.stdin, child.stdout 和child.stderr。他们可能会共享父进程的 stdio 流，或者也可以是独立的被导流的流对象。

3. Node 提供了 child_process 模块来创建子进程

5.2 创建进程的方法

1. exec - child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式一次性返回。exec方法会从子进程中返回一个完整的buffer。默认情况下，这个buffer的大小应该是200k。如果子进程返回的数据大小超过了200k，程序将会崩溃，同时显示错误信息“Error：maxBuffer exceeded”。你可以通过在exec的可选项中设置一个更大的buffer体积来解决这个问题，但是你不应该这样做，因为exec本来就不是用来返回很多数据的方法。

2. spawn - child_process.spawn 使用指定的命令行参数创建新进程。spawn 会返回一个带有stdout和stderr流的对象。你可以通过stdout流来读取子进程返回给Node.js的数据。stdout拥有’data’,’end’以及一般流所具有的事件。当你想要子进程返回大量数据给Node时，比如说图像处理，读取二进制数据等等，你最好使用spawn方法。

3. fork - child_process.fork 是 spawn()的特殊形式，用于在子进程中运行的模块，如 fork(‘./son.js’) 相当于 spawn(‘node’, [‘./son.js’]) 。与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。

5.3 实例分析

5.3.1 exec

  require('child_process').exec('dir', {encoding: ‘utf-8’}, function(err, stdout, stderr) {
      if (err) {
          console.log(error.stack);
          console.log('Error code: ' + error.code);
          console.log('Signal received: ' + error.signal);
      }
      //console.log(err, stdout, stderr);
      console.log('data : ' + stdout);
  }).on('exit', function (code) {
      console.log('子进程已退出, 退出码 ' + code);
  });

5.3.2 spawn

  var child_process = require('child_process');
  var spawnObj = child_process.spawn('ping', ['127.0.0.1'], {encoding: 'utf-8'});
  spawnObj.stdout.on('data', function(chunk) {
      console.log(chunk.toString());
  });
  spawnObj.stderr.on('data', (data) => {
    console.log(data);
  });
  spawnObj.on('close', function(code) {
      console.log('close code : ' + code);
  }
  spawnObj.on('exit', (code) => {
      console.log('exit code : ' + code);
      fs.close(fd, function(err) {
          if(err) {
              console.error(err);
          }
      });
  });

5.3.3 fork

分为 “父进程”（parent.js） 和”子进程”（child.js）。在命令行执行的时候要切换到上述文件的目录中，否则会找不到子进程。

parent.js

  console.log('parent pid: ' + process.pid);
  var fork = require('child_process').fork;
  //fork方法返回的是子进程
  var child = fork('./child.js');
  console.log('fork return pid: ' + child.pid);
  child.on('message', function(msg){
      console.log('parent get message: ' + JSON.stringify(msg));
  });
  child.send({key: 'parent value'});

child.js

  console.log('child pid: ' + process.pid);
  process.on('message', function(msg){
      console.log('child get message: ' + JSON.stringify(msg));
  });
  process.send({key: 'child value'});

6. 介绍一下express或koa框架的基本架构？

1. Express 是一个Node.js的基础框架，主要基于 Connect 中间件，并且自身封装了路由(需要配合bodyParser)、视图处理等功能，使用人数众多，弊端是callback回调方式。

2. Koa 是一个比Express更精简，使用node新特性的中间件框架。其提供的是一个架子，而几乎所有的功能都需要由第三方中间件完成，比如koa-router, koa-view等。

[!NOTE]
Koa 利用 co 作为底层运行框架，利用 Generator 的特性，实现“无回调”的异步处理

6.1 处理路由

6.1.1 Express

[!NOTE]
使用 express.Router 类来创建可安装的模块化路由处理程序。Router 实例是完整的中间件和路由系统，以下示例将路由器创建为模块，在其中装入中间件，定义一些路由，然后安装在主应用程序的路径中。

  var express = require('express');
  var router = express.Router();
  router.use(function timeLog(req, res, next) {
    console.log('Time: ', Date.now());
    next();
  });
  // define the home page route
  router.get('/', function(req, res) {
    res.send('Birds home page');
  });
  // define the about route
  router.get('/about', function(req, res) {
    res.send('About birds');
  });

  module.exports = router;

接着，在应用程序中装入路由器模块：

  var routes = require('./route');
  ...
  app.use('/route', routes);

6.1.2 Koa

路由处理 Express 是自身集成的，而 Koa 需要引入中间件

var koa = require('koa')
var route = require('koa-route') //中间件
var app = koa()
app.use(route.get('/', function *(){
  this.body = 'Hello World'
}))

6.2 HTTP Request

[!NOTE]
两个框架都封装了HTTP Request对象，有一点不同是 Koa v1 使用 this 取代 Express 的 req、res。

6.2.1 Express

  var app = require('express')()
  app.get('/room/:id', function (req, res) {
    console.log(req.params)
  })
  // 获取POST数据需要 body-parser 中间件
  var bodyParser = require('body-parser')
  app.use(bodyParser.json())
  app.post('/sendgift', function (req, res) {
    console.log(req.body)
  })

6.2.2 Koa

  var app = require('koa')()
  var route = require('koa-route')

  app.use(route.get('/room/:id', function *() {
    console.log(this.req.query)
  }))

  // 获取POST数据需要 co-body 中间件
  var parse = require('co-body')
  app.use(route.post('/sendgift', function *() {
    var post = yield parse(this.request)
    console.log(post)
  }))

6.3 区别

6.3.1 异步流程控制

Express 采用 callback 来处理异步，Koa v1 采用 generator，Koa v2 采用 async/await。

6.3.2 错误处理

Express 使用 callback 捕获异常，对于深层次的异常捕获不了，
Koa 使用 try catch，能更好地解决异常捕获。

  // Express callback
  app.use(function (err, req, res, next) {
    console.error(err.stack)
    res.status(500).send('Something broke!')
  })
  // Koa generator
  app.use(function *(next) {
    try {
      yield next
    } catch (err) {
      this.status = err.status || 500
      this.body = { message: err.message }
      this.app.emit('error', err, this)
    }
  })
  // Koa async/await
  app.use(async (ctx, next) => {
    try {
      await next()
    } catch (err) {
      ctx.status = err.status || 500
      ctx.body = { message: err.message }
      ctx.app.emit('error', err, this)
    }
  })

6.3.3 中间件处理

1. Express中app.use就是往中间件数组中塞入新的中间件，中间件处理方式是线性的，next过后继续寻找下一个中间件。 一个请求进来经过一系列中间件处理后再响应给用户，清晰明了。

2. 缺点：基于 callback 组合业务逻辑，业务逻辑复杂时嵌套过多，异常捕获困难。

3. Koa的中间件处理方式是一个洋葱模型，koa处理完中间件后还会回来走一趟，这就给了我们更加大的操作空间。

  const Koa = require('koa');
  const app = new Koa();

  // x-response-time
  app.use(async (ctx, next) => {
    const start = Date.now();
    await next();
    const ms = Date.now() - start;
    ctx.set('X-Response-Time', `${ms}ms`);
  });

  // logger
  app.use(async (ctx, next) => {
    const start = Date.now();
    await next();
    const ms = Date.now() - start;
    console.log(`${ctx.method} ${ctx.url} - ${ms}`);
  });

  // response
  app.use(async ctx => {
    ctx.body = 'Hello World';
  });

[!NOTE]
当koa处理中间件遇到await next()的时候会暂停当前中间件进而处理下一个中间件，最后再回过头来继续处理剩下的任务