入门 node.js 你必须知道的那些事

Posted JavaScript

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了入门 node.js 你必须知道的那些事相关的知识，希望对你有一定的参考价值。

最基本的一些操作和概念

用 node 执行一段 js 代码

  1. 在命令行中用 cd 切换到桌面

  2. 创建一个文件夹和并用 cd 命令切换到这个文件夹mkdir nodeTest && cd nodeTest

  3. 创建一个 js 文件并写上简单的 js 代码 touch a.js

 
   
   
 
    
  
    
    
  
  1.     var a = 10;
    2. 
  
    
    
  
  2.     console.log(a);
    3. 
  
    
    
  
  3.     console.log(a + 10);
    4.

  1. 在命令行中输入 node a.js 命令行会输出 10 20

node 引用文件的方式

  1. Node.js 采用了 CommonJS 规范, 通过 require 来引入一个 js 文件

  2. 新建文件 b.js 并在文件中引入 a.js

    • touch b.js

    • require('./a.js')

  3. 执行 b.js

    • node b.js 命令行会输出 10 20

node 中的模块概念

  1. node 中一个模块就是一个 js 文件，多个模块组成一个特定功能的一堆文件叫包

  2. 一个 js 文件可以定义它自己暴露给外部的变量 (意思就是另一个文件通过 require 引用它后需要怎么使用它),node 中提供共了 exports 和 module.exports 两个变量来实现它

a.js

 
   
   
 
    
  
    
    
  
  1. function func1() {
    2. 
  
    
    
  
  2.    console.log('aaa')
    3. 
  
    
    
  
  3. }
    4. 
  
    
    
  
  4. function func2() {
    5. 
  
    
    
  
  5.    console.log('bbb')
    6. 
  
    
    
  
  6. }
    7. 
  
    
    
  
  7. exports.a = func1
    8. 
  
    
    
  
  8. exports.b = func2
    9.

b.js

 
   
   
 
    
  
    
    
  
  1. var a = require('./a.js')
    2. 
  
    
    
  
  2. a.func1() //会打印出aaa
    3. 
  
    
    
  
  3. a.func2() //会打印出bbb
    4.

c.js

 
   
   
 
    
  
    
    
  
  1. //es6 模式匹配写法
    2. 
  
    
    
  
  2. var {fun1,fun2} = require('./a.js')//fun1和fun2必须跟a.js中的变量名相同，这里是固定的
    3. 
  
    
    
  
  3. fun1() //会打印出aaa
    4. 
  
    
    
  
  4. fun2() //会打印出bbb
    5.

a.js

 
   
   
 
    
  
    
    
  
  1. //类的写法
    2. 
  
    
    
  
  2. function Test() {
    3. 
  
    
    
  
  3.    this.func1 = function() {
    4. 
  
    
    
  
  4.        console.log('aaa')
    5. 
  
    
    
  
  5.    }
    6. 
  
    
    
  
  6.    this.func2 = function() {
    7. 
  
    
    
  
  7.        console.log('bbb')
    8. 
  
    
    
  
  8.    }
    9. 
  
    
    
  
  9. }
    10. 
  
    
    
  
  10. module.exports = Hello
    11.

b.js

 
   
   
 
    
  
    
    
  
  1. var Test = require('./a.js')
    2. 
  
    
    
  
  2. var test = new Test()
    3. 
  
    
    
  
  3. test.func1()
    4. 
  
    
    
  
  4. test.func2()
    5.

  3. exports 和 module.exports 的关系

比如 exports.a = 3，实际上 module.exports.a 也是等于 3 的

又比如 exports = {}，这样 exports 就和 module.exports 的指向的对象就不一样了，后面再怎么修改 exports 也不会影响到 module.exports 的值，也不会影响到文件输出的变量

再比如 module.exports={}，这样造成的效果和上面 exports={} 的效果是一样的

建议：如果你还傻傻分不清楚它们的区别，以后在不是必须用到 module.exports 的时候只用 exports, 如果导出一个类这样的必须用到 module.exports 就不要使用 exports 了, 不要混在一起用就不会出错了

  4. node 中的 npm

node 中默认自带了 npm，npm 是一个包管理器，上面说到包就是一个个模块 (js 文件) 组成的一个具有特定功能的一堆 js 文件，通过 npm 我们可以引入这些包 (如果不理解，把包理解成一个个插件也没有错) 来轻松实现一些功能

安装一个模块你只需要 npm install xxx 就可以安装了，然后在你自己的 js 中用 var xxx = require('./xxx') 就可以使用了

通过 npm install xxx 安装完 xxx 模块后，你会发现当前目录下多了一个 nodemodules 文件夹，打开 nodemodules 文件夹你会发现里面有一个 xxx 文件夹。你在执行 npm install xxx 的时候，实际上 npm 也只是帮你把 xxx 这个包下载下来了而已，仅此而已

当你通过 npm 安装了十来个或者更多的包的时候你可能自己早就不知道自己安装了哪些包了，因为很多包依赖了其它的包 (一个包用到另一个包提供的功能是非常正常的行为，就像我们在用别人包里的功能一样), 所以 npm 提供了 package.json 这个文件来管理包

package.json 是一个文件，里面可以定义很多键值对，其中有几个字段非常重要，dependencies 表示上线运行时依赖的包，devDependencies 表示开发时依赖的包，scripts 可以定义自己的脚本，main 表示所有的包你都会通过这个文件引入

当你在 dependencies 和 devDependencies 定义好依赖，然后在命令行中输入 npm install，npm 就会帮你自动安装好这些包；反过来你在命令行中输入 npm install xxx --save 后 npm 就会在 package.json 中的 dependencies 自动加上 xxx，如果执行的是 npm install xxx --save-dev 就会在 devDependencies 中自动加上 xxx。

而在 scripts 中定义的脚本就直接可以在命令行中运行了，如果还弄不懂，可以看一下我的另一篇文章，如何制作自己的 npm 包

node.js 中自带的那些模块

http 模块

使用别人的模块，其实就是使用别人写好的方法 (函数)，只需要搞清楚别人提供的方法是怎么用的就可以了，可以查 node.js 官网查 api 或者看看网上写的教程就好。

下面演示了一个最简单的 http 模块的使用方法，在当前目录下在命令行中输入 node test.js，http 会挂起一个监听，只需要在浏览器中输入 http://localhost:8000，test.js 就会跟浏览器返回 <div>hello world</div>显示在页面上：

 
   
   
 
    
  
    
    
  
  1. test.js
    2. 
  
    
    
  
  2. var http = require('http')
    3. 
  
    
    
  
  3. var callBack = function(req, res) {
    4. 
  
    
    
  
  4.     res.write('<div>hello world</div>')
    5. 
  
    
    
  
  5.     res.end()
    6. 
  
    
    
  
  6. }
    7. 
  
    
    
  
  7. http.createServer(callBack).listen(8000)
    8.

url 模块

在 http 模块的例子中传入了一个回调函数，两个参数分别是 request 和 response，前者是浏览器传给我们的对象，后者是我们传给浏览器的对象。

其中 req 中包含了 url 这个属性，可以在回调函数中把它打印出来 console.log(req.url), 加入你在浏览器中输入的是：http://localhost:8000/aaa/bbb?abc=3，那么打印出来的值是：/aaa/bbb?abc=3

在这里我们需要使用到的是 / aaa/bbb 和 abc=3 分开来的结果，node 给我们提供了一个处理 url 的模块，就叫做 url 模块. 当然如果你自己想处理这个 url 也是完全可以的，用正则表达式就可以，但是已经有现成的为啥不用呢

下面简单演示一下用法，在浏览器输入：http://localhost:8000/aaa/bbb?abc=3

 
   
   
 
    
  
    
    
  
  1. test.js
    2. 
  
    
    
  
  2. var http = require('http')
    3. 
  
    
    
  
  3. var url = require('url')
    4. 
  
    
    
  
  4. var callBack = function(req, res) {
    5. 
  
    
    
  
  5.     var urlString = url.parse(req.url)
    6. 
  
    
    
  
  6.     var path = urlString.pathname
    7. 
  
    
    
  
  7.     var query = urlString.query
    8. 
  
    
    
  
  8.     console.log(path,query)//打印出/aaa/bbb abc=3
    9. 
  
    
    
  
  9.    res.write('<div>hello world</div>')
    10. 
  
    
    
  
  10.    res.end()
    11. 
  
    
    
  
  11. }
    12. 
  
    
    
  
  12. http.createServer(callBack).listen(8000)
    13.

fs 模块

fs 是一个提供文件操作功能的模块，可以对文件进行读写存删等操作，下面演示向浏览器返回本 js 的内容：

 
   
   
 
    
  
    
    
  
  1. test.js
    2. 
  
    
    
  
  2. var http = require('http')
    3. 
  
    
    
  
  3. var fs = require('fs')
    4. 
  
    
    
  
  4. var callBack = function(req, res) {
    5. 
  
    
    
  
  5.     fs.readFile('./test.js', 'utf-8', function(err, data) {
    6. 
  
    
    
  
  6.         res.write(data)
    7. 
  
    
    
  
  7.         res.end()
    8. 
  
    
    
  
  8.     })
    9. 
  
    
    
  
  9. }
    10. 
  
    
    
  
  10. http.createServer(callBack).listen(8000)
    11.

用 http 模块、url 模块、http 模块搭建一个静态服务器

 
   
   
 
    
  
    
    
  
  1. var http = require('http')
    2. 
  
    
    
  
  2. var url = require('url')
    3. 
  
    
    
  
  3. var fs = require('fs')
    4. 
  
    
    
  
  4. var callBack = function(req, res) {
    5. 
  
    
    
  
  5. var pathname = url.parse(req.url).pathname
    6. 
  
    
    
  
  6. if (pathname == '/') {
    7. 
  
    
    
  
  7.     pathname = '/index.html'
    8. 
  
    
    
  
  8. }
    9. 
  
    
    
  
  9. fs.readFile('.' + pathname, 'utf-8', function(err, data) {
    10. 
  
    
    
  
  10.         if (err) {
    11. 
  
    
    
  
  11.             res.write('Error 404')
    12. 
  
    
    
  
  12.         } else {
    13. 
  
    
    
  
  13.             res.write(data)
    14. 
  
    
    
  
  14.         }
    15. 
  
    
    
  
  15.         res.end()
    16. 
  
    
    
  
  16.     }
    17. 
  
    
    
  
  17. )}
    18. 
  
    
    
  
  18. http.createServer(callBack).listen(8000)
    19.

使用外部模块

简单说明

外部模块都是第三方提供的模块，node.js 默认是不提供的，所以需要用 npm 安装，这里提供 package.json 文件，只需要执行 npm install 安装就行了，另外是管理 MongoDB 数据库的一个包，所以本地需要把 MongoDB 单独安装一下。

 
   
   
 
    
  
    
    
  
  1. package.json
    2. 
  
    
    
  
  2. {
    3. 
  
    
    
  
  3.   "dependencies": {
    4. 
  
    
    
  
  4.     "cheerio": "^1.0.0-rc.2",
    5. 
  
    
    
  
  5.     "eventproxy": "^1.0.0",
    6. 
  
    
    
  
  6.     "express": "^4.16.2",
    7. 
  
    
    
  
  7.     "koa": "^2.4.1",<!--koa是用来替代express的框架-->
    8. 
  
    
    
  
  8.     "superagent": "^3.8.1"
    9. 
  
    
    
  
  9.   }
    10. 
  
    
    
  
  10. }
    11.

express

express 提供了基本的路由和静态文件访问的功能，当然还有其它的功能，这里主要演示它的基本使用 下面 1,2,3 都是设置 public 和 files 目录下为静态文件，可以直接通过文件路径访问，1、2 可以同时存在，即可以指定几个目录均为静态文件目录，在指定目录为静态文件后，访问静态文件需要省略这个目录，比如访问 public 目录下的 css/index.css：localhost:8000/css/index.css, 直接省略了 public， 可以通过 3 来指定替换目录名称的路径，通过 3 设置后，要访问 public 下的 css/index.css：localhost:8000/public/css/index.css

 
   
   
 
    
  
    
    
  
  1. var express = require('express')
    2. 
  
    
    
  
  2. var app = express()
    3. 
  
    
    
  
  3. 1\. app.use(express.static('public'))
    4. 
  
    
    
  
  4. 2\. app.use(express.static('files'))
    5. 
  
    
    
  
  5. 3\. app.use('/static',express.static(public))
    6. 
  
    
    
  
  6. app.get('/', function (req, res) {
    7. 
  
    
    
  
  7.   res.send('Hello World');//一个回调方法对应一个路径
    8. 
  
    
    
  
  8. })
    9. 
  
    
    
  
  9. app.get('/user', function (req, res) {
    10. 
  
    
    
  
  10.   res.send('user');
    11. 
  
    
    
  
  11. })
    12. 
  
    
    
  
  12. app.listen(8000, function () {
    13. 
  
    
    
  
  13.   console.log('app is listening at port 3000');
    14. 
  
    
    
  
  14. })
    15.

superagent、cheerio 模块

superagent 是一个可以发 http 请求的模块，回调函数中的 res 就是请求到的内容

cheerio 是在服务器端类式 jquery 的框架，看代码应该能看出来

下面演示的是抓取糯米网的餐品列表链接

 
   
   
 
    
  
    
    
  
  1. var superagent = require('superagent')
    2. 
  
    
    
  
  2. var cheerio = require('cheerio')
    3. 
  
    
    
  
  3. var spideUrl = 'https://t10.nuomi.com/pc/t10/index'
    4. 
  
    
    
  
  4. superagent.get(spideUrl)
    5. 
  
    
    
  
  5.     .end(function(err, res) {
    6. 
  
    
    
  
  6.         if (err) {
    7. 
  
    
    
  
  7.             return console.error(err);
    8. 
  
    
    
  
  8.         }
    9. 
  
    
    
  
  9.         var foodUrls = [];
    10. 
  
    
    
  
  10.         var $ = cheerio.load(res.text)
    11. 
  
    
    
  
  11.         // 获取首页所有的链接
    12. 
  
    
    
  
  12.         $('.j-item a').each(function(idx, element) {
    13. 
  
    
    
  
  13.             var $element = $(element)
    14. 
  
    
    
  
  14.             foodUrls.push($element.attr('href'))
    15. 
  
    
    
  
  15.         })
    16. 
  
    
    
  
  16.         console.log(topicUrls)
    17. 
  
    
    
  
  17.     })
    18.

eventproxy

在爬取一堆类式的链接的时候，一个个链接写挺麻烦的，eventproxy 提供了监听，然后触发回调的方式来处理这类问题，下面是我拷贝的一段代码，应该挺容易看懂的

 
   
   
 
    
  
    
    
  
  1. //得到一个 eventproxy 的实例
    2. 
  
    
    
  
  2. var ep = new eventproxy() 
    3. 
  
    
    
  
  3. // 命令 ep 重复监听 urls.length 次（在这里也就是 10 次） 
    4. 
  
    
    
  
  4. ep.after('topic_html', urls.length, function (topics) {
    5. 
  
    
    
  
  5.   topics = topics.map(function(page) {
    6. 
  
    
    
  
  6.     var $ = cheerio.load(page)
    7. 
  
    
    
  
  7.     var userId = $('.runUserName a font').eq(0).text()
    8. 
  
    
    
  
  8.     return userId
    9. 
  
    
    
  
  9.   });
    10. 
  
    
    
  
  10.   console.log(topics);
    11. 
  
    
    
  
  11. })
    12. 
  
    
    
  
  12. urls.forEach(function(item) {
    13. 
  
    
    
  
  13.   superagent.get(item)
    14. 
  
    
    
  
  14.     .end(function (err, res) {
    15. 
  
    
    
  
  15.       ep.emit('topic_html', res.text)
    16. 
  
    
    
  
  16.     })
    17. 
  
    
    
  
  17. })
    18.

总结

大部分学习前端其实是没必要深入学习 node.js 的，一方面没那个精力，然后也没那么必要，但是一些基本的东西还是有必要好好学学的

大多数前端同学之所以觉得应该学前端，其实是平时接触到的 npm、require 模块、es6 的语法等问题觉得比较棘手，以为是自己不懂 node.js，其实这些和 node.js 并无太大关系，这些已经影响到学习前端其它内容的地方还是需要好好学习的

学习 node.js 基本的东西还是有必要的，比如搭建个简单的服务器，做点基本的逻辑处理和数据处理，做个爬虫啥的。而这些都很简单，看两篇博客做几个练习就够了，再深入就根据实际情况学习就好了。

原文：https://segmentfault.com/a/1190000012066000


以上是关于入门 node.js 你必须知道的那些事的主要内容，如果未能解决你的问题，请参考以下文章

React.js入门必须知道的那些事

数字货币：2020你必须知道的那些事！

学习java，你必须知道的那些事

央行数字货币将到来？你必须知道的那些事！

我国央行数字货币推出,你必须知道的那些事!

关于前后端分离，你需要知道的那些事