Benchmark: Check function. typeof vs constructor + null check

Script Preparation code:

var fun = a => {};

Tests:

typeof
typeof(fun) === 'function'
constructor
fun && fun.constructor === Function

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

typeof

73.7M/s

constructor

67.5M/s

View exact numbers

✓ typeof: 73,673,848 ops/sec
• constructor: 67,542,336 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
typeof
constructor

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 132 on Windows

View result in a separate tab

typeof

125.0M/s

constructor

114.8M/s

View exact numbers

Test name	Executions per second
✓ typeof	125,031,360 Ops/sec
constructor	114,784,432 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 JSON for the JavaScript microbenchmark on MeasureThat.net.

**Benchmark Definition**

The benchmark is designed to measure the performance difference between two approaches:

1. `typeof(a => {}) === 'function'`
2. `(a => {}).constructor === Function`

These approaches aim to check if a function is defined, but they do so in slightly different ways.

**Options Compared**

There are two main options being compared:

1. **`typeof(a => {}) === 'function'`**: This approach uses the `typeof` operator to check the type of an expression. It's a simple and widely supported way to determine if something is a function.
2. **`(a => {}).constructor === Function`**: This approach uses the property access syntax `(a => {}).constructor` to get the constructor property of an object, and then compares it to `Function`. This method assumes that every function has a constructor property set to the `Function` class.

**Pros and Cons**

1. **`typeof(a => {}) === 'function'`**:
	* Pros: Simple, widely supported, easy to read.
	* Cons: May not be as efficient due to the use of `typeof`, which can involve some overhead for type checking.
2. **`(a => {}).constructor === Function`**:
	* Pros: More explicit and clear about what it's doing, potentially more efficient since it avoids using `typeof`.
	* Cons: Requires the object has a constructor property set to `Function`, which might not be the case in all situations (e.g., when using `Set` or other non-function constructors).

**Library Usage**

There is no explicit library usage mentioned in this benchmark.

**Special JS Features/Syntax**

There are two special features/syntax used:

1. **Arrow function syntax (`a => {}`)**: This syntax is used to define a small anonymous function.
2. **Property access syntax (`(a => {}).constructor === Function`)**: This syntax is used to access the `constructor` property of an object.

**Other Considerations**

When writing JavaScript code, it's essential to consider performance-critical parts of your application and optimize them when necessary. In this case, the benchmark is designed to measure the performance difference between two approaches, allowing developers to make informed decisions about which one to use in their own code.

**Alternatives**

If you need more control over how `typeof` behaves or want a more explicit way to check if something is a function, you could consider using other methods:

1. **`function(a) {}()`**: This approach creates an immediately invoked function expression (IIFE) and checks if it returns the expected result.
2. **`a.__proto__ === Function.prototype`**: This method checks if the prototype of `a` is set to `Function.prototype`.

Keep in mind that these alternatives might have different trade-offs in terms of performance, readability, or compatibility with older browsers.

In summary, this benchmark provides a clear comparison between two approaches for checking if something is a function. Understanding the pros and cons of each approach can help developers make informed decisions about which one to use in their own code.

Check function. typeof vs constructor + null check (version: 1)

Difference between typeof(a => {}) === 'function' and (a => {}).constructor === Function

Comparing performance of: `typeof vs constructor`

Created: 7 years ago by: Registered User

Go to the latest result

typeof

constructor

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Check function. typeof vs constructor + null check (version: 1)

Difference between typeof(a => {}) === 'function' and (a => {}).constructor === Function

Comparing performance of: typeof vs constructor

Created: 7 years ago by: Registered User

Go to the latest result

typeof

constructor

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `typeof vs constructor`