1、将十六进制数组转换为 ArrayBuffer

function getBuffer(hexArr) {let buffer = new ArrayBuffer(hexArr.length)let dataView = new DataView(buffer);hexArr.forEach((item, index) => {dataView.setUint8(index, item);})return buffer
}

• 创建了一个与输入数组长度相同的新的 ArrayBuffer 对象
• 使用 DataView 对象来操作这个新的 ArrayBuffer
• 遍历输入的十六进制数组，将每个元素转换为无符号 8 位整数（Uint8），并将其写入到新的 ArrayBuffer对象中

2、将ArrayBuffer 对象转换为十六进制字符串

function ab2hex(buffer) {let hexArr = Array.prototype.map.call(new Uint8Array(buffer),function (bit) {return ('00' + bit.toString(16)).slice(-2)})return hexArr.join('');
}

• 创建一个空数组 hexArr
• 通过调用 Array.prototype.map 方法，将输入的 ArrayBuffer 对象转换为一个由十六进制字符串组成的数组
• 在 map 方法的回调函数中，将每个字节转换为两位的十六进制字符串，并将其添加到 hexArr 中
• 使用 join('') 方法将 hexArr 数组中的所有元素连接成一个完整的十六进制字符串，并返回结果

3、将十六进制字符串转换为 ASCII 字符串

function hexToAscii(hex) {var str = '';for (var i = 0; i < hex.length; i += 2) {var charCode = parseInt(hex.substr(i, 2), 16);str += String.fromCharCode(charCode);}return str;
}

• 使用一个循环来遍历输入的十六进制字符串 hex。每次迭代，它会处理两个字符（一个字节）
• 使用 parseInt 函数将当前两个字符的十六进制表示转换为一个十进制数值
• 使用 String.fromCharCode 函数将该十进制数值转换为对应的 ASCII 字符，并将其添加到 str 字符串中

4、计算给定十六进制数组的 CRC 校验值

function getCrcData(hexArr) {let crcData = 0;for (let i = 0; i < hexArr.length; i++) {crcData ^= hexArr[i];}return '0x' + crcData.toString(16)
}

• 在循环中，对 crcData 和当前遍历到的十六进制数组元素进行异或操作（^=）
• 循环结束后，将计算得到的 CRC 校验值转换为十六进制字符串

5、将日期转换为十六进制字符串数组

function dateTohexString(date) {var date = new Date(date);var timestamp = Math.floor(date.getTime() / 1000); // 将日期转换为时间戳（以秒为单位）var buffer = new ArrayBuffer(4);var dataView = new DataView(buffer);dataView.setUint32(0, timestamp, true);var byteArray = new Uint8Array(buffer);var hexString = Array.from(byteArray).map(byte => byte.toString(16).padStart(2, '0')).join('');let arr = (hexString.match(/.{1,2}/g))let hexStringArr = []arr.forEach(item => {hexStringArr.push("0x" + item)})return hexStringArr
}

• 创建一个长度为4的 ArrayBuffer 对象，并使用 DataView 来操作这个缓冲区
• 使用 setUint32() 方法，它将时间戳写入到 ArrayBuffer 中
• 使用 Uint8Array 类型的视图来获取 ArrayBuffer 的字节表示，并将其存储在变量 byteArray 中
• 使用 Array.from() 方法将 byteArray 转换为普通数组，并通过 map() 方法将每个字节转换为两位的十六进制字符串
• 使用 join('') 将所有的十六进制字符串连接成一个完整的字符串，并按每两个字符分割为数组元素

6、将十六进制字符串数组转换为日期对象

function hexStringToDate(hexString) {var byteArray = new Uint8Array(hexString.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));var buffer = byteArray.buffer;var dataView = new DataView(buffer);var timestamp = dataView.getUint32(0, true) * 1000; // 将秒转换为毫秒var dateTime = new Date(timestamp);return dateTime
}

• 接收一个十六进制字符串 hexString 作为输入
• 使用正则表达式来将每两个字符分割为一个元素，并使用 map()方法将每个元素转换为对应的十进制数
• 使用 Uint8Array 构造函数创建一个新的无符号8位整数数组，将转换得到的十进制数作为参数传递给它
• 使用 byteArray.buffer 获取数组的缓冲区对象，并将其存储在变量 buffer 中
• 使用 DataView对象来操作缓冲区
• 使用 getUint32() 方法，它从缓冲区中读取四个字节，并将其作为以秒为单位的时间戳存储在变量 timestamp 中
• 使用 new Date() 构造函数创建一个新的日期对象，并将时间戳作为参数传递给它，将结果存储在变量 dateTime 中

7、将时间字符串转换为反转的十六进制字符串数组

function timeTohexString(time) {var parts = time.split(":");var hours = parseInt(parts[0], 10); // 小时数var minutes = parseInt(parts[1], 10); // 分钟数// 计算总秒数var totalSeconds = hours * 3600 + minutes * 60;var hexString = totalSeconds.toString(16);while (hexString.length < 6) {hexString = '0' + hexString;}// 返回反转后的十六进制数组let pairs = hexString.match(/.{1,2}/g);let littleEndianHex = pairs.reverse();let newArr = littleEndianHex.map(item => '0x' + item)return newArr;
}

8、将给定的十进制数转换为一个反转的十六进制字符串数组

function decimalToHex(decimal, byteLength) {// 将十进制转换为十六进制字符串let hexString = decimal.toString(16);// 确保十六进制字符串占byteLength个字节while (hexString.length < byteLength) {hexString = '0' + hexString;}// 返回反转后的十六进制数组let pairs = hexString.match(/.{1,2}/g);let littleEndianHex = pairs.reverse();let newArr = littleEndianHex.map(item => '0x' + item)return newArr;
}

• 确保十六进制字符串占据指定的字节长度

9、将十六进制字符串切分为字节数组

function splitHexStringToByteArray(hexString) {// 检查输入字符串的长度是否为偶数，如果不是，则在其前面添加一个0if (hexString.length % 2 !== 0) {hexString = '0' + hexString;}// 将输入字符串切分为一个字节的数组const byteArray = [];for (let i = 0; i < hexString.length; i += 2) {const byte = hexString.substr(i, 2);byteArray.push('0x' + byte);}return byteArray;
}

• for 循环，每次从 hexString 中取出两个字符，将其转换为一个字节，并将结果存储在变量 byte 中

10、解析 TLV（Tag-Length-Value）数据

function parseTlvData(data) {const tlvArray = [];let index = 0;while (index < data.length) {const type = data[index];const length = data[index + 1];const value = data.slice(index + 2, index + 2 + length);tlvArray.push({type,length,value});index += 2 + length;}return tlvArray;
}

• 初始化一个变量 index 为 0，表示从数据的起始位置开始解析
• 在循环内部，首先获取当前索引位置的字节作为 TLV 的类型（Tag），并将其存储在变量 type 中
• 获取下一个字节作为 TLV 的长度（Length），并将其存储在变量 length 中
• 使用 slice() 方法从索引位置加 2 开始，截取长度为 length 的部分作为 TLV 的值（Value），并将其存储在变量 value 中
• 将 { type, length, value } 组成的对象添加到 tlvArray 数组中
• 更新 index 的值，以便继续解析下一个 TLV 数据

11、将汉字转换为字符编码数组

function hanziTochart(hanzi) {let chart = [];for (let i = 0; i < hanzi.length; i++) {const charCode = hanzi.charCodeAt(i); // 获取每个字符的Unicode编码const hexString = (charCode.toString(16)).match(/.{1,2}/g); // 将Unicode编码转换为十六进制字符串hexString.map(item => {chart.push('0x' + item);})}return chart
}

12、将字符编码数组转换回汉字

function chartTohanzi(chart) {let chartArr = chart.match(/.{1,4}/g)let hanzi = "";for (let i = 0; i < chartArr.length; i++) {const hexString = chartArr[i];const charCode = parseInt(hexString, 16); // 将十六进制字符串转换为Unicode编码const char = String.fromCharCode(charCode); // 将Unicode编码转换为字符hanzi += char;}return hanzi
}