Interface type check with Typescript

Question

This question is the direct analogon to Class type check with TypeScript  I need to find out at runtime if a variable of type any implements an interface  Here s my code   interface A      member string     var a any  member  foobar     if a instanceof A  alert a member     If you enter this code in the typescript playground  the last line will be marked as an error   The name A does not exist in the current scope   But that isn t true  the name does exist in the current scope  I can even change the variable declaration to var a A  member  foobar    without complaints from the editor  After browsing the web and finding the other question on SO I changed the interface to a class but then I can t use object literals to create instances   I wondered how the type A could vanish like that but a look at the generated javascript explains the problem   var a         member   foobar     if a instanceof A        alert a member       There is no representation of A as an interface  therefore no runtime type checks are possible   I understand that javascript as a dynamic language has no concept of interfaces  Is there any way to type check for interfaces    The typescript playground s autocompletion reveals that typescript even offers a method implements  How can I use it

User · Accepted Answer

You can achieve what you want without the instanceof keyword as you can write custom type guards now:

interface A{
    member:string;
}

function instanceOfA(object: any): object is A {
    return 'member' in object;
}

var a:any={member:"foobar"};

if (instanceOfA(a)) {
    alert(a.member);
}

Lots of Members

If you need to check a lot of members to determine whether an object matches your type, you could instead add a discriminator. The below is the most basic example, and requires you to manage your own discriminators... you'd need to get deeper into the patterns to ensure you avoid duplicate discriminators.

interface A{
    discriminator: 'I-AM-A';
    member:string;
}

function instanceOfA(object: any): object is A {
    return object.discriminator === 'I-AM-A';
}

var a:any = {discriminator: 'I-AM-A', member:"foobar"};

if (instanceOfA(a)) {
    alert(a.member);
}

User · Answer

export interface ConfSteps       group  string      key  string      steps  string        private verify    void       const obj             group    group          key    key          steps              stepsPlus                   if  this implementsObject lt ConfSteps gt  obj    group    key    steps             console log  Implements ConfSteps    obj                 private objProperties  Array lt string gt         private implementsObject lt T gt  obj  any  keys   keyof T      boolean       JSON parse JSON stringify obj    key  value    gt          this objProperties push key               for  const key of keys          if   this objProperties includes key toString               return false                    this objProperties   null      return true

User · Answer

In TypeScript 1 6  user-defined type guard will do the job   interface Foo       fooProperty  string     interface Bar       barProperty  string     function isFoo object  any   object is Foo       return  fooProperty  in object     let object  Foo   Bar   if  isFoo object             object  has type  Foo       object fooProperty    else           object  has type  Bar       object barProperty      And just as Joe Yang mentioned  since TypeScript 2 0  you can even take the advantage of tagged union type   interface Foo       type   foo       fooProperty  string     interface Bar       type   bar       barProperty  number     let object  Foo   Bar      You will see errors if  strictNullChecks  is enabled  if  object type      foo            object has type  Foo       object fooProperty    else          object has type  Bar       object barProperty      And it works with switch too

User · Answer

You can validate a TypeScript type at runtime using ts-validate-type  like so  does require a Babel plugin though    const user   validateType lt   name  string   gt  data

User · Answer

Type guards in Typescript  TS has type guards for this purpose  They define it in the following manner   Some expression that performs a runtime check that guarantees the type in some scope   This basically means that the TS compiler can narrow down the type to a more specific type when it has sufficient information  For example  function foo  arg  number   string        if  typeof arg      number                fine  type number has toFixed method         arg toFixed         else              Property  toFixed  does not exist on type  string   Did you mean  fixed           arg toFixed              TSC can infer that the type is string because             the possibility of type number is eliminated at the if statement          To come back to your question  we can also apply this concept of type guards to objects in order to determine their type  To define a type guard for objects  we need to define a function whose return type is a type predicate  For example  interface Dog       bark       gt  void        The function isDog is a user defined type guard    the return type   pet is Dog  is a type predicate      it determines whether the object is a Dog function isDog pet  object   pet is Dog     return  pet as Dog  bark     undefined     const dog  any    bark       gt   console log  woof       if  isDog dog            TS now knows that objects within this if statement are always type Dog        This is because the type guard isDog narrowed down the type to Dog     dog bark

User · Answer

How about User-Defined Type Guards  https   www typescriptlang org docs handbook advanced-types html  interface Bird       fly        layEggs       interface Fish       swim        layEggs       function isFish pet  Fish   Bird   pet is Fish     magic happens here     return   lt Fish gt pet  swim     undefined        Both calls to  swim  and  fly  are now okay   if  isFish pet         pet swim      else       pet fly

User · Answer

Working with string literals is difficult because if you want to refactor you method or interface names then it could be possible that your IDE don t refactor these string literals  I provide you mine solution which works if there is at least one method in the interface export class SomeObject implements interfaceA     public methodFromA         export interface interfaceA     methodFromA       Check if object is of type interface  const obj   new SomeObject    const objAsAny   obj as any  const objAsInterfaceA   objAsAny as interfaceA  const isObjOfTypeInterfaceA   objAsInterfaceA methodFromA    null  console log isObjOfTypeInterfaceA   Note  We will get true even if we remove  implements interfaceA  because the method still exists in the SomeObject class

User · Answer

Here s the solution I came up with using classes and lodash   it works      TypeChecks ts import   from  lodash    export class BakedChecker       private map  Map lt string  string gt        public constructor keys  string    types  string              this map   new Map lt string  string gt  keys map  k  i    gt                return  k  types i                         if  this map has    optional                this map delete    optional               getBakedKeys     string             return Array from this map keys                getBakedType key  string    string           return this map has key    this map get key     quot notfound quot            export interface ICheckerTemplate         optional   any       propName  string   any     export function bakeChecker template   ICheckerTemplate    BakedChecker       let keys     keysIn template       if     optional  in template            keys   keys concat   keysIn template   optional  map k   gt        k              return new BakedChecker keys  keys map k   gt            const path   k startsWith           optional     k substr 1    k          const val     get template  path           if  typeof val      object   return val          return typeof val              export default function checkType lt T gt  obj  any  template  BakedChecker    obj is T       const o keys     keysIn obj       const t keys     difference template getBakedKeys        optional         return t keys every tk   gt            if  tk startsWith                     const ak   tk substr 1               if  o keys includes ak                     const tt   template getBakedType tk                   if  typeof tt      string                       return typeof   get obj  ak      tt                  else                       return checkType lt any gt    get obj  ak   tt                                               return true                    else               if  o keys includes tk                     const tt   template getBakedType tk                   if  typeof tt      string                       return typeof   get obj  tk      tt                  else                       return checkType lt any gt    get obj  tk   tt                                               return false                       custom classes     MyClasses ts  import checkType    bakeChecker   from    TypeChecks    class Foo       a   string      b  boolean      c  number       public static  checker   bakeChecker             optional                a   quot  quot                     b  false          c  0            class Bar       my string   string      another string  string      foo   Foo       public static  checker   bakeChecker             optional                my string   quot  quot               foo  Foo  checker                    another string   quot  quot             to check the type at runtime  if  checkType lt Bar gt  foreign object  Bar  checker

User · Answer

Based on Fenton s answer  here s my implementation of a function to verify if a given object has the keys an interface has  both fully or partially   Depending on your use case  you may also need to check the types of each of the interface s properties  The code below doesn t do that   function implementsTKeys lt T gt  obj  any  keys   keyof T      obj is T       if   obj     Array isArray keys             return false             const implementKeys   keys reduce  impl  key    gt  impl  amp  amp  key in obj  true        return implementKeys      Example of usage   interface A       propOfA  string      methodOfA  Function     let objectA  any     propOfA            Check if objectA partially implements A let implementsA   implementsTKeys lt A gt  objectA    propOfA      console log implementsA      true  objectA methodOfA        gt  true      Check if objectA fully implements A implementsA   implementsTKeys lt A gt  objectA    propOfA    methodOfA      console log implementsA      true  objectA           Check again if objectA fully implements A implementsA   implementsTKeys lt A gt  objectA    propOfA    methodOfA      console log implementsA      false  as objectA now is an empty object

User · Answer

same as above where user-defined guards were used but this time with an arrow function predicate  interface A     member string     const check    p  any   p is A   gt  p hasOwnProperty  member     var foo  any     member   foobar     if  check foo       alert foo member

User · Answer

Here s another option  the module ts-interface-builder provides a build-time tool that converts a TypeScript interface into a runtime descriptor  and ts-interface-checker can check if an object satisfies it   For OP s example    interface A     member  string      You d first run ts-interface-builder which produces a new concise file with a descriptor  say  foo-ti ts  which you can use like this   import fooDesc from    foo-ti ts   import  createCheckers  from  ts-interface-checker   const  A    createCheckers fooDesc    A check  member   hello                  OK A check  member  17                      Fails with   member is not a string     You can create a one-liner type-guard function   function isA value  any   value is A   return A test value

User · Answer

TypeGuards  interface MyInterfaced       x  number    function isMyInterfaced arg  any   arg is MyInterfaced       return arg x     undefined     if  isMyInterfaced obj          obj as MyInterfaced   x

User · Answer

typescript 2 0 introduce tagged union  Typescript 2 0 features  interface Square       kind   square       size  number     interface Rectangle       kind   rectangle       width  number      height  number     interface Circle       kind   circle       radius  number     type Shape   Square   Rectangle   Circle   function area s  Shape           In the following switch statement  the type of s is narrowed in each case clause        according to the value of the discriminant property  thus allowing the other properties        of that variant to be accessed without a type assertion      switch  s kind            case  square   return s size   s size          case  rectangle   return s width   s height          case  circle   return Math PI   s radius   s radius

User · Answer

Because the type is unknown at run-time  I wrote code as follows to compare the unknown object  not against a type  but against an object of known type    Create a sample object of the right type Specify which of its elements are optional Do a deep compare of your unknown object against this sample object   Here s the  interface-agnostic  code I use for the deep compare   function assertTypeT lt T gt  loaded  any  wanted  T  optional   Set lt string gt    T        this is called recursively to compare each element   function assertType found  any  wanted  any  keyNames   string   void       if  typeof wanted     typeof found          throw new Error  assertType expected   typeof wanted  but found   typeof found               switch  typeof wanted          case  boolean         case  number         case  string           return     primitive value type -- done checking       case  object           break     more to check       case  undefined         case  symbol         case  function         default          throw new Error  assertType does not support   typeof wanted               if  Array isArray wanted           if   Array isArray found             throw new Error  assertType expected an array but found   found                   if  wanted length     1               assume we want a homogenous array with all elements the same type         for  const element of found              assertType element  wanted 0                      else              assume we want a tuple         if  found length     wanted length              throw new Error               assertType expected tuple length   wanted length  found   found length                       for  let i   0  i  lt  wanted length    i              assertType found i   wanted i                            return            for  const key in wanted          const expectedKey   keyNames   keyNames         key   key        if  typeof found key       undefined             if   optional     optional has expectedKey               throw new Error  assertType expected key   expectedKey                       else           assertType found key   wanted key   expectedKey                        assertType loaded  wanted     return loaded as T       Below is an example of how I use it   In this example I expect the JSON contains an array of tuples  of which the second element is an instance of an interface called User  which has two optional elements    TypeScript s type-checking will ensure that my sample object is correct  then the assertTypeT function checks that the unknown  loaded from JSON  object matches the sample object   export function loadUsers    Map lt number  User gt      const found   require    users json      const sample   number  User          49942               name    ChrisW          email    example example com          gravatarHash    75bfdecf63c3495489123fe9c0b833e1          profile              location    Normandy            aboutMe    I wrote this  n nFurther details are to be supplied                      favourites                   const optional  Set lt string gt    new Set lt string gt    profile aboutMe    profile location       const loaded   number  User      assertTypeT found   sample   optional     return new Map lt number  User gt  loaded        You could invoke a check like this in the implementation of a user-defined type guard

User · Answer

I would like to point out that TypeScript does not provide a direct mechanism for dynamically testing whether an object implements a particular interface    Instead  TypeScript code can use the JavaScript technique of checking whether an appropriate set of members are present on the object  For example   var obj   any   new Foo     if  obj someInterfaceMethod

User · Answer

I found an example from  progress kendo-data-query in file filter-descriptor interface d ts Checker declare const isCompositeFilterDescriptor   source  FilterDescriptor   CompositeFilterDescriptor    gt  source is CompositeFilterDescriptor   Example usage const filters  Array lt FilterDescriptor   CompositeFilterDescriptor gt    filter filters   filters forEach  element  FilterDescriptor   CompositeFilterDescriptor    gt        if  isCompositeFilterDescriptor element                element type is CompositeFilterDescriptor       else              element type is FilterDescriptor

User · Answer

It s now possible  I just released an enhanced version of the TypeScript compiler that provides full reflection capabilities  You can instantiate classes from their metadata objects  retrieve metadata from class constructors and inspect interface classes at runtime  You can check it out here  Usage example   In one of your typescript files  create an interface and a class that implements it like the following   interface MyInterface       doSomething what  string   number     class MyClass implements MyInterface       counter   0       doSomething what  string   number           console log  Doing     what           return this counter              now let s print some the list of implemented interfaces   for  let classInterface of MyClass getClass   implements        console log  Implemented interface      classInterface name      compile with reflec-ts and launch it     node main js Implemented interface  MyInterface Member name  counter - member kind  number Member name  doSomething - member kind  function   See reflection d ts for Interface meta-type details   UPDATE  You can find a full working example here

[javascript] Interface type check with Typescript

Lots of Members

Examples related to javascript

Examples related to typescript

Examples related to interface