node（三）buffer 文件 读取 写入

一、Buffer

- Buffer的结构和数组很像，操作的方法也和数组类似
- 数组中不能存储二进制的文件，而buffer就是专门用来存储二进制数据
- 使用buffer不需要引入模块，直接使用即可
- 在buffer中存储的都是二进制数据，但是在显示时都是以16进制的二位数形式显示
   buffer中每一个元素的范围是从00 - ff   0 - 255
   00000000 - 11111111

计算机 一个0 或一个1 我们称为1位（bit）

   8bit = 1byte（字节）
   1024byte = 1kb
   1024kb = 1mb
   1024mb = 1gb
   1024gb = 1tb

   buffer中的一个元素，占用内存的一个字节

- Buffer的大小一旦确定，则不能修改，Buffer实际上是对底层内存的直接操作

二、buffer简单方法

let b ="libufan";
let c="李不烦";
let buf=Buffer.from(b);//将字符串转换成buffer
let cnbuf=Buffer.from(c);

console.log(buf.length);//占用内存的大小 7
console.log(cnbuf.length);//9
console.log(c.length);//字符串的长度
console.log(buf);//<Buffer 6c 69 62 75 66 61 6e>
console.log(cnbuf);//<Buffer e6 9d 8e e4 b8 8d e7 83 a6>
//UTF-8编码：一个英文字符等于一个字节，一个中文（含繁体）等于三个字节。
// 中文标点占三个字节，英文标点占一个字节

// 创建指定大小的buffer
//buffer构造函数都是不推荐使用的 被弃用
let buf3=new Buffer(10);//创建10个字节的buffer
console.log(buf3.length);//10

let buf4=Buffer.alloc(6);
console.log(buf4.length);//6
console.log(buf4);//<Buffer 00 00 00 00 00 00>
// 通过索引操作buffer中的元素
buf4[0]=10;
buf4[1]=16;
buf4[2]=17;
buf4[3]=259;
buf4[4] = 0xaa;
console.log(buf4);//<Buffer 0a 10 11 03 aa 00>
//前三个元素没有问题，将十进制转换成二进制存入内存，然后以十六进制的形式显示出来
//但第四个数字就出现问题了，为什么十进制的259转换成十六进制03这么小的数，
// 因为259转换成二进制是 10 000 0011，有十位，一个字节由八位组成，所以系统自动保留后八位，
// 变成000 0011，转换成十六进制就是 03了。

console.log(buf4[4]);//170 只要数字在控制台或页面中输出一定是10进制

let buf5=Buffer.allocUnsafe(10);//创建一个指定大小的buffer，但是buffer中可能含有敏感数据
console.log(buf5);//<Buffer 28 0c 29 c1 81 01 00 00 58 e5>
//是不是有一个疑惑，刚创建的buf5为什么会有数据
// 因为allocUnsafe这个方法，在创建buf5时，会占用10个字节的内存，它不会将原来内存中的数据清除
// 所以若原来内存中保存有账号 密码敏感数据时，不安全 不建议使用此方法

三、fs

文件系统（File System）
   - 文件系统简单来说就是通过Node来操作系统中的文件
   - 使用文件系统，需要先引入fs模块，fs是核心模块，直接引入不需要下载

1.同步文件写入

/*
	文件系统（File System）
		- 文件系统简单来说就是通过Node来操作系统中的文件
		- 使用文件系统，需要先引入fs模块，fs是核心模块，直接引入不需要下载

同步文件的写入 步骤
1、打开文件 ：fs.openSync(path[, flags, mode])；
	- path 要打开文件的路径
 					- flags 打开文件要做的操作的类型
 						r 只读的
 						w 可写的
 					- mode 设置文件的操作权限，一般不传
				 返回值：
				 - 该方法会返回一个文件的描述符（fd）作为结果，我们可以通过该描述符来对文件进行各种操作

2、向文件里写入内容：fs.writeSync(fd, string[, position[, encoding]])
                     - fd 文件的描述符，需要传递要写入的文件的描述符
 					- string 要写入的内容
 					- position 写入的起始位置
 					- encoding 写入的编码，默认utf-8
3.保存并关闭文件
 				fs.closeSync(fd)
 					- fd 要关闭的文件的描述符
 */

let fs=require("fs");
let fd =fs.openSync("fs1.txt","w");// 没有文件创建文件
fs.writeSync(fd,"hah");
fs.closeSync(fd);

2.异步文件写入

/**
 异步文件写入
 fs.open(path, flags[, mode], callback) ；- 用来打开一个文件

 - callback 异步调用的方法，结果都是通过回调函数的参数返回的
 - 回调函数两个参数：
 err 错误对象，如果没有错误则为null
 fd  文件的描述符

 fs.write(fd, string[, position[, encoding]], callback)
 - 用来异步写入一个文件
 回调会接收到参数 (err, written, string)，其中 written 指定传入的字符串中被要求写入的字节数。 
 被写入的字节数不一定与被写入的字符串字符数相同。
 
 fs.close(fd, callback)
 - 用来关闭文件
 */
let fs=require("fs");
fs.open("fs2.txt","w",function (err,fd) {
    if (!err){
        console.log("异步打开成功")
        fs.write(fd,"libufan",function (err) {
            if (!err){
                console.log("异步写入成功");
                fs.close(fd,function (err) {
                    if (!err){
                        console.log("异步关闭了")
                    }
                    
                });
            } 
        });
    } else {
        console.log(err);
    }
});

3.简单文件写入

/**
 *  fs.writeFile(file, data[, options], callback)// 异步
 *  fs.writeFileSync(file, data[, options])//同步
 - file 要操作的文件的路径
 - data 要写入的数据
 - options 选项，可以对写入进行一些设置
 - callback 当写入完成以后执行的函数

 - flag
 r 只读
 w 可写
 a 追加
 */
let fs=require("fs");
fs.writeFile("C:\\Users\\liwy\\Desktop\\fs4.txt","woshi李不烦a",{flag:"a"},function (err) {
    if (!err){
        console.log("文件已保存");
    }
})

4.流式文件写入

/*
	同步、异步、简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出
 */
var fs = require("fs");

//流式文件写入
//创建一个可写流
/*
	fs.createWriteStream(path[, options])
		- 可以用来创建一个可写流
		- path，文件路径
		- options 配置的参数
 */
var ws = fs.createWriteStream("hello3.txt");

//可以通过监听流的open和close事件来监听流的打开和关闭
/*
	on(事件字符串,回调函数)
		- 可以为对象绑定一个事件

	once(事件字符串,回调函数)
		- 可以为对象绑定一个一次性的事件，该事件将会在触发一次以后自动失效

* */
ws.once("open",function () {
	console.log("流打开了~~~");
});

ws.once("close",function () {
	console.log("流关闭了~~~");
});

//通过ws向文件中输出内容
ws.write("把孤独当做晚餐");
ws.write("却难以下咽");

//关闭流
ws.end();

以上是文件的写入

5、简单文件的读取

/*
	1.同步文件读取
	2.异步文件读取
	3.简单文件读取
	 fs.readFile(path[, options], callback)
	 fs.readFileSync(path[, options])
	 	- path 要读取的文件的路径
	 	- options 读取的选项
	 	- callback回调函数，通过回调函数将读取到内容返回(err , data)
	 		err 错误对象
	 		data 读取到的数据，会返回一个Buffer

	4.流式文件读取
 */

var fs = require("fs");

var path = "C:/Users/lilichao/Desktop/笔记.mp3";

fs.readFile("an.jpg" , function (err , data) {
	if(!err){
		//console.log(data);
		//data,是读取到的数据，二进制数据，将data写入到文件中
		fs.writeFile("C:/Users/lilichao/Desktop/hello.jpg",data,function(err){
			if(!err){
				console.log("文件写入成功");
			}
		} );
	}
});

6.流文件读取

/*
	流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
 */

var fs = require("fs");

//创建一个可读流
var rs = fs.createReadStream("b.mp3");
//创建一个可写流
var ws = fs.createWriteStream("a.mp3");

//监听流的开启和关闭
rs.once("open",function () {
	console.log("可读流打开了~~");
});

rs.once("close",function () {
	console.log("可读流关闭了~~");
	//数据读取完毕，关闭可写流

	ws.end();
});

ws.once("open",function () {
	console.log("可写流打开了~~");
});

ws.once("close",function () {
	console.log("可写流关闭了~~");
});

//如果要读取一个可读流中的数据，必须要为可读流绑定一个data事件，data事件绑定完毕，它会自动开始读取数据
rs.on("data", function (data) {
	//console.log(data);
	//将读取到的数据写入到可写流中
	ws.write(data);
});

7.流文件处理 简单 推荐

/*
	流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
 */

var fs = require("fs");

//创建一个可读流
var rs = fs.createReadStream("C:/Users/lilichao/Desktop/笔记.mp3");
//创建一个可写流
var ws = fs.createWriteStream("b.mp3");

//pipe()可以将可读流中的内容，直接输出到可写流中
rs.pipe(ws);