Determining if an object aligns with a specific type in Typescript

Question

Determining if an object aligns with a specific type in Typescript

Hey there, I've got a little dilemma. Imagine I have a type called A:

type A = {
    prop1: string,
    prop2: {
        prop3: string
    }
}

Now, let's say I'm getting a JSON object from an outside service and I need to check if that JSON aligns with type A:

function isA(obj:any): boolean {
    // What's the best approach here?
}

If my obj looks something like this:

{
 prop1: "Hello",
 prop2: {
    prop3: "World"
 }
}

or like this:

{
     prop1: "Hello",
     prop2: {
        prop3: "World"
     },
     moreProps: "I don't care about"
}

The function should return true, but for something like this:

{
     foo: "Hello",
     bar: {
        prop3: "World"
     }
}

It should return false. Any ideas on how to make this happen easily?

Cheers!

typescript

Answer 1

Answer №1

Enhance your type validation with a type-guard to help Typescript narrow down types during type-checking

To implement a type-guard, adjust the return type of your isA function to be obj is A

Here's how your type validation function should look like:

function isA(obj: unknown): obj is A {
    // return boolean here
}

Utilize the typeof operator for property verification

The typeof operator provides a string value indicating the variable's type. (docs)

For instance, you can apply it for object A in the following way:

function isA(obj: unknown): obj is A {
    return (
        obj &&
        typeof obj === 'object' &&
        typeof obj['prop1'] === 'string' &&
        obj['prop2'] &&
        typeof obj['prop2'] === 'object' &&
        typeof obj['prop2']['prop3'] === 'string'
    );
}

This may seem complex at first, but breaking it down with comments on each check can enhance readability.

An essential note is that typeof null returns 'object', so remember to verify if an object exists rather than solely checking its type.

By integrating these improvements, you will not only validate types accurately at runtime but also enable TypeScript to refine type-checking by narrowing down obj to type A when isA confirms the match.

Answer 2

Enhance your type validation with a type-guard to help Typescript narrow down types during type-checking

To implement a type-guard, adjust the return type of your isA function to be obj is A

Here's how your type validation function should look like:

function isA(obj: unknown): obj is A {
    // return boolean here
}

Utilize the typeof operator for property verification

The typeof operator provides a string value indicating the variable's type. (docs)

For instance, you can apply it for object A in the following way:

function isA(obj: unknown): obj is A {
    return (
        obj &&
        typeof obj === 'object' &&
        typeof obj['prop1'] === 'string' &&
        obj['prop2'] &&
        typeof obj['prop2'] === 'object' &&
        typeof obj['prop2']['prop3'] === 'string'
    );
}

This may seem complex at first, but breaking it down with comments on each check can enhance readability.

An essential note is that typeof null returns 'object', so remember to verify if an object exists rather than solely checking its type.

By integrating these improvements, you will not only validate types accurately at runtime but also enable TypeScript to refine type-checking by narrowing down obj to type A when isA confirms the match.

Answer 3

Answer №2

Here's an alternative approach that involves creating a "template object" for runtime comparisons:

// Define a constant object as a template for comparison.
const myTemplateObject = {
  prop1: "",
  prop2: 12,
  prop3: 14 as string | number,
  prop4: {
    potatoes: "",
    carrots: 0,
  },
};

// Export the type based on the template object.
export type myType = typeof myTemplateObject;

// Function to check if an object matches the defined type in the template.
export function matchesType(
  object: Record<string, unknown>,
  templateObject: Record<string, unknown>
) {
  for (const key in templateObject) {
    const templatePropValue = templateObject[key];
    const templatePropType = templatePropValue;
    switch (templatePropType) {
      case "function":
      // fall-through
      case "symbol":
      // fall-through
      case "undefined":
        throw new Error(
          `matchesType function does not support template objects with ${templatePropType} fields`
        );
      case "bigint":
      case "boolean":
      case "number":
      case "string":
        return templatePropType === typeof object[key];
      case "object":
        const objectPropValue = object[key];
        if (typeof objectPropValue === "object" && objectPropValue !== null) {
          return matchesType(
            objectPropValue as Record<string, unknown>,
            templatePropValue as Record<string, unknown>
          );
        } else {
          return false;
        }
    }
  }
  return true;
}

Answer 4

Here's an alternative approach that involves creating a "template object" for runtime comparisons:

// Define a constant object as a template for comparison.
const myTemplateObject = {
  prop1: "",
  prop2: 12,
  prop3: 14 as string | number,
  prop4: {
    potatoes: "",
    carrots: 0,
  },
};

// Export the type based on the template object.
export type myType = typeof myTemplateObject;

// Function to check if an object matches the defined type in the template.
export function matchesType(
  object: Record<string, unknown>,
  templateObject: Record<string, unknown>
) {
  for (const key in templateObject) {
    const templatePropValue = templateObject[key];
    const templatePropType = templatePropValue;
    switch (templatePropType) {
      case "function":
      // fall-through
      case "symbol":
      // fall-through
      case "undefined":
        throw new Error(
          `matchesType function does not support template objects with ${templatePropType} fields`
        );
      case "bigint":
      case "boolean":
      case "number":
      case "string":
        return templatePropType === typeof object[key];
      case "object":
        const objectPropValue = object[key];
        if (typeof objectPropValue === "object" && objectPropValue !== null) {
          return matchesType(
            objectPropValue as Record<string, unknown>,
            templatePropValue as Record<string, unknown>
          );
        } else {
          return false;
        }
    }
  }
  return true;
}

Determining if an object aligns with a specific type in Typescript

Answer №1

Answer №2

Similar questions

Deriving values in Typescript based on a subset of a union for conditional typing

Cannot utilize remote.require() in TypeScript due to compatibility issues

Show the attribute of an element in a pop-up window

Incorporate form information into an array in Angular Version 2 or higher

TypeScript encounters challenges with implementing Redux containers

Exploring the Angular Heroes Journey: What's the significance of one being labeled with a colon while the other is identified

Tips on transforming Angular 2/4 Reactive Forms custom validation Promise code into Observable design?

Determine the route parameter name based on the path string, for example, '/posts/:id'

Encountered an issue in React Native/Typescript where the module 'react-native' does not export the member 'Pressable'.ts(2305)

Launch another modal and then deactivate the initial modal

Implementing a ReactJS component with a TypeScript interface for displaying an Alert box message using Material

Svelte: highlighting input text when selected

Handling onChange events for several typescript <Select> elements

Monaco Editor in TypeScript failing to offer autocomplete suggestions

reactjs: disable a specific eslint rule

An error occurs when attempting to create a document using the context.application.createDocument method in the Word Javascript

An error was encountered at line 52 in the book-list component: TypeError - The 'books' properties are undefined. This project was built using Angular

No matter the circumstances, the "Unexpected end of form" error consistently appears when attempting to upload files in Express

tsc will automatically incorporate additional files

Guide to activating data transfer object validators in NEST JS