Benchmark: typeof vs instanceof Function

Script Preparation code:

var f = () => {};

Tests:

instanceof
f instanceof Function
typeof
typeof f === 'function'

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof
typeof

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36

Browser/OS: Chrome 147 on Windows

View result in a separate tab

Test name	Executions per second
instanceof	52346064.0 Ops/sec
typeof	60576100.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 provided benchmark and its results.

**Benchmark Definition**

The benchmark is defined by a JSON object that contains information about the test. Here, we have two individual test cases:

* `typeof f === 'function'`
* `f instanceof Function`

Both tests aim to measure the performance of JavaScript's `typeof` operator and the `instanceof` operator.

**Options Compared**

In this benchmark, only two options are compared:

1. Using `typeof` to check if a value is a function
2. Using `instanceof` to check if an object is an instance of a constructor function

**Pros and Cons**

* **`typeof` approach:**
	+ Pros:
		- Easy to implement and understand.
		- Fast, as it uses a simple string comparison.
	+ Cons:
		- May not work correctly for all types of functions (e.g., arrow functions).
		- Can return incorrect results if the function is `null` or `undefined`.
* **`instanceof` approach:**
	+ Pros:
		- More accurate and robust than `typeof`, especially for function objects.
		- Handles edge cases like `null` and `undefined` correctly.
	+ Cons:
		- Can be slower due to the creation of a temporary object.

**Library**

In this benchmark, no external libraries are used. The tests only rely on native JavaScript features.

**Special JS Feature or Syntax**

None is mentioned in this specific benchmark.

**Benchmark Preparation Code**

The preparation code for each test case is:

* `var f = () => {};`

This creates an anonymous function `f`, which is a valid JavaScript expression. This allows us to focus on the performance comparison between `typeof` and `instanceof`.

**Individual Test Cases**

We have two test cases:

1. **`instanceof`**: Tests whether `f` (the created function) is an instance of the `Function` constructor using `instanceof`.
2. **`typeof`**: Tests whether `f` (the created function) has a type of `'function'` using `typeof`.

**Latest Benchmark Result**

The latest benchmark result shows the performance metrics for both test cases:

* `typeof f === 'function'`: 113437992 executions per second
* `f instanceof Function`: 808455168 executions per second

Based on this, it appears that `instanceof` is generally faster than using `typeof` to check if a value is a function.

**Other Alternatives**

There are other alternatives for checking if a value is a function in JavaScript:

* Using the `Function` constructor directly: `new Function()` (not recommended due to security concerns)
* Using the `is-function` library or polyfill
* Using other libraries like Lodash's `isFunction`

However, these alternatives are not part of this specific benchmark, which focuses on comparing native JavaScript features.

Related benchmarks:

typeof vs instanceof Function (version: 0)

Comparing performance of: instanceof vs typeof

Created: 6 years ago by: Guest

Jump to the latest result

instanceof

typeof

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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