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 ? "=" : "==");
};

​x
 
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)
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)
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)
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)

 
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)
var bin = byteArrayToString(uint8);
var res = window.btoa(bin)
validate(res)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 8 days ago)

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

Browser/OS: Firefox 136 on Windows

View result in a separate tab

Test name	Executions per second
String.fromCharCode.apply	1383.3 Ops/sec
String.fromCharCode	680.5 Ops/sec
bytesToBase64	221.4 Ops/sec
arr join	977.0 Ops/sec
byteArrayToString	2129.1 Ops/sec

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

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

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.
String.fromCharCode: This test case creates a string by concatenating individual characters using String.fromCharCode(uint8[i]).
bytesToBase64: This test case uses a custom bytesToBase64 function to convert the Uint8Array to a base64 string.
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().
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

String.fromCharCode.apply: This approach is likely to be the fastest, as it uses a built-in method optimized for performance.
String.fromCharCode: Concatenating individual characters using String.fromCharCode(uint8[i]) can lead to slower performance due to string creation overhead.
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.
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.
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.

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: 8 years ago by: Registered User

Jump to the latest result

String.fromCharCode.apply

String.fromCharCode

bytesToBase64