Ensuring the validity of various data types using typeguard

Question

Ensuring the validity of various data types using typeguard

How can I create a type guard that validates multiple types? Here is what I have in mind:

interface A { }

interface B extends A {
  foo: number;
}

interface C extends A {
  bar: number;
}

function checkType<T extends A>(item: A): item is T {
  if((item as B).foo)
    // validate as B
  if((item as A).bar)
    // validate as A
}

This is how I plan to implement it:

if(checkType<B>(item)) {
// do something 
}

typescript

Answer 1

Answer №1

It has been mentioned that achieving what you desire is not feasible.

During the compilation of TypeScript code, the static type system gets erased. Therefore, consider the following TypeScript code snippet:

const item: A = { foo: 123 };
if (is<B>(item)) { console.log(item.foo.toFixed(2)); }
if (is<C>(item)) { console.log(item.bar.toFixed(2)); }

The resulting JavaScript code after compilation could look like this:

const item: A = Math.random() < 0.5 ? { foo: 123 } : { bar: 456 };
if (is(item)) { console.log(item.foo.toFixed(2)); }
if (is(item)) { console.log(item.bar.toFixed(2)); }

Hence, at runtime, it becomes essential for `is(item)` to function as a `B` check in one instance and a `C` check in the next. This scenario requires uniqueness in results based on type information which isn't inherently present. It delves into the realm of supernatural capabilities beyond standard human-made software functionality.

To implement something achievable without resorting to magic, the solution lies in providing your function with runtime data to determine the appropriate checks. For example, tweaking `is()` to include a second parameter containing the type name to be checked:

const item: A = Math.random() < 0.5 ? { foo: 123 } : { bar: 456 };
if (is(item, "B")) { console.log(item.foo.toFixed(2)); }
if (is(item, "C")) { console.log(item.bar.toFixed(2)); }

This updated approach enables the `is()` implementation to utilize the second parameter to determine the property to validate at runtime. While the solution may seem convoluted, it's viable and comes with an appropriately defined type signature showcasing its integrity:

type PossibleTypes = B | C;
const props = {
    B: "foo",
    C: "bar"
} as const
type Props = typeof props;

function is<K extends keyof Props>(
    item: A,
    typeName: K
): item is Extract<PossibleTypes, Record<Props[K], number>> {
    const key = props[typeName];
    return ((key in item) && (typeof (item as any)[key] === "number"));
}

In this new setup, a precise union type `PossibleTypes` enumerates the types eligible for checking within `is()`. The `props` object maps type names "B" and "C" to their respective properties for verification. Also, `Props` represents the type of `props` in use.

The `is()` function employs generics via `K` for the type name, whereas the result constitutes a type predicate confirming if `item` aligns with either type `B` or `C`. Type extraction from the `PossibleTypes` union ensures accuracy by verifying a numeric property matching the key specified in `Props[K]`.

By mapping type names to valid keys and validating these keys within `item`, the `is()` mechanism adeptly performs the necessary property verifications.

While there exist alternate paths to transform `is()` into a manageable form, each alteration might yield similar levels of dissatisfaction due to minimal gains from consolidating diverse checks within a single type guard function. With only two types, namely `B` and `C`, opting for simplicity by creating distinct check functions might offer a clearer path forward:

function isB(item: A): item is B {
    return ("foo" in item) && (typeof (item as any).foo === "number");
}
function isC(item: A): item is C {
    return ("bar" in item) && (typeof (item as any).bar === "number");
}
const item: A = Math.random() < 0.5 ? { foo: 123 } : { bar: 456 };
if (isB(item)) { console.log(item.foo.toFixed(2)); }
if (isC(item)) { console.log(item.bar.toFixed(2)); }

Your decision ultimately hinges on specific usage scenarios and personal preferences.

Click here for Playground link to the code

Answer 2

It has been mentioned that achieving what you desire is not feasible.

During the compilation of TypeScript code, the static type system gets erased. Therefore, consider the following TypeScript code snippet:

const item: A = { foo: 123 };
if (is<B>(item)) { console.log(item.foo.toFixed(2)); }
if (is<C>(item)) { console.log(item.bar.toFixed(2)); }

The resulting JavaScript code after compilation could look like this:

const item: A = Math.random() < 0.5 ? { foo: 123 } : { bar: 456 };
if (is(item)) { console.log(item.foo.toFixed(2)); }
if (is(item)) { console.log(item.bar.toFixed(2)); }

Hence, at runtime, it becomes essential for `is(item)` to function as a `B` check in one instance and a `C` check in the next. This scenario requires uniqueness in results based on type information which isn't inherently present. It delves into the realm of supernatural capabilities beyond standard human-made software functionality.

To implement something achievable without resorting to magic, the solution lies in providing your function with runtime data to determine the appropriate checks. For example, tweaking `is()` to include a second parameter containing the type name to be checked:

const item: A = Math.random() < 0.5 ? { foo: 123 } : { bar: 456 };
if (is(item, "B")) { console.log(item.foo.toFixed(2)); }
if (is(item, "C")) { console.log(item.bar.toFixed(2)); }

This updated approach enables the `is()` implementation to utilize the second parameter to determine the property to validate at runtime. While the solution may seem convoluted, it's viable and comes with an appropriately defined type signature showcasing its integrity:

type PossibleTypes = B | C;
const props = {
    B: "foo",
    C: "bar"
} as const
type Props = typeof props;

function is<K extends keyof Props>(
    item: A,
    typeName: K
): item is Extract<PossibleTypes, Record<Props[K], number>> {
    const key = props[typeName];
    return ((key in item) && (typeof (item as any)[key] === "number"));
}

In this new setup, a precise union type `PossibleTypes` enumerates the types eligible for checking within `is()`. The `props` object maps type names "B" and "C" to their respective properties for verification. Also, `Props` represents the type of `props` in use.

The `is()` function employs generics via `K` for the type name, whereas the result constitutes a type predicate confirming if `item` aligns with either type `B` or `C`. Type extraction from the `PossibleTypes` union ensures accuracy by verifying a numeric property matching the key specified in `Props[K]`.

By mapping type names to valid keys and validating these keys within `item`, the `is()` mechanism adeptly performs the necessary property verifications.

While there exist alternate paths to transform `is()` into a manageable form, each alteration might yield similar levels of dissatisfaction due to minimal gains from consolidating diverse checks within a single type guard function. With only two types, namely `B` and `C`, opting for simplicity by creating distinct check functions might offer a clearer path forward:

function isB(item: A): item is B {
    return ("foo" in item) && (typeof (item as any).foo === "number");
}
function isC(item: A): item is C {
    return ("bar" in item) && (typeof (item as any).bar === "number");
}
const item: A = Math.random() < 0.5 ? { foo: 123 } : { bar: 456 };
if (isB(item)) { console.log(item.foo.toFixed(2)); }
if (isC(item)) { console.log(item.bar.toFixed(2)); }

Your decision ultimately hinges on specific usage scenarios and personal preferences.

Click here for Playground link to the code

Ensuring the validity of various data types using typeguard

Answer №1

Similar questions

How can I adjust the timeout or enhance my code for Excel Online's ExcelScript error regarding the Range getColumn function timing out?

Adding items to a Mat Menu dynamically during execution

Tips on effectively rendering child components conditionally in React

Retrieve the name from the accordion that was clicked

Using React.js and TypeScript to leverage a single component for both <input /> and <textarea /> elements

Exploring the differences between Typescript decorators and class inheritance

What is the method for throwing errors with NestJS guards without relying on an authentication module?

Rendering illuminated component with continuous asynchronous updates

The Azure function application's automatic reload feature does not function properly with the v4 model

The challenge of resizing dialog elements in Angular Material

What is the method for inserting a loop into a print template?

VS-Code is not a fan of accessors when targeting ES6

TypeScript fails to recognize when variable has already undergone undefined or null value check

Guide on incorporating a bootstrap button into a React component using typescript

Angular Routing can be a powerful tool for managing multiple article posts in an efficient and organized way

How can you obtain the key that comes after or before an existing key in a sorted TypeScript string enum?

Could there be a more effective approach to managing interfaces and eliminating 'TypeErrors'?

index signature in TypeScript is an optional feature

Facing issue with local redis session not functioning as intended

Leverage environment variables within your index.html file