Benchmark: Native array length vs Lodash's isEmpty

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.core.js"></script>

Script Preparation code:

var collection1 = undefined
var collection2 = [1, 2, 3]

var isEmpty = _.isEmpty

Tests:

native undefined
!!(collection1 && collection1.length)
isEmpty undefined
isEmpty(collection1)
native array
!!(collection1 && collection1.length)
isEmpty array
isEmpty(collection2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native undefined
isEmpty undefined
native array
isEmpty array

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and test cases to explain what's being tested, compared, and their pros/cons.

**Benchmark Definition**

The benchmark definition is represented by two JSON objects: `Script Preparation Code` and `Html Preparation Code`. The former defines the JavaScript variables used in the benchmarks, while the latter includes a library (Lodash) that provides a utility function `isEmpty`.

1. `Script Preparation Code`: This code snippet defines two variables:
	* `collection1`: set to `undefined`
	* `collection2`: an array with elements `[1, 2, 3]`

The purpose of this setup is to test how JavaScript handles the length property of different types of objects (arrays and undefined).

2. `Html Preparation Code`: This code includes a script tag that loads the Lodash library version 4.17.11.

**Test Cases**

There are four individual test cases:

1. **native undefined**: Tests whether accessing the `length` property on an `undefined` value evaluates to `true` or `false`.
```javascript
!!(collection1 && collection1.length)
```
This is a common JavaScript idiom that returns `true` if `collection1` is truthy (e.g., not `undefined`) and has a length property. If `collection1` is `undefined`, the expression evaluates to `false`.

2. **isEmpty undefined**: Tests whether calling the `isEmpty` function from Lodash on an `undefined` value returns `true`.
```javascript
isEmpty(collection1)
```
Since `collection1` is `undefined`, this call is likely expected to return `true`.

3. **native array**: Tests whether accessing the `length` property on a valid array (`collection2`) evaluates to `true`.
```javascript
!!(collection1 && collection1.length)
```
This should return `false`, as `collection1` is an empty object (due to being set to `undefined` earlier), and its length is 0.

4. **isEmpty array**: Tests whether calling the `isEmpty` function from Lodash on a valid array (`collection2`) returns `true`.
```javascript
isEmpty(collection2)
```
Since `collection2` has elements, this call is likely expected to return `false`.

**Pros and Cons**

1. **Direct vs Indirect Access**: The test cases compare direct access to the length property (Tests 1 and 3) with indirect access via a function call (Test 2). Pros: highlights how functions like `length` and `isEmpty` affect performance. Cons: may be less intuitive or slower due to the extra function call.
2. **Lodash Library**: Using Lodash introduces an external dependency that may impact benchmark results. Pros: allows for testing specific library-related behaviors. Cons: adds complexity, potential dependencies, and may not be suitable for all environments.

**Other Considerations**

* The `!!` operator is a common JavaScript idiom used to return `true` or `false` based on the truthiness of an expression. It's equivalent to using `if (expr) expr; else;` or simply `if (expr) { ... }`.
* When dealing with arrays, it's essential to consider that accessing an array by index returns a value with its own length property, which may not be what you expect.
* The benchmark setup relies on the initial values of `collection1` and `collection2`. This might affect the results if these values are changed or if the test cases are run multiple times.

**Alternatives**

To create similar benchmarks without Lodash, you could:

* Define a custom `length` property for `undefined` using `Object.defineProperty(collection1, 'length', { value: 0 });`
* Implement a simple `isEmpty` function using a conditional statement, e.g., `function isEmpty(arr) { return arr == null && typeof arr === 'object'; }`

By considering these alternatives, you can create benchmarks that test specific JavaScript behaviors without relying on external libraries.

Latest run results:

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

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

Browser/OS: Chrome 94 on Windows

View result in a separate tab

Test name	Executions per second
native undefined	15525742.0 Ops/sec
isEmpty undefined	6867025.0 Ops/sec
native array	15310820.0 Ops/sec
isEmpty array	7161439.5 Ops/sec

Related benchmarks:

Native array length vs Lodash's isEmpty (version: 0)

Comparing performance of: native undefined vs isEmpty undefined vs native array vs isEmpty array

Created: 4 years ago by: Guest

Jump to the latest result

native undefined

isEmpty undefined

native array

isEmpty array

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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