Creating a custom function to compute object attributes for an object that may contain optional properties

Question

Creating a custom function to compute object attributes for an object that may contain optional properties

I have a dataset containing information for a variety of dog breeds, and I am looking to compute the average weight of certain breeds. Each record in the dataset represents a different breed of dog along with their respective weights. The data includes five core breeds that are always present and two additional breeds that may or may not appear:

// TypeScript

type dogSample = {
    // 5 core breeds that always appear
    bulldog: number,
    poodle: number,
    pug: number,
    chihuahua: number,
    boxer: number,
    // 2 additional that sometimes appear
    dalmatian?: number,
    rottweiler?: number, // rottweiler only appears if dalmatian does
    // other irrelevant properties
    foo: string,
    bar: boolean,
    baz: number
    // and possibly many other unrelated properties
}

The objective is to calculate the average weight of all the dogs based on these specific properties. To achieve this, three functions have been created:

const calcMeanCoreFive = (obj: dogSample) =>
  (obj.bulldog + obj.poodle + obj.pug + obj.chihuahua + obj.boxer) / 5;

const calcMeanCoreFivePlusDalmatian = (obj: Required<dogSample>) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian) /
  6;

const calcMeanCoreFivePlusDalmatianPlusRottw = (obj: Required<dogSample>) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian +
    obj.rottweiler) /
  7;

Finally, there is a master function that encapsulates all three versions:

const calcMeanDogSample = (obj: dogSample, nBreeds: 5 | 6 | 7) =>
  nBreeds === 5
    ? calcMeanCoreFive(obj)
    : nBreeds === 6
    ? calcMeanCoreFivePlusDalmatian(obj)
//                                   ^
    : calcMeanCoreFivePlusDalmatianPlusRottw(obj);
//                                            ^
// argument of type 'dogSample' is not assignable to parameter of type 'Required<dogSample>'

Attempted Solution

To address the issue, an attempt was made to modify the typing within calcMeanDogSample() using Required<dogSample>:

const calcMeanDogSample2 = (obj: Required<dogSample>, nBreeds: 5 | 6 | 7) =>
  nBreeds === 5
    ? calcMeanCoreFive(obj)
    : nBreeds === 6
    ? calcMeanCoreFivePlusDalmatian(obj)
    : calcMeanCoreFivePlusDalmatianPlusRottw(obj);

This adjustment resolved the error within the function's definition but caused issues when attempting to call calcMeanDogSample2() with an object of type dogSample:

const someDogSample = {
  bulldog: 24,
  poodle: 33,
  pug: 21.3,
  chihuahua: 7,
  boxer: 24,
  dalmatian: 20,
  foo: "abcd",
  bar: false,
  baz: 123,
} as dogSample;

calcMeanDogSample2(someDogSample, 6);
//                     ^
// Argument of type 'dogSample' is not assignable to parameter of type // 'Required<dogSample>'.
//   Types of property 'dalmatian' are incompatible.
//     Type 'number | undefined' is not assignable to type 'number'.
//       Type 'undefined' is not assignable to type 'number'.ts(2345)

Question

Is there an alternative way to define the typing for calcMeanDogSample() to resolve this issue?

Code can be tested on the TS playground

typescript function option-type required-field

Answer 1

Answer №1

Instead of simply adapting your current algorithm to meet TypeScript's type safety standards, I recommend refactoring the approach to achieve a more universal solution:

const calculateMeanDogSample = (obj: DogSample) => {
  let sum = obj.bulldog + obj.poodle + obj.pug + obj.chihuahua + obj.boxer;
  let nBreeds = 5;
  for (let v of [obj.dalmatian, obj.rottweiler]) {
    if (typeof v === "number") {
      sum += v;
      nBreeds++;
    }
  }
  return sum / nBreeds;
}

To calculate the mean value, we divide the total sum of the relevant properties by the count of breeds (nBreeds). The five primary breed properties are mandatory, while the optional dalmatian and rottweiler ones contribute only if present.

You can verify this behavior with an example like this:

const someDogSample = {
  bulldog: 24,
  poodle: 33,
  pug: 21.3,
  chihuahua: 7,
  boxer: 24,
  dalmatian: 20,
  foo: "abcd",
  bar: false,
  baz: 123,
};

console.log(calculateMeanDogSample(someDogSample)); // 21.55

An even more streamlined refactoring option involves converting keys to potentially defined numbers, removing undefined values, and computing their mean:

const mean = (x: number[]) => x.reduce((a, v) => a + v, 0) / x.length;
const calculateMeanDogSample2 = (obj: DogSample) => mean(
  (["bulldog", "poodle", "pug", "chihuahua", "boxer", "dalmatian", "rottweiler"] as const)
    .map(k => obj[k])
    .filter((v): v is number => typeof v === "number")
);
console.log(calculateMeanDogSample2(someDogSample)); // 21.55

Playground link for code testing

Answer 2

Instead of simply adapting your current algorithm to meet TypeScript's type safety standards, I recommend refactoring the approach to achieve a more universal solution:

const calculateMeanDogSample = (obj: DogSample) => {
  let sum = obj.bulldog + obj.poodle + obj.pug + obj.chihuahua + obj.boxer;
  let nBreeds = 5;
  for (let v of [obj.dalmatian, obj.rottweiler]) {
    if (typeof v === "number") {
      sum += v;
      nBreeds++;
    }
  }
  return sum / nBreeds;
}

To calculate the mean value, we divide the total sum of the relevant properties by the count of breeds (nBreeds). The five primary breed properties are mandatory, while the optional dalmatian and rottweiler ones contribute only if present.

You can verify this behavior with an example like this:

const someDogSample = {
  bulldog: 24,
  poodle: 33,
  pug: 21.3,
  chihuahua: 7,
  boxer: 24,
  dalmatian: 20,
  foo: "abcd",
  bar: false,
  baz: 123,
};

console.log(calculateMeanDogSample(someDogSample)); // 21.55

An even more streamlined refactoring option involves converting keys to potentially defined numbers, removing undefined values, and computing their mean:

const mean = (x: number[]) => x.reduce((a, v) => a + v, 0) / x.length;
const calculateMeanDogSample2 = (obj: DogSample) => mean(
  (["bulldog", "poodle", "pug", "chihuahua", "boxer", "dalmatian", "rottweiler"] as const)
    .map(k => obj[k])
    .filter((v): v is number => typeof v === "number")
);
console.log(calculateMeanDogSample2(someDogSample)); // 21.55

Playground link for code testing

Answer 3

Answer №2

The issue arises from the lack of connection between the nBreeds and the input obj within the type system.

Fortunately, TypeScript provides a solution by allowing you to notify the compiler that these properties do indeed exist in your data if they can satisfy a conditional check: this is known as a user-defined type guard with a return type referred to as a type predicate. Below is an example demonstrating its usage with your data, eliminating the need for the nBreeds argument!

You may also find the utility types Required<Type> and Pick<Type, Keys> useful.

type DogSample = {
  bulldog: number;
  poodle: number;
  pug: number;
  chihuahua: number;
  boxer: number;
  dalmatian?: number;
  rottweiler?: number;
  // other irrelevant properties
  foo: string;
  bar: boolean;
  baz: number;
};

// This is called a user-defined type guard (and the return type is called a type predicate)
function sampleIncludesBreed <T extends DogSample, K extends keyof DogSample>(
  obj: T,
  breed: K,
): obj is T & Required<Pick<DogSample, K>> {
  return typeof (obj as Required<DogSample>)[breed] === 'number';
}

const calcMeanCoreFive = (obj: DogSample) =>
  (obj.bulldog + obj.poodle + obj.pug + obj.chihuahua + obj.boxer) / 5;

const calcMeanCoreFivePlusDalmatian = (obj: (
  DogSample
  & Required<Pick<DogSample, 'dalmatian'>>
)) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian) /
  6;

const calcMeanCoreFivePlusDalmatianPlusRottw = (obj: (
  DogSample
  & Required<Pick<DogSample, 'dalmatian'>>
  & Required<Pick<DogSample, 'rottweiler'>>
)) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian +
    obj.rottweiler) /
  7;

const calcMeanDogSample = (obj: DogSample) => {
  if (sampleIncludesBreed(obj, 'dalmatian')) {
    return sampleIncludesBreed(obj, 'rottweiler')
      ? calcMeanCoreFivePlusDalmatianPlusRottw(obj) /*
                                               ^^^
      This type is: (parameter) obj: DogSample & Required<Pick<DogSample, "dalmatian">> & Required<Pick<DogSample, "rottweiler">> */
      : calcMeanCoreFivePlusDalmatian(obj); /*
                                      ^^^
      This type is: (parameter) obj: DogSample & Required<Pick<DogSample, "dalmatian">> */
  }
  return calcMeanCoreFive(obj); /*
                          ^^^
  This type is: (parameter) obj: DogSample */
};

const someDogSample = {
  bulldog: 24,
  poodle: 33,
  pug: 21.3,
  chihuahua: 7,
  boxer: 24,
  dalmatian: 20,
  foo: "abcd",
  bar: false,
  baz: 123,
} as DogSample;

calcMeanDogSample(someDogSample);

On a different note unrelated to your query but centered around dogs and data: You might enjoy exploring the API provided at dog.ceo.

Answer 4

The issue arises from the lack of connection between the nBreeds and the input obj within the type system.

Fortunately, TypeScript provides a solution by allowing you to notify the compiler that these properties do indeed exist in your data if they can satisfy a conditional check: this is known as a user-defined type guard with a return type referred to as a type predicate. Below is an example demonstrating its usage with your data, eliminating the need for the nBreeds argument!

You may also find the utility types Required<Type> and Pick<Type, Keys> useful.

type DogSample = {
  bulldog: number;
  poodle: number;
  pug: number;
  chihuahua: number;
  boxer: number;
  dalmatian?: number;
  rottweiler?: number;
  // other irrelevant properties
  foo: string;
  bar: boolean;
  baz: number;
};

// This is called a user-defined type guard (and the return type is called a type predicate)
function sampleIncludesBreed <T extends DogSample, K extends keyof DogSample>(
  obj: T,
  breed: K,
): obj is T & Required<Pick<DogSample, K>> {
  return typeof (obj as Required<DogSample>)[breed] === 'number';
}

const calcMeanCoreFive = (obj: DogSample) =>
  (obj.bulldog + obj.poodle + obj.pug + obj.chihuahua + obj.boxer) / 5;

const calcMeanCoreFivePlusDalmatian = (obj: (
  DogSample
  & Required<Pick<DogSample, 'dalmatian'>>
)) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian) /
  6;

const calcMeanCoreFivePlusDalmatianPlusRottw = (obj: (
  DogSample
  & Required<Pick<DogSample, 'dalmatian'>>
  & Required<Pick<DogSample, 'rottweiler'>>
)) =>
  (obj.bulldog +
    obj.poodle +
    obj.pug +
    obj.chihuahua +
    obj.boxer +
    obj.dalmatian +
    obj.rottweiler) /
  7;

const calcMeanDogSample = (obj: DogSample) => {
  if (sampleIncludesBreed(obj, 'dalmatian')) {
    return sampleIncludesBreed(obj, 'rottweiler')
      ? calcMeanCoreFivePlusDalmatianPlusRottw(obj) /*
                                               ^^^
      This type is: (parameter) obj: DogSample & Required<Pick<DogSample, "dalmatian">> & Required<Pick<DogSample, "rottweiler">> */
      : calcMeanCoreFivePlusDalmatian(obj); /*
                                      ^^^
      This type is: (parameter) obj: DogSample & Required<Pick<DogSample, "dalmatian">> */
  }
  return calcMeanCoreFive(obj); /*
                          ^^^
  This type is: (parameter) obj: DogSample */
};

const someDogSample = {
  bulldog: 24,
  poodle: 33,
  pug: 21.3,
  chihuahua: 7,
  boxer: 24,
  dalmatian: 20,
  foo: "abcd",
  bar: false,
  baz: 123,
} as DogSample;

calcMeanDogSample(someDogSample);

On a different note unrelated to your query but centered around dogs and data: You might enjoy exploring the API provided at dog.ceo.

Creating a custom function to compute object attributes for an object that may contain optional properties

Answer №1

Answer №2

Similar questions

Ng2-table experiencing compatibility issues with the most recent version of Angular2

Typescript input event

What is the best way to implement debouncing for an editor value that is controlled by the parent component?

Sending variables to imported files using Typescript

Exploring the variance between inlineSourceMap and inlineSources within the TypeScript compiler options

How can I retrieve the SID received in a different tab using MSAL.js?

Utilizing moment.js in conjunction with typescript and the module setting of "amd"

Issue with calling jqPlot function in jQuery causing malfunction

Tips for closing a Modal Dialog in Vue3 using a different component, such as PimeVue

In order to load an ES module, specify the "type" as "module" in the package.json file or utilize the .mjs extension

What methods are typically used for testing functions that return HTTP observables?

What is the best way to assign table rows to various interfaces in typescript?

Ensuring Input Validity in Angular4 and Symfony3

Replace deprecated TypedUseSelectorHook with createSelectorHook for improved functionality

Unable to link to 'amount' because it is not a recognized attribute of 'ng-wrapper'

Modifying the name of a key in ng-multiselect-dropdown

Implementation of a nested interface using a generic and union types

Utilizing Angular to send intricate objects through HTTP POST requests

Tips for bundling TypeScript Angular with internal modules using SystemJS

What is the proper way to define a new property for an object within an npm package?