HarmonyOS鸿蒙Next中实现二进制数据处理功能示例代码

介绍

本示例基于Uint8Array实现二进制数据的处理，提供简单的处理二进制数据的操作，包括：读取单字节数据、读取无/有符号16位int数据、读取无/有符号32位int数据、读取无/有符号64位int数据、读取字符串数据以及读取浮点数数据。

实现二进制数据处理功能源码链接

效果预览

使用说明

本示例仅提供简单的二进制数据处理方式示例，不适用与处理复杂的二进制数据。

实现思路

1. 读取单字节数据。

export class ParseUtil {
  static readByte(b: Uint8Array, pos: number): number {
    return b[pos] & 0xFF;
  }
}

1. 读取无符号16位int。

export class ParseUtil {
  static readUInt16LE(b: Uint8Array, pos: number): number {
    if (pos + 2 < b.length) {
      pos = pos + 2;
      return ((b[--pos] & 0xFF) << 8) | (b[--pos] & 0xFF);
    } else {
      return 0;
    }
  }
}

1. 读取16位int。

export class ParseUtil {
  static readInt16LE(b: Uint8Array, pos: number): number {
    if (pos + 2 < b.length) {
      pos = pos + 2;
      let x = ((b[--pos] & 0xFF) << 8) | (b[--pos] & 0xFF);
      return (x >= 32768) ? x - 65536 : x;
    } else {
      return 0;
    }
  }
}

1. 读取无符号32位int。

export class ParseUtil {
  static readUInt32LE(b: Uint8Array, pos: number): number {
    if (pos + 4 < b.length) {
      pos = pos + 4;
      return ((b[--pos] & 0xFF) << 24) | ((b[--pos] & 0xFF) << 16) | ((b[--pos] & 0xFF) << 8) | (b[--pos] & 0xFF);
    } else {
      return 0;
    }
  }
}

1. 读取32位int。

export class ParseUtil {
  static readInt32LE(b: Uint8Array, pos: number): number {
    if (pos + 4 < b.length) {
      pos = pos + 4;
      let x = ((b[--pos] & 0xFF) << 24) | ((b[--pos] & 0xFF) << 16) | ((b[--pos] & 0xFF) << 8) | (b[--pos] & 0xFF);
      return ((x >= 2147483648) ? x - 4294967296 : x);
    } else {
      return 0;
    }
  }
}

1. 读取无符号64位int。

export class ParseUtil {
  // 64 位二进制 解析
  static readUInt64LE(b: Uint8Array, pos: number): number {
    if (pos + 7 < b.length) {
      let result =
        (((b[pos + 3] & 0xFF) << 24) | ((b[pos + 2] & 0xFF) << 16) | ((b[pos + 1] & 0xFF) << 8) |
          ((b[pos + 0] & 0xFF)));
      // 32位表示高四位和
      let result11 =
        (((b[pos + 7] & 0xFF) << 24) | ((b[pos + 6] & 0xFF) << 16) | ((b[pos + 5] & 0xFF) << 8) |
          ((b[pos + 4] & 0xFF)));
      return (result11 * 65536 * 65536 + result);
    } else {
      return 0;
    }
  }
}

1. 读取64位int。

export class ParseUtil {
  static readInt64LE(b: Uint8Array, pos: number): number {
    if (pos + 7 < b.length) {
      let result =
        (((b[pos + 3] & 0xFF) << 24) | ((b[pos + 2] & 0xFF) << 16) | ((b[pos + 1] & 0xFF) << 8) |
          ((b[pos + 0] & 0xFF)));

      // 32位表示高四位和
      let result11 =
        (((b[pos + 7] & 0xFF) << 24) | ((b[pos + 6] & 0xFF) << 16) | ((b[pos + 5] & 0xFF) << 8) |
          ((b[pos + 4] & 0xFF)));

      let rs = (result11 * 65536 * 65536 + result);
      if (rs > 4294967296 * 2147483648 - 1) {
        rs -= 4294967296 * 4294967296;
      }
      return rs;
    } else {
      return 0;
    }
  }
}

1. 读取字符串。

export class ParseUtil {
  static readUTF(b: Uint8Array, pos: number): string {
    // 前两个字节作为字符串的长度，判定字符串在二进制数据中的边界
    let len = ParseUtil.readUInt16LE(b, pos);
    pos = pos + 2;

    let a: Uint8Array = new Uint8Array(len);

    let ret = '';
    try {
      for (let i = 0; i < len; i++) {
        let charCode = ParseUtil.readByte(b, pos);
        a[i] = charCode;
        pos++;
      }
      let textDecoder = util.TextDecoder.create('utf-8')
      ret = textDecoder.decodeToString(a);
    } catch (e) {
      hilog.error(domainId, tag, e);
    }
    return ret;
  }
}

1. 读取浮点数。

export class ParseUtil {
  static byteArrayToFloat(bytes: Uint8Array, pos: number): number {
    if (pos + 3 < bytes.length) {
      let b1 = bytes[pos + 3] & 0xFF;
      let b2 = bytes[pos + 2] & 0xFF;
      let b3 = bytes[pos + 1] & 0xFF;
      let b4 = bytes[pos] & 0xFF;
      let sign = 1 - (b1 >> 7 << 1); // sign = bit 0
      let exp = (b1 << 1 & 0xFF | b2 >> 7) - 127; // exponent = bits 1..8
      let sig = (b2 & 0x7F) << 16 | b3 << 8 | b4; // significand = bits 9..31
      if (sig == 0 && exp == -127) {
        return 0.0;
      }
      return (sign * (1 + Math.pow(2, -23) * sig) * Math.pow(2, exp));
    } else {
      return 0.0;
    }
  }
}