文字联合类型的类型保护

Question

I have two types in TypeScript:

type PublicMethods = 'Time' | 'Assets' | 'AssetPairs' ;
type PrivateMethods = 'Balance' | 'TradeBalance';

I would like to use the same api function to handle these types, but the behaviour is different for each. Something along the lines of:

public api = (method: PublicMethods | PrivateMethods, params: any) => {

  // ...how do I create a type guard here?
  if(method instanceof PublicMethods) { // 😱 Doesn't like this!
    // ...
  }

}

I also tried overloading the function, like this:

public api(method: PublicMethods | PrivateMethods, params: any, callback: Function);

public api(method: PublicMethods, params: any, callback: Function) {
   // ...implementation
}

public api(method: PrivateMethods, params: any, callback: Function) {
   // ...implementation
}

Didn't like that either. Any suggestions?

Answer 1

You can create a type guard like this:

const isPublicMethod = (value: any): value is PublicMethod => {
  return ['Time', 'Assets', 'AssetPairs'].includes(value);
};

and then use it in your API integration function:

public api = (method: PublicMethods | PrivateMethods, params: any) => {
  if(isPublicMethod(method)) {
    ...
  }
}

Warning, Be careful, since TS will not throw if PublicMethod type is updated and type guard is not.

To handle this better, use the following approach:

const PUBLIC_METHODS = ['Time', 'Assets', 'AssetPairs'] as const;

type PublicMethod = typeof PUBLIC_METHODS[number];

const isPublicMethod = (value: any): value is PublicMethod => {
  return PUBLIC_METHODS.includes(value);
};

Answer 2

If you define your types based on a constant array:

const PublicMethods = ['Time', 'Assets', 'AssetPairs'] as const;
const PrivateMethods = ['Balance', 'TradeBalance'] as const;

type PublicMethods = typeof PublicMethods[number];
type PrivateMethods = typeof PrivateMethods[number];

You'll now be able to use the name PublicMethods as both a type and a variable that refers to the union of strings and array, respectively. With this, you can create a user-defined type guard using a type predicate :

function isPublicMethod(value: string): value is PublicMethods {
    // some sort of assertion is needed because
    // it will error that type 'string' is not assignable to type '"Time" | "Assets" | "AssetPairs"'
    return PublicMethods.includes(value as any);
}

This allows you to narrow the value to PublicMethods , the type, by checking if PublicMethods , the array, includes value :

function doStuff(method: PrivateMethods | PublicMethods) {
    if (isPublicMethod(method)) {
        method
        // ^? PublicMethods
    }
}

Playground

Answer 3

Note that typescript types are not available at runtime, so

  if(method instanceof PublicMethods) {
    // ...
  }

does not work, since method will actually be a string.

So a very basic solution is a switch .

public api = (method: PublicMethods | PrivateMethods, params: any) => {

  switch(method){
    case 'Time': ...
    case 'Assets': ...
    ...
  }

}

If you want to discern between PublicMethods and PrivateMethods without iterating them, you can use enums:

enum PublicMethods{
  'Time' = 'Time',
  'Assets' = 'Assets'
}

public api = (method: PublicMethods | PrivateMethods, params: any) => {
  if(method in PublicMethods){
    ...
  }

}