Benchmark: Lodash has vs Native Javascript

Lodash has vs Native Javascript (version: 0)

This benchmark compares the performance of lodash's `has` function with native JavaScript code for checking if an object has a specific property. The lodash `has` function checks if `path` is a direct property of `object`. The native JavaScript code uses the `in` operator to check if an object has a specific property.

Comparing performance of: lodash.has vs Native JavaScript

Created: one year ago by: Registered User

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js" integrity="sha512-WFN04846sdKMIP5LKNphMaWzU7YpMyCU245etK3g/2ARYbPK9Ub18eG+ljU96qKRCWh+quCY7yefSmlkQw1ANQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>

Script Preparation code:

cspSrcs = {
    key: 'value'
};

Tests:

lodash.has
_.has(cspSrcs, 'key');
Native JavaScript
'key' in cspSrcs;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.has
Native JavaScript

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash.has	7464575.0 Ops/sec
Native JavaScript	17482956.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 7 months ago):

LLMs can make mistakes. Check important info.

**Overview**

The provided JSON represents a benchmark test on the MeasureThat.net website, comparing the performance of Lodash's `has` function with native JavaScript code for checking if an object has a specific property.

**What is tested**

Two approaches are compared:

1. **Lodash's `has` function**: This function checks if `path` is a direct property of `object`. The benchmark measures how long it takes to perform this check.
2. **Native JavaScript using the `in` operator**: This approach uses the `in` operator to check if an object has a specific property. The benchmark measures how long it takes to perform this check.

**Options compared**

The two options are:

* Lodash's `has` function
* Native JavaScript code using the `in` operator

**Pros and cons of each approach**

1. **Lodash's `has` function**:
	* Pros: concise and readable, handles nested objects, and provides a convenient way to check if an object has a specific property.
	* Cons: may be slower than native JavaScript code due to the overhead of calling a library function.
2. **Native JavaScript using the `in` operator**:
	* Pros: lightweight, fast, and flexible, as it can be used in various scenarios beyond just checking properties.
	* Cons: less readable and more verbose than Lodash's `has` function, and may not handle nested objects as elegantly.

**Library usage**

The benchmark uses the Lodash library, which is a JavaScript utility library that provides a wide range of functions for tasks such as data manipulation, functional programming, and string manipulation. In this specific case, the `has` function is used to check if an object has a specific property.

**Special JS feature or syntax**

There are no special JavaScript features or syntaxes mentioned in the benchmark definition or test cases. The code uses standard JavaScript syntax and does not employ any advanced features such as async/await, Promises, or Web Workers.

**Other alternatives**

If you need to perform similar checks on objects, other approaches could include:

* Using a different library, such as Underscore.js or Ramda
* Implementing a custom function for checking object properties
* Using a template literal with the `in` operator (e.g., `${object}['key'] in 'value'`)
* Using a library like Object.prototype.hasOwnProperty.call()

Related benchmarks: