Node.js 如何操作二进制数据？

// 创建一个长度为 16 字节的 ArrayBuffer
const buffer = new ArrayBuffer(16)
console.log(buffer.byteLength) // 输出: 16

// 创建一个 8 字节的 ArrayBuffer
const buffer = new ArrayBuffer(8)

// 创建一个视图，将 buffer 视为一个包含 2 个 32 位有符号整数的数组
const int32View = new Int32Array(buffer)
console.log(int32View.length) // 输出: 2 (8 字节 / 4 字节每元素)

// 创建一个视图，将同一个 buffer 视为一个包含 8 个 8 位无符号整数的数组
const uint8View = new Uint8Array(buffer)
console.log(uint8View.length) // 输出: 8 (8 字节 / 1 字节每元素)

// 通过视图写入数据
int32View[0] = 256
console.log(int32View) // 输出: Int32Array(2) [256, 0]

// 通过另一个视图观察数据的变化
// 256 的二进制是 100000000，需要两个字节存储 (1, 0)
console.log(uint8View) // 输出: Uint8Array(8) [0, 1, 0, 0, 0, 0, 0, 0]

const buffer = new ArrayBuffer(12) // 创建一个 12 字节的 buffer
const view = new DataView(buffer)

// 在偏移量 0 处写入一个 16 位无符号整数 (256)
view.setUint16(0, 256)
// 在偏移量 4 处写入一个 32 位浮点数 (3.14)
view.setFloat32(4, 3.14)
// 在偏移量 9 处写入一个 8 位有符号整数 (-1)
view.setInt8(9, -1)

// 读取数据
console.log(view.getUint16(0)) // 输出: 256
console.log(view.getFloat32(4)) // 输出: 3.140000104904175 (浮点精度)
console.log(view.getInt8(9)) // 输出: -1

const buffer = new ArrayBuffer(2)
const view = new DataView(buffer)

// 使用大端序写入
view.setUint16(0, 0x1234, false) // false 代表大端序
console.log(view.getUint8(0).toString(16)) // 输出: "12"
console.log(view.getUint8(1).toString(16)) // 输出: "34"

// 使用小端序写入
view.setUint16(0, 0x1234, true) // true 代表小端序
console.log(view.getUint8(0).toString(16)) // 输出: "34"
console.log(view.getUint8(1).toString(16)) // 输出: "12"

const buf = Buffer.from("Hello")
console.log(buf instanceof Uint8Array) // true! Buffer 是 Uint8Array 的子类
console.log(buf.buffer instanceof ArrayBuffer) // true

// 1. 从字符串创建（默认 UTF-8 编码）
const buf1 = Buffer.from("Node.js 二进制")
console.log(buf1) // <Buffer 4e 6f 64 65 2e 6a 73 20 e4 ba 8c e8 bf 9b e5 88 b6>

// 2. 从字符串创建，并指定编码
const buf2 = Buffer.from("SGVsbG8gV29ybGQ=", "base64") // Base64 解码
console.log(buf2.toString()) // 输出: Hello World

// 3. 从字节数组创建
const buf3 = Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f])
console.log(buf3.toString()) // 输出: Hello

// 4. 从另一个 Buffer 或 TypedArray 创建（复制数据）
const buf4 = Buffer.from(buf3)
buf4[0] = 0x68 // 修改 buf4
console.log(buf3.toString()) // 原 buf3 不受影响，输出: Hello

// 创建一个长度为 10 字节，并用 0 填充的 Buffer
const buf1 = Buffer.alloc(10)
console.log(buf1) // <Buffer 00 00 00 00 00 00 00 00 00 00>

// 创建一个长度为 10 字节，并用 'A' (0x41) 填充的 Buffer
const buf2 = Buffer.alloc(10, "A")
console.log(buf2) // <Buffer 41 41 41 41 41 41 41 41 41 41>

// 创建一个长度为 10 字节，并用 0x42 填充的 Buffer
const buf3 = Buffer.alloc(10, 0x42)
console.log(buf3) // <Buffer 42 42 42 42 42 42 42 42 42 42>

// 创建一个长度为 10 字节的未初始化 Buffer
const buf = Buffer.allocUnsafe(10)
console.log(buf) // 输出可能类似于: <Buffer 00 00 00 00 00 00 00 00 00 00>
// 注意: 虽然这里看起来是 0，但请不要依赖这个行为！

// 安全使用场景：当你**立即**用新数据完全覆盖它时
const unsafeBuf = Buffer.allocUnsafe(1024)
// 立即用 fs.read 填充它，或立即用新数据覆盖
// fs.readSync(fd, unsafeBuf, 0, unsafeBuf.length, 0);

const buf = Buffer.alloc(8)

// 写入数据
buf.writeUInt32BE(0x12345678, 0) // 大端序写入 32 位无符号整数
buf.writeInt16LE(-1234, 4) // 小端序写入 16 位有符号整数

// 读取数据
console.log(buf.readUInt32BE(0).toString(16)) // 输出: 12345678
console.log(buf.readInt16LE(4)) // 输出: -1234

// 尝试读取超出 Buffer 边界会抛出异常
// console.log(buf.readUInt32BE(5)); // RangeError [ERR_OUT_OF_RANGE]

const buf = Buffer.alloc(256)

// 将字符串写入 Buffer (默认 UTF-8 编码)
const len = buf.write("Hello, 世界!", "utf8")
console.log(`写入了 ${len} 个字节`) // 输出: 写入了 14 个字节

// 将 Buffer 转换为字符串
console.log(buf.toString("utf8", 0, len)) // 输出: Hello, 世界!

// 只转换一部分
console.log(buf.toString("utf8", 0, 5)) // 输出: Hello

// 使用不同的编码
console.log(buf.toString("hex", 0, len)) // 输出: 48656c6c6f2c20e4b896e7958c21
console.log(buf.toString("base64", 0, len)) // 输出: SGVsbG8sIOS4lueVjCE=

const buf1 = Buffer.from("Buffer is a powerful tool!")
const buf2 = buf1.slice(0, 6) // 从索引 0 开始，截取 6 个字节

console.log(buf2.toString()) // 输出: Buffer

// 修改 buf2 会影响 buf1
buf2.write("MODIFY")
console.log(buf1.toString()) // 输出: MODIFY is a powerful tool!

const buf1 = Buffer.from("ABCDEFG")
const buf2 = Buffer.alloc(7)

// 将 buf1 的全部内容拷贝到 buf2
buf1.copy(buf2)
console.log(buf2.toString()) // 输出: ABCDEFG

// 修改 buf2 不会影响 buf1
buf2.write("abcdefg")
console.log(buf1.toString()) // 输出: ABCDEFG (原 buf1 未变)

const buf1 = Buffer.from("Hello, ")
const buf2 = Buffer.from("World!")
const buf3 = Buffer.from(" How are you?")

// 拼接多个 Buffer
const combined = Buffer.concat([buf1, buf2, buf3])
console.log(combined.toString()) // 输出: Hello, World! How are you?

// 可以指定总长度，如果计算错误可能导致数据截断或填充
const combined2 = Buffer.concat([buf1, buf2], 10)
console.log(combined2.toString()) // 输出: Hello, Wo (只取了前10个字节)

const text = "你好，Node.js!"

// UTF-8 编码 (默认, 可变长, 支持全球字符)
const utf8Buf = Buffer.from(text, "utf8")
console.log("UTF-8 长度:", utf8Buf.length) // 每个中文字符通常占3字节

// Base64 编码 (用于二进制数据文本化)
const base64Text = utf8Buf.toString("base64")
console.log("Base64:", base64Text)

// 从 Base64 解码回 Buffer
const decodedBuf = Buffer.from(base64Text, "base64")
console.log("解码后:", decodedBuf.toString("utf8"))

// Hex 编码 (每个字节用两个十六进制字符表示)
const hexText = utf8Buf.toString("hex")
console.log("Hex:", hexText)

const { Blob } = require("node:buffer")

// 1. 从字符串创建 Blob
const blob1 = new Blob(["Hello, ", "Node.js Blob!"], { type: "text/plain" })
console.log(blob1.size) // 输出: 20 (字节大小)
console.log(blob1.type) // 输出: text/plain

// 2. 从 Buffer 创建 Blob
const buf = Buffer.from("This is from a Buffer")
const blob2 = new Blob([buf])
console.log(blob2.size) // 输出: 19

// 3. 将 Blob 转换为文本 (异步操作)
blob1.text().then((text) => {
  console.log("Blob content:", text) // 输出: Hello, Node.js Blob!
})

// 4. 将 Blob 转换为 ArrayBuffer (异步操作)
blob2.arrayBuffer().then((ab) => {
  const view = new Uint8Array(ab)
  console.log("As Uint8Array:", view)
})

// 5. 创建 Blob 的切片 (同样返回新的 Blob，不拷贝数据)
const slice = blob1.slice(0, 5, "text/plain")
slice.text().then(console.log) // 输出: Hello

// 6. 使用 async/await 语法
async function readBlob(blob) {
  const text = await blob.text()
  console.log("Async read:", text)
}
readBlob(blob1)

const http = require("node:http")
const fs = require("node:fs")
const path = require("node:path")

const server = http.createServer((req, res) => {
  if (req.method === "POST" && req.url === "/upload") {
    const filename = `upload_${Date.now()}.bin`
    const filePath = path.join(__dirname, "uploads", filename)
    const writeStream = fs.createWriteStream(filePath)

    // req 是一个可读流，数据以 Buffer 块的形式到达
    req.on("data", (chunk) => {
      // 'chunk' 就是一个 Buffer
      console.log(`Received ${chunk.length} bytes of data.`)
      writeStream.write(chunk)
    })

    req.on("end", () => {
      writeStream.end()
      res.writeHead(200, { "Content-Type": "text/plain" })
      res.end("File uploaded successfully!")
    })

    req.on("error", (err) => {
      console.error("Upload error:", err)
      res.writeHead(500)
      res.end("Upload failed!")
    })
  } else {
    res.writeHead(404)
    res.end("Not Found")
  }
})

const PORT = process.env.PORT || 3000
server.listen(PORT, () => {
  console.log(`Server listening on port ${PORT}`)
})

const net = require("node:net")

// 假设协议格式：
// [4 bytes Magic Number: 0xDEADBEEF] [4 bytes Payload Length] [N bytes Payload]
const MAGIC_NUMBER = 0xdeadbeef

function parsePacket(socket) {
  let buffer = Buffer.alloc(0)

  socket.on("data", (data) => {
    // 将新接收到的数据拼接到缓冲区
    buffer = Buffer.concat([buffer, data])

    // 尝试解析一个完整的数据包
    while (buffer.length >= 8) {
      // 至少需要 8 字节头部
      const magic = buffer.readUInt32BE(0)
      const payloadLength = buffer.readUInt32BE(4)
      const totalLength = 8 + payloadLength

      // 检查魔数是否匹配
      if (magic !== MAGIC_NUMBER) {
        console.error("Invalid magic number:", magic.toString(16))
        socket.destroy()
        return
      }

      // 检查是否收到了足够的数据
      if (buffer.length < totalLength) {
        console.log("Packet incomplete, waiting for more data...")
        break // 跳出循环，等待更多数据
      }

      // 提取 Payload
      const payload = buffer.slice(8, totalLength)
      console.log("Received payload:", payload.toString())

      // 处理完一个包后，从缓冲区中移除它
      buffer = buffer.slice(totalLength)
    }
  })
}

const server = net.createServer((socket) => {
  console.log("Client connected")
  parsePacket(socket)

  socket.on("end", () => {
    console.log("Client disconnected")
  })
})

server.listen(8080, () => {
  console.log("Protocol parser server listening on port 8080")
})

const fs = require("node:fs/promises")

/**
 * 读取 PNG 文件的宽度和高度
 * PNG 文件格式以 8 字节签名开头，然后是 IHDR chunk，其中包含宽高信息。
 * IHDR chunk 结构: [Length: 4 bytes] [Type: "IHDR"] [Width: 4 bytes] [Height: 4 bytes] ...
 */
async function getPngDimensions(filePath) {
  try {
    // 只需要读取文件的前几十个字节即可找到 IHDR chunk
    const handle = await fs.open(filePath, "r")
    const buffer = Buffer.alloc(32) // 通常 IHDR chunk 很靠前
    await handle.read(buffer, 0, buffer.length, 0)
    await handle.close()

    // 检查 PNG 签名
    const pngSignature = Buffer.from([
      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a
    ])
    if (!buffer.slice(0, 8).equals(pngSignature)) {
      throw new Error("Not a valid PNG file")
    }

    let offset = 8 // 跳过签名
    while (offset < buffer.length - 4) {
      const length = buffer.readUInt32BE(offset)
      const type = buffer.slice(offset + 4, offset + 8).toString()

      if (type === "IHDR") {
        const width = buffer.readUInt32BE(offset + 8)
        const height = buffer.readUInt32BE(offset + 12)
        return { width, height }
      }
      offset += 12 + length // 移动到下一个 chunk
    }
    throw new Error("IHDR chunk not found in the first 32 bytes")
  } catch (error) {
    console.error("Error reading PNG:", error)
    return null
  }
}

// --- 使用示例 ---
;(async () => {
  const dimensions = await getPngDimensions("./example.png")
  if (dimensions) {
    console.log(`PNG image dimensions: ${dimensions.width} x ${dimensions.height}`)
  }
})()

console.log("Default pool size:", Buffer.poolSize) // 默认是 8 * 1024 (8KB)

// 当你使用 Buffer.alloc() 分配小于 poolSize 的 Buffer 时，
// Node.js 会尝试从预分配的内存池中获取，而不是每次都向 V8 申请。
// 这可以减少内存碎片和垃圾回收的频率。

// 示例：连续分配多个小 Buffer，它们可能来自同一个池
const buf1 = Buffer.alloc(1024)
const buf2 = Buffer.alloc(1024)
// buf1 和 buf2 的底层内存可能相邻，这有助于 CPU 缓存效率

let chunks = []
let totalLength = 0

socket.on("data", (chunk) => {
  chunks.push(chunk)
  totalLength += chunk.length

  // 假设已经知道一个完整消息的长度是 messageLength
  if (totalLength >= messageLength) {
    const fullMessage = Buffer.concat(chunks, messageLength)
    // 处理 fullMessage...

    // 处理完一个消息后，重置累加器
    const remainingData =
      totalLength > messageLength
        ? fullMessage.slice(messageLength) // 处理粘包
        : Buffer.alloc(0)
    chunks = remainingData.length > 0 ? [remainingData] : []
    totalLength = remainingData.length
  }
})

const original = Buffer.from("Hello World")
const realCopy = Buffer.from(original) // 这会创建一个新的、拥有独立内存的 Buffer

realCopy.write("Hi")
console.log(original.toString()) // 输出: Hello World (原 Buffer 未受影响)

const valueSize = 4 // 例如，一个 32 位整数
const offset = 10

if (offset + valueSize <= buffer.length) {
  const value = buffer.readUInt32BE(offset)
  // 处理 value
} else {
  // 数据不完整，等待更多数据或报告错误
}