Care sunt metodele magice PHP?

Question

Accepted Answer

**Metodele magice** sunt metode speciale (prefixate cu `__`) pe care PHP le apelează automat în răspuns la anumite acțiuni asupra unui obiect — cum ar fi accesarea unei proprietăți nedefinite, apelarea unei metode nedefinite, sau convertirea unui obiect la string. Ele vă permit să interceptați și să personalizați comportamentul obiectelor.

## Constructorul și metodele comune ale ciclului de viață

```php
<?php
class User {
    public function __construct(string $name) { /* runs on `new User(...)` */ }
    public function __destruct() { /* runs when the object is destroyed */ }
}
```

## Suprașarcina proprietăților: __get și __set

```php
class Container {
    private array $data = [];

public function __get($name) {            // called on reading an INACCESSIBLE/undefined property
        return $this->data[$name] ?? null;
    }
    public function __set($name, $value) {     // called on writing one
        $this->data[$name] = $value;
    }
    public function __isset($name): bool { return isset($this->data[$name]); }
}

$c = new Container();
$c->foo = "bar";    // triggers __set('foo', 'bar')
echo $c->foo;        // triggers __get('foo') → "bar"
```

`__get`/`__set` interceptează accesul la proprietăți care nu există sau nu sunt accesibile — activând proprietăți dinamice (folosite de ORM-uri, obiecte de configurare).

## Suprașarcina metodelor: __call și __callStatic

```php
class Api {
    public function __call($method, $args) {    // called for UNDEFINED method calls
        return $this->request($method, $args);   // e.g. dynamic API methods
    }
    public static function __callStatic($method, $args) { /* static version */ }
}
$api->getUsers();   // no getUsers() method → __call('getUsers', [])
```

`__call`/`__callStatic` interceptează apeluri la metode nedefinite — folosite pentru API-uri fluide/dinamice (ex. Laravel's query builder, facades).

## __toString și __invoke

```php
class Money {
    public function __construct(private float $amount) {}
    public function __toString(): string {        // when the object is used as a string
        return '$' . number_format($this->amount, 2);
    }
}
echo new Money(9.5);   // "$9.50" — __toString called automatically

class Multiplier {
    public function __invoke($x) { return $x * 2; }   // makes the object CALLABLE
}
$double = new Multiplier();
$double(5);   // 10 — __invoke called
```

## De ce este important

Metodele magice sunt o caracteristică importantă a PHP pentru personalizarea comportamentului obiectelor, și înțelegerea lor este valoroasă atât pentru a le folosi în mod adecvat, cât și — mai ales — pentru a înțelege cum frameworkurile PHP obțin „magia

Care sunt metodele magice PHP?

Constructorul și metodele comune ale ciclului de viață

Suprașarcina proprietăților: get și set

Suprașarcina metodelor: call și callStatic

toString și invoke

De ce este important