Node.js学习笔记(四) fs、os、path模块

这篇文章我们将会学习 Node 中的一些内置模块，分别是 fs、os、path

1、fs 模块

fs 模块提供类似 UNIX 标准的 文件操作 API，其中所有的方法均有 异步 和 同步 版本

在一般情况下，异步方法性能更高，所以下面只会介绍常用的异步方法

（1）通用操作

① 获取信息：stat(path, callback)

• path：路径
• callback：回调函数，接收两个参数，分别是 Error 对象和 fs.stats 对象，stats 对象的常用方法如下：
  • isFile()：如果是文件返回 true，否则返回 false
  • isDirectory()：如果是目录返回 true，否则返回 false
  • isBlockDevice()：如果是块设备返回 true，否则返回 false
  • isCharacterDevice()：如果是字符设备返回 true，否则返回 false
  • isSymbolicLink()：如果是软链接返回 true，否则返回 false
  • isFIFO()：如果是 FIFO 返回true，否则返回 false
  • isSocket()：如果是 Socket 返回 true，否则返回 false

const fs = require('fs')
fs.stat('input.txt', function (err, stats) {
	if (err) {
        return console.error(err)
    }
    // 检测文件类型
    console.log(stats.isFile())
    console.log(stats.isDirectory())
})

（2）文件操作

① 打开文件：open(path, flags[, mode], callback)

• path：文件路径
• flags：文件打开方式，它的取值如下：
  • r：以读取模式打开文件，如果文件不存在则抛出异常
  • r+：以读写模式打开文件，如果文件不存在则抛出异常
  • rs：以同步的方式读取文件
  • rs+：以同步的方式读取和写入文件
  • w：以写入模式打开文件，如果文件不存在则创建文件
  • wx：类似于 w，但是如果文件存在，那么文件写入失败
  • w+：以读写模式打开文件，如果文件不存在则创建文件
  • wx+：类似 w+，但是如果文件存在，那么文件读写失败
  • a：以追加模式打开文件，如果文件不存在则创建文件
  • ax：类似 a， 但是如果文件存在，那么文件追加失败
  • a+：以读取追加模式打开文件，如果文件不存在则创建文件
  • ax+：类似 a+，但是如果文件存在，那么文件读取追加失败
• mode：文件权限，创建文件的默认权限为 0666
• callback：回调函数，接收两个参数，分别是错误信息和文件描述符

② 关闭文件：close(fd, callback)

• fd：文件描述符
• callback：回调函数，没有参数

const fs = require('fs')
// 打开文件
fs.open('file.txt', 'r+', function(err, fd) {
    if (err) {
    	return console.error(err)
    }
    console.log('文件打开成功')
    // 关闭文件
    fs.close(fd, function(err) {
        if (err) {
        	console.error(err)
        } 
        console.log('文件关闭成功')
    })
})

③ 写入文件：writeFile(file, data[, options], callback)

• file：文件路径或文件描述符
• data：要写入文件的数据，可以是 String 或 Buffer 对象
• options：配置对象，包含三个属性，分别如下：
  • encoding：文件编码，默认为 utf8
  • mode：文件权限，默认为 0666
  • flag：文件打开方式，默认为 w
• callback：回调函数，接收一个参数，就是错误信息

const fs = require('fs')
var data = 'Hello World'
// 写入文件
fs.writeFile('file.txt', data, function(err) {
    if (err) {
  		return console.error(err)
    }
    console.log('文件写入成功')
})

④ 读取文件：read(fd, buffer, offset, length, position, callback)

• fd：文件描述符
• buffer：数据写入的缓冲区
• offset：缓冲区的写入偏移量
• length：文件读取的字节数
• position：文件读取的起始位置，如果为 null，则会从当前文件指针的位置读取
• callback：回调函数，接收三个参数，分别是错误信息、读取字节数和缓冲区对象

const fs = require('fs')
var buf = new Buffer.alloc(1024)
// 打开文件
fs.open('file.txt', 'r+', function(err, fd) {
    if (err) {
        return console.error(err)
    }
    // 读取文件
    fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
        if (err) {
        	console.error(err)
        }
        if (bytes > 0) {
            var data = buf.slice(0, bytes).toString()
        	console.log(data)
        }
    })
})

⑤ 截取文件：ftruncate(fd, len, callback)

• fd：文件描述符
• len：截取长度
• callback：回调函数，没有参数

const fs = require('fs')
var buf = new Buffer.alloc(1024)
// 打开文件
fs.open('file.txt', 'r+', function(err, fd) {
    if (err) {
    	return console.error(err);
    }
    // 截取文件
    fs.ftruncate(fd, 10, function(err) {
        if (err){
        	console.error(err)
        }
        console.log('文件截取成功')
    })
})

⑥ 删除文件：unlink(path, callback)

• path：文件路径
• callback：回调函数，没有参数

（3）目录操作

① 创建目录：mkdir(path[, options], callback)

• path：文件路径
• options：配置信息，它的取值如下：
  • recursive：是否以递归的方式创建目录，默认为 false
  • mode：目录权限，默认为 0777
• callback：回调函数，没有参数

② 删除目录：rmdir(path, callback)

• path：文件路径
• callback：回调函数，没有参数

③ 读取目录：readdir(path, callback)

• path：文件路径
• callback：回调函数，接收两个参数，分别是错误信息和目录下的文件数组

const fs = require('fs')
// 读取目录
fs.readdir('./', function(err, files) {
    if (err) {
    	return console.error(err);
    }
    files.forEach(function (file) {
    	console.log(file)
    })
})

（4）管道 Stream

Stream 是一个 抽象接口，Node 中很多对象都实现了这个接口

① 管道类型

Stream 对象共有四种类型，分别如下：

• Readable：可读
• Writable：可写
• Duplex：可读可写
• Transform：操作被写入数据，然后读出结果

② 管道事件

所有的 Stream 对象都是 EventEmitter 的实例，常用的绑定事件如下：

• data：当有数据可读时触发
• end：当没有数据可读时触发
• finish：当所有数据都被写入时触发
• error：在接收和写入过程中发生错误时触发

③ 读取 Stream

const fs = require('fs')
var data = ''
// 创建可读流
var readerStream = fs.createReadStream('input.txt')
// 设置编码
readerStream.setEncoding('UTF8')
// 处理流事件（data、end、error）
readerStream.on('data', function(chunk) {
   data += chunk
})
readerStream.on('end', function() {
   console.log(data)
})
readerStream.on('error', function(err) {
   console.log(err.stack)
})

④ 写入 Stream

const fs = require('fs')
var data = 'Hello World'
// 创建可写流
var writerStream = fs.createWriteStream('output.txt')
// 写入数据
writerStream.write(data, 'UTF8')
// 标记文件末尾
writerStream.end()
// 处理流事件（finish、error）
writerStream.on('finish', function() {
    console.log('Finished')
})
writerStream.on('error', function(err){
   console.log(err.stack)
})

⑤ 管道流

管道流用于从一个流传递数据到另一个流

const fs = require('fs')
// 创建可读流
var readerStream = fs.createReadStream('input.txt')
// 创建可写流
var writerStream = fs.createWriteStream('output.txt')
// 读取 input.txt 文件内容，并将内容写入 output.txt 文件
readerStream.pipe(writerStream)

⑥ 链式流

链式流一般用于管道，可以理解成多个管道相连

const fs = require('fs')
const zlib = require('zlib')
// 压缩 input.txt 文件为 input.txt.gz
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'))
// 解压 input.txt.gz 文件为 input.txt
fs.createReadStream('input.txt.gz')
  .pipe(zlib.createGunzip())
  .pipe(fs.createWriteStream('input.txt'))

2、os 模块

os 模块提供 基本的系统操作函数，常用的属性和方法如下：

• type()：返回操作系统名
• platform()：返回编译时的操作系统名
• hostname()：返回操作系统主机名
• cpus()：返回一个对象数组，包含每个 CPU 的信息
• arch()：返回 CPU 架构，可能是 x64、arm 或 ia32
• endianness()：返回 CPU 字节序，可能是 BE 或 LE
• totalmem()：返回操作系统总内存量，单位为字节
• freemem()：返回操作系统空闲内存量，单位为字节
• networkInterfaces()：返回网络接口列表

const os = require('os')

console.log(os.type())
console.log(os.platform())
console.log(os.hostname())
console.log(os.cpus())
console.log(os.arch())
console.log(os.endianness())
console.log(os.totalmem())
console.log(os.freemem())
console.log(os.networkInterfaces())

详细内容请看官方文档：https://nodejs.org/api/os.html

3、path 模块

path 模块提供 处理文件路径的工具，常用的属性和方法如下：

• sep：平台的文件路径分隔符，可以是 \ 或 /
• delimiter：平台的分隔符，可以是 ; 或 :
• posix：以 posix 兼容的方式提供 path 方法
• win32：以 win32 兼容的方式提供 path 方法
• normalize(path)：规范化路径
• dirname(path)：返回路径中的文件夹名称
• basename(path)：返回路径中的文件名称
• extname(path)：返回路径中的文件后缀名
• parse(pathString)：从字符串中返回路径对象
• format(pathObject)：从对象中返回路径字符串
• isAbsolute(path)：判断是否为绝对路径
• relative(from, to)：基于 from 将 to 从绝对路径转换为相对路径
• path.join([path1],[path2] ... [pathN])：连接路径

const path = require('path')
const home = 'D:\Blog\source\_posts'

console.log(path.sep)
console.log(path.delimiter)
console.log(path.posix)
console.log(path.win32)

console.log(path.dirname(home))
console.log(path.basename(home))
console.log(path.extname(home))

console.log(path.isAbsolute(home))
console.log(path.relative('D:\Blog\public', home))

console.log(path.join(home, 'Node.js学习笔记(四) fs、os、path模块'))

详细内容请看官方文档：https://nodejs.org/api/path.html

【 阅读更多 Node.js 系列文章，请看 Node.js学习笔记 】