如何在TS环境下模拟nodejs的buffer 类型，全API

在 TypeScript 环境下，可以使用 `Uint8Array` 类型来模拟 Node.js 中的 `Buffer` 类型，因为 `Uint8Array` 也是用来处理二进制数据的。

以下是一个示例，展示如何在 TypeScript 中使用 `Uint8Array` 类型来模拟 Node.js 中的 `Buffer` 类型，并且包含了一些常用的 API：

class MyBuffer {
  private data: Uint8Array;

  constructor(arg: number | number[] | ArrayBuffer | SharedArrayBuffer | ArrayBufferView | string) {
    if (typeof arg === "number") {
      this.data = new Uint8Array(arg);
    } else if (Array.isArray(arg)) {
      this.data = new Uint8Array(arg);
    } else if (arg instanceof ArrayBuffer) {
      this.data = new Uint8Array(arg);
    } else if (arg instanceof SharedArrayBuffer) {
      this.data = new Uint8Array(arg);
    } else if (ArrayBuffer.isView(arg)) {
      this.data = new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength);
    } else if (typeof arg === "string") {
      this.data = new TextEncoder().encode(arg);
    } else {
      throw new TypeError("Invalid argument");
    }
  }

  static alloc(size: number, fill?: number): MyBuffer {
    const buf = new MyBuffer(size);
    if (typeof fill === "number") {
      buf.fill(fill);
    }
    return buf;
  }

  static from(value: string | number[] | ArrayBuffer | SharedArrayBuffer | ArrayBufferView, offset?: number, length?: number): MyBuffer {
    const buf = new MyBuffer(value);
    return buf.slice(offset, length);
  }

  static isBuffer(obj: any): obj is MyBuffer {
    return obj instanceof MyBuffer;
  }

  get length(): number {
    return this.data.length;
  }

  slice(start?: number, end?: number): MyBuffer {
    const newData = this.data.slice(start, end);
    return new MyBuffer(newData);
  }

  readInt8(offset: number): number {
    return this.data[offset] << 24 >> 24;
  }

  readUInt8(offset: number): number {
    return this.data[offset];
  }

  readInt16LE(offset: number): number {
    return this.data[offset] | (this.data[offset + 1] << 8);
  }

  readUInt16LE(offset: number): number {
    return this.readInt16LE(offset) >>> 0;
  }

  readInt16BE(offset: number): number {
    return (this.data[offset] << 8) | this.data[offset + 1];
  }

  readUInt16BE(offset: number): number {
    return this.readInt16BE(offset) >>> 0;
  }

  readInt32LE(offset: number): number {
    return this.data[offset] | (this.data[offset + 1] << 8) | (this.data[offset + 2] << 16) | (this.data[offset + 3] << 24);
  }

  readUInt32LE(offset: number): number {
    return this.readInt32LE(offset) >>> 0;
  }

  readInt32BE(offset: number): number {
    return (this.data[offset] << 24) | (this.data[offset + 1] << 16) | (this.data[offset + 2] << 8) | this.data[offset + 3];
  }

  readUInt32BE(offset: number): number {
    return this.readInt32BE(offset) >>> 0;
  }

  writeInt8(value: number, offset: number): void {
    this.data[offset] = value;
  }

  writeUInt8(value: number, offset: number): void {
    this.data[offset] = value;
  }

  writeInt16LE(value: number, offset: number): void {
    this.data[offset] = value & 0xff;
    this.data[offset + 1] = (value >> 8) & 0xff;
  }

  writeUInt16LE(value: number, offset: number): void {
    this.writeInt16LE(value, offset);
  }

  writeInt16BE(value: number, offset: number): void {
    this.data[offset] = (value >> 8) & 0xff;
    this.data[offset + 1] = value & 0xff;
  }

  writeUInt16BE(value: number, offset: number): void {
    this.writeInt16BE(value, offset);
  }

  writeInt32LE(value: number, offset: number): void {
    this.data[offset] = value & 0xff;
    this.data[offset + 1] = (value >> 8) & 0xff;
    this.data[offset + 2] = (value >> 16) & 0xff;
    this.data[offset + 3] = (value >> 24) & 0xff;
  }

  writeUInt32LE(value: number, offset: number): void {
    this.writeInt32LE(value, offset);
  }

  writeInt32BE(value: number, offset: number): void {
    this.data[offset] = (value >> 24) & 0xff;
    this.data[offset + 1] = (value >> 16) & 0xff;
    this.data[offset + 2] = (value >> 8) & 0xff;
    this.data[offset + 3] = value & 0xff;
  }

  writeUInt32BE(value: number, offset: number): void {
    this.writeInt32BE(value, offset);
  }

  fill(value: number, start?: number, end?: number): void {
    this.data.fill(value, start, end);
  }

  toString(encoding?: string, start?: number, end?: number): string {
    const encoder = new TextDecoder(encoding);
    const newData = this.data.slice(start, end);
    return encoder.decode(newData);
  }

  toJSON(): {type: 'Buffer', data: number[]} {
    return {
      type: 'Buffer',
      data: Array.from(this.data),
    };
  }
}

// example usage
const buf1 = new MyBuffer('hello world');
console.log(buf1.toString()); // "hello world"
console.log(buf1); // MyBuffer { data: Uint8Array(11) [...] }

const buf2 = MyBuffer.alloc(10, 0x1);
console.log(buf2); // MyBuffer { data: Uint8Array(10) [...] }

const buf3 = MyBuffer.from([0x1, 0x2, 0x3, 0x4]);
console.log(buf3); // MyBuffer { data: Uint8Array(4) [...] }

console.log(MyBuffer.isBuffer(buf2)); // true

const buf4 = buf1.slice(6);
console.log(buf4); // MyBuffer { data: Uint8Array(5) [...] }

buf2.writeInt8(0x2, 0);
console.log(buf2); // MyBuffer { data: Uint8Array(10) [...] }

console.log(buf1.toJSON()); // { type: 'Buffer', data: [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100 ] }

上述代码包含了 `alloc`、`from`、`isBuffer`、`length`、`slice`、`readInt8`、`readUInt8`、`readInt16LE`、`readUInt16LE`、`readInt16BE`、`readUInt16BE`、`readInt32LE`、`readUInt32LE`、`readInt32BE`、`readUInt32BE`、`writeInt8`、`writeUInt8`、`writeInt16LE`、`writeUInt16LE`、`writeInt16BE`、`writeUInt16BE`、`writeInt32LE`、`writeUInt32LE`、`writeInt32BE`、`writeUInt32BE`、`fill`、`toString` 和 `toJSON` 这些方法，这些方法与 Node.js 中的 `Buffer` 类型的 API 功能相同。