Node.js基础学习(2)

梦里梦外; 2023-10-13 19:51 7阅读 0赞

# Node.js 全局对象 #

JavaScript 中有`一个特殊的对象`，称为`全局对象（Global Object）`，它及其所有属性都可以在程序的任何地方访问，即`全局变量`。

在浏览器 JavaScript 中，通常`window 是全局对象`， 而 Node.js 中的`全局对象是 global`，所有`全局变量（除了 global 本身以外）都是 global 对象的属性`。

在 Node.js 我们可以直接访问到 global 的属性，而不需要在应用中包含它。

## 全局对象与全局变量 ##

`global`最根本的作用是作为`全局变量的宿主`。按照 ECMAScript 的定义，满足以下条 件的变量是全局变量：

*  在最外层定义的变量；
 *  全局对象的属性；
 *  隐式定义的变量（未定义直接赋值的变量）。  
    当你定义一个全局变量时，这个变量同时也会成为全局对象的属性，反之亦然。需要注 意的是，在 Node.js 中你不可能在最外层定义变量，因为所有用户代码都是属于当前模块的， 而模块本身不是最外层上下文。

注意： `最好不要使用 var 定义变量以避免引入全局变量`，因为全局变量会污染命名空间，提高代码的耦合风险。

## \_\_filename ##

`__filename 表示当前正在执行的脚本的文件名`。它将`输出文件所在位置的绝对路径`，且和命令行参数所指定的文件名不一定相同。 如果在模块中，返回的值是模块文件的路径。

实例  
创建文件 main.js ，代码如下所示：

// 输出全局变量 __filename 的值
    console.log( __filename );

执行 main.js 文件，代码如下所示:

$ node main.js
    /web/com/runoob/nodejs/main.js

## \_\_dirname ##

`__dirname 表示当前执行脚本所在的目录`。

实例  
创建文件 main.js ，代码如下所示：

// 输出全局变量 __dirname 的值
    console.log( __dirname );

执行 main.js 文件，代码如下所示:

$ node main.js
    /web/com/runoob/nodejs
    setTimeout(cb, ms)

`setTimeout(cb, ms) 全局函数`在`指定的毫秒(ms)数后执行指定函数(cb)`。：setTimeout() 只执行一次指定函数。

返回一个代表定时器的句柄值。

实例  
创建文件 main.js ，代码如下所示：

function printHello(){
        
       console.log( "Hello, World!");
    }
    // 两秒后执行以上函数
    setTimeout(printHello, 2000);

执行 main.js 文件，代码如下所示:

$ node main.js
    Hello, World!
    clearTimeout(t)

clearTimeout( t ) 全局函数用于停止一个之前通过`setTimeout()`创建的定时器。 参数 t 是通过 setTimeout() 函数创建的定时器。

实例  
创建文件 main.js ，代码如下所示：

function printHello(){
        
       console.log( "Hello, World!");
    }
    // 两秒后执行以上函数
    var t = setTimeout(printHello, 2000);
    
    
    // 清除定时器
    clearTimeout(t);
    执行 main.js 文件，代码如下所示:
    
    $ node main.js
    setInterval(cb, ms)
    setInterval(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。

返回一个代表定时器的句柄值。可以使用 `clearInterval(t)` 函数来清除定时器。

`setInterval()`方法会不停地调用函数，直到`clearInterval()`被调用或窗口被关闭。

实例  
创建文件 main.js ，代码如下所示：

function printHello(){
        
       console.log( "Hello, World!");
    }
    // 两秒后执行以上函数
    setInterval(printHello, 2000);

执行 main.js 文件，代码如下所示:

$ node main.jsHello, World! Hello, World! Hello, World! Hello, World! Hello, World! ……

以上程序每隔两秒就会输出一次"Hello, World!"，且会永久执行下去，直到你按下 ctrl + c 按钮。

## console ##

console 用于提供控制台标准输出，它是由 Internet Explorer 的 JScript 引擎提供的调试工具，后来逐渐成为浏览器的实施标准。

Node.js 沿用了这个标准，提供与习惯行为一致的 console 对象，用于向标准输出流（stdout）或标准错误流（stderr）输出字符。

### console 方法 ###

以下为 console 对象的方法:

`console.log`接收若干 个参数，如果只有一个参数，则输出这个参数的字符串形式。如果有多个参数，则 以类似于C 语言 printf() 命令的格式输出。

`第一个参数是一个字符串，如果没有 参数，只打印一个换行`。

console.log('Hello world'); 
    console.log('byvoid%diovyb'); 
    console.log('byvoid%diovyb', 1991);

运行结果为：

Hello world 
    byvoid%diovyb 
    byvoid1991iovyb

console.error()：与console.log() 用法相同，只是向标准错误流输出。  
console.trace()：向标准错误流输出当前的调用栈。  
console.trace();  
运行结果为：

Trace: 
    at Object.<anonymous> (/home/byvoid/consoletrace.js:1:71) 
    at Module._compile (module.js:441:26) 
    at Object..js (module.js:459:10) 
    at Module.load (module.js:348:31) 
    at Function._load (module.js:308:12) 
    at Array.0 (module.js:479:10) 
    at EventEmitter._tickCallback (node.js:192:40)

实例  
创建文件 main.js ，代码如下所示：

console.info("程序开始执行：");
    
    var counter = 10;
    console.log("计数: %d", counter);
    
    console.time("获取数据");
    //
    // 执行一些代码
    // 
    console.timeEnd('获取数据');
    
    console.info("程序执行完毕。")

执行 main.js 文件，代码如下所示:

$ node main.js
    程序开始执行：
    计数: 10
    获取数据: 0ms
    程序执行完毕

## process ##

`process 是一个全局变量`，即 `global 对象的属性`。

它用于描述当前`Node.js 进程状态的对象`，`提供了一个与操作系统的简单接口`。通常在你写本地命令行程序的时候，少不了要 和它打交道。下面将会介绍 process 对象的一些最常用的成员方法。

![在这里插入图片描述][f5322afcfdd440d0865399a0cc0619d2.png]  
实例  
创建文件 main.js ，代码如下所示：

process.on('exit', function(code) {
        
    
      // 以下代码永远不会执行
      setTimeout(function() {
        
        console.log("该代码不会执行");
      }, 0);
      
      console.log('退出码为:', code);
    });
    console.log("程序执行结束");

执行 main.js 文件，代码如下所示:

$ node main.js
    程序执行结束
    退出码为: 0

### 退出状态码 ###

退出状态码如下所示：  
Process 属性  
Process 提供了很多有用的属性，便于我们更好的控制系统的交互：  
![在这里插入图片描述][99f99ec2007a4502a3d55e801f58fe79.png]

### Process 属性 ###

Process 提供了很多有用的属性，便于我们更好的控制系统的交互：  
![在这里插入图片描述][6f89d65de7504998bb5108744c1f7c63.png]  
实例  
创建文件 main.js ，代码如下所示：

// 输出到终端
    process.stdout.write("Hello World!" + "\n");
    
    // 通过参数读取
    process.argv.forEach(function(val, index, array) {
        
       console.log(index + ': ' + val);
    });
    
    // 获取执行路径
    console.log(process.execPath);
    
    
    // 平台信息
    console.log(process.platform);

执行 main.js 文件，代码如下所示:

$ node main.js
    Hello World!
    0: node
    1: /web/www/node/main.js
    /usr/local/node/0.10.36/bin/node
    darwin

# Node.js 常用工具 #

`util`是`一个Node.js 核心模块`，`提供常用函数的集合`，`用于弥补核心 JavaScript 的功能 过于精简的不足。`

使用方法如下：

const util = require('util');

## util.callbackify ##

`util.callbackify(original)`将 `async 异步函数（或者一个返回值为 Promise 的函数）`转换成遵循`异常优先的回调风格的函数`，例如将`(err, value) => ... 回调作为最后一个参数。`在回调函数中，`第一个参数为拒绝的原因（如果 Promise 解决，则为 null），第二个参数则是解决的值。`  
实例

const util = require('util');
    
    async function fn() {
        
      return 'hello world';
    }
    const callbackFunction = util.callbackify(fn);
    
    callbackFunction((err, ret) => {
        
      if (err) throw err;
      console.log(ret);
    });

以上代码输出结果为：

hello world

`回调函数是异步执行的`，并且`有异常堆栈错误追踪`。 `如果回调函数抛出一个异常`，`进程会触发一个 'uncaughtException' 异常，如果没有被捕获，进程将会退出。`

`null` 在回调函数中作为一个参数有其特殊的意义，`如果回调函数的首个参数为 Promise 拒绝的原因且带有返回值，且值可以转换成布尔值 false，这个值会被封装在 Error 对象里，可以通过属性 reason 获取。`

function fn() {
        
      return Promise.reject(null);
    }
    const callbackFunction = util.callbackify(fn);
    
    callbackFunction((err, ret) => {
        
      // 当 Promise 被以 `null` 拒绝时，它被包装为 Error 并且原始值存储在 `reason` 中。
      err && err.hasOwnProperty('reason') && err.reason === null;  // true
    });

original 为 `async 异步函数`。该`函数返回传统回调函数`。

## util.inherits ##

`util.inherits(constructor, superConstructor)` 是一个`实现对象间原型继承的函数`。

`JavaScript 的面向对象特性是基于原型的`，与常见的基于类的不同。JavaScript 没有提供对象继承的语言级别特性，而是通过`原型复制来实现的`。

在这里我们只介绍 util.inherits 的用法，示例如下：

我们定义了一个基础对象 `Base`和一个继承自 `Base 的 Sub`，Base 有三个在构造函数内定义的属性和一个原型中定义的函数，通过`util.inherits 实现继承`。运行结果如下：

base 
    Hello base 
    {
         name: 'base', base: 1991, sayHello: [Function] } 
    sub 
    {
         name: 'sub' }

注意：`Sub`仅仅继承了`Base 在原型中定义的函数`，而构造函数内部创造的`base 属 性和 sayHello 函数都没有被 Sub 继承`。

同时，在原型中定义的属性不会被 console.log 作 为对象的属性输出。如果我们去掉 objSub.sayHello(); 这行的注释，将会看到：

node.js:201 
    throw e; // process.nextTick error, or 'error' event on first tick 
    ^ 
    TypeError: Object #<Sub> has no method 'sayHello' 
    at Object.<anonymous> (/home/byvoid/utilinherits.js:29:8) 
    at Module._compile (module.js:441:26) 
    at Object..js (module.js:459:10) 
    at Module.load (module.js:348:31) 
    at Function._load (module.js:308:12) 
    at Array.0 (module.js:479:10) 
    at EventEmitter._tickCallback (node.js:192:40)

## util.inspect ##

`util.inspect(object,[showHidden],[depth],[colors])`是一个将任意对象转换 为`字符串的方法`，通常用于`调试和错误输出`。它至少接受一个参数 object，即要转换的对象。

`showHidden`是一个可选参数，如果值为 true，将会输出更多隐藏信息。

`depth 表示最大递归的层数`，如果对象很复杂，你可以指定层数以控制输出信息的多 少。`如果不指定depth，默认会递归 2 层，指定为 null 表示将不限递归层数完整遍历对象`。 如果 colors 值为 true，输出格式将会以 ANSI 颜色编码，通常用于在终端显示更漂亮 的效果。

特别要指出的是，`util.inspect 并不会简单地直接把对象转换为字符串，即使该对 象定义了 toString 方法也不会调用。`

var util = require('util'); 
    function Person() {
         
        this.name = 'byvoid'; 
        this.toString = function() {
         
        return this.name; 
        }; 
    } 
    var obj = new Person(); 
    console.log(util.inspect(obj)); 
    console.log(util.inspect(obj, true));

运行结果是：

Person {
         name: 'byvoid', toString: [Function] }
    Person {
        
      name: 'byvoid',
      toString: 
       {
         [Function]
         [length]: 0,
         [name]: '',
         [arguments]: null,
         [caller]: null,
         [prototype]: {
         [constructor]: [Circular] } } }

## util.isArray(object) ##

`如果给定的参数 "object" 是一个数组返回 true，否则返回 false。`

var util = require('util');
    
    util.isArray([])
      // true
    util.isArray(new Array)
      // true
    util.isArray({
        })
      // false

## util.isRegExp(object) ##

如果给定的参数 “object” 是一个正则表达式返回true，否则返回false。

var util = require('util');
    
    util.isRegExp(/some regexp/)
      // true
    util.isRegExp(new RegExp('another regexp'))
      // true
    util.isRegExp({
        })
      // false

## util.isDate(object) ##

如果给定的参数 “object” 是一个日期返回true，否则返回false。

var util = require('util');
    
    util.isDate(new Date())
      // true
    util.isDate(Date())
      // false (without 'new' returns a String)
    util.isDate({
        })
      // false

# Node.js 文件系统 #

Node.js 提供一组类似 `UNIX（POSIX）标准的文件操作API`。 Node 导入文件系统模块(fs)语法如下所示：

var fs = require("fs")

## 异步和同步 ##

Node.js 文件系统（fs 模块）模块中的方法均有`异步和同步`版本，例`如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()。`

`异步的方法函数`最后一个参数为`回调函数`，回调函数的`第一个参数包含了错误信息(error)。`

建议大家使用`异步方法`，比起同步，`异步方法性能更高，速度更快，而且没有阻塞。`

实例  
创建 input.txt 文件，内容如下：

菜鸟教程官网地址：www.runoob.com
    文件读取实例

创建 file.js 文件, 代码如下：

var fs = require("fs");
    
    // 异步读取
    fs.readFile('input.txt', function (err, data) {
        
       if (err) {
        
           return console.error(err);
       }
       console.log("异步读取: " + data.toString());
    });
    
    // 同步读取
    var data = fs.readFileSync('input.txt');
    console.log("同步读取: " + data.toString());
    
    console.log("程序执行完毕。");

以上代码执行结果如下：

$ node file.js 
    同步读取: 菜鸟教程官网地址：www.runoob.com
    文件读取实例
    
    程序执行完毕。
    异步读取: 菜鸟教程官网地址：www.runoob.com
    文件读取实例

接下来，让我们来具体了解下 Node.js 文件系统的方法。

## 打开文件 ##

语法  
以下为在异步模式下打开文件的语法格式：

fs.open(path, flags[, mode], callback)

参数  
参数使用说明如下：

*  path - 文件的路径。
 *  flags - 文件打开的行为。具体值详见下文。
 *  mode - 设置文件模式(权限)，文件创建默认权限为 0666(可读，可写)。
 *  callback - 回调函数，带有两个参数如：callback(err, fd)。
 *  flags 参数可以是以下值：

Flag 描述  
![在这里插入图片描述][19c73f94c95d44af95101d286be59273.png]

实例  
接下来我们创建 file.js 文件，并打开 input.txt 文件进行读写，代码如下所示：

var fs = require("fs");
    
    // 异步打开文件
    console.log("准备打开文件！");
    fs.open('input.txt', 'r+', function(err, fd) {
        
       if (err) {
        
           return console.error(err);
       }
      console.log("文件打开成功！");     
    });

以上代码执行结果如下：

$ node file.js 
    准备打开文件！
    文件打开成功！

## 获取文件信息 ##

语法  
以下为`通过异步模式获取文件信息`的语法格式：

fs.stat(path, callback)

参数  
参数使用说明如下：

*  path - 文件路径。
 *  callback - 回调函数，带有两个参数如：(err, stats), stats 是 fs.Stats 对象。

fs.stat(path)执行后，会将stats类的实例返回给其回调函数。可以通过stats类中的提供方法判断文件的相关属性。例如判断是否为文件：

var fs = require('fs');
    
    fs.stat('/Users/liuht/code/itbilu/demo/fs.js', function (err, stats) {
        
        console.log(stats.isFile());         //true
    })

stats类中的方法有：

![在这里插入图片描述][14e3605a66404cf6ac1bd5c58c2ad7ff.png]

实例  
接下来我们创建 file.js 文件，代码如下所示：

var fs = require("fs");
    
    console.log("准备打开文件！");
    fs.stat('input.txt', function (err, stats) {
        
       if (err) {
        
           return console.error(err);
       }
       console.log(stats);
       console.log("读取文件信息成功！");
       
       // 检测文件类型
       console.log("是否为文件(isFile) ? " + stats.isFile());
       console.log("是否为目录(isDirectory) ? " + stats.isDirectory());    
    });

以上代码执行结果如下：

$ node file.js 
    准备打开文件！
    {
         dev: 16777220,
      mode: 33188,
      nlink: 1,
      uid: 501,
      gid: 20,
      rdev: 0,
      blksize: 4096,
      ino: 40333161,
      size: 61,
      blocks: 8,
      atime: Mon Sep 07 2015 17:43:55 GMT+0800 (CST),
      mtime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST),
      ctime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST) }
    读取文件信息成功！
    是否为文件(isFile) ? true
    是否为目录(isDirectory) ? false

## 写入文件 ##

语法  
以下为异步模式下写入文件的语法格式：

fs.writeFile(file, data[, options], callback)

writeFile 直接打开文件默认是 w 模式，所以如果文件存在，该方法写入的内容会覆盖旧的文件内容。

参数  
参数使用说明如下：

*  file - 文件名或文件描述符。
 *  data - 要写入文件的数据，可以是 String(字符串) 或 Buffer(缓冲) 对象。
 *  options - 该参数是一个对象，包含 \{encoding, mode, flag\}。默认编码为 utf8, 模式为 0666 ， flag 为 ‘w’
 *  callback - 回调函数，回调函数只包含错误信息参数(err)，在写入失败时返回。

实例  
接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备写入文件
    数据写入成功！
    --------我是分割线-------------
    读取写入的数据！
    异步读取文件数据: 我是通 过fs.writeFile 写入文件的内容

## 读取文件 ##

语法  
以下为异步模式下读取文件的语法格式：

fs.read(fd, buffer, offset, length, position, callback)

该方法使用了文件描述符来读取文件。

参数  
参数使用说明如下：

*  fd - 通过 fs.open() 方法返回的文件描述符。
 *  buffer - 数据写入的缓冲区。
 *  offset - 缓冲区写入的写入偏移量。
 *  length - 要从文件中读取的字节数。
 *  position - 文件读取的起始位置，如果 position 的值为 null，则会从当前文件指针的位置读取。
 *  callback - 回调函数，有三个参数err, bytesRead, buffer，err 为错误信息， bytesRead 表示读取的字节数，buffer 为缓冲区对象。

实例  
input.txt 文件内容为：

菜鸟教程官网地址：www.runoob.com

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备打开已存在的文件！
    文件打开成功！
    准备读取文件：
    42  字节被读取
    菜鸟教程官网地址：www.runoob.com

## 关闭文件 ##

语法  
以下为`异步模式下关闭文件的语法格式`：

fs.close(fd, callback)

该方法使用了文件描述符来读取文件。

参数  
参数使用说明如下：

*  fd - 通过 fs.open() 方法返回的文件描述符。
 *  callback - 回调函数，没有参数。

实例  
input.txt 文件内容为：

菜鸟教程官网地址：www.runoob.com

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备打开文件！
    文件打开成功！
    准备读取文件！
    菜鸟教程官网地址：www.runoob.com
    文件关闭成功

## 截取文件 ##

语法  
以下为`异步模式下截取文件`的语法格式：

fs.ftruncate(fd, len, callback)

该方法使用了文件描述符来读取文件。

参数  
参数使用说明如下：

*  fd - 通过 fs.open() 方法返回的文件描述符。
 *  len - 文件内容截取的长度。
 *  callback - 回调函数，没有参数。

实例  
input.txt 文件内容为：

site:www.runoob.com

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备打开文件！
    文件打开成功！
    截取10字节内的文件内容，超出部分将被去除。
    文件截取成功。
    读取相同的文件
    site:www.r
    文件关闭成功

## 删除文件 ##

语法  
以下为删除文件的语法格式：

fs.unlink(path, callback)

参数  
参数使用说明如下：

*  path - 文件路径。
 *  callback - 回调函数，没有参数。

实例  
input.txt 文件内容为：

site:www.runoob.com

接下来我们创建 file.js 文件，代码如下所示：

var fs = require("fs");
    
    console.log("准备删除文件！");
    fs.unlink('input.txt', function(err) {
        
       if (err) {
        
           return console.error(err);
       }
       console.log("文件删除成功！");
    });

以上代码执行结果如下：

$ node file.js 
    准备删除文件！
    文件删除成功！

再去查看 input.txt 文件，发现已经不存在了。

## 创建目录 ##

语法  
以下为创建目录的语法格式：

fs.mkdir(path[, options], callback)

参数  
参数使用说明如下：

*  path - 文件路径。
 *  options 参数可以是：
 *  recursive - 是否以递归的方式创建目录，默认为 false。
 *  mode - 设置目录权限，默认为 0777。
 *  callback - 回调函数，没有参数。

实例  
接下来我们创建 file.js 文件，代码如下所示：

var fs = require("fs");
    // tmp 目录必须存在
    console.log("创建目录 /tmp/test/");
    fs.mkdir("/tmp/test/",function(err){
        
       if (err) {
        
           return console.error(err);
       }
       console.log("目录创建成功。");
    });

以上代码执行结果如下：

$ node file.js 
    创建目录 /tmp/test/
    目录创建成功。

可以添加 recursive: true 参数，不管创建的目录 /tmp 和 /tmp/a 是否存在：

fs.mkdir('/tmp/a/apple', {
         recursive: true }, (err) => {
        
      if (err) throw err;
    });

## 读取目录 ##

语法  
以下为读取目录的语法格式：

fs.readdir(path, callback)

参数  
参数使用说明如下：

*  path - 文件路径。
 *  callback - 回调函数，回调函数带有两个参数err, files，err 为错误信息，files 为 目录下的文件数组列表。

实例  
接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    查看 /tmp 目录
    input.out
    output.out
    test
    test.txt

## 删除目录 ##

语法  
以下为删除目录的语法格式：

fs.rmdir(path, callback)

参数  
参数使用说明如下：

*  path - 文件路径。
 *  callback - 回调函数，没有参数。

实例  
接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备删除目录 /tmp/test
    读取 /tmp 目录
    ……

# Node.js GET/POST请求 #

在很多场景中，我们的服务器都需要跟用户的浏览器打交道，如表单提交。

`表单提交到服务器一般都使用 GET/POST 请求`。

本章节我们将为大家介绍 Node.js GET/POST请求。

## 获取GET请求内容 ##

由于`GET请求直接被嵌入在路径中`，`URL是完整的请求路径，包括了?后面的部分`，因此你可以`手动解析后面的内容作为GET请求的参数`。

node.js 中 url 模块中的 parse 函数提供了这个功能。

实例

在浏览器中访问 `http://localhost:3000/user?name=菜鸟教程&url=www.runoob.com`然后查看返回结果:

![在这里插入图片描述][8f4bfe3ee50c4f30a608057756be4da9.png]

### 获取 URL 的参数 ###

我们可以使用`url.parse 方法来解析 URL 中的参数`，代码如下：

实例

var http = require('http');
    var url = require('url');
    var util = require('util');
     
    http.createServer(function(req, res){
        
        res.writeHead(200, {
        'Content-Type': 'text/plain'});
     
        // 解析 url 参数
        var params = url.parse(req.url, true).query;
        res.write("网站名：" + params.name);
        res.write("\n");
        res.write("网站 URL：" + params.url);
        res.end();
     
    }).listen(3000);

在浏览器中访问 `http://localhost:3000/user?name=菜鸟教程&url=www.runoob.com` 然后查看返回结果:

![在这里插入图片描述][e99ce04f53374b5fba8cf2b21d87f67e.png]

## 获取 POST 请求内容 ##

`POST 请求的内容全部的都在请求体中`，`http.ServerRequest`并没有一个属性内容为请求体，`原因是等待请求体传输可能是一件耗时的工作`。

比如上传文件，而很多时候我们可能并不需要理会请求体的内容，恶意的POST请求会大大消耗服务器的资源，所以`node.js 默认是不会解析请求体的，当你需要的时候，需要手动来做`。

基本语法结构说明

以下实例表单通过 POST 提交并输出数据：

实例

# Node.js 工具模块 #

在 Node.js 模块库中有很多好用的模块。接下来我们为大家介绍几种常用模块的使用：

序号 模块名 & 描述  
1 [OS 模块][OS]  
提供基本的系统操作函数。  
2 [Path 模块][Path]  
提供了处理和转换文件路径的工具。  
3 [Net 模块][Net]  
用于底层的网络通信。提供了服务端和客户端的的操作。  
4 [DNS 模块][DNS]  
用于解析域名。  
5 [Domain 模块][Domain]  
简化异步代码的异常处理，可以捕捉处理try catch无法捕捉的。

# Node.js Web 模块 #

## 什么是 Web 服务器？ ##

Web服务器一般指网站服务器，是指驻留于因特网上某种类型计算机的程序，Web服务器的基本功能就是提供Web信息浏览服务。它只需支持HTTP协议、HTML文档格式及URL，与客户端的网络浏览器配合。

大多数 web 服务器都支持服务端的脚本语言（php、python、ruby）等，并通过脚本语言从数据库获取数据，将结果返回给客户端浏览器。

目前最主流的三个Web服务器是`Apache、Nginx、IIS`。

## Web 应用架构 ##

![在这里插入图片描述][3e1afbb5bce14265b82d4a79fe6edc43.png]

`Client- 客户端`，一般指浏览器，`浏览器可以通过 HTTP 协议向服务器请求数据`。

`Server - 服务端`，一般指 Web 服务器，`可以接收客户端请求，并向客户端发送响应数据`。

`Business - 业务层`， 通过 Web 服务器处理应用程序，`如与数据库交互，逻辑运算，调用外部程序等`。

`Data - 数据层`，一般由数据库组成。

## 使用 Node 创建 Web 服务器 ##

Node.js 提供了`http 模块`，http 模块主要用于`搭建 HTTP 服务端和客户端`，`使用 HTTP 服务器或客户端功能必须调用 http 模块`，代码如下：

var http = require('http');

以下是演示一个最基本的 HTTP 服务器架构(使用 8080 端口)，创建 server.js 文件，代码如下所示：

实例

接下来我们在该目录下创建一个 index.html 文件，代码如下：

index.html 文件
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>菜鸟教程(runoob.com)</title>
    </head>
    <body>
        <h1>我的第一个标题</h1>
        <p>我的第一个段落。</p>
    </body>
    </html>

执行 server.js 文件：

$ node server.js
    Server running at http://127.0.0.1:8080/

接着我们在浏览器中打开地址：http://127.0.0.1:8080/index.html，显示如下图所示:  
![在这里插入图片描述][622cc7b039404af1bcf3ab47a289798c.png]

执行 server.js 的控制台输出信息如下：

Server running at http://127.0.0.1:8080/
    Request for /index.html received.     #  客户端请求信息

## 使用 Node 创建 Web 客户端 ##

Node 创建 Web 客户端需要引入 http 模块，创建 client.js 文件，代码如下所示：

实例

新开一个终端，执行 client.js 文件，输出结果如下：

$ node  client.js 
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>菜鸟教程(runoob.com)</title>
    </head>
    <body>
        <h1>我的第一个标题</h1>
        <p>我的第一个段落。</p>
    </body>
    </html>

执行 server.js 的控制台输出信息如下：

Server running at http://127.0.0.1:8080/
    Request for /index.html received.   # 客户端请求信息

# Node.js Express 框架 #

## Express 简介 ##

Express 是一个简洁而灵活的 `node.js Web应用框架`, 提供了一系列强大特性`帮助你创建各种 Web 应用，和丰富的 HTTP 工具`。

使用 Express 可以快速地搭建一个完整功能的网站。

`Express 框架核心特性：`

*  可以设置中间件来响应 HTTP 请求。
 *  定义了路由表用于执行不同的 HTTP 请求动作。
 *  可以通过向模板传递参数来动态渲染 HTML 页面。

## 安装 Express ##

安装 Express 并将其保存到依赖列表中：

$ cnpm install express --save

以上命令会将`Express 框架安装在当前目录的 node_modules 目录中， node_modules 目录下会自动创建 express 目录`。以下几个重要的模块是需要与 express 框架一起安装的：

*  body-parser - node.js 中间件，用于处理 JSON, Raw, Text 和 URL 编码的数据。
 *  cookie-parser - 这就是一个解析Cookie的工具。通过req.cookies可以取到传过来的cookie，并把它们转成对象。
 *  multer - node.js 中间件，用于处理 enctype=“multipart/form-data”（设置表单的MIME编码）的表单数据。

$ cnpm install body-parser --save
    $ cnpm install cookie-parser --save
    $ cnpm install multer --save

安装完后，我们可以查看下 express 使用的版本号：

$ cnpm list express
    /data/www/node
    └── express@4.15.2  -> /Users/tianqixin/www/node/node_modules/.4.15.2@express

## 第一个 Express 框架实例 ##

接下来我们使用 Express 框架来输出 “Hello World”。

以下实例中我们引入了 express 模块，并在客户端发起请求后，响应 “Hello World” 字符串。

创建 express\_demo.js 文件，代码如下所示：  
express\_demo.js 文件代码：

//express_demo.js 文件
    var express = require('express');
    var app = express();
     
    app.get('/', function (req, res) {
        
       res.send('Hello World');
    })
     
    var server = app.listen(8081, function () {
        
     
      var host = server.address().address
      var port = server.address().port
     
      console.log("应用实例，访问地址为 http://%s:%s", host, port)
     
    })

执行以上代码：

$ node express_demo.js 
    应用实例，访问地址为 http://0.0.0.0:8081

在浏览器中访问 http://127.0.0.1:8081，结果如下图所示：

![在这里插入图片描述][b92025d7eaf240158dd5ff47e3ce0f7a.png]

## 请求和响应 ##

Express 应用使用回调函数的参数： request 和 response 对象来处理请求和响应的数据。

app.get('/', function (req, res) {
        
       // --
    })

request 和 response 对象的具体介绍：

Request 对象 - request 对象表示 HTTP 请求，包含了请求查询字符串，参数，内容，HTTP 头部等属性。常见属性有：

req.app：当callback为外部文件时，用req.app访问express的实例  
req.baseUrl：获取路由当前安装的URL路径  
req.body / req.cookies：获得「请求主体」/ Cookies  
req.fresh / req.stale：判断请求是否还「新鲜」  
req.hostname / req.ip：获取主机名和IP地址  
req.originalUrl：获取原始请求URL  
req.params：获取路由的parameters  
req.path：获取请求路径  
req.protocol：获取协议类型  
req.query：获取URL的查询参数串  
req.route：获取当前匹配的路由  
req.subdomains：获取子域名  
req.accepts()：检查可接受的请求的文档类型  
req.acceptsCharsets / req.acceptsEncodings / req.acceptsLanguages：返回指定字符集的第一个可接受字符编码  
req.get()：获取指定的HTTP请求头  
req.is()：判断请求头Content-Type的MIME类型  
**Response 对象 - response 对象表示 HTTP 响应，即在接收到请求时向客户端发送的 HTTP 响应数据。常见属性有：**

res.app：同req.app一样  
res.append()：追加指定HTTP头  
res.set()在res.append()后将重置之前设置的头  
res.cookie(name，value \[，option\])：设置Cookie  
opition: domain / expires / httpOnly / maxAge / path / secure / signed  
res.clearCookie()：清除Cookie  
res.download()：传送指定路径的文件  
res.get()：返回指定的HTTP头  
res.json()：传送JSON响应  
res.jsonp()：传送JSONP响应  
res.location()：只设置响应的Location HTTP头，不设置状态码或者close response  
res.redirect()：设置响应的Location HTTP头，并且设置状态码302  
res.render(view,\[locals\],callback)：渲染一个view，同时向callback传递渲染后的字符串，如果在渲染过程中有错误发生next(err)将会被自动调用。callback将会被传入一个可能发生的错误以及渲染后的页面，这样就不会自动输出了。  
res.send()：传送HTTP响应  
res.sendFile(path \[，options\] \[，fn\])：传送指定路径的文件 -会自动根据文件extension设定Content-Type  
res.set()：设置HTTP头，传入object可以一次设置多个头  
res.status()：设置HTTP状态码  
res.type()：设置Content-Type的MIME类型

## 路由 ##

我们已经了解了 HTTP 请求的基本应用，而`路由决定了由谁(指定脚本)去响应客户端请求`。

在HTTP请求中，我们可以通过路由`提取出请求的URL以及GET/POST参数`。

接下来我们扩展 Hello World，添加一些功能来处理更多类型的 HTTP 请求。

创建 express\_demo2.js 文件，代码如下所示：

express_demo2.js 文件代码：
    var express = require('express');
    var app = express();
     
    //  主页输出 "Hello World"
    app.get('/', function (req, res) {
        
       console.log("主页 GET 请求");
       res.send('Hello GET');
    })
     
     
    //  POST 请求
    app.post('/', function (req, res) {
        
       console.log("主页 POST 请求");
       res.send('Hello POST');
    })
     
    //  /del_user 页面响应
    app.get('/del_user', function (req, res) {
        
       console.log("/del_user 响应 DELETE 请求");
       res.send('删除页面');
    })
     
    //  /list_user 页面 GET 请求
    app.get('/list_user', function (req, res) {
        
       console.log("/list_user GET 请求");
       res.send('用户列表页面');
    })
     
    // 对页面 abcd, abxcd, ab123cd, 等响应 GET 请求
    app.get('/ab*cd', function(req, res) {
           
       console.log("/ab*cd GET 请求");
       res.send('正则匹配');
    })
     
     
    var server = app.listen(8081, function () {
        
     
      var host = server.address().address
      var port = server.address().port
     
      console.log("应用实例，访问地址为 http://%s:%s", host, port)
     
    })

执行以上代码：

$ node express\_demo2.js  
应用实例，访问地址为 http://0.0.0.0:8081  
接下来你可以尝试访问 http://127.0.0.1:8081 不同的地址，查看效果。

在浏览器中访问 http://127.0.0.1:8081/list\_user，结果如下图所示：

![在这里插入图片描述][c8316988422f462d9c6e570b8e8e08ac.png]

## 静态文件 ##

Express 提供了内置的中间件 `express.static`来设置静态文件如：图片， CSS, JavaScript 等。

你可以使用 express.static 中间件来设置静态文件路径。例如，如果你将图片， CSS, JavaScript 文件放在 public 目录下，你可以这么写：

app.use('/public', express.static('public'));

我们可以到 public/images 目录下放些图片,如下所示：

node_modules
    server.js
    public/
    public/images
    public/images/logo.png

让我们再修改下 “Hello World” 应用添加处理静态文件的功能。

创建 express\_demo3.js 文件，代码如下所示：

express_demo3.js 文件代码：
    var express = require('express');
    var app = express();
     
    app.use('/public', express.static('public'));
     
    app.get('/', function (req, res) {
        
       res.send('Hello World');
    })
     
    var server = app.listen(8081, function () {
        
     
      var host = server.address().address
      var port = server.address().port
     
      console.log("应用实例，访问地址为 http://%s:%s", host, port)
     
    })

执行以上代码：

$ node express_demo3.js 
    应用实例，访问地址为 http://0.0.0.0:8081

执行以上代码：

在浏览器中访问 http://127.0.0.1:8081/public/images/logo.png（本实例采用了菜鸟教程的 logo）

## GET 方法 ##

以下实例演示了在表单中通过 `GET 方法提交两个参数`，我们可以使用 server.js 文件内的 process\_get 路由器来处理输入：

index.html 文件代码：

<html>
    <body>
    <form action="http://127.0.0.1:8081/process_get" method="GET">
    First Name: <input type="text" name="first_name">  <br>
     
    Last Name: <input type="text" name="last_name">
    <input type="submit" value="Submit">
    </form>
    </body>
    </html>

server.js 文件代码：

执行以上代码：

node server.js  
应用实例，访问地址为 http://0.0.0.0:8081  
浏览器访问 http://127.0.0.1:8081/index.html，如图所示：

现在你可以向表单输入数据，并提交，如下演示：  
![在这里插入图片描述][a4f2443d52004ce6b0e5430bf708d2f2.png]

## POST 方法 ##

以下实例演示了在表单中通过 POST 方法提交两个参数，我们可以使用 server.js 文件内的 process\_post 路由器来处理输入：

index.html 文件代码：

<html>
    <body>
    <form action="http://127.0.0.1:8081/process_post" method="POST">
    First Name: <input type="text" name="first_name">  <br>
     
    Last Name: <input type="text" name="last_name">
    <input type="submit" value="Submit">
    </form>
    </body>
    </html>

server.js 文件代码：

执行以上代码：

$ node server.js
    应用实例，访问地址为 http://0.0.0.0:8081

浏览器访问 http://127.0.0.1:8081/index.html，如图所示：  
![在这里插入图片描述][557235fbdbf84aad8ba9bb87149e2177.png]

## 文件上传 ##

以下我们创建一个用于上传文件的表单，使用 POST 方法，表单 enctype 属性设置为 multipart/form-data。

index.html 文件代码：

<html>
    <head>
    <title>文件上传表单</title>
    </head>
    <body>
    <h3>文件上传：</h3>
    选择一个文件上传: <br />
    <form action="/file_upload" method="post" enctype="multipart/form-data">
    <input type="file" name="image" size="50" />
    <br />
    <input type="submit" value="上传文件" />
    </form>
    </body>
    </html>

server.js 文件代码：

执行以上代码：

$ node server.js 
    应用实例，访问地址为 http://0.0.0.0:8081

浏览器访问 http://127.0.0.1:8081/index.html，如图所示：

![在这里插入图片描述][4c3c7b19c022472ea3bae2ef7a7a3c7a.png]

## Cookie 管理 ##

我们可以使用中间件向`Node.js 服务器发送 cookie 信息`，以下代码输出了客户端发送的 cookie 信息：

express\_cookie.js 文件代码：

// express_cookie.js 文件
    var express      = require('express')
    var cookieParser = require('cookie-parser')
    var util = require('util');
     
    var app = express()
    app.use(cookieParser())
     
    app.get('/', function(req, res) {
        
        console.log("Cookies: " + util.inspect(req.cookies));
    })
     
    app.listen(8081)

执行以上代码：

$ node express_cookie.js

现在你可以访问 http://127.0.0.1:8081 并查看终端信息的输出，如下演示：  
![在这里插入图片描述][5cafd091bd6b409b878af3781b2bbcd7.png]

[f5322afcfdd440d0865399a0cc0619d2.png]: https://img-blog.csdnimg.cn/f5322afcfdd440d0865399a0cc0619d2.png
[99f99ec2007a4502a3d55e801f58fe79.png]: https://img-blog.csdnimg.cn/99f99ec2007a4502a3d55e801f58fe79.png
[6f89d65de7504998bb5108744c1f7c63.png]: https://img-blog.csdnimg.cn/6f89d65de7504998bb5108744c1f7c63.png
[19c73f94c95d44af95101d286be59273.png]: https://img-blog.csdnimg.cn/19c73f94c95d44af95101d286be59273.png
[14e3605a66404cf6ac1bd5c58c2ad7ff.png]: https://img-blog.csdnimg.cn/14e3605a66404cf6ac1bd5c58c2ad7ff.png
[8f4bfe3ee50c4f30a608057756be4da9.png]: https://img-blog.csdnimg.cn/8f4bfe3ee50c4f30a608057756be4da9.png
[e99ce04f53374b5fba8cf2b21d87f67e.png]: https://img-blog.csdnimg.cn/e99ce04f53374b5fba8cf2b21d87f67e.png
[OS]: https://www.runoob.com/nodejs/nodejs-os-module.html
[Path]: https://www.runoob.com/nodejs/nodejs-path-module.html
[Net]: https://www.runoob.com/nodejs/nodejs-net-module.html
[DNS]: https://www.runoob.com/nodejs/nodejs-dns-module.html
[Domain]: https://www.runoob.com/nodejs/nodejs-domain-module.html
[3e1afbb5bce14265b82d4a79fe6edc43.png]: https://img-blog.csdnimg.cn/3e1afbb5bce14265b82d4a79fe6edc43.png
[622cc7b039404af1bcf3ab47a289798c.png]: https://img-blog.csdnimg.cn/622cc7b039404af1bcf3ab47a289798c.png
[b92025d7eaf240158dd5ff47e3ce0f7a.png]: https://img-blog.csdnimg.cn/b92025d7eaf240158dd5ff47e3ce0f7a.png
[c8316988422f462d9c6e570b8e8e08ac.png]: https://img-blog.csdnimg.cn/c8316988422f462d9c6e570b8e8e08ac.png
[a4f2443d52004ce6b0e5430bf708d2f2.png]: https://img-blog.csdnimg.cn/a4f2443d52004ce6b0e5430bf708d2f2.png
[557235fbdbf84aad8ba9bb87149e2177.png]: https://img-blog.csdnimg.cn/557235fbdbf84aad8ba9bb87149e2177.png
[4c3c7b19c022472ea3bae2ef7a7a3c7a.png]: https://img-blog.csdnimg.cn/4c3c7b19c022472ea3bae2ef7a7a3c7a.png
[5cafd091bd6b409b878af3781b2bbcd7.png]: https://img-blog.csdnimg.cn/5cafd091bd6b409b878af3781b2bbcd7.png