Qué son los modificadores de acceso en TypeScript

Los modificadores de acceso son palabras clave que se utilizan para controlar la visibilidad y accesibilidad de las propiedades y métodos dentro de una clase.

Estos modificadores permiten definir qué partes de una clase pueden ser accedidas desde fuera de la clase y cuáles deben permanecer ocultas, facilitando la encapsulación y el diseño más seguro del código.

Los tres principales modificadores de acceso disponibles en TypeScript: son public, private y protected.

Modificador public

El modificador public es el valor predeterminado en TypeScript y permite que las propiedades y métodos sean accesibles desde cualquier parte del código.

Esto significa que se pueden leer y modificar desde fuera de la clase en la que están definidos.

class Estudiante {
    public nombre: string;
    public edad: number;

    constructor(nombre: string, edad: number) {
        this.nombre = nombre;
        this.edad = edad;
    }

    public mostrarInfo(): void {
        console.log(`Nombre: ${this.nombre}, Edad: ${this.edad}`);
    }
}

const estudiante = new Estudiante("Carlos", 21);
console.log(estudiante.nombre);  // Acceso público
estudiante.mostrarInfo();        // Método público

En este ejemplo, tanto las propiedades nombre y edad, como el método mostrarInfo, son public, por lo que pueden ser accedidos y utilizados fuera de la clase Estudiante.

Modificador private

El modificador private oculta las propiedades y métodos de una clase, de modo que solo puedan ser accedidos y modificados desde dentro de la propia clase.

Los miembros private no son accesibles desde fuera de la clase ni desde sus clases derivadas.

class CuentaBancaria {
    private saldo: number;

    constructor(saldoInicial: number) {
        this.saldo = saldoInicial;
    }

    public mostrarSaldo(): void {
        console.log(`Saldo: ${this.saldo}`);
    }

    public depositar(cantidad: number): void {
        if (cantidad > 0) {
            this.saldo += cantidad;
        }
    }
}

const cuenta = new CuentaBancaria(1000);
cuenta.mostrarSaldo();    // Salida: Saldo: 1000
cuenta.depositar(500);
cuenta.mostrarSaldo();    // Salida: Saldo: 1500

console.log(cuenta.saldo);  // Error: Property 'saldo' is private and only accessible within class 'CuentaBancaria'.

Aquí, la propiedad saldo es private, lo que significa que no puede ser accedida directamente desde fuera de la clase CuentaBancaria. Solo los métodos de la clase, como depositar y mostrarSaldo, pueden acceder y modificar saldo.

Modificador protected

El modificador protected permite que las propiedades y métodos sean accesibles dentro de la clase en la que están definidos y en sus clases derivadas, pero no desde fuera de estas clases.

Esto es útil para permitir que las clases derivadas accedan a miembros que no deberían ser públicos.

class Vehiculo {
    protected marca: string;

    constructor(marca: string) {
        this.marca = marca;
    }
}

class Coche extends Vehiculo {
    public modelo: string;

    constructor(marca: string, modelo: string) {
        super(marca);
        this.modelo = modelo;
    }

	// la clase coche puede usar .marca
    public mostrarDetalles(): void {
        console.log(`Marca: ${this.marca}, Modelo: ${this.modelo}`);
    }
}

const coche = new Coche("Toyota", "Corolla");
coche.mostrarDetalles();  // Salida: Marca: Toyota, Modelo: Corolla

// el programa no puede usar marca directamente
console.log(coche.marca);  // Error: Property 'marca' is protected and only accessible within class 'Vehiculo' and its subclasses.

En este ejemplo, la propiedad marca es protected, por lo que solo puede ser accedida dentro de la clase Vehiculo y sus clases derivadas, como Coche. No es accesible desde fuera de estas clases.