Find out the quantity of enum elements in TypeScript

Question

Find out the quantity of enum elements in TypeScript

Exploring the realm of TypeScript, one may wonder about determining the number of elements in an enum. Consider this example:

enum ExampleEnum {

    element1 = 1,
    element2 = 2,
    element3 = 3,
    element4 = 4,
    element5 = 5,
    element6 = 6

}

var exampleEnumElementCount:number = ?

So how exactly can we figure out the count of elements in this Enum? In the given case, it should be 6.

typescript enums

Answer 1

Answer №1

Getting the count of enum elements in Typescript can be achieved using a workaround method. By utilizing the implementation of enum reverse mapping, you can use the following code snippet:

Object.keys(ExampleEnum).length / 2;

It is important to note that for string enums, dividing by two is not necessary as no reverse mapping properties are generated:

Object.keys(StringEnum).length;

If your enum contains both string and numeric values, you can calculate the count using the following approach:

Object.keys(ExampleEnum).filter(isNaN).length;

Answer 2

Getting the count of enum elements in Typescript can be achieved using a workaround method. By utilizing the implementation of enum reverse mapping, you can use the following code snippet:

Object.keys(ExampleEnum).length / 2;

It is important to note that for string enums, dividing by two is not necessary as no reverse mapping properties are generated:

Object.keys(StringEnum).length;

If your enum contains both string and numeric values, you can calculate the count using the following approach:

Object.keys(ExampleEnum).filter(isNaN).length;

Answer 3

Answer №2

When working with an enum that starts counting from 0, you have the option to add a placeholder for the size as the last element, like this:

enum ERROR {
  UNKNOWN = 0,
  INVALID_TYPE,
  BAD_ADDRESS,
  ...,
  __LENGTH
}

By utilizing ERROR.__LENGTH, you can easily determine the total size of the enum, regardless of how many elements are added.

If you need to introduce an arbitrary offset, you can include it in the enum definition:

enum ERROR {
  __START = 7,
  INVALID_TYPE,
  BAD_ADDRESS,
  __LENGTH
}

In this scenario, the number of meaningful errors would be calculated as

ERROR.__LENGTH - (ERROR.__START + 1)

Answer 4

When working with an enum that starts counting from 0, you have the option to add a placeholder for the size as the last element, like this:

enum ERROR {
  UNKNOWN = 0,
  INVALID_TYPE,
  BAD_ADDRESS,
  ...,
  __LENGTH
}

By utilizing ERROR.__LENGTH, you can easily determine the total size of the enum, regardless of how many elements are added.

If you need to introduce an arbitrary offset, you can include it in the enum definition:

enum ERROR {
  __START = 7,
  INVALID_TYPE,
  BAD_ADDRESS,
  __LENGTH
}

In this scenario, the number of meaningful errors would be calculated as

ERROR.__LENGTH - (ERROR.__START + 1)

Answer 5

Answer №3

The solution provided may not function correctly with enum versions containing attached values, but my revised version caters to all types of enums:

export function countEnumElements(enumType: any): number {
    let count = 0
    for(let key in enumType) {
        if(isNaN(Number(key))) count++
    }
    return count
}

Test code example using Mocha:

it('enumElementCounts', function() {
    enum IntEnum { one, two }
    enum StringEnum { one = 'oneman', two = 'twoman', three = 'threeman' }
    enum NumberEnum { lol = 3, mom = 4, kok = 5, pop = 6 }
    expect(countEnumElements(IntEnum)).to.equal(2)
    expect(countEnumElements(StringEnum)).to.equal(3)
    expect(countEnumElements(NumberEnum)).to.equal(4)
})

Answer 6

The solution provided may not function correctly with enum versions containing attached values, but my revised version caters to all types of enums:

export function countEnumElements(enumType: any): number {
    let count = 0
    for(let key in enumType) {
        if(isNaN(Number(key))) count++
    }
    return count
}

Test code example using Mocha:

it('enumElementCounts', function() {
    enum IntEnum { one, two }
    enum StringEnum { one = 'oneman', two = 'twoman', three = 'threeman' }
    enum NumberEnum { lol = 3, mom = 4, kok = 5, pop = 6 }
    expect(countEnumElements(IntEnum)).to.equal(2)
    expect(countEnumElements(StringEnum)).to.equal(3)
    expect(countEnumElements(NumberEnum)).to.equal(4)
})

Answer 7

Answer №4

Expanding on the response provided by @Esqarrouth, it is important to note that in an enum, each value except for string enums will result in two keys being generated. For instance, consider the following enum defined in TypeScript:

enum MyEnum {
    a = 0, 
    b = 1.5,
    c = "oooo",
    d = 2,
    e = "baaaabb"
}

Upon transpilation into Javascript, the resulting code will look like this:

var MyEnum;
(function (MyEnum) {
    MyEnum[MyEnum["a"] = 0] = "a";
    MyEnum[MyEnum["b"] = 1.5] = "b";
    MyEnum["c"] = "oooo";
    MyEnum[MyEnum["d"] = 2] = "d";
    MyEnum["e"] = "baaaabb";
})(MyEnum || (MyEnum = {}));

In the above example, you can observe that having an entry like a assigned the value 0 results in two corresponding keys; MyEnum["a"] and MyEnum[0]. Conversely, string values such as entries c and e only generate one key.

To determine the total count of keys, one can identify the Keys that are not numeric, thus:

var MyEnumCount = Object.keys(MyEnum).map((val, idx) => Number(isNaN(Number(val)))).reduce((a, b) => a + b, 0);

This code snippet iterates over all keys, assigning a value of 1 to string keys and 0 to numerical keys, then aggregates them using the reduce function.

An alternative method that may be easier to comprehend is as follows:

var MyEnumCount = (() => {
    let count = 0;
    Object.keys(MyEnum).forEach((val, idx) => {
        if (Number(isNaN(Number(val)))) {
            count++;
        }
    });
    return count;
})();

You can experiment with this concept on the TypeScript playground available at https://www.typescriptlang.org/play/

Answer 8

Expanding on the response provided by @Esqarrouth, it is important to note that in an enum, each value except for string enums will result in two keys being generated. For instance, consider the following enum defined in TypeScript:

enum MyEnum {
    a = 0, 
    b = 1.5,
    c = "oooo",
    d = 2,
    e = "baaaabb"
}

Upon transpilation into Javascript, the resulting code will look like this:

var MyEnum;
(function (MyEnum) {
    MyEnum[MyEnum["a"] = 0] = "a";
    MyEnum[MyEnum["b"] = 1.5] = "b";
    MyEnum["c"] = "oooo";
    MyEnum[MyEnum["d"] = 2] = "d";
    MyEnum["e"] = "baaaabb";
})(MyEnum || (MyEnum = {}));

In the above example, you can observe that having an entry like a assigned the value 0 results in two corresponding keys; MyEnum["a"] and MyEnum[0]. Conversely, string values such as entries c and e only generate one key.

To determine the total count of keys, one can identify the Keys that are not numeric, thus:

var MyEnumCount = Object.keys(MyEnum).map((val, idx) => Number(isNaN(Number(val)))).reduce((a, b) => a + b, 0);

This code snippet iterates over all keys, assigning a value of 1 to string keys and 0 to numerical keys, then aggregates them using the reduce function.

An alternative method that may be easier to comprehend is as follows:

var MyEnumCount = (() => {
    let count = 0;
    Object.keys(MyEnum).forEach((val, idx) => {
        if (Number(isNaN(Number(val)))) {
            count++;
        }
    });
    return count;
})();

You can experiment with this concept on the TypeScript playground available at https://www.typescriptlang.org/play/

Answer 9

Answer №5

To simplify the process, we first check for NaN and then determine the length. Let's explore this approach using integer-based enums and string-based enums.

Integer based enum:

enum Color {
  Red = 0,
  Green,
  Blue
}

console.log(Object.keys(Color)) /// output: ["0", "1", "2", "Red", "Green", "Blue"]

Therefore, the length is:

const enumLength = Object.keys(Color).filter(key => isNaN(Number(key))).length;
console.log(enumLength); /// output: 3

String based enum:

enum Color {
  Red = 'red',
  Green = 'green',
  Blue  = 'blue'
}

console.log(Object.keys(Color)) /// output: ["Red", "Green", "Blue"]
const enumLength = Object.keys(Color).filter(key => isNaN(Number(key))).length;
console.log(enumLength); /// **output: 3**

Answer 10

To simplify the process, we first check for NaN and then determine the length. Let's explore this approach using integer-based enums and string-based enums.

Integer based enum:

enum Color {
  Red = 0,
  Green,
  Blue
}

console.log(Object.keys(Color)) /// output: ["0", "1", "2", "Red", "Green", "Blue"]

Therefore, the length is:

const enumLength = Object.keys(Color).filter(key => isNaN(Number(key))).length;
console.log(enumLength); /// output: 3

String based enum:

enum Color {
  Red = 'red',
  Green = 'green',
  Blue  = 'blue'
}

console.log(Object.keys(Color)) /// output: ["Red", "Green", "Blue"]
const enumLength = Object.keys(Color).filter(key => isNaN(Number(key))).length;
console.log(enumLength); /// **output: 3**

Find out the quantity of enum elements in TypeScript

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Trouble with HammerJs swipeRight and swipeLeft in Angular 8 when using overflow:auto

The Ionic 5 app features a white iframe that functions perfectly on the web platform

I am unable to refresh the table data in Angular

What is the most effective way to properly define class attributes?

Guide to setting the order of rendering in React applications

Unit testing Angular components can often uncover errors that would otherwise go unnoticed in production. One common

Fast screening should enhance the quality of the filter options

Error in Angular Apollo V3: Jest unable to locate module 'apollo-angular'

Navigating in Angular when encountering an HTTP 401 Error

Are npm @types packages causing issues in Visual Studio?

Obtaining data from a Nested Json file in Angular 5

Retrieve the precise generic type from a function

experimenting with a TypeScript annotation

The new experimental appDir feature in Next.js 13 is failing to display <meta> or <title> tags in the <head> section when rendering on the server

Validating user input on the server side in a Typescript and .NET Core application

Assign each active class name to the Tab components in React

Load images in advance using the link tag to eliminate the warning (html/Javascript)

How can we add a key:value pair at a specific position in an array in Angular 2 using Typescript?

As soon as you start typing in the TextInput field, the keyboard abruptly disappears

Can one mimic a TypeScript decorator?