buffer

buffer

• buffer可以存储数据,可以和字符串相互转化
• 读取操作不指定编码时,读取结果是buffer类型
• buffer是16进制的
• buffer代表的是内存，一旦声明好，不能去扩展(随意更改大小);如果要更改buffer的大小，可以截取内存（改小）或者创造一个大的内存空间，将数据拷贝过去(改大)

常用api

ps: Buffer为类上的方法， buffer为实例方法

• Buffer.alloc 和 Buffer.allocUnsafe

  • tips:
    1. Buffer 模块预先分配了大小为 Buffer.poolSize 的内部 Buffer 实例作为池，用于快速分配使用 Buffer.allocUnsafe()、Buffer.from(array)、Buffer.concat() 创建的新 Buffer 实例，仅当 size 小于或等于 Buffer.poolSize >> 1（Buffer.poolSize 除以二再向下取整）时才使用弃用的 new Buffer(size) 构造函数
    2. Buffer.alloc(size, fill) 永远不会使用内部的 Buffer 池，而 Buffer.allocUnsafe(size).fill(fill) 会在 size 小于或等于 Buffer.poolSize 的一半时使用内部的 Buffer 池

  const buf1 = Buffer.alloc(3) // <Buffer 00 00 00>
  const buf2 = Buffer.allocUnsafe(3) // <Buffer 58 ad f9>  存储的内容是随机的
  

• Buffer.compare

  • 返回值1(小于) 0(相等) -1(大于)

  const buf1 = Buffer.from('1234')
  const buf2 = Buffer.from('0123')
  const arr = [buf1, buf2]
  console.log(arr.sort(Buffer.compare)) // [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
  

• Buffer.alloc(size[, fill])

  • 分配 size 个字节的新 Buffer,fill为填充内容

  const buf = Buffer.alloc(3) // <Buffer 00 00 00>
  
  const buf2 = Buffer.alloc(3, 'abcdd') // <Buffer 61 62 63>
  

• Buffer.from()

  • Buffer.from(array | arrayBuffer | buffer | string)

  // 传入array
  console.log(Buffer.from([1,2,3])) // 使用 0 – 255 范围内的字节 array 分配新的 Buffer。 该范围之外的数组条目将被截断以符合它
  
  // 传入buffer
     // 将传入的 buffer 数据复制到新的 Buffer 实例上
  const buf1 = Buffer.from('buffer')
  const buf2 = Buffer.from(buf1)
  buf1[0] = 0x61
  console.log(buf1.toString()) // auffer
  console.log(buf2.toString()) // buffer
  
  // 传入string
  console.log(Buffer.from('abc')) // 创建包含 string 的新 Buffer
  

• buffer.toString([encoding])

  • 默认编码为utf-8，支持base64、hex等

  const buf = Buffer.from([65])
  buf.toString('utf-8') // A   
  

• buffer.length

  const buf = Buffer.from('张三')
  console.log(buf.length) // 返回字节数！！！   6 
  

• buffer.slice(length)

  const buf3 = Buffer.from('张三')
  console.log(buf3.slice(3).toString()) // 三 (汉字占3个字节)
  

• Buffer.copy(target[, targetStart])

  • 将数据从buf区域复制到target区域

  const buf1 = Buffer.allocUnsafe(26)
  const buf2 = Buffer.allocUnsafe(26).fill('!')
  for(let i = 0; i < 26; i++){
    buf1[i] = i + 97
  }
  console.log(buf1)
  buf1.copy(buf2, 8, 16, 20) // 将buf1字节16到19复制到buf2中，从buf2的字节8开始 （左闭又开区间！！！）
  console.log(buf2.toString()) // !!!!!!!!qrst!!!!!!!!!!!!!!
  

• buffer.concat(list[, totalLength])

  • 将list中的所有buffer连接在一起，返回新的Buffer

  const buf1 = Buffer.alloc(10)
  const buf2 = Buffer.alloc(14)
  const buf3 = Buffer.alloc(8) 
  const buf4 = Buffer.concat([buf1, buf2, buf3])
  

• Buffer.isBuffer(obj)

  console.log(Buffer.isBuffer(Buffer.alloc(1))) // true
  console.log(Buffer.isBuffer(Buffer.from('foo'))) // true
  console.log(Buffer.isBuffer('abc')) // false
  

• example

  // 创建大小为3个字节的内存
  let buf1 = Buffer.alloc(3);
  
  // 如果数组中的内容不能识别，则认为是0
  let buf2 = Buffer.from([-2, 3, 3]); // <Buffer fe 03 03>
  console.log(buf2);
  
  const buf3 = Buffer.from('张三');
  console.log(buf3) // e5 bc a0 e4 bc 9f e9 b9 8f
  console.log(buf3.length) // length返回的是字节的大小！
  console.log(buf3[buf3.length - 1]) // 143(8f)  会将十六进制转为十进制
  console.log(buf3.toString('base64'));
  console.log(buf3.toString('utf-8'));
  
  const buf4 = Buffer.from([1, 2, 3, 4])
  const buf5 = buf4.slice(0, 1) 
  buf5[0] = 100 //因为buffer中存的都是引用 修改buf5,buf4中的值会改变!!!
  console.log(buf4)
  console.log(buf5)
  // 原理与下相同 例1
  let arr = [
    [1], 2, 3
  ]
  let arr1 = arr.slice(0, 1)
  arr1[0][0] = 100
  console.log(arr1) // [ [ 100 ] ]
  console.log(arr) // [ [ 100 ], 2, 3 ]
  // 例2
  const obj = [{
    a: 1
  }, 2]
  const newObj = obj.slice(0, 1)
  newObj[0].a = 100
  console.log(newObj)
  console.log(obj)
  
  // Buffer.copy(target, targetStart, sourceStart, sourceEnd)
  Buffer.prototype.copy = function (target, targetStart, sourceStart = 0, sourceEnd = this.length) { // 参数也可以访问到this
    for (let i = sourceStart; i < sourceEnd; i++) {
      target[targetStart++] = this[i]
    }
  }
  Buffer.concat = function (bufferList, len) {
    if (!len) {
      len = bufferList.reduce((a, b) => a + b.length, 0)
    }
    const newBuffer = Buffer.alloc(len)
    let offset = 0
    for (let i = 0; i < bufferList.length; i++) {
      let buf = bufferList[i]
      if (Buffer.isBuffer(buf)) { // 判断是否为Buffer
        bufferList[i].copy(newBuffer, offset)
        offset += buf.length
      }
    }
    return newBuffer
  }
  const buf6 = Buffer.from('张')
  console.log(buf6[3], 'buf6')
  const buf7 = Buffer.from('三')
  const buff = Buffer.alloc(buf6.length + buf7.length)
  buf6.copy(buff, 0, 0, 3) // 注意这里是3  左闭右开区间!!!
  buf7.copy(buff, 3, 3, 6)
  console.log(buff.toString())
  console.log(Buffer.concat([buf6, buf7, 'abc'], 12).toString())