node.js—buffer缓冲模块

Buffer对象

0.准备知识
- 0.1计算机只能识别0和1(因为计算机只认识通电和断电两种状态),
- 0.2所有存储在计算机上的数据都是0和1组成的(数据越大0和1就越多)
- 0.3计算机中的度量单位
  - 1 B(Byte字节) = 8 bit(位)
  - 00000000 就是一个字节
  - 111111111 也是一个字节
  - 10101010 也是一个字节
  - 任意8个 0或1的组合都是一个字节
  - 1 KB = 1024 B
  - 1 MB = 1024KB
  - 1 GB = 1024MB
1.什么是Buffer?
- Buffer是NodeJS全局对象上的一个类,是一个专门用于存储字节数据的类
- NodeJS提供了操作计算机底层API,而计算机底层只能识别0和1,所以就提供了一个专门用于存储字节数据的类
2.如何创建一个Buffer对象
- 2.1创建一个指定大小的Buffer
  - 格式Buffer.alloc(size[, fill[, encoding]])
    - 示例：Buffer.alloc(5)
- 2.2根据数组/字符串创建一个Buffer对象
  - 格式Buffer.from(string[, encoding])
    - 示例：Buffer.from('abc')
3.Buffer对象本质
- 本质就是一个数组

Buffer实例方法

1.将二进制数据转换成字符串
- 格式：buf.toString([encoding[, start[, end]]])
  - encoding: 要使用的字符编码,默认值： 'utf8'。
  - start: 开始解码的字节偏移量,默认值： 0。
  - end: 停止解码的字节偏移量（不包括）,默认值： buf.length。
  - 示例：buf.toString()
2.往Buffer中写入数据
- 格式：buf.write(string[, offset[, length]][, encoding])
  - string: 要写入 buf 的字符串。
  - offset: 开始写入 string 之前要跳过的字节数,默认值: 0。
  - length: 要写入的字节数,默认值: buf.length - offset
  - encoding: string的字符编码,默认值: 'utf8'。
  - 示例：

let buff = Buffer.alloc(5);
buff.write('abcdef');
console.log(buff.toString());  // abcde

3.从指定位置截取新Buffer
- 格式：buf.slice([start[, end]])
  - start: 新Buffer开始的位置。默认值: 0。
  - end: 新Buffer结束的位置（不包含）

let buff = Buffer.alloc(5);
buff.write('abcdef');
console.log(buff.toString().slice(2,4));  // cd

Buffer静态方法

1.检查是否支持某种编码格式
- Buffer.isEncoding(encoding)

let buff = Buffer.isEncoding('utf-8');
console.log(buff);   // true

2.检查是否是Buffer类型对象
- Buffer.isBuffer(obj)

// let obj = {};  // 这么写是false
let obj = Buffer.alloc(5);  // 输出是true
let buff = Buffer.isBuffer(obj);
console.log(buff);

3.获取Buffer实际字节长度
- Buffer.byteLength(string[, encoding])
- ==注意点==: 一个汉字占用三个字节

let buff1 = Buffer.from('abc');
let buff2 = Buffer.from('微双');
console.log(buff1.length);   // 3
console.log(buff2.length);   // 6

4.合并Buffer中的数据
- Buffer.concat(list[, totalLength])

let buff1 = Buffer.from('abc');
let buff2 = Buffer.from('123');
let res = Buffer.concat([buff1,buff2]);
console.log(res.toString());  // abc123

路径Path

1.路径模块(path)
- 封装了各种路径相关的操作,和Buffer一样,NodeJS中的路径也是一个特殊的模块
- 不同的是Buffer模块已经添加到Global上了, 所以不需要手动导入
- 而Path模块没有添加到Global上,所以使用时需要手动导入
2.获取路径的最后一部分(最后斜杠后面的部分)
- path.basename(path[, ext])

let path = require('path');
// let res = path.basename('C:\\study\\node\\node\\index.html');  // index.html
// let res = path.basename('C:\\study\\node\\node');  // node
let res = path.basename('C:\\study\\node\\node\\index.html','.html');  //index
console.log(res);

3.获取路径（最后斜杠前面的所有路径）
- path.dirname(path)

let path = require('path');
// let res = path.dirname('C:\\study\\node\\node\\index.html');  // C:\study\node\node
let res = path.dirname('C:\\study\\node\\node');  // C:\study\node
console.log(res);

4.获取扩展名称（路径末尾的扩展名，若没有则返回空）
- path.extname(path)

let path = require('path');
// let res = path.extname('C:\\study\\node\\node\\index.html'); // .html
let res = path.extname('C:\\study\\node\\node'); // 空
console.log(res);

5.判断是否是绝对路径
- path.isAbsolute(path)
- 注意点（区分操作系统）
  - 在Linux操作系统中 ==/ 开头==就是绝对路径，并且路径的分隔符是 ==左斜杠 /==
  - 在Windows操作系统中 ==盘符开头== 就是绝对路径，并且路径的分隔符是 ==右斜杠\\==
  - 特殊情况，可能是新规定：==示例中，\\开头，没有盘符，依旧是true==

let path = require('path');
// let res = path.isAbsolute('C:\\study\\node\\node\\index.html');  // true
// let res = path.isAbsolute('\\study\\node\\node\\index.html');  // true
let res = path.isAbsolute('study\\node\\node\\index.html');  // false
console.log(res);

6.获取当前操作系统变量路径分隔符
- path.sep （windows是\ Linux是/）
  - 如果是在Linux操作系统中运行那么获取到的是左斜杠 /
  - 如果是在Windows操作系统中运行那么获取到的是右斜杠 \

let path = require('path');
console.log(path.sep);  //  \

7.获取当前路径环境路径分隔符
- path.delimiter (windows中使用; linux中使用:)
- 区分操作系统
  - 如果是在Windows操作系统中运行那么获取到的是 ;
  - 如果是在Linux操作系统中运行那么获取到的是 :

let path = require('path');
console.log(path.delimiter);   // ;

1.路径的格式化处理(相互转换)
- path.parse() string->obj
  - 将路径转换成对象
- path.format() obj->string
  - 将对象转换成路径

// 1.path.parse()
let path = require('path');
let obj = path.parse('C:\\study\\node\\node\\index.html');
console.log(obj);  /* 输出{
  root: 'C:\\',
  dir: 'C:\\study\\node\\node',
  base: 'index.html',
  ext: '.html',
  name: 'index'
} */

// 2.path.format()
let path = require('path');
let obj = {
    root: 'C:\\',
    dir: 'C:\\study\\node\\node',
    base: 'index.html',
    ext: '.html',
    name: 'index'
};
console.log(path.format(obj));  // C:\study\node\node\index.html

2.拼接路径
- path.join([...paths])
  - 1.没有斜杠\，该方法会自动添加
  - 2.有斜杠\或者有.\都是前后参数拼接
  - 3.斜杠前面有不止一个点.，那么会自动根据前面的参数生成的路径,去到上一级或上一级以上的路径

let path = require('path');

// let res = path.join('C:\\study\\node','index.html'); // C:\study\node\index.html
// let res = path.join('C:\\study\\node','\\index.html'); // C:\study\node\index.html
// let res = path.join('C:\\study\\node','.\\index.html'); // C:\study\node\index.html
let res = path.join('C:\\study\\node','..\\index.html'); // C:\study\index.html
console.log(res);

3.规范化路径
- path.normalize(path)

let path = require('path');
let res = path.normalize('C:\\study\\\\node\\node\\\\index.html'); //C:\study\node\node\index.html
console.log(res);

4.计算相对路径
- 根据第一个路径找到第二个路径的相对路径
- path.relative(from, to)

let path = require('path');
// let res = path.relative('C:\\study\\node\\node','C:\\study\\node\\index.html');  // ..\index.html
let res = path.relative('C:\\study\\node\\node','C:\\study\\node\\node\\index.html');  // index.html
console.log(res);

5.解析路径
- path.resolve([...paths])
  - 注意点: ==如果后面的参数是绝对路径, 那么前面的参数就会被忽略==

let path = require('path');
// let res = path.resolve('C:\\study\\node\\node','C:\\study\\node\\index.html');  // C:\study\node\index.html
let res = path.relative('\\study\\node','\\index.html');  // ..\..\index.html
console.log(res);