Benchmark: parseInt vs Number vs Number/Number.isInteger

Script Preparation code:

var ids = ['678', '604%2C700', '780', '0', '        ', '123.8']
var someConstant = 200;

Tests:

Basic
var res = ids.filter((id) => Number(id) !== someConstant);
Basic with Number check
var res = ids.filter((id) => Number(id) && Number(id) !== someConstant);
Basic with Number and isInteger check
var res = ids.filter((id) => Number(id) && Number.isInteger(Number(id)) && Number(id) !== someConstant);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Basic
Basic with Number check
Basic with Number and isInteger check

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 139 on Windows

View result in a separate tab

Test name	Executions per second
Basic	7868355.5 Ops/sec
Basic with Number check	7990624.0 Ops/sec
Basic with Number and isInteger check	7102243.5 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.

**Overview**

The benchmark tests three different ways to compare a value to a constant using the `Number` function in JavaScript. The values are strings that may or may not represent integers, and the goal is to determine which approach is the fastest.

**Options Compared**

1. **Basic**: Using `Number(id) !== someConstant`. This checks if the string representation of the number is not equal to the constant.
2. **Basic with Number check**: Using `Number(id) && Number(id) !== someConstant`. This checks two things: first, that the string representation of the number is a valid number (`Number(id)`), and second, that it's not equal to the constant.
3. **Basic with Number and isInteger check**: Using `Number(id) && Number.isInteger(Number(id)) && Number(id) !== someConstant`. This checks three things: first, that the string representation of the number is a valid number (`Number(id)`), second, that it's an integer (using `Number.isInteger`), and third, that it's not equal to the constant.

**Pros and Cons**

1. **Basic**: Fastest approach, as it only checks if the string representation of the number is not equal to the constant.
	* Pros: Simple and fast.
	* Cons: May return incorrect results for certain edge cases (e.g., strings that represent numbers like "123.8").
2. **Basic with Number check**: Slightly slower than Basic, but provides additional information about the validity of the number.
	* Pros: Provides more robust error handling and can help catch invalid inputs.
	* Cons: Adds an extra step to the comparison, which may slow it down slightly.
3. **Basic with Number and isInteger check**: Slowest approach, as it checks multiple conditions.
	* Pros: Provides comprehensive validation of the input data, including whether it's a valid integer.
	* Cons: Slower than Basic due to the additional checks.

**Library/Functionality**

The benchmark uses two built-in JavaScript functions:

1. `Number()`: Converts a string or other value to a number.
2. `Number.isInteger()`: Returns a boolean indicating whether a given number is an integer.

**Special JS Feature/Syntax**

There's no special JavaScript feature or syntax being tested here, as it's all standard built-in functionality.

**Other Alternatives**

If you were to rewrite this benchmark using different approaches, you might consider:

1. Using `parseInt()` instead of `Number()`, which would allow for more fine-grained control over the parsing process.
2. Implementing your own custom comparison function that takes into account specific requirements or edge cases.
3. Using a library like Lodash or Ramda to provide additional utility functions for working with numbers and arrays.

However, given the simplicity and expressiveness of JavaScript's built-in `Number` and `Number.isInteger` functions, it's likely that this benchmark is well-suited to demonstrate their performance characteristics.

Related benchmarks:

parseInt vs Number vs Number/Number.isInteger (version: 0)

Comparing performance of: Basic vs Basic with Number check vs Basic with Number and isInteger check

Created: 3 years ago by: Guest

Jump to the latest result

Basic

Basic with Number check

Basic with Number and isInteger check

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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