【HarmonyOS Next】常见的字节转换

字节转换、位运算在实际开发中具有广泛的应用价值，特别是在处理字节级数据时发挥着重要作用。例如，在网络通信中用于大小端序转换，在数据解析时进行位提取操作。这些特性使得位运算在USB通信、蓝牙（Ble）数据传输、近场通信（NFC）以及TCP/IP协议栈等底层通信场景中成为不可或缺的技术手段。

在java中表示数值的整型有byte、short、int、long，分别对应1字节、2字节、4字节、8字节。另外还有浮点型float、double。
在ArkTs中表示数值的类型为number，表示整型和浮点型。

在Harmony ArkTs中我们似乎不再关注它的范围，也不再关注类似于java语言中的符号位。

在ArkTs中字节数组用Uint8Array表示，表示一个8位无符号整数的数组。每个元素的取值范围0到255（即1个字节），那我们应该怎么使用它？

位提取

复制代码

 static getBit(value: number, index: number): number {
    return (value >> index) & 0x01;
  }

value是数值，index是索引，代表取的第几位，上诉代码通过右移和位操作提取一个数值中的某一位（0或1）。假设value=13，取它的第一位（index=0）的数值时，13的二进制是0000 1101，& 0000 0001，所以返回值为1

工具类-不同的字节范围转换成number

下面的工具类中提供了转换步骤，比如2字节、4字节与number的转换，同时提供了大小端的区分。

复制代码

export class ByteUtils {
  static readonly TAG: string = 'ByteUtils';

  /**
   * 获取位
   * @param value
   * @param index
   * @returns
   */
  static getBit(value: number, index: number): number {
    return (value >> index) & 0x01;
  }

  /**
   * Byte[] 与 int 互转
   * =============================================================================================
   */

  /**
   * 将int转为高字节在前，低字节在后的byte数组（大端）
   *
   * @param n int
   * @return byte[]
   */
  static intToByteBig(n: number): Uint8Array {
    let b = new Uint8Array(4);
    b[3] = (n & 0xff);
    b[2] = (n >> 8 & 0xff);
    b[1] = (n >> 16 & 0xff);
    b[0] = (n >> 24 & 0xff);
    return b;
  }

  /**
   * 将int转为低字节在前，高字节在后的byte数组（小端）
   *
   * @param n int
   * @return byte[]
   */
  static intToByteLittle(n: number): Uint8Array {
    let b = new Uint8Array(4);
    b[0] = (n & 0xff);
    b[1] = (n >> 8 & 0xff);
    b[2] = (n >> 16 & 0xff);
    b[3] = (n >> 24 & 0xff);
    return b;
  }

  /**
   * byte数组到int的转换(小端)
   *
   * @param bytes
   * @return
   */
  static bytes2IntLittle(bytes: Uint8Array): number {
    let int1 = bytes[0] & 0xff;
    let int2 = (bytes[1] & 0xff) << 8;
    let int3 = (bytes[2] & 0xff) << 16;
    let int4 = (bytes[3] & 0xff) << 24;
    return int1 | int2 | int3 | int4;
  }

  /**
   * byte数组到int的转换(大端)
   *
   * @param bytes
   * @return
   */
  static bytes2IntBig(bytes: Uint8Array): number {
    let int1 = bytes[3] & 0xff;
    let int2 = (bytes[2] & 0xff) << 8;
    let int3 = (bytes[1] & 0xff) << 16;
    let int4 = (bytes[0] & 0xff) << 24;
    return int1 | int2 | int3 | int4;
  }

  /**
   * Byte[] 与 short 互转
   * =============================================================================================
   */

  /**
   * 将short转为高字节在前，低字节在后的byte数组（大端）
   *
   * @param n short
   * @return byte[]
   */
  static shortToByteBig(n: number): Uint8Array {
    let b = new Uint8Array(2);
    b[1] = (n & 0xff);
    b[0] = (n >> 8 & 0xff);
    return b;
  }

  /**
   * 将short转为低字节在前，高字节在后的byte数组(小端)
   *
   * @param n short
   * @return byte[]
   */
  static shortToByteLittle(n: number): Uint8Array {
    let b = new Uint8Array(2);
    b[0] = (n & 0xff);
    b[1] = (n >> 8 & 0xff);
    return b;
  }

  /**
   * 读取小端byte数组为short
   *
   * @param b
   * @return
   */
  static byteToShortLittle(b: Uint8Array): number {
    return (((b[1] << 8) | b[0] & 0xff));
  }

  /**
   * 读取大端byte数组为short
   *
   * @param b
   * @return
   */
  static byteToShortBig(b: Uint8Array): number {
    return (((b[0] << 8) | b[1] & 0xff));
  }
}

工具类-16进制转换

16进制是一种数值的表示方式，通常表示字节数组，它在调试过程中更容易理解。

复制代码

import { buffer } from "@kit.ArkTS";

export class HexUtils {
  static readonly TAG: string = 'HexUtils';

  static numberToHex(num: number): string {
    return num.toString(16).toUpperCase().padStart(2, '0');
  }

  //十六进制转Uint8Array
  static HexStrToUint8Array(data: string): Uint8Array {
    return new Uint8Array(buffer.from(data, 'hex').buffer);
  }

  // Uint8Array转十六进制
  static uint8ArrayToHexStr(data: Uint8Array): string {
    let hexString = '';
    let i: number;
    for (i = 0; i < data.length; i++) {
      let char = ('00' + data[i].toString(16)).slice(-2);
      hexString += char;
    }
    return hexString;
  }
}