Typescript convert const array of objects to typed index lookup object

Question

const cars = [
  { id: 'id1', name: 'ford' },
  { id: 'id2', name: 'audi' },
  { id: 'id3', name: 'bmw' },
] as const;
type CarId = typeof cars[number]['id'];

const carIndexes = cars.reduce((acc, car, i) => ({ ...acc, [car.id]: i }), {});
console.log(carIndexes);

This code works fine, and prints out

{ id1: 0, id2: 1, id3: 2 }

carIndexes gives me a map that allows me to look up the index of each car by their id, but I would like carIndexes to be strongly typed. When I change its type signature to { [K in CarId]: number }:

const carIndexes: { [K in CarId]: number } = cars.reduce((acc, car, i) => ({ ...acc, [car.id]: i }), {});

I get the error:

error TS2739: Type '{}' is missing the following properties from type '{ id1: number; id2: number; id3: number; }': id1, id2, id3

I would like to use a plain object, rather than a Map, because an object with type { [K in CarId]: number } guarantees that looking up the index can't fail for any CarId.

HTN · Accepted Answer · 2021-02-21 10:19:43Z

1

AFAIK, without casting manually to {[K in CarId]: number}, there is no way for typescript to detect that cars.reduce((acc, car, i) => ({ ...acc, [car.id]: i }), {}) (or other ways) will return an object with the whole CardId as index.

answered Feb 21, 2021 at 10:19

HTN

3,6121 gold badge10 silver badges18 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Roberto Zvjerković · Accepted Answer · 2021-02-21 10:23:35Z

0

I think you will have to explicitly type the reduce accumulator value:

const cars = [
    { id: 'id1', name: 'ford' },
    { id: 'id2', name: 'audi' },
    { id: 'id3', name: 'bmw' },
] as const;
type CarId = typeof cars[number]['id'];

const carIndexes = cars
    .reduce(
        (acc, car, i) => (
            { ...acc, [car.id]: i }
        ),
        {} as { [K in CarId]: number }
    );
console.log(carIndexes);

answered Feb 21, 2021 at 10:23

Roberto Zvjerković

10.2k4 gold badges31 silver badges49 bronze badges

Comments

matej bobaly · Accepted Answer · 2021-02-26 23:19:27Z

The best attempt at type safety in this case might be to use corresponding Partial type:

let carIndexes: Partial<{ [key in CarId]: number }> = {};
for (let i = 0; i < cars.length; ++i) {
  carIndexes[cars[i].id] = i;
  
  // note that following line would not compile due to TS2339: Property 'OTHER_PROPERTY' does not 
  // exist on type 'Partial<{ id1: number; id2: number; id3: number; }>'
  // carIndexes.OTHER_PROPERTY = 0;
}

The use of reduce() function proposed by some other answers and involving an explicit cast, in fact, ensures almost no static type safety. For instance, if I make a typo like following, the code still compiles:

const carIndexes: { [K in CarId]: number } = cars.reduce(
  (acc, car, i) => ({ 
    ...acc,
    //following line should not compile as there is no property "id" on typeof carIndexes
    id: i 
  }),
  {} as {[K in CarId]: number}
);

Collectives™ on Stack Overflow

Typescript convert const array of objects to typed index lookup object

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related