Contenido del curso
Fundamentos de POO
POO Avanzada
Asincronismo y consumo de APIs
Genéricos
Próximos pasos
Acceso privado
Contenido del curso
Miguel Angel Reyes Moreno
Juan David Reyes
Reinaldo Mendoza
Axel Enrique Galeed Gutierrez
Andrés Felipe Eslava Zuluaga
Axlin Miranda
Brahyan Antonio Martinez Madera
Jordy Mairena Montoya
Eduardo Robles
Diego Delgado
William Cortes
Ivan David Martinez Baron
Jesús Patricio Pereira Matus
Dario Mendoza
Vladimir Farrera Vera
fabio andres zamora osorio
Brahyan Antonio Martinez Madera
Sergio Noriega
Christian Armando Consuelo Mayén
Ulqernesh Karvenae
Ronaldo Delgado
Oscar Adrián Martínez Cavazos
carlos pino
Oscar Adrián Martínez Cavazos
Carlos Ponce
Andrés Felipe Eslava Zuluaga
Sé que no es el enfoque del curso, pero es necesario mencionarlo para mejorar el inglés. No se pronuncia 'priveit', se pronuncia 'praivet'
es importante el ingles es indispensable, gracias!
No se porque ese error es tan común, al principio no sabia que decía hasta que lo escribió, :D
¿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}`; // } }
Excelente dato
Excelente información, no conocía que se podía utilizar el símbolo # para también tratarlo como privado, gracias por compartirlo
Es magico que cuando aprendes esto, no sabes como trabajaste sin ello antes, TS💙
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);
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"); }
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.
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
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.
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
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.
y el "protected" como se usa?
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?
Si de hecho JS se inspiro en TS para hacerlo:
desde la version 3.8.
En cambio javascript 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
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
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*}`; }
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 }
me gusto este video se me ocurre muchas opciones para usarlo
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 :)
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.
@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!
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
// 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**