Benchmark: Instanceof vs string comparison vs property checking vs constructor comparison

HTML Preparation code:

<script>
class TestClass {
    constructor() {
        this.a = 2;
        this.t = 'mesh';
    }
}
</script>

Script Preparation code:

var obj = new TestClass();

Tests:

instanceof
obj instanceof TestClass;
string type
obj.t === 'mesh'
string type + undefined
obj.t !== undefined
property
obj.a !== undefined
constructor comparison
obj.constructor === TestClass

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof
string type
string type + undefined
property
constructor comparison

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 20 days ago)

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

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
instanceof	191508304.0 Ops/sec
string type	167427600.0 Ops/sec
string type + undefined	187944224.0 Ops/sec
property	180722896.0 Ops/sec
constructor comparison	180859728.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in the provided benchmark.

The benchmark compares the performance of different approaches to compare two values:

1. `instanceof` operator
2. Comparing a basic string type using `===`
3. Checking if a property is defined using `!== undefined`
4. Comparing a value with an object constructor

**Options Comparison**

The test cases evaluate the following options:

* `instanceof`: checks if an object is of a specific class (in this case, `TestClass`)
* Basic string comparison: compares two strings for equality (`===`)
* Property checking: checks if a property exists and is not undefined (`!== undefined`)
* Constructor comparison: checks if an object's constructor matches the expected one

**Pros and Cons**

Here are some pros and cons of each approach:

1. `instanceof`:
	* Pros: Can be used to check for both type and class, can be useful in certain situations.
	* Cons: May not work as expected with inheritance or prototypal inheritance, may have performance implications due to the need to look up the object's prototype chain.
2. Basic string comparison (`===`):
	* Pros: Simple, fast, and widely supported.
	* Cons: May not be suitable for all types of data (e.g., NaN, undefined), can lead to unexpected behavior if used with non-strict equality checks.
3. Property checking (`!== undefined`):
	* Pros: Fast, simple, and can be used with any type of data.
	* Cons: May return false positives if the property is not defined but has a value (e.g., `undefined`, `null`), may not work as expected with certain types of data (e.g., NaN).
4. Constructor comparison (`constructor ===`):
	* Pros: Can be used to check for both type and class, can be useful in certain situations.
	* Cons: May not work as expected with inheritance or prototypal inheritance, may have performance implications due to the need to look up the object's prototype chain.

**Library**

The `TestClass` is a custom class created using JavaScript classes. Its purpose is to demonstrate how to create a simple class in JavaScript and use it in the benchmark test cases.

**Special JS Feature or Syntax**

There is no special JS feature or syntax used in this benchmark, only standard JavaScript features and data types.

**Other Alternatives**

If you need to compare values in JavaScript, some alternative approaches include:

* Using a library like Lodash's `isEqual` function
* Implementing your own custom comparison functions
* Using a different type of equality check (e.g., strict equality with `===`)

Keep in mind that the choice of approach depends on the specific use case and requirements.

Related benchmarks:

Instanceof vs string comparison vs property checking vs constructor comparison (version: 0)

Measure the performance of instanceOf operator vs comparing a basic string type.

Comparing performance of: instanceof vs string type vs string type + undefined vs property vs constructor comparison

Created: 3 years ago by: Guest

Jump to the latest result

instanceof

string type

string type + undefined

property

constructor comparison

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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