Benchmark: ArrayBuffer vs JSON serialization ---- v2

Tests:

JSON serialization
const arr = Array.from({ length: 5000 }).map(() => Math.random()); const serialized = JSON.stringify(arr); const deserialized = JSON.parse(serialized); const serializedAgain = JSON.stringify(deserialized);
ArrayBuffer serialization
const arr = Array.from({ length: 5000 }).map(() => Math.random()); const buffer = new ArrayBuffer(arr.length * 4); const view = new DataView(buffer); for (let i = 0; i<buffer.byteLength; i+=4){ view.setFloat32(arr[i]); } const view2 = new DataView(buffer);

Historical Performance Data aggregated from 20 community runs

Desktop Results:

Chrome 13 runs

ArrayBuffer serialization

1K/s

JSON serialization

469/s

Fastest: ArrayBuffer serialization (2.1x faster)

View exact numbers

✓ ArrayBuffer serialization: 1,001 ops/sec
• JSON serialization: 469 ops/sec

Firefox 7 runs

ArrayBuffer serialization

5K/s

JSON serialization

677/s

Fastest: ArrayBuffer serialization (8.1x faster)

View exact numbers

✓ ArrayBuffer serialization: 5,456 ops/sec
• JSON serialization: 677 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON serialization
ArrayBuffer serialization

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/135.0.0.0 Safari/537.36

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

ArrayBuffer serialization

5K/s

JSON serialization

1K/s

View exact numbers

Test name	Executions per second
✓ ArrayBuffer serialization	5,453 Ops/sec
JSON serialization	1,118 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**What is being tested?**

The two test cases compare how different browsers serialize JavaScript arrays using either `ArrayBuffer` or JSON serialization.

**Options compared:**

1. **JSON serialization**: The browser converts the array into a string format using `JSON.stringify()` and then deserializes it back to an array using `JSON.parse()`.
2. **ArrayBuffer serialization**: The browser creates an `ArrayBuffer` instance, stores the array data in it using a `DataView`, and then serializes the buffer.

**Pros and cons of each approach:**

1. **JSON serialization:**
	* Pros:
		+ Widely supported across browsers.
		+ Human-readable format.
	* Cons:
		+ May not be as efficient for large datasets.
		+ Can lead to larger serialized data sizes.
2. **ArrayBuffer serialization:**
	* Pros:
		+ More efficient for large datasets.
		+ Can result in smaller serialized data sizes.
	* Cons:
		+ Not all browsers support `ArrayBuffer` and `DataView`.
		+ Requires manual handling of the `DataView` object.

**Other considerations:**

1. **Browser support**: Both approaches rely on browser-specific features, which may not be compatible across all browsers.
2. **Performance differences**: The test results indicate that ArrayBuffer serialization is faster than JSON serialization in this specific benchmark.

**Library usage:**

In the provided benchmark code, there is no explicit library usage beyond built-in JavaScript features like `Array.from()`, `Math.random()`, and `JSON.stringify()`/`JSON.parse()`.

**Special JS feature or syntax:**

There are no special JavaScript features or syntax used in this benchmark. It only relies on standard JavaScript language constructs.

**Alternatives:**

If you need to compare serialization approaches, here are some alternative test cases you could consider:

1. **Blob-based serialization**: Instead of using `ArrayBuffer`, use the Blob API to serialize and deserialize data.
2. **Typed arrays**: Use other typed array types like Int8Array or Float64Array for serialization.
3. **Big Integers**: Compare serialization performance with Big Integers, which can be more efficient for large numbers.

Keep in mind that the choice of alternative test cases depends on your specific use case and requirements.

ArrayBuffer vs JSON serialization ---- v2 (version: 0)

Comparing performance of: `JSON serialization vs ArrayBuffer serialization`

Created: 4 years ago by: Guest

Go to the latest result

JSON serialization

ArrayBuffer serialization

Historical Performance Data aggregated from 20 community runs

Desktop Results:

Chrome 13 runs

Firefox 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

ArrayBuffer vs JSON serialization ---- v2 (version: 0)

Comparing performance of: JSON serialization vs ArrayBuffer serialization

Created: 4 years ago by: Guest

Go to the latest result

JSON serialization

ArrayBuffer serialization

Historical Performance Data aggregated from 20 community runs

Desktop Results:

Chrome 13 runs

Firefox 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `JSON serialization vs ArrayBuffer serialization`