Benchmark: typeof vs instanceof vs constructor equality check

Script Preparation code:

function Ticket(id) {
  this._id = id;
}

var testTicket = new Ticket(1);
var count = 1000;

Tests:

instanceof check
for (var i = 0; i < count; i += 1) { if (testTicket instanceof Ticket) { continue; } }
constructor check
for (var i = 0; i < count; i += 1) { if (testTicket.constructor === Ticket) { continue; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof check
constructor check

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
instanceof check	422278.8 Ops/sec
constructor check	519055.8 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

In the provided benchmark, we are comparing three approaches to checking the type of an object in JavaScript: using `instanceof`, using the `.constructor` property, and through the use of `typeof`. However, the individual test cases only include comparisons between `instanceof` and `.constructor`.

### Benchmark Explanation

1. **Test Cases:**
   - **`instanceof` Check:**
     ```javascript
     for (var i = 0; i < count; i += 1) {
       if (testTicket instanceof Ticket) {
         continue;
       }
     }
     ```
     This test leverages the `instanceof` operator, which checks whether the prototype property of a constructor appears in the prototype chain of an object. In this case, it checks if `testTicket` is an instance of the `Ticket` function.

- **Constructor Check:**
     ```javascript
     for (var i = 0; i < count; i += 1) {
       if (testTicket.constructor === Ticket) {
         continue;
       }
     }
     ```
     This test uses the `.constructor` property of the object, which directly references the function that created the object (in this case, it checks if `testTicket.constructor` is equal to the `Ticket` constructor).

### Comparison of Approaches

- **Pros and Cons:**
  - **`instanceof`:**
    - **Pros:** 
      - Works well with inheritance. If you create any subclasses from `Ticket`, `instanceof` will still correctly identify them as instances of `Ticket`.
      - It's widely recognized and used in various JavaScript communities.
    - **Cons:** 
      - If you use objects from a different realm (like iframes) or the prototype chain is altered, the check may not behave as expected.
  
  - **Constructor Check:**
    - **Pros:** 
      - Simple and straightforward for direct constructor checks, assuming no modifications to the constructor property.
      - Faster in certain scenarios, as it directly compares references.
    - **Cons:** 
      - Does not handle inheritance well; if the object is an instance of a subclass, the check will return false.
      - If the constructor has been changed or overridden, this can lead to inaccurate results.

### Results Analysis

From the benchmark results provided, we can see the following execution rates:
- `constructor check`: 519,055.81 executions per second
- `instanceof check`: 422,278.75 executions per second

This indicates that the constructor check performed better than the `instanceof` check in this specific environment and configuration. It might suggest that for this particular test, the constructor check is the optimal approach for speed when you know the structure of your code won't change.

### Other Considerations and Alternatives

- **Type Checking Alternatives:** Beyond `instanceof` and `.constructor`, there is also `typeof`. However, it's primarily for checking the types of primitive data types (like strings, numbers, etc.) rather than checking the type of a user-defined object.
  
- **Libraries for Type Checking:** There are libraries (like `lodash` and `underscore`) that offer utility functions for more complex type checks, including `_.isEqual` or `_.isObject`, that can provide additional insights or capabilities.
  
- **Performance Context:** It's essential to consider that performance can vary across environments (different browsers, different devices, etc.), so benchmarks should be interpreted in the context of where the code is intended to run.

In conclusion, the `instanceof` and constructor checks provide complementary approaches to type verification in JavaScript. Each has its benefits depending on the context of its use, making it valuable for developers to understand these distinctions when optimizing code.

Related benchmarks:

typeof vs instanceof vs constructor equality check (version: 1)

Comparing typeof vs instanceof vs .constructor property

Comparing performance of: instanceof check vs constructor check

Created: one month ago by: Guest

Jump to the latest result

instanceof check

constructor check

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):