Benchmark: has vs native last

HTML Preparation code:

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

Script Preparation code:

data = {
    'meta': {
        'pagination': {
            'page': 1,
            'limit': 10
        }
    },
    'data': {
        'id': 123,
        'name': 'Example'
    },
    'errors': 'None'
}

Tests:

native
data && data.meta && data.data && data.errors ? data.data : data
lodash
( _.has(data,'meta') && _.has(data,'data') && _.has(data,'errors') ) ? data.data : data

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native
lodash

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
native	2153154.5 Ops/sec
lodash	1160687.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents a benchmark test case on MeasureThat.net, which allows users to compare the performance of different approaches in JavaScript.

**Benchmark Definition**

The benchmark definition is an expression that evaluates a condition and returns either the original object or a default value (in this case, `data`). The two expressions are:

1. `"data && data.meta && data.data && data.errors ? data.data : data"` ( Native )
2. `( _.has(data,'meta') && _.has(data,'data') && _.has(data,'errors') ) ? data.data : data` ( Lodash )

**What is being tested?**

In the first expression, `data` and its properties (`meta`, `data`, and `errors`) are checked recursively to determine if at least one of them exists. If any property exists, the expression returns the value of `data.data`. Otherwise, it returns `data`.

The second expression uses the Lodash library's `_has` function to check if each property exists in the `data` object. The `&&` operator is used to chain these checks together, and if all properties exist, the expression returns `data.data`. If any property does not exist, the expression returns `data`.

**Options compared**

Two options are being compared:

1. **Native**: The first expression uses native JavaScript syntax to check for existence.
2. **Lodash**: The second expression uses Lodash's `_has` function to check for existence.

**Pros and Cons of each approach:**

**Native Approach:**

Pros:

* Lightweight and fast, as it only requires native JavaScript functions.
* Easy to understand and implement.

Cons:

* Can be slower due to the overhead of recursive checks.
* May not handle edge cases or complex data structures well.

**Lodash Approach:**

Pros:

* Faster performance due to the optimized implementation of `_has` in Lodash.
* Handles edge cases and complex data structures more robustly.

Cons:

* Requires an additional library, which may add latency.
* More difficult to understand and implement, especially for those without experience with Lodash.

**Library Overview:**

Lodash is a popular JavaScript utility library that provides a wide range of functions for working with arrays, objects, and other data structures. The `_has` function checks if an object has a specific property at a given path. In this benchmark, it's used to check for existence in the `data` object.

**Special JS Feature/Syntax:**

None are mentioned in this benchmark. However, if you're interested in exploring other JavaScript features or syntax, I can provide information on that as well!

**Other alternatives:**

If you'd like to explore alternative approaches, here are a few options:

1. **Prototype Chain**: Instead of using Lodash's `_has` function, you could use the prototype chain to check for existence. This approach is more lightweight but may not be as efficient.
2. **Array.prototype.includes()**: You could also use `Array.prototype.includes()` to check if an object has a specific property. This approach is even more lightweight than using Lodash's `_has` function.

Keep in mind that the best approach depends on your specific use case and performance requirements.

Related benchmarks:

has vs native last (version: 0)

Comparing performance of: native vs lodash

Created: one year ago by: Guest

Jump to the latest result

native

lodash

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):