Home / Questions / 243754
Accepted
Pablo Lozano
Asked: 2020-03-08 07:51:59 +0800 CST 2020-03-08 07:51:59 +0800 CST

When should you use an interface and not a class (and vice versa)?

  • 772

When we program with Typescript, we have a concept that doesn't exist in Javascript: interfaces. In ES6 there are classes, which are syntactic sugar for classical prototyping, but no variable typing and nothing resembling an interface.

One may think that interfaces are the same as in Java or C#, but I have come across this:

class MiClase {

  constructor( public atributoA: string) {}

  metodoA() {
    //hace algo
  }
}

interface MiInterfaz extends MiClase {
    algo: any;
}

function miFuncion(attr: MiClase) {
  console.log(attr instanceof MiClase);
}

function miFuncion2(attr: MiInterfaz) {
  console.log(attr instanceof MiClase);
}

let a = {
    atributoA: 'hola',
    atributoB: 6,
    metodoA: function () { },
};


miFuncion(a); //false
miFuncion2(a);//false

let b = new MiClase('Una auténtica instancia de MiClase');

miFuncion(b); //true
miFuncion2(b);//compilador marca error, no cumple la interfaz

What's going on here?

  • Why does ait not give an error miFuncionwhen it is clearly not of the class MiClase?
  • Why are they interchangeable? The interface extends a class and doesn't give an error!
javascript

1 Answers

  1. Best Answer

    Why does ait not give an error miFuncionwhen it is clearly not of the class MiClase?

    a is an anonymous object so it will never be the instance of the type MiClase.

    If you try it in javascript you will see that it also returns false:

    function MiClase(valor){
   this.atributo = valor;
}

var aninimo = {atributo: 4};
var instancia = new MiClase(4);

console.log(aninimo instanceof MiClase);
console.log(instancia instanceof MiClase);

    Typescript's type checker focuses on how the value/object is defined , not its type. This is called duck typing . Hence, in this case the compiler does not throw you any error:

    let a = {
    atributoA: 'hola',
    atributoB: 6,
    metodoA: function () { },
};

miFuncion(a); //false

    According to the documentation :

    The compiler only checks that at least the properties defined on the interface are present and match the required types.

    Like aif you have the properties required by the interface/class MiClase, the compiler allows you to.

    Why are they interchangeable? The interface extends a class and doesn't give an error!

    As already mentioned, typescript is not focused on the type, but on the way the type is defined, so when an interface extends a class you are simply adding to the interface the form of the class it inherits.

    In summary, to know when to use an interface or class, the same principles as always are used and thus avoid confusion:

    1. If you need to define a contract to define different behaviors with the same interface or you need to support multiple inheritance, you use an interface.
    2. If you need a specific implementation (such as a factory class), you use a class.
    • 9