Benchmark: Object.prototype.toString.call vs typeof

Object.prototype.toString.call vs typeof (version: 0)

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

Created: 4 years ago by: Registered User

Jump to the latest result

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 months ago)

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

Browser/OS: Firefox 141 on Windows

View result in a separate tab

Test name	Executions per second
typeof -> string	27567416.0 Ops/sec
Object.prototype.toString.call -> string	3991418.0 Ops/sec
typeof -> boolean	15027905.0 Ops/sec
Object.prototype.toString.call -> boolean	4075635.5 Ops/sec
typeof -> object	12846283.0 Ops/sec
Object.prototype.toString.call -> object	3999299.0 Ops/sec
typeof -> function	24192610.0 Ops/sec
Object.prototype.toString.call -> function	4457707.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is testing two approaches to determine the type of a value in JavaScript:

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

Both approaches are being compared for different data types (string, boolean, object, function, array, number, map, set, and buffer).

**Options Compared**

The benchmark is comparing two options for each data type:

* `typeof` operator: returns a string value indicating the type of the operand
* `Object.prototype.toString.call()`: returns a string value indicating the type of the operand

**Pros and Cons of Each Approach**

1. `typeof` operator:
	* Pros:
		+ Faster execution, as it's a built-in operator
		+ More concise code
	* Cons:
		+ May not work correctly for all types (e.g., `Object`)
		+ May return `NaN` for some numeric values
2. `Object.prototype.toString.call()` method:
	* Pros:
		+ Works correctly for all types, including `Object`
		+ Returns a string value that includes the type name
	* Cons:
		+ Slower execution compared to `typeof`
		+ More verbose code

**Library and Purpose**

The benchmark uses the `Map` and `Set` objects from the JavaScript standard library. The purpose is to test how each approach handles these types.

**Special JS Feature or Syntax**

There are no special features or syntaxes being tested in this benchmark. It's focused on comparing two common approaches for type checking.

**Other Considerations**

When writing your own benchmarks, consider the following:

* Use a large dataset with diverse types to ensure representative results
* Optimize code for performance and conciseness
* Test for edge cases and corner scenarios
* Use a reliable timing mechanism to avoid false positives

**Alternatives**

If you're looking for alternatives or variations on this benchmark, consider:

* Testing other type checking approaches, such as `instanceof` or using a library like Lodash's `typeCheck`
* Adding more data types, such as `RegExp`, `Date`, or `Error`
* Increasing the size of the dataset or adding more complex scenarios
* Comparing performance with different JavaScript engines or environments

Related benchmarks: