Encapsulamiento
Práctica de ocultar datos internos y controlar su acceso mediante modificadores en TypeScript.
Encapsulamiento
El encapsulamiento es la práctica de ocultar los datos internos de un objeto y permitir el acceso a ellos únicamente a través de una interfaz controlada (métodos). Sirve para evitar que código externo modifique el estado de tu objeto de forma no autorizada o dañina.
En TypeScript, los modificadores de acceso son las palabras clave que usas para decidir qué nivel de protección le das a cada propiedad o método.
Modificadores de Acceso
1. public (Acceso libre)
Es el modificador por defecto en TypeScript. Si no pones nada, la propiedad o método es public. Cualquier código fuera de la clase puede leerlo o modificarlo.
typescriptclass Persona {
public nombre: string; // O simplemente: nombre: string;
constructor(nombre: string) {
this.nombre = nombre;
}
}
const p = new Persona("Carlos");
console.log(p.nombre); // ✅ Se puede leer desde fuera: "Carlos"
p.nombre = "Juan"; // ✅ Se puede modificar desde fuera
2. private y # (Solo visible dentro de la clase)
Impide que la propiedad se pueda leer o modificar desde fuera de la clase. Sirve para datos confidenciales o lógica interna.
A. private de TypeScript
Es una restricción solo a nivel de compilación de TypeScript. Si intentas acceder a ella desde fuera, TypeScript te dará un error de compilación.
typescriptclass CuentaBancaria {
private saldo: number = 1000;
public verSaldo(): number {
return this.saldo; // ✅ Permitido: estamos dentro de la misma clase
}
}
const cuenta = new CuentaBancaria();
console.log(cuenta.verSaldo()); // ✅ Imprime 1000
// ❌ ERROR de TypeScript: La propiedad 'saldo' es privada
// console.log(cuenta.saldo);
// cuenta.saldo = 50000;
B. # Campos Privados Nativos de JavaScript
Es la sintaxis nativa de JavaScript moderno. A diferencia de private, el signo # hace que la propiedad sea realmente privada en tiempo de ejecución.
typescriptclass CuentaBancaria {
#pin: string = "1234"; // Propiedad privada nativa (#)
validarPin(ingresado: string): boolean {
return this.#pin === ingresado; // ✅ Permitido dentro de la clase
}
}
const cuenta = new CuentaBancaria();
// console.log(cuenta.#pin); ❌ Error grave de JavaScript: campo privado no accesible
3. protected (Visible en la clase y en sus hijas)
Es como private, pero con una excepción: las clases que heredan de ella (clases hijas) SÍ pueden acceder a la propiedad. Desde fuera de la clase sigue estando totalmente prohibido.
typescriptclass Empleado {
protected salarioBase: number = 2000; // Protegido
}
// Clase hija que hereda de Empleado
class Gerente extends Empleado {
public calcularSueldoTotal(): number {
// ✅ Permitido: Gerente es hija de Empleado, así que puede ver 'salarioBase'
return this.salarioBase + 1000;
}
}
const g = new Gerente();
console.log(g.calcularSueldoTotal()); // ✅ Imprime 3000
// ❌ ERROR: Desde fuera de la clase no se puede acceder a 'salarioBase'
// console.log(g.salarioBase);
4. readonly (Solo lectura)
Permite asignar un valor únicamente en la declaración o dentro del constructor. Una vez que el objeto se crea, su valor se vuelve inmutable (nadie puede cambiarlo, ni desde fuera ni desde dentro).
typescriptclass Usuario {
public readonly id: number; // Se puede leer, pero no modificar
public nombre: string;
constructor(id: number, nombre: string) {
this.id = id; // ✅ Se permite asignar solo en el constructor
this.nombre = nombre;
}
public cambiarId() {
// this.id = 999; ❌ ERROR: No se puede reasignar una propiedad 'readonly'
}
}
const u = new Usuario(101, "Ana");
console.log(u.id); // ✅ Imprime 101 (se puede leer sin problema)
// u.id = 202; ❌ ERROR: Es de solo lectura