Benchmark: typeof function vs call in function

Script Preparation code:

var fn = function(){};
var obj = {};
var objNull = null;
var unknown; // undefined

Tests:

typeof function
var isFuncTrue = typeof fn === 'function'; var isFuncFalse = typeof obj === 'function'; var isFuncFalse2 = typeof objNull === 'function'; var isFuncFalse3 = typeof unknown === 'function';
call in function
var isFuncTrue = fn && 'call' in fn; var isFuncFalse = obj && 'call' in obj; var isFuncFalse2 = objNull && 'call' in objNull; var isFuncFalse3 = unknown && 'call' in unknown;
!!fn?.call
var isFuncTrue = !!fn?.call; var isFuncFalse = !!obj?.call; var isFuncFalse2 = !!objNull?.call; var isFuncFalse3 = !!unknown?.call;
fn?.call != null
var isFuncTrue = fn?.call != null; var isFuncFalse = obj?.call != null; var isFuncFalse2 = objNull?.call != null; var isFuncFalse3 = unknown?.call != null;
fn?.call != void 0
var isFuncTrue = fn?.call != void 0; var isFuncFalse = obj?.call != void 0; var isFuncFalse2 = objNull?.call != void 0; var isFuncFalse3 = unknown?.call != void 0;
isFuncTrue = fn?.call != undefined;
var isFuncTrue = fn?.call != undefined; var isFuncFalse = obj?.call != undefined; var isFuncFalse2 = objNull?.call != undefined; var isFuncFalse3 = unknown?.call != undefined;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
typeof function
call in function
!!fn?.call
fn?.call != null
fn?.call != void 0
isFuncTrue = fn?.call != undefined;

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.1.1

View result in a separate tab

Test name	Executions per second
typeof function	9300926.0 Ops/sec
call in function	6173735.5 Ops/sec
!!fn?.call	6911329.0 Ops/sec
fn?.call != null	9090097.0 Ops/sec
fn?.call != void 0	8914031.0 Ops/sec
isFuncTrue = fn?.call != undefined;	2929500.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

The provided benchmark tests the performance of different ways to check if a value is a function in JavaScript. The test cases compare the following approaches:

1. Using `typeof` operator (`typeof fn === 'function'`)
2. Checking if an object has a `call` property using the `in` operator (`'call' in obj`)
3. Using optional chaining (`!!fn?.call`)
4. Checking if the result of calling a value with `()` is not null or undefined (`fn?.call != null`, `fn?.call != void 0`, and `fn?.call != undefined`)

**Options comparison**

Each test case compares two approaches:

* The first approach is the one being tested.
* The second approach is a common alternative.

For example, in the "typeof function" test case, the first approach uses `typeof fn === 'function'`, while the second approach uses `'call' in fn`.

**Pros and cons of each approach**

1. **`typeof` operator**: This approach is simple and widely supported. However, it can be slower than other approaches because it involves a string comparison.
2. **Checking if an object has a `call` property using `in` operator**: This approach is fast because it only checks if the property exists, but it may not work for all types of values (e.g., strings).
3. **Optional chaining (`!!fn?.call`)**: This approach is concise and modern, but it requires support for optional chaining in older browsers.
4. **Checking if the result of calling a value with `()` is not null or undefined**: This approach is simple and can be faster than using `typeof` or checking for `call` property, but it may not work for all types of values (e.g., objects without `call` method).

**Library usage**

None of the test cases use any external libraries.

**Special JavaScript features or syntax**

The benchmark uses optional chaining (`!!fn?.call`) and the `in` operator to check if an object has a `call` property. These are modern JavaScript features introduced in ECMAScript 2018 (ES2018).

**Other alternatives**

Other approaches that could be used to test this benchmark include:

* Using a function constructor (`new Function()`): This approach is slower than checking for the existence of a `call` property.
* Using a closure: This approach is not relevant to this specific benchmark.

Note that these alternative approaches may not be as efficient or concise as the ones being tested, and may not work in all cases.

Related benchmarks:

typeof function vs call in function (version: 0)

Comparing performance of: typeof function vs call in function vs !!fn?.call vs fn?.call != null vs fn?.call != void 0 vs isFuncTrue = fn?.call != undefined;

Created: one year ago by: Guest

Jump to the latest result

typeof function

call in function

!!fn?.call

fn?.call != null

fn?.call != void 0

isFuncTrue = fn?.call != undefined;

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):