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: one year ago

Test name	Executions per second
Double negation (!!row.length) with destructuring	152023.5 Ops/sec
Double negation (!!row.length) without destructuring	150900.1 Ops/sec
Comparison (row.length > 0) with destructuring	149770.0 Ops/sec
Comparison (row.length > 0) without destructuring	149477.1 Ops/sec
Double negation (!!row)	113755.1 Ops/sec
Boolean constructor	122064.4 Ops/sec
Array.length property	148235.5 Ops/sec
Array.some() method	149990.5 Ops/sec
Object.keys()	667.9 Ops/sec
for...of loop	147990.8 Ops/sec
Array.isArray() with length	147376.4 Ops/sec
typeof with length	142089.6 Ops/sec
First element check	149051.6 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