Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Clases públicas y privadas

25/32
Recursos

Aportes 22

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Para solucionar el “error” al colocar # sólo hay que cambiar el target en el tsconfig.json:

Un pequeño tip sobre la pronunciación de la palabra private
Es común para nosotros latino pronunciarla como priveit. Diría que un 95% de latinos la pronuncian así. Pero la correcta pronunciación sería algo como praivt pudiendo poner también una e en la última sílaba praivet

Clases - miembros públicos: define un modificador de acceso publico por defecto para los miembros de la clase. También es posible marcar un miembro como publico usando la palabra reservada public
Clases - miembros privados: define una manera propia de declarar o marcar un miembro como privado usando la palabra reservada private

class Person{
	private id:number;
	private name: string;
	public constructor(){}
	public getName(){
		return this.name
	}
}

Miembros privados ECMAScript: soporta (a partir de la versión 3.8) la nueva sintaxis JavaScript para miembros privados: #atributo. Esta caracteristica puede ofrecer mejores garantias de aislamiento en miembros privados

class Person{
	#id:number;
	#name: string;
	public constructor(){}
	public getName(){
		return this.#name
	}
}

Para que VSCode no nos tire errores por usar esta sintaxis, instalar JavaScript and TypeScript Nightly

Usar la sintaxis # para miembros privados es mejor porque nos garantiza encapsular nuestros miembros privados. a diferencia de usar private

Aún agregando la extensión sugerida, el error sigue apareciendo. Debemos agregar una propiedad a nuestro archivo tsconfig.json:
{ "compilerOptions": { ... "target": "es5" } }

Sugiero usar CTRL + D para seleccionar los public que quieran pasar a private y no cambiar de uno en uno, les ahorra un poco de tiempo.

Es como si C# y JS hubieran tenido un hijo.

  • TS define un modificador de acceso publico por defecto para los miembros de clase ( public )
  • TS define un modificador de acceso privado para los miembros que no se deseen ser leídos por fuera de la clase ( private )
  • con TS se tiene una sintaxis para métodos privados. Usando el signo # antes del nombre del miembro de clase: p.e. #atributo
    Esto se hace debido a que ofrece garantías de aislamiento en miembros privados.
    ( Private identifiers are only available when targeting ECMAScript 2015 and higher. )
export {}

enum PhotoOrientation {
    Landscape,
    Portrait,
    Square,
    Panorama,
};

class Picture {
    // properties
    #id: number;
    #title: string;
    #orientation: PhotoOrientation;
    //constructor
    public constructor( id: number, title: string, orientation: PhotoOrientation ) {
        this.#id = id;
        this.#title = title;
        this.#orientation = orientation;
    }
    //Performance
    private toString() {
        return `[id: ${this.#id}, title: ${this.#title}, orientation: ${this.#orientation}]`
    }
}

class Album {
    #id: string;
    #title: string;
    #pictures: Picture[];

    public constructor( id: string, title: string ) {
        this.#id = id;
        this.#title = title;
        this.#pictures = [];
    }    

    private addPicture(picture: Picture) {
        this.#pictures.push(picture);
    }
}

let album: Album = new Album('stories-1', 'Photos of mine');
/** Don't care about commented code below. The classes has private members, the output will be empty  */
// const newPic: Picture = new Picture(2, 'my new pic!', PhotoOrientation.Panorama);
// const new2Pic: Picture = new Picture(3, 'my 2nd new pic!', PhotoOrientation.Portrait);
// const new3Pic: Picture = new Picture(4, 'my 3rd new pic!', PhotoOrientation.Portrait);
// album.addPicture(newPic); there's an error due to private class props
// album.addPicture(new2Pic); there's an error due to private class props
// album.addPicture(new3Pic);  there's an error due to private class props
console.log('album -> ', album);

Cordial saludo.
Creo que el título de este vídeo debería reformularse, ya que como tal vemos los miembros públicos y privados de las clases, no que las clases van a ser públicas o privadas.
La verdad me he confundido al leer el título, porque no le veo sentido a por ejemplo tener una clase privada o ¿Si tiene sentido?

private vs # (hash)


PRIVATE
Cuando usas la palabra reservada private en un atributo, e intentas acceder a ella fuera de la clase, el compilador de typescript te dará un error. Hay varias formas de evitar este error, por ejemplo, usando una aserción de tipo:

const miObjeto = new MiClase();
console.log((miObjeto as any).propiedadPrivada);

Esto no da errores, y ebn cambio sí se puede acceder a la propiedad privada a la hora de ejecutar el archivo JavaScript.


# (HASH)
En cambio, con el # hash, que hace parte de la sintaxis de Ecmascript 2015, vuelve al atributo realmente privado, incluso en el archivo JavaScript que genera el compilador.
De igual forma, si sigues intentando acceder al atributo fuera de la clase, typescript te arrojará un error.

https://stackoverflow.com/questions/59641564/what-are-the-differences-between-the-private-keyword-and-private-fields-in-types

existe la manera de decirle a TS que al transplilar mitifique el código?

private y public, muy similar a C#.

Es una pena yo que estaba feliz con private :’(, y pense que # era algo así como protected

export {};

// TypeScript 3.8

enum PhotoOrientation {
    Landscape,
    Portrait,
    Square,
    Panorama
}

class Picture {
    // Propiedades
    #id: number;
    #title: string;
    #orientation: PhotoOrientation;

    public constructor(id: number, 
                title: string, 
                orientation: PhotoOrientation) {
        this.#id = id;
        this.#title = title;
        this.#orientation = orientation;
    }

    // Comportamiento
    public toString() {
        return `[id: ${this.#id}, 
                 title: ${this.#title}, 
                 orientation: ${this.#orientation}]`;
    }
}

class Album {
    #id: number;
    #title: string;
    #pictures: Picture[];

    public constructor(id: number, title: string) {
        this.#id = id;
        this.#title = title;
        this.#pictures = [];
    }

    public addPicture(picture: Picture) {
        this.#pictures.push(picture);
    }
}

const album: Album = new Album(1, 'Personal Pictures');
const picture: Picture = new Picture(1, 'Platzi session', PhotoOrientation.Square);
album.addPicture(picture);
console.log('album', album);

// Accediendo a los miembros publicos
// picture.id = 100; // private
// picture.title = 'Another title'; // private
// album.title = 'Personal Activities'; //private
console.log('album', album);

Les comparto los 4 tipos de encapsulamiento que puede tener una atributo o función.
Por lo general protected se utiliza en herencia, esto se verá en las próximas clases.

Encapsulación , modificadores de acceso private, public,

En la actualidad 2022 no es necesario instalar JavaScript and TypeScript ,ya que en consola si te imprime el mismo resultado de que si lo instalaras

Quise mostrar todas las imágenes así que, en el archivo ‘clases-private.ts’ escribí esta función:

public showPictures(){
    for (let index = 0; index < this.pictures.length; index++) {
      console.log(`Soy el índice ${index}`)
      console.table(this.pictures[index])
    }
  }

Creé unas variables extras para ponerlo a prueba:

const album: Album = new Album(1, 'Personal Pictures')
const picture: Picture = new Picture(1, 'Selfie', PhotoOrientation.Square)
const picture2: Picture = new Picture(2, 'Selfie2', PhotoOrientation.Landscape)
const picture3: Picture = new Picture(3, 'Selfie3', PhotoOrientation.Portrait)
album.addPicture(picture)
album.addPicture(picture2)
album.addPicture(picture3)

console.log(album) //* Imprime el objeto
console.table({album}) //* Como manejamos un objeto, podemos usar console.table
album.showPictures()

Resultado:

“pribeit…”

CLASES PUBLICAS Y PRIVADAS

TypeScript define un modificador de acceso público por defecto para los miembros de clase.

También es posible marcar un miembro como público usando la palabra reservada public

export{}

enum PhotoOrientation {

  Landscape,
  Portrait,
  Square,
  Panorama
}

class Picture {
  public id:number;
  public title:string;
  public orientation:PhotoOrientation;

  public constructor(id:number,title:string,orientation:PhotoOrientation){

    this.id = id;
    this.title = title;
    this.orientation = orientation;

  }

  public toString(){
    return `[id ${this.id},
            title: ${this.title},
            orientation: ${this.orientation}]`;
  }

}

//Accediendo a los miembros publicos
    //Como tenemos acceso a los objetos de nuestra clase podremos acceder a sus atributos y cambiarlos Bv
      //Por defecto typescript considera un modificador de acceso public por defecto para cada uno
        //De los miembros
          //Aunque tambien podremos utilizar la palabra public para indicarlo pero implicitamento lo trae
  picture.id = 100; //public
  picture.title = 'Otro titulo'; //public
  album.title = 'Personal Activities';
  console.log(album);

Clases Miembros Privados

Typescript define una manera propia de declarar o marcar un miembro como privado usando la palabra reservada private

export{}

enum PhotoOrientation {

  Landscape,
  Portrait,
  Square,
  Panorama
}

class Picture {
  private id:number;
  private title:string;
  private orientation:PhotoOrientation;

  //El constructor es una excepcion el no ponerlo en private ya que no podriamos crear objetos a partir
    //De el y seria inutil nuestra clase
  constructor(id:number,title:string,orientation:PhotoOrientation){

    this.id = id;
    this.title = title;
    this.orientation = orientation;

  }

  //Para las funciones tambien pondremos el acceso publico
  public toString(){
    return `[id ${this.id},
            title: ${this.title},
            orientation: ${this.orientation}]`;
  }

}

class Album{

  private id:number;
  private title:string;
  private pictures: Picture[];

  public constructor(id:number, title:string){

    this.id = id;
    this.title = title;
    this.pictures = [];
  }
    public addPicture(picture:Picture){
      this.pictures.push(picture);

    }

  }

  const album:Album = new Album(1, 'personal pictures');
  const picture: Picture = new Picture(1, 'Platzi session', PhotoOrientation)
  album.addPicture(picture);

  console.log(album);

  //Al momento de que queramos acceder a estas propiedades para imprimirlas o cambiarlas
    //No podremos hacerlo ya que estas propiedas serian privadas
  picture.id = 100; //public
  picture.title = 'Otro titulo'; //public
  album.title = 'Personal Activities';
  console.log(album);

Miembros Privados Ecmascript

Typescript también soporta (a partir de la versión 3.8) la nueva sintaxis Javascript para miembros privados. #atributo

Esta característica puede ofrecer mejores garantías de aislamiento en miembros privados.

Hacer el uso de # lo podremos hacer en ves de la palabra reservada private porque hace una mejor función y al momento de aplicarla se utilizaría en todos lados ese atributo que es definido en el contexto de la clase, esta sintaxis una mejor encapsulación y no nos permite conocer ningún estado interno.

2x

🤓 praivit —> private

<h3>Clases publicas</h3>

Ts define un modificador de acceso publico por defecto para todos los miembros de la clase

Pero tambien podemos dejarlo mas claro con la keyboard public

<h3>Clases privadas</h3>

Podemos “bloquear” ciertas propiedades o directamente clases enteras para evitar que se puedan acceder desde fuera de la misma, con esto logramos encapsulación

Usamos la keyboard private o directamente # esta ultima es mejor