JavaScript, un limbaj versatil, permite crearea de programe care adoptă diverse abordări: funcțională, orientată pe obiecte și imperativă.
Pentru a susține modelul orientat pe obiecte, JavaScript include clase. Înțelegerea lor fiind fundamentală, acest articol oferă o explorare detaliată a conceptului de clase în JavaScript și a modului în care acestea pot fi utilizate.
Ce sunt clasele în JavaScript?
În programarea orientată pe obiecte, sistemele sunt modelate ca ansambluri de obiecte care interacționează. Obiectele stochează informații sub formă de proprietăți și efectuează acțiuni prin metodele lor. O clasă definește proprietățile și metodele comune obiectelor de același tip, servind astfel drept șablon pentru acestea.
Terminologii esențiale ale claselor
Pentru a asigura o înțelegere comună, vom explica termenii cheie legați de clase. Dacă sunteți deja familiarizat cu programarea orientată pe obiecte, puteți trece direct la secțiunea următoare.
❇️ O clasă este un plan pentru crearea de obiecte, un model de bază pentru instanțe de același tip. Procesul de creare a unui obiect pe baza șablonului oferit de clasă este denumit instanțiere.
❇️ Un membru al clasei este orice element constitutiv al clasei, divizat în două categorii principale: metode și proprietăți.
❇️ O proprietate este un membru al clasei utilizat în principal pentru stocarea valorilor, care pot fi simple (numere, șiruri de caractere) sau complexe (obiecte, matrice).
❇️ Unele proprietăți, numite proprietăți private, sunt accesibile doar în interiorul clasei, în timp ce altele, proprietăți publice, sunt accesibile atât în interiorul, cât și în exteriorul clasei.
❇️ O metodă este o funcție definită în cadrul unei clase, având acces la proprietățile publice și private ale acesteia. Similar proprietăților, metodele pot fi publice sau private.
❇️ Anumite metode, cunoscute sub numele de getters și setters, facilitează interacțiunea codului extern cu proprietățile clasei. Getters extrag valorile proprietăților, în timp ce setterii le modifică.
❇️ Membrii statici, accesibili doar la nivelul clasei, nu pot fi accesați prin instanțele clasei. Pe de altă parte, membrii non-statici sunt accesibili exclusiv prin instanțele clasei, ceea ce necesită instanțierea clasei înainte de a putea fi utilizați.
La instanțierea unei clase, se apelează o metodă specială, funcția constructor, responsabilă de configurarea proprietăților instanței.
Explicarea instanțierii unei clase
În JavaScript, instanțierea unei clase se realizează utilizând cuvântul cheie „new” urmat de numele clasei. De exemplu, pentru a instanția clasa Array:
const myArr = new Array()
Crearea de clase în JavaScript
Această secțiune va prezenta modul de creare a unei clase care încorporează toate conceptele discutate în secțiunea Terminologie. Vom ilustra acest proces printr-o serie de exemple, fiecare bazându-se pe cel anterior.
Declararea unei clase goale
Pentru a declara o clasă în JavaScript, folosim cuvântul cheie „class” urmat de un nume, iar apoi definim corpul clasei între acolade. Acesta conține toți membrii clasei.
Un exemplu de declarație a unei clase cu un corp gol:
class Dog {
}
Această clasă poate fi instanțiată și afișată în consolă:
const pet = new Dog; console.log(pet);
Crearea proprietăților publice
Proprietățile publice sunt definite printr-un identificator și o valoare opțională.
class Dog {
name = "Roy";
age;
}
În acest exemplu, „name” este inițializat cu un șir, iar „age” este definit fără o valoare inițială.
const pet = new Dog(); console.log(pet.name); console.log(pet.age);
Definirea metodelor publice
Metodele pot fi adăugate în interiorul corpului clasei, fiind definite similar funcțiilor, cu excepția cuvântului cheie „function”.
class Dog {
name = "Roy";
age;
walk () {
console.log("Walking");
}
}
În exemplul de mai sus, am definit metoda „walk”. Fiecare instanță a clasei „Dog” va include această metodă.
const pet = new Dog(); pet.walk();
Accesarea proprietăților din metode
În general, proprietățile unui obiect sunt accesate folosind operatorul punct. De exemplu, pentru a accesa proprietatea „name” a unui obiect numit „person”, am folosi „person.name”.
person.name
Totuși, pentru a accesa o proprietate din interiorul obiectului, folosim cuvântul cheie „this” în locul numelui obiectului. De exemplu:
this.name
„this” face referire la obiectul curent. Pentru a accesa proprietățile clasei din metode, folosim sintaxa „this.nume_proprietate”.
Crearea proprietăților private
Pentru a face proprietățile „name” și „age” private, vom redefini clasa astfel:
class Dog {
#name = "Roy";
#age;
walk () {
console.log("Walking");
}
}
Proprietățile private sunt identificate printr-un simbol „#”. Încercarea de a le accesa direct va genera erori.
const dog = new Dog(); dog.#name
Crearea metodelor Getter și Setter
Acum, proprietățile „name” și „age” ale clasei sunt private, fiind accesibile doar prin metodele interne. Pentru a permite accesul la aceste proprietăți din exteriorul clasei, definim metode getter și setter. Să exemplificăm acest lucru pentru proprietatea „name”:
class Dog {
#name = "Roy";
#age;
get name () {
return this.#name;
}
set name (value) {
this.#name = value;
}
walk () {
console.log("Walking");
}
}
Cu clasa definită, putem modifica numele și îl putem afișa cu următorul cod:
const pet = new Dog(); // Setting the name pet.name = "Rex"; // Getting the name console.log(pet.name);
Crearea de metode private
Similar proprietăților private, metodele private sunt marcate cu un simbol „#”. Declarația unei metode private arată astfel:
class Dog {
#name = "Roy";
#age;
get name () {
return this.#name;
}
set name (value) {
this.#name = value;
}
#increaseAge() {
this.#age ++;
}
#decreaseAge () {
this.#age --;
}
walk () {
console.log("Walking");
}
}
Încercarea de a accesa aceste metode din exteriorul clasei nu va funcționa.
const pet = new Dog(); pet.#increaseAge();
Crearea unei metode de constructor
Metoda constructor este apelată automat la instanțierea unei clase și este folosită pentru a inițializa proprietățile. În exemplul următor, vom inițializa proprietățile „age” și „name” folosind argumentele primite la instanțiere:
class Dog {
#name;
#age;
constructor (name = "Dog", age = 0) {
this.#name = name;
this.#age = age;
}
get name () {
return this.#name;
}
set name (value) {
this.#name = value;
}
#increaseAge() {
this.#age ++;
}
#decreaseAge () {
this.#age --;
}
walk () {
console.log("Walking");
}
}
La instanțierea clasei, putem furniza un nume și o vârstă:
const pet = new Dog('Roy', 3);
console.log(pet.name);
Crearea proprietăților și metodelor statice
Membrii statici pot fi accesați fără a instanția clasa. Vom crea o proprietate statică și o metodă:
class Dog {
#name;
#age;
static genus = "Canis";
constructor (name = "Dog", age = 0) {
this.#name = name;
this.#age = age;
}
static bark() {
console.log("Woof");
}
get name () {
return this.#name;
}
set name (value) {
this.#name = value;
}
#increaseAge() {
this.#age ++;
}
#decreaseAge () {
this.#age --;
}
walk () {
console.log("Walking");
}
}
Proprietatea statică și metoda pot fi accesate direct, fără a instanția clasa:
console.log(Dog.genus); Dog.bark();
Moștenirea
Clasele pot moșteni proprietăți de la alte clase. O clasă care moștenește membri dintr-o altă clasă se numește superclasă, iar clasa de la care moștenește este clasa de bază sau subclasa.
Pentru a crea o superclasă în JavaScript, folosim cuvântul cheie „extends”. Iată un exemplu în care moștenim din clasa „Dog”:
class Rottweiler extends Dog {
constructor (name, age) {
super(name, age);
this.breed = 'rottweiler';
}
}
În constructorul superclasei, am apelat funcția „super”, care face referire la constructorul clasei de bază, transmițând numele și vârsta ca argumente.
const myPet = new Rottweiler(); console.log(myPet);
Concluzie
În acest articol, am examinat conceptul de clase în JavaScript, incluzând membrii pe care îi pot deține și diversele categorii de membri. Am ilustrat aceste concepte prin exemple practice.
Vă invităm să explorați și întrebările frecvente în interviurile despre programarea orientată pe obiecte.