0

根据这个答案的评论，我想使用 Unit8Array 来实现同样的事情：

var bin = parseInt('1000', 2); //=8

我是说：

输入是：

length = 4
digits = [1,0,0,0]

在一些 TypedArray 魔术之后，输出将是：

8

让我们看一个（2位长度）的具体示例：

counts = {};
var a = [[0,1],[0,0],[0,1],[0,0],[0,0],[1,1]]; 
for(var i in a){
  var id = parseInt(a[i].join(''), 2);
  if(!++counts[id])counts[id] = 1;
}
console.log(counts); //{0: 3, 1: 2, 3: 1}

我的笔记在这里。

4

3 回答 3

0

这有用吗？

var a = 1 << 3; // shift the bits of 1 (0001) 3 places: 1000
if (a == 8) {
    // this block will execute
}

另一个例子：

var i,
    result = 0,
    len = 4,
    bits = [1, 0, 0, 0];

for (i = 0; i < len; ++i) {
    result = (result << 1) + bits[i];
}

alert(result);

请记住，parseInt可能比这更快。

于 2013-08-31T11:03:57.903 回答
0

你想得到这个吗parseInt(string, radix)

radix一个整数，表示上述字符串的基数。

不确定，是不是有点像你期望的

var x = new Uint8Array([1,0,0,0]);
var a = x[0].toString()+x[1].toString()+x[2].toString()+x[3].toString();
console.log(parseInt(a, 2));
console.log(a.length);
于 2013-08-31T10:35:12.927 回答
0

如果您想要更快的速度，请将 id 处理为整数，而不是数组，并使用 & 和 | 进行一些更改 操作：

 counts = {};
 var a = [1,0,1,0,0,3]; 
 for(var i=0; i<a.length; i++ ){
    var c = counts[a[i]] || 0 ;
    counts[a[i]]= c+1 ;
 }
 console.log(counts); // { 0: 3,  1: 2, 3: 1 }

设置第 k 位：

id |=  1 << k;

清除第 k 位：

id &= !(1 << k);

交换第 k 位：

id ^= (1 << k);

读取第 k 位：

bitK = (id >> k ) & 1;

因此，您可能会编写小函数来执行这些操作，它们有 99% 的机会被 javascript 引擎内联，这将比数组处理 + parseInt 快得多。
您甚至可以直接编写此代码。也许在某些情况下，您将能够缓存 1 << k，但无论如何，移位指令的成本非常低。

另一个优点是您可以在一条指令中处理多个测试，例如：

var setRequiredMask   = ( 1<<3 |  1<<5 ) ;   // to test if bits 3 and 5 set
var clearRequiredMask = ( 1<<2 | 1 <<4 ) ;   // to test if bit 2 and 4 cleared
var someRequiredMask  = ( 1<<0 | 1 <<6 ) ;   // to test if either bit 0 or bit 6 to be set

var satisfyConditions = ((id & setRequiredMask) == setRequiredMask) && 
                         ((id & !clearRequiredMask) ==0 ) &&
                            (id & someRequiredMask) ;

在这里，我们将 7 次内存访问换成完全相同数量的布尔运算。
如果在循环中使用这个测试来过滤一个数组，速度增益是巨大的。

以同样的方式，您可以在一条指令中设置/清除/交换多个位，测试一个条件集是否包含在另一个条件集中，测试它们是否正交，......所有这些都以非常快的方式进行。

唯一的限制是您可以使用此方法处理不超过 32 种可能性。

然后，您可以将 id 存储在类型化数组中，具体取决于可能性的最大数量，仅使用 Int8Array 或 Int32Array，但与 [] 相比，我不确定性能增益是否会那么有趣。

句法 ：

var arr = new Int8Array( _length_ );

或者

var arr = new Int32Array( _length_ );
于 2013-08-31T12:15:27.423 回答