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

  1. 为什么JavaScript是单线程?#

防止DOM渲染冲突的问题;

Html5中的Web Worker可以实现多线程

2.什么是任务队列?#

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

2.1 同步和异步任务#

同步任务指的是,在主线程上排队执行的任务,只有前一个任务执行完毕,才能执行后一个任务;

异步任务指的是,不进入主线程、而进入"任务队列"(task queue)的任务,只有"任务队列"通知主线程,某个异步任务可以执行了,该任务才会进入主线程执行。

2.2 执行流程#

所有同步任务都在主线程上执行,形成一个执行栈(execution context stack)。

主线程之外,还存在一个"任务队列"(task queue)。只要异步任务有了运行结果,就在"任务队列"之中放置一个事件。

一旦"执行栈"中的所有同步任务执行完毕,系统就会读取"任务队列",看看里面有哪些事件。那些对应的异步任务,于是结束等待状态,进入执行栈,开始执行。

主线程不断重复上面的第三步。

  1. 什么是事件循环(EventLoop)?#

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

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

setTimeout : 只是将事件插入了"任务队列",必须等到当前代码(执行栈)执行完,主线程才会去执行它指定的回调函数

process.nextTick : 在当前"执行栈"的尾部----下一次Event Loop(主线程读取"任务队列")之前----触发回调函数。(所有的异步任务被触发之前执行)

setImmediate:在当前"任务队列"的尾部添加事件,也就是说,它指定的任务总是在下一次Event Loop时执行,这与setTimeout(fn, 0)很像。

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

Copy

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才能执行完。

  1. 说一下NodeJS的运行机制?#

V8引擎解析JavaScript脚本。

解析后的代码,调用Node API。

libuv库负责Node API的执行。它将不同的任务分配给不同的线程,形成一个Event Loop(事件循环),以异步的方式将任务的执行结果返回给V8引擎。

V8引擎再将结果返回给用户。

  1. Node创建线程的方法和区别?#

5.1 Node的单线程#

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

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

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

5.2 创建进程的方法#

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

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

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

5.3 实例分析#

5.3.1 exec#

Copy

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#

Copy

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

Copy

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

Copy

console.log('child pid: ' + process.pid);

process.on('message', function(msg){

console.log('child get message: ' + JSON.stringify(msg));

});

process.send({key: 'child value'});

  1. 介绍一下express或koa框架的基本架构?#

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

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

[!NOTE]

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

6.1 处理路由#

6.1.1 Express#

[!NOTE]

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

Copy

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;

接着,在应用程序中装入路由器模块:

Copy

var routes = require('./route');

...

app.use('/route', routes);

6.1.2 Koa#

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

Copy

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#

Copy

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#

Copy

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,能更好地解决异常捕获。

Copy

// 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 中间件处理#

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

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

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

Copy

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()的时候会暂停当前中间件进而处理下一个中间件,最后再回过头来继续处理剩下的任务

我来评几句
登录后评论

已发表评论数()

相关站点

热门文章