Benchmark: InstanceOf vs String type vs Symbol

HTML Preparation code:

<script>
var S = Symbol('symbol')
class TestClass {
    constructor() {
        this.a = 2;
        this.t = 'mesh';
  		this.s = S
    }
}
</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
symbol
obj.s === S

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof
string type
string type + undefined
property
symbol

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark compares different ways to check if an object is of the correct type or has specific properties in JavaScript.

Here's a breakdown:

**Options Compared:**

* **`instanceof TestClass`**: This checks if an object is an instance of a particular class (`TestClass` in this case). It's a traditional way to verify object type but can be less performant than other methods.
* **`obj.t === 'mesh'`**: This directly compares the value of the property `t` with the string 'mesh'.  This is simple and efficient if you know the exact property value you're looking for.
* **`obj.t !== undefined`**: This checks if the property `t` exists and has a defined value (not `undefined`). While it works, it doesn't guarantee the property has the expected value.
* **`obj.a !== undefined`**:  Similar to above, but checks for the existence of property `a`. 
* **`obj.s === S`**: This compares the value of the symbol property `s` with the pre-defined symbol `S`.

**Pros and Cons:**

| Method | Pros | Cons |
|---|---|---|
| `instanceof` |  Clear type check, widely understood | Can be slower than direct property comparison |
| String Comparison (`===`) | Fast and efficient if you know the exact value | Only works for known values; not suitable for complex object checks |
| Property Existence Check (`!== undefined`) |  Simple to implement | Doesn't guarantee the correct value, only existence |

**Other Considerations:**

* **Symbols**: Symbols are unique identifiers in JavaScript, often used to create private properties. Comparing with symbols can be efficient but might not be as intuitive as other methods.
* **Benchmarking Context**: The performance difference between these methods can vary depending on factors like the size of the object, the number of comparisons, and the specific JavaScript engine being used.

**Alternatives:**

* **Type Guards**: TypeScript offers type guards, which allow you to narrow down the type of an object based on certain conditions, improving code clarity and performance. 
* **Reflection (Use with Caution)**:  JavaScript provides reflection mechanisms (e.g., `Object.prototype.hasOwnProperty`) that can be used for introspection. However, they can be less performant and are generally avoided for critical performance paths.

Let me know if you have any more questions!

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Safari 15 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
instanceof	5026850.5 Ops/sec
string type	12037116.0 Ops/sec
string type + undefined	3695302.0 Ops/sec
property	3754269.8 Ops/sec
symbol	3929437.0 Ops/sec

Related benchmarks:

InstanceOf vs String type vs Symbol (version: 0)

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

Comparing performance of: instanceof vs string type vs string type + undefined vs property vs symbol

Created: 2 years ago by: Guest

Jump to the latest result

instanceof

string type

string type + undefined

property

symbol

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):