Node.js 笔记03

一、buffer（缓存区）

Node里面的buffer，是一个二进制数据容器，数据结构类似与数组，专门用于Node中数据的存放

1. buffer的基本使用

历史上的使用方式：const buf1 = new Buffer(10)； 这种方式存在安全隐患，即分配到的内存可能还存储着旧数据。

Buffer中存储的都是二进制数据，但是在显示时都是以16进制的形式显示

Buffer.from(str) 将一个字符串转换为buffer
Buffer.alloc(size) 创建一个指定大小的Buffer
Buffer.allocUnsafe(size) 返回一个指定大小但未初始化的 Buffer。因为 Buffer 是未初始化的，可能包含旧数据。

为了使 Buffer 实例的创建更可靠，new Buffer() 构造函数已被废弃，建议使用 Buffer.from()、Buffer.alloc()、和 Buffer.allocUnsafe()

Buffer 的内容是未知的，可能包含敏感数据。使用 Buffer.alloc() 可以创建已初始化的 Buffer。

let str = '查看工作流';

let buffer = Buffer.from(str);
console.log(buffer);
console.log(buffer.length);
console.log(buffer.toString()); //输出以十进制输出
// <Buffer e6 9f a5 e7 9c 8b e5 b7 a5 e4 bd 9c e6 b5 81>
// 15
// 查看工作流

let buffer = Buffer.alloc(10);
console.log(buffer);//<Buffer 00 00 00 00 00 00 00 00 00 00>
buffer[0] = 10;
buffer[1] = 11;
buffer[2] = 0XFC;
buffer[9] = 9;
buffer[10] = 20; // 这个数不会被添加进去
console.log(buffer);//<Buffer 0a 0b fc 00 00 00 00 00 00 09>
console.log(buffer[1].toString(16)); // b
buffer.forEach((item,index)=>{
    console.log(index + ":" + item); //输出是以十进制输出
})
/*
0:10
1:11
2:252
3:0
4:0
5:0
6:0
7:0
8:0
9:9
*/

Buffer使用相关注意点:

Buffer的结构和数组很像，操作的方法也和数组类似
Buffer中是以二进制的方式存储数据的
Buffer是Node自带，不需要引入，直接使用即可

二、文件系统（File System）

1. 基本概念

在Node中，与文件系统的交互是非常重要的，服务器的本质就将本地的文件发送给远程的客户端, Node通过fs模块来和文件系统进行交互，该模块提供了一些标准文件访问API来打开、读取、写入文件，以及与其交互。

要使用fs模块，首先要从核心模块中加载： const fs = require("fs");

fs模块中所有的操作都有两种形式可供选择同步和异步。

同步文件系统会阻塞程序的执行，也就是除非操作完毕，否则不会向下执行代码。

异步文件系统不会阻塞程序的执行，而是在操作完成时，通过回调函数将结果返回。

2.文件操作

打开文件
fs.open(path, flags[, mode], callback)
fs.openSync(path, flags[, mode])

r 读取文件 , 文件不存在则出现异常
r+ 读写文件 , 文件不存在则出现异常
rs 在同步模式下打开文件用于读取
rs+ 在同步模式下打开文件用于读写
w 打开文件用于写操作 , 如果不存在则创建，如果存在则截断
wx 打开文件用于写操作 , 如果存在则打开失败
w+ 打开文件用于读写 , 如果不存在则创建 , 如果存在则截断
wx+ 打开文件用于读写 , 如果存在则打开失败
a 打开文件用于追加 , 如果不存在则创建
ax 打开文件用于追加 , 如果路径存在则失败
a+ 打开文件进行读取和追加 , 如果不存在则创建该文件
ax+ 打开文件进行读取和追加 , 如果路径存在则失败

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

// 1、引入模块
let fs = require('fs');
//2、打开文件
let fd = fs.openSync('a/1.txt','w');
console.log(fd);  //3

// 3、写入内容
fs.writeFileSync(fd,'nice day!');

// 4. 保存并退出
fs.closeSync(fd);

console.log('hello');
//3
// hello

//使用的同步方法，所以先打印3，再打印hello

异步方式：

// 1、引入模块
fs = require('fs');

// 2、打开文件
fs.open('a/2.txt','a',(err,fd)=>{
    // 2.1 判断是否有错
    if(!err){
        // 2.2 写入文件
        fs.writeFile(fd,'收费通知单
',(err)=>{
            // 2.3 文件写入成功
            if(!err){
                console.log('写入文件成功');
            }else{
                throw err;
            }
            // 2.4 关闭文件
            fs.close(fd,(err)=>{
                if(!err){
                    console.log('文件已经保存并关闭');
                }
            })
        })
    }else {
        throw err;
    }
});

// 3.其他操作
console.log('其他操作');

/*
-----------执行结果----------
其他操作
写入文件成功
文件已经保存并关闭
*/
// 因为是异步的，所以先执行的 其他操作，然后进行的写入操作等。

关于写入文件：

fs中提供了四种不同的方式将数据写入文件

简单文件写入

同步文件写入

异步文件写入

流式文件写入

1. 简单的文件写入
• fs.writeFile(file, data[, options], callback)
• fs.writeFileSync(file, data[, options])
参数：
– file 文件路径
– data 被写入的内容，可以是String或Buffer
– options 对象，包含属性（encoding、mode、flag）
– callback 回调函数

2. 同步文件写入
• fs.writeSync(fd, buffer, offset, length[, position])
• fs.writeSync(fd, data[, position[, encoding]])
参数
– fd 文件描述符，通过openSync()获取
– data 要写入的数据（String 或 Buffer）
– offset buffer写入的偏移量
– length 写入的长度
– position 写入的起始位置
– encoding 写入编码
注意： 要完成同步写入文件，先需要通过openSync()打开文件来获取一个文件描述符，然后在通过writeSync()写入文件。

3. 异步文件写入
• fs.write(fd, buffer, offset, length[, position], callback)
• fs.write(fd, data[, position[, encoding]], callback)
参数：
– fd 文件描述符
– data 要写入的数据（String 或 Buffer）
– offset buffer写入的偏移量
– length 写入的长度
– position 写入的起始位置
– encoding 写入编码
注意： 要使用异步写入文件，先需要通过open()打开文件，然后在回调函数中通过write()写入。


4.流式文件写入
  看下面的代码

写入流：

let fs = require('fs');

// 1 创建写入流
let ws = fs.createWriteStream('a/3.txt');
// console.log(ws);  // 这个打印出一大堆东西，flags ，path之类的

// 2 写入内容
ws.write('唯一号');
ws.write('姓名');
ws.write('证件类型');
ws.write('证件号码');

// 3 关闭通道
ws.end();

// 4 监听到通道打开
ws.once('open',()=>{
    console.log('通道打开');
});

// 5 监听关闭通道
ws.once('close',()=>{
    console.log('通道关闭');
});

/*
通道打开
通道关闭
*/

读取图片，写入图片文件：

读取音视频等文件，也是一样的，本质都是二进制。

let fs = require('fs');

fs.readFile('a/1.jpg',(err,data)=>{
    if(!err){
        // 写入文件
        fs.writeFile('a/2.jpg',data,(err)=>{
            if(!err){
                console.log('写入成功');
            }else {
                console.log('写入失败');
                throw err;
            }
        })
    }else {
        throw err;
    }
});

读入，写入流：

let fs = require('fs');

// 1. 创建读入和写入流
let rs = fs.createReadStream('a/1.wmv');
let ws = fs.createWriteStream('./22.wmv');

// 2. 写入
rs.on('data', (data) => {
    // console.log(data);
    ws.write(data);
});

// 4. 监听流的打开和关闭
ws.once('open', () => {
    console.log('写入流通道已经打开');
});

ws.once('close', () => {
    console.log('写入流通道已经关闭');
});

rs.once('open', () => {
    console.log('读入流通道已经打开');
});

rs.once('close', () => {
    console.log('读入流通道已经关闭');
    // 3. 关闭通道
    ws.end();
});

// 读入流通道已经打开
// 写入流通道已经打开
// 读入流通道已经关闭
// 写入流通道已经关闭

通过管道的方式读入和写入，还是管道比较好呀！！！

let fs = require('fs');

// 1. 创建读入和写入流
let rs = fs.createReadStream('a/1.jpg');
let ws = fs.createWriteStream('a/32.jpg');

// 创建管道
rs.pipe(ws);

// 4. 监听流的打开和关闭
ws.once('open', ()=>{
    console.log('写入流通道已经打开');
});

ws.once('close', ()=>{
    console.log('写入流通道已经关闭');
});

rs.once('open', ()=>{
    console.log('读入流通道已经打开');
});

rs.once('close', ()=>{
    console.log('读入流通道已经关闭');
});

// 读入流通道已经打开
// 写入流通道已经打开
// 读入流通道已经关闭
// 写入流通道已经关闭