Benchmark: Object.prototype.toString.call vs typeof (only isObject, full implementation)

Script Preparation code:

var types = {
    array: [1, 2, 3],
    number: 123,
    string: '123',
    map: new Map([
        [1, 1],
        [2, 2],
        [3, 3]
    ]),
    set: new Set([1, 2, 3]),
    buffer: new ArrayBuffer([1, 2, 3]),
    boolean: true,
    arrow: () => {},
    function: function() {},
    object: {}
}

var values = Object.values(types)

Tests:

typeof -> object
values.map(value => typeof value === "object" && !Array.isArray(value) && value !== null)
Object.prototype.toString.call -> object
values.map(value => Object.prototype.toString.call(value) === '[object Object]')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
typeof -> object
Object.prototype.toString.call -> object

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 118 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
typeof -> object	2871256.5 Ops/sec
Object.prototype.toString.call -> object	1268973.9 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark, hosted on MeasureThat.net, compares the performance of two approaches to check if an object is an instance of another type in JavaScript:

1. `typeof` operator
2. `Object.prototype.toString.call()` method

Both methods are tested with a set of predefined types (arrays, numbers, strings, maps, sets, buffers, booleans, arrow functions, and objects) to ensure the results are accurate.

**Options Compared**

The benchmark compares two approaches:

1. **`typeof` operator**: This is a built-in JavaScript operator that returns a string indicating the type of an object.
2. **`Object.prototype.toString.call()` method**: This is a method on the `Object` prototype that returns a string representing the type of an object.

**Pros and Cons**

**`typeof` Operator:**

Pros:

* Fast and lightweight, making it suitable for performance-critical code.
* Easy to read and write, as it's a built-in operator.
* Works with most types of objects.

Cons:

* Can return incorrect results for some edge cases (e.g., `NaN`, `Infinity`, or objects with non-standard prototype chains).
* Does not provide additional information about the object's type beyond its category (e.g., array, number, string).

**`Object.prototype.toString.call()` Method:**

Pros:

* Provides more detailed information about an object's type, including its class name and any prototype chain.
* Can handle edge cases that `typeof` may not cover.

Cons:

* Slower than the `typeof` operator due to the method call overhead.
* Requires explicit method invocation (`Object.prototype.toString.call()`), which can make code more verbose.

**Library Used**

None of the benchmark tests explicitly use any libraries beyond the built-in JavaScript `Object` prototype and the `Array`, `Map`, `Set`, and `Buffer` constructors.

**Special JS Features/Syntax**

The benchmark does not mention using any special JavaScript features or syntax, such as async/await, generators, or ES6 classes. The code is written in traditional JavaScript, with no explicit use of modern language features.

**Other Alternatives**

If you need to check the type of an object in JavaScript, other alternatives include:

1. Using a library like `lodash.type` or `type-checker` for more advanced type checking.
2. Implementing your own type checking function using `instanceof` or a custom implementation.
3. Using a different method, such as `constructor.name` or `class` syntax (available in ES6+).

Keep in mind that these alternatives may have their own trade-offs and performance characteristics.

Related benchmarks:

Object.prototype.toString.call vs typeof (only isObject, full implementation) (version: 0)

Comparing performance of: typeof -> object vs Object.prototype.toString.call -> object

Created: 2 years ago by: Guest

Jump to the latest result

typeof -> object

Object.prototype.toString.call -> object

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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