readFile(readFileSync)（path[, options], callback）
第一个参数是文件路径、第二个参数是配置的参数例如编码格式，第三个是回调函数（同步方法是没有回调函数的）
//是把整个文件作为一个整体
fs.readFile('./1.txt',{encoding:'utf8'},function (err,data) {
console.log(err);
console.log(data);
});
//同步方法是没有回调函数的
let result=fs.readFileSync('./1.txt',{encoding: 'utf8'});
console.log(result);
writeFile(writeFileSync)（file, data[, options], callback）
第一个参数是文件路径、第二个参数是写入的内容，第三个是参数配置，第四个是回调函数。
fs.writeFile('./2.txt','123',{encoding: 'utf8'},(err) => {
console.log('write OK');
})
fs.writeFileSync('./3.txt','456');
简单的实现拷贝
const fs=require('fs');
function copy(src,dest,cb) {
fs.readFile(src,(err,data) => {
fs.writeFile(dest,data,cb);
});
}
copy('3.txt','4.txt',() => {
console.log('拷贝完成');
});
appendFile(追加文件内容,不能使用writeFile，因为writeFile存在的话会先清空在写入，不存在会创建)
fs.writeFile('./4.txt','789',{flag:'a'});
fs.appendFile('./4.txt','789');
flags(配置参数选项)
linux权限
编码问题（gbk->utf8转换过程中会出现一个BOM头）
let path = require('path');
let result = fs.readFileSync(path.resolve(__dirname,'./text.txt'));
console.log(stripBOM(result).toString())
function stripBOM(content){
if(Buffer.isBuffer(content)){
if(content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf ){
return content.slice(3);
}
}else{
if (content.charCodeAt(0) === 0xFEFF) {
content = content.slice(1);
}
}
return content;
}
open(filename,flags,[mode],callback)
//fd file descriptor 文件描述符 是一个数字或者说索引
fs.open('./5.txt','r',(err,fd) => {
console.log(fd);
fs.open('./4.txt','r',(err,fd) => {
console.log(fd);
});
});
read(fd, buffer, offset, length, position, callback((err, bytesRead, buffer)))
- 第一个参数是文件描述符
- 第二个参数用来存放读取的内容的buffer
- 第三个参数存放内容的buffer的起始索引
- 第四个参数存放内容的长度
- 第五个参数读取文件的起始索引
- 第六个参数是回调函数（bytesRead是实际读取的字节数）
fs.open('./6.txt','r',0666,(err,fd) => {
let buffer=Buffer.alloc(6);//[0,1,2,3,4,5]
fs.read(fd,buffer,0,3,3,(err,bytesRead) => {
fs.read(fd,buffer,3,3,6,(err,byteRead) => {
console.log(buffer.toString());
});
});
});
write(fd, buffer[, offset[, length[, position]]], callback)
- 第一个参数是文件描述符
- 第二个参数用来存放要写入的内容的buffer
- 第三个参数存放要写入的内容的buffer的起始索引
- 第四个参数存放要写入的内容的长度
- 第五个参数写入文件的起始索引
- 第六个参数是回调函数
fs.open('./6.txt','r+',0666,(err,fd) => {
let buffer=Buffer.from('珠峰培训');//[0,1,2,3,4,5,6,7,8,9,10,11]
//fd buffer offset
fs.write(fd,buffer,3,6,3,(err,bytesWritten) => {
console.log(err);
// 先同步缓存在进行关闭
fs.fsync(fd,(err) => {
fs.close(fd,(err) => {
console.log('关闭文件');
});
});
});
});
fsync(fd,[callback]) (同步磁盘缓存)
close(fd,[callback])（关闭文件）
read和write实现的copy
function copy(src,dest) {
fs.open(src,'r',(err,readFd)=> {
fs.open(dest,'w',(err,writeFd) => {
let buffer=Buffer.alloc(BUFFER_SIZE);
let readed=0;
let writed=0;
function next() {
fs.read(readFd,buffer,0,BUFFER_SIZE,readed,(err,bytesRead) => {
readed+=bytesRead;
bytesRead&&fs.write(writeFd,buffer,0,bytesRead,writed,(err,bytesWritten) => {
writed+=bytesWritten;
next();
});
});
};
next();
});
});
}
目录操作
- mkdir (创建目录的时候要求父目录必须存在)
fs.mkdir('a/b/c',err => {
console.log(err);
console.log('创建成功');
});
- access (判断文件是否存在)
fs.access('b',(err) => {
console.log(err);
});
同步创建目录
function mkpSync(dir) {
let parts=dir.split(path.sep);//['a','b','c']
for (let i=1;i<=parts.length;i++){
// a a/b a/b/c
let current=parts.slice(0,i).join(path.sep);
try {
fs.accessSync(current);
} catch (err) {
fs.mkdirSync(current);
}
}
}
异步创建目录
function mkpAsync(dir,callback) {
let parts=dir.split(path.sep);//[a,b,c]
let index=1;
function next() {
if (index>parts.length) return callback();
let current=parts.slice(0,index).join(path.sep);//a
index++;
fs.access(current,(err) => {
if (err) {
fs.mkdir(current,next);
} else {
next();
}
});
}
next();
}
终极await/async实现创建目录
function promisify(fn) {
return function (...args) {
return new Promise((resolve,reject) => {
fn.call(null,...args,err=>err? reject():resolve());
});
}
}
async function mkp(dir) {
let parts=dir.split(path.sep);//['a','b','c']
for (let i=1;i<=parts.length;i++){
// a a/b a/b/c
let current=parts.slice(0,i).join(path.sep);
try {
await promisify(fs.access)(current);
} catch (err) {
await promisify(fs.mkdir)(current);
}
}
}
删除目录（要删除目录需要先把目录中的内容读出来）
读取目录内容、路径拼接、判断文件类型（不同方法处理）
- 删除目录（fs.rmdirSync）
- 删除文件（fs.unlinkSync）
let files = fs.readdirSync('a');
files = files.map(file => path.join('a',file));
files.forEach(file=>{
let statObj = fs.statSync(file);
if(statObj.isDirectory()){
fs.rmdirSync(file);
}else{
fs.unlinkSync(file);
}
})
先序深度优先
// 同步
let fs = require('fs');
let path = require('path');
function removeDir(p) {
let statObj = fs.statSync(p);
if(statObj.isDirectory()){
let dirs = fs.readdirSync(p);
dirs = dirs.map(dir => path.join(p,dir));
for(let i = 0; i<dirs.length;i++){
// 深度 先将儿子移除掉 再删除掉自己
removeDir(dirs[i]);
}
fs.rmdirSync(p);
}else{
fs.unlinkSync(p);
}
}
// promise 并行
let fs = require('fs');
let path = require('path');
function removeDir(p) {
return new Promise((resolve,reject)=>{
fs.stat(p,(err,statObj)=>{ // 判断文件类型 是目录 递归 否则就删除即可
if(statObj.isDirectory()){
fs.readdir(p, function (err, dirs) {
// 映射路径
dirs = dirs.map(dir => path.join(p, dir));
// 映射promise
dirs = dirs.map(dir => removeDir(dir));
// 删除完儿子后 删除自己
Promise.all(dirs).then(() => {
fs.rmdir(p, resolve);
});
});
}else{
fs.unlink(p,resolve);
}
});
});
}
function removeDir(p,callback) {
fs.stat(p,function (err,statObj) {
if (statObj.isDirectory()){
fs.readdir(p,function (err,dirs) {
dirs = dirs.map(dir=>path.join(p,dir));
// 我们希望 可以同时删除这些目录
if(dirs.length == 0) return fs.rmdir(p,callback);
// 先预定一个函数 所有儿子都删除了的函数回调
let index = 0;
function all() {
index++;
if (index === dirs.length) fs.rmdir(p, callback);
// if (index === dirs.length) fs.rmdir(p, ()=>callback());
}
dirs.forEach(dir=>{
removeDir(dir, all);
});
});
}else{
fs.unlink(p,callback)
}
});
}
// async和await
let fs = require('fs');
let path = require('path');
let util = require('util');
let stat = util.promisify(fs.stat);
let readdir = util.promisify(fs.readdir);
let rmdir = util.promisify(fs.rmdir);
let unlink = util.promisify(fs.unlink);
async function removeDir(p) {
let statObj = await stat(p);
if(statObj.isDirectory()){
let dirs = await readdir(p);
dirs = dirs.map(dir=>path.join(p,dir));
dirs = dirs.map(dir => removeDir(dir));
await Promise.all(dirs);
await rmdir(p);
}else{
// 要等待文件删除后 才让promise执行完 所以需要await
await unlink(p);
}
}
// 回调写法 串行
let fs = require('fs');
let path = require('path');
function removeDir(p,callback) {
fs.stat(p,(err,statObj)=>{
if(statObj.isDirectory()){
fs.readdir(p,function (err,dirs) {
// 异步怎么递归？
// next函数用来递归的
dirs = dirs.map(dir => path.join(p, dir));
// 标识先删除第一个
function next(index) {
if (index === dirs.length) return fs.rmdir(p, callback)
let file = dirs[index];
// 删除目录后将下一次的删除继续传递
removeDir(file, ()=>next(index+1));
}
next(0);
})
}else{ // 文件删除执行callback即可
fs.unlink(p,callback);
}
});
}
先序广度优先
let fs = require('fs');
let path = require('path');
function removeDir(p) {
let arr = [p];
let index = 0;
let current;
while (current = arr[index++]) {
let statObj = fs.statSync(current);
if (statObj.isDirectory()) {
let dirs = fs.readdirSync(current);
arr = [...arr, ...dirs.map(dir => path.join(current, dir))];
}
}
for (let i = arr.length - 1; i >= 0; i--) {
let statObj = fs.statSync(arr[i]);
if (statObj.isDirectory()) {
fs.rmdirSync(arr[i])
}else{
fs.unlinkSync(arr[i])
}
}
}
可读流、可写流
流有两种模式 一种是暂停模式 一种是流动模式
createReadStream
let rs = fs.createReadStream('./1test.js',{
flags:'r', // 读取的方式
// encoding:null,// 编码 buffer
autoClose:true,
start:0,
end:9, // 包后
highWaterMark:2 // 最高水位线
});
let arr = []
rs.on('data',function (data) {
rs.pause(); // 暂停 暂停触发data事件
arr.push(data);
setTimeout(() => {
rs.resume();
}, 1000);
});
rs.on('error',function (err) {
console.log(err);
});
rs.on('end',function () {
console.log(Buffer.concat(arr).toString());
});
createWriteStream
写 (第一次会真的往文件里写) 后面会写到缓存中。highWaterMark只是一个标识而已，一般配合着读取来用。当写入的内容超过highWaterMark的时候会暂停一下。
let fs = require('fs');
let ws = fs.createWriteStream('2.txt',{
flags:'w',
encoding:'utf8',
autoClose:true,
start:0,
highWaterMark:3
});
let flag = ws.write('1');
console.log(flag); // true
flag = ws.write('1');
console.log(flag); // true
flag = ws.write('1');
console.log(flag); // false
ws.on('drain',function () {
console.log('抽干')
});
// 抽干方法必须当前的写入的内容（内存+文件） 已经大于等于了highWater，才会触发drain，当内容全部写入后 会执行drain方法
ws.end('我死了');//会将缓存区的内容 清空后再关闭文件
ws.write('ok');// write after end不能再结束后继续写入
手动实现的可读流（createReadStream）
let EventEmitter = require('events');
let fs = require('fs');
class ReadStream extends EventEmitter {
constructor(path, options = {}) {
super();
// 默认参数配置
this.path = path;
this.autoClose = options.autoClose || true;
this.flags = options.flags || 'r';
this.encoding = options.encoding || null;
this.start = options.start || 0;
this.end = options.end || null;
this.highWaterMark = options.highWaterMark || 64 * 1024;
// 应该有一个读取文件的位置 可变的(可变的位置)
this.pos = this.start;
// 控制当前是否是流动模式
this.flowing = null;
// 构建读取到的内容的buffer
this.buffer = Buffer.alloc(this.highWaterMark);
// 当创建可读流 要将文件打开
this.open(); // 异步执行
// 判断是否绑定了新的事件
this.on('newListener', (type) => {
if(type === 'data'){ // 用户监听了data事件，就开始读取吧
this.flowing = true;
this.read();// 开始读取文件
}
});
}
read(){
// 这时候文件还没有打开呢，等待着文件打开后再去读取
if(typeof this.fd !== 'number'){
// 等待着文件打开，再次调用read方法
return this.once('open',()=>this.read());
}
// 开始读取了
// 文件可能有10个字符串
// start 0 end 4
// 每次读三个 3
// 0-2
// 34
let howMuchToRead = this.end ? Math.min(this.highWaterMark,this.end - this.pos+1) :this.highWaterMark
// 文件描述符 读到哪个buffer里 读取到buffer的哪个位置
// 往buffer里读取几个,读取的位置
// 想读三个 文件只有2个
fs.read(this.fd, this.buffer,0,howMuchToRead,this.pos,(err,bytesRead)=>{
if (bytesRead>0){ // 读到内容了
this.pos += bytesRead;
// 保留有用的
let r = this.buffer.slice(0, bytesRead);
r = this.encoding ? r.toString(this.encoding) : r;
// 第一次读取
this.emit('data', r);
// 流动模式
if (this.flowing) {
this.read();
}
}else{
this.emit('end');
this.destroy();
}
});
}
pipe(dest){
this.on('data',(data)=>{
let flag = dest.write(data);
if(!flag){
this.pause();
}
});
dest.on('drain',()=>{
this.resume();
});
this.on('end',()=>{
this.destroy();
});
}
destroy() { // 判断文件是否打开 (将文件关闭掉)
// 文件已经打开了
if (typeof this.fd === 'number') {
fs.close(this.fd, () => {
this.emit('close');
});
return;
}
this.emit('close');
}
open() { // 打开文件的逻辑
fs.open(this.path, this.flags, (err, fd) => {
if (err) {
this.emit('error', err);
if (this.autoClose) {
this.destroy(); // 销毁 关闭文件（触发close事件）
} return;
}
this.fd = fd;
this.emit('open'); // 触发文件开启事件
});
}
pause(){
this.flowing = false;
}
resume(){
this.flowing = true;
this.read(); // 继续读取
}
}
module.exports = ReadStream;
手动实现的可写流（createWriteStream）
let fs = require('fs');
let EventEmitter = require('events');
class WriteStream extends EventEmitter{
constructor(path,options ={}){
super();
this.path = path;
this.flags = options.flags || 'w';
this.mode = options.mode || 0o666;
this.highWaterMark = options.highWaterMark || 16*1024;
this.start = options.start || 0;
this.autoClose = options.autoClose|| true;
this.encoding = options.encoding || 'utf8';
// 是否需要触发drain事件
this.needDrain = false;
// 是否正在写入
this.writing = false;
// 缓存 正在写入就放到缓存中
this.buffer = [];
// 算一个当前缓存的个数
this.len = 0;
// 写入的时候也有位置关系
this.pos = this.start;
this.open();
}
// 0 [1 2]
write(chunk, encoding = this.encoding,callback){
chunk = Buffer.isBuffer(chunk)?chunk:Buffer.from(chunk);
this.len += chunk.length;// 每次调用write就统计一下长度
this.needDrain = this.highWaterMark <= this.len;
// this.fd
if(this.writing){
this.buffer.push({chunk,encoding,callback});
}else{
// 当文件写入后 清空缓存区的内容
this.writing = true; // 走缓存
this._write(chunk,encoding,()=>this.clearBuffer());
}
return !this.needDrain; // write 的返回值必须是true / false
}
_write(chunk,encoding,callback){
if (typeof this.fd !== 'number') {
return this.once('open', () => this._write(chunk, encoding, callback));
}
// fd是文件描述符 chunk是数据 0 写入的位置和 长度 , this.pos偏移量
fs.write(this.fd, chunk,0,chunk.length,this.pos,(err,bytesWritten)=>{
this.pos += bytesWritten;
this.len -= bytesWritten; // 写入的长度会减少
callback();
});
}
clearBuffer(){
let buf = this.buffer.shift();
if(buf){
this._write(buf.chunk, buf.encoding, () => this.clearBuffer());
}else{
this.writing = false;
this.needDrain = false; // 触发一次drain 再置回false 方便下次继续判断
this.emit('drain');
}
}
destroy(){
if(typeof this.fd === 'number'){
fs.close(this.fd,()=>{
this.emit('close');
});
return
}
this.emit('close');
}
open(){
fs.open(this.path,this.flags,this.mode,(err,fd)=>{
if(err){
this.emit('error');
this.destroy();
return
}
this.fd = fd;
this.emit('open');
});
}
}
module.exports = WriteStream;
继承Stream的可读流
//我的流如果继承了 Readable接口 就必须要重写一个_read的方法,并且有push方法
class MyReadStream extends Readable{ // read _read
constructor(){
super();
this.index = 0;
}
_read(){
if(this.index == 5){
return this.push(null); // 读取完毕了
}
this.push(this.index+++''); // push方法也是Readble实现的
}
}
let rs = new MyReadStream();
rs.on('data',function (data) {
console.log(data);
})
rs.on('end',function () {
console.log('end');
})
继承Stream的可写流
let { Writable } = require('stream'); // 流的模块
let fs = require('fs');
// 我的流如果继承了 Readable接口 就必须要重写一个_write的方法
class MyWriteStream extends Writable { // write _write
constructor() {
super();
}
_write(chunk,encoding,clearBuffer) {
fs.appendFile('1.txt',chunk,function () {
clearBuffer();
})
}
}
let ws = new MyWriteStream();
ws.write('hello','utf8',function () {
console.log('ok');
});
ws.write('hello', 'utf8', function () {
console.log('ok');
});
readable
let fs = require('fs');
let rs = fs.createReadStream('./1.txt',{
autoClose:true,
start:0,
flags:'r',
encoding:'utf8',
highWaterMark:3// 默认先在杯子里 填 3滴水
})
// 暂停模式先把水杯 给你填满，自己去喝 喝多少取决于你自己
// 1).readable 当杯子里的水 是空的时候 会触发readable事件（还会将杯子里的水在填入 highWaterMark个）
// 2).如果当前杯子里的水 小于hightWaterMark 会再次读取highWaterMark个
// 3) 行读取器
rs.on('readable',()=>{
let r = rs.read(1);
console.log(rs._readableState.length);// 查看剩余的数量
setTimeout(()=>{
console.log(rs._readableState.length);
},5000)
});
lineReader
// 行读取器 没读完一行 就把这一行的内容 发射出来
let EventEmitter = require('events');
let fs = require('fs');
class LineReader extends EventEmitter {
constructor(path) {
super();
this.path = path;
let RETURN = 13;
let LINE = 10;
this.arr = []; // 存放内容的
// \r 13 windows 怎么表示是新的一行 就用\r
// \n 10 mac 没有\r 只有\n
this._rs = fs.createReadStream(this.path); // 64k
// 判断用户监听了newLine事件
let r ;
this.on('newListener', (type) => {
if (type === 'newLine') {
this._rs.on('readable', () => {
let current; // 当前读出来的内容
while (current = this._rs.read(1)) {
switch (current[0]) {
case RETURN:
r = Buffer.concat(this.arr).toString();
this.emit('newLine', r);
this.arr = [];
// 如果下一个是换行 我就抛弃掉如果不是换行 我就留到数组里
let next = this._rs.read(1);
if (next[0] !== LINE) {
this.arr.push(current);
}
break;
case LINE:
r = Buffer.concat(this.arr).toString();
this.emit('newLine', r);
this.arr = [];
default:
this.arr.push(current);
}
}
});
this._rs.on('end', () => {
let r = Buffer.concat(this.arr).toString();
this.emit('newLine', r);
})
}
})
}
}
// 行读取器
let lineReader = new LineReader('./1.txt');
lineReader.on('newLine', (data) => {
console.log(data, '-------------');// 123 // 456 // 789
});
转化流和双工流
双工流需要重写_write和_read方法。转化流重写_transform，应用场景在压缩。
let {Duplex,Transform} = require('stream');
class MyDuplex extends Duplex{
// 可能是没关系 也可能是有关系
_read(){
this.push('hello');
this.push(null);
}
_write(chunk,encoding,clearBuffer){
console.log(chunk);
clearBuffer();
}
}
let my = new MyDuplex();
my.on('data',function (data) {
console.log(data);
})
my.write('hello')
my.write('hello')
// 转化流 用的比较多的地方 压缩
class MyTransfer extends Transform{
_transform(chunk,encoding,clearBuffer){ // 参数和可写流是一样的
let str = chunk.toString().toUpperCase();
this.push(str);
clearBuffer();
}
}
let my = new MyTransfer();
// 会箭头可读流中的内容 把内容写入到可写流中
process.stdin.pipe(my).pipe(process.stdout); // 应用场景压缩
