Benchmark: (Expanded) Filtering out empty rows from a 2D Array

(Expanded) Filtering out empty rows from a 2D Array (version: 2)

Comparing performance of: Double negation (!!row.length) with destructuring vs Double negation (!!row.length) without destructuring vs Comparison (row.length > 0) with destructuring vs Comparison (row.length > 0) without destructuring vs Double negation (!!row) vs Boolean constructor vs Array.length property vs Array.some() method vs Object.keys() vs for...of loop vs Array.isArray() with length vs typeof with length vs First element check vs Length property cast with destructuring vs Length property cast without destructuring

Created: 10 days ago by: Registered User

Jump to the latest result

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);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 days ago)

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/OS: Chrome 131 on Windows

View result in a separate tab

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

Autogenerated LLM Summary (model gpt-4o-mini, generated 10 days ago):

LLMs can make mistakes. Check important info.

This benchmark tests multiple approaches for filtering out empty rows from a 2D array in JavaScript. The focus is on how efficiently different functions can determine if a row (an inner array) is considered "non-empty".

### Comparison of Options

1. **Destructuring vs Non-Destructuring:**
   - Some functions use destructuring to directly extract the `length` property from the row (e.g., `lengthPropertyDestructured`, `lengthGreaterThanZeroDestructured`).
   - Others access the `length` property directly from the row object (e.g., `lengthPropertyNormal`, `lengthGreaterThanZeroNormal`).
   
   **Pros/Cons:**
   - **Destructuring** can make the code cleaner and more concise. However, it might add slight overhead due to syntax parsing.
   - **Non-Destructuring** can be more straightforward, with potentially better performance since it avoids destructuring.

2. **Double Negation vs Boolean Constructor:**
   - Functions like `doubleNegateLengthDestructured` and `doubleNegateLengthNormal` use double negation (`!!`) to coerce the length to a boolean.
   - The `booleanConstructor` function uses the `Boolean` constructor for coercion.
   
   **Pros/Cons:**
   - **Double Negation** is a common and fast way to convert a value to a boolean. However, it might be less readable for those unfamiliar.
   - **Boolean Constructor** is explicit but can be slower and less idiomatic in performance-critical code.

3. **Using Array and Object Methods:**
   - Functions like `arrayLengthProperty`, `arraySomeMethod`, and `objectKeys` use methods like `Array.some()` and `Object.keys()`.
   
   **Pros/Cons:**
   - `Array.some()` returns true if any element satisfies the condition but may come with additional overhead compared to direct property checks. 
   - `Object.keys()` checks the number of properties in an object, which is not directly relevant for arrays but tests the condition in a different way.

4. **Looping Constructs:**
   - The `forOfLoop` checks if there is at least one element by using a loop.
   
   **Pros/Cons:**
   - The loop is flexible and simple but might be slower than simple property checks for performance-sensitive scenarios.

5. **Type Checks:**
   - `isArrayWithLength` checks that the value is an array and has a length greater than zero.
   - `typeofArrayWithLength` checks whether the type is 'object' with a length property.
   
   **Pros/Cons:**
   - Type checks add safety but can introduce performance overhead due to the additional checks involved.

6. **First Element Check:**
   - The `firstElementCheck` verifies if the first element of the row is defined.
   
   **Pros/Cons:**
   - It's straightforward, but accessing the first element might not be the fastest way to filter empty rows.

### Benchmarking Results Summary

The results indicate that the functions checking the length properties (`lengthPropertyDestructured`, `lengthPropertyNormal`) performed the best, indicating that simple length checks are optimal for this use case. The standard property access (`row.length`) offers significant improvements in performance and is straightforward for readability.

### Other Considerations

- **Unoptimized Conditions**: Some methods may appear robust but could introduce performance penalties in large datasets.
- **Algorithm Complexity**: Consider the overall time complexity of filtering operations versus simple checks—e.g., O(n) for a filter versus O(1) for direct property checks.
- **Readability vs Performance**: Balancing clean code with the need for performance is crucial. Simple checks are more readable and often faster.

### Alternatives

1. **Array.prototype.flat()**: You could flatten the array and filter empty items afterward, but it wouldn't be efficient for large datasets as it processes the entire structure.
2. **Native for loops**: Custom looping can sometimes outperform higher-order functions, especially in tight loops where every millisecond counts. However, it's less readable.
3. **Libraries**: Utilizing libraries like Lodash can enhance array manipulation and readability at the potential cost of performance due to added overhead.

In conclusion, for filtering empty rows in a 2D array, directly checking the `length` property serves as the most efficient approach, as evidenced by the benchmark results. Making use of simple functions improves both readability and performance in most scenarios.

Related benchmarks:

(Expanded) Filtering out empty rows from a 2D Array (version: 2)

Created: 10 days ago by: Registered User

Jump to the latest result

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

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 10 days ago):