Welke magische methoden bestaan er in PHP en hoe…

Magische methoden in PHP zijn speciale methoden die beginnen met dubbele onderstreping (bijvoorbeeld __construct), die automatisch worden aangeroepen in bepaalde situaties.

De belangrijkste magische methoden en hun gebruik:

__construct(): Wordt aangeroepen bij het maken van een object van een klasse. Gebruikt voor het initialiseren van objecteigenschappen en het uitvoeren van eerste acties.

<?php
class MyClass {
    public function __construct() {
        echo "Object gemaakt!";
    }
}
$obj = new MyClass(); // Zal "Object gemaakt!" tonen

__destruct(): Wordt aangeroepen bij het vernietigen van een object (bijvoorbeeld wanneer het script eindigt of het object uit het geheugen wordt verwijderd). Gebruikt voor het vrijmaken van bronnen (sluiten van bestanden, verbindingen met databases).
```
<?php
class MyClass {
    public function __destruct() {
        echo "Object vernietigd!";
    }
}
$obj = new MyClass();
unset($obj); // Zal "Object vernietigd!" tonen
```

__call(string $name, array $arguments): Wordt aangeroepen bij het proberen aanroepen van een niet-beschikbare of niet-bestaande methode in de context van een object. $name bevat de naam van de methode, $arguments is een array van argumenten.

<?php
class MyClass {
    public function __call($name, $arguments) {
        echo "Niet-beschikbare methode '{$name}' aangeroepen met argumenten: " . implode(', ', $arguments);
    }
}
$obj = new MyClass();
$obj->nonExistentMethod('arg1', 'arg2'); // Zal "Niet-beschikbare methode 'nonExistentMethod' aangeroepen met argumenten: arg1, arg2" tonen

__callStatic(string $name, array $arguments): Wordt aangeroepen bij het proberen aanroepen van een niet-beschikbare of niet-bestaande statische methode in de context van een klasse. Vergelijkbaar met __call, maar voor statische aanroepen.

<?php
class MyClass {
    public static function __callStatic($name, $arguments) {
        echo "Niet-beschikbare statische methode '{$name}' aangeroepen met argumenten: " . implode(', ', $arguments);
    }
}
MyClass::nonExistentStaticMethod('static_arg'); // Zal "Niet-beschikbare statische methode 'nonExistentStaticMethod' aangeroepen met argumenten: static_arg" tonen

__get(string $name): Wordt aangeroepen bij het proberen opvragen van een niet-beschikbare of niet-bestaande eigenschap in de context van een object. $name bevat de naam van de eigenschap.

<?php
class MyClass {
    private $data = ['key' => 'value'];
    public function __get($name) {
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];
        }
        return null;
    }
}
$obj = new MyClass();
echo $obj->key; // Zal "value" tonen
echo $obj->nonExistentKey; // Zal een lege string tonen (afhankelijk van de geretourneerde waarde null)

__set(string $name, mixed $value): Wordt aangeroepen bij het proberen een waarde in te stellen voor een niet-beschikbare of niet-bestaande eigenschap in de context van een object. $name bevat de naam van de eigenschap, $value is de toe te wijzen waarde.

<?php
class MyClass {
    private $data = [];
    public function __set($name, $value) {
        $this->data[$name] = $value;
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
$obj->newKey = 'newValue';
print_r($obj->getData()); // Zal Array ( [newKey] => newValue ) tonen

__isset(string $name): Wordt aangeroepen bij het gebruik van isset() of empty() op een niet-beschikbare of niet-bestaande eigenschap in de context van een object. Geeft een boolean terug.

<?php
class MyClass {
    private $data = ['present' => 'value'];
    public function __isset($name) {
        return array_key_exists($name, $this->data);
    }
}
$obj = new MyClass();
var_dump(isset($obj->present));     // Zal bool(true) tonen
var_dump(isset($obj->absent));      // Zal bool(false) tonen

__unset(string $name): Wordt aangeroepen bij het gebruik van unset() op een niet-beschikbare of niet-bestaande eigenschap in de context van een object.

<?php
class MyClass {
    private $data = ['remove_me' => 'value_to_remove'];
    public function __unset($name) {
        if (array_key_exists($name, $this->data)) {
            unset($this->data[$name]);
            echo "Eigenschap '{$name}' verwijderd.\n";
        }
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
print_r($obj->getData());
unset($obj->remove_me); // Zal "Eigenschap 'remove_me' verwijderd." tonen en het element uit $data verwijderen
print_r($obj->getData());

__sleep(): Wordt aangeroepen vóór serialisatie van het object met serialize(). Moet een array van eigenschapsnamen retourneren die geserialiseerd moeten worden.

<?php
class MyClass {
    public $prop1 = 'value1';
    public $prop2 = 'value2';
    public function __sleep() {
        return ['prop1']; // Alleen prop1 serialiseren
    }
}
$obj = new MyClass();
$serialized = serialize($obj); // Zal alleen prop1 serialiseren
echo $serialized; // Zal ongeveer tonen O:7:"MyClass":1:{s:5:"prop1";s:6:"value1";}

__wakeup(): Wordt aangeroepen na deserialisatie van het object met unserialize(). Gebruikt voor het herstellen van verbindingen met databases of andere acties die nodig zijn na het herstellen van het object.

<?php
class MyClass {
    public $prop1;
    public $resource; // Stel dat dit een resource van een verbinding is
    public function __wakeup() {
        // Resource herstellen, bijvoorbeeld een databaseverbinding
        $this->resource = fopen('/tmp/my_file.txt', 'w'); // Voorbeeld
        echo "Object gewekt en resource hersteld!\n";
    }
    public function __sleep() {
        // In __sleep serialiseren we geen resource
        return ['prop1'];
    }
    public function __destruct() {
        if (is_resource($this->resource)) {
            fclose($this->resource);
            echo "Resource gesloten.\n";
        }
    }
}
$obj = new MyClass();
$obj->prop1 = 'deserialized value';
$serialized = serialize($obj);
unset($obj);

$deserialized_obj = unserialize($serialized); // Roept __wakeup() aan
var_dump($deserialized_obj->prop1);

__toString(): Wordt aangeroepen wanneer het object als string wordt gebruikt (bijvoorbeeld bij echo of concatenatie). Moet een stringrepresentatie van het object retourneren.

<?php
class MyClass {
    public $name = "MyObject";
    public function __toString() {
        return "Object van type MyClass met naam: " . $this->name;
    }
}
$obj = new MyClass();
echo $obj; // Zal "Object van type MyClass met naam: MyObject" tonen

__invoke(...): Wordt aangeroepen bij het proberen het object als functie aan te roepen. Kan elk aantal argumenten accepteren.

<?php
class MyCallableClass {
    public function __invoke(...$args) {
        echo "Object werd aangeroepen als functie met argumenten: " . implode(', ', $args);
    }
}
$obj = new MyCallableClass();
$obj('arg1', 123); // Zal "Object werd aangeroepen als functie met argumenten: arg1, 123" tonen

__set_state(array $properties): Wordt statisch aangeroepen voor klassen geëxporteerd met var_export(). Ontvangt een array van geëxporteerde eigenschappen. Moet een nieuw object van de klasse maken en teruggeven.

<?php
class MyClass {
    public $prop;
    public static function __set_state(array $properties) {
        $obj = new MyClass();
        $obj->prop = $properties['prop'];
        return $obj;
    }
}
$obj = new MyClass();
$obj->prop = 'exported value';
$exported = var_export($obj, true); // Exporteert het object
// $exported bevat code die een object herstelt, gebruikmakend van __set_state()
eval('$restored_obj = ' . $exported . ';');
var_dump($restored_obj); // Zal het MyClass-object tonen met de eigenschap 'exported value'

__debugInfo(): Wordt aangeroepen bij het gebruik van functies zoals var_dump() op het object. De methode moet een array retourneren met informatie over de eigenschappen die getoond moeten worden.

<?php
class MyClass {
    public $publicProp = 'public';
    private $privateProp = 'private';
    public function __debugInfo() {
        return ['publicProp' => $this->publicProp, 'private_info' => 'enkele details over privateProp'];
    }
}
$obj = new MyClass();
var_dump($obj); // Zal de informatie tonen die __debugInfo() retourneert

__clone(): Wordt aangeroepen na het klonen (clone) van een object. Wordt gebruikt voor diepe kopieën van interne objecten of datastructuren.

<?php
class SubObject {
    public $value;
    public function __construct($value) {
        $this->value = $value;
    }
}
class MyClass {
    public $object;
    public $anotherProp;
    public function __construct() {
        $this->object = new SubObject('initial');
        $this->anotherProp = 'original';
    }
    public function __clone() {
        // Diepe kopie van de geneste objecten
        $this->object = clone $this->object;
    }
}
$obj = new MyClass();
$cloned_obj = clone $obj;

// Nu zijn $obj->object en $cloned_obj->object verschillende instanties van SubObject
$cloned_obj->object->value = 'modified';

var_dump($obj->object->value);       // Zal "initial" tonen
var_dump($cloned_obj->object->value); // Zal "modified" tonen

Tabel met korte beschrijving:

Methode	Beschrijving	Wordt aangeroepen bij...
`__construct()`	Constructor van de klasse.	Bij het maken van een nieuw exemplaar van de klasse.
`__destruct()`	Destructor van de klasse.	Bij het verwijderen van het object of het beëindigen van het script.
`__call()`	Afhandeling van niet-bestaande/niet-toegankelijke methoden van het object.	Bij het proberen aanroepen van een niet-beschikbare of niet-bestaande methode.
`__callStatic()`	Afhandeling van niet-bestaande/niet-toegankelijke statische methoden.	Bij het proberen aanroepen van een niet-beschikbare of niet-bestaande statische methode.
`__get()`	Afhandeling van het opvragen van niet-beschikbare/niet-bestaande eigenschappen.	Bij het opvragen van een niet-beschikbare of niet-bestaande eigenschap.
`__set()`	Afhandeling van het instellen van niet-beschikbare/niet-bestaande eigenschappen.	Bij het instellen van een niet-beschikbare of niet-bestaande eigenschap.
`__isset()`	Afhandeling van `isset()` of `empty()` voor eigenschappen.	Bij het gebruik van `isset()` of `empty()` op een niet-beschikbare of niet-bestaande eigenschap.
`__unset()`	Afhandeling van `unset()` voor eigenschappen.	Bij het gebruik van `unset()` op een niet-beschikbare of niet-bestaande eigenschap.
`__sleep()`	Voorbereiding op serialisatie.	Bij het aanroepen van `serialize()` voor het object.
`__wakeup()`	Post-verwerking na deserialisatie.	Bij het aanroepen van `unserialize()` voor het object.
`__toString()`	Stringrepresentatie van het object.	Bij gebruik van het object als string (bijvoorbeeld bij `echo`).
`__invoke()`	Aanroep van het object als functie.	Bij het proberen aanroepen van het object als functie.
`__set_state()`	Aanmaken van een object na export met `var_export()`.	Bij het evalueren van code die is geëxporteerd met `var_export()`.
`__debugInfo()`	Informatie voor debug-functies (`var_dump()`).	Bij het aanroepen van `var_dump()` voor het object.
`__clone()`	Post-klonering verwerking.	Bij het aanroepen van `clone` voor het object.

Welke magische methoden bestaan er in PHP en hoe worden ze gebruikt?