A veces, saber mucho es peligroso. Peligroso para uno y peligroso para los otros. Además, saber mucho hace todo más complejo, y a veces uno busca que la vida sea más simple. En la programación orientada a objetos se podría decir lo mismo de las clases: cuando uno usa una clase, mientras más se sabe de ésta, más complejo es usarla. Es por eso que existen las interfaces, para no saber todo de una clase sino solamente lo justo y necesario.
¿Qué es una interfaz?
Si bien en la programación orientada a objetos hay muchas formas de definir una interfaz, creo que la más acertada para definirla en Typescript es la siguiente:
“
“Interfaces, y a veces llamadas firmas, es el mecanismo que usa Typescript para definir tipos en las clases”.
Y… ¿qué significa esto? Significa que, a veces, sólo querés definir las propiedades y métodos que van a ser visibles al mundo exterior, sin ninguna implementación (sin ninguna clase), ya que no querés atar esa definición a ninguna clase. Para eso existen las interfaces, para definir los atributos y métodos de una «cosa», sin importar qué sea esa cosa.
¡Pero capaz es mas fácil de ver con un ejemplo! Si, por ejemplo, tuviéramos la clase Pato y la clase Pez, y quisiéramos tratarlos a ambos como Animales, podríamos definir la interfaz Animal
Como vemos en el ejemplo, el «mundo exterior» (cualquier clase) usa la interfaz «animal» sin saber su implementación, o sea, su clase. Este gráfico, aunque parezca muy simple, tiene un concepto potentísimo en la programación orientada a objetos, el de desacoplar nuestro código de una implementación en particular (de una clase). Esto tiene muchas utilidades, pero quedáte con la idea de que al «mundo exterior» no le importa lo que hace internamente una clase, sino qué métodos y atributos son visibles para él.
¿Cómo se crea una interfaz?
Definir una interfaz es muy simple, se hace de la siguiente manera:
interface Saludar {
nombre: string
decirHola():string
}
Se usa la palabra reservada interface para definir una interfaz. Es muy similar a como se define una clase, con la diferencia de que las interfaces, a diferencia de las clases, solo se declaran atributos y métodos sin su implementación.
¿Cómo se usa una interfaz?
La forma de usar una interfaz también es muy simple. Como son las clases las que usan las interfaces, éstas usan la palabra reservada “implements” para decirle a una clase que implemente una interfaz.
interface Saludar {
decirHola();
}
class SaludarEspaniol implements Saludar {
decirHola() {
return 'Hola!!!';
}
}
Básicamente, que una clase implemente una interfaz, significa que la clase tiene que declarar todos los atributos y métodos que dice la interfaz. La interfaz es el contrato entre el mundo exterior y la clase, de ambos lados se ponen de acuerdo; la clase se compromete a implementar los métodos que están en la interfaz, y el mundo exterior a usar sólo los métodos que estén definidos en la interfaz.
Es más, una clase puede implementar mas de una interfaz
interface MiInterface1 {
metodo1();
}
interface MiInterface2 {
metodo2();
}
class MiClase implements MiInterface1, MiInterface2 {
metodo1() {
/* codigo metodo 1 */
}
metodo2() {
/* codigo metodo 2 */
}
}
¿Qué problema resuelve una interfaz?
Las Interfaces tienen muchas ventajas a la hora de usarlas:
– Definir tipos en las clases (el contrato con el mundo exterior)
Al definir tipos a las clases, nos aseguramos de que éstas clases tengan las propiedades y métodos que nosotros decimos, por ejemplo :
interface Saludar {
decirHola();
}
class SaludarEspaniol implements Saludar {
decirHola() {
return"Saludo: Hola!!!";
}
}
En el código definimos la interfaz “Saludar” para que la clase “SaludarEspaniol” la implemente. De esta manera, nos aseguramos que esta clase y todas las clases que implementen la interfaz Saludar tengan el método decirHola(). Si este método no existiera en una clase que implemente Saludar, el código explotaría.
– Ocultar la implementación de la clase
Otra ventaja a la hora de usar interfaces es ocultar cómo está hecha una clase, o sea, su implementación.
Siguiendo con el ejemplo anterior, si quisiéramos crear una instancia de la clase saludarEspaniol, y luego usarla:
let yo: Saludar = new SaludarEspaniol() yo.decirHola();
Si se fijan, la variable “yo” no necesita conocer nada de la clase más que el método decirHola(). No importa como esté hecho ese método, no importa si se conecta a internet, si lee el archivo de nuestra computadora ó si sólo imprime en pantalla un mensaje. El que use la interfaz «saludar» sólo necesita saber que tiene disponible el método decirHola(), eso es todo lo que necesitás saber, ¡nada más!.
Es más si tu IDE lo permite, hasta te puede autocompletar el método
– Poder cambiar una clase por otra
Otra de las grandes ventajas de usar interfaces es el hecho de poder cambiar una clase por otra (ambas que implementen la misma interfaz), y que tu código siga funcionando lo más bien.
interface Saludar {
decirHola();
}
class SaludarEspaniol implements Saludar {
decirHola() {
return 'Hola!!!';
}
}
class SaludarIngles implements Saludar {
decirHola() {
return 'Hello!!!';
}
}
en este código si tenemos lo siguiente:
let saludo = SaludarEspaniol(); saludo.decirHola();
podemos cambiarlo por:
let saludo = SaludarIngles(); saludo.decirHola();
y el resto del código lo dejamos como está ¡y seguiría funcionando!
Un momento… ¿Cuál es la diferencia entre interfaces y types?
Básicamente son lo mismo :P, pero Typescript recomienda usar interfaces para definir tipos de clases y usar type para definir tipos de datos.
Tranquilamente, una clase puede implementar tanto una “interfaz” como un “tipo”, pero conceptualmente eso no sería correcto, ya que las clases implementan interfaces, y las variables tienen tipos de datos.
¿Y puedo crear objeto usando interfaces?
O sea, ¿puedo hacer algo así?:
interface MiInterface {
hola:string;
}
let miInterface = new MiInterface();
No, ésto no se puede hacer, si lo hacés el código te va a explotar, por lo siguiente: una interfaz es sólo un contrato, o sea, es sólo la forma que te comunicas con una clase pero no es una clase, es por eso que no puedes crear objetos a través de interfaces, como lo hacés con las clases.
Conclusión
Las interfaces son un concepto potentísimo en la programación orientada a objetos. Permiten desacoplar el uso de la implementación de una clase.
Suscribíte a la Newsletter!
Si te suscribís, nunca te vas a perder un post Y vas a tener acceso a mi contenido exclusivo de forma totalmente gratuita. ¡Suscribite!
gustavodohara.com te informa que los datos de carácter personal que me proporciones rellenando el presente formulario serán tratados por Gustavo Dohara como responsable de esta web.
Finalidad de la recolección y tratamiento de los datos personales: gestionar el alta a esta suscripción y remitir boletines periódicos con información y oferta prospectiva de productos o servicios propios y de terceros afiliados.
Legitimación: Consentimiento del interesado. Destinatarios: Mailchimp. Puedes consultar aquí su política de privacidad. Derechos: Podrás ejercer tus derechos de acceso, rectificación, limitación y suprimir los datos en gustavo@gustavodohara.com así como el derecho a presentar una reclamación ante una autoridad de control. Puedes consultar la información adicional y detallada sobre Protección de Datos en mi política de privacidad