Benchmark: Number.isInteger() vs typeof

Tests:

Number.isInteger() positive
Number.isInteger(3) === true
typeof positive
typeof 3 === "number";
Number.isInteger() negative
Number.isInteger("three") === false
typeof negative
typeof "three" === "number";

Historical Performance Data aggregated from 10 community runs

Desktop Results:

Chrome 10 runs

typeof negative

178.9M/s

typeof positive

175.0M/s

Number.isInteger() positive

140.8M/s

Number.isInteger() negative

139.4M/s

Fastest: typeof negative (1.3x faster)

View exact numbers

✓ typeof negative: 178,884,064 ops/sec
• typeof positive: 174,995,712 ops/sec
• Number.isInteger() positive: 140,822,112 ops/sec
• Number.isInteger() negative: 139,442,560 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
Number.isInteger() positive
typeof positive
Number.isInteger() negative
typeof negative

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:136.0) Gecko/20100101 Firefox/136.0

Browser/OS: Firefox 136 on Linux

View result in a separate tab

typeof positive

1531.8M/s

typeof negative

1497.4M/s

Number.isInteger() negative

1445.3M/s

Number.isInteger() positive

1311.5M/s

View exact numbers

Test name	Executions per second
✓ typeof positive	1,531,819,392 Ops/sec
typeof negative	1,497,396,352 Ops/sec
Number.isInteger() negative	1,445,254,912 Ops/sec
Number.isInteger() positive	1,311,527,296 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into explaining the benchmark and its various components.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark test case created using MeasureThat.net. The test case compares two approaches: `Number.isInteger()` and `typeof` to detect if a variable is an integer.

**Approaches Compared**

There are two main approaches being compared:

1. **`Number.isInteger()`**: This method checks if a value is an integer by returning `true` if it's equal to its integer value (i.e., `3 === 3`) and `false` otherwise.
2. **`typeof` with string comparison**: This approach uses the `typeof` operator to check if a variable is of type "number". To avoid false positives, a string comparison is used (`"number"`), so that even non-numeric strings are treated as not being numbers.

**Pros and Cons**

**`Number.isInteger()`**:

Pros:

* More explicit and intuitive way to check for integers.
* Often preferred in modern JavaScript code due to its readability and maintainability.

Cons:

* May be slower than `typeof` due to the additional comparison step.
* Can be less efficient if used with non-integer values, as it will still perform a type check.

**`typeof` with string comparison**:

Pros:

* Faster and more lightweight compared to `Number.isInteger()`.
* Can handle non-numeric strings correctly without causing false positives.

Cons:

* Less readable and maintainable due to the use of string literals.
* May be less intuitive for developers familiar with `Number.isInteger()`.

**Library and Special Features**

There are no libraries used in this benchmark. However, it's worth noting that `Number.isInteger()` is a built-in JavaScript method introduced in ECMAScript 2015 (ES6).

**Special JS Feature/ Syntax**

There are no special features or syntaxes being tested here, as both approaches use standard JavaScript language constructs.

**Other Considerations**

* The benchmark assumes that the input values will be either integers (`3`) or strings (`"three"`).
* The `typeof` approach with string comparison may not work correctly for non-numeric values (e.g., `NaN`, objects, etc.).
* Other optimizations, such as using `Number()` instead of implicit conversion, could potentially improve performance.

**Alternatives**

Some alternative approaches to detect integers in JavaScript include:

1. Using a regex pattern (`^[0-9]+$`) to match only numeric strings.
2. Utilizing the `Number()` function with a strict equality check (`Number(x) === x`).
3. Leveraging modern JavaScript features, such as `Int32Array` or `BigInt`, for more efficient integer checks (not applicable in this benchmark).

These alternatives may offer different trade-offs between performance, readability, and maintainability, depending on the specific use case and requirements.

Number.isInteger() vs typeof (version: 0)

Is it faster to detect if a variable is an integer or is it faster to use typeof to verify the type?

Comparing performance of: `Number.isInteger() positive vs typeof positive vs Number.isInteger() negative vs typeof negative`

Created: 2 years ago by: Registered User

Go to the latest result

Number.isInteger() positive

typeof positive

Number.isInteger() negative

typeof negative

Historical Performance Data aggregated from 10 community runs

Desktop Results:

Chrome 10 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Number.isInteger() vs typeof (version: 0)

Is it faster to detect if a variable is an integer or is it faster to use typeof to verify the type?

Comparing performance of: Number.isInteger() positive vs typeof positive vs Number.isInteger() negative vs typeof negative

Created: 2 years ago by: Registered User

Go to the latest result

Number.isInteger() positive

typeof positive

Number.isInteger() negative

typeof negative

Historical Performance Data aggregated from 10 community runs

Desktop Results:

Chrome 10 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: `Number.isInteger() positive vs typeof positive vs Number.isInteger() negative vs typeof negative`