学习 Node 的目标

  • 优秀的前端—可以和后端有效沟通
  • 敏捷的全栈—快速开发全栈应用
  • 架构师—践行工程化思想

模块 - module

概述

Node应用由模块组成，采用CommonJS模块化规范，在node中一个文件就是一个模块，每个模块都有自己的作用域。

特点

  • 所有代码都运行在模块作用域，不会污染全局作用域。
  • 模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存。
  • 模块加载的顺序，按照其在代码中出现的顺序。

主要内容

module 对象

CommonJS规范规定，每个模块内部，都有一个module对象，代表当前模块,它的exports属性是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。

module对象的属性：

  1. module.id        # 模块的识别符，通常是带有绝对路径的模块文件名。
  2. module.filename  # 模块的文件名，带有绝对路径。      
  3. module.loaded    # 返回一个布尔值，表示模块是否已经完成加载。
  4. module.parent    # 返回一个对象，表示调用该模块的模块。
  5. module.children  # 返回一个数组，表示该模块要用到的其他模块。
  6. module.exports   # 表示模块对外输出的值。

require 方法

Node使用CommonJS模块规范，内置的require()用于加载模块文件,require命令的基本功能是，读入并执行一个JavaScript文件，然后返回该模块的module.exports属性。

exports 变量

在模块中，还有一个变量exports，它是module.exports对象的引用，在使用exports变量时，注意不要破坏它和module.exports对象之间的引用关系。我们经常看到这样的写法：

  1. exports = module.exports = somethings

上面的代码等价于:

  1. module.exports = somethings
  3. exports = module.exports

原理很简单，即 module.exports 指向新的对象时，exports 断开了与 module.exports 的引用，那么通过exports = module.exports 让 exports 重新指向 module.exports 即可。

  1. function add (x, y) {
  2.   return x + y
  3. }
  5. function minus (x, y) {
  6.   return x -y
  7. }
  9. // ES Module 导出的模块，在使用 require 函数导入时默认放在了 default 属性下面
  10. export default {
  11.   add,
  12.   minus
  13. }
  15. // 改变 module.exports 的引用之后，后面再使用 exports 是无效的
  16. // module.exports = {
  17. //   add
  18. // }
  20. // exports.minus = minus 
  22. // 保证 exports 和 module.exports 引用关系不被破坏
  23. // exports = module.exports = {
  24. //   add
  25. // }
  27. // exports.minus = minus

模块加载中的两个问题

  1. 路径问题：根据参数的不同格式，require命令去不同路径寻找模块文件。

    （1） 如果参数字符串以“/”开头，则表示加载的是一个位于绝对路径的模块文件。

    比如，require('E:/NodeJs/module/2.js')

    （2）如果参数字符串以“./”开头，则表示加载的是一个位于相对路径（当前目录）的模块文件。

    比如，require('./2.js')

    （3）如果参数字符串不以“./“或”/“开头，则表示加载node的核心模块，或者是node_modules下面的模块

    比如，require('fs')

  2. 文件查找问题

    (1)首先按照加载的模块的文件名称进行查找

    (2)如果没有找到，则会在模块文件名称后面加上.js后缀，进行查找

    (3)如果还没有找到，则会在模块文件名称后面加上.json后缀，进行查找

    (4)如果还没有找到，则会在模块文件名称后面加上.node后缀，进行查找

    (5)以上都没有找到就会报错

全局变量 - global

全局变量在所有模块中均可使用。

以下变量虽然看起来像全局变量，但实际上不是。 它们的作用域只在模块内，详见 module文档：

process - 进程

process对象是一个全局变量，可以在任何地方都能访问到它，通过这个对象提供的属性和方法，使我们可以对当前运行的程序的进程进行访问和控制。

  1. process.argv      # 返回一个包含命令行参数的数组
  2. process.env       # 返回用户环境信息
  3. process.version   # 返回node版本信息
  4. process.versions  # 返回node及node依赖包版本信息
  5. process.pid       # 返回进程的pid
  6. process.title     # 返回当前进程显示的名称
  7. process.arch      # 返回CPU处理器架构
  1. stdin、stdout：标准输入输出流（I/O操作）
  3. process.stdin.resume()  // 开启输入流, 监听输入流数据，默认开启
  4. process.stdin.pause()   // 关闭输入流
  6. 例1: 监听用户的输入数据
  8. process.stdin.on('data', function (chunnk){
  9.     console.log('用户输入了:' + chunnk )
  10.     process.stdin.pause();
  11. });
  13. 例2: 要求用户输入两个数值，然后把和输出到终端
  15. var num1, num2;
  16. process.stdout.write('请输入num1的值：');
  17. process.stdin.on('data', function (chunk) {
  18.   if (!num1) {
  19.     num1 = Number(chunk);
  20.     process.stdout.write('请输入num2的值: ');
  21.   } else {
  22.       num2 = Number(chunk)
  23.       process.stdout.write('结果是：' + (num1 + num2))
  24.       process.stdin.pause()
  25.    }
  26. })

提示：vscode的内置调试控制台默认不从stdout的输出流中抓取内容，需要在vscode的启动配置(launch.json)中添加如下配置：

  1. {
  2.   // 使用 IntelliSense 了解相关属性。 
  3.   // 悬停以查看现有属性的描述。
  4.   // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
  6.     "version": "0.2.0",
  7.     "configurations": [
  8.         {
  9.             "type": "node",
  10.             "request": "launch",
  11.             "outputCapture": "std",        // 抓取stdout输出流的内容
  12.             "console": "externalTerminal", // 另外打开控制台
  13.             "name": "启动程序",
  14.             "program": "${file}"
  15.         }
  16.     ]
  17. }

Buffer

Buffer 类用于操作二进制数据流 。

  1. (1) Buffer.alloc(5)         创建一个Buffer对象，并为这个对象分配空间大小
  3.   var bf = Buffer.alloc(5)
  4.   console.log(bf)
  6.   // 当我们为一个Buffer对象分配空间大小之后，其长度是固定的，不能更改
  7.   bf[5]=1;
  8.   console.log(bf);
  10. (2) Buffer.alloc(4, 'abcd')  创建一个Buffer对象，并初始化
  12.   var bf=Buffer.alloc(4, 'abcd');
  13.   console.log(bf);
  15. (3) Buffer.from(sring,[encoding]) 创建一个Buffer对象，并使用字符串初始化,第二个参数用于指定字符串编码
  17.   var bf=new Buffer('miaov','utf-8');
  18.   console.log(bf);
  20.  (4) buf.length // 输出的是字节长度
  22.    var str1='miaov';
  23.    console.log(str1.length);
  24.    var bf=new Buffer(str1);
  25.    console.log(bf.length);
  26.    var str2='妙味';
  27.    console.log(str2.length);
  28.    var bf2=new Buffer(str2);
  29.    console.log(bf2.length); // 输出的是字节长度

常用方法

  1. (1) buf.write(string[, offset[, length]][, encoding]) 将字符串写入到Buffer中
  2.     string 要写入 buf 的字符串。
  3.     offset 从Buffer对象中的第几位开始写入。默认: 0。
  4.     length 写入的字符串的长度。默认: buf.length - offset。
  5.     encoding 字符编码。默认: 'utf8'。
  7.     var str='miaov';
  8.     var bf=new Buffer(5);
  9.     bf.write(str);
  11.     bf.write(str,1);
  12.     console.log(bf);
  14.     bf.write(str,1,2);
  15.     console.log(bf);
  18. (2) buf.toString([encoding[, start[, end]]]) 根据encoding参数，将Buffer对象输出为字符串
  20.     var bf=new Buffer('miaov');
  21.     console.log(bf.toString());
  22.     console.log(bf.toString('utf-8',1,3)); //不包含结束位
  24.     var bf2=new Buffer('妙味');
  25.     console.log(bf2);
  26.     console.log(bf2.toString('utf-8',1));
  29.  (3) buf.toJSON()    将Buffer对象转换为JSON格式
  31.     var bf=new Buffer('miaov');
  32.     console.log(bf.toJSON());     // {type: 'Buffer', data:[109,105,97,111,118]}
  35.  (4) buf.slice([start[, end]])    返回一个新的buffer，这个buffer将和老的buffer引用相同的内存地址
  37.     注意：修改这个新的buffer对象，会改变原来老的buffer对象
  39.     var bf=new Buffer('miaov');
  40.     console.log(bf);
  41.     var bf2=bf.slice(2);
  42.     console.log(bf2);
  44.     bf2[0]=2;
  45.     console.log(bf2);
  46.     console.log(bf); // 老的buffer也被改变了
  49.  (5) bf.copy(targetBuffer,[targetStart],[sourceStart],[sourceEnd])    进行buffer的拷贝
  51.     修改新的buffer对象，不会会改变原来老的buffer对象
  53.     var bf=new Buffer('miaov');
  54.     console.log(bf);
  56.     var bf2=new Buffer(6);
  57.     bf.copy(bf2); //将bf中的内容拷贝到bf2中
  58.     console.log(bf2);
  60.     bf2[0]=2;
  61.     console.log(bf2);
  62.     console.log(bf);

静态方法

  1. Buffer.isEncoding('utf-8')        # 检测Buffer对象是否支持某种编码
  3. Buffer.isBuffer(bf)               # 判断某个对象是否是Buffer对象
  5. Buffer.byteLength(str)            # 返回该字符串的字节长度，encoding编码默认是utf-8
  7. Buffer.concat(arr,[totallLength]) # 返回一个将传入的buffer数组中所有的buffer对象拼接在一起新的buffer对象
  9. var str1='miaov';
  10. var str2='妙味';
  11. var arr=[new Buffer(str1),new Buffer(str2)];
  12. var bf=Buffer.concat(arr,11);        // 当第二个参数不给的时候，程序会默认计算buffer数组的总字节长度
  1. // 标准输入输出流中的内容也是二进制数据
  2. process.stdout.write('请输入内容:');
  3. process.stdin.resume();
  4. process.stdin.on('data',function (chunk){
  5.   console.log(chunk); // <Buffer 61 0a>   0a：回车
  6.   console.log(chunk.toString());
  7.   console.log('输入的内容是：' + chunk); // 用+进行字符串拼接时，会自动对chunk进行字符串转换
  8.   process.stdin.pause();
  9. })

文件系统 - fs

fs 模块提供了一些 API，用于与文件系统进行交互，所有的文件系统操作都有异步和同步两种形式。

读写操作

  1. （1）打开一个文件
  2.     fs.open(path,flags,[mode],callback)  异步
  3.     fs.openSync(path, flags, [mode])     同步
  5.   path:  文件路径
  6.   flags: 打开文件的模式 读/写
  7.   mode:  设置文件的模式 读/写/执行  4/2/1
  8.   callback:
  9.     err: 文件打开失败时错误信息保存在err对象里面，如果成功err为null
  10.     fd： 打开的文件的标识
  12.   var fs = require('fs');
  13.   var fileName = __dirname + '/' + '1.txt'
  15.   //异步方式
  16.   fs.open(fileName, 'r', function (err, fd) {
  17.     console.log(fd);
  18.   })
  20.   //同步方式
  21.   var fd = fs.openSync(fileName, 'r');
  22.   console.log(fd);
  1. （2）读取文件内容，从指定的文档标识符fd读取文件数据
  3.     fs.read(fd, buffer, offset, length, position, callback)  异步
  4.     fs.readSync(fd, buffer, offset, length, position)                同步,返回bytesRead的个数
  6.   fd: 通过open方法成功打开一个文件返回的编号,用来标识打开的文件
  7.   buffer：数据将被写入到的 buffer 对象
  8.   offset: 读取的内容添加到buffer中的起始位置
  9.   length: 是一个整数，指定要读取的字节数
  10.   position: 读取文件的起始位置
  11.   callback: 
  12.     error: 文件读取失败时错误信息保存在err对象里面，如果成功err为null
  13.     bytesRead: 读取的字节数
  14.     buffer: 读取完成之后的buffer对象
  16.   var fs = require('fs');
  17.   var fileName = __dirname + '/' + '1.txt'
  19.     // 异步方式
  20.   fs.open(fileName, 'r', function (err, fd) {
  21.     if (err) {
  22.       console.log('文件打开失败');
  23.     } else {
  24.       var bf1 = new Buffer(10);
  25.       fs.read(fd, bf1, 0, 4, null, function (error, bytesRead, buf) {
  26.         console.log(bytesRead);
  27.         console.log(buf);
  28.         console.log(buf.toString());
  29.       })
  30.     }
  31.   })
  33.   // 同步方式
  34.   fs.open(fileName, 'r', function (err, fd) {
  35.     if (err) {
  36.       console.log('文件打开失败');
  37.     } else {
  38.       var bf1 = new Buffer(10);
  39.       var bytesRead = fs.readSync(fd, bf1, 0, 2, null)
  40.       console.log(bytesRead)
  41.     }
  42.   })
  1. (3) 写入数据到指定文件中/关闭打开的文件
  3.   异步
  4.   写入 buffer 到 fd 指定的文件
  5.   fs.write(fd, buffer, offset, length[, position], callback) 
  7.     fd: 打开文件的标识
  8.     buffer：要写入的数据
  9.     offset：buffer对象中要写入的数据的起始位置
  10.     length: 是一个整数，指定要写入的字节数
  11.     position：指向从文件开始写入数据的的起始位置
  12.     callback：
  13.          error: 文件写入失败时错误信息保存在error对象里面，如果成功error为null
  14.          bytesWritten: 写入的字节数
  15.          buffer: 读取完成之后的buffer对象
  17.     写入 string 到 fd 指定的文件，如果 string 不是一个字符串，则该值将被强制转换为一个字符串。
  18.   fs.write(fd, string[, position[, encoding]], callback) 
  19.        fd: 打开文件的标识
  20.     string：写入string 到 fd 指定的文件
  21.     position：指向从文件开始写入数据的的起始位置
  22.     callback：
  23.          error:  文件写入失败时错误信息保存在error对象里面，如果成功error为null
  24.          written: 写入的字节数
  25.          string: 读取完成之后的buffer对象
  27.      关闭一个打开的文件
  28.   fs.close(fd, callback)
  30.   同步
  31.   fs.writeSync(fd, buffer, offset, length[, position])
  32.   fs.writeSync(fd, data[, position[, encoding]])
  33.   fs.closeSync(fd)
  35.     // 当我们要对打开的文件进行写操作的时候，打开文件的模式应该是读写方式 r+
  36.   fs.open(fileName, 'r+', function (err, fd) {
  37.   if (err) {
  38.     console.log('打开文件失败');
  39.   } else {
  40.     var bf = new Buffer('abcd');
  41.     fs.write(fd, bf, 0, 4, 0, function (err, bytesWritten, buf) {
  42.       console.log(bytesWritten)
  43.       console.log(buf.toString())
  44.     })
  45.     fs.write(fd, '123', 3, 'utf-8', function (err, written, string) {
  46.       console.log(written)
  47.       console.log(string)
  48.     });
  49.     fs.close(fd, function () {});
  50.     fs.write(fd, '9', 7, 'utf-8', function () {}); //文件已经关闭，这段代码不会执行
  51.   }
  52. })

fs.open、fs.read、 fs.write等是更底层的操作，node提供了一些封装好的方法供开发者调用，可以更方便的对文件进行读写操作

  1. （1）写入数据
  2.     fs.writeFlie(filename, data, [options], callback)  异步的将数据写入一个文件，如果该文件不存在，则新建，如果存在则覆盖原来的内容。data 可以是一个string，也可以是一个原生buffer。
  3.     fs.writeFileSync(filename, data, [options])
  5.     fs.appendFile(filename, data, [options], callback) 异步的将数据写入一个文件，如果该文件不存在，则新建，如果存在则添加到原内容后面。data 可以是一个string，也可以是一个原生buffer。
  6.     fs.appendFileSync(filename, data, [options])
  8.     fs.access(path[, mode], callback)    检查文件是否存在于当前目录
  10.   var fs = require('fs');
  11.   var filename = __dirname + '/' + '2.txt';
  13.   fs.writeFile(filename, 'hello', function (err) {
  14.     console.log(err);
  15.   })
  17.   fs.appendFile(filename, '-leo', function (err) {
  18.     console.log(err);
  19.   })
  21.   fs.access(filename, fs.constants.F_OK, (err) => {
  22.      console.log(`${filename} ${err ? '不存在' : '存在'}`);
  23.   })
  25.     // 结合fs.access对文件进行读取操作
  26.   fs.access(filename, fs.constants.F_OK, (err) => {
  27.      if(err) {
  28.        fs.writeFile(filename,'hello',function (err){
  29.          if(err){
  30.            console.log('出错了');
  31.          }else{
  32.            console.log('创建新文件成功');
  33.          }
  34.      });
  35.      } else {
  36.        fs.appendFile(filename,'-leo',function (err){
  37.          if(err){
  38.            console.log('新的内容添加失败');
  39.          }else{
  40.            console.log('新的内容添加成功');
  41.          }
  42.        })
  43.      }
  44.   })
  46.   // 同步模式
  47.   fs.access(filename, fs.constants.F_OK, (err) => {
  48.      if(err) {
  49.        fs.writeFileSync(filename,'miaov');
  50.        console.log('新文件创建成功');
  51.      } else {
  52.        fs.appendFile(filename,'-leo');
  53.        console.log('新内容添加成功');
  54.      }
  55.   })
  1. （2）读取数据
  2.     fs.readFile(filename, [options], callback) 异步读取一个文件的全部内容
  3.     fs.readFileSync(filename, [options])
  5.   var fs = require('fs');
  6.   var filename = __dirname + '/' + '2.txt';
  8.    fs.readFile(filename, function (err, data) {
  9.      if (err) {
  10.        console.log(' 文件读取失败');
  11.      } else {
  12.        console.log(data.toString());
  13.      }
  14.    })

常用的文件操作

  1.    fs.unlink(path, callback)  删除一个文件
  2.    fs.rename(oldPath, newPath, callback)  重命名
  3.    fs.stat(path, callback) 读取文件信息
  4.    fs.watch(filename, [options], [listener]) 监控文件的修改
  6.    var fs = require('fs');
  7.    var filename = __dirname + '/' + '2.txt';
  9.    fs.unlink(filename,function (err){
  10.      if(err){
  11.        console.log('删除成功');
  12.      }else{
  13.        console.log('删除失败');
  14.      }
  15.    })
  17.   fs.rename(filename,__dirname + '/' + '3.txt',function (err){
  18.      if(err){
  19.        console.log('重命名失败');
  20.      }else{
  21.        console.log('重命名成功');
  22.      }
  23.    })
  25.   fs.stat(filename, function (err, stats) {
  26.     console.log(stats);
  27.   })
  29.   fs.watch(filename, function (eventType, fileName) {
  30.     if (fileName) {
  31.       console.log(eventType);
  32.       console.log(fileName + '发生了改变');
  33.     } 
  34.   })

常用的文件夹操作

  1.   fs.mkdir(path, [mode], callback) 创建一个文件夹
  2.   fs.rmdir(path, callback) 删除一个文件夹
  3.   fs.readdir(path, callback) 读取文件夹
  5.   var fs = require('fs');
  7.   fs.mkdir(__dirname + '/1', function (err) {
  8.      console.log(err);
  9.   })
  11.   fs.rmdir(__dirname + '/1',function (err){
  12.     console.log(arguments);
  13.   })
  16.   fs.readdir(__dirname, function (err, fileList) {
  17.     // console.log(fileList); // 返回值是一个数组，包含了该文件夹下所有文件
  18.     fileList.forEach(function (item) {
  19.       fs.stat(__dirname + '/' + item, function (err, stats) {
  20.         switch (stats.mode) {
  21.           case 16822:
  22.             console.log('[文件夹]: ' + item);
  23.             break;
  24.           case 33206:
  25.             console.log('[文件]: ' + item);
  26.             break;
  27.           default:
  28.             console.log('其他类型: ' + item);
  29.            break;
  30.         }
  31.       })
  32.     })
  33.   })

网络编程 - http

通过http模块，可以非常方便的搭建一个 http 服务器

搭建http服务器

  1.   // 加载一个http模块
  2.   var http = require('http');
  4.   （1） 通过http模块下的 createServer 创建并返回一个http服务器对象 
  5.           http.createServer([requestListener])
  6.           requestListener : 监听到客户端连接的回调函数(request事件的回调函数，也可以采用下面的写法)
  8.    var server = http.createServer();
  10.   （2） 监听客户端连接请求，只有当调用了listen方法以后，服务器才开始工作
  11.         server.listen(port, [hostname], [backlog], [callback])
  12.         port : 监听的端口
  13.         hostname : 主机名（IP/域名)
  14.         backlog : 连接等待队列的最大长度
  15.         callback : 调用listen方法并成功开启监听以后，会触发一个listening事件，callback将作为该事件的                              执行函数
  17.   server.listen(8080, 'localhost');
  19.   (3) error 事件 当服务开启失败的时候触发的事件 参数err : 具体的错误对象
  21.   server.on('error', function () {
  22.     console.log('err');
  23.   })
  25.   (4) 当server调用listen方法并成功开始监听以后触发的事件，该事件的回调也可以在listen方法中使用
  27.   server.on('listening', function () {
  28.     console.log('listenning');
  29.   })
  31.  (5) request事件: 当有客户端发送请求的时候触发
  32.      参数：
  33.       req对象 ：通过它我们可以获取到这次请求的一些信息，比如头信息，数据等    
  34.       res对象 ：通过他我们可以向该次请求的客户端输出返回响应
  36.       req对象:    
  37.       httpVersion : 使用的http协议的版本
  38.       headers : 请求头信息中的数据
  39.       url : 请求的地址
  40.       method : 请求方式
  42.       res对象 
  43.       write(chunk, [encoding]) : 发送一个数据块到响应正文中
  44.       end([chunk], [encoding]) : 当所有的正文和头信息发送完成以后调用该方法告诉服务器数据已经全部发送完成了，这个方法在每次完成信息发送以后必须调用，并且是最后调用
  45.       statusCode : 该属性用来设置返回的状态码
  46.       setHeader(name, value) : 设置返回头信息
  47.       writeHead(statusCode, [reasonPhrase], [headers]) : 这个方法只能在当前请求中使用一次，并且必须在response.end()之前调用
  49.   server.on('request',function (req,res){
  50.     console.log('有用户连接进来了');
  51.     res.writeHead(200,'OK',{
  52.       //'content-type':'text/plain',//纯文本
  53.       'content-type':'text/html;charset=utf-8'
  54.     });
  55.     res.write('<h1>你好，欢迎学习node</h1>');
  56.     res.end(); // 当所有的正文和头信息发送完成以后调用该方法告诉服务器数据已经全部发送完成了
  57.   })

url处理

  2. 上一个例子中，监听到request事件时(当有客户端发送请求时)，返回的数据都是一样的
  3. 实际开发过程中，对于不同请求，我们需要返回不同的数据,所以需要用到url模块对req对象中的url进行处理
  5. var http = require('http');
  6. var url = require('url');
  8. (1)url.parse(request.url): 对url格式的字符串进行解析，返回一个对象,不同的url处理之后返回的数据是不同的 
  9. var urlObj = url.parse('http://www.baidu.com:8080/a/b?age=23&name=jack#p=1')
  10. console.log(urlObj);
  12. (2)利用url模块处理request.url，对于不同的pathname(路径),返回不同的数据,即做出不同的响应
  14. var server = http.createServer();
  15. server.listen(8080, 'localhost');
  17. server.on('request', function (req, res) {
  18.   //req.url: 访问路径
  19.   //console.log(req.url);
  20.   var urlObj = url.parse(req.url);
  21.   switch (urlObj.pathname) {
  22.     case '/':
  23.       //首页
  24.       res.writeHead(200, {
  25.         'content-type': 'text/html;charset=utf-8'
  26.       })
  27.       res.end('<h1>这是首页</h1>');
  28.       break;
  29.     case '/user':
  30.       //个人中心
  31.       res.writeHead(200, {
  32.         'content-type': 'text/html;charset=utf-8'
  33.       })
  34.       res.end('<h1>这是个人中心</h1>');
  35.       break;
  36.      default:
  37.      //处理其他情况
  38.      res.writeHead(404, {
  39.         'content-type': 'text/html;charset=utf-8'
  40.      })
  41.      res.end('<h1>页面不见了</h1>');
  42.      break;
  43.   }
  44. })

请求数据处理

  1.   使用fs模块实现nodejs代码和html的分离
  2.      queryString模块  对get和和post方法提交的数据进行处理
  3.       queryString.parse() : 将一个 querystring 反序列化为一个对象
  5.     var http = require('http');
  6.     var url = require('url');
  7.     var fs = require('fs');
  9.    通过req.method 拿到请求的方法
  10.    (1) get请求的数据处理 ：get请求的数据在querystring中，通过url.parse解析之后可以存放在query属性中。 qs.parse(urlObj.query)
  11.    (2) post请求的数据处理 : post发送的数据会被写入缓冲区中(buffer)，需要通过resquest的data和end事件来获取数据，并且用 + 进行字符串拼接或者 chunk.toString()，对chunk进行字符串转换。
  14. var qs = require('querystring');
  15. var server = http.createServer();
  17. //保存html目录路径
  19. var HtmlDir = __dirname + '/html';
  20. server.listen(8080, 'localhost');
  21. server.on('request', function (req, res) {
  22.   var urlObj = url.parse(req.url);
  23.   switch (urlObj.pathname) {
  24.     case '/':
  25.       // 首页
  26.       sendData(HtmlDir + '/index.html', req, res);
  27.       break;
  28.     case '/user':
  29.       // 个人中心
  30.       sendData(HtmlDir + '/user.html', req, res);
  31.       break;
  32.     case '/login':
  33.       // 登录页面
  34.       sendData(HtmlDir + '/login.html', req, res);
  35.       break;
  36.     case '/login/check':
  37.       // 登录验证
  38.       // get请求
  39.       // qs.parse(urlObj.query)   
  41.       // post请求 nodejs用req.on(data)接收客户端的post请求数据
  42.       if (req.method.toUpperCase() == 'POST') {
  43.         var str = '';
  44.         req.on('data', function (chunk) {
  45.           str += chunk; // 用 + 进行字符串拼接时，会自动对chunk进行字符串转换，等同于 chunk.toString()
  46.         })
  47.         req.on('end', function () {
  48.           console.log(qs.parse(str));
  49.         })
  50.       }
  51.       break;
  52.     default:
  53.       //处理其他情况
  54.       break;
  55.   }
  56. })
  58. function sendData(file, req, res) {
  59.   fs.readFile(file, function (err, data) {
  60.     if (err) {
  61.       res.writeHead(404, {
  62.         'content-type': 'text/html;charset=utf-8'
  63.       })
  64.       res.end('<h1>页面不见了......</h1>');
  65.     } else {
  66.       res.writeHead(200, {
  67.         'content-type': 'text/html;charset=utf-8'
  68.       })
  69.       res.end(data);
  70.     }
  71.   })
  72. }
  74. 总结： http模块配合url模块、fs模块、queryString搭建了一个对于不同的http请求进行响应的web服务器

异步处理

流程控制

Node.js 通过回调函数来实现异步操作，这样很容易导致回调地狱，影响代码的可读性和可维护性。

  1. const fs = require("fs");
  2. const { promisify } = require("util");
  3. const readFile = promisify(fs.readFile);
  5. // 要求: 按顺序输出 1.txt、2.txt、3.txt 三个文件中的内容
  7. // callback
  8. fs.readFile(__dirname + "/1.txt", function(err, data) {
  9.   if (err) {
  10.     console.log(" 文件读取失败");
  11.   } else {
  12.     console.log(data.toString());
  13.     fs.readFile(__dirname + "/2.txt", function(err, data) {
  14.       if (err) {
  15.         console.log(" 文件读取失败");
  16.       } else {
  17.         console.log(data.toString());
  18.         fs.readFile(__dirname + "/3.txt", function(err, data) {
  19.           if (err) {
  20.             console.log(" 文件读取失败");
  21.           } else {
  22.             console.log(data.toString());
  23.           }
  24.         });
  25.       }
  26.     });
  27.   }
  28. });
  30. // promise
  31. // readFile(__dirname + "/1.txt").then(data => {
  32. //   console.log(data.toString())
  33. //   return readFile(__dirname + "/2.txt")
  34. // }).then((data) => {
  35. //   console.log(data.toString())
  36. //   return readFile(__dirname + "/3.txt")
  37. // }).then(data => {
  38. //   console.log(data.toString())
  39. // })
  41. // generate
  42. // const co = require("co")
  44. // 自己实现一个 co 函数
  45. // function co (gen) {
  46. //   var it = gen()
  47. //   function next(){
  48. //     var result = it.next()
  49. //     if (result.done) return result.value
  50. //     result.value.then(function() {
  51. //       next();
  52. //     });
  53. //   }
  54. //   next();
  55. // }
  57. // const generator = function* () {
  58. //   yield readFile(__dirname + "/1.txt").then(data => {
  59. //     console.log(data.toString());
  60. //   });
  61. //   yield readFile(__dirname + "/2.txt").then(data => {
  62. //     console.log(data.toString());
  63. //   });
  64. //   yield readFile(__dirname + "/3.txt").then(data => {
  65. //     console.log(data.toString());
  66. //   });
  67. // };
  69. // const gen = generator('Generator')
  70. // gen.next()
  71. // gen.next()
  72. // gen.next()
  74. // co(generator)
  76. // async/await
  77. // (async() => {
  78. //   await readFile(__dirname + "/1.txt").then((data) => { console.log(data.toString()) })
  79. //   await readFile(__dirname + "/2.txt").then((data) => { console.log(data.toString()) })
  80. //   await readFile(__dirname + "/3.txt").then((data) => { console.log(data.toString()) })
  81. // })()

异常处理

  1. // Node.js 回调风格
  2. // 最后一个参数是回调函数
  3. // 回调函数的参数为 (err, result)，前面是可能的错误，后面是正常的结果
  5. const fs = require("fs");
  6. const { promisify } = require("util");
  8. function readFile(filename, callback) {
  9.   try {
  10.     let result = fs.readFileSync(filename);
  11.     callback(null, result);
  12.   } catch (error) {
  13.     callback(error);
  14.   }
  15. }
  17. // 回调方式
  18. // readFile(__dirname + "/test.txt", (err, data) => {
  19. //   if (err) {
  20. //     console.log(" 文件读取失败");
  21. //   } else {
  22. //     console.log(data.toString());
  23. //   }
  24. // });
  26. // promise
  27. // const readFile2 = promisify(readFile)
  29. // readFile2(__dirname + "/test.txt").then(data => {
  30. //   console.log(data.toString());
  31. // }).catch(err => {
  32. //   console.log(" 文件读取失败");
  33. // })
  35. // async/await
  36. const readFile3 = promisify(readFile)
  38. setTimeout(async () => {
  39.   try {
  40.     let data = await readFile3(__dirname + "/test.txt")
  41.     console.log(data.toString())
  42.   } catch (err) {
  43.     console.log("文件读取失败")
  44.   }
  45. })