Benchmark: ArrayBuffer to base64 String

Script Preparation code:

var ab = new ArrayBuffer(70*1024);
var uint8 = new Uint8Array(ab);
for (var i = 0; i < ab.byteLength; i++) {
    uint8[i] = i % 256;
}
var expected = window.btoa(String.fromCharCode.apply(null, uint8));

function byteArrayToString(bytes) {
  var CHUNK_SIZE = 8*1024;
  if (bytes.length <= CHUNK_SIZE)
    return String.fromCharCode.apply(null, bytes);
  var str = '';
  for (var i = 0; i < bytes.length; i += CHUNK_SIZE)
    str += String.fromCharCode.apply(null, bytes.slice(i, i+CHUNK_SIZE));
  return str;
}

function validate(res){
  if (res !== expected)
      throw "expected=" + expected + " but got " + res;
}


function uint6ToB64(nUint6) {
  return nUint6 < 26 ?
      nUint6 + 65
    : nUint6 < 52 ?
      nUint6 + 71
    : nUint6 < 62 ?
      nUint6 - 4
    : nUint6 === 62 ?
      43
    : nUint6 === 63 ?
      47
    :
      65;
};

function bytesToBase64(aBytes) {
  var eqLen = (3 - (aBytes.length % 3)) % 3, sB64Enc = "";

  for (var nMod3, nLen = aBytes.length, nUint24 = 0, nIdx = 0; nIdx < nLen; nIdx++) {
    nMod3 = nIdx % 3;
    nUint24 |= aBytes[nIdx] << (16 >>> nMod3 & 24);
    if (nMod3 === 2 || aBytes.length - nIdx === 1) {
      sB64Enc += String.fromCharCode(uint6ToB64(nUint24 >>> 18 & 63), uint6ToB64(nUint24 >>> 12 & 63), uint6ToB64(nUint24 >>> 6 & 63), uint6ToB64(nUint24 & 63));
      nUint24 = 0;
    }
  }

  return  eqLen === 0 ?
            sB64Enc
          :
            sB64Enc.substring(0, sB64Enc.length - eqLen) + (eqLen === 1 ? "=" : "==");
};

Tests:

String.fromCharCode.apply
var bin = String.fromCharCode.apply(null, uint8); var res = window.btoa(bin) validate(res)
String.fromCharCode
var bin = ''; for (var i = 0; i < uint8.byteLength; i++) bin += String.fromCharCode(uint8[i]); var res = window.btoa(bin) validate(res)
bytesToBase64
var res = bytesToBase64(uint8) validate(res)
arr join
var bin = []; for (var i = 0; i < uint8.byteLength; i++) bin.push(String.fromCharCode(uint8[i])); var res = window.btoa(bin.join('')) validate(res)
byteArrayToString
var bin = byteArrayToString(uint8); var res = window.btoa(bin) validate(res)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.fromCharCode.apply
String.fromCharCode
bytesToBase64
arr join
byteArrayToString

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
String.fromCharCode.apply	6416.4 Ops/sec
String.fromCharCode	1806.4 Ops/sec
bytesToBase64	498.1 Ops/sec
arr join	2879.1 Ops/sec
byteArrayToString	8185.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the test cases and explain what is being tested.

**Overview**

The benchmark measures the performance of converting an `ArrayBuffer` to a base64 string in different ways, using various JavaScript functions.

**Test Cases**

1. **String.fromCharCode.apply**: This test case uses the `String.fromCharCode.apply(null, uint8)` syntax to create a string from the `Uint8Array`. The resulting string is then passed to the `window.btoa()` function.
2. **String.fromCharCode**: This test case creates a string by concatenating individual characters using `String.fromCharCode(uint8[i])`.
3. **bytesToBase64**: This test case uses a custom `bytesToBase64` function to convert the `Uint8Array` to a base64 string.
4. **arr join**: This test case pushes individual characters onto an array and then joins them into a string using `bin.join('')`, before passing it to `window.btoa()`.
5. **byteArrayToString**: This test case uses a custom `byteArrayToString` function to convert the `Uint8Array` to a string, which is then passed to `window.btoa()`.

**Options Compared**

The benchmark compares the performance of five different approaches:

* Using `String.fromCharCode.apply(null, uint8)`
* Creating a string by concatenating individual characters using `String.fromCharCode(uint8[i])`
* Using the custom `bytesToBase64` function
* Pushing individual characters onto an array and joining them into a string using `bin.join('')`
* Using the custom `byteArrayToString` function

**Pros and Cons of Each Approach**

1. **String.fromCharCode.apply**: This approach is likely to be the fastest, as it uses a built-in method optimized for performance.
2. **String.fromCharCode**: Concatenating individual characters using `String.fromCharCode(uint8[i])` can lead to slower performance due to string creation overhead.
3. **bytesToBase64**: This custom function is designed specifically for base64 conversion and might be optimized for performance, but its implementation details are not provided in the benchmark.
4. **arr join**: Pushing individual characters onto an array and joining them into a string using `bin.join('')` can lead to slower performance due to array manipulation overhead.
5. **byteArrayToString**: The custom `byteArrayToString` function is designed specifically for converting `Uint8Array` to strings, but its implementation details are not provided in the benchmark.

**Latest Benchmark Results**

The latest benchmark results show the executions per second for each test case across different browsers and platforms. The top performer is the `String.fromCharCode.apply` approach, followed by the custom `bytesToBase64` function.

In summary, the benchmark measures the performance of converting an `ArrayBuffer` to a base64 string in different ways, using various JavaScript functions. The results show that the built-in `String.fromCharCode.apply` method is likely to be the fastest, while custom approaches like `bytesToBase64` and `byteArrayToString` might offer competitive performance.

Related benchmarks:

ArrayBuffer to base64 String (version: 23)

Comparing performance of: String.fromCharCode.apply vs String.fromCharCode vs bytesToBase64 vs arr join vs byteArrayToString

Created: 7 years ago by: Registered User

Jump to the latest result

String.fromCharCode.apply

String.fromCharCode

bytesToBase64

arr join

byteArrayToString

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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