Hello World!

Każdy język programowania ma swoje smaczki. W przypadku PHP smaczkiem tym są magiczne metody – znienawidzone przez jednych, nadużywane przez innych. Zastosowane z rozwagą i dobrze użyte mogą znacząco wpłynąć na rozwój kodu. Każda magiczna metoda rozpoczyna się dwoma znakami podkreślenia ( __ ). Twórcy języka wyraźnie zaznaczyli, że konwencja ta jest zarezerwowana wyłącznie dla magicznych metod i nie powinna być stosowana w innych przypadkach.

Konstruktor

Najczęściej używaną przez programistów PHP magią jest konstruktor. Oznaczony jako __construct odpowiada za inicjalizację obiektu. Konstruktor może przyjąć dowolną liczbę argumentów i wbrew pozorom nic nie zwraca.

class Foo
{
    protected $_zmienna;

    public function __construct($arg1 = null)
    {
        $this->_zmienna = $arg1;
    }
}

Jeśli zwrócimy coś w konstruktorze, dopiero jego jawne wywołanie spowoduje, że wartość ta będzie dostęna.

class Foo
{
    public function __construct()
    {
        return null;
    }
}

$foo = new Foo();
var_dump($foo->__construct()); // wyswieli NULL

Konstruktory mogą być podstępne, zwłaszcza jeśli korzystamy z dziedziczenia. Należy pamiętać, iż nadpisanie konstruktora spowoduje, że wykona się konstruktor zadeklarowany najniżej w hierarchii. Pozostałe musimy sami wywołać.

class Foo
{
    public function __construct()
    {
        echo 'Konstruktor Foo';
    }
}

class Bar extends Foo
{
    public function __construct()
    {
        echo 'Konstruktor Bar';
    }
}

class Baz extends Bar
{
    public function __construct()
    {
        echo 'Konstruktor Baz';
    }
}

$baz = new Baz();

Powyższy kod wyświetli tylko jeden tekst – Konstruktor Baz. Dopiero jawne wskazanie, że konstruktor rodzica też ma się wykonać, spowoduje wyświetlenie pozostałych tekstów.

class Foo
{
    public function __construct()
    {
        echo 'Konstruktor Foo';
    }
}

class Bar extends Foo
{
    public function __construct()
    {
        parent::__construct();
        echo 'Konstruktor Bar';
    }
}

class Baz extends Bar
{
    public function __construct()
    {
        parent::__construct();
        echo 'Konstruktor Baz';
    }
}

$baz = new Baz();

Powyższy kod wyświetli

Konstruktor Foo
Konstruktor Bar
Konstruktor Baz

Jak widać konstruktory wykonują się po kolei. Dzieje się tak dlatego, że wywołanie konstruktora rodzica jest pierwszą instrukcją. Dzięki możliwości sterowania momentem wywołania konstruktora rodzica mamy wpływ na proces inicjalizacji obiektów.

Destruktor

Przeciwieństwem konstruktora jest destruktor, który służy do sprzątania bałaganu po obiekcie. Metoda ta zostanie wywołana w momencie, gdy na dany obiekt nie wskazuje żadna referencja. Podobnie jak w przypadku konstruktorów, destruktory klas nadrzędnych należy wywołać samemu.

class Foo
{
    public function __destruct()
    {
        echo 'Destruktor Foo';
    }
}

class Bar extends Foo
{
    public function __destruct()
    {
        parent::__destruct();
        echo 'Destruktor Bar';
    }
}

class Baz extends Bar
{
    public function __destruct()
    {
        parent::__destruct();
        echo 'Destruktor Baz';
    }
}

$baz = new Baz();

Przeciążanie metod

W PHP nie ma możliwości zdefiniowania dowolnej ilości takich samych metod z różnymi parametrami. Jeśli ktoś spróbuje takie coś zrobić, niemiło się rozczaruje. Z pomocą przychodzi kolejna magia w postaci dwóch metod: __call oraz __callStatic. Obie metody działają w taki sam sposób, przy czym __call działa z poziomu obiektu, a __callStatic z poziomu klasy. Obie metody zostaną wywołane w przypadku gdy na obiekcie (__call) lub klasie (__callStatic) wywołana zostanie niezdefiniowana metoda.

Zarówno metoda __call jak i __callStatic przyjmują dwa argumenty. Pierwszym z nich jest nazwa wywołanej (nieistniejącej) metody, drugim tablica przekazanych do niej argumentów.

class Foo
{
	public function bar()
	{
		return 'jestem metoda bar';
	}

	public static function baz()
	{
		return 'jestem statyczna metoda baz';
	}

	public function __call($name, $args)
	{
		return 'wywolano nieistniejaca metode ' . $name . ' z argumentami: '
			. print_r($args, true);
	}

	public static function __callStatic($name, $args)
	{
		return 'wywolano nieistniejaca statyczna metode ' . $name . ' z argumentami: '
			. print_r($args, true);
	}
}

$foo = new Foo();
echo $foo->bar();
echo $foo->nieistniejaca_metoda('abc', 123);

echo Foo::baz();
echo Foo::nieistniejaca_metoda_statyczna('abc', 123);

Powyższy kod wyświetli:

jestem metoda bar
wywolano nieistniejaca metode nieistniejaca_metoda z argumentami:
Array
(
    [0] => abc
    [1] => 123
)

jestem statyczna metoda baz
wywolano nieistniejaca statyczna metode nieistniejaca_metoda_statyczna z argumentami:
Array
(
    [0] => abc
    [1] => 123
)

Do czego jest to potrzebne? Po pierwsze do zastąpienia setek zbędnych metod wykonujących tą samą czynność, różniącą się jednym parametrem. Dobrym przykładem będzie tutaj metoda pobierająca dane z bazy na podstawie nazwy kolumny – getUsersByName. Magiczna metoda jest w stanie rozpoznać nazwę tabeli (Users) oraz nazwę kolumny (Name) i na tej podstawie pobrać dane. Dzięki zastosowaniu magii nie musimy pisać metod dla wszystkich tabel i wszystkich kolumn w bazie.

Innym zastosowaniem opisanych wyżej metod jest przechwytywanie niepoprawnych wywołań metod i eleganckie zgłaszanie wyjątków.

Przeciążanie właściwości

Podobnie jak metody, przeciążać można również właściwości. PHP oferuje cztery magiczne metody to umożliwiające. Są to:

• __set – wywoływana w momencie zapisywania nieistniejącej lub niedostępnej publicznie właściwości
• __get – wywoływana w momencie pobierania nieistniejącej lub niedostępnej publicznie właściwości
• __isset – wywoływana w momencie sprawdzania nieistniejącej właściwość
• __unset – wywoływana w momencie usuwania nieistniejącej lub niedostępnej publicznie właściwości

class Foo
{
	protected $_data = array();

	public function __set($name, $value)
	{
		$this->_data[$name] = $value;
	}

	public function __get($name)
	{
		return $this->_data[$name];
	}

	public function __isset($name)
	{
		return isset($this->_data[$name]);
	}

	public function __unset($name)
	{
		unset($this->_data[$name]);
	}}

$foo = new Foo();
var_dump($foo);

$foo->bar = 123;
$foo->baz = 'abc';
var_dump($foo);
var_dump(isset($foo->baz));
var_dump(isset($foo->baaz));

unset($foo->bar);
var_dump($foo);

Powyższy kod wyświetli

object(Foo)#1 (1) {
  ["_data":protected]=>
  array(0) {
  }
}

object(Foo)#1 (1) {
  ["_data":protected]=>
  array(2) {
    ["bar"]=>
    int(123)
    ["baz"]=>
    string(3) "abc"
  }
}

bool(true)

bool(false)

object(Foo)#1 (1) {
  ["_data":protected]=>
  array(1) {
    ["baz"]=>
    string(3) "abc"
  }
}

O ile robienie obiektowej nakładki na tablicę mija się z celem, tak wykorzystanie przeciążania właściwości w przypadku obiektów operujących na danych pochodzących z różnych źródeł pozwala na znaczne zmniejszenie ilości kodu oraz wprowadzenie spójnego interfejsu dostępu do tych danych. Przeciążanie właściwości połączone z przeciążaniem metod daje ogromne możliwości pozwalające na tworzenie jednorodnych obiektów, będących swoistą czarną skrzynką. Co więcej, skrzynka ta nie będzie przeładowana zbędnym kodem.

Serializacja obiektów

Co robimy jeśli chcemy zachować stan jakiegoś obiektu na później? Serializujemy go. PHP oferuje dwie magiczne metody związane z serializacją. Są to __sleep, wywoływana w momencie użycia funkcji serialize na obiekcie oraz __wakeup, wywoływana w momencie deserializacji obiektu przy pomocy funkcji unserialize.

class Foo
{
	public function __sleep()
	{
		echo 'zaspiam';
		return array();
	}

	public function __wakeup()
	{
		echo 'budze sie';
	}
}

$foo = new Foo();

echo 'przed serializacja';
$serialized = serialize($foo);
echo 'po serializacji';

echo 'przed deserializacja';
unserialize($serialized);
echo 'po deserializacji';

W wyniku działania powyższego skryptu uzyskamy następujący efekt

przed serializacja
zaspiam
po serializacji

przed deserializacja
budze sie
po deserializacji

W serializacji nie chodzi o wyświetlanie tekstu, a o zapisywanie aktualnego stanu obiektu. Tylko co to oznacza? Oznacza to ni mniej ni więcej jak zapamiętanie tych właściwości, na podstawie których będziemy mogli przywrócić obiekt do stanu sprzed serializacji. Czyli jeśli nasz obiekt przed serializacją łączył się do bazy lub otwierał jakiś plik, po deserializacji musi do tej bazy już być połączony a plik mieć już otwarty. I do tego właśnie służą metody __sleep i __wakeup. Pierwsza z nich musi zwrócić tablicę nazw właściwości, które chcemy zapamiętać. Druga w momencie deserializacji będzie w stanie wywołać wszystkie niezbędne metody, które przywrócą obiekt do właściwego stanu na podstawie zapamiętanych właściwości.

class Foo
{
	protected $_fileName = '';
	protected $_fh;

	public function __construct($fileName)
	{
		$this->_fileName = $fileName;
	}

	public function openFile()
	{
		$this->_fh = fopen($this->_fileName, 'r');
	}

	public function test()
	{
		var_dump($this->_fh);
	}

	public function __sleep()
	{
		return array('_fileName');
	}

	public function __wakeup()
	{
		$this->openFile();
	}
}

$foo = new Foo(__FILE__);
$foo->openFile();
$foo->test();
$serialized = serialize($foo);

$bar = unserialize($serialized);
$bar->test();

Obiekty jako ciągi

Czasami zachodzi potrzeba “wyświetlenia” obiektu. Zdarza się to w przypadku obiektów reprezentujących jakiś ciąg znaków, np. zapytanie SQL. Zamiast tworzyć metodę, którą następnie będziemy musieli wywołać, wystarczy użyć magicznej metody __toString. Jeśli obiekt jest w nią wyposażony, to w momencie “echowania” obiektu lub zrzutowania go na typ string, zostanie ona wywołana. Zgodnie ze swoją nazwą metoda ta musi zwracać string.

class Foo
{
	public function __toString()
	{
		return 'ciag reprezentujacy obiekt';
	}
}

$foo = new Foo();
echo $foo;

Obiekty jako funkcje

Obiekty można wywoływać jako funkcje. Wprawdzie brzmi to absurdalnie, ale jest to możliwe. W zasadzie dzięki tej funkcjonalności w PHP można korzystać z funkcji anonimowych. Jak to działa? Bardzo prosto – podczas użycia obiektu jako funkcji, wywołana zostanie magiczna metoda __invoke.

class Foo
{
	public function __invoke($arg1, $arg2)
	{
		echo $arg1;
		echo $arg2;
	}
}

$foo = new Foo();
$foo('abc', 123);

Metoda ta poza wspomnianymi funkcjami anonimowymi nie ma żadnego praktycznego zastosowania.

Klonowanie obiektów

Ostatnią magią dostępną w PHP jest metoda __clone, uruchamiana po sklonowaniu obiektu. Klonowanie obiektu polega na wykonaniu kopii klonowanego obiektu, a nie kopii referencji do niego. Dzięki temu uzyskujemy dwa niezależne od siebie obiekty. Metoda __clone ma zadanie umożliwić przeprowadzenie dodatkowych operacji na nowym obiekcie.

class Foo
{
	public $a = 'abc';

	public function __clone()
	{
		$this->a = 123;
	}
}

$foo = new Foo();
$bar = clone $foo;

echo $foo->a; // wyswietli abc
echo $bar->a; // wyswietli 123

Metoda ta bardzo często wykorzystywana jest razem z singletonem w celu zapobiegnięcia stworzenia kolejnej instancji klasy. Najczęściej w metodzie __clone klasy będącej singletonem rzucany jest wyjątek, który skutecznie zniechęca do klonowania takiego obiektu.

Podsumowanie

Uff. Dotarliśmy do końca pehapowej magii. Jak widać jest jej całkiem sporo. Zanim jednak zaczniecie z niej korzystać w każdym możliwym miejscu, musicie wiedzieć, że zbyt dużo magii oznacza “not enough mana”, czyli mułowaty projekt, przy którym poci się najlepszy serwer. Nie można również zapominać o wygodzie programowania, która praktycznie zanika przy zbyt intensywnym czarowaniu. Za przykład niech posłuży tutaj magiczny Zend Framework, który jest praktycznie nieużywalny bez IDE oraz sporej wiedzy encyklopedycznej.

Jedyną radą jaką jestem w stanie wam udzielić będzie – “use the force”, ale z głową.