Aké magické metódy existujú v PHP a ako sa používajú…

Magické metódy v PHP sú špeciálne metódy začínajúce dvojitým podčiarknutím (napríklad __construct), ktoré sa automaticky volajú v určitých situáciách.

Hlavné magické metódy a ich použitie:

__construct(): Volá sa pri vytvorení objektu triedy. Používa sa na inicializáciu vlastností objektu a vykonanie počiatočných akcií.

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

__destruct(): Volá sa pri zničení objektu (napríklad keď skript končí alebo objekt je odstránený z pamäti). Používa sa na uvoľnenie zdrojov (zatvorenie súborov, spojení s databázami).
```
<?php
class MyClass {
    public function __destruct() {
        echo "Objekt zničený!";
    }
}
$obj = new MyClass();
unset($obj); // Vypíše "Objekt zničený!"
```

__call(string $name, array $arguments): Volá sa pri pokuse volať nedostupnú alebo neexistujúcu metódu v kontexte objektu. $name obsahuje meno metódy a $arguments je pole argumentov.

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

__callStatic(string $name, array $arguments): Volá sa pri pokuse volať nedostupnú alebo neexistujúcu statickú metódu v kontexte triedy. Je podobná __call, ale pre statické volania.

<?php
class MyClass {
    public static function __callStatic($name, $arguments) {
        echo "Volaná nedostupná statická metóda '{$name}' s argumentmi: " . implode(', ', $arguments);
    }
}
MyClass::nonExistentStaticMethod('static_arg'); // Vypíše "Volaná nedostupná statická metóda 'nonExistentStaticMethod' s argumentmi: static_arg"

__get(string $name): Volá sa pri pokuse získať hodnotu nedostupného alebo neexistujúceho vlastnosti v kontexte objektu. $name obsahuje meno 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ázdny reťazec (v závislosti od návratovej hodnoty null)

__set(string $name, mixed $value): Volá sa pri pokuse nastaviť hodnotu nedostupného alebo neexistujúceho vlastnosti v kontexte objektu. $name obsahuje meno vlastnosti a $value je nastavovaná hodnota.

<?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á sa pri volaní isset() alebo empty() na nedostupnom alebo neexistujúcom vlastnosti v kontexte objektu. Vracia 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));     // Vypíše bool(true)
var_dump(isset($obj->absent));      // Vypíše bool(false)

__unset(string $name): Volá sa pri volaní unset() na nedostupnom alebo neexistujúcom vlastnosti v kontexte 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 "Vlastnosť '{$name}' odstránená.\n";
        }
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
print_r($obj->getData());
unset($obj->remove_me); // Vypíše "Vlastnosť 'remove_me' odstránená." a odstráni prvok z $data
print_r($obj->getData());

__sleep(): Volá sa pred serializáciou objektu pomocou serialize(). Musí vrátiť pole mien vlastností, ktoré majú byť serializované.

<?php
class MyClass {
    public $prop1 = 'value1';
    public $prop2 = 'value2';
    public function __sleep() {
        return ['prop1']; // Serializujeme iba prop1
    }
}
$obj = new MyClass();
$serialized = serialize($obj); // Serializuje iba prop1
echo $serialized; // Vypíše približne O:7:"MyClass":1:{s:5:"prop1";s:6:"value1";}

__wakeup(): Volá sa po deserializácii objektu pomocou unserialize(). Používa sa na obnovenie spojení s databázami alebo iné akcie potrebné po obnovení objektu.

<?php
class MyClass {
    public $prop1;
    public $resource; // Predpokladajme, že je to zdroj spojenia
    public function __wakeup() {
        // Obnoviť zdroj, napríklad spojenie s databázou
        $this->resource = fopen('/tmp/my_file.txt', 'w'); // Príklad
        echo "Objekt prebudený a zdroj obnovený!\n";
    }
    public function __sleep() {
        // V __sleep neserializujeme zdroj
        return ['prop1'];
    }
    public function __destruct() {
        if (is_resource($this->resource)) {
            fclose($this->resource);
            echo "Zdroj zatvorený.\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á sa, keď je objekt použitý ako reťazec (napríklad pri echo alebo konkatenácii). Musí vrátiť reťazcové zobrazenie objektu.

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

__invoke(...): Volá sa pri pokuse volať objekt ako funkciu. Môže prijímať ľubovoľný počet argumentov.

<?php
class MyCallableClass {
    public function __invoke(...$args) {
        echo "Objekt bol volaný ako funkcia s argumentmi: " . implode(', ', $args);
    }
}
$obj = new MyCallableClass();
$obj('arg1', 123); // Vypíše "Objekt bol volaný ako funkcia s argumentmi: arg1, 123"

__set_state(array $properties): Volá sa staticky pre triedy exportované pomocou var_export(). Získa pole exportovaných vlastností. Musí vytvoriť nový objekt triedy a vrátiť ho.

<?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 obsahovať kód na vytvorenie objektu, ktorý používa __set_state()
eval('$restored_obj = ' . $exported . ';');
var_dump($restored_obj); // Vypíše objekt MyClass s vlastnosťou 'exported value'

__debugInfo(): Volá sa pri volaní funkcií typu var_dump() pre objekt. Metóda by mala vracať pole s informáciami o vlastnostiach objektu, ktoré majú byť zobrazené.

<?php
class MyClass {
    public $publicProp = 'public';
    private $privateProp = 'private';
    public function __debugInfo() {
        return ['publicProp' => $this->publicProp, 'private_info' => 'nejaké detaily o privateProp'];
    }
}
$obj = new MyClass();
var_dump($obj); // Vypíše informácie, ktoré vracia __debugInfo()

__clone(): Volá sa po operácii klonovania (clone) objektu. Používa sa na hlboké kopírovanie vnútorných objektov alebo dátových štruktúr.

<?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() {
        // Klonujeme vnútorný objekt pre hlboké kopírovanie
        $this->object = clone $this->object;
    }
}
$obj = new MyClass();
$cloned_obj = clone $obj;

// Teraz $obj->object a $cloned_obj->object sú rôzne inštancie SubObject
$cloned_obj->object->value = 'modified';

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

Tabuľka s krátkym popisom:

Metóda	Popis	Volá sa pri...
`__construct()`	Konštruktor triedy.	Vytvorení nového inštancie triedy.
`__destruct()`	Deštruktor triedy.	Odstránení objektu alebo ukončení skriptu.
`__call()`	Spracovanie volania neexistujúcich/nedostupných metód objektu.	Pokuse o volanie nedostupnej alebo neexistujúcej metódy objektu.
`__callStatic()`	Spracovanie volania neexistujúcich/nedostupných statických metód.	Pokus o volanie nedostupnej alebo neexistujúcej statickej metódy triedy.
`__get()`	Spracovanie získania hodnoty neexistujúcej/nedostupnej vlastnosti.	Pokus o získanie hodnoty nedostupnej alebo neexistujúcej vlastnosti objektu.
`__set()`	Spracovanie nastavenia hodnoty neexistujúcej/nedostupnej vlastnosti.	Pokus o nastavenie hodnoty nedostupnej alebo neexistujúcej vlastnosti objektu.
`__isset()`	Spracovanie `isset()` alebo `empty()` pre vlastnosti.	Volanie `isset()` alebo `empty()` na nedostupnej alebo neexistujúcej vlastnosti objektu.
`__unset()`	Spracovanie `unset()` pre vlastnosti.	Volanie `unset()` na nedostupnej alebo neexistujúcej vlastnosti objektu.
`__sleep()`	Príprava na serializáciu.	Volanie `serialize()` pre objekt.
`__wakeup()`	Post-serializačná spracovanie.	Volanie `unserialize()` pre objekt.
`__toString()`	Reťazcové zobrazenie objektu.	Použitie objektu ako reťazca (napríklad pri `echo`).
`__invoke()`	Volanie objektu ako funkcie.	Pokus o volanie objektu ako funkcie.
`__set_state()`	Vytvorenie objektu po exporte s `var_export()`.	Vyhodnotenie kódu vytvoreného `var_export()`.
`__debugInfo()`	Informácie pre ladenie (`var_dump()`).	Volanie `var_dump()` pre objekt.
`__clone()`	Post-serializačné spracovanie po klonovaní.	Volanie `clone` pre objekt.

Aké magické metódy existujú v PHP a ako sa používajú?