Benchmark: Tuple versus Object 2

Tuple versus Object 2 (version: 3)

Shows a fully defined plain object is fastest. Surprisingly, even beat Array & Tuple. Expando = object with properties added after creation. Literal = all properties defined at creation. Array = additional elements are pushed after creation (~Expando). Tuple = all elements defined at creation, ie: size is constant. Indexed object = an object who's keys are numbers. The expectation is this will be slowest as indexing into objects causes number toString() conversion.

Comparing performance of: `Array vs Expando Object vs Indexed Expando vs Tuple vs Literal Object vs Indexed Literal Object`

Created: one year ago by: Registered User

Go to the latest result

Script Preparation code:

var COUNT = 100000

Tests:

Array
const objects = []; for(let prev, idx = 0; idx < COUNT; idx++) { const obj = [ idx, COUNT-1-idx, prev, null ]; if(prev) prev[3] = obj; prev = obj; obj.push(objects.push(obj)); // expanded obj.push(objects); // expanded } return objects;
Expando Object
const objects = [] for(let prev, idx = 0; idx < COUNT; idx++) { const obj = { idx, remaining: COUNT-1-idx, prev }; if(prev) prev.next = obj; // expanded prev = obj; obj.result = objects.push(obj); // expanded obj.all = objects; // expanded } return objects;
Indexed Expando
const objects = []; for(let prev, idx = 0; idx < COUNT; idx++) { const obj = { 0: idx, 1: COUNT-1-idx, 2: prev }; if(prev) prev[3] = obj;// expanded prev = obj; obj[4] = objects.push(obj);// expanded obj[5] = objects; // expanded } return objects;
Tuple
const objects = [] for(let prev, idx = 0; idx < COUNT; idx++) { const obj = [ idx, COUNT-1-idx, prev, null, undefined, null ]; if(prev) prev[3] = obj; prev = obj; obj[4] = objects.push(obj); obj[5] = objects; } return objects;
Literal Object
const objects = [] for(let prev, idx = 0; idx < COUNT; idx++) { const obj = { idx, remaining: COUNT-1-idx, prev, next: null, result: undefined, all: null }; if(prev) prev.next = obj; prev = obj; obj.result = objects.push(obj); obj.all = objects; } return objects;
Indexed Literal Object
const objects = []; for(let prev, idx = 0; idx < COUNT; idx++) { const obj = { 0: idx, 1: COUNT-1-idx, 2: prev, 3: null, 4: undefined, 5: null }; if(prev) prev[3] = obj; prev = obj; obj[4] = objects.push(obj); obj[5] = objects; } return objects;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array
Expando Object
Indexed Expando
Tuple
Literal Object
Indexed Literal Object

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Android 15; Mobile; rv:140.0) Gecko/140.0 Firefox/140.0

Browser/OS: Firefox Mobile 140 on Android

View result in a separate tab

Plain object

294/s

Tuple

192/s

Array

186/s

Indexed Expando

183/s

Expando Object

166/s

Plain Indexed

164/s

View exact numbers

Test name	Executions per second
✓ Plain object	294 Ops/sec
Tuple	192 Ops/sec
Array	186 Ops/sec
Indexed Expando	183 Ops/sec
Expando Object	166 Ops/sec
Plain Indexed	164 Ops/sec