Nodejs模块化、内置模块

偏执的太偏执、 2022-12-02 15:07 304阅读 0赞

# Ⅰ- 壹 - 开始学习Nodejs #

## 一 nodejs 怎么运行 js 文件 ##

1.  打开命令行, 输入 node 回车
    
    表示已经运行 node 这个 "软件"你就可以再命令行输入 js 代码来执行
    
    缺点: 代码留不下来
2.  打开命令行, 输入 node 你要执行的文件 回车
    
    把 js 代码写在一个 .js 后缀的文件里面
    
    通过命令行运行

## 二 模块化开发 ##

### 1 前端定义 ###

*  js 文件是引入再 html 文件中使用的
 *  多个 js 文件时引入再一个 html 文件中
 *  我们共享一个 window
 *  你需要再其他文件里面使用的方法
 *  你直接挂载再 window 上, 或者就直接写在全局

### 2 nodejs定义 ###

*  每一个 js 文件都是相对独立的
 *  我们只能靠模块化开发

## 三 Nodejs模块化分类 ##

### 1 什么是模块 ###

*  一个 js 文件就是一个模块
 *  我们把一类方法放在一个 js 文件里面, 这个 js 文件就变成了一个模块
 *  再需要哪一类方法的时候, 引入这个 js 文件就好了

### 2. 什么是模块化 ###

*  再开发的过程中, 尽可能把开发方式趋近于模块的方式
 *  把我们所有的内容都按照类别分好文件
 *  按需引入 可以使用\{ \}解构

### 3. 模块化的分类 ###

#### (1) 自定义模块 ####

*  我们自己按照模块化的语法, 开发的 js 文件
 *  自己定义模块, 自己再需要的时候导入模块使用
 *  自己决定模块内哪些内容向外暴露

**定义模块**

在每一个 js 文件里面,天生自带一个变量, 叫做 module, 表示模块,用来描述这个文件(模块)的

我们这个文件定义好以后, 你想让别人使用的东西, 就放在 module.exports 里面.再设计的时候, 给我们提供了两种其他方式

1.  给 module.exports 从新赋值,赋值为一个新的对象或者数组或者任何其他数据类型
2.  exports 也是每一个 js 文件天生自带的一个变量,每一个 js 文件里面相当于有一句代码 var exports = module.exports

注意: 如果你需要给 module.exports 从新赋值, 那么不能使用 exports

**使用模块**

就是把其他模块导入到自己的文件里面,使用另一个文件导出的内容,每一个 js 文件里面天生自带一个方法, 叫做 require()

`语法: require('要导入的 js 文件路径')`

如果后缀是 .js 可以省略不写,返回值: 被导入文件里面的 module.exports,导入以后, 你就可以使用 01 这个文件里面向外暴露的内容

#### (2) 内置模块 ####

*  node 这个环境天生自带的一些模块(“一个一个的 js 文件”)
 *  你需要使用的时候, 直接引入使用就好了

重点详解

#### (3) 第三方模块 ####

在 [npmjs.com官网][npmjs.com]上，我们可以下载别人已经封装好的模块到自己的项目中使用，这些模块都是第三方模块

例如 jquer 安装的时候会根据后缀安装 -g全局安装会安装在本地 不填写默认安装在本项目的node\_modules（没有的话会自动创建）文件目录下

*  在你需要的位置导入\*\*直接 require(包名)\*\*不需要 .js 后缀
 *  第三方包的使用么有规则

# Ⅱ - 贰 - Nodejs内置模块 #

常用的内置模块

<table> 
 <thead> 
  <tr> 
   <th>内置模块名称</th> 
   <th>简介</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>url</td> 
   <td>用于处理与解析 URL</td> 
  </tr> 
  <tr> 
   <td>querystring</td> 
   <td>用于解析和格式化 URL 查询字符串；</td> 
  </tr> 
  <tr> 
   <td>http</td> 
   <td>HTTP服务；</td> 
  </tr> 
  <tr> 
   <td>path</td> 
   <td>路径，用于处理文件路径和目录路径；</td> 
  </tr> 
  <tr> 
   <td>fs</td> 
   <td>文件系统，用于文件的读写操作；</td> 
  </tr> 
  <tr> 
   <td>events</td> 
   <td>事件触发器，用于事件的派发与监听；</td> 
  </tr> 
 </tbody> 
</table>

## 一 fs模块 ##

*  fs 模块 - file system 文件系统模块
 *  这个模块里面封装的方法都是和操作 文件 和 文件夹 相关的内容\*
 *  node 天生自带的一个模块，我们直接导入使用

<table> 
 <thead> 
  <tr> 
   <th>fs方法</th> 
   <th>简介</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><em>readFile()</em></td> 
   <td><em>异步读取文件</em></td> 
  </tr> 
  <tr> 
   <td><em>readFileSync()</em></td> 
   <td><em>同步读取文件</em></td> 
  </tr> 
  <tr> 
   <td><em>writeFile()</em></td> 
   <td><em>异步写入文件</em></td> 
  </tr> 
  <tr> 
   <td><em>appendFile()</em></td> 
   <td><em>异步追加内容</em></td> 
  </tr> 
  <tr> 
   <td><em>appendFileSync()</em></td> 
   <td><em>同步追加内容</em></td> 
  </tr> 
  <tr> 
   <td><em>readdir()</em></td> 
   <td><em>异步读取文件夹</em></td> 
  </tr> 
  <tr> 
   <td><em>readdirSync()</em></td> 
   <td><em>同步读取文件夹</em></td> 
  </tr> 
  <tr> 
   <td><em>mkdir()</em></td> 
   <td><em>异步创建文件夹</em></td> 
  </tr> 
  <tr> 
   <td><em>mkdirSync()</em></td> 
   <td><em>同步创建文件夹</em></td> 
  </tr> 
  <tr> 
   <td><em>rmdir()</em></td> 
   <td><em>异步删除文件夹</em></td> 
  </tr> 
  <tr> 
   <td><em>rmdirSync()</em></td> 
   <td><em>同步删除文件夹</em></td> 
  </tr> 
  <tr> 
   <td><em>unlink()</em></td> 
   <td><em>异步删除文件</em></td> 
  </tr> 
  <tr> 
   <td><em>unlinSync()</em></td> 
   <td><em>同步删除文件</em></td> 
  </tr> 
  <tr> 
   <td><em>stat()</em></td> 
   <td><em>异步查看</em></td> 
  </tr> 
  <tr> 
   <td><em>statSync()</em></td> 
   <td><em>同步查看</em></td> 
  </tr> 
  <tr> 
   <td><em>isFile()</em></td> 
   <td><em>注意: 只有 stats 可以调用</em></td> 
  </tr> 
  <tr> 
   <td><em>isDirectory()</em></td> 
   <td><em>注意: 只有 stats 可以调用</em></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

### 1 文件的读写 ###

分为同步读写和异步读写，方法都会有三个参数第二个为选填

#### （1）同步读写 ####

*readFileSync()*、*writeFileSync()*

\*readFileSync()\*同步读取文件

*  语法: fs.readFileSync(路径, 读取格式)\*
 *  返回值: 读取的文件内容\*
 *  注意: 读取路径不存在, 或者没有权限的时候, 会报错, 打断程序的继续执行\*

//  导入 fs 模块
    const fs = require('fs')
    const res = fs.readFileSync('./test1.txt', 'utf8')
    console.log('读取完成')
    console.log(res)

\*writeFileSync()*同步写入文件*

*  语法: fs.writeFileSync(路径, 要写入的内容)\*
 *  注意: 完全覆盖式的写入\*

//  导入 fs 模块
    const fs = require('fs')
    fs.writeFileSync('./test.js', 'hello node')
    console.log('写入完成')

#### （2）异步读写 ####

*readFile()*、 *writeFile()*

\*readFile()*异步读取文件*

*  语法: fs.readFile(路径, 读取格式, 回调函数)\*
 *  路径: 你要读取的文件的路径, 如果路径不存在, 会出现错误\*
 *  读取格式: 选填, 默认是 buffer, 我们可以选填 ‘utf8’\*
 *  回调函数: 读取成功以后会执行的函数\*

//  导入 fs 模块
    const fs = require('fs')
    fs.readFile('./test.txt', 'utf8', function (err, data) {
      // err 就是读取失败的时候的错误信息
      // data 就是读取成功的时候的读取内容
      if (err) return console.log(err)
    
      console.log('读取成功')
      console.log(data)
    })

\*writeFile()*异步写入文件*

*  语法: fs.writeFile(路径, 要写入的内容, 回调函数)\*
 *  路径: 你要写入文件的路径, 如果路径文件不存在, 会创建一个这个文件再写入\*
 *  写入的内容: 你自己定义\*
 *  回调函数: 写入成功以后执行的函数, 必填\*
 *  注意: 完全覆盖式的写入\*

//  导入 fs 模块
    const fs = require('fs')
    
    fs.writeFile('./test.txt', '你好 世界', function () {
      console.log('写入完成')
    })

### 2 追加内容 ###

#### （1）appendFile() ####

*  异步追加内容\*
 *  语法: fs.appendFile(路径, 追加的内容, 回调函数)\*
 *  路径: 写入文件的路径, 没有该路径, 自己创建\*
 *  追加的内容\*
 *  回调函数: 必填\*

fs.appendFile('./test1.txt', 'hello world', () => {})

#### （2）appendFileSync() ####

*  同步追加内容\*
 *  语法: fs.appendFileSync(路径, 追加的内容)\*

fs.appendFileSync('./test1.txt', '你好 世界')

### 3 文件夹的读取创建删除 ###

#### （1） readdir() ####

*  异步读取文件夹\*
 *  语法: fs.readdir(路径, 回调函数)\*

fs.readdir('../02_自定义模块', (err, data) => {
      if (err) return console.log(err)
    
      console.log('读取文件夹成功')
      console.log(data)
    })

#### （2） readdirSync() ####

*  同步读取文件夹\*
 *  语法: fs.readdirSync(路径)\*

const res = fs.readdirSync('../02_自定义模块')
    console.log(res)

#### （3）mkdir() ####

*  异步创建文件夹\*
 *  语法: fs.mkdir(路径, 回调函数)\*

fs.mkdir('./a', (err) => {
      if (err) return console.log(err)
    
      console.log('创建文件夹成功')
    })

#### （4） mkdirSync() ####

*  同步创建文件夹\*
 *  语法: fs.mkdirSync(路径)\*

fs.mkdirSync('./b')

#### （5）rmdir() ####

*  异步删除文件夹\*
 *  语法: fs.rmdir(路径, 回调函数)\*

fs.rmdir('./a', err => {
      if (err) return console.log(err)
    })

#### （6） rmdirSync() ####

*  同步删除文件夹\*
 *  语法: fs.rmdirSync(路径)\*

fs.rmdirSync('./b')

### 4 文件的删除查看 ###

#### （1）unlink() ####

*  异步删除文件\*
 *  语法: fs.unlink(路径, 回调函数)\*

fs.unlink('./test1.txt', err => {
      if (err) return console.log(err)
    })

#### （2）unlinSync() ####

*  同步删除文件\*
 *  语法: fs.unlinkSync(路径)\*

fs.unlinkSync('./test123.txt')

#### （3）stat() ####

*  异步查看\*
 *  语法: fs.stat(路径, 回调函数)\*
 *  回调函数里面可以接收一个 data\*
 *  表示你查看的这个路径的内容\*

fs.stat('./test.txt', (err, data) => {
      if (err) return console.log(err)
    
      console.log(data)
      console.log(data.isFile())
      console.log(data.isDirectory())
    })

#### （4）statSync() ####

*  同步查看\*
 *  语法: fs.statSync(路径)\*
 *  返回值: 查看该路径的结果\*

const res = fs.statSync('../02_自定义模块')
    console.log(res)
    console.log(res.isFile())
    
    console.log(res.isDirectory())

#### （5）isFile() ####

*  注意: 只有 stats 可以调用\*
 *  stat 的 回调函数中的 data\*
 *  statSync 的返回值\*
 *  语法: stats.isFile()\*
 *  返回值: 一个布尔值\*

#### （6）isDirectory() ####

*  注意: 只有 stats 可以调用\*
 *  stat 的 回调函数中的 data\*
 *  statSync 的返回值\*
 *  语法: stats.isDirectory()\*
 *  返回值: 一个布尔值\*

## 二 path 模块 ##

*  node 自带的一个内置模块
 *  里面封装的都是一些操作路径的或者和路径相关的方法
 *  使用的时候直接导入就可以了*const* path = require(‘path’)

<table> 
 <thead> 
  <tr> 
   <th>path方法</th> 
   <th>简介</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><em>join()</em></td> 
   <td><em>拼接相对路径</em></td> 
  </tr> 
  <tr> 
   <td><em>resolve()</em></td> 
   <td><em>拼接绝对路径</em></td> 
  </tr> 
  <tr> 
   <td><em>extname()</em></td> 
   <td><em>获取文件后缀名</em></td> 
  </tr> 
  <tr> 
   <td><em>isAbsolute()</em></td> 
   <td><em>判断路径是不是绝对路径</em></td> 
  </tr> 
  <tr> 
   <td><em>parse()</em></td> 
   <td><em>解析路径信息</em></td> 
  </tr> 
 </tbody> 
</table>

### 1 join() ###

*  拼接相对路径\*
 *  语法: path.join(路径1, 路径2, 路径3, …)\*
 *  返回值: 拼接好的路径结果\*
 *  注意:\*
    
    拼接规则是后一个参数是前一个参数的子级\*
    
    除非你写 …

const path = require('path')
    const path1 = path.join('a', './b', '/c', 'd')
    console.log(path1)
    
    const path2 = path.join('a', './b', '/c', 'd', '../e')
    console.log(path2)

### 2 resolve() ###

*  拼接绝对路径
 *  语法: path.resolve(路径1, 路径2, 路径3, …)
 *  返回值: 拼接好的绝对路径
 *  注意:
    
    拼接规则是每一个参数都是相对独立的一个参数
    
    如果你写 /xx, 直接回到根目录
    
    xx 当前目录下
    
    ./xx 当前目录下
    
    …/xx 上一级目录
    
    /xx 根目录

const path1 = path.resolve('a', './b')
    console.log(path1)
    const path2 = path.resolve('a', './b', '/c')
    console.log(path2)

### 3 extname() ###

*  获取文件后缀名
 *  语法: path.extname(文件名)
 *  返回值: 该文件的后缀名

const ext = path.extname('abc.html')
    console.log(ext)

### 4 isAbsolute() ###

*  判断路径是不是绝对路径
 *  语法: path.isAbsolute(路径)
 *  返回值: 一个布尔值
 *  路径区分:
    
    绝对路径: 从根目录开始的路径
    
    相对路径: 不是从根目录开始的路径

const res = path.isAbsolute('/a/b')
    console.log(res)

### 5 parse() ###

*  解析路径信息
 *  语法: path.parse(路径)
 *  返回值: 一个对象, 里面包含该路径的所有信息

const res = path.parse(__filename)
    console.log(res)
    
    /*
      {
        root: 'E:\\',
        dir: 'E:\\BK_9\\01_qwe\\01_DAY',
        base: '02_path模块.js',
        ext: '.js',
        name: '02_path模块'
      }
    */

## 三 url 内置模块 ##

*  node 自带的一个内置模块
 *  里面封装的都是和 url 地址栏相关的方法
 *  使用的时候直接导入使用

### 1 parse() ###

*  解析 url 地址的方法
 *  语法: url.parse(url 地址, 是否解析查询字符串)
    
    地址: 要解析的地址，是否解析查询字符串: 默认是 false, 选填 true会把地址里面的查询字符串解析成一个对象的形式
 *  返回值: 是一个对象, 里面包含整个 url 地址的所有信息

const url = require('url')
    const res = url.parse('http://www.guoxiang.com:8080/a/b/c/hello.html?a=100&b=200#abc', true)
    console.log(res)
    /*
      {
        protocol: 'http:',
        slashes: true,
        auth: null,
        host: 'www.guoxiang.com:8080',
        port: '8080',
        hostname: 'www.guoxiang.com',
        hash: '#abc',
        search: '?a=100&b=200',
        query: 'a=100&b=200',
        pathname: '/a/b/c/hello.html',
        // 路径标识符, 前后端配套的一个标识符(暗号)
        path: '/a/b/c/hello.html?a=100&b=200',
        href: 'http://www.guoxiang.com:8080/a/b/c/hello.html?a=100&b=200#abc'
      }
    */
    // post 请求是在请求体携带参数
      a=100&b=200&c=300
    const str = 'a=100&b=200&c=300'
    const res = url.parse('?' + str, true)
    console.log(res)

## 四 http 模块 ##

*  也是 node 内置的一个 模块
 *  主要是用来创建一个 http 服务的模块
 *  需要使用的时候直接导入使用

### 1 createServer() ###

*  创建服务的方法
 *  语法: http.createServer(function () \{\})
    
     每一个请求进来的时候, 都会触发函数
 *  返回值: 一个服务

// 1. createServer()
    const http = require('http')
    const fs = require('fs')
    const server = http.createServer(function (req, res) {
      // 这个函数接收两个参数
      // req: request 本次请求的所有信息
      //     req. 里面有一个信息叫做 url 就是路径信息
      // res: response 本次的响应对象
      //     res 里面有一个方法叫做 end()
      //     专门给前端返回信息的方法
      // console.log('有请求进来了')
    
      // console.log(req.url)
      if (req.url === '/abc') {
        // 读取 index.html
        fs.readFile('./index.html', (err, data) => {
          if (err) return console.log(err)
    
          // 把 data 返回给前端
          res.end(data)
        })
      }
    
    
    
    })
    
    // 2. 监听端口号
    server.listen(8080, () => {
      console.log('running at port 8080! ^_^ ')
    })

### 2 listen() ###

*  注意: 需要使用 服务(createServer 的返回值) 来调用
 *  语法: 服务.listen(端口号, 回调函数)
    
    端口号: 0 ~ 65535, 尽量不使用 1024 以下
    
    域名: 默认是本机 localhost || 127.0.0.1
 *  当 listen 执行以后
    
    你的 命令行, 就会被变成了一个服务器
    
    一个什么都没有的服务器
    
    当你访问 localhost:8080 的时候, createServer 后面的函数就会执行

# 0 - 0 - 知识点： #

## 一 *每一个 js 文件里面自带两个变量* ##

*1. \_\_dirname: 表示该文件所在的文件夹的绝对路径*

*2. \_\_filename: 表示该文件的绝对路径*

[npmjs.com]: https://www.npmjs.com/package/package