JS 字节流 解析

---

前言

提示：最近作者在工作之余，遇到了关于字节数据传输，前端解析数据的问题，为此写了一个用于处理该类问题的 js 库。

---

提示：以下是本篇文章正文内容，下面案例可供参考

JS 源码

代码如下（示例）：

var BOOL_TYPE = 0,       // Bool
    INT8_TYPE = 1,       // Char
    UINT8_TYPE = 2,      // UChar
    INT16_TYPE = 3,      // Short
    UINT16_TYPE = 4,     // UShort
    INT32_TYPE = 5,      // Int
    INT64_TYPE = 6       // Long
    UINT32_TYPE = 7,     // UInt
    FLOAT32_TYPE = 8,    // Float
    FLOAT64_TYPE = 9,    // Double
    BYTE_TYPE = 10,      // Byte
    Str_TYPE = 11;  
    
// type：数据类型， Bin：二进制流，begin：数据起始位置（字节），Num: 1
function TypedArrays(Type, Bin) {//, begin, Num
    //var _num = 1;
    switch (Type) {
        case BOOL_TYPE: return Bin[0] == 1 ? true : false;
        case INT8_TYPE: return toInt8(Bin); 
        case UINT8_TYPE: return toUint8(Bin); 
        case INT16_TYPE: return toInt16(Bin);    
        case UINT16_TYPE: return toUint16(Bin);  
        case INT32_TYPE: return toInt32(Bin);    
        case INT64_TYPE: return toInt64(Bin);    
        case UINT32_TYPE: return toUint32(Bin);  
        case FLOAT32_TYPE: return toFloat32(Bin);
        case FLOAT64_TYPE: return toFloat64(Bin);
        case BYTE_TYPE: return toBytes(Bin);
        case Str_TYPE: return toString(Bin);
        default: return -1;
    }
}

// 截取指定大小数据并转换成指定的数据类型
function ByteToType(Type, Bin, begin, Num) {
    return TypedArrays(Type, Bin.splice(begin, Num));//, begin, Num);
}

// ASCII to char
function ASCII2Char(v) { return String.fromCharCode(v); }

// ASCII to string
function ASCII2Str(Bin, StartByte, Type, MsgLen) {
    var MsgName = "";
    var Index = 0;

    while (Index < MsgLen) {
        var AsciiValue = TypedArrays(Type, Bin, StartByte, 1); StartByte += 1;
        if (AsciiValue != 0)
            MsgName += ASCII2Char(AsciiValue);
        else
            return MsgName;
        Index++;
    }
    return MsgName;
}
function byteToString(arr) {
    if (typeof arr === 'string') {
        return arr;
    }
    var str = '',
        _arr = arr;
    for (var i = 0; i < _arr.length; i++) {
        var one = _arr[i].toString(2),
            v = one.match(/^1+?(?=0)/);
        if (v && one.length == 8) {
            var bytesLength = v[0].length;
            var store = _arr[i].toString(2).slice(7 - bytesLength);
            for (var st = 1; st < bytesLength; st++) {
                if (_arr.length > i + st) {
                    store += _arr[st + i].toString(2).slice(2);
                } else {
                    store = '000000';
                }
            }
            str += String.fromCharCode(parseInt(store, 2));
            i += bytesLength - 1;
        } else {
            str += String.fromCharCode(_arr[i]);
        }
    }
    return str;
}
           
//构建一个视图，把字节数组写到缓存中，索引从0开始，大端字节序
function getView(bytes) {
    var view = new DataView(new ArrayBuffer(bytes.length));
    for (var i = 0; i < bytes.length; i++) {
        view.setUint8(i, bytes[i]);
    }
    return view;
}

function toString(bytes) {
    //var data = getView(bytes);
    return byteToString(bytes);
}

//对应数组，或单数结果
function toBytes(bytes) {
    if (bytes.length > 1) {
        return bytes;
    } else {
        return bytes[0];
    }
}
//将字节数组转成有符号的8位整型，大端字节序
function toInt8(bytes) {
    return getView(bytes).getInt8();
}
//将字节数组转成无符号的8位整型，大端字节序
function toUint8(bytes) {
    return getView(bytes).getUint8();
}
//将字节数组转成有符号的16位整型，大端字节序
function toInt16(bytes) {
    return new Int16Array(getView(bytes).buffer, 0, 1)[0]; 
}
//将字节数组转成无符号的16位整型，大端字节序
function toUint16(bytes) {
    return new Uint16Array(getView(bytes).buffer, 0, 1)[0];
}
//将字节数组转成有符号的32位整型，大端字节序
function toInt32(bytes) {
    return new Int32Array(getView(bytes).buffer, 0, 1)[0]; 
}
//将字节数组转成无符号的32位整型，大端字节序
function toUint32(bytes) {
    return new Uint32Array(getView(bytes).buffer, 0, 1)[0]; 
}
//将字节数组转成有符号的64位整型，大端字节序
function toInt64(bytes) {
    return new BigInt64Array(getView(bytes).buffer, 0, 1)[0];
}
//将字节数组转成有符号的64位整型，大端字节序
function toUint64(bytes) {
    return new BigUint64Array(getView(bytes).buffer, 0, 1)[0];
}
//将字节数组转成32位浮点型，大端字节序
function toFloat32(bytes) {
    return getView(bytes).getFloat32();
}
//将字节数组转成64位浮点型，大端字节序
function toFloat64(bytes) {
    return new Float64Array(getView(bytes).buffer, 0, 1)[0]; 
}
//将数值写入到视图中，获得其字节数组，大端字节序
function getUint8Array(len, setNum) {
    var buffer = new ArrayBuffer(len);  //指定字节长度
    setNum(new DataView(buffer));  //根据不同的类型调用不同的函数来写入数值
    return new Uint8Array(buffer); //创建一个字节数组，从缓存中拿取数据
}
//得到一个8位有符号整型的字节数组，大端字节序
function getInt8Bytes(num) {
    return getUint8Array(1, function (view) { view.setInt8(0, num); })
}
//得到一个8位无符号整型的字节数组，大端字节序
function getUint8Bytes(num) {
    return getUint8Array(1, function (view) { view.setUint8(0, num); })
}
//得到一个16位有符号整型的字节数组，大端字节序
function getInt16Bytes(num) {
    return getUint8Array(2, function (view) { view.setInt16(0, num); })
}
//得到一个16位无符号整型的字节数组，大端字节序
function getUint16Bytes(num) {
    return getUint8Array(2, function (view) { view.setUint16(0, num); })
}
//得到一个32位有符号整型的字节数组，大端字节序
function getInt32Bytes(num) {
    return getUint8Array(4, function (view) { view.setInt32(0, num); })
}
//得到一个32位无符号整型的字节数组，大端字节序
function getUint32Bytes(num) {
    return getUint8Array(4, function (view) { view.setUint32(0, num); })
}
//得到一个32位浮点型的字节数组，大端字节序
function getFloat32Bytes(num) {
    return getUint8Array(4, function (view) { view.setFloat32(0, num); })
}
//得到一个64位浮点型的字节数组，大端字节序
function getFloat64Bytes(num) {
    return getUint8Array(8, function (view) { view.setFloat64(0, num); })
}
    

使用步骤

代码如下（示例）：

ByteToType(INT32_TYPE, [0,1,1,2], 0, 4); //转换类型 int32，源数据，取值下标，取几位

---

总结

提示：以上简单示例，仅为模板，大家可以有自己更好的思路哦。