# Node.js 基础

# 初识 Nodejs

# 什么是Node.js

Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行时环境

Node.js 主要包括 V8引擎 和 内置API（fs 、 path 、 http 、js内置对象、querystring 、stc …）
内置API给待执行的js代码提供能力，V8引擎来执行js代码。
浏览器是Js的前端运行环境
Node.js是js的后端运行环境
Node.js中无法调用 DOM 和 BOM等浏览器内置的API

# Node.js可以干什么

基于 Express 框架 (opens new window)，可以快速构建 Web 应用
基于 Electron 框架 (opens new window)，可以构建跨平台的桌面应用
基于 restify 框架 (opens new window)，可以快速构建 API 接口项目
读写和操作数据库、创建实用的命令行工具辅助前端开发、etc…

# Node.js的学习路径

JavaScript 基础语法 + Node.js内置API模块（fs、path、http等）+ 第三方API模块（express、mysql等）

# 安装Node.js

官方网站下载node.js node -v 查看node的版本号

# 在Node.js 环境中执行JavaScript代码

打开cmd 需要切换到文件所处的文件目录 node 文件地址
先到所处目录下按住 shift + 点击鼠标右键 -> 在此处打开powershell窗口

node执行js

终端中基础的按钮操作

↑ 可以快速找到上一条执行的命令
tab键补全路径
esc键清空当前一行输入的命令
cls命令清空终端的所有命令行（包括之前运行了的)

# Buffer 缓冲区 [x]

Buffer 缓冲区文档 (opens new window)

Buffer 的结构与数组类似，操作方法也与数组类似
数组不能存储二进制文件，Buffer 是专门存储二进制数据的
Buffer 存储的是二进制数据，显示时以 16 进制的形式显示
Buffer 每一个元素范围是 00~ff，即 0~255、00000000~11111111
每一个元素占用一个字节内存
Buffer 是对底层内存的直接操作，因此大小一旦确定就不能修改

Buffer 常用方法：

Buffer.from(str[, encoding])：将一个字符串转换为 Buffer
Buffer.alloc(size)：创建指定大小的 Buffer
Buffer.alloUnsafe(size)：创建指定大小的 Buffer，可能包含敏感数据（分配内存时不会清除内存残留的数据）
buf.toString()：将 Buffer 数据转为字符串

var str = 'Hello前端'

var buf = Buffer.from(str)

// 占用内存的大小，一个汉字3字节 13
console.log(buf.length)
// 字符串的长度 7
console.log(str.length)
// 8进制输出第一个元素 145
console.log(buf[1].toString(8))

//创建一个10个字节的buffer
var buf2 = Buffer.alloc(10)
//通过索引，来操作buf中的元素
buf2[0] = 88
buf2[1] = 255
buf2[2] = 0xaa
buf2[3] = 255

var buf3 = Buffer.allocUnsafe(10)
console.log(buf3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# fs 文件系统模块

fs 模块中所有的操作都有两种形式可供选择:同步和异步
同步文件系统会阻塞程序的执行，也就是除非操作完毕，否则不会向下执行代码
异步文件系统不会阻塞程序的执行，而是在操作完成时，通过回调函数将结果返回
实际开发很少用同步方式，因此只介绍异步方式

打开模式：

模式	说明
r	读取文件，文件不存在抛异常
r+	读写文件，文件不存在抛异常
rs	同步模式下打开文件用于读取
rs+	同步模式下打开文件用于读写
w	写文件，不存在则创建，存在则覆盖原有内容
wx	写文件，文件存在打开失败
w+	读写文件，不存在创建，存在截断
wx+	读写，存在打开失败
a	追加，不存在创建
ax	追加，存在失败
a+	追加和读取，不存在创建
ax+	追加和读取，存在失败

# 读取文件

# 简单文件读取

语法格式：

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

[ ] 表示可选项其他是必选的

path：必选参数,文件路径
options：可选参数,表示以什么编码格式来读取文件：若是字符串则指定编码格式
- encoding：编码格式
- flag：打开方式
callback：必选参数,回调函数
- err：错误信息
- data：读取的数据，如果未指定编码格式则返回一个 Buffer

// 1.导入 fs 模块，来操作文件
const fs = require("fs");
// 2.调用 fs.readFile() 方法读取文件
// 以utf8的编码格式，读取指定文件的内容，并打印err和data的值
fs.readFile('./files/1.txt', 'utf-8', function (err, data) {
    // 2.1 打印失败的结果
    // 如果读取失败，则err是错误对象，data的值为undefined
    console.log("err", err);
    console.log("----------------");
    // 2.2 打印成功的结果
    console.log("data", data);
})


// err判断文件是否读取成功
const fs = require('fs')
fs.readFile('./files/1.txt', 'utf-8', function(err, data) => {
  if(err) {
    return console.log('失败!' + err.message)
  }
  console.log('成功:' + data)
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 流式文件读取 [x]

简单文件读取的方式会一次性读取文件内容到内存中，若文件较大，会占用过多内存影响系统性能，且读取速度慢
大文件适合用流式文件读取，它会分多次将文件读取到内存中

var fs = require('fs')

// 创建一个可读流
var rs = fs.createReadStream('C:/Users/笔记.mp3')
// 创建一个可写流
var ws = fs.createWriteStream('a.mp3')

// 监听流的开启和关闭
// 这几个监听不是必须的
rs.once('open', function () {
  console.log('可读流打开了~~')
})

rs.once('close', function () {
  console.log('可读流关闭了~~')
  //数据读取完毕，关闭可写流
  ws.end()
})

ws.once('open', function () {
  console.log('可写流打开了~~')
})

ws.once('close', function () {
  console.log('可写流关闭了~~')
})

//要读取一个可读流中的数据，要为可读流绑定一个data事件，data事件绑定完毕自动开始读取数据
rs.on('data', function (data) {
  console.log(data)
  //将读取到的数据写入到可写流中
  ws.write(data)
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

简便方式：

var fs = require('fs')

var rs = fs.createReadStream('C:/Users/lilichao/Desktop/笔记.mp3')
var ws = fs.createWriteStream('b.mp3')

// pipe()可以将可读流中的内容，直接输出到可写流中
rs.pipe(ws)

1
2
3
4
5
6
7

# 写入文件

# 简单文件写入

语法格式：

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

file：必选参数,文件路径
data：必选参数,写入内容
options：可选参数,默认utf-8. 包含 encoding, mode, flag;若是字符串则指定编码格式
callback：必选参数,回调函数

注意

文件存在且有内容是会覆盖其中的内容的
可以创建文件不可以创建路径

const fs = require('fs')
fs.writeFile('./files/2.txt', 'Hello Nodejs', function (err) {
    // 写入成功err是null
    // 写入失败err是个错误对象
  if (err) {
    return console.log('失败!' + err.message)
  }
  console.log('文件写入成功!')
})

fs.writeFile('C:/Users/hello.txt', '通过 writeFile 写入的内容', { flag: 'w' }, function (err) {
  if (!err) {
    console.log('写入成功！')
  } else {
    console.log(err)
  }
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 流式文件写入 [x]

// 同步、异步、简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出
var fs = require('fs')

// 创建一个可写流
var ws = fs.createWriteStream('hello3.txt')

ws.once('open', function () {
  console.log('流打开了~~')
})

ws.once('close', function () {
  console.log('流关闭了~~')
})

// 通过ws向文件中输出内容
ws.write('通过可写流写入文件的内容')
ws.write('1')
ws.write('2')
ws.write('3')
ws.write('4')

// 关闭流
ws.end()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 读写文件小案例

// 复制文件内容
fs.readFile("C:/Users/笔记.mp3", function(err, data) {
 if(!err) {
  console.log(data);
  // 将data写入到文件中
  fs.writeFile("C:/Users/hello.jpg", data, function(err){
   if(!err){
    console.log("文件写入成功");
   }
  } );
 }
});

// 整理成绩案例
// 实现的步骤
// 1.导入fs文件系统模块
// 2.使用fs.readFile()方法,读取 成绩.txt文件
// 3.判断文件是否读取失败
// 4.读取成功的话 就处理 成绩数据
// 5.数据处理完 用writeFile()方法，写入到新文件 xx.txt 文件

const fs = require("fs");
fs.readFile('./files/成绩.txt', 'utf-8', function (err, data) {
    if (err) { return console.log("成绩读取失败!"); }
    console.log("成绩读取成功!", data);
    // // 4.1 将数据 根据空格分割
    // const arr1 = data.split(' ')
    // const newArr = [];
    // // 4.2 循环 将每项的 = 替换成 ：
    // arr1.forEach(item => {
    //     newArr.push(item.replace("=", "："))
    // })
    // // console.log("newArr", newArr);
    // // 4.3 将处理好的数据 拼接 成字符串
    // const newStr = newArr.join('\r\n');
    // // console.log("newStr", newStr);
    let newStr = data.split(" ").map(item => item.replace("=", ":")).join("\r\n")

    fs.writeFile("./files/成绩ok.txt", newStr, function (err) {
        if (err) { return  console.log("成绩写入失败");}
        console.log("成绩写入成功");
    })
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

# 路径动态拼接问题 `__dirname`

在使用 fs 模块操作文件时，如果提供的操作路径是以 ./ 或 ../ 开头的相对路径时，容易出现路径动态拼接错误的问题
原因：代码在运行的时候，会以执行 node 命令时所处的目录，动态拼接出被操作文件的完整路径
解决方案：在使用 fs 模块操作文件时，直接提供完整的路径(但是移植性比较差，不利于维护)，从而防止路径动态拼接的问题
最佳方案：双下划线dirname
__dirname 获取文件所处的绝对路径，不会以node执行命令所处目录而变化

fs.readFile(__dirname + '/files/1.txt', 'utf8', function(err, data) {
  ...
})

1
2
3

注意：以上只是演示__dirname怎么使用，路径用路径拼接path.join()实现, + 可能会存在问题

# 其它操作 [x]

验证路径是否存在：

fs.exists(path, callback)
fs.existsSync(path)

获取文件信息：

fs.stat(path, callback)
fs.stat(path)

删除文件：

fs.unlink(path, callback)
fs.unlinkSync(path)

列出文件：

fs.readdir(path[,options], callback)
fs.readdirSync(path[, options])

截断文件：

fs.truncate(path, len, callback)
fs.truncateSync(path, len)

建立目录：

fs.mkdir(path[, mode], callback)
fs.mkdirSync(path[, mode])

删除目录：

fs.rmdir(path, callback)
fs.rmdirSync(path)

重命名文件和目录：

fs.rename(oldPath, newPath, callback)
fs.renameSync(oldPath, newPath)

监视文件更改：

fs.watchFile(filename[, options], listener)

# path 路径模块

path 模块是 Node.js 官方提供的、用来处理路径的模块。它提供了一系列的方法和属性，用来满足用户对路径的处理需求。

# 路径拼接 `path.join()`

const path = require('path')
const fs = require('fs')

// 注意 ../ 会抵消前面的路径
// ./ 会被忽略
const pathStr = path.join('/a', '/b/c', '../', './d', 'e')
console.log(pathStr) // \a\b\d\e
const pathStr = path.join('/a', '/b/c', '../../', './d', 'e')
console.log(pathStr) // \a\d\e

fs.readFile(path.join(__dirname, './files/1.txt'), 'utf8', function (err, dataStr) {
  if (err) {
    return console.log(err.message)
  }
  console.log(dataStr)
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 获取路径中的文件名 `path.basename()`

使用 path.basename() 方法，可以获取路径中的最后一部分。常通过该方法获取路径中的文件名

path.basename(path[, ext])

path: 文件路径
ext: 文件扩展名

const path = require('path')

// 定义文件的存放路径
const fpath = '/a/b/c/index.html'

const fullName = path.basename(fpath)
console.log(fullName) // index.html

const nameWithoutExt = path.basename(fpath, '.html')
console.log(nameWithoutExt) // index

1
2
3
4
5
6
7
8
9
10

# 获取路径中文件扩展名 `path.extname()`

const path = require('path')

const fpath = '/a/b/c/index.html'

const fext = path.extname(fpath)
console.log(fext) // .html

1
2
3
4
5
6

# http 模块

http 模块是 Node.js 官方提供的、用来创建 web 服务器的模块。

# 服务器相关概念补充

补充知识：服务器和普通电脑的区别

服务器和普通电脑的区别在于，服务器上安装了web服务器软件，例如IIS、Apache等。 1.1 phpStudy (opens new window) 中有提供Apache服务
1.1.1 右键-服务管理器-Apache-启动
1.1.2 右键-网络根目录（里面放弄好的文件就可以ip访问了）
Node.js中不需要使用IIS、Apache等第三方web服务器软件。可以用Node.js提供的http模块，通过几行简单的代码，就可以轻松的手写一个服务器软件，从而对外提供web服务。

服务器相关的概念 IP地址域名和域名服务器端口号

IP地址：互联网上每台计算机的唯一地址.
1.1 IP地址的格式，通常用"点分十进制"表示成（a.b.c.d）的形式 0~255之间的十进制整数。比如：127.0.0.1 。
1.2 互联网中每台web服务器，都有自己的ip地址。比如可以 ping www.baidu.com 查看百度服务器的IP地址为112.80.248.76。
域名和域名服务器
2.1 域名地址：因为IP一串数字，不直观，不便于记忆，所以有了另一套字符型的地址方案，即域名地址。比如：www.baidu.com 是域名。
2.2 域名服务器：就是提供IP地址和域名之间转换服务的服务器。比如：127.0.0.1 对应的域名就是localhost
端口号 3.1 每个服务器中的web服务对应一个唯一的端口号，一个端口号不能被多个web服务占用。 3.2 实际应用中，url中的80端口可以被省略

# 创建基本 Web 服务器

创建web服务器的基本步骤

导入http模块

创建web服务器实例

为服务器实例绑定request事件，监听客户端的请求

3.1 req 是请求对象，它包含了与客户端相关的数据和属性

3.1.1 req.url 客户端请求的URL地址(端口号后面的部分)
3.1.2 req.method 客户端的 method 请求类型

3.2 res 响应对象，服务器相关的数据或属性

启动服务器

const http = require('http')

// 创建 web 服务器实例
const server = http.createServer()

// 为服务器实例绑定 request 事件，监听客户端的请求
server.on('request', function (req, res) {
  // 只要有客户端来请求我们自己的服务器，就会触发request事件，从而调用这个事件的处理函数
  const url = req.url
  const method = req.method
  const str = `Your request url is ${url}, and request method is ${method}`
  console.log(str)

  // 设置 Content-Type 响应头，解决给客户端数据，中文乱码的问题
  res.setHeader('Content-Type', 'text/html; charset=utf-8')
  // 向客户端响应内容,并且结束这次请求的处理过程
  res.end(str)
})

// 启动服务器
server.listen(8080, function () {
  console.log('server running at http://127.0.0.1:8080')
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 实现简陋路由效果

const http = require('http')
const server = http.createServer()

server.on('request', (req, res) => {
  const url = req.url
  // 设置默认的响应内容为 404 Not found
  let content = '<h1>404 Not found!</h1>'
  // 判断用户请求的是否为 / 或 /index.html 首页
  // 判断用户请求的是否为 /about.html 关于页面
  if (url === '/' || url === '/index.html') {
    content = '<h1>首页</h1>'
  } else if (url === '/about.html') {
    content = '<h1>关于页面</h1>'
  }

  res.setHeader('Content-Type', 'text/html; charset=utf-8')
  res.end(content)
})

server.listen(80, () => {
  console.log('server running at http://127.0.0.1')
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

const fs = require("fs");
const path = require("path");
const http = require("http");
const server = http.createServer();
server.on("request", function (req, res) {
    res.setHeader("Content-Type", 'text/html; charset=utf-8')
    let url = req.url;
    // 刚好是访问地址
    // let fpath = path.join(__dirname, url);
    // 路径优化
    let fpath = "";
    if (url === "/") {
        fpath = path.join(__dirname, "./files/index.txt")
    } else {
        fpath = path.join(__dirname, "./files", url)
    }
    console.log("------:", fpath);
    // 读取文件
    fs.readFile(fpath, "utf-8", (err, data) => {
        if (err) { return res.end("404 Not Found.") }
        res.end(data);
    })
})
server.listen(8083, function () {
    console.log('server running at http://127.0.0.1:8082')
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 模块化

# 模块化概念

模块化是指解决一个复杂问题时，自顶向下逐层把系统划分为若干模块的过程，模块是可组合、分解和更换的单元。
模块化可提高代码的复用性和可维护性，实现按需加载。
模块化规范是对代码进行模块化拆分和组合时需要遵守的规则，如使用什么语法格式引用模块和向外暴露成员。

# Node.js 中模块的分类

内置模块
自定义模块
第三方模块（包）。第三方个人或团队开发出来的

// 1.加载内置的fs模块
const fs = require("fs");

// 2.加载用户的自定义模块(可以省略.js的后缀名)
const custom = require("./cunstom.js")

// 3.加载第三方模块
const moment = require("moment")

1
2
3
4
5
6
7
8

# Node.js 中的模块作用域

和函数作用域类似，在自定义模块中定义的变量、方法等成员，只能在当前模块内被访问，这种模块级别的访问限制，叫做模块作用域
防止全局变量污染

# 模块作用域的成员

自定义模块中都有一个 module 对象，存储了和当前模块有关的信息
在自定义模块中，可以使用 module.exports 对象，将模块内的成员共享出去，供外界使用。导入自定义模块时，得到的就是 module.exports 指向的对象。
默认情况下，exports 和 module.exports 指向同一个对象最终共享的结果。
以 module.exports 指向的对象为准。如下图：

不同的例子

前面两个例子，可以看见，创建了新的对象，exports 和 module.exports 指向了不同的对象。

# CommonJS 模块化规范

CommonJs 规定了规模的特性和各模块之间如何相互依赖

规定：

每个模块内部，module 变量代表当前模块
module 变量是一个对象，module.exports 是对外的接口
加载某个模块即加载该模块的 module.exports 属性

# npm - 包的概念

第三方模块（包）。第三方个人或团队开发出来的

可以从 https://www.npmjs.com/ (opens new window) 网站上搜索自己所需要的包

可以从 https://registry.npmjs.org/ (opens new window) 服务器上下载自己需要的包

# 1. npm 安装包

npm install 包的完整名称
npm i xxx

// 安装指定版本号 
npm i xxx@1.0.1
// 卸载包
npm uninstall 包的完整名称

1
2
3
4
5
6
7

# 2. 初次安装包后多了哪些文件

node_modules 文件夹：用来存放所有已安装到项目的包。require()导入第三方包的时候就是从这个文件夹查找并加载包的
package-lock.json 配置文件用来记录 node_modules目录下的每一个包的下载信息，例如包的名字、版本号、下载地址

# 3. 包的语义化版本规范

包的版本号是以“点分十进制”，总共三位数如：1.11.0 其中每一位数字代表的含义如下：

第一位数字：大版本
第二位数字：功能版本
第三位数字：Bug修复版本

只要前面的版本增长了，后面的版本就归零

# 4. 包管理配置文件 `package.json`

在项目的根目录中，必须提供package.json的包管理配置文件

项目的名称、版本号、描述等
项目中都用到了哪些包
哪些包只在开发期间会用到、哪些包在开发和部署的时候都需要用到

由于node_modules 文件夹很大一般就是项目共享的时候，剔除这个文件夹。（将node_modules文件夹，添加到.gitignore忽略文件中）

自己项目的截图

# 4.1. 快速创建 package.json `npm init -y`

PS D:\SCLziji\node_code_study\day1\code> npm init -y
Wrote to D:\SCLziji\node_code_study\day1\code\package.json:

{
  "name": "code",
  "version": "1.0.0",
  "description": "",
  "main": "00.test.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"  
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行此命令，要求路径上不能有中文和空格

npm install 会自动把包的名称和版本号记录到package.json

# 4.2 `devDependencies`和`dependencies`节点

只在项目开发阶段会用到，项目上线之后不会用到建议放在devDependencies节点

npm install 包名 --save-dev
// 简写
npm i 包名 -D

1
2
3

开发和项目上线之后都需要使用，建议放在dependencies节点

# 5.下载速度慢用淘宝NPM镜像服务器

切换npm的下包镜像源

# 切换为淘宝镜像源
npm config set registry=https://registry.npm.taobao.org/
# 查看镜像源
PS D:\SCLziji\node_code_study\day1\code> npm config get registry
https://registry.npm.taobao.org/

1
2
3
4
5

# 6. nrm 方便切换下包的镜像源

# 安装nrm
npm i nrm -g
# 查看所有可用的镜像源
nrm ls
# 将下包的镜像源切换为taobao镜像
nrm use taobao

1
2
3
4
5
6

# 7. 包的分类和规范的包结构

# 7.1 包的分类

项目包
安装在 node_modules目录中的包，都是项目包
1.1 开发依赖包在devDependencies节点中的包
1.2 核心依赖包在dependencies节点中的包
全局包
安装的时候带 -g
这是我自己的路径：C:\Users\64802\AppData\Roaming\npm\node_modules

# 7.2 包的内部结构

必须以单独的目录而存在
包的顶级目录下必须包含package.json 这个包管理配置文件
package.json 中必须包含name（名字）、version（版本）、main（包的入口）这三个属性

require("moment")这个引入先找对应的package.json 文件的main ; 然后加载main下的

# 8. 开发属于自己的包

没有做笔记

# 模块加载机制

模块第一次加载后会被缓存，即多次调用 require() 不会导致模块的代码被执行多次，提高模块加载效率。

# 内置模块加载

内置模块加载优先级最高。

# 自定义模块加载

加载自定义模块时，路径要以 ./ 或 ../ 开头，否则会作为内置模块或第三方模块加载。

导入自定义模块时，若省略文件扩展名，则 Node.js 会按顺序尝试加载文件：

按确切的文件名加载
补全 .js 扩展名加载
补全 .json 扩展名加载
补全 .node 扩展名加载
报错

# 第三方模块加载

若导入第三方模块， Node.js 会从当前模块的父目录开始，尝试从 /node_modules 文件夹中加载第三方模块。
如果没有找到对应的第三方模块，则移动到再上一层父目录中，进行加载，直到文件系统的根目录。

例如，假设在 C:\Users\bruce\project\foo.js 文件里调用了 require('tools')，则 Node.js 会按以下顺序查找：

C:\Users\bruce\project\node_modules\tools
C:\Users\bruce\node_modules\tools
C:\Users\node_modules\tools
C:\node_modules\tools

# 目录作为模块加载

当把目录作为模块标识符进行加载的时候，有三种加载方式：

在被加载的目录下查找 package.json 的文件，并寻找 main 属性，作为 require() 加载的入口
如果没有 package.json 文件，或者 main 入口不存在或无法解析，则 Node.js 将会试图加载目录下的 index.js 文件。
若失败则报错

Express →

# Node.js 基础

# 初识 Nodejs

# 什么是Node.js

# Node.js可以干什么

# Node.js的学习路径

# 安装Node.js

# 在Node.js 环境中执行JavaScript代码

# Buffer 缓冲区 [x]

# fs 文件系统模块

# 读取文件

# 简单文件读取

# 流式文件读取 [x]

# 写入文件

# 简单文件写入

# 流式文件写入 [x]

# 读写文件小案例

# 路径动态拼接问题 __dirname

# 其它操作 [x]

# path 路径模块

# 路径拼接 path.join()

# 获取路径中的文件名 path.basename()

# 获取路径中文件扩展名 path.extname()

# http 模块

# 服务器相关概念补充

# 创建基本 Web 服务器

# 实现简陋路由效果

# 模块化

# 模块化概念

# Node.js 中模块的分类

# Node.js 中的模块作用域

# 模块作用域的成员

# CommonJS 模块化规范

# npm - 包的概念

# 1. npm 安装包

# 2. 初次安装包后多了哪些文件

# 3. 包的语义化版本规范

# 4. 包管理配置文件 package.json

# 4.1. 快速创建 package.json npm init -y

# 4.2 devDependencies和dependencies节点

# 5.下载速度慢 用淘宝NPM镜像服务器

# 6. nrm 方便切换下包的镜像源

# 7. 包的分类 和 规范的包结构

# 7.1 包的分类

# 7.2 包的内部结构

# 8. 开发属于自己的包

# 模块加载机制

# 内置模块加载

# 自定义模块加载

# 第三方模块加载

# 目录作为模块加载

# 路径动态拼接问题 `__dirname`

# 路径拼接 `path.join()`

# 获取路径中的文件名 `path.basename()`

# 获取路径中文件扩展名 `path.extname()`

# 4. 包管理配置文件 `package.json`

# 4.1. 快速创建 package.json `npm init -y`

# 4.2 `devDependencies`和`dependencies`节点

# 5.下载速度慢用淘宝NPM镜像服务器

# 7. 包的分类和规范的包结构