Benchmark: Encode vs Blob on large string

Script Preparation code:

iterations = 1000;
function randomStringGen(n) {
    let strings = [];
    for (let i = 0; i < n; i++) {
      let s = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
      strings[i] = s;
    }
    return strings;
}
var randomStrings = randomStringGen(iterations);
var encoder = new TextEncoder();

AخA
 
iterations = 1000;function randomStringGen(n) {    let strings = [];    for (let i = 0; i < n; i++) {      let s = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);      strings[i] = s;    }    return strings;}var randomStrings = randomStringGen(iterations);var encoder = new TextEncoder(); 

Tests:

Blob

var j = 0;
for (let i = 0; i < iterations; i++) {
 new TextEncoder().encode(randomStrings.join('')).length
}

 
var j = 0;for (let i = 0; i < iterations; i++) { new TextEncoder().encode(randomStrings.join('')).length}

TextEncoder

var j = 0;
for (let i = 0; i < iterations; i++) {
  new Blob([randomStrings.join('')]).size
}

 
var j = 0;for (let i = 0; i < iterations; i++) {  new Blob([randomStrings.join('')]).size}

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
Blob
TextEncoder

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Blob	17.9 Ops/sec
TextEncoder	4.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition and test cases.

**Benchmark Definition**

The benchmark measures the performance difference between encoding a large string using `TextEncoder` (Blob) and creating a Blob from the same string.

**Script Preparation Code**

The script preparation code generates an array of random strings, stores them in the variable `randomStrings`, and creates a new instance of `TextEncoder`.

```javascript
iterations = 1000;
function randomStringGen(n) {
    let strings = [];
    for (let i = 0; i < n; i++) {
        let s = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
        strings[i] = s;
    }
    return strings;
}
var randomStrings = randomStringGen(iterations);
var encoder = new TextEncoder();
```

**Html Preparation Code**

There is no HTML preparation code provided.

**Test Cases**

The benchmark consists of two test cases:

1. **Blob**: This test case measures the time it takes to encode a large string using `TextEncoder` ( Blob).
```javascript
for (let i = 0; i < iterations; i++) {
    new TextEncoder().encode(randomStrings.join('')).length
}
```

2. **TextEncoder**: This test case measures the time it takes to create a Blob from a large string.
```javascript
for (let i = 0; i < iterations; i++) {
    new Blob([randomStrings.join('')]).size
}
```

**Options being compared**

The two test cases are comparing:

* Encoding a large string using `TextEncoder` (Blob) vs. creating a Blob from the same string.

**Pros and Cons of each approach:**

1. **Blob**:
	* Pros:
		+ Can be more efficient for encoding large strings, as it avoids the overhead of creating a new string.
		+ May be faster in some cases due to the optimized encoding algorithm.
	* Cons:
		+ Can be slower for small strings or when encoding is not necessary, as the overhead of creating a Blob can outweigh any benefits.
2. **TextEncoder**:
	* Pros:
		+ Typically faster and more efficient than creating a Blob, especially for small strings.
		+ Provides more control over the encoding process, allowing for custom encoding schemes.
	* Cons:
		+ May be slower for very large strings or when encoding is necessary.

**Library: `TextEncoder`**

The `TextEncoder` library provides an optimized way to encode strings in JavaScript. It's designed to be fast and efficient, making it suitable for encoding large amounts of data. The library uses a optimized algorithm that takes into account the specifics of the string being encoded, such as its length and character set.

**Special JS feature: ` Blob`**

The `Blob` object is a modern JavaScript feature that represents a binary file or data blob. When used in conjunction with `TextEncoder`, it provides an efficient way to encode strings by converting them into a format that can be easily processed by web browsers and other applications.

Other alternatives:

* For encoding large strings, you could consider using libraries like `utf-8` or `utf-16`, which provide optimized encoding algorithms for text data.
* If you need more control over the encoding process, you could use custom encoding schemes, such as base64 or hexadecimal encoding.
* For creating a Blob from a string, you could also use libraries like `FileReader` or `FileSaver`, which provide APIs for working with files and blobs in JavaScript.

Related benchmarks:

Encode vs Blob on large string (version: 0)

Comparing performance of: Blob vs TextEncoder

Created: one year ago by: Guest

Jump to the latest result