Benchmark: instanceof vs symbol property on Error()

Script Preparation code:

const err = Error()

function isInstanceOf(x) {
	return x instanceof InstOf
}


const symb = Symbol()

let errWithSymb = Error()
errWithSymb[symb] = 1

function hasSymb(x) {
	return typeof x === "object" && symb in x
}

Tests:

instanceof
isInstanceOf(err)
has symbol
hasSymb(errWithSymb)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof
has symbol

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0

Browser/OS: Firefox 115 on Windows

View result in a separate tab

Test name	Executions per second
instanceof	92545232.0 Ops/sec
has symbol	475990112.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested, the options compared, pros and cons of those approaches, and other considerations.

**Benchmark Definition**

The benchmark definition provides two functions: `isInstanceOf` and `hasSymb`. These functions are used to test the performance of accessing a property on an object using the `instanceof` operator versus directly accessing a symbol as a property.

*   `isInstanceOf(x)` checks if the input `x` is an instance of a specific class (`InstOf`). The `Instanceof` keyword in JavaScript returns true if the object passed to it is an instance or subclass of the specified constructor.
*   `hasSymb(x)` checks if the input `x` has a property with the same symbol as the predefined symbol `symb`. The symbol is assigned to an error object (`errWithSymb`) using the syntax `errWithSymb[symb] = 1`.

**Options Compared**

The benchmark compares two approaches:

*   **Using `instanceof`**: This approach uses the `instanceof` operator to check if an object is an instance of a specific class.
*   **Directly accessing a symbol as a property**: This approach directly accesses the symbol as a property on the object using bracket notation (`x[symb]`).

**Pros and Cons**

**Using `instanceof`:**

*   Pros:
    *   Widely supported by most JavaScript engines.
    *   Can be used with any class, not just objects with a symbol property.
*   Cons:
    *   May be slower due to the overhead of invoking the constructor check.
    *   May not work correctly for non-instantiable constructors or functions.

**Directly accessing a symbol as a property:**

*   Pros:
    *   Can be faster than using `instanceof` because it avoids the overhead of constructor checks.
    *   Works with symbols, which can be used to create unique and private properties in objects.
*   Cons:
    *   Requires access to the symbol, which may not always be possible (e.g., when accessing a property through a proxy).
    *   Limited support for certain browsers or JavaScript engines.

**Other Considerations**

The benchmark also considers the following:

*   **Proxy objects**: The `hasSymb` function uses a proxy object to create a new error with the symbol property. This allows testing of how different JavaScript engines handle symbols in proxies.
*   **Symbol creation**: The benchmark creates symbols using the `Symbol()` constructor, which is available in ECMAScript 2015 (ES6) and later standards.

**Library Usage**

The benchmark uses the `InstOf` class to create instances for testing with `instanceof`. This class is not a built-in JavaScript class but rather a custom class that can be defined by the user. The purpose of this class is to provide a testable instance that can be used with `instanceof`.

**Special JS Features/Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax, such as async/await, generators, or classes (beyond the custom `InstOf` class). However, it does rely on the behavior of symbols and proxy objects in different browsers and JavaScript engines.

In summary, this benchmark compares two approaches to accessing properties on objects using `instanceof` versus directly accessing a symbol as a property. The results can help developers understand the performance implications of using these approaches in their own code.

Related benchmarks:

instanceof vs symbol property on Error() (version: 2)

Comparing performance of: instanceof vs has symbol

Created: one year ago by: Registered User

Jump to the latest result

instanceof

has symbol

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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