3.文件操作

node.js的文件操作

文件读取

同步操作

//index.js文件
//文件操作第一步，引入fs模块
var fs = require('fs');
//readFileSync(files,options)
//files:文件路径,options代表选项，有两个参数  flag和encoding
//flag代表要执行的操作类型，encoding格式是对象，代表编码格式，可选
var fd = fs.readFileSync('hello.txt',{flag:'a',encoding:'utf-8'});
console.log(fd);    //输出结果  hello

//hello.txt文件
hello

异步操作

var fs = require('fs');
//readFile(files,[options],callback)
//callback:回调函数，格式callback(err,data)  err代表出错后的提示信息，data代表返回的数据
fs.readFile('hello.txt',{flag:'r',encoding:'utf-8'},function(err,data){
    if(err){
        console.log(err)
    }else{
        console.log(data)
    }
    console.log(456)
})
console.log(123)
//输出结果
// 123
// hello
// 456

缺点：一次只能读取一个文件，多读则要嵌套，结构复杂

对上述操作封装成一个函数

let fs = require('fs');
//定义一个函数 fsRead(){
function fsRead(path){
    //返回一个promise对象
    //promise(callback) funciton(res,rsj)   res:成功返回的值，rej失败返回的值
	return new Promise(function(res,rej){
        fs.readFile(path,{flag:'r',encoding:'utf-8'},function(err,data){
            if(err){
                //失败执行的内容
                rej(err);
            }else{
                //成功执行的内容
                res(data);
            };
        });
    }); 
};
//调用函数,返回一个promise对象
var w1 = fsRead('hello.txt');
//调用promise的then方法
w1.then(function(){
    //输出成功后后返回的值
    console.log(res)      //结果hello2
})

再次封装，使其实现按顺序读取多个文件

hello.txt文件

hello2

hello2.txt文件

hello3

hello3.txt文件

hello第三个文件

index.js文件

let fs = require('fs');
//定义一个函数 fsRead(){
function fsRead(path){
    //返回一个promise对象
    //promise(callback) funciton(res,rsj)   res:成功返回的值，rej失败返回的值
	return new Promise(function(res,rej){
        fs.readFile(path,{flag:'r',encoding:'utf-8'},function(err,data){
            if(err){
                //失败执行的内容
                rej(err);
            }else{
                //成功执行的内容
                res(data);
            };
        });
    }); 
};
//采用异步操作,创建一个函数，使其按顺序读取
async function ReadList(){
    var file = await fsRead('hello.txt');
 	console.log(file);   
    var file2 = await fsRead('hello2.txt');
    console.log(file2);   
    var file3 = await fsRead('hello3.txt');
    console.log(file3);   
}
ReadList();
//结果
// hello2
// hello3
// hello第三个文件

总之，同步效率低，异步效率高，使用异步，并进行封装,使用async方式

文件写入

var fs = require('fs');
//writeFile(files,content,[encoding],callback),异步操作，同步与read类似，不使用
//content:写入的内容
fs.writeFile('hello.txt','晚上吃啥？',{flag:'w',encoding:'utf-8'},function(err){
    if(err){
        console.log('写入内容出错')
    }else{
        console.log('写入内容成功')
    }
})

上述代码的问题，每一次写入都会覆盖掉之前写过的内容，修改上述代码,每写一次都会在下面进行追加而不是覆盖

fs.writeFile('hello.txt','晚上吃啥?\n',{flag:'a',encoding:'utf-8'},function(err))

对上述代码进行封转,使其按顺序执行多个文件

let fs = require(path,content);
//定义一个函数writefs
function writefs(){
    //返回一个Promise对象，res代表成功时的结果，rej代表失败返回的结果
     return new Promise(function(res,rej){
         fs.writeFile(path,content,{flag:'a',encoding:'utf-8'},function(err){
            if(err){
                //失败
                rej(err)
            }else{
                //成功
                res(err)
            }
        })
     })
}
async function writeList(){
    await writefs('1.txt','1\n');
    await writefs('1.txt','2\n');
    await writefs('1.txt','3\n');
}
writeList()
// 结果
// 会在同目录下创建一个名为1.txt的文件，在里面的内容如下
// 1
// 2
// 3

总结flag

1.flag:’w’ 写入 w:write
2.flag:’r’ 读取 r:read
3.flag:’a’ 追加 a:append

补充

buffer

使用原因：
1.数组不能进行二进制数据的操作
2.js数组不像java，python等语言效率高
3.buffer在内存空间开辟固定大小的内存，效率高

1.字符串与buffer之间的转换

//将字符串转成buffer对象
var str = 'helloworld'
let buf = Buffer.from(str)
console.log(buf)					//结果：<Buffer 68 65 6c 6c 6f 77 6f 72 6c 64>  二进制，但内容太长转换为16进制

//将buffer转换成字符串
console.log(buf.toString())			//结果：helloworld

2.创建缓冲区

//方式1
//开辟一个空的buffer(缓冲区)
//Buffer.alloc(size)     size代表缓存区的存放的数字的个数
let buf = Buffer.allloc(10)
console.log(buf)					//结果：<Buffer 00 00 00 00 00 00 00 00 00 00>
buf(0)=255
console.log(buf)					//结果：<Buffer ff 00 00 00 00 00 00 00 00 00>

buf(0)=256
consolr.log(buf)					//结果：<Buffer 00 00 00 00 00 00 00 00 00 00>   每个数字最大值是255，否则溢出


//方式2
//Buffer.allocUnsafe(size)     size代表缓存区的存放的数字的个数
let buf = Buffer.alllocUnsafe(10)
console.log(buf)					//结果：<Buffer 00 00 00 00 00 00 00 00 99 aa>

注：方式1安全但效率低，方式2不安全但效率高

目录操作

目录读取

//引入fs模块
let fs = require('fs');
//fs.readdir(path,callback)
//path:读取的文件路径，function(err,files)     err:读取错误的返回信息，files，读取的文件，格式是数组
fs.readdir('../03fs',function(err,files){
	if(err){
		console.log(err)
	}else{
        console.log(files)						//结果：{'buffer.js','delete.js','read.js'}
    }
})

实现内容的写入并输出

1.读取一个目录，并将其所有目录名输出到同目录下另一个文件all.txt中

test.js文件

let fs = require('fs');
//将上述fsWrite复制到一个新的文件lcf中，将其引入
let fsWrite = require('./lcf');
const txtPath = 'all.txt';
fs.readdir('../03fs',function(err,files){
	if(err){
		console.log(err);
	}else{
        //循环里面的内容,注意是async异步函数
        files.forEach(async function(filename,i)){
        	await fsWrite(txtPath,filename);
		}
 	}
})

2.读取一个目录，并将其所有文件里的所有信息输出到同目录下另一个文件all.txt中

test.js文件

let fs = require('fs');
//将上述fsWrite,fsRead复制到一个新的文件lcfs中，将其引入
let {fsWrite,fsRead} = require('./lcfs');
const txtPath = 'all.txt';
fs.readdir('../03fs',function(err,files){
	if(err){
		console.log(err);
	}else{
        //循环里面的内容,注意是async异步函数
        files.forEach(async function(filename,i)){
			let content = await faRead('../03fs/'+filename);
        	await fsWrite(txtPath,content);
		}
 	}
})

目录删除

//引入fs模块
let fs = require('fs');
//fs.rmdir(path,callback)
//path:读取的文件路径，function(err,files)     err:读取错误的返回信息，files，读取的文件，格式是数组
fs.rmdir('../03fs',function(err,files){
	if(err){
		console.log(err)
	}else{
        consolr.log(files)						//结果：{'buffer.js','delete.js','read.js'}
    }
})

node中的输入与输出

//创建readline包
let readline = require('readline');
//实例化接口对象
var r1 = readline.createInterface({
    //创建一个输入进程
    input:process.stdin,
    //创建一个输出进程
    output.process.stdout
})
//设置r1提问事件
re.question('今晚吃啥？',function(answer){
    console.log('答复：'+answer)
    //回复完之后关闭接口对象
    r1.close()
})
//结果
// 今晚吃啥：123
// 答复：123

文件流

写入流

let fs = require('fs');
//1.创建写入流
//fs.createWriteStream(file,[options]),返回的是一个对象
let ws = fs.createWriteStream('hello.txt',{flag:'w',encoding:'utf-8'});
//监听文件打开事件
ws.on('open',function(){
    console.log('文件打开');
})
//监听文件关闭事件
ws.on('close',function(){
    console.log('文件写入完成，关闭');
})
//文件流写入
ws.write('hello1 ',function(err){
    if(err){
        console.log(err);
    }else{
        console.log('内容1流入完成');
    }
})
ws.write('hello2',function(err){
    if(err){
        console.log(err);
    }else{
        console.log('内容2流入完成');
    }
})
//文件写入成功
ws.end(function(){
    console.log('文件写入关闭');
})
//结果
// 文件打开
// 内容1流入完成
// 内容2流入完成
// 文件写入关闭
// 文件写入完成，关闭       
// 在hello.txt文件中有：hello1 hello2

读入流

let fs = require('fs');
//1.创建读入流
//fs.createReadStream(file,[options]),返回的是一个对象
let rs = fs.createReadStream('hello.txt',{flag:'r',encoding:'utf-8'});
//监听文件打开事件
rs.on('open',function(){
    console.log('读取文件已打开');
})
//监听文件关闭事件
rs.on('close',function(){
    console.log('读取流结束');
})
//每一批数据流入完成
rs.on('data',function(chunk){
	console.log(chunk);
    //console.log(chunk.legth)    //每一批流入的数据最大是65536  
})
//结果
// 读取文件已打开
// hello1 hello2
// 读取流结束    

实现对文件的复制

let fs = require('fs');
//1.创建写入流
//fs.createReadStream(file,[options]),返回的是一个对象
let rs = fs.createReadStream('hello.txt',{flag:'r',encoding:'utf-8'});
let ws = fs.createWriteStream('1.txt',{flag:'r',encoding:'utf-8'});
//监听文件打开事件
rs.on('open',function(){
    console.log('读取文件已打开');
})
//监听文件关闭事件
rs.on('close',function(){
    ws.end();
    console.log('读取流结束，关闭');
})
//每一批数据流入完成
rs.on('data',function(chunk){
	console.log(chunk);
    ws.write(chunk,function(err){
        if(err){
            console.log(err)
        }else{
            console.log('单批输入流完成')
        }
    })
})

管道流实现对文件的复制

let fs = require('fs');
//1.创建写入流
//fs.createReadStream(file,[options]),返回的是一个对象
let rs = fs.createReadStream('hello.txt',{flag:'r',encoding:'utf-8'});
let ws = fs.createWriteStream('1.txt',{flag:'r',encoding:'utf-8'});
//监听文件打开事件
rs.on('open',function(){
    console.log('读取文件已打开');
})
//监听文件关闭事件
rs.on('close',function(){
    console.log('文件写入完成，关闭');
})
//管道流，对一个文件读出并写入
rs.pipe(ws);