Performance Report

Writing binary arrays – functions vs direct access

1.20×Test with direct access is faster than Test with functions

Generated

Apr 25, 2026 · by Kyle Reese

Source

jsperf.net/neleyi

Speed leaderboard

Ops per second, ranked

Source: V8 Firecracker analysis · 2 tests

Speed animation

Watch the relative pace

Fastest case

Test with direct access

28.18Mops/sec

Every ball crosses the same lane. Faster snippets get shorter lap times, so the visual rhythm matches the throughput spread in the report.

Source: Controlled V8 analysis · top 2 of 2 ranked tests.

#1Test with direct access

28.18M

#2Test with functions

23.39M1.20× slower

Winner

Test with direct access

Speed

28.18Mops/sec

1.20× ahead of Test with functions

Picked because it produced the highest sustained throughput across the engines analysed for this benchmark.

Code

data[0] = 1;
data[1] = 2;
data[2] = 3;
data[3] = 4;
data[4] = 5;

Head to head

1.20× difference

Fastest

Test with direct access

28.18Mops/sec

data[0] = 1;
data[1] = 2;
data[2] = 3;
data[3] = 4;
data[4] = 5;

Slowest

Test with functions

23.39Mops/sec

writeData(data, 0, 1, 2, 3, 4, 5);

Cross-runtime

Node · Deno · Bun · friends

Same code executed on different JavaScript engines. Higher bars = faster.

JIT amplification

How much the optimizer helped

Per-test boost

Test with functions13.2×

Memory-boundJIT-friendly

Test with direct access10×

Memory-boundJIT-friendly

Most JIT-sensitive

Test with functions

V8 ran this snippet 13.2× faster than the interpreter baseline.

This benchmark is highly sensitive to V8 optimization. Treat the winner as engine-dependent and re-check other runtimes before generalising.

Static complexity

What the code shape suggests

Peak time

O(1)

Test with functions

Space

2/2

tests estimated as O(1)

Shape

2/2

linear or better

Test

Time

Space

Test with functions

O(1)

90%

O(1)

constant

Test with direct access

O(1)

90%

O(1)

constant

How to read it

The analyser scores the benchmark test body from its parsed code structure. Setup variables help identify context, but setup work is not charged to every test case.

Estimate, not proof

Dynamic calls, regular expressions, platform APIs, and parser recovery can reduce confidence. Use this beside the measured runtime data.

Memory response

Throughput under memory limits

Source

QuickJS memory-limit profiles power this chart, giving a deterministic view of allocation pressure.

Model readout

Test with direct access

is stable across memory limits · 98% confidence

Test with functions

is stable across memory limits · 93% confidence

Useful for spotting snippets that plateau early, degrade under pressure, or keep scaling as memory headroom grows.

Analyst's take

What the data means

The same test wins both with and without the optimising compiler — a sign that the result is driven by genuine algorithmic differences, not by a quirk of V8's JIT.

Wins on paperWins in production

Test with direct access

Fastest under both QuickJS (no JIT) and V8 (with JIT). The algorithmic edge is real — V8 didn't have to bend over backwards to make it look good.

Methodology

Where these numbers came from

Browser runs

42

Public benchmark executions used for the leaderboard and environment breakdowns.

Controlled runtimes

4

Node / Deno / Bun worker data across 8 single-core test-runtime pairs and 8 captured profiles.

Bun 1.3.13

2 tests · 18.37M avg

Deno 2.7.13

2 tests · 11.68M avg

Node.js 25.9.0

2 tests · 15.46M avg

Node.js lts

2 tests · 16.85M avg

Top browsers

Chrome95%

Safari5%

Top operating systems

Mac OS76%

Windows14%

iOS5%

Other (1)5%

Thanks for watching

Run it yourself.

Every benchmark on jsperf.net is reproducible. Open the source link, hit "Run", and watch the numbers light up in your browser.

Sourcejsperf.net/neleyi

GeneratedApr 25, 2026

ByKyle Reese

Powered by jsperf.net · presentation reports are a donor perk.

Writing binary arrays – functions vs direct access

Ops per second

Test with direct access

1.20× difference

Across JS engines

Optimizer boost

Big-O from code structure

Memory-limit sweep

What the data means

Where the data came from

Run it yourself.

Writing binary arrays – functions vs direct access

Writing binary arrays – functions vs direct access

Ops per second, ranked

Watch the relative pace

Test with direct access

1.20× difference

Node · Deno · Bun · friends

How much the optimizer helped

What the code shape suggests

Throughput under memory limits

What the data means

Where these numbers came from

Run it yourself.