一、Node.js 是什么

Node.js 不是一门新的语言，是基于 V8 引擎的一个让 js 能够运行在服务端的运行环境（runtime）；我们也可以理解成是一个 VM（虚拟机）；在服务器上安装 node 后，就可以在服务器上用 js 开发服务端程序，从此 JS 就成为了全栈开发语言

开发一个完整的项目，不仅需要前端还需要后端；后端的代码是运行在服务器上的；前后端通过 http 协议通信传递数据；客户端通过 http 协议发送请求，服务端接收客户端的请求，然后把资源通过 http 响应给客户端；

  • 传统的服务端语言：
  1. Java
  2. Php
  3. C C++
  4. .net
  5. python
  6. Golang

二、Node 的优势

JS 在 node 环境下运行的语法，运行的特点：

  1. 单线程异步，事件驱动
  2. 事件驱动的非阻塞 I/O 操作，轻量高效
  3. npm 包管理器，全球最大的开源 node 生态系统
  4. npm 是伴随着 node 一起安装的，安装完 node，npm 也就安装好了
  5. npm 包是别人做好的库或者工具，我们只需要安装和导入就可以使用（yarn 也是新兴的包管理器）

三、Node 中的模块

什么是模块；

模块：在 Node 中每个 js 都是一个模块，所有的逻辑和方法都应该写在模块内；

Node 的模块分为三种：

  • 内置的核心模块：安装 node 时 node 内置的模块一并安装了；如 http 模块，fs 模块等
  • 自定义模块：我们自己写的模块；
  • 第三方的模块：通过 npm 安装的

四、自己创建一个模块

  • 新建一个 js 文件，名为 4-test.js
  1. console.log(11100);
  3. function fn() {
  4.     console.log(1 + 1)
  5. }
  7. fn();
  9. module.exports.fn = fn;

模块的导出

有三种导出方式：

  1. module.exports = fn;
  1. module.exports = fn;
  1. exports.fn = fn;
  1. exports.fn = fn;
  1. module.exports.fn = fn 等效于 exports.fn = fn;
  1. module.exports.fn = fn;

模块原理：

node 天生自带模块化，node 会在 js 文件外面套一个自执行函数，并且执行时传入 exports、module、require、dirname** **、filename

(function (exports, module, require, dirname**, filename) {
// console.log(exports); // 导出
// console.log(module); // 模块
// console.log(require); // 导入
// console.log(dirname); // 路径，绝对路径
// console.log(filename); // 文件名，带绝对路径和拓展名
})(exports, module, require, __dirname__, **filename);

五、使用模块

导入模块

使用模块之前要先导入模块：

  • 导入模块的方法：require()
  1. let test = require('./4-test'); // 导入时模块中的代码就会执行

注意：js 运行在浏览器端，浏览器会提供全局对象 window，在 node 中没有 window，node 中有 global

  1. console.log(test);

不同导出方式导入的结果也不同

  1. 如果模块中使用 module.exports = fn; 或者 exports.fn = fn;导出，我们在其他模块导入时，导入后得到的就是 fn;
  1. test();
  1. 通过 exports.fn = fn; 我们导入将会得到一个对象，需要通过对象.属性名访问方法才能调用
  1. console.log(test); {fn: [Function] } // 我们从4-test中导出的模块是一个对象
  2. test.fn();

模块导入的注意事项：

  1. 导入内置模块和第三方模块时可以不写路径
  2. 导入自己写的模块时要写路径
  3. 在 node 中导入模块可以省略 .js 和 .json;
  1. // 内置模块
  2. let http = require('http');
  3. let fs = require('fs');
  5. let json = require('./aside');
  7. console.log(Array.isArray(json)); // 在 node 环境中，node 会自动把 json 处理成对象

六、一个模块导出多条信息

  • 6-sum.js 文件中有这样两个方法，都要导出
  1. function sum(...arg) {
  2.     let total = null;
  3.     arg.forEach(item => total += item);
  4.     return total;
  5. }
  7. function minus(a, b) {
  8.     return a - b;
  9. }
  1. 逐个导出：
  1. module.exports.sum = sum;
  2. module.exports.minus = minus;
  1. 把 module.exports 指向一个新的对象
  1. module.exports = {
  2.     sum,
  3.     minus
  4. };

七、导入多个

  • 配合解构赋值使用
  1. let s = require('./6-sum');
  2. console.log(s);
  3. let {sum, minus} = s;
  4. let total = sum(1, 3, 5, 7, 9);
  5. console.log(total);

八、第三方模块

第三方的模块

使用第三方的模块称为依赖包；需要使用 npm 或者 yarn 来安装（下载）；以后大家会使用 npm 或者 yarn 来下载组件、框架、或者类库

  • 通过命令行来下载依赖

1. 初始化配置文件，通过 npm 生成一个 package.json；这个 package.json 是用来记录当前项目所需要的依赖（框架、类库、脚手架等）

  1. npm init -y

注意文件路径不要有中文；

2. 安装项目依赖：

  1. -dependencies 生产依赖
  3. -devDependencies 开发依赖
  1. npm install 依赖包名称

3. npm install 参数：

  1. 1. 无 会把依赖包下载到 node_modules 中，会添加到 devpendencies 中；
  2. 2. -g 全局安装，把依赖包或者工具像程序一样安装在系统中，并且添加到环境变量，并且声成一个命令，这个命令在哪里都能运行；
  3. 3. -save 会把依赖包下载到 node_modules 中，并且在 package.json 中的 dependencies 中添加信息；
  4. 4. -save-dev 安装依赖包到 node_modules 中，并且会在 package.json 的 devDependencies 添加该依赖的信息；
  • 一些工具性的东西如 webpack、less-loader、bable 等都是开发依赖；而 jq 等都是生产依赖；

4. npm install 命令：

  1. 安装指定的安装包：npm install 参数 依赖包
  2. 根据 package.json 安装 npm install

九、内置的 fs 模块

什么是内置模块

内置模块（built-in）：node 的安装时已经内置了核心模块，不用我们制造，可以直接使用；

fs模块：file system 文件系统，文件读写模块，用于读写文件；

  1. let fs = require('fs');

1. 异步读取文件：

  1. fs.readFile(fileName, option, callback)
  • fileName: 文件名
  • option: 以哪一种编码返回内容，默认的 buffer 类型的值，buffer 中存储的是二进制数据；所以一般设置为 utf8
  • callback: 读取文件后执行的回调
  1. fs.readFile('./text.txt', 'utf8', function (err, data) {
  2.     err // 读取失败的错误信息
  3.     data // 从文件中读取来的数据
  4.     console.log(data)
  5. });

2. 同步读取文件：

  1. fs.readFileSync(fileName, options);
  • fileName: 文件名
  • options: 编码
  • 该方法会返回同步读取到的内容
  1. let content = fs.readFileSync('./text.txt', 'utf8');
  2. console.log(content);

3. 修改文件（向文件中写）

3.1 异步写入：

  1. fs.writeFile(path, data, option, callback)
  • path 文件名（如果没有就创建一个文件）
  • data 写入文件的数据
  • option 文件编码
  • callback 写入后执行的回调
  1. fs.writeFile('1.js', 'console.log(`hello world`);','utf8', function (err, data) {
  2.     if (err) {
  3.         console.log(err);
  4.     } else {
  5.         console.log('写入成功')
  6.     }
  7. });

3.2 同步写入：

  1. fs.writeFileSync(path, data, option)
  • path 文件名及路径
  • data 写入的数据
  • option 写入的编码
  1. fs.writeFileSync('../x.js', 'alert(`hello world`)', 'utf8');

注意以上写入都是覆盖的写入，把文件中原有的内容覆盖掉；

4. 向文件中追加内容:

4.1 异步追加

  1. fs.appendFile(path, data, option, callback);
  • data 写入文件的数据
  • option 文件编码
  • callback 写入后执行的回调
  1. fs.appendFile('./1.js', '\nfunction sum (a, b) {return a + b}', 'utf8', function (err, data) {
  2.     if (err) {
  3.         console.log(err);
  4.     } else {
  5.         console.log(data)
  6.     }
  7. });

4.2 同步追加

  1. fs.appendFileSync(path, data, option);
  • path 文件名及路径
  • data 写入的数据
  • option 写入的编码
  1. fs.appendFileSync('../x.js', ';\n\rfunction minus(a, b) {return a - b}', 'utf8');