Welche magischen Methoden gibt es in PHP und wie…

Mächtige Methoden in PHP sind spezielle Methoden, die mit zwei Unterstrichen beginnen (z.B. __construct) und in bestimmten Situationen automatisch aufgerufen werden.

Die wichtigsten magischen Methoden und ihre Verwendung:

__construct(): Wird beim Erstellen eines Objekt der Klasse aufgerufen. Wird verwendet, um Eigenschaften des Objekts zu initialisieren und Anfangsaktionen durchzuführen.

<?php
class MyClass {
    public function __construct() {
        echo "Objekt erstellt!";
    }
}
$obj = new MyClass(); // Gibt "Objekt erstellt!" aus

__destruct(): Wird beim Zerstören des Objekts aufgerufen (z.B. wenn das Skript endet oder das Objekt aus dem Speicher entfernt wird). Wird verwendet, um Ressourcen freizugeben (Dateien schließen, Verbindungen zu Datenbanken).
```
<?php
class MyClass {
    public function __destruct() {
        echo "Objekt zerstört!";
    }
}
$obj = new MyClass();
unset($obj); // Gibt "Objekt zerstört!" aus
```

__call(string $name, array $arguments): Wird aufgerufen, wenn versucht wird, eine nicht zugängliche oder nicht existente Methode im Kontext des Objekts aufzurufen. $name enthält den Methodennamen, $arguments ist ein Array der Argumente.

<?php
class MyClass {
    public function __call($name, $arguments) {
        echo "Nicht zugängliche Methode '{$name}' mit Argumenten: " . implode(', ', $arguments);
    }
}
$obj = new MyClass();
$obj->nonExistentMethod('arg1', 'arg2'); // Gibt "Nicht zugängliche Methode 'nonExistentMethod' mit Argumenten: arg1, arg2" aus

__callStatic(string $name, array $arguments): Wird aufgerufen, wenn versucht wird, eine nicht zugängliche oder nicht existente statische Methode im Kontext der Klasse aufzurufen. Ähnlich wie __call, aber für statische Aufrufe.

<?php
class MyClass {
    public static function __callStatic($name, $arguments) {
        echo "Nicht zugängliche statische Methode '{$name}' mit Argumenten: " . implode(', ', $arguments);
    }
}
MyClass::nonExistentStaticMethod('static_arg'); // Gibt "Nicht zugängliche statische Methode 'nonExistentStaticMethod' mit Argumenten: static_arg" aus

__get(string $name): Wird aufgerufen, wenn versucht wird, den Wert einer nicht zugänglichen oder nicht existierenden Eigenschaft im Kontext des Objekts zu erhalten. $name enthält den Eigenschaftsnamen.

<?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; // Gibt "value" aus
echo $obj->nonExistentKey; // Gibt eine leere Zeichenkette aus (abhängig vom Rückgabewert null)

__set(string $name, mixed $value): Wird aufgerufen, wenn versucht wird, den Wert einer nicht zugänglichen oder nicht existierenden Eigenschaft im Kontext des Objekts zu setzen. $name enthält den Eigenschaftsnamen, $value ist der zu setzende Wert.

<?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()); // Gibt Array ( [newKey] => newValue ) aus

__isset(string $name): Wird aufgerufen bei Verwendung von isset() oder empty() auf einer nicht zugänglichen oder nicht existierenden Eigenschaft im Kontext des Objekts. Gibt einen booleschen Wert zurück.

<?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));     // Gibt bool(true) aus
var_dump(isset($obj->absent));      // Gibt bool(false) aus

__unset(string $name): Wird aufgerufen bei Verwendung von unset() auf einer nicht zugänglichen oder nicht existierenden Eigenschaft im Kontext des Objekts.

<?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 "Eigenschaft '{$name}' entfernt.\n";
        }
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
print_r($obj->getData());
unset($obj->remove_me); // Gibt "Eigenschaft 'remove_me' entfernt." aus und entfernt das Element aus $data
print_r($obj->getData());

__sleep(): Wird vor der Serialisierung des Objekts mit serialize() aufgerufen. Muss ein Array der Eigenschaftsnamen zurückgeben, die serialisiert werden sollen.

<?php
class MyClass {
    public $prop1 = 'value1';
    public $prop2 = 'value2';
    public function __sleep() {
        return ['prop1']; // Nur prop1 serialisieren
    }
}
$obj = new MyClass();
$serialized = serialize($obj); // Nur prop1 serialisieren
echo $serialized; // Gibt ungefähr O:7:"MyClass":1:{s:5:"prop1";s:6:"value1";}

__wakeup(): Wird nach der Deserialisierung des Objekts mit unserialize() aufgerufen. Wird verwendet, um Verbindungen zu Datenbanken wiederherzustellen oder andere Aktionen nach der Wiederherstellung des Objekts durchzuführen.

<?php
class MyClass {
    public $prop1;
    public $resource; // Angenommen, dies ist eine Ressourcenverbindung
    public function __wakeup() {
        // Ressource wiederherstellen, z.B. eine Datenbankverbindung
        $this->resource = fopen('/tmp/my_file.txt', 'w'); // Beispiel
        echo "Objekt erwacht und Ressource wiederhergestellt!\n";
    }
    public function __sleep() {
        // In __sleep serialisieren wir die Ressource nicht
        return ['prop1'];
    }
    public function __destruct() {
        if (is_resource($this->resource)) {
            fclose($this->resource);
            echo "Ressource geschlossen.\n";
        }
    }
}
$obj = new MyClass();
$obj->prop1 = 'wiederhergestellter Wert';
$serialized = serialize($obj);
unset($obj);

$deserialized_obj = unserialize($serialized); // Ruft __wakeup() auf
var_dump($deserialized_obj->prop1);

__toString(): Wird aufgerufen, wenn das Objekt als String verwendet wird (z.B. bei echo oder Konkatenation). Muss eine stringrepräsentation des Objekts zurückgeben.

<?php
class MyClass {
    public $name = "MyObject";
    public function __toString() {
        return "Objekt vom Typ MyClass mit Name: " . $this->name;
    }
}
$obj = new MyClass();
echo $obj; // Gibt "Objekt vom Typ MyClass mit Name: MyObject" aus

__invoke(...): Wird aufgerufen, wenn versucht wird, das Objekt wie eine Funktion aufzurufen. Kann beliebig viele Argumente akzeptieren.

<?php
class MyCallableClass {
    public function __invoke(...$args) {
        echo "Objekt wurde als Funktion mit Argumenten aufgerufen: " . implode(', ', $args);
    }
}
$obj = new MyCallableClass();
$obj('arg1', 123); // Gibt "Objekt wurde als Funktion mit Argumenten aufgerufen: arg1, 123" aus

__set_state(array $properties): Wird statisch aufgerufen für Klassen, die mit var_export() exportiert wurden. Empfängt ein Array der exportierten Eigenschaften. Muss ein neues Objekt der Klasse erstellen und zurückgeben.

<?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 = 'exportierter Wert';
$exported = var_export($obj, true); // Exportiert das Objekt
// $exported enthält den Code zum Erstellen des Objekts, der __set_state() nutzt
eval('$restored_obj = ' . $exported . ';');
var_dump($restored_obj); // Gibt das MyClass-Objekt mit der Eigenschaft 'exportierter Wert' aus

__debugInfo(): Wird beim Aufruf von Funktionen wie var_dump() für das Objekt aufgerufen. Die Methode sollte ein Array mit Informationen über die Eigenschaften des Objekts zurückgeben, die angezeigt werden sollen.

<?php
class MyClass {
    public $publicProp = 'public';
    private $privateProp = 'private';
    public function __debugInfo() {
        return ['publicProp' => $this->publicProp, 'private_info' => 'einige Details über privateProp'];
    }
}
$obj = new MyClass();
var_dump($obj); // Zeigt die durch __debugInfo() zurückgegebenen Informationen

__clone(): Wird nach der Klonoperation (clone) des Objekts aufgerufen. Wird verwendet, um tiefe Kopien interner Objekte oder Datenstrukturen durchzuführen.

<?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() {
        // Klont das innere Objekt für eine tiefe Kopie
        $this->object = clone $this->object;
    }
}
$obj = new MyClass();
$cloned_obj = clone $obj;

// Jetzt sind $obj->object und $cloned_obj->object verschiedene Instanzen von SubObject
$cloned_obj->object->value = 'geändert';

var_dump($obj->object->value);       // Gibt "initial" aus
var_dump($cloned_obj->object->value); // Gibt "geändert" aus

Tabelle mit einer kurzen Beschreibung:

Methode	Beschreibung	Wird aufgerufen bei...
`__construct()`	Konstruktor der Klasse.	Beim Erstellen einer neuen Instanz der Klasse.
`__destruct()`	Destruktor der Klasse.	Beim Zerstören des Objekts oder Beenden des Skripts.
`__call()`	Handhabt Aufrufe nicht zugänglicher oder nicht vorhandener Methoden.	Wenn ein nicht zugänglicher oder nicht vorhandener Methodenaufruf erfolgt.
`__callStatic()`	Handhabt Aufrufe nicht zugänglicher oder nicht vorhandener statischer Methoden.	Wenn ein nicht zugänglicher oder nicht vorhandener statischer Methodenaufruf erfolgt.
`__get()`	Handhabt Zugriff auf nicht zugängliche oder nicht vorhandene Eigenschaften.	Wenn versucht wird, den Wert einer nicht zugänglichen oder nicht vorhandenen Eigenschaft zu erhalten.
`__set()`	Handhabt das Setzen von Werten für nicht zugängliche oder nicht vorhandene Eigenschaften.	Wenn versucht wird, eine Eigenschaft zu setzen, die nicht zugänglich oder nicht vorhanden ist.
`__isset()`	Handhabt `isset()` oder `empty()` auf Eigenschaften.	Wenn `isset()` oder `empty()` auf eine nicht zugängliche oder nicht vorhandene Eigenschaft angewendet wird.
`__unset()`	Handhabt `unset()` auf Eigenschaften.	Wenn `unset()` auf eine nicht zugängliche oder nicht vorhandene Eigenschaft angewendet wird.
`__sleep()`	Bereitet das Objekt auf die Serialisierung vor.	Wenn `serialize()` auf das Objekt angewendet wird.
`__wakeup()`	Nachbearbeitung nach der Deserialisierung.	Wenn `unserialize()` auf das Objekt angewendet wird.
`__toString()`	String-Darstellung des Objekts.	Wenn das Objekt als String verwendet wird (z.B. bei `echo`).
`__invoke()`	Ruft das Objekt wie eine Funktion auf.	Wenn versucht wird, das Objekt wie eine Funktion aufzurufen.
`__set_state()`	Erstellt ein Objekt nach Export mit `var_export()`.	Wenn der mit `var_export()` exportierte Code ausgewertet wird.
`__debugInfo()`	Bietet Debug-Informationen für `var_dump()`.	Wenn `var_dump()` auf das Objekt angewendet wird.
`__clone()`	Nachbearbeitung nach der Klonung.	Wenn `clone` für das Objekt verwendet wird.

Welche magischen Methoden gibt es in PHP und wie werden sie verwendet?