TypeScript's version of Java's enum (or C#'s structure)

Question

TypeScript's version of Java's enum (or C#'s structure)

I'm facing the challenge of creating an enum in Typescript that mimics the functionality of Java enums. In TypeScript, only integer-based enums like C# are supported, unlike in Java where we can have custom objects with non-integer related properties within an enum. Is there a way to achieve this in Typescript without having to resort to workarounds?

My goal is to replicate an enum structure similar to this Java code snippet in Typescript:

public enum Something { 

 PENNY("PENNY"), NICKLE("NICKLE"); 

 private String value; 

 private Something (String value) { 
  this.value = value; 
 } 

};

typescript enums

Answer 1

Answer №1

Currently, the current programming languages like Java or C# do not have native support for enums. However, I have come up with a workaround solution.

/**
 * Decorator for Enum.
 * @param {string} idPropertyName - property name to find enum value by property value. Usage in valueOf method
 * @return constructor of enum type
 */
export function Enum<T = any>(idPropertyName?: keyof T) {
    // Implementation details go here...
}

// Other types and interfaces related to Enums...

/** 'Casting' method to make correct Enum Type */
export function EnumType<T>(): IStaticEnum<T> {
    return (<IStaticEnum<T>> Enumerable);
}

Now, using enums has become much simpler

// Example usage of the Enum workaround

@Enum("value")
class Something extends EnumType<Something>() {

    static readonly PENNY = new Something("Penny");
    static readonly NICKLE = new Something("Nickle");

    constructor(readonly value: string) {
        super();
    }
}

// Sample usage of the created Enum
console.log("" + Something.PENNY);              
console.log("" + Something.NICKLE);             
console.log(Something.values());                
console.log(Something.valueByName("PENNY"));    
console.log(Something.PENNY.enumName);

All the solutions provided above ensure type safety when working with Enums.

Answer 2

Currently, the current programming languages like Java or C# do not have native support for enums. However, I have come up with a workaround solution.

/**
 * Decorator for Enum.
 * @param {string} idPropertyName - property name to find enum value by property value. Usage in valueOf method
 * @return constructor of enum type
 */
export function Enum<T = any>(idPropertyName?: keyof T) {
    // Implementation details go here...
}

// Other types and interfaces related to Enums...

/** 'Casting' method to make correct Enum Type */
export function EnumType<T>(): IStaticEnum<T> {
    return (<IStaticEnum<T>> Enumerable);
}

Now, using enums has become much simpler

// Example usage of the Enum workaround

@Enum("value")
class Something extends EnumType<Something>() {

    static readonly PENNY = new Something("Penny");
    static readonly NICKLE = new Something("Nickle");

    constructor(readonly value: string) {
        super();
    }
}

// Sample usage of the created Enum
console.log("" + Something.PENNY);              
console.log("" + Something.NICKLE);             
console.log(Something.values());                
console.log(Something.valueByName("PENNY"));    
console.log(Something.PENNY.enumName);

All the solutions provided above ensure type safety when working with Enums.

Answer 3

Answer №2

Even though TypeScript enums can only hold numeric values, it is still possible to access their names as well as their indexes. To get the name of an enum value, you can pass the number back to the enum itself:

enum Color { Red, Green, Blue }

console.log(Color[Color.Red]); // "Red"

Another approach is to utilize a Map for this purpose:

const colorText = new Map([
  [Color.Red, 'RED'],
  // Add more mappings here...
]);

Answer 4

Even though TypeScript enums can only hold numeric values, it is still possible to access their names as well as their indexes. To get the name of an enum value, you can pass the number back to the enum itself:

enum Color { Red, Green, Blue }

console.log(Color[Color.Red]); // "Red"

Another approach is to utilize a Map for this purpose:

const colorText = new Map([
  [Color.Red, 'RED'],
  // Add more mappings here...
]);

Answer 5

Answer №3

After some research on this topic, I discovered that TypeScript has included support for String Enums since version 2.4. This feature is similar to Java's enum and very user-friendly.

Check out the release notes for TypeScript 2.4 here:

String Enums

In TypeScript 2.4, enum members can now have string initializers.

enum Colors {
    Red = "RED",
    Green = "GREEN",
    Blue = "BLUE", }

One thing to note is that enums initialized with strings cannot be reverse-mapped to retrieve the original enum member name. In other words, you cannot use Colors["RED"] to get the string "Red".

Answer 6

After some research on this topic, I discovered that TypeScript has included support for String Enums since version 2.4. This feature is similar to Java's enum and very user-friendly.

Check out the release notes for TypeScript 2.4 here:

String Enums

In TypeScript 2.4, enum members can now have string initializers.

enum Colors {
    Red = "RED",
    Green = "GREEN",
    Blue = "BLUE", }

One thing to note is that enums initialized with strings cannot be reverse-mapped to retrieve the original enum member name. In other words, you cannot use Colors["RED"] to get the string "Red".

Answer 7

Answer №4

Creating an enum is as simple as this and it functions similarly to Java or C#.

export enum ControlType {
  INPUT,
  SELECT,
  DATEPICKER
}


console.log(ControlType.INPUT); // returns 0
console.log(ControlType[ControlType.INPUT]); // returns INPUT

You can include additional information with numeric values only.

export enum ControlType {
  INPUT = 3,
  SELECT = 6,
  DATEPICKER = "abc".length // computed member
}

console.log(ControlType.INPUT); // returns 3

If you need to add members that are not numbers, you can use <any> type.

export enum ControlType {
  INPUT = <any>'input',
  SELECT = <any>'select',
  DATEPICKER = <any>'date-picker'
}

console.log(ControlType.INPUT); // returns 'input'

The limitation is that you can only compare these values with variables of type any. For example;

(ControlType.INPUT === myVar) {..}

In this case, myVar must be declared as myVar: any = 'input'; even if it's a string.

Answer 8

Creating an enum is as simple as this and it functions similarly to Java or C#.

export enum ControlType {
  INPUT,
  SELECT,
  DATEPICKER
}


console.log(ControlType.INPUT); // returns 0
console.log(ControlType[ControlType.INPUT]); // returns INPUT

You can include additional information with numeric values only.

export enum ControlType {
  INPUT = 3,
  SELECT = 6,
  DATEPICKER = "abc".length // computed member
}

console.log(ControlType.INPUT); // returns 3

If you need to add members that are not numbers, you can use <any> type.

export enum ControlType {
  INPUT = <any>'input',
  SELECT = <any>'select',
  DATEPICKER = <any>'date-picker'
}

console.log(ControlType.INPUT); // returns 'input'

The limitation is that you can only compare these values with variables of type any. For example;

(ControlType.INPUT === myVar) {..}

In this case, myVar must be declared as myVar: any = 'input'; even if it's a string.

Answer 9

Answer №5

Many individuals are unaware of the true essence of Java enums, which consist of a collection of static singletons sharing a common base class.

This concept greatly differs from primitive-based enums. In C#, one has the ability to incorporate extension methods into an enum, but lacks polymorphism functionality. Meanwhile, in Typescript, usage of a static function is required.

Moreover, there exists a relatively new paradigm of sealed classes that do not rely on static elements, enabling the utilization of interfaces instead of abstract base classes. These classes can directly participate in constructor-based dependency injection, unlike enums which only allow for property injection.

C# may also offer sealed classes, whereas Typescript does not possess final or even sealed options, necessitating the emulation through a parallel interface and factory coupled with a switch statement.

Answer 10

Many individuals are unaware of the true essence of Java enums, which consist of a collection of static singletons sharing a common base class.

This concept greatly differs from primitive-based enums. In C#, one has the ability to incorporate extension methods into an enum, but lacks polymorphism functionality. Meanwhile, in Typescript, usage of a static function is required.

Moreover, there exists a relatively new paradigm of sealed classes that do not rely on static elements, enabling the utilization of interfaces instead of abstract base classes. These classes can directly participate in constructor-based dependency injection, unlike enums which only allow for property injection.

C# may also offer sealed classes, whereas Typescript does not possess final or even sealed options, necessitating the emulation through a parallel interface and factory coupled with a switch statement.

TypeScript's version of Java's enum (or C#'s structure)

Answer №1

Answer №2

Answer №3

String Enums

Answer №4

Answer №5

Similar questions

The getStaticProps() function in NextJS has not been invoked

Struggling with the compilation of this Typescript code

Creating organized lists in Angular 4 using list separators

What is the best way to set up the parser and plugins using ESLint's updated flat configuration?

Component html element in Angular not being updated by service

What is the best way to output a JSX element using an inline switch statement?

What could be the reason for the exclusion of 'null' from the return type of Document.getElementById in VS Code?

Issue: Unrecognized element type in next.js while starting development server

Creating robust unit tests for Node.js applications with the help of redis-mock

React TSX file not recognizing JSON data stored in an HTML data attribute

In production mode, ExpressJs dispatches the stack efficiently

How can I retrieve the `checked` state of an input in Vue 3 using Typescript?

What is the best way to send multiple parameters to @Directives or @Components in Angular using TypeScript?

Tips for delivering a variable to a React Native Stylesheet

A guide on accessing a dynamic object key in array.map()

JavaScript heap running out of memory after upgrading from Angular 11 to versions 12, 13, or 14

Error message stating: rxjs and firebase encountered a TypeError when attempting to add property 0 because the object is not

The use of aliases is not supported by a published node module

`Is there a way to manage date formats across all components using a single method in Angular?`

What is the best way to implement a <Toast> using blueprintjs?