node.js核心模块

double丶dragon

已于 2023-04-03 10:24:01 修改

阅读量230

点赞数

分类专栏： node 文章标签： node.js javascript 前端

于 2023-03-31 16:57:44 首次发布

本文链接：https://blog.csdn.net/qq_60749459/article/details/129798398

版权

node 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

node.js模块

全局对象

window 是浏览器的宿主对象，node中是没有的，global是node中的全局对象，作用类似于window，ES标准下，全局对象的标准名应该是 globalThis，globalThis在浏览器和node中都可以使用。

核心模块

核心模块，是node中自带的模块，可以在node中直接使用

1.process

表示当前的node进程
通过该对象可以获取进程的信息，或者对进程做各种操作
如何使用:
process是一个全局变量，可以直接使用
有哪些属性和方法：
process.exit( ) 结束当前进程，终止node
process.nextTick(callback[, …args]) 将函数插入到 tick队列中， tick队列中的代码会在同步代码之后，微任务队列之前执行。

console.log(1)
process.exit()
console.log(2)
//2不会被打印出来，node进程被终止了

2.path

表示路径:

通过path可以用来获取各种路径
要使用path，需要先对其进行引入
path.resolve()
用来生成一个绝对路径，如果直接调用resolve，则返回当前的工作目录，如果将一个相对路径作为参数，则resolve会自动将其转换为绝对路径，此时根据工作目录的不同，它所产生的绝对路径也不同；它一般会传入两个参数，第一个是绝对路径，如动态的绝对路径__dirname，第二个是相对路径，它会自动计算出最终的路径。

const path = require("node:path")// node:可加可不加，加了速度快
const a = path.resolve()
const a1 = path.resolve(__dirname)
const a2 = path.resolve(__dirname,'./hello.js')
const a3 = path.resolve(__dirname,'../hello.js')
const a4 = path.resolve('D:\\practice\\vue-study\\hello','./hello.js')
console.log(a); // D:\practice\vue-study\html
console.log(a1); // D:\practice\vue-study\html\commonJs
console.log(a2); // D:\practice\vue-study\html\commonJs\hello.js
console.log(a3); // D:\practice\vue-study\html\hello.js
console.log(a4); // D:\practice\vue-study\hello\hello.js

path.join()
路径拼接，可以把多个路径片段拼接为一个完整的路径字符串，参数可以传多个，用逗号隔开，但是只能传入字符串，其他会报错。

const path = require("node:path")// node:可加可不加，加了速度快
const a = path.join('b', 'c','d')
const a1 = path.join(__dirname,'b', 'c', 'd')
console.log(a);// b\c\d
console.log(a1);// D:\practice\vue-study\html\commonJs\b\c\d

path.basename()
获取路径中的文件名并返回，有两个参数，第一个为必传的路径，第二个是可选的拓展名，如果传了第二个参数，那么返回的文件名就没有后缀。
path.extname()
返回文件后缀，传入一个路径参数

const path = require("node:path")
const a = path.basename('D:\\practice\\vue-study\\html\\hello.js')
const a2 = path.basename('D:\\practice\\vue-study\\html\\hello.js','.js')
const a3 = path.basename(path.resolve(__dirname,'./sb.js'),'.js')
console.log(a); // hello.js
console.log(a2); // hello
console.log(a3); // sb
const b = path.extname('index.html')
console.log(b); //.html

3.fs（File System）

fs用来操作磁盘中的文件
文件操作也就是所谓的I/O，input output
使用fs模块，同样需要引入

一些方法：
fs.readFile()读取文件(异步方式)
fs.readFileSync()同步的读取文件的方法，会阻塞后边代码的执行
fs.appendFile()创建新文件，或将数据添加到已有文件中
fs.mkdir()创建目录
fs.rmdir()删除目录
fs.rm()删除文件
fs.rename()重命名
fs.copyFile()复制文件

读取文件

fs.readFileSync()是同步读取文件，会阻塞后面代码执行，只需要传入一个参数，也就是文件所在路径。它会返回一个Buffer对象，Buffer是一个临时用来存储数据的缓冲区。一般情况下利用toString()方法就可以看到文件的内容。
fs.readFile()是异步读取文件，需要传入两个参数，路径和回调函数，回调函数用来处理数据和错误。代码如下：

const fs = require('node:fs')
const path = require('node:path')
// 同步读文件
const a = fs.readFileSync(path.resolve(__dirname, "./hello.txt"))
console.log(a);
/* 
Buffer(12) [228, 187, 138, 229, 164, 169, 228, 189, 160, 229,
165, 189, buffer: ArrayBuffer(8192), byteLength: 12, byteOffset: 2712, length: 12]
*/

// 异步读文件
fs.readFile(
  path.resolve(__dirname, "./hello.txt"),
  (err, buffer) => {
    if (err) {
      console.log("出错了~")
    } else {
      console.log(buffer.toString())
    }
  }
)

当然，异步问题可以用promise来解决，或者async…await，用promise的时候引入方式也会变化。代码如下：

// promise
const path = require('node:path')
//注意fs模块的promise引入
const fs = require('node:fs/promises')
fs.readFile(path.resolve(__dirname, "./hello.txt")).then(buffer => {
  console.log(buffer.toString())
}).catch(e => {
  console.log("出错了~")
})

// async...await
// 用立即执行函数，await后面进行方法调用
;(async () => {
  try {
    const buffer = await fs.readFile(path.resolve(__dirname, "./hello.txt"))
    console.log(buffer.toString())
  } catch (e) {
    console.log("出错了~~")
  }
})()

创建文件

fs.mkdir()用来创建目录，有两个参数，第一个是目录所在路径，第二个是非必传参数{ recursive: true }对象，仅仅在需要创建多层目录的时候传入。
fs.appendFile()用来创建文件，需要传入两个参数，第一个是文件所在路径，第二个是文件的数据。

const path = require('node:path')
const fs = require('node:fs/promises')
// 不创建有层级的目录时，只需要传一个路径参数
fs.mkdir(path.resolve(__dirname, './m2')).then(() => { })
// 创建有多层的目录时，需要传入一个对象{ recursive: true }
fs.mkdir(path.resolve(__dirname, "./hello/abc"), { recursive: true })
.then(r => {
  console.log("操作成功~")
})
.catch(err => {
  console.log("创建失败", err)
})

const path = require('node:path')
const fs = require('node:fs/promises')
fs.appendFile(
  path.resolve(__dirname, "./hello.txt"),
  "超哥讲的真不错",
).then(r => {
  console.log("添加成功")
})

删除文件

fs.rmdir()删除目录，传入一个路径参数，到具体目录，目录底下不能有其他目录或文件，否则会报错。
fs.rm()删除文件，有两个参数，当只传入第一个路径参数时，只能删除具体路径的文件；当传入{ recursive: true }时，路径上的文件及其子文件都会被删除(包括目录)。

const path = require('node:path')
const fs = require('node:fs/promises')
fs.rmdir(path.resolve(__dirname, "./hello/abc")).then(() => {
  console.log('删除成功~');
})
// hello文件夹及其里面的任何文件都会被删掉
fs.rm(path.resolve(__dirname, "./hello"),{ recursive: true }).then(() => {
  console.log('删除成功~');
})

重命名（剪切）

fs.rename()重命名文件，也可以挪动文件位置，传入两个路径参数，第一个路径是原本文件的路径，第二个路径是重命名后的，也就是说，路径不仅可以重命名，也能挪动文件到别的位置。

const path = require('node:path')
const fs = require('node:fs/promises')
// 把上级文件夹的图片，改名并且挪到同级
fs.rename(
  path.resolve(__dirname, "../an.jpg"),
  path.resolve(__dirname, "./an2.jpg")
).then(r => {
  console.log("重命名成功")
})

复制文件

fs.copyFile()传入两个参数，第一个是要复制的文件地址，第二个是要复制到哪里的地址。

const path = require('node:path')
const fs = require('node:fs/promises')
fs.copyFile(
  path.resolve(__dirname, './m/hello.txt'),
  path.resolve(__dirname, './hello.txt')
).then(() => {
    console.log('复制成功')
  })

4.http

用于创建服务和开启服务，使用的时候要先引入

// 1.导入 http 模块
const http = require('http');
// 2.创建服务对象
// 传入两个参数，第一个是请求报文对象，第二个是响应报文对象
const server = http.createServer((request, response) => {
  // 获取请求方法
  console.log(request.method); 
  // 获取请求的url,只包含路径和查询字符串
  console.log(request.url);
  // 获取http协议的版本号
  console.log(request.httpVersion);
  // 获取请求头,请求头是一个对象
  console.log(request.headers);

  // 获取请求体，一般是post请求
  let body = ''
  // 绑定data事件
  // chunk是个Buffer对象，需要转为字符串
  request.on('data', chunk => {
    body = chunk.toString()
  })
  // 绑定end事件，没有end事件是获取不到请求体的
  request.on('end', () => {
    console.log(body);
  })
  
  // 获取请求路径与查询字符串
  // 可以传入一个参数(完整的url)
  // let url = new URL('http://127.0.0.1:9000/search?a=100')
  // 也可以传入两个参数，如下：request.url相当于/search?a=100
  let url = new URL(request.url,'http://127.0.0.1:9000')
  // 这里的url是一个对象
  console.log(url);
  /*
  URL {
    href: 'http://127.0.0.1:9000/search?a=100&b=200',
    origin: 'http://127.0.0.1:9000',
    protocol: 'http:',
    username: '',
    password: '',
    host: '127.0.0.1:9000',
    hostname: '127.0.0.1',
    port: '9000',
    pathname: '/search',
    search: '?a=100&b=200',
    searchParams: URLSearchParams { 'a' => '100', 'b' => '200' },
    hash: ''
  }
  */
  // 获取查询字符串的值得用searchParams的get方法
  console.log(url.searchParams.get('a'));//100
  
  // 设置响应状态码
  response.statusCode = 203
  // 设置响应状态描述(很少用)
  response.statusMessage = 'iloveyou'
  // 设置响应头
  // 相同的头对应多个参数时，第二个参数用数组形式
  response.setHeader('content-type', 'text/html;charset=utf-8')
  //设置响应体
  // write方法可以调用多次，而end方法只能调用一次
  // write方法可以没有，end方法必须存在
  response.write('你好啊，http')
  response.end('Hello HTTP Server 你好')
}) 
// 3.监听端口，启动服务
server.listen(9000, () => {
  console.log('服务器启动了！'); // 回调函数在服务启动时执行
})