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

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 42 runs

string type

21.0M/s

instanceof

8.9M/s

constructor comparison

8.8M/s

property

8.3M/s

string type + undefined

8.3M/s

Fastest: string type (2.5x faster)

View exact numbers

✓ string type: 21,013,596 ops/sec
• instanceof: 8,854,780 ops/sec
• constructor comparison: 8,835,674 ops/sec
• property: 8,332,293 ops/sec
• string type + undefined: 8,282,611 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
instanceof
string type
string type + undefined
property
constructor comparison

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 145 on Mac OS X 10.15.7

View result in a separate tab

constructor comparison

184.7M/s

string type + undefined

184.6M/s

instanceof

182.0M/s

string type

180.6M/s

property

166.6M/s

View exact numbers

Test name	Executions per second
✓ constructor comparison	184,690,880 Ops/sec
string type + undefined	184,613,104 Ops/sec
instanceof	181,958,368 Ops/sec
string type	180,586,288 Ops/sec
property	166,633,696 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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: 5 years ago by: Guest

Go to the latest result

instanceof

string type

string type + undefined

property

constructor comparison

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 42 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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: 5 years ago by: Guest

Go to the latest result

instanceof

string type

string type + undefined

property

constructor comparison

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 42 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: `instanceof vs string type vs string type + undefined vs property vs constructor comparison`