Benchmark: Lodash isPlainObject vs typeof

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.20/lodash.min.js"></script>

Script Preparation code:

var sampleObject = null;

Tests:

Lodash isPlainObject
_.isPlainObject(sampleObject);
typeof
typeof sampleObject === 'object' && sampleObject != null

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

typeof

15.2M/s

Lodash isPlainObject

10.0M/s

Fastest: typeof (1.5x faster)

View exact numbers

✓ typeof: 15,193,470 ops/sec
• Lodash isPlainObject: 10,031,970 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash isPlainObject
typeof

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

typeof

171.1M/s

Lodash isPlainObject

153.7M/s

View exact numbers

Test name	Executions per second
✓ typeof	171,097,344 Ops/sec
Lodash isPlainObject	153,665,312 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark, hosted on MeasureThat.net, compares the performance of two approaches to check if an object is plain in JavaScript: using the `_.isPlainObject()` function from the Lodash library and the `typeof` operator.

**Lodash Library**

The Lodash library is a popular utility library for functional programming tasks. In this benchmark, it's used to define a function `_.isPlainObject()` that takes an object as input and returns `true` if it's a plain object (i.e., not an array or other non-plain object), and `false` otherwise.

**`typeof` Operator**

The `typeof` operator is a built-in JavaScript operator that returns the type of a value. In this benchmark, it's used to check if an object is a "plain" object by verifying its type using `typeof sampleObject === 'object' && sampleObject != null`. This ensures that the object is not null and is of type `object`, which excludes arrays and other non-plain objects.

**Performance Comparison**

The benchmark compares the execution speed of these two approaches:

* **Lodash `_.isPlainObject()`**: This approach uses a dedicated function from the Lodash library to check if an object is plain. While it may be more readable, this approach might incur a slight overhead due to the additional function call and potential optimizations in the JavaScript engine.
* **`typeof` Operator**: This approach relies on the built-in `typeof` operator, which can be faster since it's optimized by the JavaScript engine. However, it requires manual verification of the null check to exclude non-plain objects.

**Pros and Cons**

* Lodash `_.isPlainObject()`:
	+ Pros: More readable code, less error-prone (no need for manual null checks).
	+ Cons: May incur a slight overhead due to the additional function call.
* `typeof` Operator:
	+ Pros: Faster execution speed, optimized by JavaScript engine.
	+ Cons: Requires manual null check to exclude non-plain objects.

**Other Considerations**

* The benchmark only measures performance on plain objects; if the object is not null and has other properties (e.g., functions), `_.isPlainObject()` will still be faster due to Lodash's implementation optimizations.
* The use of `typeof` might lead to unexpected behavior in some cases, such as when working with object prototypes or using Object.create().

**Alternatives**

If you're interested in exploring alternative approaches:

* Use `instanceof Object`: Similar to `typeof`, but provides more explicit type checking and avoids potential issues with Object prototype chains.
* Implement a custom function: You can write your own function to check if an object is plain, taking into account the specific requirements of your use case. However, this approach requires manual optimization and testing to ensure performance competitiveness.

I hope this explanation helps! Let me know if you have any further questions.

Lodash isPlainObject vs typeof (version: 1)

Comparing performance of: `Lodash isPlainObject vs typeof`

Created: 5 years ago by: Registered User

Go to the latest result

Lodash isPlainObject

typeof

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Lodash isPlainObject vs typeof (version: 1)

Comparing performance of: Lodash isPlainObject vs typeof

Created: 5 years ago by: Registered User

Go to the latest result

Lodash isPlainObject

typeof

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Lodash isPlainObject vs typeof`