You are unable to use T[keyof T] for indexing an empty object

Question

You are unable to use T[keyof T] for indexing an empty object

I have been working on implementing a highly efficient group by algorithm based on the insights from this Stack Overflow discussion and attempting to define the types. However, I encountered the following error:

T[keyof T] cannot be used to index {}

Below is my approach:

 static groupBy<T>(xs: T[], key: keyof T) {
        return xs.reduce((rv, x)=> {
            (rv[x[key]] = rv[x[key]] || []).push(x);
            return rv;
        }, {});
    };

javascript typescript

Answer 1

Answer №1

If you wish to avoid using any, it is important to accurately define types to specify that the reducer can merge data together effectively.

function groupBy<T extends {[LK in K]: keyof any}, K extends keyof T>(items: T[], key: K) {
  return items.reduce<{[LK2 in T[K]]?: Array<T>};>((result, item) => {
            (result[item[key]] = result[item[key]] || [])?.push(item);
            return result;
        }, {});
};

const output = groupBy([{ test: 'key' }], 'test');

output.key?.length; // 1

T represents an object where the type of the specified key can be used as a reference (for result).

When dealing with reducers - begin with an empty object - it is necessary to clarify that the outcome will be an object wherein the key's value is an array containing entities from the initial set {[LK2 in T[K]]?: Array<T>}

Answer 2

If you wish to avoid using any, it is important to accurately define types to specify that the reducer can merge data together effectively.

function groupBy<T extends {[LK in K]: keyof any}, K extends keyof T>(items: T[], key: K) {
  return items.reduce<{[LK2 in T[K]]?: Array<T>};>((result, item) => {
            (result[item[key]] = result[item[key]] || [])?.push(item);
            return result;
        }, {});
};

const output = groupBy([{ test: 'key' }], 'test');

output.key?.length; // 1

T represents an object where the type of the specified key can be used as a reference (for result).

When dealing with reducers - begin with an empty object - it is necessary to clarify that the outcome will be an object wherein the key's value is an array containing entities from the initial set {[LK2 in T[K]]?: Array<T>}

Answer 3

Answer №2

rv: will be any

class A {
  static groupBy<T>(xs: T[], key: keyof T) {
    return xs.reduce((rv: any, x) => {
      (rv[x[key]] = rv[x[key]] || []).push(x);
      return rv;
    }, {});
  }
}

To utilize this function:

interface Person {
  name: string;
  age: number;
  salary: number;
}
const data: Person[] = [
  {name:"deepak", age: 30, salary: 2000},
  {name:"deepak1", age: 32, salary: 1000},
  {name:"deepak", age: 29, salary: 3000}
]
class A {
  static groupBy<T>(xs: T[], key: keyof T) {
    return xs.reduce((rv: any, x) => {
      (rv[x[key]] = rv[x[key]] || []).push(x);
      return rv;
    }, {});
  }
}
console.log(A.groupBy(data, "name"))

Explanation from Lodash library:

groupBy(
            predicate?: Lodash.ListIterator<T, boolean> | Lodash.DictionaryIterator<T, boolean> | string,
            thisArg?: any,
        ): Lodash.Dictionary<T[]>;
        groupBy<R extends {}>(predicate?: R): Lodash.Dictionary<T[]>;

The grouped result is stored in an object where keys are strings or numbers, following a more generic solution.

interface Any<T> {
  [key: string]: T[];
}
interface SMap<T> {
  [key: string]: T;
}
class A {
  static groupBy<T extends SMap<string>>(xs: T[], key: keyof T) {
    return xs.reduce((rv: Any<T>, x) => {
      if (!rv[x[key]]) {
        rv[x[key]] = [];
      }
      rv[x[key]].push(x);
      return rv;
    }, {});
  }
}

Answer 4

rv: will be any

class A {
  static groupBy<T>(xs: T[], key: keyof T) {
    return xs.reduce((rv: any, x) => {
      (rv[x[key]] = rv[x[key]] || []).push(x);
      return rv;
    }, {});
  }
}

To utilize this function:

interface Person {
  name: string;
  age: number;
  salary: number;
}
const data: Person[] = [
  {name:"deepak", age: 30, salary: 2000},
  {name:"deepak1", age: 32, salary: 1000},
  {name:"deepak", age: 29, salary: 3000}
]
class A {
  static groupBy<T>(xs: T[], key: keyof T) {
    return xs.reduce((rv: any, x) => {
      (rv[x[key]] = rv[x[key]] || []).push(x);
      return rv;
    }, {});
  }
}
console.log(A.groupBy(data, "name"))

Explanation from Lodash library:

groupBy(
            predicate?: Lodash.ListIterator<T, boolean> | Lodash.DictionaryIterator<T, boolean> | string,
            thisArg?: any,
        ): Lodash.Dictionary<T[]>;
        groupBy<R extends {}>(predicate?: R): Lodash.Dictionary<T[]>;

The grouped result is stored in an object where keys are strings or numbers, following a more generic solution.

interface Any<T> {
  [key: string]: T[];
}
interface SMap<T> {
  [key: string]: T;
}
class A {
  static groupBy<T extends SMap<string>>(xs: T[], key: keyof T) {
    return xs.reduce((rv: Any<T>, x) => {
      if (!rv[x[key]]) {
        rv[x[key]] = [];
      }
      rv[x[key]].push(x);
      return rv;
    }, {});
  }
}

Answer 5

Answer №3

This revised version is longer than the original one. It avoids using "any" or "as" casting, making it suitable for various data types as group keys, including unknown ones.

export function groupBy<T>(xs: T[], key: keyof T): Map<unknown, T[]> {
  return xs.reduce((rv: Map<unknown, T[]>, entity: T) => {
    const value = entity[key];
    if (rv.has(value)) {
      rv.get(value)?.push(entity)
    } else {
      rv.set(value, [entity]);
    }
    return rv;
  }, new Map());
};

Here's an example of how you can use this function:

const badgesByTypes = groupBy(currentState.badges, 'type');
for (const [key, values] of badgesByTypes.entries()) {
}

Answer 6

This revised version is longer than the original one. It avoids using "any" or "as" casting, making it suitable for various data types as group keys, including unknown ones.

export function groupBy<T>(xs: T[], key: keyof T): Map<unknown, T[]> {
  return xs.reduce((rv: Map<unknown, T[]>, entity: T) => {
    const value = entity[key];
    if (rv.has(value)) {
      rv.get(value)?.push(entity)
    } else {
      rv.set(value, [entity]);
    }
    return rv;
  }, new Map());
};

Here's an example of how you can use this function:

const badgesByTypes = groupBy(currentState.badges, 'type');
for (const [key, values] of badgesByTypes.entries()) {
}

You are unable to use T[keyof T] for indexing an empty object

Answer №1

Answer №2

Answer №3

Similar questions

Ensure that the button becomes clickable only after text has been inputted into the field

Stop the Decimal in MUI TextField

Angular form not sending data when using $http.post

How can I extract a specific value from an array in a JSON object by sorting it?

Python Selenium: Cannot Click on Element - Button Tag Not Located

Develop JavaScript code to handle multiple JSON objects

retrieving information from a data attribute

develop the following application and execute the npm run dev command, but encounter the error message: "Command failed with exit code 1."

execute bower install for the specified bower.json file

What is the syntax for accessing a nested object within the .find method?

Modifying the CSS class of an element does not produce the desired effect after altering its styles using JavaScript

Is there a restriction on the number of routes available from Google Maps Directions Service?

IE compatibility mode causing ckeditor dropdown to be hidden

jQuery's find method returns a null value

Utilizing AJAX to submit a combination of text fields and files in an HTML form

How can one change the color of movable tiles to red while keeping the rest of the tiles in their original state in a puzzle game?

What is the best way to confirm the invocation of super in sinonjs?

Running the Luis Recogniser on ChoicePrompt is a straightforward process that can be easily

Create seamless communication between Angular application and React build

Setting up Vue CLI 4 for optimal development: Integrating ESLint, Prettier, Airbnb rules, TypeScript, and Vetur