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);   

---