Constructores en JavaScript

En JavaScript, el Constructor es un método especial dentro de una clase que se invoca automáticamente cuando se crea una nueva instancia de esa clase.

El propósito principal del constructor es inicializar el objeto con valores predeterminados o con valores proporcionados por el usuario.

En otras palabras, el constructor establece el estado inicial de un objeto al momento de su creación.

Sintaxis básica del constructor

La sintaxis de un constructor dentro de una clase en JavaScript es la siguiente:

class MiClase {
    constructor(parametro1, parametro2) {
        // inicialización de propiedades del objeto
        this.propiedad1 = parametro1;
        this.propiedad2 = parametro2;
    }
}

Este constructor inicializa las propiedades del objeto con los valores de los parámetros proporcionados cuando se crea la nueva instancia.

Ejemplo básico

Imaginemos que queremos crear una clase Coche que represente diferentes coches. Queremos que cada coche tenga propiedades como marca, modelo y año.

class Coche {
    constructor(marca, modelo, año) {
        this.marca = marca;
        this.modelo = modelo;
        this.año = año;
    }
}

const miCoche = new Coche('Toyota', 'Corolla', 2020);
console.log(miCoche);

La salida del código será:

Coche { marca: 'Toyota', modelo: 'Corolla', año: 2020 }

Constructor por defecto

Si no definimos un constructor dentro de una clase, JavaScript creará un constructor predeterminado vacío.

Este constructor predeterminado no realiza ninguna acción de inicialización, lo que significa que no se asignan propiedades directamente en la creación del objeto.

class Persona {
    // No hay constructor explícito aquí
}

const persona1 = new Persona();
console.log(persona1); // Persona {}

Creación de instancias con clases

Cada vez que se crea un nuevo objeto utilizando la palabra clave new, JavaScript llama al constructor de la clase correspondiente para inicializar ese objeto.

let persona1 = new Persona("Juan", 30);
persona1.saludar(); // Salida: "Hola, mi nombre es Juan y tengo 30 años."

El constructor establece las propiedades iniciales del objeto, y puedes usar los parámetros que pases al constructor para configurar esas propiedades de forma flexible.

this dentro del constructor

Dentro del constructor, this hace referencia a la instancia actual de la clase, es decir, el objeto que estamos creando.

class Persona {
    constructor(nombre, edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    saludar() {
        console.log(`Hola, mi nombre es ${this.nombre} y tengo ${this.edad} años.`);
    }
}

const persona1 = new Persona('Juan', 25);
persona1.saludar(); // "Hola, mi nombre es Juan y tengo 25 años."

Valor por defecto en el constructor

A veces, es posible que no siempre queramos que el usuario pase todos los parámetros al crear un objeto. En esos casos, podemos asignar valores predeterminados dentro del constructor.

class Coche {
    constructor(marca = 'Desconocida', modelo = 'Desconocido', año = 2000) {
        this.marca = marca;
        this.modelo = modelo;
        this.año = año;
    }
}

const coche1 = new Coche();
console.log(coche1); // Coche { marca: 'Desconocida', modelo: 'Desconocido', año: 2000 }

const coche2 = new Coche('Ford', 'Mustang', 1969);
console.log(coche2); // Coche { marca: 'Ford', modelo: 'Mustang', año: 1969 }

El constructor y la herencia

En JavaScript, las clases pueden heredar de otras clases. Cuando una clase hereda de otra, el constructor de la clase hija puede llamar al constructor de la clase padre utilizando super().

class Vehiculo {
    constructor(marca, modelo) {
        this.marca = marca;
        this.modelo = modelo;
    }
}

class Coche extends Vehiculo {
    constructor(marca, modelo, año) {
        super(marca, modelo); // Llamamos al constructor de la clase padre (Vehiculo)
        this.año = año;
    }
}

const coche1 = new Coche('Honda', 'Civic', 2022);
console.log(coche1); // Coche { marca: 'Honda', modelo: 'Civic', año: 2022 }