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

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 keys = Object.keys(types)

Tests:

typeof -> object
keys.map(key => typeof types[key] === "object")
Object.prototype.toString.call -> object
keys.map(key => Object.prototype.toString.call(types[key]) === '[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

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

LLMs can make mistakes. Check important info.

Let's break down the JavaScript microbenchmark on MeasureThat.net.

**Benchmark Definition**

The benchmark tests two approaches to check if an object is an instance of `Object`. The script preparation code defines an object `types` with various types, including arrays, numbers, strings, maps, sets, buffers, booleans, and functions. It then extracts the keys of this object using `Object.keys()`.

**Options Compared**

The benchmark compares two options:

1. **`typeof`**: This operator returns a string indicating the type of the object. To check if an object is an instance of `Object`, you can use `typeof types[key] === "object"`.
2. **`Object.prototype.toString.call`**: This method returns a string representation of the object, prefixed with "[object Object]" for objects.

**Pros and Cons**

*   **`typeof`**:
    *   Pros: Fast and lightweight.
    *   Cons: Can be affected by type coercion (e.g., `null` or `undefined` would return `"object"`), and may not work as expected in some cases (e.g., if the object is a primitive value).
*   **`Object.prototype.toString.call`**:
    *   Pros: More accurate than `typeof`, as it returns a specific string representation for objects, regardless of type coercion.
    *   Cons: Slower and heavier than `typeof`.

**Library and Purpose**

In this benchmark, the `Map` and `Set` constructors are used to create instances of these data structures. The `ArrayBuffer` constructor is used to create a buffer object.

**Special JS Feature or Syntax**

This benchmark does not use any special JavaScript features or syntax beyond what's standard in modern JavaScript.

**Other Alternatives**

If you want to check if an object is an instance of `Object`, there are other alternatives:

*   **`instanceof`**: This operator checks if an object is an instance of a given constructor. You can use it like this: `types[key] instanceof Object`.
*   **`Object.create(null)`**: This method creates a new object with no prototype chain, and you can check if it's an instance of `Object` by verifying that its constructor is `Object`.

Keep in mind that these alternatives might have different performance characteristics or behavior depending on the specific use case.

In summary, the benchmark tests two common approaches to checking if an object is an instance of `Object`: using `typeof` and `Object.prototype.toString.call`. The choice between these options depends on your priorities: speed vs. accuracy and robustness.

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/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36

Browser/OS: Chrome 107 on Mac OS X 10.15.7

View result in a separate tab

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

Related benchmarks:

Object.prototype.toString.call vs typeof (only isObject) (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 one month ago):