Ensuring the correct class type in a switch statement

Question

Ensuring the correct class type in a switch statement

It's been a while since I've used Typescript and I'm having trouble remembering how to properly type guard multiple classes within a switch statement.

class A {}
class B {}
class C {}

type OneOfThem = A | B | C;

function test(foo: OneOfThem): string {
    switch(/* something using foo */) {
        /* A */:
            return "A";
        /* B */:
            return "B";
        /* C */:
            return "C";

        /* should not need to use "default" as all cases are handled */
    }
}

I have tried various options, such as:

Using foo.constructor
Using instanceof inside the case statements
adding an extra member to the three classes to be used in the switch statement

but none of them seem to work (

Function lacks ending return statement and return type does not include 'undefined'

).

Am I mistaken in thinking that this cannot be done with classes?

typescript class switch-statement deno typeguards

Answer 1

Answer №1

Introducing an additional member to the three classes for utilization in the switch statement

This approach is likely the most straightforward solution for your scenario: it employs Discriminated Union. By including a discriminant member in each class, utilizing literal types (i.e. not just string or number), you can distinguish which class foo originates from:

class A {
    readonly kind = "a"
}
class B {
    kind: "b" = "b"
}
class C {
    kind = "c" as const
}

Subsequently, differentiate according to this kind discriminant property:

function test(foo: OneOfThem): string { // Alright
    switch (foo.kind) {
        case "a":
            foo
            return "A";
        case "b":
            foo
            return "B";
        case "c":
            foo
            return "C";
    }
}

Playground Link

Answer 2

Introducing an additional member to the three classes for utilization in the switch statement

This approach is likely the most straightforward solution for your scenario: it employs Discriminated Union. By including a discriminant member in each class, utilizing literal types (i.e. not just string or number), you can distinguish which class foo originates from:

class A {
    readonly kind = "a"
}
class B {
    kind: "b" = "b"
}
class C {
    kind = "c" as const
}

Subsequently, differentiate according to this kind discriminant property:

function test(foo: OneOfThem): string { // Alright
    switch (foo.kind) {
        case "a":
            foo
            return "A";
        case "b":
            foo
            return "B";
        case "c":
            foo
            return "C";
    }
}

Playground Link

Ensuring the correct class type in a switch statement

Answer №1

Similar questions

Unable to locate the main source for loading

The path referenced in typings is incorrect

"Extra loader required to manage output from these loaders." error encountered in React and Typescript

The Angular @Input directive may be prone to receiving inaccurate model data

transitioning from angular cli version 1.7 to version 12

A guide to fetching and organizing an array of object identifiers using TypeScript

Using C++ Empty Angle Brackets in a Template Class Return Function

What is the best way to implement callbacks with $http in Typescript?

Tips for storing information in a JSON document?

An issue occurred in the modal window following the relocation of project files

Error encountered while initializing a C++ deque to read and store data within a class

Is there a way to ensure that the return type of a generic function is always optional in Typescript?

flushMicrotasks does not function properly in conjunction with the image.onload event

Angular Error TS2554: Received x arguments instead of the expected 0 on piped operators

Creating an endless scrolling feature with Ionic 3

Deducing data types from arrays containing both narrow and wide elements

What is the best method for compressing and decompressing JSON data using PHP?

What is the best way to implement this object builder in TypeScript strict mode without adding unnecessary weight to it?

Incorporating Ionic v3 with the latest StripeJS/Stripe Elements version 7.26.0

How can type annotations be properly incorporated into this TypeScript code using an inline function class?