Do you think this is a clever way to circumvent using ENUM for a parameter?

Question

Do you think this is a clever way to circumvent using ENUM for a parameter?

As I continue to explore different coding styles in Typescript and Angular, I recently encountered a method without any comments attached to it.

It seems like this method is enforcing that the value passed in must be one of the defined options, but strangely, it does not utilize ENUM for enforcement. This lack of documentation could potentially cause issues in a large codebase.

Is my understanding correct that this method requires the value to be equal to one of the || options?

static getEndpoint = (type: string = 'alpha' || 'bravo' || 'charlie) => {}

In my opinion, utilizing an ENUM would have been a better approach:

export enum MyTypes {
  ALPHA = 'alpha',
  BRAVO = 'bravo',
  CHARLIE = 'charlie',
}

And then modifying the method like this:

static getEndpoint = (type: MyTypes = MyTypes.ALPHA) => {}

angular typescript

Answer 1

Answer №1

In the hypothetical scenario:

static getEndpoint = (type: 'alpha' | 'bravo' | 'charlie' = 'alpha') => {}

then indeed. However, at present, it will permit any string input and default to 'alpha'. This is due to:

(type: string = 'alpha' || 'bravo' || 'charlie')
//     ^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//       |                  \ the default value, 
//       |                    which results in: 'alpha'
//       |
//       \-- the actual type (in this case: string)

Reference: Literal Types

Answer 2

In the hypothetical scenario:

static getEndpoint = (type: 'alpha' | 'bravo' | 'charlie' = 'alpha') => {}

then indeed. However, at present, it will permit any string input and default to 'alpha'. This is due to:

(type: string = 'alpha' || 'bravo' || 'charlie')
//     ^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//       |                  \ the default value, 
//       |                    which results in: 'alpha'
//       |
//       \-- the actual type (in this case: string)

Reference: Literal Types

Answer 3

Answer №2

The code displayed is unable to compile due to a missing '. However, assuming you have this:

static getEndpoint = (type: string = 'alpha' || 'bravo' || 'charlie') => {}

then no, the code does not enforce anything other than the requirement for type to be a string. Essentially, the code above is no different from:

static getEndpoint = (type: string = 'alpha') => {}

The section after the = sign represents a default parameter value, and the expression 'alpha' || 'bravo' || 'charlie' will always evaluate to 'alpha'.

It seems like it was supposed to be written as follows:

static getEndpoint = (type: 'alpha' | 'bravo' | 'charlie') => {}

This uses a union of string literal types, requiring the type passed for type to be either "alpha", "bravo", or "charlie". For example:

getEndpoint("alpha");

However, passing a variable like s even if it contains the string "alpha" without verification at compile-time would not work:

let s: string;
// ...something setting `s`...
getEndpoint(s);

In this form, using a union of string literal types serves a similar function to an enum.

If it were up to me, I would have approached it differently...

You've introduced two modifications there:

Employing an enum design
Offering a distinct default value — well, technically it's the same but done intentionally :-)

Your version works fine, but if you prefer string literal types, it would appear like this:

static getEndpoint = (type: 'alpha' | 'bravo' | 'charlie' = 'alpha') => {}

Answer 4

The code displayed is unable to compile due to a missing '. However, assuming you have this:

static getEndpoint = (type: string = 'alpha' || 'bravo' || 'charlie') => {}

then no, the code does not enforce anything other than the requirement for type to be a string. Essentially, the code above is no different from:

static getEndpoint = (type: string = 'alpha') => {}

The section after the = sign represents a default parameter value, and the expression 'alpha' || 'bravo' || 'charlie' will always evaluate to 'alpha'.

It seems like it was supposed to be written as follows:

static getEndpoint = (type: 'alpha' | 'bravo' | 'charlie') => {}

This uses a union of string literal types, requiring the type passed for type to be either "alpha", "bravo", or "charlie". For example:

getEndpoint("alpha");

However, passing a variable like s even if it contains the string "alpha" without verification at compile-time would not work:

let s: string;
// ...something setting `s`...
getEndpoint(s);

In this form, using a union of string literal types serves a similar function to an enum.

If it were up to me, I would have approached it differently...

You've introduced two modifications there:

Employing an enum design
Offering a distinct default value — well, technically it's the same but done intentionally :-)

Your version works fine, but if you prefer string literal types, it would appear like this:

static getEndpoint = (type: 'alpha' | 'bravo' | 'charlie' = 'alpha') => {}

Do you think this is a clever way to circumvent using ENUM for a parameter?

Answer №1

Answer №2

Similar questions

Incorporating a counter feature into an Angular HTML document

What is the best way to change the parent route without losing the child routes?

Transforming a function into an array in TypeScript

Creating a sequence of HTTP calls that call upon themselves using RxJs operators

How to retrieve a parameter value within the app component in Angular 2

Associating function parameters with object types in TypeScript

A guide on implementing getStaticProps using TypeScript in Next.js

`The error "mockResolvedValue is not recognized as a function when using partial mocks in Jest with Typescript

The challenge with the Optional Chaining operator in Typescript 3.7@beta

Exploring date comparisons in TypeScript and Angular 4

The ngxpagination template is currently experiencing issues with filtering and pagination functionality

Angular 2 Material - Troubleshooting: Why does my input lose focus?

Error message: "Using AngularFire 2 caused an issue as Firebase is not identified as a

Using Stack and Drawer Navigations Together in React Native Navigation(v6)

TypeScript's Awaitable concept

Searching for MongoDB / Mongoose - Using FindOneById with specific conditions to match the value of an array inside an object nestled within another array

Strategies for effectively choosing this specific entity from the repository

There is no way to convert a strongly typed object into an observable object using MobX

An error is thrown when attempting to use npm install, stating "integrity checksum failed. The expected sha1 checksum was sha1-6G...=, but the actual checksum was sha512

What is the approach taken by this component to display its child elements?