Modificadores de acceso de TypeScript
Los modificadores de acceso (Access Modifiers) son una de las características principales de la programación orientada a objetos en TypeScript.
Se utilizan para controlar la visibilidad de los miembros de la clase (propiedades, métodos, constructores).
Mediante los modificadores de acceso se puede lograr la encapsulación y proteger los detalles internos de implementación de la clase.
Diagrama SVG: Ámbito de los modificadores de acceso
¿Por qué se necesitan los modificadores de acceso?
Uno de los tres principios de la programación orientada a objetos es la encapsulación.
La encapsulación significa ocultar los datos y los métodos que operan sobre ellos, exponiendo al exterior solo las interfaces necesarias.
Los modificadores de acceso son el medio para implementar la encapsulación; controlan el ámbito de visibilidad de los miembros de la clase.
Explicación del concepto:Los modificadores de acceso determinan dónde se puede acceder a los miembros de la clase. TypeScript proporciona tres modificadores de acceso: public, protected, private.
Modificador public
public es el modificador de acceso predeterminado; indica que los miembros se pueden acceder desde cualquier lugar.
Ya sea dentro de la clase, en las subclases o fuera de la clase, se puede acceder a los miembros public.
Ejemplo
class Animal {
// Usar public en la propiedad name (se puede omitir; por defecto es public)
public name: string;
// Constructor
public constructor(name: string) {
this.name = name;
}
// Método público para hablar
public speak(): void {
console.log(this.name + " Emite un sonido");
}
}
// Crear una instancia
var animal = new Animal("Animal");
// Acceder a la propiedad public desde fuera de la clase
console.log(animal.name);
// Llamar al método public desde fuera de la clase
animal.speak();
Resultado de ejecución:
Animal El animal emite sonidos.
Explicación:Si no se escribe ningún modificador de acceso, TypeScript usa public por defecto. Por lo tanto, public se puede omitir, pero para mayor claridad del código, se recomienda declararlo explícitamente.
Modificador private
private indica miembros privados; solo se puede acceder a ellos dentro de la clase donde se definen.
Ni las subclases ni el exterior de la clase pueden acceder a los miembros private.
Esto se usa a menudo para ocultar los detalles de implementación internos de la clase y proteger los datos contra modificaciones accidentales.
Ejemplo
class BankAccount {
// Usar private para el saldo; solo se puede acceder dentro de la clase
private balance: number;
// Constructor
constructor(initialBalance: number) {
this.balance = initialBalance;
}
// Método para depositar
public deposit(amount: number): void {
if (amount > 0) {
this.balance += amount; // Dentro de la clase se puede acceder a la propiedad private
console.log("Depósito exitoso, saldo actual: " + this.balance);
}
}
// Obtener el saldo
public getBalance(): number {
return this.balance; // Dentro de la clase se puede acceder a la propiedad private
}
}
// Crear una instancia de cuenta
var account = new BankAccount(1000);
// Depositar
account.deposit(500);
// Obtener el saldo mediante el método público
console.log("Saldo: " + account.getBalance());
// Error: no se puede acceder directamente a la propiedad private desde fuera de la clase
// console.log(account.balance); // ¡Error de compilación!
Resultado de ejecución:
存款成功,当前余额: 1500 余额: 1500
Mejores prácticas:Establecer el estado interno de la clase como private y proporcionar un acceso controlado mediante métodos public es la práctica estándar para implementar la encapsulación.
Modificador protected
protected indica miembros protegidos; se puede acceder a ellos dentro de la clase y en las subclases.
Desde fuera de la clase no se puede acceder directamente a los miembros protected.
Esto es muy útil cuando se necesita que las subclases hereden ciertas funcionalidades de la clase padre, ocultando a su vez los detalles de implementación.
Ejemplo
class Person {
// Usar protected para name; las subclases pueden acceder
protected name: string;
constructor(name: string) {
this.name = name;
}
}
// Definir la clase Empleado, que hereda de Person
class Employee extends Person {
// El departamento es privado
private department: string;
constructor(name: string, department: string) {
super(name); // Llamar al constructor de la clase padre
this.department = department;
}
// Método de presentación
public introduce(): string {
// La subclase puede acceder al miembro protected name
return "Soy " + this.name + ", en " + this.department + " trabajo";
}
}
// Crear una instancia de empleado
var emp = new Employee("Alice", "Departamento de tecnología");
console.log(emp.introduce());
// Error: no se puede acceder al miembro protected desde fuera de la clase
// console.log(emp.name); // ¡Error de compilación!
Resultado de ejecución:
我是 Alice,在 技术部 工作
Escenarios de aplicación:protected se usa a menudo para definir propiedades que las subclases necesitan usar, pero que no deberían exponerse al exterior.
Modificador readonly
readonly se utiliza para establecer una propiedad como de solo lectura.
Solo se puede asignar un valor en la declaración o en el constructor; después no se puede modificar.
Esto es muy útil al definir constantes o identificadores.
Ejemplo
class User {
// Las propiedades modificadas con readonly solo se pueden asignar durante la inicialización
// ID de usuario
readonly id: number;
// Nombre de usuario
readonly name: string;
constructor(id: number, name: string) {
this.id = id;
this.name = name;
}
}
// Crear una instancia de usuario
var user = new User(1, "Alice");
console.log("Usuario: " + user.id + ", " + user.name);
// Error: no se puede modificar una propiedad readonly
// user.id = 2; // ¡Error de compilación!
// user.name = "Bob"; // ¡Error de compilación!
Resultado de ejecución:
Usuario: 1, Alice
Nota:readonly y private no entran en conflicto. Se pueden usar readonly y private a la vez; así el miembro no se puede modificar ni se puede acceder desde el exterior.
Propiedades de parámetro
TypeScript proporciona una sintaxis abreviada para las propiedades de parámetro (Parameter Properties).
Se pueden usar modificadores de acceso directamente en los parámetros del constructor, lo que crea e inicializa automáticamente las propiedades.
Ejemplo
class Point {
// Usar modificadores directamente en los parámetros del constructor
// Equivale a declarar y asignar las propiedades al mismo tiempo
constructor(
// Modificador public: crea la propiedad pública x
public x: number,
// Modificador public: crea la propiedad pública y
public y: number,
// Modificador private: crea la propiedad privada z
private z: number
) {
// El cuerpo del constructor puede estar vacío; las propiedades ya se crean automáticamente
}
// Calcular la suma de las tres dimensiones
public sum(): number {
// Se puede acceder a todas las propiedades dentro de la clase
return this.x + this.y + this.z;
}
}
// Crear una instancia del punto
var point = new Point(1, 2, 3);
// Se puede acceder a las propiedades públicas desde el exterior
console.log("x: " + point.x);
console.log("y: " + point.y);
// Llamar al método
console.log("Suma total: " + point.sum());
// Error: no se puede acceder a las propiedades privadas desde el exterior
// console.log(point.z); // ¡Error de compilación!
Resultado de ejecución:
x: 1 y: 2 总和: 6
Código simplificado:Las propiedades de parámetro pueden simplificar en gran medida la definición de clases, evitando repetir código de declaración y asignación.
Comparación de modificadores de acceso
A continuación se muestra la comparación del alcance de los tres modificadores de acceso.
| Modificador | Dentro de la clase | Subclase | Fuera de la clase (instancia) |
|---|---|---|---|
| public | ✓ Accesible | ✓ Accesible | ✓ Accesible |
| protected | ✓ Accesible | ✓ Accesible | ✗ No accesible |
| private | ✓ Accesible | ✗ No accesible | ✗ No accesible |
Recomendaciones de selección:Por defecto, utiliza `private`; cuando las subclases necesiten acceder, utiliza `protected`; cuando se requiera exposición total, utiliza `public`.
Consideraciones
- Modificador predeterminado:Si no se escribe ningún modificador, el valor predeterminado es `public`.
- Constructor:El constructor también puede usar modificadores de acceso para controlar los permisos de instanciación.
- Combinación de readonly:readonly se puede combinar con public, protected y private
- Impacto en la compilación:Los modificadores de acceso solo se verifican en tiempo de compilación, no tienen efecto en tiempo de ejecución.
Mejores prácticas:Utiliza el modificador de acceso más restrictivo posible. Solo expón las interfaces públicas necesarias y establece la implementación interna como `private` o `protected`.
Resumen
Los modificadores de acceso son la herramienta central con la que TypeScript implementa el encapsulamiento.
- public:Acceso público, es el valor predeterminado.
- private:Privado, solo visible dentro de la clase.
- protected:Protegido, visible dentro de la clase y las subclases.
- readonly:Solo lectura, no se puede modificar después de la inicialización.
- Propiedades de parámetros:Sintaxis que simplifica la declaración de propiedades.
Otras extensionesRecomendación:Adquiere el hábito de usar modificadores de acceso; esto es la base para escribir código TypeScript de alta calidad.