Benchmark: Multiple Nil checks 0.5 2

Multiple Nil checks 0.5 2 (version: 0)

Comparing performance of: a === null || a === undefined || b === null || b === undefined || c === null || c === undefined || d === null || d === undefined || e === null || e === undefined || f === null || f === undefined || g === null || g === undefined || h === null || h === undefined || i === null || i === undefined || j === null || j === undefined || k === null || k === undefined || l === null || l === undefined vs Super duper cool nil check

Created: 3 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var a = null;
var b = false;
var c = 0;
var d = '';
var e = NaN;
var f = 'test';
var g = 42;
var h = {};
var i = { a: 1, b: 'test' };
var j = [];
var k = [{}];
var l = [1, 2, 3, 4, 5];

function isNilSingleNullUndefined(parameter) { 
    return parameter === null || parameter === undefined;
}

function isNilLodash(...parameters) { 
    return _.some(parameters, (parameter) =>  _.isNil(parameter) );
}

// also evaluates falsy values true
function isNilLogicalNot(...parameters) { 
    return parameters.some((parameter) =>  !parameter );
}

function isNilNullUndefined(...parameters) { 
    return parameters.some((parameter) =>  parameter === null || parameter === undefined );
}

function isNilNull(...parameters) { 
    return parameters.some((parameter) =>  parameter == null );
}

function isNilSuperDuperCool(...args) {
        if (!args) return;
        
        let i = 0;

        while (args[i]) {
            ++i;
        }

        return i < args.length;
}

Tests:

a === null || a === undefined || b === null || b === undefined || c === null || c === undefined || d === null || d === undefined || e === null || e === undefined || f === null || f === undefined || g === null || g === undefined || h === null || h === undefined || i === null || i === undefined || j === null || j === undefined || k === null || k === undefined || l === null || l === undefined
a === null || a === undefined || b === null || b === undefined || c === null || c === undefined || d === null || d === undefined || e === null || e === undefined || f === null || f === undefined || g === null || g === undefined || h === null || h === undefined || i === null || i === undefined || j === null || j === undefined || k === null || k === undefined || l === null || l === undefined
Super duper cool nil check
isNilSuperDuperCool(a, b, c, d, e, f, g, h, i, j, k, l)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
a === null \|\| a === undefined \|\| b === null \|\| b === undefined \|\| c === null \|\| c === undefined \|\| d === null \|\| d === undefined \|\| e === null \|\| e === undefined \|\| f === null \|\| f === undefined \|\| g === null \|\| g === undefined \|\| h === null \|\| h === undefined \|\| i === null \|\| i === undefined \|\| j === null \|\| j === undefined \|\| k === null \|\| k === undefined \|\| l === null \|\| l === undefined
Super duper cool nil check

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Benchmark Definition JSON**

The provided JSON represents a benchmark definition, which is a set of rules for evaluating multiple variables and determining if any of them are null or undefined.

In this specific case, we have two test cases:

1. `a === null || a === undefined || b === null || b === undefined || c === null || ...`
2. `isNilSuperDuperCool(a, b, c, ..., l)` (the second test case uses the `isNilSuperDuperCool` function, which is defined in the Script Preparation Code)

**Options Compared**

The two test cases compare different approaches to checking for null or undefined values:

1. **Direct Comparison**: The first test case (`a === null || a === undefined || ...`) directly compares each variable with `null` and/or `undefined`. This approach is straightforward but may not be the most efficient, especially if there are many variables to check.
2. **`isNilSuperDuperCool` Function**: The second test case uses the `isNilSuperDuperCool` function, which iterates over the input arguments and checks for null or undefined values. This approach can be more efficient than direct comparison, but it may introduce additional overhead due to the function call.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **Direct Comparison**:
	+ Pros: Simple and straightforward.
	+ Cons: May not be efficient for large numbers of variables or complex checks.
* **`isNilSuperDuperCool` Function**:
	+ Pros: Can be more efficient than direct comparison, especially for larger inputs.
	+ Cons: Introduces additional overhead due to the function call.

**Other Considerations**

Some other considerations when evaluating null or undefined checks:

* **Falsy Values**: In addition to `null` and `undefined`, some values (like 0, empty strings, etc.) can be considered falsy in a boolean context. The `isNilLogicalNot` function (`parameters.some((parameter) => !parameter`) takes this into account.
* **Library Usage**: The benchmark uses the Lodash library for the `isNilSuperDuperCool` function. Lodash is a popular utility library that provides a variety of functional programming helpers.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in this benchmark.

**Alternative Approaches**

If you're interested in exploring alternative approaches, here are a few options:

* **Using `Array.prototype.every()`**: Instead of using the `isNilSuperDuperCool` function, you could use `Array.prototype.every()` to check if none of the input values are null or undefined.
* **Using `_.chain()` and `_.isEmpty()` from Lodash**: Another approach would be to use Lodash's `chain()` method to create a chain of operations, followed by `_.isEmpty()` to check if the resulting value is falsy.

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
a === null \|\| a === undefined \|\| b === null \|\| b === undefined \|\| c === null \|\| c === undefined \|\| d === null \|\| d === undefined \|\| e === null \|\| e === undefined \|\| f === null \|\| f === undefined \|\| g === null \|\| g === undefined \|\| h === null \|\| h === undefined \|\| i === null \|\| i === undefined \|\| j === null \|\| j === undefined \|\| k === null \|\| k === undefined \|\| l === null \|\| l === undefined	13051599.0 Ops/sec
Super duper cool nil check	1077758.9 Ops/sec

Related benchmarks: