Run results for: JavaScript Uint8Array to Base64: FileReader vs btoa vs toBase64

Run details:

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36

Browser: Chrome 141

Operating system: Windows

Device Platform: Desktop

Date tested: 10 months ago

toBase64 1K

6.1M/s

toBase64 32K

383K/s

toBase64 64K

203K/s

Self 1K

186K/s

btoa 1K

105K/s

toBase64 1M

15K/s

FileReader 1K

7K/s

Self 32K

6K/s

FileReader 32K

4K/s

btoa 32K

3K/s

Self 64K

3K/s

FileReader 64K

3K/s

btoa 64K

2K/s

FileReader 1M

228/s

Self 1M

87/s

btoa 1M

55/s

View exact numbers

Test name	Executions per second
✓ toBase64 1K	6,058,364 Ops/sec
toBase64 32K	382,675 Ops/sec
toBase64 64K	203,234 Ops/sec
Self 1K	186,125 Ops/sec
btoa 1K	105,229 Ops/sec
toBase64 1M	14,945 Ops/sec
FileReader 1K	6,652 Ops/sec
Self 32K	5,665 Ops/sec
FileReader 32K	3,839 Ops/sec
btoa 32K	3,373 Ops/sec
Self 64K	2,729 Ops/sec
FileReader 64K	2,714 Ops/sec
btoa 64K	1,639 Ops/sec
FileReader 1M	228 Ops/sec
Self 1M	87 Ops/sec
btoa 1M	55 Ops/sec

Script Preparation code:

function bytesToBase64ByFileReader(bytes) {
    return new Promise(r => {
        const reader = new FileReader()
        reader.onload = () => r(reader.result)
        reader.readAsDataURL(new Blob([bytes]))
    }).then(url => url.slice(url.indexOf(",") + 1));
}

function bytesToBase64ByBtoa(bytes) {
    return btoa(bytes.reduce((data, byte) => data + String.fromCharCode(byte), ""));
}

function bytesToBase64ByToBase64(bytes) {
    return bytes.toBase64();
}

function bytesToBase64BySelf(bytes) {
    const dict = [
        "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
        "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
        "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"
    ];
    let base64 = "";
    let i;
    for (i = 0; i < bytes.length - 3; i += 3) {
        const byte1 = bytes[i];
        const byte2 = bytes[i + 1];
        const byte3 = bytes[i + 2];
        base64 += dict[byte1 >>> 2] + dict[(byte1 & 3) << 4 | byte2 >>> 4] + dict[(byte2 & 15) << 2 | byte3 >>> 6] + dict[byte3 & 63];
    }
    const has2 = i + 1 < bytes.length;
    const byte1 = bytes[i];
    const byte2 = has2 ? bytes[i + 1] : 0;
    base64 += dict[byte1 >>> 2] + dict[(byte1 & 3) << 4 | byte2 >>> 4];
    if (has2) {
        const has3 = i + 2 < bytes.length;
        const byte3 = has3 ? bytes[i + 2] : 0;
        return base64 + dict[(byte2 & 15) << 2 | byte3 >>> 6] + (has3 ? dict[byte3 & 63] : "=");
    }
    return base64 + "==";
}

const bytes1K = new Uint8Array(1024);
const bytes32K = new Uint8Array(32768);
const bytes64K = new Uint8Array(65536);
const bytes1M = new Uint8Array(1048576);
for (const bytes of [bytes1K, bytes32K, bytes64K, bytes1M])
    for (let i = 0; i < bytes.length; i += 65536)
        crypto.getRandomValues(bytes.subarray(i, i + 65536));

Tests:

FileReader 1K [Async/Deferred]
await bytesToBase64ByFileReader(bytes1K); deferred.resolve();
FileReader 32K [Async/Deferred]
await bytesToBase64ByFileReader(bytes32K); deferred.resolve();
FileReader 64K [Async/Deferred]
await bytesToBase64ByFileReader(bytes64K); deferred.resolve();
FileReader 1M [Async/Deferred]
await bytesToBase64ByFileReader(bytes1M); deferred.resolve();
btoa 1K
bytesToBase64ByBtoa(bytes1K);
btoa 32K
bytesToBase64ByBtoa(bytes32K);
btoa 64K
bytesToBase64ByBtoa(bytes64K);
btoa 1M
bytesToBase64ByBtoa(bytes1M);
toBase64 1K
bytesToBase64ByToBase64(bytes1K);
toBase64 32K
bytesToBase64ByToBase64(bytes32K);
toBase64 64K
bytesToBase64ByToBase64(bytes64K);
toBase64 1M
bytesToBase64ByToBase64(bytes1M);
Self 1K
bytesToBase64BySelf(bytes1K);
Self 32K
bytesToBase64BySelf(bytes32K);
Self 64K
bytesToBase64BySelf(bytes64K);
Self 1M
bytesToBase64BySelf(bytes1M);