NodeJS——API使用之fs文件系统模块(1)文件读写

一、基本介绍

Node中通过fs（file system）模块来操作文件，所以想要使用系统。必须先引入fs模块。 fs模块属于node的核心模块，不用下载，直接引入即可。
fs模块中的所有方法都有两个版本：

• 一个是不带sync的，异步版本
• 一个是带sync的，同步版本

二、文件的读写

1、打开文件

1)同步打开

var fd = fs.openSync(path, flags[, mode])

参数说明：
path：要打开的文件路径,如果没有path可以对应的文件则默认创建一个
flags：对文件做操作的类型
返回值fd：返回一个表示文件的整数描述符
2)异步打开

fs.open(path, flags[, mode], callback)

参数说明：
path：要打开的文件路径,如果没有path可以对应的文件则默认创建一个
flags：对文件做操作的类型
callback：callback有两个参数，callback(err,fd)。
Node绝大多数的回调都是error first（错误优先）。
3) flags

标志	说明
r	以读取模式打开文件。如果文件不存在则发生异常。
r+	以读写模式打开文件。如果文件不存在则发生异常。
rs+	以同步读写模式打开文件。命令操作系统绕过本地文件系统缓存。
w	以写入模式打开文件，文件会被创建（如果文件不存在）或截断（如果文件存在）
w+	以读写模式打开文件。文件会被创建（如果文件不存在）或截断（如果文件存在）
wx	类似 ‘w’，但如果 path 存在，则失败。
wx+	类似 ‘w+’，但如果 path 存在，则失败。
a	以追加模式打开文件。如果文件不存在，则会被创建。
a+	以读取和追加模式打开文件。如果文件不存在，则会被创建。
ax	类似于 ‘a’，但如果 path 存在，则失败
ax+	类似于 ‘a+’，但如果 path 存在，则失败。

2、读取文件

1)同步文件读取

var  bytesRead = fs.readSync(fd, buffer, offset, length, position)

参数说明：

    fd：要读取的文件描述符
    buffer：将读取的内容写入到的buffer
    offset：写入buffer时的偏移量
    length：一次性读取的字节数
    position：读取的位置
    bytesRead：读到了几个字节

2) 异步文件读取

fs.read(fd, buffer, offset, length, position, callback)
    callback(err,bytesRead,buffer)

3) 简单文件读取

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

参数说明：
path：文件名或文件描述符。如果 path 是一个文件描述符，则它不会被自动关闭。
options ：

encoding  默认为 null。
flag 默认为 'r'。
如果 options 是一个字符串，则它指定了字符编码。

callback

err data <string> | <Buffer>
回调有两个参数 (err, data)，其中 data 是文件的内容。
如果未指定字符编码，则返回原始的 buffer。

fs.readFile() 函数会缓存整个文件。 为了最小化内存占用，尽可能优先使用 fs.createReadStream()流式文件读取。

3、写入文件

1）同步文件写入

fs.writeSync(fd, buffer[, offset[, length[, position]]])
fs.writeSync(fd, string[, position[, encoding]])

2） 异步文件写入

fs.write(fd, buffer[, offset[, length[, position]]],callback)
fs.write(fd, string[, position[, encoding]], callback)
    callback (err, bytesWritten, buffer/ string)

3） 简单文件写入

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

参数说明：
    file 要写入的文件的路径或文件描述符
        如果 file 是一个文件描述符，则它不会被自动关闭。
    data 要写入的内容，可以是一个String也可以是一个Buffer
    options 配置对象，需要一个对象作为参数，默认如下
            {encoding:"utf8",flag:"w"}
    callback 回调函数
        error

对同一文件多次使用 fs.writeFile 且不等待回调，是不安全的。 对于这种情况，建议使用 fs.createWriteStream。

4、关闭文件

1）同步关闭

fs.closeSync(fd)

fd：文件描述符
返回：undefined

2）异步关闭

fs.close(fd, callback)

fd：文件描述符
callback：回调

5、Promise异步处理读写

util.promisify(original)

让一个遵循异常优先的回调风格的函数， 即 (err, value) => … 回调函数是最后一个参数, 返回一个返回值是一个 promise 版本的函数。

三、代码案例

01_文件同步读写.js

const fs = require("fs")
//打开文件
const fd = fs.openSync("./fs.txt","r")
const  buf = Buffer.alloc(10)
//数据读取
fs.readdirSync(fd,buf,0,10,0)
//文件关闭
fs.close(fd)

02_文件异步读写(原生回调地狱).js

/*
    1.打开文件
    2.读取文件
    3.写入文件
    4.关闭文件
*/
const fs = require("fs");
fs.open("./fs.txt","r",(err,fd)=>{
    if(!err){
        const buf = Buffer.alloc(10);
        fs.read(fd,buf,0,10,0,(err,bytesRead,buf)=>{
            fs.close(fd,(err)=>{
                if(!err){
                    fs.open("./fs2.txt","w",(err,fd)=>{
                        if(!err){
                            fs.write(fd,buf,0,10,0,(err,bytesWritten,buf)=>{
                                 fs.close(fd,()=>{
                                    console.log("读写完成")
                                })
                            })
                        }
                    })
                }
            })
        })
    }
})

03_文件异步读写(Promise).js

const {open, read, write, close} = require("fs")
const promisify = require("util").promisify
const openPromise = promisify(open)
const readPromise = promisify(read)
const writePromise = promisify(write)
const closePromise = promisify(close)

async function RWFilePromise() {
    const fd = await openPromise("./fsS.txt", "r")
    const buf = Buffer.alloc(20)
    const a = await readPromise(fd, buf, 0, 20, 0)
    console.log(a)
    const err = await closePromise(fd)
    console.log(err)
    const fdw = await openPromise("./fscopy.txt", "w")
    const b = await  writePromise(fdw, buf, 0, 20, 0)
    console.log(b)
    const err1 = await closePromise(fdw)
    console.log(err1)
    if (!err1) {
        console.log("写入成功")
    }
}

RWFilePromise()

04_简单文件读写.js

const {readFile,writeFile} = require("fs")
const promisify = require("util").promisify
const readPromise = promisify(readFile)
const writePromise = promisify(writeFile)


readFile("./fs.txt",{flag:"r"},(err,data)=>{
    writeFile("./fscopy.txt",data,{flag:"w"},(err)=>{
        if (!err){
            console.log("写入成功")
        }
    })
})

async  function RW() {
 const  data=   await  readPromise("./fsS.txt",{flag:"r"})
                await  writePromise("./fscopy.txt",data,{flag:"w"})
}

RW()

四、总结：
文件操作流程如下：
打开file ——》写文件 ——》 文件关闭
打开file ——》 读文件 ——》 文件关闭