Benchmark: Symbol vs String property access speed

Symbol vs String property access speed (version: 0)

Testing JS square-bracket property access by string and by similarly-named symbol

Comparing performance of: Symbol read vs Symbol read prototype vs Symbol write vs Symbol overwrite vs Symbol overwrite prototype vs String read vs String read prototype vs String write vs String overwrite vs String overwrite prototype

Created: 2 years ago by: Guest

Jump to the latest result

Script Preparation code:

var strings = [];
var symbols = [];
var stringMap = {__proto__: null};
var symbolMap = {__proto__: null};
var emptyMap = {__proto__: null};
for (let i = 0; i < 1000; i++) {
  strings[i] = `foobar${i}`;
  symbols[i] = Symbol(`foobar${i}`);
  stringMap[strings[i]] = i;
  symbolMap[symbols[i]] = i;
}
var stringProtoMap = {__proto__: stringMap};
var symbolProtoMap = {__proto__: symbolMap};
function mapRead(map, keys) {
  let total = 0;
  for (const key of keys) {
    total += map[key];
  }
  return total;
}
function mapWrite(map, keys) {
  for (const key of keys) {
    map[key] = true;
  }
}

Tests:

Symbol read
mapRead(symbolMap, symbols)
Symbol read prototype
mapRead(symbolProtoMap, symbols);
Symbol write
mapWrite(emptyMap, symbols);
Symbol overwrite
mapWrite(symbolMap, symbols);
Symbol overwrite prototype
mapWrite(symbolProtoMap, symbols);
String read
mapRead(stringMap, strings);
String read prototype
mapRead(stringProtoMap, strings);
String write
mapWrite(stringMap, strings);
String overwrite
mapWrite(stringMap, strings);
String overwrite prototype
mapWrite(stringProtoMap, strings);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Symbol read
Symbol read prototype
Symbol write
Symbol overwrite
Symbol overwrite prototype
String read
String read prototype
String write
String overwrite
String overwrite prototype

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 months ago)

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

Browser/OS: Chrome 138 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Symbol read	14146.6 Ops/sec
Symbol read prototype	143245.4 Ops/sec
Symbol write	137070.9 Ops/sec
Symbol overwrite	13982.1 Ops/sec
Symbol overwrite prototype	143722.6 Ops/sec
String read	156086.5 Ops/sec
String read prototype	129474.4 Ops/sec
String write	13783.9 Ops/sec
String overwrite	14032.6 Ops/sec
String overwrite prototype	139815.2 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 benchmark and its test cases.

**Benchmark Overview**

The benchmark, named "Symbol vs String property access speed", tests the performance of accessing properties using strings versus symbols in JavaScript.

**Script Preparation Code**

The script preparation code creates an array of strings (`strings`) and symbols (`symbols`) with 1000 elements each. It also sets up two maps: `stringMap` and `symbolMap`, which store indices corresponding to each string and symbol, respectively. The maps have a prototype set to `null`.

**Test Cases**

The test cases compare the performance of accessing properties using different methods:

1. **Symbol read**: Accessing a property using a symbol as the key.
2. **Symbol read prototype**: Accessing a property on the prototype chain using a symbol as the key.
3. **Symbol write**: Writing to a property using a symbol as the key.
4. **Symbol overwrite**: Overwriting a value stored in a property using a symbol as the key.
5. **String read**: Accessing a property using a string as the key.
6. **String read prototype**: Accessing a property on the prototype chain using a string as the key.
7. **String write**: Writing to a property using a string as the key.
8. **String overwrite**: Overwriting a value stored in a property using a string as the key.

**Performance Comparison**

The benchmark measures the performance of each test case and returns an array of results, where each result represents the number of executions per second (in millions) for that specific test case.

**Key Takeaways**

1. Accessing properties using symbols is generally faster than accessing properties using strings.
2. Accessing properties on the prototype chain using a symbol or string can be slower due to the overhead of traversing the prototype chain.
3. Writing and overwriting values stored in properties is relatively fast, regardless of whether you use a symbol or string as the key.

In summary, this benchmark highlights the performance benefits of using symbols for property access in JavaScript, particularly when compared to strings. However, accessing properties on the prototype chain can introduce additional overhead that may affect performance.

Related benchmarks: