Benchmark: Map string versus number keys

Script Preparation code:

var intMap = new Map();
intMap.set(1, "aaa");
intMap.set(2, "bbb");
intMap.set(3, "ccc");

var stringMap = new Map();
stringMap.set("a", "aaa");
stringMap.set("b", "bbb");
stringMap.set("c", "ccc");

Tests:

String
var a = stringMap.get("a"); var b = stringMap.get("b"); var c = stringMap.get("c");
Int
var a1 = intMap.get(1); var b2 = intMap.get(2); var c3 = intMap.get(3);

Historical Performance Data aggregated from 38 community runs

Desktop Results:

Chrome 25 runs

String

154.3M/s

Int

147.4M/s

View exact numbers

✓ String: 154,251,120 ops/sec
• Int: 147,395,312 ops/sec

Firefox 8 runs

String

1030.6M/s

Int

970.0M/s

View exact numbers

✓ String: 1,030,586,048 ops/sec
• Int: 969,958,080 ops/sec

Mobile Results:

Chrome 5 runs

Int

122.3M/s

String

118.2M/s

View exact numbers

✓ Int: 122,293,784 ops/sec
• String: 118,193,512 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
String
Int

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 24 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36 Edg/150.0.0.0

Browser/OS: Chrome 150 on Windows

View result in a separate tab

String

774.9M/s

Int

765.3M/s

View exact numbers

Test name	Executions per second
✓ String	774,931,200 Ops/sec
Int	765,278,592 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 explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is defined in JSON format, which represents a test case for JavaScript microbenchmarks on MeasureThat.net. The definition includes:

* `Name` and `Description`: These fields provide metadata about the benchmark, but they're empty in this case.
* `Script Preparation Code`: This code initializes two Maps: `intMap` and `stringMap`. The maps are populated with key-value pairs using integers and strings respectively. This setup ensures that both Map types can be used for testing.
* `Html Preparation Code`: There is no HTML preparation code provided, so we'll focus on the JavaScript implementation.

**Individual Test Cases**

The benchmark consists of two test cases:

1. **String**: This test case uses the `stringMap` to retrieve values using the `.get()` method.
2. **Int**: This test case uses the `intMap` to retrieve values using the `.get()` method with an integer key.

**What's being tested?**

The benchmark tests the performance difference between accessing keys in a Map using integers and strings. The goal is to measure which approach (integer-based or string-based) yields better performance.

**Comparison options**

There are two primary approaches compared:

1. **Integer-based**: Using the `.get()` method with an integer key (e.g., `intMap.get(1)`).
2. **String-based**: Using the `.get()` method with a string key (e.g., `stringMap.get("a")`).

**Pros and Cons of each approach**

**Integer-based:**

Pros:

* Typically faster, as JavaScript's internal integer representation is usually smaller than a string.
* Can be more cache-friendly, depending on the implementation.

Cons:

* May not work correctly if you're using a large range of keys (e.g., negative numbers or very high integers).

**String-based:**

Pros:

* More flexible, as strings can represent any value, making it easier to store and retrieve arbitrary data.
* Works with key names that are more human-readable.

Cons:

* Typically slower than integer-based access due to the overhead of string concatenation and lookup in a hash table.

**Library usage**

In this benchmark, no external libraries are used beyond the built-in JavaScript `Map` object. However, some JavaScript engines might use optimizations or implementations that could affect performance (e.g., some engines use a custom hash function).

**Special JS feature or syntax**

This benchmark doesn't use any special JavaScript features or syntax.

**Other alternatives**

If you're interested in exploring alternative approaches or test cases, here are a few examples:

* Using other data structures like `Set` or `Array` for testing.
* Adding additional keys to the Map (e.g., with different key types) to simulate more realistic scenarios.
* Incorporating external dependencies or third-party libraries to introduce potential bottlenecks.

Keep in mind that these alternatives might affect the benchmark's accuracy, and it's essential to carefully consider the test case goals and requirements when exploring new options.

Map string versus number keys (version: 0)

Comparing performance of: `String vs Int`

Created: 3 years ago by: Guest

Go to the latest result

String

Int

Historical Performance Data aggregated from 38 community runs

Desktop Results:

Chrome 25 runs

Firefox 8 runs

Mobile Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Map string versus number keys (version: 0)

Comparing performance of: String vs Int

Created: 3 years ago by: Guest

Go to the latest result

String

Int

Historical Performance Data aggregated from 38 community runs

Desktop Results:

Chrome 25 runs

Firefox 8 runs

Mobile Results:

Chrome 5 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: `String vs Int`