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

Length property cast with destructuring

156K/s

Length property cast without destructuring

155K/s

Comparison (row.length > 0) without destructuring

154K/s

Double negation (!!row.length) with destructuring

154K/s

Array.length property

154K/s

Comparison (row.length > 0) with destructuring

153K/s

Array.some() method

152K/s

Double negation (!!row.length) without destructuring

152K/s

for...of loop

152K/s

First element check

151K/s

Array.isArray() with length

150K/s

typeof with length

145K/s

Boolean constructor

128K/s

Double negation (!!row)

118K/s

Object.keys()

694/s

View exact numbers

Test name	Executions per second
✓ Length property cast with destructuring	155,992 Ops/sec
Length property cast without destructuring	155,273 Ops/sec
Comparison (row.length > 0) without destructuring	154,273 Ops/sec
Double negation (!!row.length) with destructuring	154,256 Ops/sec
Array.length property	153,668 Ops/sec
Comparison (row.length > 0) with destructuring	152,593 Ops/sec
Array.some() method	152,293 Ops/sec
Double negation (!!row.length) without destructuring	152,011 Ops/sec
for...of loop	151,516 Ops/sec
First element check	150,875 Ops/sec
Array.isArray() with length	150,011 Ops/sec
typeof with length	145,367 Ops/sec
Boolean constructor	128,206 Ops/sec
Double negation (!!row)	117,825 Ops/sec
Object.keys()	694 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);