Benchmark: Number Conversion Speed

Script Preparation code:

var mb1 = 'abc';
var mb2 = '123';

var unary = (a) => {
  try {
    +a;
    return true;
  } catch {
    return false;
  }
};
var number = (a) => !isNaN(Number(a));
var numberNum = (a) => !Number.isNaN(Number(a));
var float = (a) => !isNaN(parseFloat(a));
var floatNum = (a) => !Number.isNaN(parseFloat(a));
var int = (a) => !isNaN(parseInt(a));
var intNum = (a) => !Number.isNaN(parseInt(a));
var nanNull = (a) => a !== null && !isNaN(a);

Tests:

unary
unary(mb1); unary(mb2);
number
number(mb1); number(mb2);
numberNum
numberNum(mb1); numberNum(mb2);
int
int(mb1); int(mb2);
intNum
intNum(mb1); intNum(mb2);
float
float(mb1); float(mb2);
floatNum
floatNum(mb1); floatNum(mb2);
nanNull
nanNull(mb1); nanNull(mb2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
unary
number
numberNum
int
intNum
float
floatNum
nanNull

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and test cases to explain what's being tested, compared, and their pros and cons.

**Benchmark Definition:**

The benchmark is named "Number Conversion Speed" and measures how fast different JavaScript functions can convert strings to numbers. The script preparation code defines eight functions:

1. `unary(a)`: attempts to implicitly convert the string `a` to a number using unary plus (`+a`) and returns true if successful, false otherwise.
2. `number(a)`: checks if the string `a` is not null and can be converted to a number using `Number(a)` and returns true if successful, false otherwise.
3. `numberNum(a)`: checks if the string `a` can be converted to a number using `Number(a)` and returns true if successful, false otherwise (similar to `number(a)` but with a slightly different implementation).
4. `int(a)`: attempts to implicitly convert the string `a` to an integer using `parseInt(a)` and returns true if successful, false otherwise.
5. `intNum(a)`: checks if the string `a` can be converted to an integer using `parseInt(a)` and returns true if successful, false otherwise (similar to `int(a)` but with a slightly different implementation).
6. `float(a)`: attempts to implicitly convert the string `a` to a float using `parseFloat(a)` and returns true if successful, false otherwise.
7. `floatNum(a)`: checks if the string `a` can be converted to a float using `parseFloat(a)` and returns true if successful, false otherwise (similar to `float(a)` but with a slightly different implementation).
8. `nanNull(a)`: checks if the string `a` is not null and does not represent NaN (Not a Number) values.

**Test Cases:**

The benchmark consists of eight test cases, each calling one of the above functions with two input strings (`mb1` and `mb2`). The tests measure the execution time for each function, comparing the performance of different approaches.

**Comparison Options:**

Here are some key comparison options:

* **Implicit vs. Explicit Conversion**: `unary(a)`, `int(a)`, and `float(a)` use implicit conversion, while `number(a)`, `numberNum(a)`, `intNum(a)`, `floatNum(a)`, and `nanNull(a)` use explicit conversion (`Number(a)`, `parseInt(a)`, `parseFloat(a)`).
* **Checking for NaN**: `nanNull(a)` checks if the input string represents a NaN value, while other functions assume the input is a valid number.

**Pros and Cons:**

Here are some pros and cons for each approach:

* **Implicit Conversion (unary, int, float)**:
	+ Pros: potentially faster since fewer operations are needed.
	+ Cons: may throw errors if the input string cannot be converted to a number.
* **Explicit Conversion (number, numberNum, intNum, floatNum)**:
	+ Pros: safer since it checks for NaN values and handles invalid inputs more robustly.
	+ Cons: potentially slower due to additional operations.

**Conclusion:**

The benchmark measures the performance of different JavaScript functions for converting strings to numbers. The test cases provide a comprehensive comparison of implicit vs. explicit conversion approaches, as well as the importance of checking for NaN values. By understanding these trade-offs, developers can choose the best approach for their specific use case and optimize their code for better performance.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36

Browser/OS: Chrome 101 on Linux

View result in a separate tab

Test name	Executions per second
unary	2027073.9 Ops/sec
number	651565.9 Ops/sec
numberNum	699605.9 Ops/sec
int	505600.0 Ops/sec
intNum	532053.6 Ops/sec
float	556496.6 Ops/sec
floatNum	559483.6 Ops/sec
nanNull	936585.4 Ops/sec

Related benchmarks:

Number Conversion Speed (version: 0)

Comparing performance of: unary vs number vs numberNum vs int vs intNum vs float vs floatNum vs nanNull

Created: 2 years ago by: Guest

Jump to the latest result

unary

number

numberNum

int

intNum

float

floatNum

nanNull

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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