Interface and class in TypeScript

Question

In C# there's a quite huge difference between interfaces and classes. Indeed, a class represents a reference-type, so that we can actually create objects modeled on that class, while interfaces are meant to be contracts that a class sign to in order to ensure the existence of a certain behavior. In particular we can't create instances of interfaces.

The whole point with interfaces is to expose behavior. A class implements it by giving one explicit implementation of said behavior.

In that case, although interfaces may contain properties, most of the time we care about interfaces because of behavioral issues. So most of the type, interfaces are just contracts of behavior.

On TypeScript, on the other hand, I've seem something that made me quite uneasy, and in truth I've seen this more than once, which is the reason for this question.

In one tutorial I saw this:

export interface User {     name: string; // required with minimum 5 chracters     address?: {         street?: string; // required         postcode?: string;     } } 

But wait a minute. Why User is an interface? If we think like C#, User shouldn't be an interface. In truth, looking at it, it seems like we are defining the data type User, instead of a contract of behavior.

Thinking like we do in C#, the natural thing would be this:

export class User {     public name: string;     public address: Address; } export class Address {     public street: string;     public postcode: string; } 

But this thing of using interfaces like we do with classes, to just define a data type, rather than defining a contract of behavior, seems very common in TypeScript.

So what interfaces are meant for in TypeScript? Why do people use interfaces in TypeScript like we use clases in C#? How interfaces should be properly used in TypeScript: to establish contracts of behavior, or to define properties and object should have?

Answer 1

Consider that in Javascript, data is often exchanged as plain objects, often through JSON:

let data = JSON.parse(someString); 

Let's say this data is an array of User objects, and we'll pass it to a function:

data.forEach(user => foo(user)) 

foo would be typed like this:

function foo(user: User) { ... } 

But wait, at no point did we do new User! Should we? Should we have to write a class User and map all the data to it, even though the result would be exactly the same, an Object with properties? No, that would be madness just for the sake of satisfying the type system, but not change anything about the runtime. A simple interface which describes how the specific object is expected to look like (to "behave") is perfectly sufficient here.

Answer 2

I also came to Typescript from a C# background and have wondered the same things. I was thinking along the lines of POCOs (is POTO a thing?)

So what interfaces are meant for in TypeScript?

The Typescript Handbook seems to say that interfaces are meant for "defining contracts within your code".

Why do people use interfaces in TypeScript like we use classes in C#?

I agree with @deceze's answer here.

John Papa expands on the subject of classes and interfaces on his blog. He suggests that classes are best suited for "creating multiple new instances, using inheritance, [and] singleton objects". So, based on the intent of Typescript interfaces as described in the Typescript Handbook and one man's opinion, it would appear that classes are not necessary to establish contracts in Typescript. Instead, you should use interfaces. (Your C# senses will still be offended.)

Interfaces should be properly used in TypeScript: to establish contracts of behavior, or to define properties and object should have?

If I understand the question, you are asking if interfaces should establish contracts of behavior or contracts of structure. To this, I would answer: both. Typescript interfaces can still be used the same way interfaces are used in C# or Java (i.e. to describe the behavior of a class), but they also offer the ability to describe the structure of data.

Furthermore, my coworker got on me for using classes instead of interfaces because interfaces produce no code in the compiler.

Example:

This Typescript:

class Car implements ICar {     foo: string;     bar(): void {     } }  interface ICar {     foo: string;     bar(): void; } 

produces this Javascript:

var Car = (function () {     function Car() {     }     Car.prototype.bar = function () {     };     return Car; }()); 

Try it out