Jaké magické metody existují v PHP a jak se…

V PHP jsou magické metody speciální metody, které začínají dvojitým podtržítkem (například __construct) a jsou automaticky volány za určitých okolností.

Hlavní magické metody a jejich použití:

__construct(): Volá se při vytváření instance třídy. Používá se k inicializaci vlastností objektu a provádění počátečních akcí.

<?php
class MyClass {
    public function __construct() {
        echo "Objekt byl vytvořen!";
    }
}
$obj = new MyClass(); // Vypíše "Objekt byl vytvořen!"

__destruct(): Volá se při zničení objektu (například když skript končí nebo je objekt odstraněn z paměti). Používá se k uvolnění zdrojů (zavření souborů, ukončení spojení s databází).
```
<?php
class MyClass {
    public function __destruct() {
        echo "Objekt byl zničen!";
    }
}
$obj = new MyClass();
unset($obj); // Vypíše "Objekt byl zničen!"
```

__call(string $name, array $arguments): Volá se při pokusu zavolat nedostupnou nebo neexistující metodu v kontextu objektu. $name obsahuje název metody a $arguments pole argumentů.

<?php
class MyClass {
    public function __call($name, $arguments) {
        echo "Volána nedostupná metoda '{$name}' s argumenty: " . implode(', ', $arguments);
    }
}
$obj = new MyClass();
$obj->nonExistentMethod('arg1', 'arg2'); // Vypíše "Volána nedostupná metoda 'nonExistentMethod' s argumenty: arg1, arg2"

__callStatic(string $name, array $arguments): Volá se při pokusu zavolat nedostupnou nebo neexistující statickou metodu v kontextu třídy. Podobně jako __call, ale pro statické volání.

<?php
class MyClass {
    public static function __callStatic($name, $arguments) {
        echo "Volána nedostupná statická metoda '{$name}' s argumenty: " . implode(', ', $arguments);
    }
}
MyClass::nonExistentStaticMethod('static_arg'); // Vypíše "Volána nedostupná statická metoda 'nonExistentStaticMethod' s argumenty: static_arg"

__get(string $name): Volá se při pokusu získat hodnotu nedostupného nebo neexistujícího vlastnosti v kontextu objektu. $name obsahuje název vlastnosti.

<?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; // Vypíše "value"
echo $obj->nonExistentKey; // Vypíše prázdný řetězec (v závislosti na návratové hodnotě null)

__set(string $name, mixed $value): Volá se při pokusu nastavit hodnotu nedostupné nebo neexistující vlastnosti v kontextu objektu. $name obsahuje název vlastnosti a $value nastavovanou hodnotu.

<?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()); // Vypíše Array ( [newKey] => newValue )

__isset(string $name): Volá se při volání isset() nebo empty() na nedostupné nebo neexistující vlastnosti v kontextu objektu. Vrací boolean hodnotu.

<?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): Volá se při volání unset() na nedostupné nebo neexistující vlastnosti v kontextu objektu.

<?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 "Vlastnost '{$name}' byla odstraněna.\n";
        }
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
print_r($obj->getData());
unset($obj->remove_me); // Vypíše "Vlastnost 'remove_me' byla odstraněna." a odstraní prvek z $data
print_r($obj->getData());

__sleep(): Volá se před serializací objektu pomocí serialize(). Měl by vrátit pole názvů vlastností, které mají být serializovány.

<?php
class MyClass {
    public $prop1 = 'value1';
    public $prop2 = 'value2';
    public function __sleep() {
        return ['prop1']; // Serializuje pouze prop1
    }
}
$obj = new MyClass();
$serialized = serialize($obj); // Serializuje pouze prop1
echo $serialized; // Přibližně: O:7:"MyClass":1:{s:5:"prop1";s:6:"value1";}

__wakeup(): Volá se po deserializaci objektu pomocí unserialize(). Používá se k obnovení spojení s databází nebo jiných akcí potřebných po obnovení objektu.

<?php
class MyClass {
    public $prop1;
    public $resource; // Předpokládejme, že je to zdroj spojení
    public function __wakeup() {
        // Obnovení zdroje, například spojení s databází
        $this->resource = fopen('/tmp/my_file.txt', 'w'); // Příklad
        echo "Objekt byl probuzen a zdroj obnoven!\n";
    }
    public function __sleep() {
        // V __sleep ne serializujeme zdroj
        return ['prop1'];
    }
    public function __destruct() {
        if (is_resource($this->resource)) {
            fclose($this->resource);
            echo "Zdroj byl uzavřen.\n";
        }
    }
}
$obj = new MyClass();
$obj->prop1 = 'deserialized value';
$serialized = serialize($obj);
unset($obj);

$deserialized_obj = unserialize($serialized); // Zavolá __wakeup()
var_dump($deserialized_obj->prop1);

__toString(): Volá se při použití objektu jako řetězce (například při echo nebo konkatenaci). Měl by vrátit řetězcové zobrazení objektu.

<?php
class MyClass {
    public $name = "MyObject";
    public function __toString() {
        return "Objekt typu MyClass s názvem: " . $this->name;
    }
}
$obj = new MyClass();
echo $obj; // Vypíše "Objekt typu MyClass s názvem: MyObject"

__invoke(...): Volá se při pokusu zavolat objekt jako funkci. Může přijímat libovolný počet argumentů.

<?php
class MyCallableClass {
    public function __invoke(...$args) {
        echo "Objekt byl volán jako funkce s argumenty: " . implode(', ', $args);
    }
}
$obj = new MyCallableClass();
$obj('arg1', 123); // Vypíše "Objekt byl volán jako funkce s argumenty: arg1, 123"

__set_state(array $properties): Statický volání při exportu třídy pomocí var_export(). Přijímá pole exportovaných vlastností. Měl by vytvořit nový objekt třídy a vrátit jej.

<?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); // Exportuje objekt
// $exported bude obsahovat kód pro vytvoření objektu, který používá __set_state()
eval('$restored_obj = ' . $exported . ';');
var_dump($restored_obj); // Vypíše objekt MyClass s vlastností 'exported value'

__debugInfo(): Volá se při volání funkcí typu var_dump() na objektu. Metoda by měla vracet pole s informacemi o vlastnostech objektu, které mají být zobrazeny.

<?php
class MyClass {
    public $publicProp = 'public';
    private $privateProp = 'private';
    public function __debugInfo() {
        return ['publicProp' => $this->publicProp, 'private_info' => 'některé detaily o privateProp'];
    }
}
$obj = new MyClass();
var_dump($obj); // Zobrazí informace vrácené __debugInfo()

__clone(): Volá se po operaci klonování (clone) objektu. Používá se k hlubokému kopírování vnitřních objektů nebo datových struktur.

<?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() {
        // Klonování vnořeného objektu pro hlubokou kopii
        $this->object = clone $this->object;
    }
}
$obj = new MyClass();
$cloned_obj = clone $obj;

// Nyní $obj->object a $cloned_obj->object jsou různé instance SubObject
$cloned_obj->object->value = 'modified';

var_dump($obj->object->value);       // Vypíše "initial"
var_dump($cloned_obj->object->value); // Vypíše "modified"

Metoda	Popis	Volá se při...
`__construct()`	Konstruktor třídy.	Vytvoření nové instance třídy.
`__destruct()`	Destruktor třídy.	Při odstranění objektu nebo ukončení skriptu.
`__call()`	Zpracování volání nedostupných/neexistujících metod objektu.	Při pokusu o volání nedostupné nebo neexistující metody objektu.
`__callStatic()`	Zpracování volání nedostupných/neexistujících statických metod.	Při pokusu o volání nedostupné nebo neexistující statické metody třídy.
`__get()`	Zpracování získání hodnoty nedostupného/neexistujícího vlastnosti.	Při pokusu o získání hodnoty nedostupného nebo neexistujícího vlastnosti objektu.
`__set()`	Zpracování nastavení hodnoty nedostupné/neexistující vlastnosti.	Při pokusu o nastavení hodnoty nedostupného nebo neexistujícího vlastnosti objektu.
`__isset()`	Zpracování `isset()` nebo `empty()` pro vlastnosti.	Při volání `isset()` nebo `empty()` na nedostupném nebo neexistujícím vlastnosti objektu.
`__unset()`	Zpracování `unset()` pro vlastnosti.	Při volání `unset()` na nedostupném nebo neexistujícím vlastnosti objektu.
`__sleep()`	Příprava na serializaci.	Při volání `serialize()` na objektu.
`__wakeup()`	Po deserializaci.	Při volání `unserialize()` na objektu.
`__toString()`	Řetězcové zobrazení objektu.	Při použití objektu jako řetězce (například při `echo`).
`__invoke()`	Volání objektu jako funkce.	Při pokusu o volání objektu jako funkce.
`__set_state()`	Vytvoření objektu po exportu s `var_export()`.	Při vyhodnocení kódu vytvořeného `var_export()`.
`__debugInfo()`	Informace pro ladicí funkce (`var_dump()`).	Při volání `var_dump()` na objektu.
`__clone()`	Po klonování.	Při volání `clone` na objektu.

Jaké magické metody existují v PHP a jak se používají?