如何将ArrayBuffer转换为11位值，然后在Javascript中再次转换

我需要将256位的ArrayBuffer转换成24个11位的值，然后再转换回来

是否有一个简单的代码段来处理这种类型的操作

我有这个版本，把它转换成24个11位的值

var newBuffer = new Uint8Array(data);

var result = [];
for (var i =0, l = 24;i<l;i++){
  var index = parseInt((i*11.0)/8.0);
  var subBuffer;

  if (i==23){
    var proxyBuffer = new Uint8Array(2);
    proxyBuffer.set(newBuffer.slice(index,index+1));
    subBuffer = proxyBuffer;
  }else{
    subBuffer = newBuffer.slice(index,index+2);
  }

  var value = new Uint16Array(subBuffer.buffer);
  value = value >> (i*3)%8;
  value = value % 2048;
  result.push(value);
}
console.log(result);

var newBuffer=newuint8array（数据）；
var结果=[]；
对于（变量i=0，l=24；i>（i*3）%8；
值=值%2048；
结果：推（值）；
}
控制台日志（结果）；

使用位运算可以简化转换过程-使用

parseInt

和十进制算法不是一种简单的方法

下面的概念代码使用八位字节和11位值的普通数组。虽然

Uint8Array

和

Uint16Array

类型可能是更好的选择，但不包括创建类型化数组和/或将

arrayBuffer

转换为合适的数组类型

函数ui8To11（buffer8）{
var buffer11=[]；
var acc=0；
var accBits=0；
函数添加（八位字节）{
acc=（八位组=11）{
缓冲11.推送（acc和0x7ff）；
acc>>=11；
accBits-=11；
}
}
函数flush（）{
if（accBits）{
11.推送（acc）；
}
}
buffer8.forEach（add）；
冲洗（）；
返回缓冲区11；
}
函数ui11To8（buffer11）{
var buffer8=[]；
var acc=0；
var accBits=0；
功能添加（ui11）{
acc=（ui11=8）{
缓冲8.推送（acc和0xff）；
acc>>=8；
accBits-=8；
}
}
函数flush（）{
if（accBits）{
8.推送（acc）；
}
}
buffer11.forEach（add）；
冲洗（）；
返回缓冲区8；
}
var buffer8=[1,2,3]；//8位值，索引0处的最低有效八位字节
日志（“八位字节：”，buffer8）；
var buffer11=ui8To11（buffer8）；
日志（“undectets:”，buffer11）；
var=ui11To8（buffer11）
log（“convertedBack”，recoverted）；

有一个名为Uint1Array的库，它使一切变得更加简单

var arr = new Uint1Array(buffer);

for (let i=0, l=arr.length; i<l; i+=11){
    var zero = new Uint1Array(16);
    for (let index =0, length = 11; index<length;index++){
        zero[index]=arr[i+index];
    }

    let bit16 = new Uint16Array(zero.buffer)[0];
    outPut.push(bit16);
}

console.log(outPut);

var bit256 = new Uint1Array(256);
for (let i=0, l=outPut.length;i<l;i++){
    var hold = new Uint16Array(1);
    hold[0]=outPut[i];
    let bit16 = new Uint1Array(hold.buffer);
    let bit11 = bit16.slice(0,11);

    for (let i2=0, l2=11;i2<l2;i2++){
        bit256[(i*11)+i2]=bit11[i2];
    }
}

var arr=新的uint1数组（缓冲区）；
对于（i=0，l=arr.length；iBut 24*11不是256。从何处获取缺失的位？它们可以是零，但不会再次获取它们…零应该在何处？最后，如果数字是-10-1010-1101-1111，我想将其分解为4位值0010101011111