JavaScript - why is more frequent reading from array faster than bitwise operations

I have created simple benchmark to test, if it is faster to read more elements from uint8 array, of read less elements from uin32 array and use bitwise operations:

var rawData1 = new Uint8Array(800*600);
var rawData2 = new Uint8Array(800*600);
var rawData = new Uint8Array(800*600*2);

var j = 0;
for (var i = 0; i < rawData1.length; i++)
{
    rawData1[i] = i % 64;
    rawData2[i] = (i + 1) % 64;
    rawData[j] = rawData1[i];
    j++;
    rawData[j] = rawData2[i];
    j++;
}

var count = rawData1.length - 800;
var count2 = count / 2;

//==================================================================
var sum = 0;
var t0 = performance.now();

for (var i = 0; i < count; i += 2){ 
    sum += rawData1[i];
    sum += rawData2[i];
    sum += rawData1[i + 1]; 
    sum += rawData2[i + 1];
    sum += rawData1[i + 800];   
    sum += rawData1[i + 800 + 1];
    sum += rawData2[i + 800];
    sum += rawData2[i + 800 + 1];

}
var t1 = performance.now();
console.log("#1 took " + (t1 - t0) + " milliseconds.");
console.log("" + sum);

//=======================================================================

var data32 = new Uint32Array(rawData.buffer)
var sum2 = 0;

t0 = performance.now();

for (var i = 0; i < count2; i++){   
    var val = data32[i];
    sum2  += (val & 0x000000ff);        
    sum2  += (val & 0x0000ff00) >> 8;
    sum2  += (val & 0x00ff0000) >> 16;
    sum2  += (val & 0xff000000) >> 24;

    val = data32[i + 400];
    sum2  += (val & 0x000000ff);        
    sum2  += (val & 0x0000ff00) >> 8;
    sum2  += (val & 0x00ff0000) >> 16;
    sum2  += (val & 0xff000000) >> 24;  
}
t1 = performance.now();
console.log("#2 took " + (t1 - t0) + " milliseconds.");
console.log("" + sum2);

Both sums (sum and sum2) are the same, so computation is correct. However, the second code, with bitwise operations, is slower (around 10%). Why? I would expect, that reading from memory should be slower, than reading from a variable and using bitwise operations (or faster than memory access).