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

compare inline number

20.0M/s

compare inline string

19.9M/s

compare const number

10.7M/s

compare const string

10.6M/s

Compare Enum string

9.4M/s

Compare Enum number

9.2M/s

View exact numbers

Test name	Executions per second
✓ compare inline number	19,958,186 Ops/sec
compare inline string	19,875,886 Ops/sec
compare const number	10,656,327 Ops/sec
compare const string	10,602,270 Ops/sec
Compare Enum string	9,374,693 Ops/sec
Compare Enum number	9,243,458 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.

Enum vs const vs string (version: 0) Benchmark.js

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

Go 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):

Enum vs const vs string (version: 0) Benchmark.js

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

Go 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):

Related benchmarks

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`