node.js基础（二）

Buffer(缓冲区)

• 从结构上看Buffer非常像一个数组，它的元
素为16进制的两位数。
• 实际上一个元素就表示内存中的一个字节。
• 实际上Buffer中的内存不是通过JavaScript
分配的，而是在底层通过C++申请的。
• 也就是我们可以直接通过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.allocUnsafe(size) 创建一个指定大小的buffer，但是buffer中可能含有敏感数据
/var buf3 = Buffer.allocUnsafe(10);
console.log(buf3);/

/*
Buffer.from(str) 将一个字符串转换为buffer
Buffer.alloc(size) 创建一个指定大小的Buffer
Buffer.alloUnsafe(size) 创建一个指定大小的Buffer，但是可能包含敏感数据
buf.toString() 将缓冲区中的数据转换为字符串
*/

var str = "Hello 尚硅谷";

//将一个字符串保存到buffer中
var buf = Buffer.from(str);

//console.log(buf.length); //占用内存的大小
//console.log(str.length);//字符串的长度
//console.log(buf);

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

//创建一个10个字节的buffer
var buf2 = Buffer.alloc(10);
//通过索引，来操作buf中的元素
buf2[0] = 88;
buf2[1] = 255;
buf2[2] = 0xaa;
buf2[3] = 255;

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

/*for(var i=0 ; i<buf2.length ; i++){
	console.log(buf2[i]);
}*/


var buf4 = Buffer.from("我是一段文本数据");

console.log(buf4.toString());

Buffer的操作
• 使用Buffer保存字符串
• 创建指定大小的Buffer对象
let str = “你好 atguigu”;
let buf = Buffer.from(str , “utf-8”);
let buf3 = Buffer.alloc(1024*8)

Buffer的转换
• Buffer与字符串间的转换
– 支持的编码: • ASCII、UTF-8、UTF-16LE/UCS-2、Base64、
Binary、Hex
– 字符串转Buffer
• Buffer.from(str , [encoding]);
– Buffer转字符串
• buf.toString([encoding] , [start] , [end]);

写入操作

• 向缓冲区中写入字符串
– buf.write(string[, offset[, length]][, encoding])
• 替换指定索引位置的数据
– buf[index] • 将指定值填入到缓冲区的指定位置
– buf.fill(value[, offset[, end]][, encoding])

读取操作

• 将缓冲区中的内容，转换为一个字符串返回
– buf.toString([encoding[, start[, end]]])
• 读取缓冲区指定索引的内容
– buf[index]

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

fs（文件系统）

• 在Node中，与文件系统的交互是非常重要
的，服务器的本质就将本地的文件发送给
远程的客户端
• Node通过fs模块来和文件系统进行交互
• 该模块提供了一些标准文件访问API来打开、
读取、写入文件，以及与其交互。
• 要使用fs模块，首先需要对其进行加载
– const fs = require(“fs”);

同步文件的写入

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

2.向文件中写入内容
fs.writeSync(fd, string[, position[, encoding]])
- fd 文件的描述符，需要传递要写入的文件的描述符
- string 要写入的内容
- position 写入的起始位置
- encoding 写入的编码，默认utf-8

3.保存并关闭文件
fs.closeSync(fd)

• fd 要关闭的文件的描述符

var fs = require("fs");

//打开文件
var fd = fs.openSync("hello.txt" , "w");

//向文件中写入内容
fs.writeSync(fd , "今天天气真不错~~~", 2);

//关闭文件
fs.closeSync(fd);

console.log("程序向下执行~~~");

异步文件写入

fs.open(path, flags[, mode], callback)
- 用来打开一个文件
- 异步调用的方法，结果都是通过回调函数的参数返回的
- 回调函数两个参数：
err 错误对象，如果没有错误则为null
fd 文件的描述符
fs.write(fd, string[, position[, encoding]], callback)
用来异步写入一个文件

fs.close(fd, callback)
用来关闭文件

//引入fs模块
var fs = require("fs");


//打开文件
fs.open("hello2.txt","w",function (err , fd) {
	//判断是否出错
	if(!err){
		//如果没有出错，则对文件进行写入操作
		fs.write(fd,"这是异步写入的内容",function (err) {
			if(!err){
				console.log("写入成功~~");
			}
			//关闭文件
			fs.close(fd , function (err) {
				if(!err){
					console.log("文件已关闭~~~");
				}
			});
		});
	}else{
		console.log(err);
	}
});

console.log("程序向下执行~~~");

简单文件写入

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

• file 要操作的文件的路径

  • data 要写入的数据

  • options 选项，可以对写入进行一些设置

  • callback 当写入完成以后执行的函数

  • flag
    r 只读
    w 可写
    a 追加

//引入fs模块
var fs = require("fs");

/*fs.writeFile("hello3.txt","这是通过writeFile写入的内容",{flag:"r+"} , function (err) {
	if(!err){
		console.log("写入成功~~~");
	}else{
		console.log(err);
	}
});*/


//C:\Users\lilichao\Desktop\hello.txt
//C:\\Users\\lilichao\\Desktop\\hello.txt

fs.writeFile("C:/Users/lilichao/Desktop/hello.txt","这是通过writeFile写入的内容",{flag:"w"} , function (err) {
	if(!err){
		console.log("写入成功~~~");
	}else{
		console.log(err);
	}
});

流式文件：

可以通过监听流的open和close事件来监听流的打开和关闭
on(事件字符串,回调函数)

• 可以为对象绑定一个事件

once(事件字符串,回调函数)

• 可以为对象绑定一个一次性的事件，该事件将会在触发一次以后自动失效

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

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


var ws = fs.createWriteStream("hello3.txt");


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

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

//通过ws向文件中输出内容
ws.write("通过可写流写入文件的内容");
ws.write("今天天气真不错");
ws.write("锄禾日当午");
ws.write("红掌拨清清");
ws.write("清清真漂亮");

//关闭流
ws.end();

简单文件读取：

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写入到文件中
		fs.writeFile("C:/Users/lilichao/Desktop/hello.jpg",data,function(err){
			if(!err){
				console.log("文件写入成功");
			}
		} );
	}
});

流式文件读取

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

var fs = require("fs");

//创建一个可读流
var rs = fs.createReadStream("C:/Users/lilichao/Desktop/笔记.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);
});

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

var fs = require("fs");

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

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

同步和异步调用

• fs模块中所有的操作都有两种形式可供选择
同步和异步。 • 同步文件系统会阻塞程序的执行，也就是
除非操作完毕，否则不会向下执行代码。
• 异步文件系统不会阻塞程序的执行，而是
在操作完成时，通过回调函数将结果返回。

node
包（package）
- 将多个模块组合为一个完整的功能，就是一个包
- 包结构
bin
- 二进制的可执行文件，一般都是一些工具包中才有
lib
- js文件
doc
- 文档
test
- 测试代码
package.json
- 包的描述文件

package.json
- 它是一个json格式的文件，在它里面保存了包各种相关的信息
name 包名
version 版本
dependencies 依赖
main 包的主要的文件
bin 可执行文件

npm（Node Package Manager node的包管理器）
- 通过npm可以对node中的包进行上传、下载、搜索等操作
- npm会在安装完node以后，自动安装
- npm的常用指令
npm -v 查看npm的版本
npm version 查看所有模块的版本
npm init 初始化项目（创建package.json）
npm i/install 包名 安装指定的包
npm i/install 包名 --save 安装指定的包并添加依赖
npm i/install 包名 -g 全局安装（一般都是一些工具）
npm i/install 安装当前项目所依赖的包
npm s/search 包名 搜索包
npm r/remove 包名 删除一个包

文件系统（File System）
- Buffer（缓冲区）
- Buffer和数组的结构的非常类似，Buffer是用来存储二进制数据的
- Buffer的方法
- Buffer.from(字符串)
- 将一个字符串中内容保存到一个buffer中
- buf.toString()
- 将buffer转换为一个字符串
- Buffer.alloc(size)
- 创建一个指定大小的buffer对象
- Buffer.allocUnsafe(size)
- 创建一个指定大小的buffer对象，可以包含敏感数据

fs模块
- 在Node通过fs模块来对系统中的文件进行操作，fs模块是node中已经继承好了，不需要在使用npm下载，直接引入即可
- 引入fs
var fs = require(“fs”);
- fs模块中的大部分操作都提供了两种方法，同步方法和异步方法
同步方法带sync
异步方法没有sync，都需要回调函数

写入文件
1.同步写入
2.异步写入
3.简单写入
4.流式写入

读取文件
1.同步读取
2.异步读取
3.简单读取
4.流式读取

方法
- 打开文件
fs.open(path, flags[, mode], callback)
fs.openSync(path, flags[, mode])
读写文件
fs.write(fd, string[, position[, encoding]], callback)
fs.writeSync(fd, string[, position[, encoding]])

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

关闭文件
fs.close(fd,callback)
fs.closeSync(fd);

简单文件读取和写入
fs.writeFile(file, data[, options], callback)
fs.writeFileSync(file, data[, options])

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

流式文件读取和写入
- 流式读取和写入适用于一些比较大的文件
fs.createWriteStream(path[, options])
fs.createReadStream(path[, options])