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

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

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested and compared in this benchmark.

**The Test Case:**
The test case compares four different ways to check if an object `obj` has a certain property or characteristic:

1. **InstanceOf**: Using the `instanceof` operator to check if `obj` is an instance of the class `TestClass`.
2. **String Type**: Comparing a basic string type (`'mesh'`) to the value of `obj.t`.
3. **String Type + Undefined**: Similar to the previous one, but with an additional check for `undefined`.
4. **Property**: Checking if `obj.a` (a property) is not equal to `undefined`.
5. **Symbol**: Comparing a symbol (`S`) to the value of `obj.s`.

**The Tested Options:**

1. **InstanceOf Operator (`instanceof`)**: A built-in JavaScript operator that checks if an object is an instance of a particular class.
2. **String Type Comparison (`=== 'mesh'` or `!== undefined`)**: Directly comparing a string value to the property value of `obj.t`.
3. **Symbol Comparison (`S === obj.s`)**: Comparing a symbol to the value of `obj.s`.

**Pros and Cons of Each Option:**

1. **InstanceOf Operator**:
	* Pros: Clear, concise syntax.
	* Cons: May be slower than primitive type comparisons (strings or symbols).
2. **String Type Comparison**:
	* Pros: Fast for primitive types like strings.
	* Cons: May not work correctly with custom objects that have a string value.
3. **Symbol Comparison**:
	* Pros: Unique and fast comparison mechanism.
	* Cons: Requires manual creation of symbol values.

**Other Considerations:**

1. **Performance**: The benchmark results show the performance differences between these options. For this test case, comparing strings or symbols seems to be faster than using the `instanceof` operator.
2. **Code Clarity**: When choosing an option, consider how clear and concise your code needs to be for maintainability.

**The Library:**

No specific library is used in this benchmark. The JavaScript features being tested are built-in language capabilities.

**Special JS Features or Syntax:**

1. **Symbol**: A unique primitive value type that can be used as a key in `Map` objects, and for creating custom properties on objects.
2. **Class**: A new syntax introduced in ECMAScript 2015 (ES6) for defining classes.
3. **instanceof Operator**: A built-in operator for checking if an object is an instance of a particular class.

**Other Alternatives:**

1. **Switch Statement**: Not directly related to this test case, but can be used for branching based on primitive type values or symbol comparisons.
2. **Type Checking Libraries**: There are libraries like TypeScript or JSDoc that provide additional type checking and static analysis features, which may not be relevant here.

That's a summary of the benchmark!

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 llama3.1:latest, generated 2 months ago):