Benchmark: Enum vs const vs string

Script Preparation code:

var MyEnum;
(function (MyEnum) {
  MyEnum[MyEnum["Unknown"] = 0] = "Unknown";
  MyEnum[MyEnum["Ok"] = 1] = "Ok";
  MyEnum[MyEnum["NotOk"] = 2] = "NotOk";
})(MyEnum || (MyEnum = {}));

var ConstEnumNumber = {
  Unknown: 0,
  Ok: 1,
  NotOk: 2
};

var ConstEnumString = {
  Unknown: "Unknown",
  Ok: "Ok",
  NotOk: "NotOk"
};

var unknownValueToCompareString = "Unknown";
var unknownValueToCompareNumber = 0;

Tests:

Compare Enum string
MyEnum.Unknown === unknownValueToCompareString;
Compare Enum number
MyEnum.Unknown === unknownValueToCompareNumber;
compare const string
ConstEnumString.Unknown === unknownValueToCompareString;
compare const number
ConstEnumString.Unknown === unknownValueToCompareNumber;
compare inline string
"Unknown" === unknownValueToCompareString;
compare inline number
0 === unknownValueToCompareNumber;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Compare Enum string
Compare Enum number
compare const string
compare const number
compare inline string
compare inline number

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
Compare Enum string	9374693.0 Ops/sec
Compare Enum number	9243458.0 Ops/sec
compare const string	10602270.0 Ops/sec
compare const number	10656327.0 Ops/sec
compare inline string	19875886.0 Ops/sec
compare inline number	19958186.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark is designed to compare the performance costs of using enums in TypeScript versus using `const` strings. The test cases measure the execution time of equality comparisons between enum values, `const` string literals, and primitive values (numbers).

**Options Being Compared**

There are four options being compared:

1. **Enums**: Using enums with named values (`MyEnum.Unknown`, etc.)
2. **Const Strings**: Using `const` strings with string literals (`"Unknown"`, etc.)
3. **Inline String Literals**: Using string literals without `const` or enum syntax (`"Unknown"` in the test cases)
4. **Inline Number Comparisons**: Using primitive number comparisons (e.g., `0 === unknownValueToCompareNumber`)

**Pros and Cons of Each Approach**

1. **Enums**:
	* Pros: Can make code more readable, especially for complex value sets.
	* Cons: May have performance overhead due to lookup or iteration in the enum definition.
2. **Const Strings**:
	* Pros: Provides compile-time checks for string literals, making it easier to catch typos or invalid values.
	* Cons: May have a small performance overhead due to string interpolation or comparison at runtime.
3. **Inline String Literals**:
	* Pros: Often the fastest option, as strings can be directly compared using `===`.
	* Cons: Can lead to typos or invalid values if not properly maintained.
4. **Inline Number Comparisons**:
	* Pros: Fast and straightforward comparisons between numbers.
	* Cons: May not provide compile-time checks for valid number values.

**Library and Special JS Features**

In this benchmark, the `Enum` implementation is using a self-invoking function to create an object with named properties (`MyEnum[myValue] = value`). This is a common pattern in TypeScript to define enum-like behavior. The `ConstEnumNumber` and `ConstEnumString` variables are using `const` syntax to define objects with string values.

**Other Considerations**

When working with enums, it's essential to consider the following:

* Lookup performance: Enums can have a slower lookup time compared to directly accessing primitive values.
* Compile-time checks: Using enums or `const` strings can provide compile-time checks for invalid values or typos.

For inline string literals and number comparisons, it's crucial to maintain accuracy and consistency in your code to avoid unexpected behavior or errors.

**Alternatives**

If you're looking for alternative approaches, consider the following:

* Using primitive types (e.g., `let value: number = 0;`) instead of enums or strings.
* Employing a custom comparison function for enum values or string literals, which can provide more flexibility and control over comparisons.
* Utilizing libraries like `lodash` or `immer` to implement optimized string matching or enum lookup.

Keep in mind that the best approach depends on your specific use case, performance requirements, and code maintainability considerations.

Related benchmarks:

Enum vs const vs string (version: 0)

this is used to try and better understand the performance costs of using enum's in typescript

Comparing performance of: Compare Enum string vs Compare Enum number vs compare const string vs compare const number vs compare inline string vs compare inline number

Created: 3 years ago by: Registered User

Jump to the latest result

Compare Enum string

Compare Enum number

compare const string

compare const number

compare inline string

compare inline number

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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