Node.js API详解之 fs

文件 I/O 是对标准 POSIX 函数的简单封装。 通过 require(‘fs’) 使用该模块。 所有的方法都有异步和同步的形式。
异步方法的最后一个参数都是一个回调函数。 传给回调函数的参数取决于具体方法,但回调函数的第一个参数都会保留给异常。
如果操作成功完成,则第一个参数会是 null 或 undefined。
当使用同步方法时,任何异常都会被立即抛出。 可以使用 try/catch 来处理异常,或让异常向上冒泡。
在繁忙的进程中,建议使用异步的方法。 同步的方法会阻塞整个进程,直到完成(停止所有连接)。
注意: 在 Windows 上,使用 w 选项(通过 fs.open 或 fs.writeFile) 打开已有隐藏文件将会失败,错误信息为 EPERM 。
已有隐藏文件可以通过 r+ 选项打开。调用 fs.ftruncate 可以用来重置文件内容。

目录:

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

说明:

该方法用来创建目录,与mkdir命令的作用一致。
path:目录地址
mode:目标属性,建立目录的同时设置目录的权限,默认:0o777
callback:创建完成后执行的回调函数,带有一个异常参数。

demo:

const fs = require('fs');

fs.mkdir('fsDemo', (err) => {
	console.log(err || '目录创建成功')
});
//目录创建成功

fs.mkdir('/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo', (err) => {
	console.log(err || '目录创建成功')
});
// { Error: EEXIST: file already exists, mkdir '/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo'
//   errno: -17,
//   code: 'EEXIST',
//   syscall: 'mkdir',
//   path: '/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo' }

fs.mkdirSync(path[, mode])

说明:

同步模式的mkdir
path:目录地址
mode:目标属性,建立目录的同时设置目录的权限,默认:0o777
返回 undefined

demo:

const fs = require('fs');

console.log(fs.mkdirSync('fsDemo'));
//undefined

console.log(fs.mkdirSync('/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo'));
// Error: EEXIST: file already exists, mkdir '/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo'

fs.mkdtemp(prefix[, options], callback)

说明:

创建一个唯一的临时目录
生成六位随机字符附加到一个要求的 prefix 后面,然后创建一个唯一的临时目录。
创建的目录路径会作为字符串传给回调的第二个参数
prefix:目录前缀
options.encoding: 默认’utf8′
callback:回调函数,参数err,folder

demo:

const fs = require('fs');

fs.mkdtemp('./fsDemo/temp-', (err, folder) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('临时目录创建完成:', folder);
	}
});
// 临时目录创建完成: ./fsDemo/temp-cDDfLY
// 临时目录创建完成: ./fsDemo/temp-bTdHU9

fs.mkdtempSync(prefix[, options])

说明:

fs.mkdtemp() 的同步版本。 返回创建的目录的路径。
prefix:目录前缀
options.encoding: 默认’utf8′

demo:

const fs = require('fs');

fs.mkdtemp('./fsDemo/temp-', (err, folder) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('临时目录创建完成:', folder);
	}
});

console.log( fs.mkdtempSync('./fsDemo/temp-') );
// ./fsDemo/temp-ww7zCT
// 临时目录创建完成: ./fsDemo/temp-EELMzK

fs.rmdir(path, callback)

说明:

该方法用来删除空目录,与rmdir命令的作用一致。
如果删除的目录不是空目录,会抛出错误。
path:目录地址
callback:完成后执行的回调函数,带有一个异常参数。
注意:在文件上调用此方法,会导致错误。

demo:

const fs = require('fs');

fs.rmdir('./fsDemo/temp-EELMzK', (err) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('目录已删除');
	}
});
//目录已删除

fs.rmdir('./fsDemo', (err) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('目录已删除');
	}
});
//{ Error: ENOTEMPTY: directory not empty, rmdir './fsDemo'
// errno: -66,
// code: 'ENOTEMPTY',
// syscall: 'rmdir',
// path: './fsDemo' }

fs.rmdirSync(path)

说明:

同步的 rmdir。返回 undefined。

demo:

const fs = require('fs');

console.log( fs.rmdirSync('./fsDemo/temp-ynCPcZ') );
// undefined

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

说明:

读取一个目录的内容。
path:目录地址
options.encoding: 默认 ‘utf8’
callback: 完成后的回调函数,回调有两个参数 (err, files),其中 files 是目录中不包括 ‘.’ 和 ‘..’ 的文件名的数组。

demo:

const fs = require('fs');

fs.readdir('./fsDemo/', (err, files) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('该目录下的内容:', files);
	}
});
// 该目录下的内容: [ 'stderr.log', 'temp-4bv2iz', 'temp-ww7zCT' ]

fs.readdirSync(path[, options])

说明:

同步的 readdir。返回一个不包括 ‘.’ 和 ‘..’ 的文件名的数组。

demo:

const fs = require('fs');

console.log( fs.readdirSync('./fsDemo/') );
// [ 'stderr.log', 'temp-4bv2iz', 'temp-ww7zCT' ]

fs.copyFile(src, dest[, flags], callback)

说明:

异步的将 src 拷贝到 dest。如果 dest 已经存在会被覆盖,不存在会被创建。
回调函数没有给出除了 err 以外的参数。Node.js 不能保证拷贝操作的原子性。如果目标文件打开后出现错误,Node.js 将尝试删除它。
flags 是一个可选的整数,用于指定行为的拷贝操作。
唯一支持的 flag 是 fs.constants.COPYFILE_EXCL ,如果 dest 已经存在,则会导致拷贝操作失败。

demo:

const fs = require('fs');

fs.copyFile('/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js', 
	'/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo/app.js', (err) => {
		if(err){ 
			console.log(err); 
		} else {
			console.log('复制成功');
		}
	});
//复制成功

fs.copyFileSync(src, dest[, flags])

说明:

同步的 copyFile。返回值是 undefined。

demo:

const fs = require('fs');

console.log( fs.copyFileSync('/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js', 
	'/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo/app.js') );
//undefined

fs.rename(oldPath, newPath, callback)

说明:

该方法对一个文件进行重命名以及对文件进行移动。

demo:

const fs = require('fs');

fs.rename('/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js', 
		'/Users/xiaoqiang/Documents/work/demo/NodeApi/app1.js', (err) => {
			if(err){ 
				console.log(err); 
			} else {
				console.log('重命名成功');
			}
		});
// 重命名成功,app.js 变为 app1.js


fs.rename('/Users/xiaoqiang/Documents/work/demo/NodeApi/app1.js', 
		'/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo/app.js', (err) => {
			if(err){ 
				console.log(err); 
			} else {
				console.log('移动文件成功');
			}
		});
// 重命名成功,app.js消失

fs.renameSync(oldPath, newPath)

说明:

同步的 rename。返回值是 undefined。

demo:

const fs = require('fs');

console.log( fs.renameSync('/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo/app.js', 
		'/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js') );
// undefined

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

说明:

异步地打开文件。
path:要打开的文件地址
mode:可设置文件模式(权限和 sticky 位),但只有当文件被创建时才有效。默认为 0o666,可读写。
callback: 该回调有两个参数 (err, fd)。
fd:file descriptor(文件描述符),用于后续的调用使用该文件。
flags 可以是以下值:
‘r’ – 以读取模式打开文件。如果文件不存在则发生异常。
‘r+’ – 以读写模式打开文件。如果文件不存在则发生异常。
‘rs+’ – 以同步读写模式打开文件。命令操作系统绕过本地文件系统缓存。
这对 NFS 挂载模式下打开文件很有用,因为它可以让你跳过潜在的旧本地缓存。 它对 I/O 的性能有明显的影响,所以除非需要,否则不要使用此标志。
注意,这不会使 fs.open() 进入同步阻塞调用。 如果那是你想要的,则应该使用 fs.openSync()。
‘w’ – 以写入模式打开文件。文件会被创建(如果文件不存在)或截断(如果文件存在)。
‘wx’ – 类似 ‘w’,但如果 path 存在,则失败。
‘w+’ – 以读写模式打开文件。文件会被创建(如果文件不存在)或截断(如果文件存在)。
‘wx+’ – 类似 ‘w+’,但如果 path 存在,则失败。
‘a’ – 以追加模式打开文件。如果文件不存在,则会被创建。
‘ax’ – 类似于 ‘a’,但如果 path 存在,则失败。
‘a+’ – 以读取和追加模式打开文件。如果文件不存在,则会被创建。
‘ax+’ – 类似于 ‘a+’,但如果 path 存在,则失败。
常用的常量可从 fs.constants 获取。
fs.open() 某些标志的行为是与平台相关的。 因此,在 macOS 和 Linux 下用 ‘a+’ 标志打开一个目录,会返回一个错误。

demo:

const fs = require('fs');

fs.open('./client.js', 'r+', (err, fd) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('文件描述符为:', fd);
	}
});
//文件描述符为: 13

fs.openSync(path, flags[, mode])

说明:

fs.open() 的同步版本。 返回一个表示文件描述符的整数。

demo:

const fs = require('fs');

console.log( fs.openSync('./client.js', 'r+') );
// 13

fs.close(fd, callback)

说明:

关闭一个文件描述符
fd: 文件描述符
callback:完成后的回调函数,传递一个err
传递一个不存在的文件描述符,会抛出异常

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

fs.close(fd, (err) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('文件描述符已关闭');
	}
});
// 文件描述符已关闭

fs.close(19, (err) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('文件描述符已关闭');
	}
});
// { Error: EBADF: bad file descriptor, close errno: -9, code: 'EBADF', syscall: 'close' }

fs.closeSync(fd)

说明:

同步的 fs.close()。返回 undefined。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

console.log( fs.closeSync(fd) );
// undefined

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

说明:

从指定的fd(文件描述符)中读取数据。
buffer:文件数据要放入的容器Buffer
offset:Buffer中开始写入数据的偏移量
length:指定要读取的字节数
position:指定文件中开始读取的位置
callback 有三个参数 (err, bytesRead, buffer)。
bytesRead: 读取的字节数,buffer读取的内容buffer

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

const byteLen = 100;
let index = 0;

var fileBuffer = Buffer.alloc(0);

readFileBylen = () =>{
	fs.read(fd, Buffer.alloc(byteLen), 0, byteLen, (byteLen * index), (err, bytesRead, buffer) => {
		if(err){ 
			console.log(err); 
		} else {
			console.log(`第${index+1}次读取文件,从位置${byteLen*index}开始,读取了${bytesRead}个字节`)
			if(bytesRead < byteLen){
				fileBuffer = Buffer.concat([fileBuffer, buffer.slice(0, bytesRead)]);
				console.log(fileBuffer.toString())
			}else{
				fileBuffer = Buffer.concat([fileBuffer, buffer]);
				index++;
				readFileBylen();
			}
		}
	});
};

readFileBylen();
// 第1次读取文件,从位置0开始,读取了100个字节
// 第2次读取文件,从位置100开始,读取了100个字节
// 第3次读取文件,从位置200开始,读取了100个字节
// 第4次读取文件,从位置300开始,读取了100个字节
// 第5次读取文件,从位置400开始,读取了100个字节
// 第6次读取文件,从位置500开始,读取了5个字节

fs.readSync(fd, buffer, offset, length, position)

说明:

fs.read() 的同步版本。 返回 bytesRead 的数量。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

const byteLen = 200;
let index = 0;

var fileBuffer = Buffer.alloc(0);

readFileBylen = () =>{
	let cacheBuffer = Buffer.alloc(byteLen);
	let bytesRead = fs.readSync(fd, cacheBuffer, 0, byteLen, (byteLen * index));

	console.log(`第${index+1}次读取文件,从位置${byteLen*index}开始,读取了${bytesRead}个字节`)
	if(bytesRead < byteLen){
		fileBuffer = Buffer.concat([fileBuffer, cacheBuffer.slice(0, bytesRead)]);
		console.log(fileBuffer.toString())
	}else{
		fileBuffer = Buffer.concat([fileBuffer, cacheBuffer]);
		index++;
		readFileBylen();
	}
};

readFileBylen();
// 第1次读取文件,从位置0开始,读取了200个字节
// 第2次读取文件,从位置200开始,读取了200个字节
// 第3次读取文件,从位置400开始,读取了105个字节

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

说明:

异步地读取一个文件的全部内容。
path: 文件名或文件描述符(fd)。
options: 传递字符创时为文件编码
options.encoding: 默认为 null
options.flag: 打开属性,默认'r'
回调有两个参数 (err, data),其中 data 是文件的内容。
如果未指定字符编码,则返回原始的 buffer。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

fs.readFile(fd, 'utf8', (err, data) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log(data);
	}
});
//输出文件内容

fs.readFileSync(path[, options])

说明:

fs.readFile() 的同步版本。 返回 path 的内容。
如果指定了 encoding 选项,则该函数返回一个字符串,否则返回一个 buffer

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

const fileStr = fs.readFileSync(fd, 'utf8');

console.log(fileStr);
//输出文件内容

fs.stat(path, callback)

说明:

该方法返回关于文件的信息
path:文件地址
回调有两个参数 (err, stats) 其中 stats 是一个 fs.Stats 对象。
不建议在调用 fs.open() 、fs.readFile() 或 fs.writeFile() 之前使用 fs.stat() 检查一个文件是否存在。
作为替代,用户代码应该直接打开/读取/写入文件,当文件无效时再处理错误。
传递不存在的文件地址会抛出异常。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

fs.stat('./client.js', (err, stats) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('文件详细:', stats);
	}
});
// 文件详细: Stats {
//   dev: 16777220,
//   mode: 33188,
//   nlink: 1,
//   uid: 501,
//   gid: 20,
//   rdev: 0,
//   blksize: 4194304,
//   ino: 8593282677,
//   size: 505,
//   blocks: 8,
//   atimeMs: 1515727518580.965,
//   mtimeMs: 1515724815631.0774,
//   ctimeMs: 1515724815632.412,
//   birthtimeMs: 1515724815631.0276,
//   atime: 2018-01-12T03:25:18.581Z,
//   mtime: 2018-01-12T02:40:15.631Z,
//   ctime: 2018-01-12T02:40:15.632Z,
//   birthtime: 2018-01-12T02:40:15.631Z }

fs.statSync(path)

说明:

同步的 fs.stat。 返回一个 fs.Stats 实例。
传递不存在的文件地址会抛出异常。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

console.log( fs.statSync('./client1.js') );
//Error: ENOENT: no such file or directory, stat './client1.js'

fs.fstat(fd, callback)

说明:

功能与 fs.stat() 一致,区别是传递文件描述符fd。
回调获得两个参数 (err, stats),其中 stats 是一个 fs.Stats 对象。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

fs.fstat(fd, (err, stats) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('文件详细:', stats);
	}
});
// 文件详细: Stats {
//   dev: 16777220,
//   mode: 33279,
//   ...
// }

fs.fstatSync(fd)

说明:

同步的 fs.fstat() 返回一个 fs.Stats 实例。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

console.log( fs.fstatSync(fd) );
// Stats {
//   dev: 16777220,
//   mode: 33279,
//   ...
// }

fs.lstat(path, callback)

说明:

与 fs.stat() 功能一致,区别是如果传递的是一个符号链接,
该方法返回的是链接的信息,而不是链接所指向文件的信息。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

fs.lstat('./client.js', (err, stats) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('文件详细:', stats);
	}
});
// 文件详细: Stats {
//   dev: 16777220,
//   mode: 33279,
//   ...
// }

fs.lstatSync(path)

说明:

同步的 fs.lstat() 返回一个 fs.Stats 实例。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

console.log( fs.lstatSync('./client.js') );
// Stats {
//   dev: 16777220,
//   mode: 33279,
//   ...
// }

fs.Stats 类

说明:

从 fs.stat()、fs.lstat() 和 fs.fstat() 及其同步版本返回的对象都是该类型。
该对象提供以下方法使用:
stats.isFile()
stats.isDirectory()
stats.isBlockDevice()
stats.isCharacterDevice()
stats.isSymbolicLink() (仅对 fs.lstat() 有效)
stats.isFIFO()
stats.isSocket()

Stat 时间值

说明:

stat 对象中的时间有以下语义
atime "访问时间" - 文件数据最近被访问的时间。
mtime "修改时间" - 文件数据最近被修改的时间。
ctime "变化时间" - 文件状态最近更改的时间(修改索引节点数据)
birthtime "创建时间" - 文件创建的时间。 当文件被创建时设定一次。
在创建时间不可用的文件系统中,该字段可能被替代为 ctime 或 1970-01-01T00:00Z(如 Unix 的纪元时间戳 0)。
注意,该值在某些情况下可能会大于 atime 或 mtime。

fs.access(path[, mode], callback)

说明:

测试 path 指定的文件或目录的用户权限。
mode 是一个可选的整数,指定要执行的可访问性检查。以下常量定义了 mode 的可能值:
fs.constants.F_OK - path 文件对调用进程可见。 这在确定文件是否存在时很有用,但不涉及 rwx 权限。 如果没指定 mode,则默认为该值。
fs.constants.R_OK - path 文件可被调用进程读取。
fs.constants.W_OK - path 文件可被调用进程写入。
fs.constants.X_OK - path 文件可被调用进程执行。 对 Windows 系统没作用(相当于 fs.constants.F_OK)。
最后一个参数 callback 是一个回调函数,会带有一个可能的错误参数被调用。
不建议在调用 fs.open() 、 fs.readFile() 或 fs.writeFile() 之前使用 fs.access() 检查一个文件的可访问性。
如此处理会造成紊乱情况,因为其他进程可能在两个调用之间改变该文件的状态。 作为替代,用户代码应该直接打开/读取/写入文件,当文件无法访问时再处理错误。

demo:

const fs = require('fs');

fs.access('./client1.js', (err) => {
	if(err){
		console.log(err);
	}else{
		const fd = fs.openSync('./client1.js', 'r+');
		// do something
	}
});
// { Error: ENOENT: no such file or directory, access './client1.js'
//   errno: -2,
//   code: 'ENOENT',
//   syscall: 'access',
//   path: './client1.js' }

/*
	以上demo可以通过判断是否抛出err来判断文件是否可以访问
	可以这么做,但是不推荐。
	好的建议是直接在操作文件时,通过异常信息判断文件的访问性。
	上面的demo可以优化为:
*/

fs.open('./client1.js', 'r', (err, fd) => {
  if (err) {
	    if (err.code === 'ENOENT') {
	      	console.error('文件不存在');
	      	return;
	    }
    	throw err;
  	}
	// do something
});

fs.accessSync(path[, mode])

说明:

fs.access() 的同步版本。 如果有任何可访问性检查失败则抛出错误,否则什么也不做。

demo:

const fs = require('fs');

fs.accessSync('./client1.js')
// Error: ENOENT: no such file or directory, access './client1.js'

fs.exists(path, callback)(已废弃)

说明:

通过检查文件系统来测试给定的路径是否存在。
然后使用 true 或 false 为参数调用 callback。
不推荐在调用 fs.open,fs.readFile(),fs.writeFile() 之前使用 fs.exists() 检测文件是否存在。
这样做会引起竞争条件,因为在两次调用之间,其他进程可能修改文件。
作为替代,用户应该直接开/读取/写入文件,当文件不存在时再处理错误。

demo:

const fs = require('fs');
// const fd = fs.openSync('./client.js', 'r+');

fs.exists('./client1.js', (exists) => {
	console.log(`文件${exists?'':'不'}存在`);
});
//文件不存在

fs.exists('./client.js', (exists) => {
	console.log(`文件${exists?'':'不'}存在`);
});
//文件存在

fs.existsSync(path)

说明:

fs.exists() 的同步版本。 如果文件存在,则返回 true,否则返回 false。
注意,虽然 fs.exists() 是废弃的,但 fs.existsSync() 不是。

demo:

const fs = require('fs');
// const fd = fs.openSync('./client.js', 'r+');

const exists = fs.existsSync('./client.js');

console.log(`文件${exists?'':'不'}存在`);
// 文件不存在

fs.write(fd, buffer[, offset[, length[, position]]], callback)

说明:

写入 buffer 到 fd 指定的文件
fd:文件描述符
buffer:要写入的数据
offset 决定 buffer 中被写入的部分
length 是一个整数,指定要写入的字节数。
position 指向从文件开始写入数据的位置的偏移量。
如果 typeof position !== 'number',则数据从当前位置写入。
注意:如果当亲偏移量指向的位置有内容,那么write方法会用buffer的数据覆盖掉。
回调有三个参数 (err, bytesWritten, buffer),其中 bytesWritten 指定从 buffer 写入了多少字节。
注意,多次对同一文件使用 fs.write 且不等待回调,是不安全的。 对于这种情况,强烈推荐使用 fs.createWriteStream。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');
const website = Buffer.from('来自:www.isjs.cn');

fs.write(fd, website, (err, bytesWritten, buffer) => {
	if (err) {
    	throw err;
  	}else{
  		console.log(`写入buffer成功,写入${bytesWritten}字节。写入的内容为:${buffer}`);
  	}
});
// 写入buffer成功,写入20字节。写入的内容为:来自:www.isjs.cn

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

说明:

fs.write() 的同步版本。 返回写入的字节数。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');
const website = Buffer.from('来自:www.isjs.cn');

const bytesWritten = fs.writeSync(fd, website);
console.log(`写入了${bytesWritten}字节数据。`)
// 写入了20字节数据。

fs.write(fd, string[, position[, encoding]], callback)

说明:

写入 string 到 fd 指定的文件。 如果 string 不是一个字符串,则该值将被强制转换为一个字符串。
position 指向从文件开始写入数据的位置的偏移量。 如果 typeof position !== 'number',则数据从当前位置写入。
encoding 是期望的字符串编码。
回调有三个参数 (err, written, string),其中 written 指定传入的字符串被写入多少字节。
注意,写入的字节与字符串的字符是不同的。
不同于写入 buffer,该方法整个字符串必须被写入。 不能指定子字符串。
这是因为结果数据的字节偏移量可能与字符串的偏移量不同。
注意:如果当亲偏移量指向的位置有内容,那么write方法会用buffer的数据覆盖掉。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');
const website = '来自:www.isjs.cn';


fs.write(fd, website, (err, written, string) => {
	if (err) {
    	throw err;
  	}else{
  		console.log(`写入buffer成功,写入${written}字符。写入的内容为:${string}`);
  	}
});
// 写入buffer成功,写入20字符。写入的内容为:来自:www.isjs.cn

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

说明:

fs.write() 的同步版本。 返回写入的字节数。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');
const website = '来自:www.isjs.cn';

const bytesWritten = fs.writeSync(fd, website);
console.log(`写入了${bytesWritten}字符数据。`)
// 写入了20字符数据。

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

说明:

异步地写入数据到文件,如果文件已经存在,则替代文件。
file:文件名或文件描述符
options.encoding: data编码,默认'utf8'
options.mode:文件属性,默认0o666
data 可以是一个字符串或一个 buffer。
如果 data 是一个 buffer,则忽略 encoding 选项。它默认为 'utf8'。
注意:如果 file 指定为一个文件描述符,则它不会被自动关闭。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');
const website = '来自:www.isjs.cn';

fs.writeFile(fd, website, {encoding:'utf8', mode:0o666, flag:'w'}, (err) => {
	if (err) {
    	throw err;
  	}else{
  		console.log(`写入成功`);
  	}
});
// 写入成功

fs.writeFileSync(file, data[, options])

说明:

fs.writeFile() 的同步版本。返回 undefined。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');
const website = '来自:www.isjs.cn';

console.log( fs.writeFileSync(fd, website, {encoding:'utf8', mode:0o666, flag:'w'}) );
// undefined

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

说明:

异步地追加数据到一个文件,如果文件不存在则创建文件。 data 可以是一个字符串或 buffer。
file: 文件名或文件描述符
data:要追加的数据
options:如果为字符串,则它指定了字符编码,如果是对象,有以下属性:
options.encoding 默认为 'utf8'
options.mode 默认为 0o666
options.flag 默认为 'a'

demo:

const fs = require('fs');

const website = '来自:www.isjs.cn';

fs.appendFile('./client.js', website, {encoding:'utf8', mode:0o666, flag:'a'}, (err) => {
	if (err) {
    	throw err;
  	}else{
  		console.log(`追加成功`);
  	}
});
// 追加成功

fs.appendFileSync(file, data[, options])

说明:

fs.appendFile() 的同步版本。 返回 undefined。

demo:

const fs = require('fs');

const website = '来自:www.isjs.cn';

console.log( fs.appendFileSync('./client.js', website, {encoding:'utf8', mode:0o666, flag:'a'}) );
// undefined

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

说明:

监视 filename 的变化,filename 可以是一个文件或一个目录。
返回的对象是一个 fs.FSWatcher。
第二个参数是可选的。 如果提供的 options 是一个字符串,则它指定了 encoding。
否则 options 应该以一个对象:
options.persistent 指明如果文件正在被监视,进程是否应该继续运行。默认 = true
options.recursive 指明是否全部子目录应该被监视,或只是当前目录。 适用于当一个目录被指定时,且只在支持的平台。默认 = false
options.encoding 指定用于传给监听器的文件名的字符编码。默认 = 'utf8'
监听器回调有两个参数 (eventType, filename)。
eventType 可以是 'rename' 或 'change',filename 是触发事件的文件的名称
注意,在大多数平台,当一个文件出现或消失在一个目录里时,'rename' 会被触发
注意,监听器回调是绑定在 fs.FSWatcher 的 'change' 事件上,但它跟 eventType 的 'change' 值不是同一个东西。

demo:

const fs = require('fs');

fs.watch('./client.js', (eventType, filename) => {
	console.log(`事件类型是: ${eventType}`);
  	if (filename) {
    	console.log(`提供的文件名: ${filename}`);
  	} else {
    	console.log('未提供文件名');
  	}
});
// 事件类型是: change
// 提供的文件名: client.js

fs.FSWatcher 类

说明:

从 fs.watch() 返回的对象是该类型。
fs.watch() 的 listener 回调会绑定到 FSWatcher 的 change 事件。

change 事件

说明:

当一个被监视的目录或文件有变化时触发该事件。
事件传递给callback两个参数:
eventType:fs 变化的类型
filename:变化的文件名

demo:

const fs = require('fs');

const fsWatcher = fs.watch('./client.js');

fsWatcher.on('change', (eventType, filename) => {
	console.log(`事件类型是: ${eventType}`);
  	if (filename) {
    	console.log(`提供的文件名: ${filename}`);
  	} else {
    	console.log('未提供文件名');
  	}
});
// 事件类型是: change
// 提供的文件名: client.js

'error' 事件

说明:

当发生错误时触发。

demo:

const fs = require('fs');

const fsWatcher = fs.watch('./client.js');

fsWatcher.on('error', (err) => {
	console.log('文件监听异常');
});

watcher.close()

说明:

停止监听 fs.FSWatcher 的变化。

demo:

const fs = require('fs');

const fsWatcher = fs.watch('./client.js');

fsWatcher.close();

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

说明:

监视 filename 的变化。 回调 listener 会在每次访问文件时被调用。
options 参数可被省略。 如果提供的话,它应该是一个对象。
options 对象可能包含一个名为 persistent 的布尔值,表明当文件正在被监视时,进程是否应该继续运行。
options 对象可以指定一个 interval 属性,表示目标应该每隔多少毫秒被轮询。
options 默认值为 { persistent: true, interval: 5007 }。
listener 有两个参数,当前的状态对象(curr)和以前的状态对象(prev),这里的状态对象是 fs.Stat 实例。
如果你想在文件被修改而不只是访问时得到通知,则需要比较 curr.mtime 和 prev.mtime。
注意:fs.watch() 比 fs.watchFile 和 fs.unwatchFile 更高效。
可能的话,应该使用 fs.watch 而不是 fs.watchFile 和 fs.unwatchFile。

demo:

const fs = require('fs');

fs.watchFile('./client.js', { persistent: true, interval: 5007 }, (curr, prev) => {
	console.log('文件的上一个状态:', prev);
	console.log('文件的当前状态:', curr);
});
// 文件的上一个状态: Stats {
//   dev: 16777220,
//   mode: 33188,
//   nlink: 1,
//   uid: 501,
//   gid: 20,
//   rdev: 0,
//   blksize: 4194304,
//   ino: 8593282677,
//   size: 503,
//   blocks: 8,
//   atimeMs: 1515743684617.1555,
//   mtimeMs: 1515743682361.9941,
//   ctimeMs: 1515743682361.9941,
//   birthtimeMs: 1515724815631.0276,
//   atime: 2018-01-12T07:54:44.617Z,
//   mtime: 2018-01-12T07:54:42.362Z,
//   ctime: 2018-01-12T07:54:42.362Z,
//   birthtime: 2018-01-12T02:40:15.631Z }
  
// 文件的当前状态: Stats {
//   dev: 16777220,
//   mode: 33188,
//   nlink: 1,
//   uid: 501,
//   gid: 20,
//   rdev: 0,
//   blksize: 4194304,
//   ino: 8593282677,
//   size: 525,
//   blocks: 8,
//   atimeMs: 1515743684617.1555,
//   mtimeMs: 1515744166551.941,
//   ctimeMs: 1515744166551.941,
//   birthtimeMs: 1515724815631.0276,
//   atime: 2018-01-12T07:54:44.617Z,
//   mtime: 2018-01-12T08:02:46.552Z,
//   ctime: 2018-01-12T08:02:46.552Z,
//   birthtime: 2018-01-12T02:40:15.631Z }

fs.unwatchFile(filename[, listener])

说明:

停止监视 filename 文件的变化。 如果指定了 listener,则只移除特定的监听器。
否则,所有的监听器都会被移除,且已经有效地停止监视 filename。
调用 fs.unwatchFile() 且带上一个未被监视的文件名,将会是一个空操作,而不是一个错误。
注意:fs.watch() 比 fs.watchFile() 和 fs.unwatchFile() 更高效。
可能的话,应该使用 fs.watch() 而不是 fs.watchFile() 和 fs.unwatchFile()。

demo:

const fs = require('fs');

const listener = (curr, prev) => {
	console.log('文件的上一个状态:', prev);
	console.log('文件的当前状态:', curr);
}
fs.watchFile('./client.js', { persistent: true, interval: 5007 }, listener);

fs.unwatchFile('./client.js', listener)

fs.link(existingPath, newPath, callback)

说明:

使用此方法创建一个硬链接
existingPath:源文件地址,文件必须存在
newPath:硬链接的存储位置
callback:完成后的回调

demo:

const fs = require('fs');

fs.link('/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js', 
	'/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo/app', (err) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('创建硬链接完成');
	}
});
// 创建硬链接完成

fs.linkSync(existingPath, newPath)

说明:

同步的 link 返回 undefined。

demo:

const fs = require('fs');

console.log( fs.linkSync('/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js', 
	'/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo/app') );
// undefined

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

说明:

主要用来找出符号链接所指向的位置
path:链接或符号地址
options.encoding: 默认:'utf8'
callback:完成后执行的回调函数, 回调有两个参数 (err, linkString)。linkString是指向的位置。

demo:

//首先我们设置一个软连接
//$ ln -s /Users/xiaoqiang/Documents/work/demo/NodeApi/app.js /usr/local/bin/app

const fs = require('fs');

fs.readlink('/usr/local/bin/app', (err, linkString) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('该链接指向的位置是:', linkString);
	}
});
//该链接指向的位置是: /Users/xiaoqiang/Documents/work/demo/NodeApi/app.js

fs.readlink('/usr/local/bin/cnpm', (err, linkString) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('该链接指向的位置是:', linkString);
	}
});
// 该链接指向的位置是: ../lib/node_modules/cnpm/bin/cnpm

fs.readlink('/usr/local/bin/123', (err, linkString) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('该链接指向的位置是:', linkString);
	}
});
// { Error: ENOENT: no such file or directory, readlink '/usr/local/bin/123'
//   errno: -2,
//   code: 'ENOENT',
//   syscall: 'readlink',
//   path: '/usr/local/bin/123' }

fs.readlinkSync(path[, options])

说明:

同步的 readlink 返回符号链接的字符串值。

demo:

const fs = require('fs');

console.log( fs.readlinkSync('/usr/local/bin/cnpm') );
//../lib/node_modules/cnpm/bin/cnpm

fs.symlink(target, path[, type], callback)

说明:

使用此方法创建一个符号链接
target:源地址
path:链接存储位置
type:可以设为 'dir'、'file' 或 'junction'(默认为 'file'),且仅在 Windows 上有效(在其他平台上忽略)
callback:完成后的回调函数,可能传递一个异常参数

demo:

const fs = require('fs');

//等同于命令: $ ln -s /Users/xiaoqiang/Documents/work/demo/NodeApi/app.js /usr/local/bin/app
fs.symlink('/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js', '/usr/local/bin/app', (err) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('链接创建成功');
	}
});
// 链接创建成功
// 如果符号链接已存在,抛出异常:
// { Error: EEXIST: file already exists, symlink '/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js' -> '/usr/local/bin/app'
//   errno: -17,
//   code: 'EEXIST',
//   syscall: 'symlink',
//   path: '/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js',
//   dest: '/usr/local/bin/app' }

fs.symlinkSync(target, path[, type])

说明:

同步的 symlink。返回 undefined。

demo:

const fs = require('fs');

console.log( fs.symlinkSync('/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js', '/usr/local/bin/app') );
// undefined

fs.unlink(path, callback)

说明:

删除一个符号链接
path:链接的存储地址
callback:完成后的回调函数,携带 err 参数

demo:

const fs = require('fs');

fs.unlink('/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo/app', (err) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log('链接已删除');
	}
});
//链接已删除

fs.unlinkSync(path)

说明:

同步的 unlink 。返回 undefined。

demo:

const fs = require('fs');

console.log( fs.unlinkSync('/Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo/app') );
//undefined

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

说明:

此方法将相对地址转换为绝对地址。
path:需要转换的地址
options:字符编码,默认'utf8'
callback:callback 有两个参数 (err, resolvedPath)。
传递不存在的相对路径会抛出异常。
除此方法外,也可以使用 process.cwd 来获取当前目录绝对路径,从而实现转换功能。

demo:

const fs = require('fs');

fs.realpath('./fsDemo/', (err, resolvedPath) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log(resolvedPath);
	}
});
// /Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo

fs.realpath('/fsDemo', (err, resolvedPath) => {
	if(err){ 
		console.log(err); 
	} else {
		console.log(resolvedPath);
	}
});
// { Error: ENOENT: no such file or directory, lstat '/fsDemo' errno: -2, code: 'ENOENT', syscall: 'lstat', path: '/fsDemo' }

fs.realpathSync(path[, options])

说明:

同步的 realpath。 返回解析的路径

demo:

const fs = require('fs');

console.log( fs.realpathSync('./fsDemo') );
// /Users/xiaoqiang/Documents/work/demo/NodeApi/fsDemo

fs.chmod(path, mode, callback)

说明:

该方法用来变更文件或目录的权限。
path:地址
mode:文件权限码
callback:完成后的回调,只有一个可能的异常参数。

demo:

const fs = require('fs');

fs.chmod('./client.js', 0o777, (err) => {
	if(err) throw err;
	console.log('修改完成');
});
// 修改完成

fs.chmodSync(path, mode)

说明:

同步的 fs.chmod()。返回 undefined。

demo:

const fs = require('fs');

console.log( fs.chmodSync('./client.js', 0o777) );
// undefined

fs.fchmod(fd, mode, callback)

说明:

该方法用来变更文件或目录的权限。
fd:文件描述符
mode:文件权限码
callback:完成后的回调,只有一个可能的异常参数。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

fs.fchmod(fd, 0o777, (err) => {
	if(err) throw err;
	console.log('修改完成');
});
// 修改完成

fs.fchmodSync(fd, mode)

说明:

同步的 fs.fchmod()。返回 undefined。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

console.log( fs.fchmodSync(fd, 0o777) );
// undefined

fs.lchmod(path, mode, callback)

说明:

该方法用来变更文件或目录的权限。 完成回调只有一个可能的异常参数。
只在 macOS 有效

demo:

const fs = require('fs');

fs.lchmod('./client.js', 0o777, (err) => {
	if(err) throw err;
	console.log('修改完成');
});
// 修改完成

fs.lchmodSync(path, mode)

说明:

同步的 fs.lchmod()。返回 undefined。

demo:

const fs = require('fs');

console.log( fs.lchmodSync('./client.js', 0o777) );
// undefined

fs.chown(path, uid, gid, callback)

说明:

该方法用来变更文件的所有者和组。
一个文件都有一个所有者, 表示该文件是谁创建的. 此为UID。
同时, 该文件还有一个组编号, 表示该文件所属的组, 一般为文件所有者所属的组. 此为GID。
path:文件地址
callback:完成后的回调,只有一个可能的异常参数。

demo:

const fs = require('fs');

fs.chown('./client.js', 501, 20, (err) => {
	if(err) throw err;
	console.log('修改完成用户组完成');
});
// 修改完成用户组完成

fs.chownSync(path, uid, gid)

说明:

同步的 fs.chown()。返回 undefined。

demo:

const fs = require('fs');

console.log( fs.chownSync('./client.js', 501, 20) );
// undefined

fs.fchown(fd, uid, gid, callback)

说明:

该方法用来变更文件的所有者和组。
与 fs.chown() 的区别是传递一个文件描述符。

demo:

const fs = require('fs');
const fd = fs.openSync('./client.js', 'r+');

fs.fchown(fd, 501, 20, (err) => {
	if(err) throw err;
	console.log('修改完成用户组完成');
});
// 修改完成用户组完成

fs.fchownSync(fd, uid, gid)

说明:

同步的 s.fchown()。返回 undefined。

demo:

const fs = require('fs');
const fd = fs.openSync('./client.js', 'r+');

console.log( fs.fchownSync(fd, 501, 20) );
// undefined

fs.lchown(path, uid, gid, callback)

说明:

与 fs.chown() 的区别是,fs.chown()在处理符号链接时会取消引用。
而 fs.lchown() 则不会。

demo:

const fs = require('fs');

fs.lchown('./client.js', 501, 20, (err) => {
	if(err) throw err;
	console.log('修改完成用户组完成');
});
// 修改完成用户组完成

fs.lchownSync(path, uid, gid)

说明:

同步的 fs.lchown()。返回 undefined。

demo:

const fs = require('fs');

console.log( fs.lchownSync('./client.js', 501, 20) );
// undefined

fs.fsync(fd, callback)

说明:

将所有修改后的数据传输/刷新到磁盘设备。
fd:文件描述符
callback:完成后的回调,只有一个可能的异常参数。

demo:

const fs = require('fs');
const fd = fs.openSync('./client.js', 'r+');

fs.fsync(fd, (err) => {
	if(err) throw err;
	console.log('数据同步完成');
});
// 数据同步完成

fs.fsyncSync(fd)

说明:

同步的 fs.fsync()。返回 undefined。

demo:

const fs = require('fs');
const fd = fs.openSync('./client.js', 'r+');

console.log( fs.fsyncSync(fd) );
// undefined

fs.fdatasync(fd, callback)

说明:

功能与 fs.fsync() 类似,但不会刷新修改源数据。

demo:

const fs = require('fs');
const fd = fs.openSync('./client.js', 'r+');

fs.fdatasync(fd, (err) => {
	if(err) throw err;
	console.log('数据同步完成');
});
// 数据同步完成

fs.fdatasyncSync(fd)

说明:

同步的 fs.fdatasync()。返回 undefined。

demo:

const fs = require('fs');
const fd = fs.openSync('./client.js', 'r+');

console.log( fs.fdatasyncSync(fd) );
// undefined

fs.truncate(path[, len], callback)

说明:

对文件进行截断,
path为文件地址
len为截断的长度,默认为0。
注意:执行此方法后文件将会被清空
回调只有一个可能的异常参数

demo:

const fs = require('fs');

fs.truncate('./client.js', (err) => {
	if(err) throw err;
	console.log('截取完成');
});
// 截取完成

fs.truncateSync(path[, len])

说明:

fs.truncate() 的同步版本。返回undefined。

demo:

const fs = require('fs');

console.log( fs.truncateSync('./client.js', 10) );
// undefined

fs.ftruncate(fd[, len], callback)

说明:

对文件进行截断,
与 fs.truncate() 的区别在于传递文件描述符
如果文件描述符指向的文件大于 len 个字节,则只有前面 len 个字节会保留在文件中。
如果前面的文件小于 len 个字节,则扩展文件,且扩展的部分用空字节('\0')填充。

demo:

const fs = require('fs');
const fd = fs.openSync('./client.js', 'r+');

fs.ftruncate(fd, 20, (err) => {
	if(err) throw err;
	console.log('截取完成');
});
// 截取完成

fs.ftruncateSync(fd[, len])

说明:

fs.ftruncate() 的同步版本。返回undefined。

demo:

const fs = require('fs');
const fd = fs.openSync('./client.js', 'r+');

console.log( fs.ftruncateSync(fd, 20) );
// undefined

fs.utimes(path, atime, mtime, callback)

说明:

改变 path 所指向的对象的文件系统时间戳。
path:文件地址
atime:atime 是在读取文件或者执行文件时更改的
mtime:mtime 是在写入文件时随文件内容的更改而更改的
atime 参数和 mtime 参数遵循以下规则:
1.值可以是 Unix 时间戳数值、Date 对象、或数值字符串如 '123456789.0'。
2.如果值不能被转换为数值,或值是 NaN 、 Infinity 或 -Infinity,则会抛出错误。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

fs.utimes('./client.js', new Date(), new Date(), (err) => {
	if(err) throw err;
	console.log('文件时间已修改')
});
// 文件时间已修改

fs.utimesSync(path, atime, mtime)

说明:

fs.utimes() 的同步版本。返回undefined。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

console.log( fs.utimesSync('./client.js', new Date(), new Date()) );
// undefined

fs.futimes(fd, atime, mtime, callback)

说明:

功能与 fs.utimes() 一致。区别是传递文件描述符fd。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

fs.futimes(fd, new Date(), new Date(), (err) => {
	if(err) throw err;
	console.log('文件时间已修改')
});
// 文件时间已修改

fs.futimesSync(fd, atime, mtime)

说明:

功能与 fs.futimes() 一致。区别是传递文件描述符fd。

demo:

const fs = require('fs');

const fd = fs.openSync('./client.js', 'r+');

console.log( fs.futimesSync(fd, new Date(), new Date()) );
// undefined

fs.createReadStream(path[, options])

说明:

返回一个新建的 ReadStream 对象
不同于在一个可读流上设置的 highWaterMark 默认值(16 kb),该方法在相同参数下返回的流具有 64 kb 的默认值。
path:文件路径
options:选项,包含以下值
flags:文件属性。默认:'r'
encoding:文件编码,默认 null
fd:文件描述符,如果指定了 fd,则会忽略 path 参数。 这意味着不会触发 'open' 事件。
mode:文件读写属性,默认0o666
autoClose:如果 autoClose 为 false,则文件描述符不会被关闭,即使有错误。默认为true。
start:指定读取范围的开始位置
end:指定读取范围的结束位置

demo:

const fs = require('fs');

const fileStream = fs.createReadStream('./client.js', {start: 2, end: 9});

fileStream.on('data', (chunk) => {
	console.log('文件内容为:', chunk);
});
// 文件内容为: 

fs.ReadStream 类

说明:

fs.ReadStream 是createReadStream返回的可读流

readStream.path

说明:

流正在读取的文件的路径,指定在 fs.createReadStream() 的第一个参数。
如果 path 传入的是一个字符串,则 readStream.path 是一个字符串。
如果 path 传入的是一个 Buffer,则 readStream.path 是一个 Buffer。

demo:

const fs = require('fs');

const fileStream = fs.createReadStream('./client.js', {start: 2, end: 9});

console.log(fileStream.path);
// ./client.js

readStream.bytesRead

说明:

返回已读取的字节数。

demo:

const fs = require('fs');

const fileStream = fs.createReadStream('./client.js', {start: 2, end: 9});

fileStream.on('data', (chunk) => {
	console.log(`已读取${fileStream.bytesRead}字节内容`);
});
// 已读取8字节内容

close 事件

说明:

当 ReadStream 底层的文件描述符被关闭时触发

demo:

const fs = require('fs');

const fileStream = fs.createReadStream('./client.js', {start: 2, end: 9});

fileStream.on('close', () => {
	console.log('文件已关闭')
})
// 文件已关闭

open 事件

说明:

当 ReadStream 的文件被打开时触发。

demo:

const fs = require('fs');

const fileStream = fs.createReadStream('./client.js', {start: 2, end: 9});

fileStream.on('open', (fd) => {
	console.log('文件已打开:', fd)
})
// 文件已打开: 13

fs.createWriteStream(path[, options])

说明:

返回一个新建的 WriteStream 对象
path:文件路径
options:选项,包含以下值
flags:文件属性。默认:'w'
encoding:文件编码,默认 utf8
fd:文件描述符,如果指定了 fd,则会忽略 path 参数。 这意味着不会触发 'open' 事件。
mode:文件读写属性,默认0o666
autoClose:如果 autoClose 为 false,则文件描述符不会被关闭,即使有错误。默认为true。
start:指定文件写入的开始位置

demo:

const fs = require('fs');

const fileStream = fs.createWriteStream('./client.js', {start: 0});

fileStream.write('www.isjs.cn');
fileStream.end();

fileStream.on('finish', (chunk) => {
	console.log('数据写入成功');
});
// 数据写入成功

fs.WriteStream 类

说明:

fs.WriteStream 是 createWriteStream 返回的可写流

writeStream.path

说明:

流正在写入的文件的路径,指定在 fs.createWriteStream() 的第一个参数。
如果 path 传入的是一个字符串,则 writeStream.path 是一个字符串。
如果 path 传入的是一个 Buffer,则 writeStream.path 是一个 Buffer。

demo:

const fs = require('fs');

const fileStream = fs.createWriteStream('./client.js', {start: 0});

fileStream.write('www.isjs.cn');
fileStream.end();

fileStream.on('finish', (chunk) => {
	console.log('数据写入成功');
	console.log('文件地址:', fileStream.path);
});
// 数据写入成功
// 文件地址: ./client.js

writeStream.bytesWritten

说明:

已写入的字节数。 不包括仍在排队等待写入的数据。

demo:

const fs = require('fs');

const fileStream = fs.createWriteStream('./client.js', {start: 0});

fileStream.write('www.isjs.cn');
fileStream.end();

fileStream.on('finish', (chunk) => {
	console.log(`数据写入成功, 共${fileStream.bytesWritten}字节。`);
});
// 数据写入成功, 共11字节。

close 事件

说明:

当 WriteStream 底层的文件描述符被关闭时触发。

demo:

const fs = require('fs');

const fileStream = fs.createWriteStream('./client.js', {start: 0});

fileStream.on('close', () => {
	console.log('文件已关闭')
})

fileStream.write('www.isjs.cn');

fileStream.end();
// 文件已关闭

open 事件

说明:

当 WriteStream 的文件被打开时触发。

demo:

const fs = require('fs');

const fileStream = fs.createWriteStream('./client.js', {start: 0});

fileStream.on('open', () => {
	console.log('文件已打开')
})

fileStream.write('www.isjs.cn');

fileStream.end();
// 文件已打开

fs.constants

说明:

返回一个包含常用文件系统操作的常量的对象。

demo:

const fs = require('fs');

console.log(fs.constants)
// { O_RDONLY: 0,
//   O_WRONLY: 1,
//   O_RDWR: 2,
//   S_IFMT: 61440,
//   ... }

fs 常量

说明:

以下常量由 fs.constants 输出。
注意:不是所有的常量在每一个操作系统上都是可用的。

文件访问常量

说明:

以下常量用于 fs.access()。

文件打开常量

说明:

以下常量用于 fs.open()。

文件类型常量

说明:

以下常量用于 fs.Stats 对象中用于决定一个文件的类型的 mode 属性。

文件模式常量

说明:

以下常量用于 fs.Stats 对象中用于决定一个文件访问权限的 mode 属性。