Getters

Les comparto mis apuntes. 😄

Get

Con get podemos acceder a una propiedad con un alcance privado, podemos obtener los datos de esa propiedad pero no modificarlos o mutarlos.

Lo podemos acceder como si fuese una propiedad más de la instancia.

Por definición, todos los getters tienen que retornar algo.

Sintaxis

class ClassName {
		constructor () {
				statements
		}

		get methodName () {
				statements
				return something;
		}
}

Una aclaración

En lo particular, prefiero utilizar el private class fields (#) para poder declarar propiedades privadas, ya que es nativo de JavaScript y además que realmente hace un encapsulamiento de las propiedades al momento de llevar el código a producción. Cabe agregar que con este nos podemos evitar realizar el uso de underscore (_) y también tener problemas con los nombres de los métodos getters y setters.

La estructura del código depende del proyecto y del equipo, pero esa es forma preferida de emplear lo mejor de ambos mundos, tanto de JavaScript como de TypeScript.

Código de la clase

Código adaptado por mí.

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

export class MyDate {
    #day: number;

    constructor (
        public year: number = 1993,
        public month: number = 7,
        day: number = 1
    ) {
        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): void {
        if (type === 'day') this.#day += amount;
        if (type === 'month') this.month += amount;
        if (type === 'year') this. year += amount;
    }

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

    get day (): number {
        // Code
        return this.#day;
    }

    get isLeapYear (): boolean {
        const { year } = this;
        if (year % 4 === 0) return false;
        if (year % 100 === 0) return true;
        return year % 4 === 0;
    }

    // get myReturn () {

    // } // Error:
}

const myDate = new MyDate(2020);
const myDate2 = new MyDate(2000);
const myDate3 = new MyDate(2001);
const myDate4 = new MyDate(2004);

myDate.day;
console.log('My Date:',myDate.day, myDate.isLeapYear);
console.log('My Date 2:',myDate2.day, myDate2.isLeapYear);
console.log('My Date 3:',myDate3.day, myDate3.isLeapYear);
console.log('My Date 4:',myDate4.day, myDate4.isLeapYear);

jajaja Pensé que era el único que buscaba en internet algunos algoritmos ya hechos. Lo importante es saber para qué usarlo en nuestras soluciones. (min 7:22).
Like si has hecho lo mismo.

Getters: Forma de acceder a variables privadas

// un getter internamente es una función, pero fuera de clase es un propiedad: no se ejecuta.
||||||||||||||||||||||||||||||||||||||
A 'get' accessor must return a value.
||||||||||||||||||||||||||||||||||||||

aca cree un get personal, que define el mes con nombre en vez de con numero

  get exampleVarGet() {
        const months = ['january', 'february', 'march', 'april', 'may', 'june', 'jule', 'august', 'september', 'october', 'november', 'december']        
        return months[this.month]
    }

para que pueda llamarse como una variable de la clase

console.log(year1.exampleVarGet)

Acá el mismo método pero usando operador ternario:

get isLeapYear(): boolean {
    return (
      (this.year % 400 === 0 || this.year % 100 !== 0) && this.year % 4 == 0
    );
  }

Getters

Los getters NO pueden ser void.

export class MyDate {
  constructor(
    private _year: number = 1998,
    private _month: number = 1,
    private _day: number = 1
  ) {}

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

  get isLeapYear(): boolean {
    if (this._year % 400 === 0) return true
    if (this._year % 100 === 0) return false

    return this._year % 4 === 0;
  }
}

const myDate = new MyDate(2024, 1, 1);
console.log(myDate.day)
console.log(myDate.isLeapYear) //* parece una propiedad pero es un método

A las variables que están globales o las que están definidas en el constructor se le llaman: Atributos y el estándar o convención es tenerla con un _. Sin embargo, cuando encapsulamos ese mismo atributo se le llama Propiedad. Solo quería aportar eso por si se confunden no es lo mismo, mayormente los atributos son privados para realizar “x” cosa en los métodos.

para mas info consulta encapsulamiento. getter y setter.
la teoria es necesaria para apropiar mejor el tema

Aquí el algoritmo

get isLeapYear(): boolean{
    if(this.year % 400 === 0) return true;
    if(this.year % 100 === 0) return false;
    return this.year % 4 === 0;
 }

Los getters no pueden recibir parametros
🤔
🤔
🤔

te amo ts