Acceso privado

Clase 5 de 25 • Curso de TypeScript: Programación Orientada a Objetos y Asincronismo

Miguel Angel Reyes Moreno

student•

Sé que no es el enfoque del curso, pero es necesario mencionarlo para mejorar el inglés. No se pronuncia 'priveit', se pronuncia 'praivet'

Juan David Reyes

student•

es importante el ingles es indispensable, gracias!

Reinaldo Mendoza

student•

No se porque ese error es tan común, al principio no sabia que decía hasta que lo escribió, :D

Axel Enrique Galeed Gutierrez

student•

¿Qué quiere decir?

Podemos proteger nuestras propiedades y métodos para que nos sean accedidos y modificados por fuera de clase.

Private

Con esta palabra reservada private estamos restringiendo el acceso de nuestros parámetros y métodos, solo podrán ser accedidos o modificados dentro de la clase.

Sintaxis

class nameClass {
		private parameter1: dataType;
		constructor (parameters) { statements }

		private method (parameters): dataType { statements }
}

Private class fields (#)

A desde hace muy poco JavaScript tiene incorporado la capacidad de poder limitar el alcance de los métodos y propiedades utilizando #. Funciona igual que private, solo que # es nativo de JavaScript y realmente limita el alcance.

Sintaxis

class nameClass {
		#parameter1: dataType;
		constructor (parameters) { statements }

		#method (parameters): dataType { statements }
}

Ejemplo

type PartOfTheCalendar = 'day' | 'month'| 'year';

export class MyDate {
    year: number;
    private month: number;
    #day: number;

    constructor (year: number, month: number, day: number) {
        this.year = year;
        this.month = month;
        this.#day = day;
    }

    printFormat (): string {
        const { year } = this;
        const day = this.#addPadding(this.#day);
        const month = this.#addPadding(this.month);
        return `${day}/${month}/${year}`;
    }

    add (amount: number, type: PartOfTheCalendar) {
        if (type === 'day') this.#day += amount;
        if (type === 'month') this.month += amount;
        if (type === 'year') this. year += amount;
    }

    #addPadding (value: number) {
        if (value < 10) return `0${value}`;
        return `${value}`;
    }

    //  private addPadding (value: number) {
    //     if (value < 10) return `0${value}`;
    //     return `${value}`;
    // }
}

Andrés Felipe Eslava Zuluaga

student•

Excelente dato

Axlin Miranda

student•

Excelente información, no conocía que se podía utilizar el símbolo # para también tratarlo como privado, gracias por compartirlo

Brahyan Antonio Martinez Madera

student•

Es magico que cuando aprendes esto, no sabes como trabajaste sin ello antes, TS💙

Jordy Mairena Montoya

student•

Dejo mi solucion

export type formatDate = 'days' | 'months' | 'years';

class MyDate {
    private _year: number;
    private _month: number;
    private _day: number;
    private _leapYear: boolean = false; // by deafault the year is not leap year

    private _months: { [key: number]: string; } = {
        1: 'January',
        2: 'February',
        3: 'March',
        4: 'April',
        5: 'May',
        6: 'June',
        7: 'July',
        8: 'August',
        9: 'September',
        10: 'October',
        11: 'November',
        12: 'December'
    };

    private _month31: number[] = [1, 3, 5, 7, 8, 10, 12]; // list of months that have 31 days

    constructor(year: number, month: number, day: number) {
        this._year = this._validYear(year);
        this._validLeapYear()
        this._month = this._validMonth(month);
        this._day = this._validDay(day);
    }

    printFormat(format: string = 'dd / nm / yy'): string {
        if (this._validError() == null) { // if validError returns null then there are no errors
            let day: string = this._addPadding(this._day);
            let month: string = this._addPadding(this._month);
            format = format.replace('yy', this._year.toString());
            format = format.replace('dd', day);
            format = format.replace('mm', month);
            format = format.replace('nm', this._months[this._month]);
            return format;
        } else {
            return this._validError()!; // notation ! tells typescript that the programmer is in control
        }
    }

    // override
    toString(): string {
        return this.printFormat();
    }

    get day(): number {
        return this._day;
    }

    get month(): number {
        return this._month;
    }

    get monthName(): string {
        return this._months[this._month];
    }

    get year(): number {
        return this._year;
    }

    get leapYear(): boolean {
        return this._leapYear;
    }

    private _validError(): string | null {
        // if any attribute has the value of zero then it is out of range and there is an error
        let error: string = '#outRange!'; // out of tange error indicator
        if (this._year == 0) {
            return `${error} year`; // error message
        }
        if (this._month == 0) {
            return `${error} month`; // error message
        }
        if (this._day == 0) {
            return `${error} day`; // error message
        }
        return null; // whithout errors
    }

    private _addPadding(num: number): string {
        if (num < 10) {
            return `0${num}`;
        }
        return num.toString();
    }

    private _validYear(year: number) {
        // if the year is greater than zero it is valid
        if(year > 0) {
            return year;
        } else {
            return 0;
        }
    }

    private _validDay(day: number) {
        // validate the day
        if (day > 0) {
            if (this._month === 2) { // if the month is february
                let evaluateDay: number = 28;
                if (this._leapYear) { // if leap year
                    evaluateDay++;
                }
                if (day <= evaluateDay) {
                    return day;
                } else {
                    return 0;
                }
            } else { // if it is any month except february
                let evaluateDay: number = 30;
                if (this._month31.includes(this._month)) { // if the month has 31 days
                    evaluateDay++;
                }
                if (day <= evaluateDay) {
                    return day;
                } else {
                    return 0;
                }
            }
        } else {
            return 0
        }
    }

    private _validMonth(month: number) {
        // Validated that the month is between 1 and 12
        if (month > 0 && month < 13) {
            return month;
        } else {
            return 0;
        }
    }

    private _validLeapYear() {
        /**
         * @ Check if the year is a leap year
         */
        let result: number;
        result = (this._year / 4) % 2; // formula if ((n/4) % 2 == 0)

        if(result == 0) {
            this._leapYear = true;
        }
    }

    add(amount: number, format: formatDate) {
        if (this._validError() == null) {
            if (format == 'days') {
                for (let i = 0; i < amount; i++) {
                    this._day += 1;
                    if (this._validDay(this._day) == 0) { // Validated the day based on the month and year
                        /* if _validDay returns 0 the valid days for the current month
                        were exceeded then the month is increased and day is restarted */
                        this._month++;
                        if (this._month == 13) {
                            this._year++;
                            this._month = 1;
                        }
                        this._day = 1;
                    }
                }
            } else if (format == 'months') {
                for (let i = 0; i < amount; i++) {
                    this._month++;
                    if (this._month > 12) {
                        this._year++;
                        this._month = 1;
                    }
                }
            } else if (format == 'years') {
                if (amount > 0) {
                    this._year += amount;
                }
            }
        }
    }
}

const myDate = new MyDate(2000, 2, 29);
console.log(myDate.printFormat('dd of nm of yy'));
myDate.add(3, 'days');
console.log(myDate.printFormat());
myDate.add(40, 'months');
console.log(myDate.printFormat('mm-dd-yy'));
console.log(myDate.toString());
console.log(myDate.day);
console.log(myDate.month);
console.log(myDate.monthName);
console.log(myDate.year);

Eduardo Robles

student•

private addMonth(months: number = 1): string {
    this._month += months;
    while (this.month > 12) {
      this.addYear();
      this._month -= 12;
    }
    return this.printFormat();
  }
  private addYear(years: number = 1) {
    this._year += years;
    return this.printFormat();
  }
  private addDay(days: number = 1): string {
    const daysPerMonth: number = 30;
    this._day += days;
    while (this.day > daysPerMonth) {
      this.addMonth();
      this._day -= daysPerMonth;
    }
    return this.printFormat();
  }
  get day(): number {
    return this._day;
  }
  get month(): number {
    return this._month;
  }
  get year(): number {
    return this._year;
  }
  add(amount: number, type: "days" | "years" | "months"): string | void {
    if (typeof amount === "number") {
      switch (type) {
        case "days":
          return this.addDay(amount);
        case "years":
          return this.addYear(amount);
        case "months":
          return this.addMonth(amount);
        default:
          return console.error("El tipo no existe");
      }
    }
    return console.error("amount debe ser un number");
  }

Diego Delgado

student•

El acceso privado a los atributos y métodos nos permite restringir la modificación no autorizada a los datos de la clase, y de esta manera tener más control sobre nuestra clase.

William Cortes

student•

me surge una duda, private no me deja accerder a ún método por fuera de la clase y public me permite utilizar el método, pero también deja modificar dicho método, pensé en poner readonly pero tampoco funcionó:

myDate.add = ():string => 'I am a bug'

console.log( myDate.add(2,'months'))
//I am a bug

//como vemos este no es el resultado deseado

Ivan David Martinez Baron

student•

Es muy interesante tu pregunta pero al parecer yo tampoco encontré solución. Chat Gpt me dio ideas sin embargo ninguna de ellas funciona y al contrario agrega errores al código. Estaré buscando en foros a ver que más encuentro.

Jesús Patricio Pereira Matus

student•

lo que hace con addPading de ponerlo private es encapsulacion de logica, porque podriamos crear todo el algoritmo dentro de la funcion format pero es una rebundancia de codigo, por lo cual creamos una funcion que haga solo esa tarea y la integramos y no nos metemos en cabeza el crear muchos ifs solo para darle el formato adecuado

Dario Mendoza

student•

El acceso privado en una variable en programación orientada a objetos (POO) se refiere a un modificador de acceso que restringe la visibilidad de esa variable únicamente dentro de la clase donde fue definida. Esto significa que no puede ser accedida o modificada directamente desde fuera de la clase, lo que promueve el encapsulamiento y protege la integridad de los datos. Por ejemplo, en TypeScript, se utiliza la palabra clave private para declarar variables privadas en una clase.

Vladimir Farrera Vera

student•

y el "protected" como se usa?

fabio andres zamora osorio

student•

Tengo entendido que actualmente en JS se puede usar # para definir atributos y metodos privados, entonces ¿en typescript se puede usar # en lugar de private?

Brahyan Antonio Martinez Madera

student•

Si de hecho JS se inspiro en TS para hacerlo:

https://www.typescriptlang.org/docs/handbook/classes.html desde la version 3.8.

En cambio javascript https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Classes/Private_class_fields lo tiene en modo experimental XD, eso significa que personas que no tienen la ultima version de navegadores modernos, no les funciona el cambio.

En resumen Ts que se transpila es la opcion mas segura para usar en empresas, en cambio para proyectos personales si que puedes probar en JS

Sergio Noriega

student•

Bueno que mal que typescript es un lenguaje transpilado si no seria excelente, pero bueno si queremos clases privadas no solo bastaria colocarle el private si no tambien el '#' por que a la final es javascript, solo que empresarial

Christian Armando Consuelo Mayén

student•

Tal vez algo redundante pero si los metodos o las variables son de uso privado dentro de las clases, a mi me gusta ponerle "_" prefijo.

  private _addPadding(value: number): string {
    return value < 10 ? `0${value}` : `${value}`;
  }
```  private \_addPadding(*value*: number): string {    return *value* < 10 ? `0${*value*}` : `${*value*}`;  }

Ulqernesh Karvenae

student•

El metodo private aunque arroja un warm en TS si copilamos el archivo a JS y ejecutamos el JS lo muestra normal, en cambio si utilizamos el #day el metodo se vuelve privado y no lo podemos modificar afuera a no ser que implementemos los getters que lo comvierte en solo lectura y los setters donde lo puedes modificar dependiendo tus parametros ejemplo

class MyDate {

  #year: number
  #month: number
  #day: number

  constructor (year: number, month: number, day: number) {
    this.#year = year
    this.#month = month
    this.#day = day
  }

  getData = (): object => {
    return {
      year: this.#year,
      month: this.#month,
      day: this.#day,
    }
  }

  printFormat = (): string => {
    const day = this.addPadding(this.#day)
    const month = this.addPadding(this.#month)

    return `${this.#year}/${month}/${day}`
  }

  addPadding(value : number): string {
    return (value.toString()).padStart(2, '0')
  }

  add(amount : number, type: 'days' | 'months' | 'years') {
    if (type === 'days') {
      this.#day += amount
    }
    if (type === 'months') {
      this.#month += amount
    }
    if (type === 'years') {
      this.#year += amount
    }
  }

  get day() {return this.#day}
  get month() {return this.#month}
  get year() {return this.#year}

  set day(value) {
    if (value >= 0 && value <= 31 ){
      this.#day = value
    }

  }
}

const myDate = new MyDate(2021,  7 , 17)
console.log(myDate.day)
myDate.day = 40
console.log(myDate.day)
console.log(myDate.month)
console.log(myDate.year)

console.log(myDate.printFormat())
export { MyDate }

Ronaldo Delgado

student•

me gusto este video se me ocurre muchas opciones para usarlo

Oscar Adrián Martínez Cavazos

student•

Hola a todos espero se encuentren genial y esten teniendo un excelente dia de code. . Me gustaria hacer una pequeña observacion de manera constructiva. Creo que para comenzar a ver el curso de POO en typescript se debió haber visto ya en su momento el curso de POO en JS, sin embargo, tengo un sentimiento de que se estan explicando muchas mas cosas de la POO en js que en TS y al final del día para eso sirve la sección en los cursos de los conocimientos previos necesarios y asi no tener que repetir todo. . OJO... Yo entiendo que en ocasiones hay que explicar algunas cosas para dar contexto al aprender pero creo que en este curso se les fue un poco de las manos este tema. . Por último me gustaria aclarar y recordar que como dije al inicio, es una opinion constructiva para mejorar la plataforma y a pesar de eso me encanta ya que todos los profesores incluyendo a Nico son increibles y siempre dan lo mejor de ellos para que podamos aprender. . Todos cometemos errores :)

carlos pino

student•

hola, en mi caso queria aprender sobre las bases de la poo pero al mismo tiempo sobre el tipado de ts y es una maravilla hacer un 2x1. ya qeu me ahorro el tiempo del otro curso y puedo por ejemplo reforzar m'as bien los principios de SOLID.

Oscar Adrián Martínez Cavazos

student•

@carlosap928, Hola Carlos si enteindo tu punto, me parece buena la idea pero aun asi sigo considerando que las clases son un poco extendidas, tal vez hacer los cursos de manera más modular sea una buena idea. . De todas formas aprendí mucho y los cursos y los profesores son geniales!

Carlos Ponce

student•

Desde ECMAscript 13 esta disponible private en js vanilla, es usa con el signo hash(#)

get #PRIVATE_GETTER() { return //... }
#PRIVATE_METHOD(a: string): string[] { return a.split(" ") }

Solo puede acceder a ellos desde la clase, en VS code esta un poco bug porque los muestra fuera de la clase, pero es porque es literal nuevo, no lleva un año, si lo quieren usar deben de poner 13 en la versión de ECMAScript

la data: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Private_class_fields

Andrés Felipe Eslava Zuluaga

student•

// Es aconsejable proteger la clase. Asi, quien utilice la clase no podrá modificar las propiedades internas de la clase

// private no me permite modificar propiedades externamente.
// private me permite entonces **encapsular** y **proteger** para tener solamente **acceso interno**