Run results for: (Expanded) Filtering out empty rows from a 2D Array

Run details:

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser: Chrome 131

Operating system: Windows

Device Platform: Desktop

Date tested: 10 days ago

Test name	Executions per second
Double negation (!!row.length) with destructuring	154255.5 Ops/sec
Double negation (!!row.length) without destructuring	152010.6 Ops/sec
Comparison (row.length > 0) with destructuring	152592.7 Ops/sec
Comparison (row.length > 0) without destructuring	154273.4 Ops/sec
Double negation (!!row)	117825.5 Ops/sec
Boolean constructor	128206.0 Ops/sec
Array.length property	153667.7 Ops/sec
Array.some() method	152293.2 Ops/sec
Object.keys()	693.9 Ops/sec
for...of loop	151516.3 Ops/sec
Array.isArray() with length	150011.1 Ops/sec
typeof with length	145366.7 Ops/sec
First element check	150875.2 Ops/sec
Length property cast with destructuring	155992.4 Ops/sec
Length property cast without destructuring	155272.9 Ops/sec

Script Preparation code:

// Array with alternating empty and non-empty arrays
const arraySize = 1000;
var testArray = new Array(arraySize)
    .fill(null)
    .map((_, i) => i % 2 === 0
        // Make the values alternate between 0-2
        ? new Array(i).fill(0).map((_, j) => j % 2) 
        : []);

function lengthPropertyDestructured({ length }) {
    // Doesn't return a boolean, but will cause an automatic cast
    return length;
}

function lengthGreaterThanZeroDestructured({ length }) {
    return length > 0;
}

function doubleNegateLengthDestructured({ length }) {
    return !!length;
}

function lengthGreaterThanZeroDestructured({ length }) {
    return length > 0;
}

function lengthPropertyNormal(row) {
    // Doesn't return a boolean, but will cause an automatic cast
    return row.length;
}

function doubleNegateLengthNormal(row) {
    return !!row.length;
}

function lengthGreaterThanZeroNormal(row) {
    return row.length > 0;
}

function doubleNegate(value) {
    return !!value;
}

var booleanConstructor = Boolean;

function arrayLengthProperty(row) {
    return row.length !== 0;
}

function arraySomeMethod(row) {
    return row.some(() => true);
}

function objectKeys(row) {
    return Object.keys(row).length > 0;
}

function forOfLoop(row) {
    for (let _ of row) return true;
    return false;
}

function isArrayWithLength(row) {
    return Array.isArray(row) && row.length > 0;
}

function typeofArrayWithLength(row) {
    return typeof row === 'object' && row !== null && row.length > 0;
}

function firstElementCheck(row) {
    return row[0] !== undefined;
}

Tests:

Double negation (!!row.length) with destructuring
testArray.filter(doubleNegateLengthDestructured);
Double negation (!!row.length) without destructuring
testArray.filter(doubleNegateLengthNormal);
Comparison (row.length > 0) with destructuring
testArray.filter(lengthGreaterThanZeroDestructured);
Comparison (row.length > 0) without destructuring
testArray.filter(lengthGreaterThanZeroNormal);
Double negation (!!row)
testArray.filter(doubleNegate);
Boolean constructor
testArray.filter(booleanConstructor);
Array.length property
testArray.filter(arrayLengthProperty);
Array.some() method
testArray.filter(arraySomeMethod);
Object.keys()
testArray.filter(objectKeys);
for...of loop
testArray.filter(forOfLoop);
Array.isArray() with length
testArray.filter(isArrayWithLength);
typeof with length
testArray.filter(typeofArrayWithLength);
First element check
testArray.filter(firstElementCheck);
Length property cast with destructuring
testArray.filter(lengthPropertyDestructured);
Length property cast without destructuring
testArray.filter(lengthPropertyNormal);

Run results for: (Expanded) Filtering out empty rows from a 2D Array

Double negation (!!row.length) with destructuring

Double negation (!!row.length) without destructuring

Comparison (row.length > 0) with destructuring

Comparison (row.length > 0) without destructuring

Double negation (!!row)

Boolean constructor

Array.length property

Array.some() method

Object.keys()

for...of loop

Array.isArray() with length

typeof with length

First element check

Length property cast with destructuring

Length property cast without destructuring