Búsqueda de sitios web

TypeScript - Diferencia entre variables privadas y protegidas

¿Cuál es la diferencia entre las variables private y protected en TypeScript? Existen preguntas similares para C#, pero no estoy seguro de si los conceptos en los dos lenguajes son idénticos. Si no lo son, sería útil conocer las diferencias.

Respuesta #1

Es lo mismo que en otros lenguajes orientados a objetos.
Los métodos/miembros privados son accesibles solo desde dentro de la clase.
Los métodos/miembros protegidos son accesibles desde dentro de la clase y también desde la clase que la extiende.

class A {
    private x: number;
    protected y: number;

    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }

    getX(): number {
        return this.x;
    }

    getY(): number {
        return this.y;
    }
}

class B extends A {
    multiply(): number {
        return this.x * this.y;
    }
}

Note que en la clase A hay acceso tanto a (privado) this.x como a (protegido) this.y.
Pero en la clase B solo hay acceso a this.y y this.x tiene este error:

La propiedad 'x' es privada y sólo accesible dentro de la clase A

(puedes ver el error en el área de pruebas)

Lo importante de entender, sin embargo, es que esto solo es cierto para TypeScript.
En JavaScript, esos miembros son accesibles para cualquiera que tenga una referencia a la instancia.

Respuesta #2

PRIVADO Método:

Cuando un miembro está marcado como privado, no se puede acceder a él desde fuera de su clase contenedora.

PROTEGIDO Método:

El modificador protected actúa de manera muy similar al modificador private, con la excepción de que los miembros declarados protected también pueden ser accedidos dentro de las clases derivadas.

Hay un punto más que añadir respecto a Variables protegidas:

cuando una variable de clase base es protegida, no podemos usar su variable desde la clase derivada directamente.

Por ejemplo:

class Car{
    protected name: string;
    constructor(name: string) { this.name = name; }
}

class Mercedes extends Car{
    private noOfWheels: number;

    constructor(name: string, noOfWheels: number) {
        super(name);
        this.noOfWheels= noOfWheels;
    }

    public getIntro() {
        return `Hello, This is my ${this.name} and I have ${this.noOfWheels} wheels.`;
    }
}

let myCar= new Mercedes ("COOL Car", 4);
console.log(myCar.getIntro());  //Hello, This is my COOL Car and I have 4 wheels.
console.log(myCar.name); // Error!! , Property 'name' is protected and only accessible within class 'Car' and its subclasses.

no podemos usar la variable name directamente desde fuera de la clase Car, aún podemos usarla desde dentro de un método de instancia de Mercedes porque Mercedes deriva de Car.

Respuesta #3

protected funciona en TypeScript de manera muy similar a como lo hace en C#. Las notas de la versión de TypeScript lo documentan de esta manera:

El nuevo modificador protected en las clases funciona como lo hace en lenguajes conocidos como C++, C# y Java. Un miembro protegido de una clase es visible solo dentro de las subclases de la clase en la que se declara

Mientras que private solo te permite tener acceso al tipo de clase inmediata. Los miembros privados no son visibles para las subclases.

Artículos relacionados