Run results for: findIndex vs for loop simple

Run details:

User agent: Mozilla/5.0 (Linux; Android 11; M2012K11AG) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.92 Mobile Safari/537.36

Browser: Chrome Mobile 96

Operating system: Android

Device Platform: Mobile

Date tested: 2 years ago

Test name	Executions per second
findIndex	10029010.0 Ops/sec
for loop	3472866.2 Ops/sec

Script Preparation code:

function Xoroshiro128Plus(options) {
    let {
        state
    } = options || {};

    if (!state) {
        let time = (Date.now() | 0) >>> 0;
        state = [
            (time & ((Math.random() * 0xffffffff) | 0)) >>> 0,
            (time & ((Math.random() * 0xffffffff) | 0)) >>> 0,
            (time & ((Math.random() * 0xffffffff) | 0)) >>> 0,
            (time & ((Math.random() * 0xffffffff) | 0)) >>> 0,
        ];
    }

    this.next64 = () => xoroshiro128plus(state);
    this.getState = () => state.slice();
}

function xoroshiro128plus(state) {
    let s0 = [state[0], state[1]];
    let s1 = [state[2], state[3]];

    let result = sum64(s0, s1);

    s1 = xor64(s1, s0);
    let [a, b] = xor64(
        xor64(or64(shiftLeft64(s0, 55), shiftRight64(s0, 9)), s1),
        shiftLeft64(s1, 14),
    );
    let [c, d] = or64(shiftLeft64(s1, 36), shiftRight64(s1, 28));

    state[0] = a;
    state[1] = b;
    state[2] = c;
    state[3] = d;

    return result;

    function shiftLeft64([x, y], count) {
        // `32` case is not handled
        if (count < 32) {
            x = x << count;
            let a = (y >>> (32 - count)) & (Math.pow(2, count) - 1);
            x += a;
            return [x >>> 0, (y << count) >>> 0];
        } else {
            x = (y & (Math.pow(2, 64 - count) - 1)) << (count - 32);
            return [x >>> 0, 0];
        }
    }

    function shiftRight64([x, y], count) {
        // `32` case is not handled
        if (count < 32) {
            let a = x & (Math.pow(2, count) - 1);
            y = (y >>> count) + (a << (32 - count));
            return [x >>> count, y >>> 0];
        } else {
            let a = (x >> (count - 32)) & (Math.pow(2, 64 - count) - 1);
            x = (x >> (count - 32)) & (Math.pow(2, 64 - count) - 1);
            x = x + (a << (count - 32));
            return [0, x >>> 0];
        }
    }

    function or64([a0, a1], [b0, b1]) {
        return [(a0 | b0) >>> 0, (a1 | b1) >>> 0];
    }

    function xor64([a0, a1], [b0, b1]) {
        return [(a0 ^ b0) >>> 0, (a1 ^ b1) >>> 0];
    }

    function sum64([a0, a1], [b0, b1]) {
        let [y, overflow] = sum32(a1, b1);
        let x = (a0 + b0 + (overflow ? 1 : 0)) >>> 0;
        return [x, y];
    }

    function sum32(a, b) {
        let overflow = false;

        let max = 0xffffffff;
        max -= a;

        if (b > max) {
            overflow = true;
        }

        return [(a + b) >>> 0, overflow];
    }
}

var random = new Xoroshiro128Plus({
    state: [1292125120, -349674120, 855278889, 359289241]
});

var ELEMENTS_COUNT = 1000;
var FIELDS_COUNT = 10;

var items = [];

for (let i = 0; i < ELEMENTS_COUNT; i++) {
    var [zIndex, bits] = random.next64();

    var obj = {
        zIndex
    };

    for (let j = 1; j <= FIELDS_COUNT; j++) {
        obj[`prop${j}`] = Boolean((bits >> (j - 1)) & 1);
    }

    items.push(obj);
}

var keys = [
  "prop1",
  "prop2",
  "prop3",
  "prop4",
  "prop5",
  "prop6",
  "prop7",
  "prop8",
  "prop9",
  "prop10",
];

Tests:

findIndex
return items.findIndex(item => item.prop7)
for loop
var i = 0; var length = items.length; for (; i < length; i++) { if (items[i].prop7) { return i; } }