Proprietăți și clase pentru citire

Constante

Pe lângă variabile, în interiorul unei clase se pot defini constante. Valorile constantelor sunt stabilite direct la momentul declarării:

<?php
class Person
{
   public $name, $age;
   const maxAge = 110; // constanta maxAge
   function __construct($name, $age)
   {
       $this->name = $name;
       if($age > Person::maxAge) $age = Person::maxAge;
       $this->age = $age;
   }
   function print()
   {
       echo "Nume: $this->name Vârstă: $this->age<br>";
   }
}

$tom = new Person("Tom", 38);
$bob = new Person("Bob", 138);
$tom->print();
$bob->print();
// accesarea unei constante statice
echo "Vârsta maximă: " . Person::maxAge . "<br>";
?>

Aici, în clasa Person este definită constanta maxAge, care are valoarea 110. Aceasta reprezintă vârsta maximă posibilă. În constructor, folosim această constantă - dacă vârsta transmisă este mai mare, atunci o limităm la maxAge. Pentru a accesa constanta clasei în interiorul și în afara clasei, se folosește sintaxa:

nume_clasă::nume_constanta

De exemplu:

Person::maxAge

Rezultatul în browser:

Nume: Tom Vârstă: 38
Nume: Bob Vârstă: 110
Vârsta maximă: 110

Este de menționat că începând cu versiunea PHP 8.3, pentru o constantă se poate stabili explicit tipul de date:

const int maxAge = 110; // constanta maxAge are tipul int

Proprietăți pentru citire

Uneori sunt necesare proprietăți care nu ar trebui să-și schimbe valoarea. Începând cu versiunea 8.1, PHP a adăugat posibilitatea de a defini proprietăți pentru citire. Aceste proprietăți sunt precedate de cuvântul cheie readonly.

Acest lucru garantează că valoarea proprietății nu va fi schimbată. Acestor proprietăți li se poate atribui o valoare o singură dată în interiorul clasei în care sunt definite (de obicei, acest lucru se face în constructorul clasei).

Aceste proprietăți diferă de constante prin faptul că pot fi stabilite în constructor. Să vedem un exemplu simplu:

<?php
class Person
{
   public readonly string $name;
   public $age;
     
   public function __construct($name, $age)
   {
       $this->name = $name;
       $this->age = $age;
   }
}
$tom = new Person("Tom", 38);
$tom->age = 22; // valoarea proprietății $age poate fi schimbată

// $tom->name = "Bob"; // valoarea proprietății $name nu poate fi schimbată, deoarece este doar pentru citire

echo "Name: $tom->name"; // putem obține valoarea proprietății $name
?>

Aici este definită clasa Person, care are două proprietăți. Proprietatea $name este definită ca o proprietate pentru citire cu modificatorul readonly:

public readonly string $name;

În plus, dacă o proprietate este definită ca proprietate doar pentru citire, trebuie să i se specifice explicit tipul de date. Astfel, în acest caz, proprietatea name reprezintă tipul string.

În constructor, proprietăților $name și $age li se atribuie valori inițiale. Totuși, după aceasta, nu vom putea schimba valoarea proprietății $name, nici măcar în interiorul aceleași clase. Putem doar să obținem valoarea sa. Dacă încercăm să-i schimbăm valoarea, de exemplu:

$tom->name = "Bob";

Vom întâmpina o eroare:

Fatal error: Uncaught Error: Cannot modify readonly property Person::$name

Este de menționat că proprietăților pentru citire nu li se poate stabili o valoare implicită la momentul definirii, deoarece în acest caz ar fi echivalentă cu o constantă:

class Person
{
   public readonly string $name = "undefined"; // ! Eroare
   public $age = 18; // Ok
}

Constructorul nu este singurul loc unde putem stabili valoarea unei proprietăți pentru citire - poate fi orice metodă a clasei. De exemplu, putem face astfel:

<?php
class Person
{
   public readonly string $name;
   public $age;
   public function init(){
       $this->name = "Bob";
   }
}
$tom = new Person();
$tom->init(); // inițializarea proprietății $name
echo "Name: $tom->name"; // Name: Bob
?>

Aici, valoarea este stabilită în metoda init(). Totuși, în acest caz, ne putem confrunta cu problema că proprietatea $name ar putea fi accesată înainte de apelarea metodei init(), ceea ce ar duce la o eroare. De aceea, constructorul este cel mai optim loc pentru inițializarea proprietăților pentru citire.

Clase pentru citire

Începând cu versiunea 8.2, PHP permite definirea claselor pentru citire. O astfel de clasă este definită cu ajutorul cuvântului cheie readonly.

Proprietățile acestor clase sunt implicit proprietăți doar pentru citire. Acest lucru garantează că niciuna dintre proprietățile obiectului nu va putea să-și schimbe valoarea. De exemplu, următoarea clasă:

readonly class Person
{
   public string $name;
   public int $age;
   public function __construct($name, $age)
   {
       $this->name = $name;
       $this->age = $age;
   }
}

va fi echivalentă cu următoarea:

class Person
{
   public readonly string $name;
   public readonly int $age;
   public function __construct($name, $age)
   {
       $this->name = $name;
       $this->age = $age;
   }
}

În plus, pentru proprietățile clasei pentru citire trebuie să specificăm explicit tipul de date. De asemenea, la moștenire, clasa derivată trebuie să fie și ea o clasă doar pentru citire.

În rest, clasele pentru citire sunt utilizate la fel ca și clasele obișnuite:

<?php
readonly class Person
{
   public function __construct(public string $name, public int $age)
   {}
}
$tom = new Person("Tom", 38);
// obținerea valorilor proprietăților
echo "Name: $tom->name Age: $tom->age"; // Name: Tom Age: 38
// modificarea valorilor proprietăților nu este permisă
// $tom->name = "Tomas"; // ! eroare
?>