Benchmark: string vs numeric enum values compare

Tests:

string enums
const a = { one: 'one', two: 'two', }; let c = 0; for (let i = 0; i < 100000; i++) { const v = i % 2 === 0 ? a.one : a.two; if (v === a.one) { c++; } }
numeric enums
const a = { one: 1, two: 2, }; let c = 0; for (let i = 0; i < 100000; i++) { const v = i % 2 === 0 ? a.one : a.two; if (v === a.one) { c++; } }

Historical Performance Data aggregated from 23 community runs

Desktop Results:

Firefox 12 runs

numeric enums

6K/s

string enums

5K/s

Fastest: numeric enums (1.3x faster)

View exact numbers

✓ numeric enums: 6,474 ops/sec
• string enums: 5,179 ops/sec

Chrome 11 runs

numeric enums

15K/s

string enums

15K/s

View exact numbers

✓ numeric enums: 15,380 ops/sec
• string enums: 15,375 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 enums
numeric enums

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0

Browser/OS: Firefox 140 on Windows

View result in a separate tab

numeric enums

5K/s

string enums

4K/s

View exact numbers

Test name	Executions per second
✓ numeric enums	4,974 Ops/sec
string enums	3,839 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview

This benchmark tests the performance of two approaches for defining and comparing enumerated values in JavaScript: one using string literals and the other using numeric literals. The primary goal is to analyze how these two strategies affect the performance of equal comparisons in a loop.

### Test Cases

1. **String Enums**:
   ```javascript
   const a = {
       one: 'one',
       two: 'two',
   };

let c = 0;

for (let i = 0; i < 100000; i++) {
       const v = i % 2 === 0 ? a.one : a.two;
       if (v === a.one) {
           c++;
       }
   }
   ```

- **Test Name**: string enums
   - **Explanation**: This test iterates 100,000 times, selecting between two string values, `a.one` ('one') and `a.two` ('two'), based on the index's parity (even or odd). It increments the counter `c` each time the selected value is equal to `a.one`.

2. **Numeric Enums**:
   ```javascript
   const a = {
       one: 1,
       two: 2,
   };

let c = 0;

for (let i = 0; i < 100000; i++) {
       const v = i % 2 === 0 ? a.one : a.two;
       if (v === a.one) {
           c++;
       }
   }
   ```

- **Test Name**: numeric enums
   - **Explanation**: Similar to the string test, this version uses numeric values instead. The constant values `1` and `2` are used instead of strings, and comparisons are made in the same manner.

### Performance Results

The benchmark results show the following executions per second for each test:

- **Numeric Enums**: 5267.26 executions per second
- **String Enums**: 4141.78 executions per second

### Pros and Cons

#### String Enums
**Pros**:
- More expressive and descriptive, making code easier to read and understand.
- Works well for scenarios requiring descriptive naming, such as in many business logic applications.

**Cons**:
- Generally slower during comparisons due to the overhead of string comparison (which involves checking multiple characters).
- Can consume more memory due to the longer nature of strings compared to simple numbers.

#### Numeric Enums
**Pros**:
- Typically faster for comparison operations since numeric comparison is usually less expensive than string comparison.
- More memory-efficient as they occupy less space compared to strings.

**Cons**:
- Less descriptive; using numbers can reduce code readability, especially if not properly documented.
- May not provide meaningful context without additional mapping or documentation.

### Other Considerations

When deciding between string and numeric enums, consider the specific use case:
- If performance is a critical aspect (e.g., in a performance-intensive loop), numeric enums might be preferable.
- If readability and maintainability are equally important, string enums may offer a better balance.

### Alternatives

Besides using string and numeric enums, developers can consider other options:
1. **Symbol Enums**: Using JavaScript's `Symbol` provides unique identifiers, which are helpful in avoiding name conflicts and also being fast in comparisons.
2. **Object Keys**: Using objects or maps to represent a collection of related constants, though this can introduce additional overhead.
3. **TypeScript Enums**: If type safety and clearer structure are required, TypeScript offers advanced enum capabilities that combine some benefits of string and numeric approaches.

Ultimately, the choice between these options will depend on the specific requirements of the application, including performance constraints, code maintainability, and team preferences.

string vs numeric enum values compare (version: 1)

Comparing performance of: `string enums vs numeric enums`

Created: one year ago by: Registered User

Go to the latest result

string enums

numeric enums

Historical Performance Data aggregated from 23 community runs

Desktop Results:

Firefox 12 runs

Chrome 11 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

string vs numeric enum values compare (version: 1)

Comparing performance of: string enums vs numeric enums

Created: one year ago by: Registered User

Go to the latest result

string enums

numeric enums

Historical Performance Data aggregated from 23 community runs

Desktop Results:

Firefox 12 runs

Chrome 11 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

Related benchmarks

Comparing performance of: `string enums vs numeric enums`