Câmpuri și metode statice

Cu excepția câmpurilor și metodelor obișnuite, o clasă poate defini câmpuri și metode statice. Spre deosebire de câmpurile/proprietățile și metodele obișnuite, acestea se referă la întreaga clasă, nu la un obiect individual.

Câmpuri statice

Câmpurile statice stochează starea întregii clase, nu a unui obiect individual. Înaintea numelui câmpului se adaugă cuvântul cheie static. De exemplu:

class Person{
   static retirementAge = 65;
   constructor(name, age){
       this.name = name;
       this.age = age;
   }
   print(){
       console.log(`Nume: ${this.name}  Varsta: ${this.age}`);
   }
}

console.log(Person.retirementAge); // 65
Person.retirementAge = 62;
console.log(Person.retirementAge); // 62

Aici, în clasa Person, este definit un câmp static retirementAge, care stochează vârsta condiționată de pensionare:

static retirementAge = 65;

Acest câmp se referă la întreaga clasă Person și descrie starea întregii clase în ansamblu. De obicei, există o vârstă comună de pensionare, valabilă pentru toți (fără a lua în considerare cazuri individuale pentru diferite profesii). Prin urmare, pentru a accesa un câmp static, se folosește numele clasei, nu numele unui obiect anume. Utilizând numele clasei, putem obține sau seta valoarea sa:

Person.retirementAge = 62;
console.log(Person.retirementAge); // 62

În acest context, nu putem să ne referim la aceste câmpuri în metodele non-statice și în constructorul clasei folosind cuvântul cheie this, așa cum este prezentat mai jos:

print(){
       console.log(`Nume: ${this.name}  Varsta: ${this.age}`);
       console.log(`Varsta pensionara: ${this.retirementAge}`);   // nu se poate face referire la un câmp static prin intermediul cuvântului cheie this
}

Dacă dorim totuși să ne referim la câmpurile și metodele statice în interiorul metodelor non-statice și în constructorul clasei, trebuie să folosim, din nou, numele clasei:

print(){
   console.log(`Nume: ${this.name}  Varsta: ${this.age}`);
   console.log(`Varsta pensionara: ${Person.retirementAge}`);
}

Metodele statice

Metodele statice, la fel ca și câmpurile statice, sunt definite pentru întreaga clasă în ansamblu, nu pentru un obiect individual. Pentru a le defini, înaintea numelui metodei se adaugă operatorul static. De exemplu:

class Person{
   constructor(name, age){
       this.name = name;
       this.age = age;
   }
   print(){
       console.log(`Nume: ${this.name}  Varsta: ${this.age}`);
   }
   static printClassInfo(){
       console.log("Clasa Person reprezintă o persoană");
   }
}
Person.printClassInfo();    // Clasa Person reprezintă o persoană.

Aici este definit un metodă statică printClassInfo() în cadrul căreia, în scopul simplificării, se afișează un mesaj. Spre deosebire de metodele obișnuite non-statice, care definesc comportamentul unui obiect, metodele statice definesc comportamentul pentru întreaga clasă. Prin urmare, pentru a le apela, se utilizează numele clasei, nu numele obiectului:

Person.printClassInfo();

Deoarece metoda statică se referă la clasa în ansamblu, nu la un obiect, nu putem să ne referim în ea la câmpurile/proprietățile și metodele non-statice ale obiectului, precum în exemplul de mai jos:

class Person{
   constructor(name, age){
       this.name = name;
       this.age = age;
   }
   print(){
       console.log(`Nume: ${this.name}  Varsta: ${this.age}`);
   }
   static printAge(){  console.log(this.age); }    // Pentru o metodă statică, nu există un `this.age`
}
Person.printAge();  // undefined

Dacă este necesar să ne referim la proprietățile unui obiect într-o metodă statică, putem defini un parametru în metodă, prin intermediul căruia obiectul va fi transmis către metodă:

class Person{
   constructor(name, age){
       this.name = name;
       this.age = age;
   }
   static print(person){
       console.log(`Nume: ${person.name}  Varsta: ${person.age}`);
   }
}
const tom = new Person("Tom", 37);
const bob = new Person("Bob", 41);
Person.print(tom);  // Tom 37
Person.print(bob);  // Bob 41

Totuși, putem utiliza cuvântul cheie `this` în metodele statice pentru a face referire la câmpurile și alte metode statice.

class Person {
   static retirementAge = 65;
   
   constructor(name, age) {
       this.name = name;
       this.age = age;
   }

   print() {
       console.log(`Nume: ${this.name}  Varsta: ${this.age}`);
   }

   static calculateRestAges(person) {
       // Daca varsta curenta este mai mica decat varsta de pensionare
       if (this.retirementAge > person.age) {
           const restAges = this.retirementAge - person.age;
           console.log(`Pana la pensie au mai ramas ${restAges} ani`);
       } else {
           console.log("Sunteti deja la pensie");
       }
   }
}

const tom = new Person("Tom", 37);
Person.calculateRestAges(tom);      // Pana la pensie au mai ramas 28 ani

const bob = new Person("Bob", 71);
Person.calculateRestAges(bob);      // Sunteti deja la pensie

Aici este definită metoda statică calculateRestAges(), care calculează câți ani mai sunt până la pensie pentru o anumită persoană. Pentru a face acest calcul, se face referire la câmpul static retirementAge:

const restAges = this.retirementAge - person.age;

Câmpurile și metodele statice private

La fel ca și în cazul câmpurilor și metodelor obișnuite, câmpurile și metodele statice pot fi private. Astfel de câmpuri și metode sunt accesibile doar din alte metode statice ale clasei:

class Person {
   static #retirementAge = 65;

   constructor(name, age) {
       this.name = name;
       this.age = age;
   }

   print() {
       console.log(`Nume: ${this.name}  Varsta: ${this.age}`);
   }

   static calculateRestAges(person) {
       if (this.#retirementAge > person.age) {
           const restAges = this.#retirementAge - person.age;
           console.log(`Pana la pensie au mai ramas ${restAges} ani`);
       } else {
           console.log("Sunteti deja la pensie");
       }
   }
}

// console.log(Person.#retirementAge);  // ! Eroare: campul retirementAge este privat
const tom = new Person("Tom", 37);
Person.calculateRestAges(tom);      // Pana la pensie au mai ramas 28 ani

const bob = new Person("Bob", 71);
Person.calculateRestAges(bob);      // Sunteti deja la pensie

În acest exemplu, câmpul static `retirementAge` este privat. Acum, se poate accesa doar în cadrul metodelor statice ale clasei.