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

Double negation (!!row.length) with destructuring

152K/s

Double negation (!!row.length) without destructuring

151K/s

Array.some() method

150K/s

Comparison (row.length > 0) with destructuring

150K/s

Comparison (row.length > 0) without destructuring

149K/s

First element check

149K/s

Array.length property

148K/s

for...of loop

148K/s

Array.isArray() with length

147K/s

typeof with length

142K/s

Boolean constructor

122K/s

Double negation (!!row)

114K/s

Object.keys()

668/s

View exact numbers

Test name	Executions per second
✓ Double negation (!!row.length) with destructuring	152,024 Ops/sec
Double negation (!!row.length) without destructuring	150,900 Ops/sec
Array.some() method	149,991 Ops/sec
Comparison (row.length > 0) with destructuring	149,770 Ops/sec
Comparison (row.length > 0) without destructuring	149,477 Ops/sec
First element check	149,052 Ops/sec
Array.length property	148,236 Ops/sec
for...of loop	147,991 Ops/sec
Array.isArray() with length	147,376 Ops/sec
typeof with length	142,090 Ops/sec
Boolean constructor	122,064 Ops/sec
Double negation (!!row)	113,755 Ops/sec
Object.keys()	668 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);