How do I prevent the error Index signature of object type implicitly has an any type when compiling typescript with noImplicitAny flag enabled

Question

I always compile Typescript with the flag --noImplicitAny  This makes sense as I want my type checking to be as tight as possible   My problem is that with the following code I get the error Index signature of object type implicitly has an  any  type   interface ISomeObject       firstKey    string      secondKey   string      thirdKey    string     let someObject  ISomeObject         firstKey     firstValue       secondKey    secondValue       thirdKey     thirdValue      let key  string    secondKey    let secondValue  string   someObject key     Important to note is that the idea is that the key variable comes  from somewhere else in the application and can be any of the keys in the object   I ve tried explicitly casting the type by   let secondValue  string    lt string gt someObject key     Or is my scenario just not possible with --noImplicitAny

User · Answer

TypeScript 2 1 introduced elegant way to handle this issue   const key   keyof ISomeObject     secondKey   const secondValue  string   someObject key     We can access all object property names during compilation phase by keyof keyword  see changelog    You only need to replace string variable type with keyof ISomeObject  Now compiler knows key variable is allowed to contain only property names from ISomeObject   Full example   interface ISomeObject       firstKey    string      secondKey   string      thirdKey    number     const someObject  ISomeObject         firstKey     firstValue       secondKey    secondValue       thirdKey    3     const key   keyof ISomeObject     secondKey   const secondValue  string   someObject key       You can mix types in interface  keyof will know which types you refer to  const keyNumber   keyof ISomeObject     thirdKey   const numberValue  number   someObject keyNumber     Live code on typescriptlang org  set noImplicitAny option   Further reading with more keyof usages

User · Answer

Adding an index signature will let TypeScript know what the type should be   In your case that would be  key  string   string   interface ISomeObject       firstKey       string      secondKey      string      thirdKey       string       key  string   string      However  this also enforces all of the property types to match the index signature  Since all of the properties are a string it works      While index signatures are a powerful way to describe the array and  dictionary  pattern  they also enforce that all properties match their return type    Edit   If the types don t match  a union type can be used  key  string   string IOtherObject   With union types  it s better if you let TypeScript infer the type instead of defining it      Type of  secondValue  is  string IOtherObject  let secondValue   someObject key      Type of  foo  is  string  let foo   secondValue         Although that can get a little messy if you have a lot of different types in the index signatures  The alternative to that is to use any in the signature   key  string   any  Then you would need to cast the types like you did above

User · Answer

There is no need to use an ObjectIndexer lt T gt   or change the interface of the original object  like suggested in most of the other answers   You can simply narrow the options for key to the ones that are of type string using the following  type KeysMatching lt T  V gt       K in keyof T   T K  extends V   K   never   keyof T    This great solution comes from an answer to a related question here  Like that you narrow to keys inside T that hold V values  So in your case to to limit to string you would do  type KeysMatching lt ISomeObject  string gt    In your example  interface ISomeObject       firstKey    string      secondKey   string      thirdKey    string     let someObject  ISomeObject         firstKey     firstValue       secondKey    secondValue       thirdKey     thirdValue      let key  KeysMatching lt SomeObject  string gt     secondKey       secondValue narrowed to string     let secondValue   someObject key    The advantage is that your ISomeObject could now even hold mixed types  and you can anyway narrow the key to string values only  keys of other value types will be considered invalid  To illustrate  interface ISomeObject       firstKey    string      secondKey   string      thirdKey    string      fourthKey   boolean     let someObject  ISomeObject         firstKey     firstValue       secondKey    secondValue       thirdKey     thirdValue      fourthKey    true         Type   quot fourthKey quot   is not assignable to type  KeysMatching lt ISomeObject  string gt    2322  let otherKey  KeysMatching lt SomeOtherObject  string gt     fourthKey    let fourthValue   someOtherObject otherKey    You find this example in this playground

User · Answer

Similar to  Piotr Lewandowski s answer  but within a forEach   const config  MyConfig             Object keys config     forEach  key  keyof MyConfig    gt        if  config key

User · Answer

No indexer  Then make your own  I ve globally defined this as an easy way to define an object signature  T can be any if needed  type Indexer lt T gt        key  string    T     I just add indexer as a class member  indexer   this as unknown as Indexer lt Fruit gt    So I end up with this  constructor private breakpointResponsiveService  FeatureBoxBreakpointResponsiveService        apple  Fruit lt string gt   pear  Fruit lt string gt       just a reference to  this  at runtime indexer   this as unknown as Indexer lt Fruit gt    something          this indexer  apple               typed as Fruit  Benefit of doing this is that you get the proper type back - many solutions that use  lt any gt  will lose the typing for you  Remember this doesn t perform any runtime verification  You ll still need to check if something exists if you don t know for sure it exists  If you want to be overly cautious  and you re using strict you can do this to reveal all the places you may need to do an explicit undefined check  type OptionalIndexed lt T gt        key  string    T   undefined     I don t usually find this necessary since if I have as a string property from somewhere I usually know that it s valid  I ve found this method especially useful if I have a lot of code that needs to access the indexer  and the typing can be changed in just one place  Note  I m using strict mode  and the unknown is definitely necessary  The compiled code will just be indexer   this  so it s very similar to when typescript creates  this   this for you

User · Answer

The simplest solution that I could find using Typescript 3 1 in 3 steps is   1  Make interface  interface IOriginal       original     key  string   any       2  Make a typed copy  let copy  IOriginal    original as any  key     3  Use anywhere  JSX included    lt input customProp  copy    gt

User · Answer

Declare type which its key is string and value can be any then declare the object with this type and the lint won t show up  type MyType     key  string   any     So your code will be  type ISomeType     key  string   any        let someObject  ISomeType             firstKey     firstValue           secondKey    secondValue           thirdKey     thirdValue              let key  string    secondKey        let secondValue  string   someObject key

User · Answer

Declare the object like this   export interface Thread       id number      messageIds  number        participants             key number   number

User · Answer

The  keyof  solution mentioned above works  But if the variable is used only once e g looping through an object etc  you can also typecast it   for  const key in someObject        sampleObject key    someObject key as keyof ISomeObject

User · Answer

The following tsconfig setting will allow you to ignore these errors - set it to true      suppressImplicitAnyIndexErrors      Suppress noImplicitAny errors for indexing objects lacking index signatures

User · Answer

Another way to avoid the error is to use the cast like this   let secondValue  string     lt any gt someObject  key    Note the parenthesis   The only problem is that this isn t type-safe anymore  as you are casting to any  But you can always cast back to the correct type   ps  I m using typescript 1 7  not sure about previous versions

User · Answer

At today better solution is to declare types  Like   enum SomeObjectKeys       firstKey    firstKey       secondKey    secondKey       thirdKey    thirdKey      let someObject  Record lt SomeObjectKeys  string gt          firstKey     firstValue       secondKey    secondValue       thirdKey     thirdValue       let key  SomeObjectKeys    secondKey    let secondValue  string   someObject key

User · Answer

use keyof typeof  const cat         name   tuntun     const key  string    name    cat key as keyof typeof cat

User · Answer

Create an interface to define the  indexer  interface Then create your object with that index  Note  this will still have same issues other answers have described with respect to enforcing the type of each item  - but that s often exactly what you want  You can make the generic type parameter whatever you need   ObjectIndexer lt  Dog   Cat gt     this should be global somewhere  or you may already be     using a library that provides such a type export interface ObjectIndexer lt T gt       id  string   T     interface ISomeObject extends ObjectIndexer lt string gt        firstKey    string      secondKey   string      thirdKey    string     let someObject  ISomeObject         firstKey     firstValue       secondKey    secondValue       thirdKey     thirdValue      let key  string    secondKey    let secondValue  string   someObject key    Typescript Playground  You can even use this in a generic constraint when defining a generic type  export class SmartFormGroup lt T extends IndexableObject lt any gt  gt  extends FormGroup Then T inside the class can be indexed  -

User · Answer

I had two interfaces  First was child of other  I did following   Added index signature in parent interface  Used appropriate type using as keyword   Complete code is as below  Child Interface  interface UVAmount     amount  number    price  number    quantity  number      Parent Interface  interface UVItem       This is index signature which compiler is complaining about     Here we are mentioning key will string and value will any of the types mentioned     key  string    UVAmount   string   number   object     name  string    initial  UVAmount    rating  number    others  object      React Component  let valueType    initial    function getTotal item  UVItem       as keyword is the dealbreaker     If you don t use it  it will take string type by default and show errors    let itemValue   item valueType  as UVAmount     return itemValue price   itemValue quantity

[typescript] How do I prevent the error "Index signature of object type implicitly has an 'any' type" when compiling typescript with noImplicitAny flag enabled?

Examples related to typescript