Benchmark: JSON.Stringify vs TextEncoder

Script Preparation code:

var i = 0;
var initialString = "This is the initial Test String";
var encoder = new TextEncoder();
var bufArray = new Uint8Array(initialString.length * 2)
var view = encoder.encode(initialString);
var initialObject = {someString: initialString};
var initialStringify = JSON.stringify(initialObject);

Tests:

Encode
var newString = "This is the updated Test String"; var view = encoder.encode(newString); if (i == 5000) console.log(view); i++;
EncodeInto
var newString = "This is the updated Test String"; var view = encoder.encodeInto(newString, bufArray); if (i == 5000) console.log(view); i++;
JSON.Stringify
var newString = "This is the updated Test String"; var object = {someString: newString}; var stringify = JSON.stringify(object); if (i == 5000) console.log(stringify); i++;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Encode
EncodeInto
JSON.Stringify

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 138 on Android

View result in a separate tab

Test name	Executions per second
Encode	451971.8 Ops/sec
EncodeInto	3070067.8 Ops/sec
JSON.Stringify	4296638.5 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The provided benchmark compares the performance of three different approaches:

1.  **TextEncoder**: A built-in JavaScript API for encoding strings to Uint8Array buffers, which can be used for various purposes like sending data over a network or storing binary data in storage.
2.  **JSON.Stringify**: A built-in JavaScript method that converts a JavaScript object to a JSON string.

**Options Compared**

The benchmark compares the performance of `TextEncoder` and `JSON.Stringify` under two different scenarios:

1.  **Encode**: This test case measures the time taken by both approaches to encode a single string into a Uint8Array buffer.
2.  **EncodeInto**: This test case measures the time taken by both approaches to encode a string directly into a Uint8Array buffer, without creating an intermediate buffer.

**Pros and Cons**

*   **TextEncoder:**
    *   Pros:
        *   More efficient for encoding large strings or binary data.
        *   Can be used with `Uint8Array` to store binary data in storage.
        *   Provides better control over the encoding process, including support for Unicode characters.
    *   Cons:
        *   Requires JavaScript 2015+ features (e.g., `text-encoding` polyfill).
        *   May require additional setup or configuration for some use cases.

*   **JSON.Stringify:**
    *   Pros:
        *   Widely supported and well-maintained.
        *   Can be used to convert objects to strings in a simple, human-readable format.
    *   Cons:
        *   Less efficient than `TextEncoder` for encoding large strings or binary data.
        *   May result in larger encoded strings due to the use of quotes and escaping.

**Library: TextEncoder**

The `TextEncoder` library is a built-in JavaScript API that provides an efficient way to encode strings to Uint8Array buffers. It was introduced in ECMAScript 2015 (ES6) and is widely supported across modern browsers. The library allows developers to specify the encoding scheme, handling of surrogate pairs, and other options.

**Special JS Feature: Arrow Functions**

The benchmark includes arrow functions (`() =>`) which are a concise way to define small functions in JavaScript. They were introduced in ECMAScript 2015 (ES6) as part of the language standard. The arrow function syntax is used in some test cases, such as `var view = encoder.encode(newString);`.

**Other Alternatives**

If you're interested in exploring alternative approaches for encoding strings or converting objects to JSON strings, consider the following options:

*   **Blob**: You can use `Blob` objects to create binary data and send it over a network or store it in storage.
*   **Buffer**: If you need to work with raw binary data, `Buffer` (a Node.js module) provides an efficient way to manipulate binary data.
*   **JSON.stringify() with custom replacer**: You can use the `replacer` option with `JSON.stringify()` to customize how objects are converted to strings.

Keep in mind that these alternatives may have different performance characteristics and use cases compared to `TextEncoder` and `JSON.Stringify`.

Hope this helps you understand what's being tested on MeasureThat.net.

Related benchmarks:

JSON.Stringify vs TextEncoder (version: 0)

Comparing performance of: Encode vs EncodeInto vs JSON.Stringify

Created: 3 years ago by: Guest

Jump to the latest result

Encode

EncodeInto

JSON.Stringify

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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