Benchmark: String to number conversion in Vanilla JS + number to string

Script Preparation code:

var toTest = [undefined, null, '-1','-1.1', '1', '100000', 'aaaa'];
var toTestString = ['uuid', 1, 100000, 'abcdefghij', 23456, 345, '1234']

Tests:

+
toTest.map((item) => (+item));
Number
toTest.map(Number);
parseInt
toTest.map(parseInt);
parseFloat
toTest.map(parseFloat);
String()
toTestString.map(String)
`${}`
toTestString.map(k => `${k}`)
nothing
toTestString.map(k => k)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
+
Number
parseInt
parseFloat
String()
`${}`
nothing

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net. The goal is to compare the performance of different methods for converting strings to numbers.

**Test Cases**

There are six test cases, each testing a specific method:

1. `nothing`: Tests the original array without any conversion.
2. `String()`: Tests using the `String()` function to convert numeric values.
3. ``${}``: Tests using template literals with `${}` placeholders for string concatenation.
4. `+`: Tests using the unary plus operator (`+`) to coerce strings to numbers.
5. `Number`: Tests using the `Number()` function to convert strings to numbers.
6. `parseInt` and `parseFloat`: Tests using the `parseInt()` and `parseFloat()` functions to convert strings to numbers.

**Options Compared**

The benchmark compares the performance of different methods for converting strings to numbers:

* Coercion using unary operators (`+`, `-`)
* Using the `Number()` function
* Using the `String()` function to coerce numeric values
* Using template literals with `${}` placeholders
* Using `parseInt()` and `parseFloat()` functions

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **Coercion using unary operators (`+`, `-`)**:
	* Pros: Simple, widely supported, and efficient.
	* Cons: Can be brittle if not properly handled (e.g., `NaN` values).
2. **Using the `Number()` function**:
	* Pros: Robust and safe, handles `NaN` values well.
	* Cons: May have performance implications due to additional overhead.
3. **Using the `String()` function**:
	* Pros: Simple and efficient for numeric values.
	* Cons: Can be slower or more memory-intensive when applied to non-numeric strings.
4. **Using template literals with `${}` placeholders**:
	* Pros: Concise, readable, and flexible.
	* Cons: May require additional configuration or setup (e.g., parsing error handling).
5. `parseInt()` and `parseFloat()` functions**:
	* Pros: Robust and safe for numeric values, handle errors well.
	* Cons: Can be slower due to additional overhead.

**Library Usage**

The benchmark uses the following JavaScript libraries:

* None explicitly mentioned in the provided code snippets.

**Special JS Features/Syntax**

No special JavaScript features or syntax are used beyond the standard operators (`+`, `-`, `Number()`, `String()`, `parseInt()`, and `parseFloat()`).

**Other Alternatives**

If you need to perform string-to-number conversions, other alternatives might include:

* Regular expressions (e.g., `\d+`)
* Math libraries (e.g., `mathjs` or `numeric-js`)
* Custom conversion functions using Arrow functions or Promises

Keep in mind that the best approach depends on your specific use case and performance requirements. MeasureThat.net's benchmark helps you evaluate different methods under a standardized environment, which can be useful for informed decision-making.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36

Browser/OS: Chrome 121 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
+	7556856.0 Ops/sec
Number	4853251.5 Ops/sec
parseInt	4015633.0 Ops/sec
parseFloat	4305946.0 Ops/sec
String()	6591342.0 Ops/sec
`${}`	15070124.0 Ops/sec
nothing	17105246.0 Ops/sec

Related benchmarks:

String to number conversion in Vanilla JS + number to string (version: 0)

Comparing performance of: + vs Number vs parseInt vs parseFloat vs String() vs `${}` vs nothing

Created: 10 months ago by: Guest

Jump to the latest result

+

Number

parseInt

parseFloat

String()

`${}`

nothing

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