Creando clases con constructores en Typescript - El Mundo de Angular

Creando clases con constructores en Typescript

¿Que pasaría si necesitaras dejar tu objeto listo para usar a la hora de crearlo… si tuvieras que ejecutar algo de código para que tu objeto quedara pipí cucú, y sólo restarla usarlo? ¿Te gustaría que fuera la misma clase la que se encargara de ejecutar ese código automáticamente por vos? Si es eso lo que necesitás, seguí leyendo ;)

¿Qué es un constructor?

Básicamente, un constructor es el método de una clase, que se ejecuta cuando ejecutamos:


new MiClase();

O sea, cuando creamos un objeto. 

La estructura de un constructor es la siguiente:


class MiClase {
    constructor() {
    }
}

 

Separando la creación de un objeto de su uso

Si separamos la vida de un objeto en dos partes, esas partes serían su creación y su uso. La creación refiere al momento en el que usamos la palabra reservada “new” para crear el objeto; y su uso, a cuando ya tenemos el objeto creado y lo usamos.

 

 

El constructor por defecto

Todas las clases se crean con un constructor por defecto. Este constructor no tiene parámetros y básicamente no hace nada más que crear la clase. Por ejemplo, si tenemos la clase:

class Persona {
}

 

Este código es perfectamente válido en Typescript, e internamente, lo que hace Typescript , si vos no le definís ningún constructor, es crearte un constructor por defecto que, básicamente, no lleva parámetros y no hace nada:

 

 

Creando nuestros propios constructores

Si, por otro lado, vos querés crear un constructor,  podés hacerlo de la siguiente forma:


class MiClase {
    constructor() {
       /*acá va tu código*/
    }
}

Recordá que el constructor ejecuta cualquier código que quieras ejecutar ni bien creás tu objeto, antes de usar cualquier otro método.

 

También fíjate, en este constructor no se usaron parámetros pero tranquilamente se le podría pasar uno, dos o la cantidad que quieras:


class MiClase {
    constructor(nombre:string) {
    }
}

Con dos parámetros:


class MiClase {
    constructor(nombre:string, apellido:string) {
    }
}

Y así, con muchos parámetros mas.

Constructores abreviados

Suponéte que querés crear la clase Persona, con los atributos nombre y apellido, y cargarles valor en el constructor. Una forma de hacerlo es la siguiente:


class Persona {
    nombre:string;
    apellido:string;
    constructor(nuevoNombre:string, nuevoApellido:string) {
       this.nombre=nuevoNombre;
       this.apellido=nuevoApellido;
    }
}

 

Pero, en Typescript, existe una forma mucho más simplificada de crear atributos e inicializarlos al mismo tiempo en el constructor:


class Persona {
    constructor(nuevoNombre:string, nuevoApellido:string) {
    }
}

Aunque no me creas, el código anterior hace exactamente lo mismo que el otro.

 

Constructores y Herencia

¿Qué pasa con la herencia? ¿Qué pasa si una clase padre tiene un constructor, y la clase hija hereda de ese padre? ¿Qué es lo que tiene que hacer?

 


class Persona {
    constructor() {
    }
}
class PersonaEducada extends Persona {
    constructor() {
       super()
    }
}

En el caso de que una clase hija tenga un constructor, es obligatorio llamar al método super() antes de cualquier otra cosa. Lo que hace super precisamente, es llamar al constructor del padre, de esta forma, cualquiera que herede una clase se asegura de llamar al constructor de la clase «padre», y así, inicializar todo lo que tenga que inicializar del padre.

 

¿Qué se pone dentro del constructor?

Como dentro del constructor de una clase se ejecuta código ni bien se crea esta clase, generalmente, lo que se pone en el constructor es código de inicialización del objeto a usar.

Por ejemplo:

Cuando queremos inicializar variables que vienen por parámetro:


class Persona {
    nombre:string;
    apellido:string;
    constructor(nuevoNombre:string, nuevoApellido:string) {
       this.nombre=nuevoNombre;
       this.apellido=nuevoApellido;
    }
}

Cuando queremos inicializar variables que no vienen por parámetro:


class MiClase {
    objetoComplejo:ObjetoComplejo;
    constructor(nuevoNombre:string, nuevoApellido:string) {
       this.objetoComplejo=newObjetoComplejo();
    }
}

Y, en general, cualquier código que quieras asegurar antes de usar tu objeto-

Conclusión

Los constructores son una herramienta muy útil en la programación orientada a objetos. Nos ahorran líneas de código y, principalmente, nos proporcionan un mecanismo de inicialización de objetos. Gracias a los constructores nos olvidamos de tener que inicializar nuestros objetos y sólo nos ocupamos de usarlos. Así que ya sabés ¡a construir objetos!

About the Author

Mi nombre es Gustavo Hernán Dohara, soy Ingeniero en Sistemas y, sobre todas las cosas, soy un apasionado por la tecnología; tengo más de 10 años de experiencia en diferentes tecnologías y he decidido compartir mis conocimientos y experiencias con cualquiera que desee aprender: alumnos, empleados, freelancers y vos. Al ritmo que cada uno pueda, en el horario en que cada uno pueda y en el lugar que cada uno elija.