Benchmark: TextDecoder vs String.fromCharCode vs Spread

Script Preparation code:

var bytes = [84,104,105,115,32,105,115,32,97,32,115,97,109,112,108,101,32,112,97,114,97,103,114,97,112,104,46];
var bufferArray = new Uint16Array(bytes);
var decoder = new TextDecoder(); // default 'utf-8' or 'utf8'

Tests:

String.fromCharCode
String.fromCharCode.apply(null, bufferArray);
TextDecoder
decoder.decode(bufferArray);
String.fromCharCode Spread
String.fromCharCode(...bufferArray);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.fromCharCode
TextDecoder
String.fromCharCode Spread

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 120 on Windows

View result in a separate tab

Test name	Executions per second
String.fromCharCode	3192024.0 Ops/sec
TextDecoder	4678905.0 Ops/sec
String.fromCharCode Spread	2224369.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.

**Benchmark Overview**

The benchmark is designed to compare the performance of three different ways to convert a 16-bit integer array (representing Unicode code points) into a string:

1. `String.fromCharCode.apply(null, bufferArray)` - This method uses the `apply` method to call the `charCodeAt` method on each element of the array, which returns the Unicode code point value.
2. `decoder.decode(bufferArray)` - This method uses the `TextDecoder` API to decode the encoded string in the `bufferArray`. The decoder is created with a default encoding (which defaults to UTF-8).
3. `String.fromCharCode(...bufferArray)` - This method uses the spread operator (`...`) to pass all elements of the array as separate arguments to the `charCodeAt` method.

**Options Compared**

The three options are compared in terms of their performance, measured by the number of executions per second (ExecutionsPerSecond).

**Pros and Cons of Each Approach:**

1. `String.fromCharCode.apply(null, bufferArray)`.
	* Pros:
		+ Portable across different browsers.
		+ Simple and well-known API.
	* Cons:
		+ May be slower due to the use of `apply` and multiple method calls.
2. `decoder.decode(bufferArray)`.
	* Pros:
		+ Efficient decoding of encoded strings.
	* Cons:
		+ Requires a TextDecoder object, which may not be available in all browsers or environments.
3. `String.fromCharCode(...bufferArray)`.
	* Pros:
		+ Similar to the first option, but with a more concise syntax.
	* Cons:
		+ May still incur performance overhead due to multiple method calls.

**Library and Purpose**

The `TextDecoder` API is a built-in JavaScript library that provides an efficient way to decode encoded strings. It's part of the Web APIs and is supported by modern browsers.

**Special JS Feature/Syntax (None)**

There are no special JavaScript features or syntaxes being used in this benchmark.

**Alternative Approaches**

Other alternatives could include:

* Using a `Buffer` class with the `toString()` method to convert the array to a string.
* Using a library like `utf8js` to encode and decode strings.
* Implementing a custom converter using bitwise operations (e.g., using bit shifts and masks).

However, these approaches would likely be less efficient or more complex than the three options being compared in this benchmark.

Related benchmarks:

TextDecoder vs String.fromCharCode vs Spread (version: 0)

Comparing performance of: String.fromCharCode vs TextDecoder vs String.fromCharCode Spread

Created: 2 years ago by: Guest

Jump to the latest result

String.fromCharCode

TextDecoder

String.fromCharCode Spread

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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