How to determine the type of object with possible and string and numeric indices in typescript?

Question

My function can work with array and objects. Objects have keys with string-type and array have keys with numeric-type. Also there can be object without keys.

I determine two interfaces and one type:

interface IObjectStringKey {
  [key: string]: any
}
interface IObjectNumberKey {
  [key: number]: any
}
// object with key-string, key-number or without key
type IObjectAnyKey = IObjectNumberKey | IObjectStringKey | {};

My function get argument - array of this type and I want to iterate through every key of every object.

function myFunction( ...sources: IObjectAnyKey[]) {
        const values = [];
for (let i = 0; i < sources.length; i++) {
    const source: IObjectAnyKey = sources[i];
        for (let key in source) {
            const val = source[key];
        }
    }
}

You can see error in playground: typescript.org/myTask (you need to enable 'noImplicitAny' in Options)

Error is "Element implicitly has an 'any' type because type 'IObjectAnyKey' has no index signature". How can I solve this problem? I need to know how to define type with different index type. Or, maybe, there is some other solve.

@TanDuong you need to click on 'Options' and check "noImplicitAny' — Alexander Knyazev

jcalz jcalz · Accepted Answer · 2018-04-06T14:54:22

IObjectAnyKey is essentially equivalent to the empty type {}. The type {} matches pretty much every value (except for null and undefined), so the union of {} with anything else (except a possibly null or undefined type) is also {}. TypeScript therefore doesn't know what keys are in source (keyof IObjectAnyKey is equivalent to never, the empty set) so it balks at indexing into it.

Your IObjectStringKey is only slightly narrower than {}. Since TypeScript introduced implicit index signatures, any type with known literal keys can be widened to a type with an index signature whose value type is the union of all value types. For example:

const literalKeys = {a: 'hey', b: 2, c: true};
const indexSignature: {[k: string]: string | number | boolean} = literalKeys;

The above assignment works because literalKeys is compatible with the index signature. Therefore, if you make myFunction() accept an array of IObjectStringKey, it shouldn't prevent you from calling it:

function myFunction(...sources: IObjectStringKey[]) {
  const values = [];
  for (let i = 0; i < sources.length; i++) {
    const source = sources[i];
    for (let key in source) {
      const val = source[key]; // no error
    }
  }
}
myFunction({},{a: 'hey'},{b: 2}); // still works

If you insist on using (the relatively useless) IObjectAnyKey, you can always just do a type assertion to make the error go away:

function myFunction(...sources: IObjectAnyKey[]) {
  const values = [];
  for (let i = 0; i < sources.length; i++) {
    const source = sources[i];
    for (let key in source) {
      const val = (source as any)[key]; // explicitly "any"
    }
  }
}

Hope that helps. Good luck.

How to determine the type of object with possible and string and numeric indices in typescript?

2 Answers