Benchmark: TextDecoder vs String.fromCharCode vs String.fromCodePoint

Script Preparation code:

var [testDecode, testFCCodeBuf, testFCCodeArr, testFCPointBuf, testFCPointArr] = (function(){
  "use strict";
  var bytesArray = [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 Uint8Array(bytesArray);
  var decoder = new TextDecoder(); // default 'utf-8' or 'utf8'
  var {fromCharCode, fromCodePoint} = String;
  var retStr = "";
  self.getRetStr = function() {return retStr};
  
  function testDecode() {
  	for (var i=0; i < 256; i=i+1|0) retStr = "" + decoder.decode(bufferArray);
  }
  function testFCCodeBuf() {
  	for (var i=0; i < 256; i=i+1|0) retStr = "" + fromCharCode.apply(null, bufferArray);
  }
  function testFCCodeArr() {
  	for (var i=0; i < 256; i=i+1|0) retStr = "" + fromCharCode.apply(null, bytesArray);
  }
  function testFCPointBuf() {
  	for (var i=0; i < 256; i=i+1|0) retStr = "" + fromCodePoint.apply(null, bufferArray);
  }
  function testFCPointArr() {
  	for (var i=0; i < 256; i=i+1|0) retStr = "" + fromCodePoint.apply(null, bytesArray);
  }
  
  return [testDecode, testFCCodeBuf, testFCCodeArr, testFCPointBuf, testFCPointArr];
})();

Tests:

TextDecoder on Uint8Array
testDecode();
String.fromCharCode on Uint8Array
testFCCodeBuf();
String.fromCharCode on Array
testFCCodeArr();
String.fromCodePoint on Uint8Array
testFCPointBuf();
String.fromCodePoint on Array
testFCPointArr();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
TextDecoder on Uint8Array
String.fromCharCode on Uint8Array
String.fromCharCode on Array
String.fromCodePoint on Uint8Array
String.fromCodePoint on Array

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of three different ways to convert between code points and Unicode strings:

1. `TextDecoder` on `Uint8Array`
2. `String.fromCharCode` on `Uint8Array`
3. `String.fromCharCode` on an array

These conversions are essential in JavaScript, as they can be used to decode binary data, such as images or audio files.

**Options Compared**

The benchmark compares the performance of each option across two scenarios:

* Converting a fixed-size array of code points (i.e., ASCII characters) from `Uint8Array` to a string.
* Converting an array of code points from `Uint8Array` to a string (for Unicode characters).

**Pros and Cons**

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

1. **TextDecoder on Uint8Array**
	* Pros: Efficient for decoding binary data, handles large inputs well.
	* Cons: May require additional setup for Unicode handling, can be slower than `String.fromCharCode` for small inputs.
2. **String.fromCharCode on Uint8Array**
	* Pros: Simple, fast, and efficient for small inputs.
	* Cons: Can be slower for large inputs due to repeated string concatenation, may not handle Unicode characters correctly without additional setup.
3. **String.fromCharCode on Array**
	* Pros: Similar performance characteristics to `String.fromCharCode` on `Uint8Array`, handles Unicode characters correctly.
	* Cons: May require more memory than using `TextDecoder`, can be slower for very large inputs.

**Library and Purpose**

In this benchmark, the following libraries are used:

1. `TextDecoder`: A built-in JavaScript library for decoding binary data into strings.
2. `String.fromCharCode` (and its array equivalent): Built-in JavaScript functions for converting code points to Unicode characters.

**Special JS Feature or Syntax**

None of the tested options rely on special JavaScript features or syntax beyond what's covered in the ECMAScript standard.

**Other Alternatives**

If you need to optimize these conversions, consider using:

1. **Buffer**: For decoding binary data into strings, as it provides a more efficient way to handle large inputs.
2. **Web Workers**: To parallelize the computation and take advantage of multi-core processors, especially for very large input sizes.

In conclusion, this benchmark helps you understand the performance differences between `TextDecoder`, `String.fromCharCode`, and its array equivalent when converting code points to Unicode strings from a fixed-size array or `Uint8Array`. The choice of option depends on your specific use case and performance requirements.

Latest run results:

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

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

Browser/OS: Chrome 123 on Linux

View result in a separate tab

Test name	Executions per second
TextDecoder on Uint8Array	9725.1 Ops/sec
String.fromCharCode on Uint8Array	17383.7 Ops/sec
String.fromCharCode on Array	55075.2 Ops/sec
String.fromCodePoint on Uint8Array	7385.9 Ops/sec
String.fromCodePoint on Array	9013.2 Ops/sec

Related benchmarks:

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

Comparing performance of: TextDecoder on Uint8Array vs String.fromCharCode on Uint8Array vs String.fromCharCode on Array vs String.fromCodePoint on Uint8Array vs String.fromCodePoint on Array

Created: 6 months ago by: Guest

Jump to the latest result

TextDecoder on Uint8Array

String.fromCharCode on Uint8Array

String.fromCharCode on Array

String.fromCodePoint on Uint8Array

String.fromCodePoint on Array

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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