safeguards for potential parameters

Question

safeguards for potential parameters

Below is a fixture file with optional properties that I have type guarded:

Fixture File-

 {
      "profiles": [
        {
          "name": "Laakea",
          "phoneNumber": "2033719225",
          "authGroupName": "Drivers"
        },
        {
          "name": "Lkhagvasuren",
          "phoneNumber": "2033719225",
          "authGroupName": "Drivers"
        },
        {
          "name": "Joaquin",
          "phoneNumber": "2033719225"
        }
      ]
    }

Type Interface-

 export interface Profile {
      name: string;
      authGroupName?: string;
      phoneNumber?: string;
      email?: string;
    }

Type Guard Function-

export function isValidProfiles(profiles: unknown): profiles is Profile[] {
  if (!Array.isArray(profiles)) {
    return false;
  }
  for (let index = 0; index < profiles.length; index += 1) {
    // Validation logic here
  }

  return true;
}

Instead of multiple if statements, any suggestions to improve the code?

typescript

Answer 1

Answer №1

When you have identical code for checking properties like email, phoneNumber, and authGroupName, it's best to refactor them into a single block of code that can be executed multiple times.

One way to do this is by creating an array of keys (defined with a const assertion to ensure the values are explicitly specified as "email", "phoneNumber", and "authGroupName" instead of just string), and then using the every() method to validate every key against every member in the profiles array:

function isValidProfiles(profiles: unknown): profiles is Profile[] {
  if (!Array.isArray(profiles)) { return false; }
  const keys = ["email", "phoneNumber", "authGroupName"] as const;
  return profiles.every(p => p && (typeof p === "object") && (typeof p.name === "string") &&
    keys.every(k => typeof p[k] === "undefined" || typeof p[k] === "string")
  );
}

In this approach, I'm ensuring that for each key k and each profile p, the type of p[k] is either "undefined" or "string". This allows for handling string properties and missing ones while also accepting properties with keys present but explicitly set to undefined. TypeScript inherently considers these optional unless you activate the --exactOptionalPropertyTypes compiler option, which isn't included in the standard --strict settings.

Now, let's put it to the test:

const val = [
  {
    "name": "Laakea",
    "phoneNumber": "2033719225",
    "authGroupName": "Drivers"
  },
  {
    "name": "Lkhagvasuren",
    "phoneNumber": "2033719225",
    "authGroupName": "Drivers"
  },
  {
    "name": "Joaquin",
    "phoneNumber": "2033719225"
  }
];
if (isValidProfiles(val)) {
  console.log(val.map(
    x => x.authGroupName ?? "no-auth").join(",")
  ); // "Drivers,Drivers,no-auth" 
} else {
  console.log("nope")
}

The validation of val as a Profile[] by the compiler appears successful, allowing smooth operations.

Access the code on Playground

Answer 2

When you have identical code for checking properties like email, phoneNumber, and authGroupName, it's best to refactor them into a single block of code that can be executed multiple times.

One way to do this is by creating an array of keys (defined with a const assertion to ensure the values are explicitly specified as "email", "phoneNumber", and "authGroupName" instead of just string), and then using the every() method to validate every key against every member in the profiles array:

function isValidProfiles(profiles: unknown): profiles is Profile[] {
  if (!Array.isArray(profiles)) { return false; }
  const keys = ["email", "phoneNumber", "authGroupName"] as const;
  return profiles.every(p => p && (typeof p === "object") && (typeof p.name === "string") &&
    keys.every(k => typeof p[k] === "undefined" || typeof p[k] === "string")
  );
}

In this approach, I'm ensuring that for each key k and each profile p, the type of p[k] is either "undefined" or "string". This allows for handling string properties and missing ones while also accepting properties with keys present but explicitly set to undefined. TypeScript inherently considers these optional unless you activate the --exactOptionalPropertyTypes compiler option, which isn't included in the standard --strict settings.

Now, let's put it to the test:

const val = [
  {
    "name": "Laakea",
    "phoneNumber": "2033719225",
    "authGroupName": "Drivers"
  },
  {
    "name": "Lkhagvasuren",
    "phoneNumber": "2033719225",
    "authGroupName": "Drivers"
  },
  {
    "name": "Joaquin",
    "phoneNumber": "2033719225"
  }
];
if (isValidProfiles(val)) {
  console.log(val.map(
    x => x.authGroupName ?? "no-auth").join(",")
  ); // "Drivers,Drivers,no-auth" 
} else {
  console.log("nope")
}

The validation of val as a Profile[] by the compiler appears successful, allowing smooth operations.

Access the code on Playground

Answer 3

Answer №2

Here's a solution I devised -

export function checkValidProfiles(profiles: unknown): profiles is Profile[] {
  if (!Array.isArray(profiles)) {
    return false;
  }
  for (let index = 0; index < profiles.length; index += 1) {
    if (
      !(
        typeof profiles[index].name === 'string' &&
        (!profiles[index].phoneNumber || typeof profiles[index].phoneNumber === 'string') &&
        (!profiles[index].email || typeof profiles[index].email === 'string') &&
        (!profiles[index].authGroupName || typeof profiles[index].authGroupName === 'string')
      )
    ) {
      return false;
    }
  }

  return true;
}

This approach may not be as robust and effective as the method created by @jcalz.

Answer 4

Here's a solution I devised -

export function checkValidProfiles(profiles: unknown): profiles is Profile[] {
  if (!Array.isArray(profiles)) {
    return false;
  }
  for (let index = 0; index < profiles.length; index += 1) {
    if (
      !(
        typeof profiles[index].name === 'string' &&
        (!profiles[index].phoneNumber || typeof profiles[index].phoneNumber === 'string') &&
        (!profiles[index].email || typeof profiles[index].email === 'string') &&
        (!profiles[index].authGroupName || typeof profiles[index].authGroupName === 'string')
      )
    ) {
      return false;
    }
  }

  return true;
}

This approach may not be as robust and effective as the method created by @jcalz.

safeguards for potential parameters

Answer №1

Answer №2

Similar questions

What is the best way to change between different Angular 2 material tabs using typescript?

Incorporating a unique variant with Tailwind called "

Can TypeScript identify and eliminate any undefined values within an array effectively?

Using Angular's setTimeout() function with an external lambda that includes a parameter

Is the stepper's vertical line separating when the label extends onto multiple lines?

TS2304: Unable to locate variable '_ZonePrivate'

Implicated Generic in TypeScript

Add TypeScript typings for npm utility manually by incorporating type definitions

Converting a Promise to an Observable in Angular using Typescript

Ensure that the method is triggered

Displaying Date in Angular 2 Application with Proper Formatting

Ways to utilize an interface with a blank object that will be filled at a subsequent time

Refresh a reactive form in Angular Material

Struggling to successfully deploy a React App to Azure through a Github Actions workflow due to encountering a TypeScript error

Error display in Elastic Apm Rum Angular implementation

The type 'Store<unknown, AnyAction>' is lacking the properties: dispatch, getState, subscribe, and replaceReducer

Error message: Unable to locate module when utilizing my alternative library packaged with Rollup

Utilize puppeteer and web-vitals in NextJS to retrieve the web performance metrics of a website

Exploring the world of mouse events in Typescript using JQuery, all the while maintaining strict typing regulations

What is the best way to extract a specific property from an object?