typescript Object types are compared structurally

Question

Object types are compared structurally. For example, in the code fragment below, class 'CPoint' matches interface 'Point' because 'CPoint' has all of the required members of 'Point'. A class may optionally declare that it implements an interface, so that the compiler will check the declaration for structural compatibility. The example also illustrates that an object type can match the type inferred from an object literal, as long as the object literal supplies all of the required members.

 interface Point {  
     x: number;  
     y: number;   }
 
 function getX(p: Point) {  
     return p.x;   }
 
 class CPoint {  
     x: number;  
     y: number;  
     constructor(x: number,  y: number) {  
         this.x = x;  
         this.y = y;  
     }   }
 
 getX(new CPoint(0, 0));  // Ok, fields match
 
 getX({ x: 0, y: 0, color: "red" });  // Extra fields Ok
 
 getX({ x: 0 });  // Error: supplied parameter does not match

In their example CPoint is considered of type Point, since it is of type Point I can pass it anywhere I can a Point. If Point stated that all implementors had method Foo(x:string), CPoint wouldn't have that method. Thus anyone accepting a Point and expecting to use Foo would blow up if CPoint was passed into it.

My question is, am I interpreting this wrong, if not why is this considered a good enough to put into the language specs?

Ryan Cavanaugh · Accepted Answer · 2016-03-15 22:07:36Z

2

If Point stated that all implementors had method Foo(x:string), CPoint wouldn't have that method. Thus anyone accepting a Point and expecting to use Foo would blow up if CPoint was passed into it.

If you did this, you would get a compile-time error that CPoint lacked the Foo method. I recommend trying it on the TypeScript Playground.

answered Mar 15, 2016 at 22:07

Ryan Cavanaugh

223k59 gold badges280 silver badges235 bronze badges

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

Comments

Andreas Jägle · Accepted Answer · 2016-03-15 22:12:03Z

The type definitions/interfaces one creates are just a compile-time thing and in my opinion, the structural subtyping is a great feature.

If you extend the Point interface with an additional method Foo(x: string), you tell the compiler that every object that wants to be a Point now also needs this method. In my opinion, this is exactly what you want to have because you can spot all places where you are passing objects that are lacking these additional properties.

Before adding such a method to an interface, it's probably better to ask yourself, if every object that has the characteristics of a Point really needs this method. In my experience it is often better to introduce some more interfaces, e.g. Fooable and using this where you need an object that needs to have the Foo method.

If you have a method that really needs objects having both characteristics, (x,y) and Foo, you can do something like this:

function myMethodRequiringASpecialObject(x: Point & Fooable) {}

This is called "intersection types". See more here: https://basarat.gitbooks.io/typescript/content/docs/types/type-system.html

Collectives™ on Stack Overflow

typescript Object types are compared structurally

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related