Benchmark: instanceof vs typeof 3

Script Preparation code:

var obj = {a:2};

Tests:

instanceof
obj instanceof Object
typeof
typeof obj === 'object'
typeof no function
typeof obj === 'object' && typeof obj !== 'function'
typeof obj or string
typeof obj === 'object' && typeof obj === 'string'
new Ojb
Object(obj) == obj
string or obj
['object', 'string'].includes(typeof obj)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof
typeof
typeof no function
typeof obj or string
new Ojb
string or obj

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 19 days ago):

LLMs can make mistakes. Check important info.

The benchmark you've provided compares different methods of determining the type of a JavaScript object, particularly focusing on two primary approaches: `instanceof` and `typeof`. Below, I'll break down each test case, compare the methods used, and discuss the pros and cons of each approach along with other considerations.

### Test Cases Overview

1. **`obj instanceof Object` (Test Name: "instanceof")**
   - **Description**: This test checks if `obj` is an instance of `Object`. The `instanceof` operator tests the prototype chain to see if `obj` is an instance of `Object`, which is a core type in JavaScript.
   - **Pros**: Accurate for distinguishing object types in cases where inheritance and prototype chains are relevant.
   - **Cons**: Can be slow if the prototype chain is long or when dealing with different execution contexts (like iframes), as it checks the entire prototype chain.

2. **`typeof obj === 'object'` (Test Name: "typeof")**
   - **Description**: This test uses the `typeof` operator which returns a string indicating the type of the unevaluated operand. In this case, it checks if `obj` is specifically of type `object`.
   - **Pros**: Fast and straightforward for determining the base type of a variable.
   - **Cons**: This will also return true for `null`, which is considered an object in JavaScript, which could be misleading in some cases.

3. **`typeof obj === 'object' && typeof obj !== 'function'` (Test Name: "typeof no function")**
   - **Description**: Here, it checks if `obj` is an object and explicitly ensures that it is not a function, addressing the limitation of the previous test.
   - **Pros**: Provides a distinction between objects and functions, making it more accurate for many use cases.
   - **Cons**: Slightly more complex and may still yield false when `obj` is `null`.

4. **`typeof obj === 'object' && typeof obj === 'string'` (Test Name: "typeof obj or string")**
   - **Description**: This test seems to be incorrectly formed as it checks if `obj` can be both an `object` and a `string` at the same time, which is impossible.
   - **Pros**: N/A (the condition can't be true).
   - **Cons**: This test is logically flawed, leading to no utility.

5. **`Object(obj) == obj` (Test Name: "new Ojb")**
   - **Description**: This test checks if calling `Object(obj)` results in an object equivalent to `obj`.
   - **Pros**: Verifies that the conversion process does not alter the original object.
   - **Cons**: May not be as common a method for type checking and could potentially yield unexpected results with primitive types.

6. **`['object', 'string'].includes(typeof obj)` (Test Name: "string or obj")**
   - **Description**: This checks if the type of `obj` is either 'object' or 'string'.
   - **Pros**: A flexible check that allows for grouping of types.
   - **Cons**: This is not a strict type check, as it can give false positives depending on what you expect (e.g., a number or boolean would not be caught).

### Performance Results Overview

From the benchmark results, we can observe the following:

- The `typeof obj === 'object'` method offers the best performance, being capable of executing more than 1.4 billion times a second.
- The `new Ojb` (although perhaps a typo for `new Obj`) follows, but significantly slower than the `typeof` method.
- The `instanceof` method executes the slowest, highlighting its overhead due to the need to inspect the prototype chain.
- Comparatively, options like `typeof` combined checks yield decent performance while enhancing clarity, although some variations like the `typeof obj === 'object' && typeof obj === 'string'` could be misconstructed and irrelevant.

### Conclusion and Alternatives

The benchmark demonstrates different methods for checking object types in JavaScript, with notable variations in speed and utility. The `typeof` operator generally provides the fastest and most direct type check, while `instanceof` should be reserved for cases where prototype inheritance needs to be considered.

**Other Alternatives**:
- **`Array.isArray(obj)`**: For checking if an object is an array.
- **`Object.prototype.toString.call(obj)`**: This method can provide accurate type information for all built-in types, including differentiating between objects, arrays, and null.
- **Using libraries**: Libraries like Lodash (`_.isObject()`) or `TypeScript` typings can enhance type checking with additional type safety and more tailored checks.

In summary, this benchmark serves as a valuable exploration of performance and reliability in type discrimination in JavaScript, guiding developers in their choice of techniques based on use case requirements.

Latest run results:

Run details: (Test run date: 19 days ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:133.0) Gecko/20100101 Firefox/133.0

Browser/OS: Firefox 133 on Linux

View result in a separate tab

Test name	Executions per second
instanceof	129415968.0 Ops/sec
typeof	1445575296.0 Ops/sec
typeof no function	712616832.0 Ops/sec
typeof obj or string	717184768.0 Ops/sec
new Ojb	1102101632.0 Ops/sec
string or obj	43195492.0 Ops/sec

Related benchmarks:

instanceof vs typeof 3 (version: 1)

Comparing performance of: instanceof vs typeof vs typeof no function vs typeof obj or string vs new Ojb vs string or obj

Created: 19 days ago by: Guest

Jump to the latest result

instanceof

typeof

typeof no function

typeof obj or string

new Ojb

string or obj

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 19 days ago):