Benchmark: JSON.stringify VS toString VS Template String

Script Preparation code:

var value = 80_000

function stringify(number){ 
  return JSON.stringify(number)
}

function toString(number){
  return (number).toString()
}

function templateString(number){
  return `${number}`
}

const teste = stringify(value)
console.log(typeof teste, teste)

Tests:

JSON.stringify
stringify(value)
toString
toString(value)
Template String
templateString(value)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON.stringify
toString
Template String

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36

Browser/OS: Chrome 106 on Linux

View result in a separate tab

Test name	Executions per second
JSON.stringify	2458792.8 Ops/sec
toString	7639538.5 Ops/sec
Template String	7350548.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Purpose**

The provided benchmark compares the performance of three different ways to convert a large number (80,000) to a string: `JSON.stringify()`, `toString()`, and template literals (`${number}`).

**Options Compared**

1. **`JSON.stringify()`**: Converts the input object to a JSON string.
2. **`toString()`**: Returns the value of the object as a string using the built-in `toString()` method.
3. **Template Literals (`${number}`)**: A new way of creating strings in JavaScript, introduced in ECMAScript 2015.

**Pros and Cons**

1. **`JSON.stringify()`**:
	* Pros: Can be used to convert objects to strings, can handle complex data structures, but may lead to performance issues with very large inputs.
	* Cons: May not work as expected with certain types of objects or arrays, can be slow for very large inputs due to the overhead of encoding and decoding the JSON string.
2. **`toString()`**:
	* Pros: Simple and widely supported, fast execution time for small to medium-sized numbers.
	* Cons: May lead to performance issues when dealing with very large numbers due to the need to convert each digit individually.
3. **Template Literals (`${number}`)**:
	* Pros: Fast execution time for both small and large numbers, simple syntax, and widely supported.
	* Cons: May not be familiar to some developers, especially those without experience with modern JavaScript features.

**Library Used**

None, the benchmark uses built-in JavaScript functions and operators.

**Special JS Features/Syntax**

Template literals are a relatively new feature in JavaScript, introduced in ECMAScript 2015. They allow for more readable and efficient string creation by inserting expressions into template strings using `${}`. In this benchmark, template literals are used to convert the number to a string in a concise and expressive way.

**Alternative Approaches**

Other approaches to converting numbers to strings might include:

* Using `Number()` or `BigInt()` functions
* Creating an array of digits and joining them together using `join()`
* Using regex or other string manipulation techniques

However, these alternatives are likely to be slower than the methods used in this benchmark.

Related benchmarks:

JSON.stringify VS toString VS Template String (version: 0)

Comparing performance of: JSON.stringify vs toString vs Template String

Created: one year ago by: Guest

Jump to the latest result

JSON.stringify

toString

Template String

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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