Milyen mágikus módszerek léteznek a PHP-ben, és…

PHP-ban a mágikus módszerek speciális metódusok, amelyek dupla aláhúzással kezdődnek (például __construct), és bizonyos helyzetekben automatikusan meghívódnak.

A fő mágikus módszerek és használatuk:

__construct(): Az osztály példányosításakor hívódik meg. Az objektum tulajdonságainak inicializálására és kezdő műveletek végrehajtására szolgál.

<?php
class MyClass {
    public function __construct() {
        echo "Objektum létrehozva!";
    }
}
$obj = new MyClass(); // Kiírja: "Objektum létrehozva!"

__destruct(): Az objektum megsemmisítésekor hívódik meg (például, amikor a szkript befejeződik vagy az objektum törlésre kerül). Erőforrások felszabadítására szolgál (fájlok zárása, adatbázis-kapcsolatok lezárása).
```
<?php
class MyClass {
    public function __destruct() {
        echo "Objektum megsemmisítve!";
    }
}
$obj = new MyClass();
unset($obj); // Kiírja: "Objektum megsemmisítve!"
```

__call(string $name, array $arguments): Az objektum kontextusában hívott, nem elérhető vagy nem létező metódus esetén hívódik meg. $name a metódus neve, $arguments pedig az argumentumok tömbje.

<?php
class MyClass {
    public function __call($name, $arguments) {
        echo "Hívott nem elérhető metódus '{$name}' argumentumokkal: " . implode(', ', $arguments);
    }
}
$obj = new MyClass();
$obj->nonExistentMethod('arg1', 'arg2'); // Kiírja: "Hívott nem elérhető metódus 'nonExistentMethod' argumentumokkal: arg1, arg2"

__callStatic(string $name, array $arguments): Statikus kontextusban hívott, nem elérhető vagy nem létező statikus metódus esetén hívódik meg. Hasonló, mint az __call, de statikus hívásokhoz.

<?php
class MyClass {
    public static function __callStatic($name, $arguments) {
        echo "Hívott nem elérhető statikus metódus '{$name}' argumentumokkal: " . implode(', ', $arguments);
    }
}
MyClass::nonExistentStaticMethod('static_arg'); // Kiírja: "Hívott nem elérhető statikus metódus 'nonExistentStaticMethod' argumentumokkal: static_arg"

__get(string $name): Az objektum kontextusában hívódik meg, amikor egy nem elérhető vagy nem létező tulajdonság értékét próbáljuk elérni. $name a tulajdonság neve.

<?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; // Kiírja: "value"
echo $obj->nonExistentKey; // Üres stringet ír ki (a null érték miatt)

__set(string $name, mixed $value): Az objektum kontextusában hívódik meg, amikor egy nem elérhető vagy nem létező tulajdonságnak értéket próbálunk adni. $name a tulajdonság neve, $value pedig az érték.

<?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()); // Kiírja: Array ( [newKey] => newValue )

__isset(string $name): Az isset() vagy empty() hívásakor hívódik meg, ha a tulajdonság nem elérhető vagy nem létező az objektumban. Igaz vagy hamis értéket ad vissza.

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

__unset(string $name): Az unset() hívásakor hívódik meg, ha a tulajdonság nem elérhető vagy nem létező az objektumban.

<?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 "A '{$name}' tulajdonság törölve lett.\n";
        }
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
print_r($obj->getData());
unset($obj->remove_me); // Kiírja: "A 'remove_me' tulajdonság törölve lett." és eltávolítja az elemet a $data-ból
print_r($obj->getData());

__sleep(): Az objektum serializálása előtt hívódik meg a serialize() használatakor. Vissza kell adnia azoknak a tulajdonságneveknek a tömbjét, amelyeket serializálni szeretnénk.

<?php
class MyClass {
    public $prop1 = 'value1';
    public $prop2 = 'value2';
    public function __sleep() {
        return ['prop1']; // Csak a prop1 kerül serializálásra
    }
}
$obj = new MyClass();
$serialized = serialize($obj); // Csak a prop1-t serializálja
echo $serialized; // Körülbelül így néz ki: O:7:"MyClass":1:{s:5:"prop1";s:6:"value1";}

__wakeup(): Az objektum deserializálása után hívódik meg a unserialize() használatakor. Az adatbázis-kapcsolatok helyreállítására vagy más utófeldolgozásra szolgál.

<?php
class MyClass {
    public $prop1;
    public $resource; // Feltételezve, hogy ez egy erőforrás
    public function __wakeup() {
        // Erőforrás helyreállítása, pl. adatbázis kapcsolat
        $this->resource = fopen('/tmp/my_file.txt', 'w'); // Példa
        echo "Az objektum felébredt és az erőforrás helyreállt!\n";
    }
    public function __sleep() {
        // A __sleep-ban nem serializáljuk az erőforrást
        return ['prop1'];
    }
    public function __destruct() {
        if (is_resource($this->resource)) {
            fclose($this->resource);
            echo "Az erőforrás bezárva.\n";
        }
    }
}
$obj = new MyClass();
$obj->prop1 = 'deserialized value';
$serialized = serialize($obj);
unset($obj);

$deserialized_obj = unserialize($serialized); // Meghívja a __wakeup() metódust
var_dump($deserialized_obj->prop1);

__toString(): Az objektum sztringként való használatakor hívódik meg (pl. echo vagy konkatenáció). Vissza kell adnia az objektum sztringes reprezentációját.

<?php
class MyClass {
    public $name = "MyObject";
    public function __toString() {
        return "MyClass típusú objektum névvel: " . $this->name;
    }
}
$obj = new MyClass();
echo $obj; // Kiírja: "MyClass típusú objektum névvel: MyObject"

__invoke(...): Az objektum hívásakor hívódik meg, mint függvény. Bármennyi argumentumot fogadhat.

<?php
class MyCallableClass {
    public function __invoke(...$args) {
        echo "Az objektum függvényként hívva argumentumokkal: " . implode(', ', $args);
    }
}
$obj = new MyCallableClass();
$obj('arg1', 123); // Kiírja: "Az objektum függvényként hívva argumentumokkal: arg1, 123"

__set_state(array $properties): Statikus hívás, amikor az osztályt a var_export() segítségével exportálják. A tömböt kapja az exportált tulajdonságokkal. Új példányt kell létrehoznia és visszaadnia.

<?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); // Exportálja az objektumot
// Az $exported tartalmazni fogja a kódot, ami létrehozza az objektumot, a __set_state() használatával
eval('$restored_obj = ' . $exported . ';');
var_dump($restored_obj); // Kiírja az objektumot, melynek property-je 'exported value'

__debugInfo(): A var_dump() típusú függvények hívásakor hívódik meg az objektumon. A metódusnak egy tömböt kell visszaadnia, ami az objektum tulajdonságairól szóló információkat tartalmazza, amelyeket meg szeretnénk jeleníteni.

<?php
class MyClass {
    public $publicProp = 'public';
    private $privateProp = 'private';
    public function __debugInfo() {
        return ['publicProp' => $this->publicProp, 'private_info' => 'néhány részlet a privateProp-ról'];
    }
}
$obj = new MyClass();
var_dump($obj); // A __debugInfo() által visszaadott információt fogja kiírni

__clone(): Az objektum klónozásakor hívódik meg. Mély másolatot készít a belső objektumokról vagy adatszerkezetekről.

<?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() {
        // Mély másolat a belső objektumról
        $this->object = clone $this->object;
    }
}
$obj = new MyClass();
$cloned_obj = clone $obj;

// Most $obj->object és $cloned_obj->object külön példányok
$cloned_obj->object->value = 'modified';

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

Metódus	Leírás	Akkor hívódik meg, amikor...
`__construct()`	Konstruktor.	Az új példány létrehozásakor.
`__destruct()`	Destruktor.	Az objektum törlésekor vagy a szkript befejeződik.
`__call()`	Nem elérhető vagy nem létező metódus hívásakor.	Amikor nem elérhető vagy nem létező metódust próbálunk hívni.
`__callStatic()`	Nem elérhető vagy nem létező statikus metódus hívásakor.	Amikor nem elérhető vagy nem létező statikus metódust próbálunk hívni.
`__get()`	Nem elérhető vagy nem létező tulajdonság értékének lekérésekor.	Amikor nem elérhető vagy nem létező tulajdonság értékét kérjük le.
`__set()`	Nem elérhető vagy nem létező tulajdonság értékének beállításakor.	Amikor nem elérhető vagy nem létező tulajdonságnak értéket adunk.
`__isset()`	`isset()` vagy `empty()` hívásakor.	Amikor `isset()` vagy `empty()`-t hívunk nem elérhető vagy nem létező tulajdonságra.
`__unset()`	Nem elérhető vagy nem létező tulajdonság unsetelésekor.	Amikor `unset()`-et hívunk nem elérhető vagy nem létező tulajdonságon.
`__sleep()`	Szerializálás előtt.	Amikor `serialize()`-t hívunk az objektumon.
`__wakeup()`	Deszerializálás után.	Amikor `unserialize()`-t hívunk az objektumon.
`__toString()`	Sztringként való használatkor.	Amikor az objektumot sztringként használjuk (pl. `echo`).
`__invoke()`	Az objektum függvényként való hívásakor.	Amikor az objektumot függvényként próbáljuk hívni.
`__set_state()`	Az `var_export()` által exportált objektum újjáépítésekor.	Kód értékelésekor, amit a `var_export()` generál.
`__debugInfo()`	`var_dump()`-hoz hasonló függvények hívásakor.	`var_dump()` hívásakor az objektumon.
`__clone()`	Klónozás utáni műveletek.	`clone`-nal klónozáskor.

Milyen mágikus módszerek léteznek a PHP-ben, és hogyan használják őket?