前端面试题（Node）

骑猪看日落 2022-01-31 11:09 76阅读 0赞

## Node ##

\*\*1. 为什么要用node? \*\*  
特点:简单强大，轻量可扩展．简单体现在`node`使用的是`javascript,json`来进行编码，人人都会；  
强大体现在非阻塞IO,可以适应分块传输数据，较慢的网络环境，尤其擅长高并发访问；轻量体现在`node`本身既是代码，又是服务器，前后端使用统一语言;可扩展体现在可以轻松应对多实例，多服务器架构，同时有海量的第三方应用组件

**2. node的构架是什么样子的?**  
主要分为三层，应用**app >> V8及node内置架构 >> 操作系统.**  
V8是node运行的环境，可以理解为node虚拟机．node内置架构又可分为三层: 核心模块(`javascript`实现) >> `c++`绑定 >> `libuv + CAes + http`.

**3. node有哪些核心模块?**

EventEmitter, Stream, FS, Net和全局对象

**4、node有哪些全局对象?**

process, console, Buffer和exports

**5、 process有哪些常用方法?**

process.stdin, process.stdout, process.stderr, process.on, process.env, process.argv, process.arch, process.platform, process.exit

**6、console有哪些常用方法?**

console.log/console.info, console.error/console.warning, console.time/console.timeEnd, console.trace, console.table

**7、node有哪些定时功能?**

setTimeout/clearTimeout, setInterval/clearInterval, setImmediate/clearImmediate, process.nextTick

**8、node中的事件循环是什么样子的?**

总体上执行顺序是：`process.nextTick >> setImmidate >> setTimeout/SetInterval`  
[链接][Link 1]

**9、node中的Buffer如何应用?**  
`Buffer`是用来处理二进制数据的，比如图片，mp3,数据库文件等.`Buffer`支持各种编码解码，二进制字符串互转．

\*\*10、什么是EventEmitter? \*\*  
`EventEmitter`是`node`中一个实现观察者模式的类，主要功能是监听和发射消息，用于处理多模块交互问题.

**11、如何实现一个EventEmitter?**  
主要分三步：定义一个子类，调用构造函数，继承`EventEmitter`  
代码演示

var util = require(‘util’);  
var EventEmitter = require(‘events’).EventEmitter;

function MyEmitter() { 
        EventEmitter.call(this); 
    } // 构造函数 
    
    util.inherits(MyEmitter, EventEmitter); // 继承 
    
    var em = new MyEmitter(); 
    em.on('hello', function(data) { 
        console.log('收到事件hello的数据:', data); 
    }); // 接收事件，并打印到控制台 
    em.emit('hello', 'EventEmitter传递消息真方便!');

**12、EventEmitter有哪些典型应用?**  
1) 模块间传递消息  
2) 回调函数内外传递消息  
3) 处理流数据，因为流是在EventEmitter基础上实现的.  
4) 观察者模式发射触发机制相关应用

**13、怎么捕获EventEmitter的错误事件?**  
监听`error`事件即可．如果有多个`EventEmitter`,也可以用`domain`来统一处理错误事件.

代码演示

var domain = require('domain'); 
    var myDomain = domain.create(); 
    myDomain.on('error', function(err){ 
        console.log('domain接收到的错误事件:', err); 
    }); // 接收事件并打印 
    myDomain.run(function(){ 
        var emitter1 = new MyEmitter(); 
        emitter1.emit('error', '错误事件来自emitter1'); 
        emitter2 = new MyEmitter(); 
        emitter2.emit('error', '错误事件来自emitter2'); 
    });

**14、EventEmitter中的newListenser事件有什么用处?**  
`newListener`可以用来做事件机制的反射，特殊应用，事件管理等．当任何on事件添加到`EventEmitter`时，就会触发`newListener`事件，基于这种模式，我们可以做很多自定义处理.

代码演示

\*\*15、什么是Stream? \*\*  
`stream`是基于事件`EventEmitter`的数据管理模式．由各种不同的抽象接口组成，主要包括可写，可读，可读写，可转换等几种类型．

**16、Stream有什么好处?**  
非阻塞式数据处理提升效率，片断处理节省内存，管道处理方便可扩展等.

**17、Stream有哪些典型应用?**  
文件，网络，数据转换，音频视频等

**18、怎么捕获Stream的错误事件?**  
监听`error`事件，方法同`EventEmitter`

\*\*19、有哪些常用Stream,分别什么时候使用? \*\*  
`Readable`为可被读流，在作为输入数据源时使用；`Writable`为可被写流,在作为输出源时使用；`Duplex`为可读写流,它作为输出源接受被写入，同时又作为输入源被后面的流读出．`Transform`机制和`Duplex`一样，都是双向流，区别时`Transfrom`只需要实现一个函数`_transfrom(chunk, encoding, callback);`而`Duplex`需要分别实现`_read(size)`函数和`_write(chunk, encoding, callback)`函数.

\*\*20、实现一个Writable Stream? \*\*  
三步走:1)构造函数`call Writable`  
2)　继承Writable `在这里插入代码片`  
3) 实现`_write(chunk, encoding, callback)`函数

代码演示

var Writable = require('stream').Writable;
    var util = require('util');
     
    function MyWritable(options) {
        Writable.call(this, options); 
    } // 构造函数 
    util.inherits(MyWritable, Writable); // 继承自Writable 
    MyWritable.prototype._write = function(chunk, encoding, callback) {
        console.log("被写入的数据是:", chunk.toString()); // 此处可对写入的数据进行处理 
        callback(); 
    };
     
    process.stdin.pipe(new MyWritable()); // stdin作为输入源，MyWritable作为输出源

**21、内置的fs模块架构是什么样子的?**  
`fs`模块主要由下面几部分组成:  
1) `POSIX`文件`Wrapper`,对应于操作系统的原生文件操作  
2) 文件流 `fs.createReadStream`和`fs.createWriteStream`  
3) 同步文件读写,`fs.readFileSync`和`fs.writeFileSync`  
4) 异步文件读写, `fs.readFile`和`fs.writeFile`

\*\*22、读写一个文件有多少种方法? \*\*  
1) POSIX式低层读写  
2) 流式读写  
3) 同步文件读写  
4) 异步文件读写

**23、怎么读取json配置文件?**  
第一种是利用`node`内置的`require('data.json')`机制，直接得到js对象;  
第二种是读入文件入内容，然后用`JSON.parse(content)`转换成`js`对象．二者的区别是`require`机制情况下，如果多个模块都加载了同一个`json`文件，那么其中一个改变了`js`对象，其它跟着改变，这是由`node`模块的缓存机制造成的，只有一个`js`模块对象; 第二种方式则可以随意改变加载后的`js`变量，而且各模块互不影响，因为他们都是独立的，是多个`js`对象.

**24、fs.watch和fs.watchFile有什么区别，怎么应用?**  
`fs.watch`利用操作系统原生机制来监听，可能不适用网络文件系统; `fs.watchFile`则是定期检查文件状态变更，适用于网络文件系统，但是相比`fs.watch`有些慢，因为不是实时机制．

**25、node的网络模块架构是什么样子的?**  
`node`全面支持各种网络服务器和客户端，包括`tcp, http/https, tcp, udp, dns, tls/ssl`等.

**26、node是怎样支持https,tls的?**  
1) `openssl`生成公钥私钥  
2) 服务器或客户端使用`https`替代`http`  
3) 服务器或客户端加载公钥私钥证书

**27、实现一个简单的http服务器?**  
思路是加载http模块，创建服务器，监听端口.

代码演示

var http = require('http'); // 加载http模块 
    
    http.createServer(function(req, res) { 
        res.writeHead(200, {'Content-Type': 'text/html'}); // 200代表状态成功, 文档类型是给浏览器识别用的 
        res.write('<meta charset="UTF-8"><h1>我是标题啊！</h1><font color="red">这么原生，初级的服务器，下辈子能用着吗?!</font>'); // 返回给客户端的html数据 
        res.end(); // 结束输出流 
    }).listen(3000); // 绑定3ooo, 查看效果请访问 http://localhost:3000

\*\*28、为什么需要child-process? \*\*  
`node`是异步非阻塞的，这对高并发非常有效．可是我们还有其它一些常用需求，比如和操作系统`shell`命令交互，调用可执行文件，创建子进程进行阻塞式访问或高CPU计算等，`child-process`就是为满足这些需求而生的．`child-process`顾名思义，就是把`node`阻塞的工作交给子进程去做．

**29、exec,execFile,spawn和fork都是做什么用的?**  
`exec`可以用操作系统原生的方式执行各种命令，如管道 cat ab.txt | grep hello;  
`execFile`是执行一个文件;  
`spawn`是流式和操作系统进行交互;  
`fork`是两个`node`程序(`javascript`)之间时行交互.

**30、实现一个简单的命令行交互程序?**  
spawn

代码演示

var cp = require('child_process'); 
    
    var child = cp.spawn('echo', ['你好', "钩子"]); // 执行命令 
    child.stdout.pipe(process.stdout); // child.stdout是输入流，process.stdout是输出流 
    // 这句的意思是将子进程的输出作为当前程序的输入流，然后重定向到当前程序的标准输出，即控制台

\*\*31、两个node程序之间怎样交互? \*\*  
用fork嘛，上面讲过了．原理是子程序用`process.on, process.send`，父程序里用`child.on,child.send`进行交互.  
代码演示

1) fork-parent.js 
    var cp = require('child_process'); 
    var child = cp.fork('./fork-child.js'); 
    child.on('message', function(msg){ 
        console.log('老爸从儿子接受到数据:', msg); 
    }); 
    child.send('我是你爸爸，送关怀来了!'); 
    
    2) fork-child.js 
    process.on('message', function(msg){ 
        console.log("儿子从老爸接收到的数据:", msg); 
        process.send("我不要关怀，我要银民币！"); 
    });

\*\*32、怎样让一个js文件变得像linux命令一样可执行? \*\*  
1) 在`myCommand.js`文件头部加入`#!/usr/bin/env node`  
2) `chmod`命令把js文件改为可执行即可  
3) 进入文件目录，命令行输入`myComand`就是相当于`node myComand.js`了

**33、child-process和process的stdin,stdout,stderror是一样的吗?**  
概念都是一样的，输入，输出，错误，都是流．区别是在父程序眼里，子程序的`stdout`是输入流，`stdin`是输出流

**34、node中的异步和同步怎么理解**  
node是单线程的，异步是通过一次次的循环事件队列来实现的．同步则是说阻塞式的IO,这在高并发环境会是一个很大的性能问题，所以同步一般只在基础框架的启动时使用，用来加载配置文件，初始化程序什么的

\*\*35、有哪些方法可以进行异步流程的控制? \*\*  
1) 多层嵌套回调  
2)　为每一个回调写单独的函数，函数里边再回调  
3) 用第三方框架比方`async, q, promise`等

**36、怎样绑定node程序到80端口?**  
1) `sudo`  
2) `apache/nginx`代理  
3) 用操作系统的`firewall iptables`进行端口重定向

**37、有哪些方法可以让node程序遇到错误后自动重启?**  
1) `runit`  
2) `forever`  
3) `nohup npm start &`

**38、怎样充分利用多个CPU?**  
一个CPU运行一个node实例

**39、怎样调节node执行单元的内存大小？**  
用`--max-old-space-size` 和 `--max-new-space-size` 来设置 v8 使用内存的上限

\*\*40、程序总是崩溃，怎样找出问题在哪里? \*\*  
1) `node --prof` 查看哪些函数调用次数多  
2) `memwatch`和`heapdump`获得内存快照进行对比，查找内存溢出

\*\*41、有哪些常用方法可以防止程序崩溃? \*\*  
1) `try-catch-finally`  
2) `EventEmitter/Stream error`事件处理  
3) `domain`统一控制  
4) `jshint`静态检查  
5) `jasmine/mocha`进行单元测试

**42、怎样调试node程序?**  
`node --debug app.js` 和`node-inspector`

**43、async都有哪些常用方法，分别是怎么用?**  
`async`是一个`js`类库，它的目的是解决`js`中异常流程难以控制的问题．`async`不仅适用在`node.js`里，浏览器中也可以使用．  
1) `async.parallel`并行执行完多个函数后，调用结束函数

async.parallel([ 
        function(){ ... }, 
        function(){ ... } 
    ], callback);

1.  `async.series`串行执行完多个函数后，调用结束函数

async.series([ 
        function(){ ... }, 
        function(){ ... } 
     ]);

1.  `async.waterfall`依次执行多个函数，后一个函数以前面函数的结果作为输入参数

async.waterfall([ 
       function(callback) { 
           callback(null, 'one', 'two'); 
       }, 
       function(arg1, arg2, callback) { 
         // arg1 now equals 'one' and arg2 now equals 'two' 
           callback(null, 'three'); 
       }, 
       function(arg1, callback) { 
           // arg1 now equals 'three' 
           callback(null, 'done'); 
       } 
    ], function (err, result) { 
       // result now equals 'done' 
    });

1.  `async.map`异步执行多个数组，返回结果数组

async.map(['file1','file2','file3'], fs.stat, function(err, results){ 
      // results is now an array of stats for each file 
    });

1.  `async.filter`异步过滤多个数组，返回结果数组

async.filter(['file1','file2','file3'], fs.exists, function(results){ 
      // results now equals an array of the existing files 
    });

**44、express项目的目录大致是什么样子的**

app.js, package.json, bin/www, public, routes, views.

**45、express常用函数**  
`express.Router`路由组件,`app.get`路由定向，`app.configure`配置，`app.set`设定参数,`app.use`使用中间件

**46、express中如何获取路由的参数**  
`/users/:name`使用`req.params.name`来获取;  
`req.body.username`则是获得表单传入参数`username`;  
`express`路由支持常用通配符 `?, +, *, and ()`

**47、express response有哪些常用方法**  
`res.download()` 弹出文件下载  
`res.end()` 结束response  
`res.json()` 返回json `在这里插入代码片`  
`res.jsonp()` 返回jsonp  
`res.redirect()` 重定向请求  
`res.render()` 渲染模板  
`res.send()` 返回多种形式数据  
`res.sendFile` 返回文件  
`res.sendStatus()` 返回状态

**48、mongodb有哪些常用优化措施**  
类似传统数据库，索引和分区

**49、mongoose是什么？有支持哪些特性?**  
`mongoose`是`mongodb`的文档映射模型．主要由`Schema`, `Model`和`Instance`三个方面组成．  
`Schema`就是定义数据类型，  
`Model`就是把`Schema`和`js`类绑定到一起，  
`Instance`就是一个对象实例．  
常见`mongoose`操作有,`save, update, find. findOne, findById, static`方法等

**50、redis支持哪些功能**

set/get, mset/hset/hmset/hmget/hgetall/hkeys, sadd/smembers, publish/subscribe, expire

**51、redis最简单的应用**

var redis = require("redis"), 
       client = redis.createClient(); 
    
    client.set("foo_rand000000000000", "some fantastic value"); 
    client.get("foo_rand000000000000", function (err, reply) { 
       console.log(reply.toString()); 
    }); 
    client.end();

**52、apache,nginx有什么区别?**  
二者都是代理服务器，功能类似．  
`apache`应用简单，相当广泛．  
`nginx`在分布式，静态转发方面比较有优势

[Link 1]: https://github.com/nodejs/node/blob/master/doc/topics/event-loop-timers-and-nexttick.md