Benchmark: Object Indexed Properties (Read)

Script Preparation code:

var LIMIT = 10000;

var ARRAY = [];
var OBJECT = {};
var SPARSE_ARRAY = [];
var SPARSE_OBJECT = {};

for (var i = 0; i < LIMIT; i++) {
  ARRAY[i] = i;
  OBJECT[i] = i;
  if (i % 2 === 0) {
    SPARSE_ARRAY[i] = i;
    SPARSE_OBJECT[i] = i;
  }
}

​x
 
var LIMIT = 10000;​var ARRAY = [];var OBJECT = {};var SPARSE_ARRAY = [];var SPARSE_OBJECT = {};​for (var i = 0; i < LIMIT; i++) {  ARRAY[i] = i;  OBJECT[i] = i;  if (i % 2 === 0) {    SPARSE_ARRAY[i] = i;    SPARSE_OBJECT[i] = i;  }}

Tests:

Array

var total = 0;
var target = ARRAY;

for (var i = 0; i < LIMIT; i++) {
  total += target[i];
}

return total;

 
var total = 0;var target = ARRAY;​for (var i = 0; i < LIMIT; i++) {  total += target[i];}​return total;

Object

var total = 0;
var target = OBJECT;

for (var i = 0; i < LIMIT; i++) {
  total += target[i];
}

return total;

 
var total = 0;var target = OBJECT;​for (var i = 0; i < LIMIT; i++) {  total += target[i];}​return total;

Sparse Array

var total = 0;
var target = SPARSE_ARRAY;

for (var i = 0; i < LIMIT; i++) {
  if (i in target) {
    total += target[i];
  }
}

return total;

 
var total = 0;var target = SPARSE_ARRAY;​for (var i = 0; i < LIMIT; i++) {  if (i in target) {    total += target[i];  }}​return total;

Sparse Object

var total = 0;
var target = SPARSE_OBJECT;

for (var i = 0; i < LIMIT; i++) {
  if (i in target) {
    total += target[i];
  }
}

return total;

 
var total = 0;var target = SPARSE_OBJECT;​for (var i = 0; i < LIMIT; i++) {  if (i in target) {    total += target[i];  }}​return total;

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
Array
Object
Sparse Array
Sparse Object

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 years ago)

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

Browser/OS: Chrome 53 on Mac OS X 10.11.6

View result in a separate tab

Test name	Executions per second
Array	1200.4 Ops/sec
Object	1192.4 Ops/sec
Sparse Array	1096.4 Ops/sec
Sparse Object	1120.1 Ops/sec

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

Benchmark Overview

The provided JSON represents a JavaScript microbenchmark test case, specifically testing the performance of accessing properties using different data structures: arrays and objects (including sparse arrays and sparse objects).

Data Structures Compared

Three types of data structures are compared:

Arrays: A dense array with 10,000 elements is created.
Objects: An object with 10,000 key-value pairs is created.
Sparse Arrays and Objects: Sparse versions of the above data structures are created by only setting values for every other index.

Pros and Cons

Here's a brief overview of each approach:

Arrays:
- Pros: Efficient access to elements using array indexing (array[i]).
- Cons: May lead to memory waste due to unused indices.
Objects:
- Pros: Allows for flexible data structure with key-value pairs, making it suitable for various use cases.
- Cons: Accessing properties using object[key] can be slower than array indexing.
Sparse Arrays and Objects:
- Pros: Reduces memory usage by only allocating space for non-zero values.
- Cons: May lead to slower performance due to the need to check if a property exists before accessing it (if (i in target)).

Library and Special JS Features

None of the provided benchmark test cases use external libraries. However, the in operator used in sparse array and object access checks is a special JavaScript feature that allows checking if a property exists on an object.

Other Alternatives

Alternative approaches to testing array and object access performance could include:

Using other data structures like linked lists or trees.
Testing with larger datasets to observe scalability differences.
Incorporating other microbenchmarks, such as string manipulation or DOM manipulation tasks.

Keep in mind that the specific test case design and variations may be tailored to focus on certain aspects of array and object access performance.

LLMs can make mistakes. Check important info.

**Benchmark Overview**

**Data Structures Compared**

Three types of data structures are compared:

1. **Arrays**: A dense array with 10,000 elements is created.
2. **Objects**: An object with 10,000 key-value pairs is created.
3. **Sparse Arrays and Objects**: Sparse versions of the above data structures are created by only setting values for every other index.

**Pros and Cons**

Here's a brief overview of each approach:

1. **Arrays**:
	* Pros: Efficient access to elements using array indexing (`array[i]`).
	* Cons: May lead to memory waste due to unused indices.
2. **Objects**:
	* Pros: Allows for flexible data structure with key-value pairs, making it suitable for various use cases.
	* Cons: Accessing properties using `object[key]` can be slower than array indexing.
3. **Sparse Arrays and Objects**:
	* Pros: Reduces memory usage by only allocating space for non-zero values.
	* Cons: May lead to slower performance due to the need to check if a property exists before accessing it (`if (i in target)`).

**Library and Special JS Features**

None of the provided benchmark test cases use external libraries. However, the `in` operator used in sparse array and object access checks is a special JavaScript feature that allows checking if a property exists on an object.

**Other Alternatives**

Alternative approaches to testing array and object access performance could include:

* Using other data structures like linked lists or trees.
* Testing with larger datasets to observe scalability differences.
* Incorporating other microbenchmarks, such as string manipulation or DOM manipulation tasks.

Keep in mind that the specific test case design and variations may be tailored to focus on certain aspects of array and object access performance.

Related benchmarks:

Object Indexed Properties (Read) (version: 0)

Comparing performance of: Array vs Object vs Sparse Array vs Sparse Object

Created: 8 years ago by: Guest

Jump to the latest result