La palabra clave implements en TypeScript

1. Comprobación de tipos de TypeScript
2. Interfaces de TypeScript
3. la cláusula implements en TypeScript

Este artículo explica la palabra clave implementos de TypeScript.

Comprobación de tipos de TypeScript

TypeScript es un superconjunto de JavaScript que incluye verificación de tipos en tiempo de compilación. La comprobación de tipos en tiempo de compilación se centra principalmente en si una variable o valor de argumento tiene la forma que se supone que debe tener.

Esta técnica se llama escritura pato en TypeScript. Como resultado de la tipificación pato, el compilador de TypeScript comprueba si los dos objetos son idénticos.

Garantiza la seguridad del tipo en un programa TypeScript.

La comprobación de tipos comprueba si dos objetos dados contienen las mismas propiedades y métodos. De lo contrario, el compilador de TypeScript arrojará un error.

Supongamos que tenemos tres clases de TypeScript, como se muestra a continuación.

class Person {
    gender: string;
}

class Employee {
    gender: string;
    empId: string;
}

class Manager {
    gender: string;
    empId: string;
}

Vamos a crear nuevos objetos Person y Employee.

let person1: Person = new Person();
let employee1: Employee = new Employee();

Este código se compilará con éxito porque no viola las reglas de verificación de tipos.

Probemos a asignar el objeto employee1 a una variable de tipo Person.

let person2: Person = employee1;

Se ha compilado con éxito porque el objeto employee1 tiene la forma de objeto Person. Como los objetos Person deben tener una sola propiedad llamada género, cumple con el objeto employee1.

La propiedad adicional empId está totalmente bien.

Intentemos asignar el objeto persona1 a la variable de tipo Employee como se muestra a continuación.

let employee2: Employee = person1;

Las reglas de escritura de Duck de TypeScript no permiten esto. Por lo tanto, el compilador de TypeScript genera un error.

Por lo general, las interfaces de TypeScript desempeñan el papel de definir tipos y contratos en el código TypeScript.

Interfaces de TypeScript

Las interfaces de TypeScript proporcionan la forma para sus clases. Cada vez que una clase de TypeScript se deriva de una interfaz, debe implementar la estructura definida por la interfaz.

Es como un contrato del mundo real; siempre que una clase acepte la interfaz, debe adherirse a la estructura de la interfaz. Las interfaces no implementan ninguna lógica empresarial.

Simplemente declara las propiedades y los métodos como se muestra a continuación.

interface IVehicle {
    vehicleNumber: string;
    vehicleBrand: string;
    vehicleCapacity: number;
    getTheCurrentGear: () => number;
    getFuelLevel(): string;
}

Las interfaces de TypeScript se pueden usar como tipo, tipo de función, tipo de matriz, etc. Se pueden usar como un contrato para una clase, como se explica en la siguiente sección.

la cláusula implements en TypeScript

La palabra clave implements de TypeScript se utiliza para implementar una interfaz dentro de una clase. La interfaz IVehicle no contiene ningún detalle a nivel de implementación.

Por lo tanto, la interfaz IVehicle puede implementarse mediante una nueva clase VipVehicle.

class VipVehicle implements IVehicle {

}

La clase VipVehicle llega a un contrato con la interfaz IVehicle, como se muestra en el ejemplo anterior. Si compila este código TypeScript, generará un error, como se muestra a continuación.

El compilador de TypeScript se queja de que no se han implementado tres propiedades y dos métodos dentro de la clase VipVehicle. Por lo tanto, es obligatorio ajustarse a la estructura de la interfaz IVehicle.

Deberíamos agregar tres propiedades e implementar los dos métodos en consecuencia.

class VipVehicle implements IVehicle {
    vehicleNumber: string;
    vehicleBrand: string;
    vehicleCapacity: number;

    getTheCurrentGear():number {
        return 3; // dummy numebr returning here for demo purposes
    }

    getFuelLevel():string {
        return 'full'; // dummy string returning here for demo purposes
    }

}

Si volvemos a compilar el código, debería compilarse correctamente.