Jak wygląda uzycie Method chaining w praktyce?

Jest on stosowany w wielu różnych językach, a webdeveloperzy mogą go znaleźć między innymi w jQuery lub frameworkach PHP. Upraszcza to znacznie tworzenie kodu, co można zobaczyć na poniższym przykładzie:

$("p").removeClass("class")
	.addClass("another_class")
	.css("color","red")
	.fadeOut("slow");

Jak zaimplementować Method chaining w PHP?

Bardzo podobnie możemy powyższe rozwiązanie wykorzystać w PHP. Jest to niezwykle proste do osiągnięcia, wystarczy, że poszczególne wywoływane metody będą zwracały cały obiekt. Przez to nie będzie trzeba go podawać za każdym razem, lecz utworzyć odpowiedni łańcuch.

Na poniższym przykładzie przedstawiono implementację Method chaining. Jest to klasa bardzo uproszczonego kalkulatora, dzięki któremu możemy wykonywać podstawowe działania matematyczne.

class Calculator{
	private $_result = 0;

	public function __construct($value = 0) {
		$this->_result = $value;
		return $this;
	}

	public function add($value){
		$this->_result+=$value;
		return $this;
	}

	public function subtract($value){
		$this->_result-=$value;
		return $this;
	}

	public function multiply($value){
		$this->_result*=$value;
		return $this;
	}

	public function divide($value){
		$this->_result/=$value;
		return $this;
	}

	public function getResult(){
		return $this->_result;
	}
}

Implementacja Metchod chaining kryje się w wywołaniu return $this na końcu każdej metody odpowiedzialnej za działania matematyczne. Dzięki temu będzie możliwe niezwykle proste wykonanie obliczeń:

$calc = new Calculator(5);
print $calc->add(2)
		->subtract(1)
		->divide(2)
		->multiply(3)
		->getResult();

Pominięcie osobnego tworzenia obiektu

Możliwe jest także zastosowanie Method chaining bezpośrednio przy wywołaniu obiektu, dzięki czemu nie będziemy musieli tworzyć go w osobnej linii. Wystarczy w tym celu dodać do klasy Calculator statyczną metodę start(), która zwróci nam utworzony obiekt:

public static function start($value = 0){
	return new Calculator($value);
}

Dzięki takiemu rozwiązaniu możemy jeszcze bardziej uprościć wywołanie kalkulatora:

print Calculator::start(5)->add(4)->divide(3)->getResult();

Na czym polega błąd CVE-2012-182 zgłoszony przez De Eindbazen’a? Jeśli PHP działa w trybie CGI (np. Apache mod_cgid), możliwe jest przekazywanie dodatkowych parametrów wykonania skryptu. Niestety, z powodu błędnego przetwarzania parametrów w URL, które nie zawierają znaku „=”, umożliwia to potencjalnemu intruzowi wykonanie wielu niebezpiecznych czynności. Jedną z nich może być na przykład wyświetlenie kodu przetwarzanego skryptu, czego można dokonać, używając parametru -s w następujący sposób:

http://localhost/index.php?-s

Parametr w postaci ?-s&=1 jest jednak całkowicie bezpieczny.

Po wydaniu poprawki 5.4.2 i 5.3.12, która miała rozwiązać problem okazało się, że część systemów bazujących na PHP w konfiguracji CGI jest nadal podatna na niebezpieczeństwo. Opublikowane 8 maja wersje PHP 5.4.3 i 5.3.13 powinny ostatecznie rozwiązywać ten problem.

Ci, którzy nie mogą dokonać aktualizacji, powinni do zabezpieczenia się wykorzystać odpowiednie reguły mod_rewrite Apache. Jak podano na php.net, można skorzystać z następującego rozwiązania:

RewriteCond %{QUERY_STRING} ^[^=]*$
RewriteCond %{QUERY_STRING} %2d|\- [NC]
RewriteRule .? - [F,L]

Należy jednak uważać, gdyż powyższe reguły mogą zablokować część poprawnych Urli (np. ?top-40). Z tego względu należy je przetestować i dopasować do swoich potrzeb.

Wersja PHP 5.4.3 dodatkowo rozwiązuje problem z przepełnianiem bufora w apache_request_headers() (CVE-2012-2329). PHP 5.3 nie jest podatne na ten błąd.

Lista poprawek odnosi się zarówno do jądra języka, jak i niektórych rozszerzeń. Pełną listę zmian, jakie zostały dokonane w wersjach PHP 5.4.1.oraz 5.3.11, można znaleźć tutaj. Oczywiście wszystkim użytkownikom zaleca się ze względów bezpieczeństwa jak najszybsze uaktualnienie do najnowszej wersji.

W PHP mamy do dyspozycji łącznie 9 typów zmiennych:

• 4 typy proste – logiczny, całkowity, zmiennoprzecinkowy i znakowy
• 2 złożone – tablicowy i obiektowy
• 3 specjalne – identyfikator zasobu (resorce), pusty (NULL) oraz wywoływalny (callable)

Podpowiadanie typów w PHP nie umożliwia niestety rozpoznawania wszystkich wymienionych powyżej. Od wersji 5 języka możemy to robić dla obiektów, interfejsów, tablic (od PHP 5.1), oraz parametrów wywoływalnych (PHP 5.4).

Podpowiadanie typów możemy stosować w zwykłych funkcjach, oraz metodach klas. Wystarczy w tym celu przed nazwą zmiennej podać oczekiwany typ (array, callable, nazwę konkretnej klasy lub interfejsu)

Podpowiadanie typów – obiekty

W przypadku podpowiadania typów obiektowych należy pamiętać o bardzo ważnej rzeczy: jeśli parametrem musi być konkretna klasa lub interfejs, dozwoleni są także ich potomkowie, uczestniczący w hierarchii dziedziczenia.

Gdy zostanie określony wymagany typu obiektu, przekazanie innego spowoduje powstanie błędu. Zostało to pokazane na poniższym przykładzie:

class Factory{
	public function produce(Product $product){
		print "Produkuję " . get_class($product);
	}
}

class Stock{
	/* ... */
}

class Product{
	/* ... */
}

class Car extends Product{
	/* ... */
}

class Motorbike extends Product{
	/* ... */
}

$factory = new Factory();
$stock = new Stock();
$car = new Car();
$motorbike = new Motorbike();

$factory->produce($car);
$factory->produce($motorbike);
$factory->produce($stock);

Zdefiniowane zostały klasy: Factory, Stock, Product oraz dziedziczące po nim Car oraz Motorbike. Klasa fabryki posiada zdefiniowaną jedną metodę, odpowiadającą za produkcję. Wymaga ona przekazania obiektu typu Product. Na powyższym listingu przekazano do niej natomiast dozwolone parametry wywodzące się z klasy Product, ale na koniec omyłkowo także Stock. Efekt będzie następujący:

Produkuję Car
Produkuję Motorbike
Fatal error: Argument 1 passed to Factory::produce() must be an instance of 
Product, called in typehinting.php on line 31 and defined in typehinting.php 
on line 3

Jak wspomniano już wcześniej, podpowiadanie typów w przypadku obiektów działa zarówno dla utworzonych bezpośrednio, jak i dziedziczących po określonym w definicji. Poprawne będzie więc też następujące wywołanie:

$factory = new Factory();
$product = new Product();

$factory->produce($product);

W powyższym przypadku może nie jest to do końca pożądane, jednak w praktyce częściej będziemy oczekiwali obiektów klas dziedziczących. Oczywiście, gdy tego chcemy, możemy zawęzić wymagany typ tylko do klasy pochodnej.

class Factory{
	public function produce(Car $product){
		print "Produkuję tylko samochody";
	}
}

W przypadku podpowiadania typów można stosować także wartości domyślne. Jeśli w naszej fabryce przewidujemy strajk, możemy posłużyć się następującą definicją:

class Factory{
	public function produce(Product $product = null){
		print "Produkuję" . get_class($product);
	}
}

$factory = new Factory();
$factory->produce();

Analogicznie do powyższych informacji, podpowiadanie typów może być używane także w przypadku interfejsów. Wystarczy określić, że parametr musi implementować jeden ze zdefiniowanych. Aby zobrazować tą możliwość, dokonamy pewnych zmian klas z pierwszego przykładu. Otóż w naszej fabryce w Indiach zamierzamy wyprodukować limitowaną wersję samochodu, o zwiększonej mocy silnika. Klasa fabryki otrzyma więc dodatkową możliwość produkcji, a specyfikacja samochodu zostanie odpowiednio zmodyfikowana poprzez implementację interfejsu (pominięto tu klasy zdefiniowane w pierwszym przykładzie):

interface limitedEdition{
	public function engineImprovements();
}

class carSpecial extends car implements limitedEdition{
	public function engineImprovements(){
		print "Zwiększona moc silnika";
	}
}

class FactoryIndia extends Factory {
	public function produceSpecialCar(limitedEdition $car){
		print "Produkuję limitowaną wersję samochodu.";
	}
}

$factoryIndia = new FactoryIndia();
$car = new car();
$carSpecial = new carSpecial();

$factoryIndia->produceSpecialCar($carSpecial);
$factoryIndia->produce($car);
$factoryIndia->produceSpecialCar($car);

Efekt wywołania kodu będzie następujący:

Produkuję limitowaną wersję samochodu.
Produkuję Car
Fatal error: Argument 1 passed to FactoryIndia::produceSpecialCar() must implement 
interface limitedEdition, called in typehinting.php5 on line 43 and defined in 
typehinting.php on line 32

Jak widać, najpierw wyprodukowano edycję limitowaną samochodu przy użyciu nowej linii produkcyjnej, a następnie powrócono do wersji zwykłej. W kolejnym kroku, w wyniku błędu pracownika, uruchomiono jednak ponownie zmodyfikowaną linię produkcyjna dla wersji podstawowej samochodu, co oczywiście zostało szybko wychwycone przez inspektorów kontroli jakości.

Podpowiadanie typów – tablice

Sytuacja jest analogiczna do opisywanych powyżej możliwości w przypadku obiektów. Poniższy przykład obrazuje w jaki sposób zastrzec, aby zdefiniowana funkcja akceptowała jako parametr tylko tablicę:

function needArray(array $param){
	print_r($param);
}

$array = array(1, 2, 3);

needArray($array);

Możemy także określić domyślą tablicę, dzięki czemu możliwe będzie wywołanie funkcji bez żadnego parametru:

function needArray(array $param = array(7, 8, 9)){
	print_r($param);
}

Podpowiadanie typów – callable

Jest to najnowsza możliwość podpowiadania typów, wprowadzona w PHP 5.4. Dzięki niej można określić, że parametr przekazywany do funkcji lub metody musi być wywoływalny. Ma to zastosowanie w przypadku stosowania callbacków oraz funkcji anonimowych.

function myFunction(callable $callback) {
	echo "Wywołuję callback: " . $callback();
}

myFunction(function() { return 'Witaj!'; });

Podsumowanie

Jak widać na przedstawionych przykładach, wykorzystanie podpowiadania typów jest niezwykle przydatne i znacznie upraszcza tworzony kod. Nie musimy aż tak wnikliwie sprawdzać przekazywanych argumentów przy pomocy is_array() lub instanceof. Mam nadzieję, że w type hinting w kolejnych wersjach PHP zostanie rozszerzone o typy proste.

Większa wydajność

Według opinii zamieszczonych w sieci, PHP 5.4 jest nawet o połowę szybsze i zużywa o  połowę mniej pamięci w stosunku do wersji 5.3.

Wbudowany serwer WWW

Do PHP 5.4 jest dołączany uproszczony web serwer, dostępny z poziomu linii komend. Został stworzony tylko do celów developerskich i nie powinien być wykorzystywany w środowisku produkcyjnym.

Cechy (traits)

Jedna z najbardziej komentowanych nowości w PHP 5.4, wprowadza możliwość dziedziczenia po wielu klasach. Cechy definiowane są analogicznie do normalnych klas, z wykorzystaniem słowa trait.

Klasy mogą korzystać z wielu cech, które są wymieniane po przecinkach po słowie use. Same cechy także mogą zawierać inne, tworząc ich zbiory. Aby uniknąć konfliktu nazw, możemy wykorzystać składnię insteadof, dzięki której okreslimy, która metoda jest ważniejsza. Oprócz tego możemy z wykorzystaniem słowa use tworzyć dla nich aliasy.

<?php
trait A {
    public function smallTalk() {
        echo 'a';
    }
    public function bigTalk() {
        echo 'A';
    }
}

trait B {
    public function smallTalk() {
        echo 'b';
    }
    public function bigTalk() {
        echo 'B';
    }
}

class Talker {
    use A, B {
        B::smallTalk insteadof A;
        A::bigTalk insteadof B;
    }
}

class Aliased_Talker {
    use A, B {
        B::smallTalk insteadof A;
        A::bigTalk insteadof B;
        B::bigTalk as talk;
    }
}
?>

Oprócz tego słowo use może być wykorzystane do zmiany widoczności metody w klasie. Widać to na poniższym przykładzie:

public function sayHello() {
        echo 'Hello World!';
    }
}

class MyClass1 {
    use HelloWorld { sayHello as protected; }
}

class MyClass2 {
    use HelloWorld { sayHello as private myPrivateHello; }
}

W związku z traits, wprowadzono także nową funkcję class_uses(), która generuje tablicę z cechami, jakich używa dana klasa:

trait foo{}
class bar{
use foo;
}
print_r(class_uses(new bar));
print_r(class_uses('bar'));

Możliwości traits są znacznie bardziej rozbudowane, przedstawiłem tu jedynie podstawowe informacje. Cechy są jedną z nowości, które wzbudzają dużo emocji. Są bardzo oczekiwanym elementem, który może znacznie poprawić możliwości PHP. Jednak z drugiej strony wiele osób przestrzega przed nadużywaniem cech, co może doprowadzić do pogorszenia jakości kodu.

Skrócona składnia definiowania tablic

Dodany został nowy sposób na definiowanie tablic, z zastosowaniem nawiasów kwadratowych:

$array1 = ["foo" => "bar", "bar" => "foo"];
$array2 = [1, 23, 34, "foo"];
$array3 = [1, 2, 3, ["a", "b", "c"], "x" => [7, 8, 9]];

Bezpośredni dostęp do elementu tablicy zwracanej przez funkcję (array dereferencing)

Dotychczas, aby odwołać się do konkretnego elementu tablicy zwracanej przez funkcję, należało najpierw pobrać ją całą do zmiennej, a następnie wybrać ten, który nas interesuje. W PHP 5.4 można to zrobić od razu, wskazując element tablicy bezpośrednio w wywołaniu funkcji:

function myFunction() {
   return array(1, 2, 3);
}

echo myFunction()[1];

Wywoływanie metody klasy w zapisie tablicowym (indirect method call)

Istnieje obecnie możliwość wywołania funkcji danej klasy, podając w tablicy nazwę klasy oraz metodę. Obrazuje to poniższy przykład:

class MyClass {
    public function myFunction($name) {
        echo "Witaj $name!";
    }
}

$fn = array('MyClass', 'myFunction');
$fn("Marcin");

Podpowiadanie typów dla callbacków (callable typehint)

W przypadku callbacków możemy teraz stosować określenie typu parametru za pomocą słowa callable. Na poniższym przykładzie pokazano, jak można w ten sposób wymagać określonego parametru przez zdefiniowana funkcję:

function myFunction(callable $callback) {
   echo "Wywołuję callback: " . $callback();
}

myFunction(function() { return 'Witaj!'; });

W przypadku, gdy do funkcji zostanie przekazana zmienna innego typu, otrzymamy odpowiedni błąd:

Catchable fatal error: Argument 1 passed to myFunction() must be callable, integer given, called in …

Możliwość użycia $this przy funkcjach anonimowych (closures)

W przypadku stosowania closure i obiektów, nie było możliwe normalne korzystanie z konstrukcji $this (istnieją pewne obejścia tego problemu). Kończyło się to odpowiednim błędem:

Fatal error: Using $this when not in object context in …

Najnowsza wersja PHP rozwiązuje ten problem, wynikiem działania skryptu będzie wyświetlenie zawartości zmiennej $value.

class MyClass 
{
  private $value = „PHP 5.4”;
  public function myFunction()
  {
    return function() { return $this->value; };
  }
}
 
$a = new MyClass;
$fn = $a->myFunction();
echo $fn();

Notacja binarna dla liczb całkowitych

Dotychczas możliwe było definiowanie liczb całkowitych w systemie dziesiętnym, ósemkowym oraz szesnastkowym, stosując odpowiednie przedrostki. PHP 5.4 wprowadza taką możliwość także dla liczb binarnych, z wykorzystaniem 0b. Poniżej przedstawiono liczbę 28 w różnych notacjach, ostatnia jest możliwa tylko w najnowszej wersji PHP:

$dec = 28;
$oct = 034;
$hex = 0x1c;
$bin = 0b11100;

Śledzenie postępu uploadu

W PHP wbudowano możliwość śledzenia postępu wysyłania danych poprzez formularze. Funkcjonalność jest domyślnie włączona, jej konfiguracja opiera się na grupie zmiennych session.upload_progress.* w php.ini. Dzięki niej możemy określić, jaka ilość danych została już wysłana.

Inne nowości

Na zakończenie kilka innych zmian, nie wymagających szczegółowego opisu:

• Instrukcje break i continue nie będą już przyjmować zmiennych, należy w tym celu stosować stałe
• Konstrukcja <?= jest obecnie dostępna niezależnie od ustawienia short_open_tag w php.ini
• Usunięcie opcji register_globals – definitywny koniec zmiennych globalnych, które zostały domyślnie wyłączone już PHP 4.2
• Usunięcie opcji register_long_arrays z php.ini – całkowite zrezygnowanie ze starych tablic $HTTP_*_VARS na rzecz krótkiego zapisu (np. $_GET zamiast $HTTP_GET_VARS)
• Konwersja tablicy na string powoduje Notice

Podsumowanie

Jak już wcześniej wspomniałem, pełna lista zmian w PHP 5.4 jest niezwykle długa. Wszystkich zainteresowanych odsyłam do dokumentacji. Warto je testować, gdyż wiele z nich może być bardzo pomocna. Oczywiście jak w każdej dziedzinie należy także i tu stosować rozwagę. Pozostaje tylko pytanie, kiedy osoby korzystające z wirtualnych serwerów WWW będą mogly skorzystać z nowych funkcjonalności PHP. Biorąc pod uwagę zwiększenie wydajności nowej wersji (co podoba się hostingodawcom), miejmy nadzieję, że nie będą musiały czekać zbyt długo.

Metoda __callStatic()

Metoda ta pojawiła się stosunkowo niedawno, bo dopiero w PHP 5.3. Jest bardzo podobna do omawianej w poprzedniej części zestawienia metody __call(). Tak jak ona jest używania w momencie wywołania nieistniejącej metody, jednak tylko w przypadku, gdy nastąpiło to w sposób statyczny (tak też musi być sama zdefiniowana). Jako parametry __callStatic() przyjmuje kolejno nazwę wywołanej metody oraz tablicę zawierającą przekazane do niej parametry. Na poniższym przykładzie widać porównanie obu metod:

class TestCall
{
	public function __call($nazwa, $argumenty)
	{
		echo "Wywołano metodę $nazwa z parametrami: " . implode(',', $argumenty) . PHP_EOL;
	}

	public static function __callStatic($nazwa, $argumenty)
	{
		echo "Wywołano statycznie metodę $nazwa z parametrami: " . implode(',', $argumenty) . PHP_EOL;
	}
}
$obj = new TestCall();
$obj->nieistniejacaMetoda('normalne wywołanie');
TestCall::nieistniejacaMetoda('statyczne wywołanie');

Wynik działania powyższego skryptu będzie następujący:

Wywołano metodę nieistniejacaMetoda z parametrami: normalne wywołanie 
Wywołano statycznie metodę nieistniejacaMetoda z parametrami: statyczne wywołanie 

Metody __isset() oraz __unset()

Pierwsza jest wywoływana w momencie, gdy pojawia się próba dostępu do nieistniejącej właściwości obiektu poprzez funkcję isset() lub empty(). Metoda __unset() jest natomiast wywoływana podczas  wykonywania funkcji unset() na nieistniejącej właściwości. Obie przyjmują jako parametr nazwę wywołanej właściwości. Poniższy przykład obrazuje sposób działania opisanych metod:

class TestowaKlasa
{
   public function __unset($nazwa)
   {
      echo "Nie można usunąć '$nazwa', zmienna nie isnieje!" . PHP_EOL;
   }

   public function __isset($nazwa){
      echo "Właściwość '$nazwa' nie istnieje!" . PHP_EOL;
   }
}

$obj = new TestowaKlasa();

unset($obj->nieistniejacaWlasciwosc);
isset($obj->nieistniejacaWlasciwosc);

Efekt działania będzie następujący:

Nie można usunąć 'nieistniejacaWlasciwosc', zmienna nie isnieje!
Właściwość 'nieistniejacaWlasciwosc' nie istnieje!

Metoda __invoke()

Została wprowadzona w PHP 5.3 i jest wywołana w momencie, gdy następuje próba użycia obiektu w sposób przeznaczony dla funkcji. Poszczególne parametry odpowiadają tym użytym w wywołaniu obiektu. Warto pamiętać, że gdy klasa posiada zdefiniowaną metodę __invoke(), zastosowanie na jej obiekcie funkcji is_callable() zwróci w rezultacie true.

class MojaKlasa 
{
   public function __invoke($parametr1, $parametr2)
   {
      var_dump($parametr1, $parametr2);		
   }	
}

$obj = new MojaKlasa();
$obj('abc', 123);
var_dump(is_callable($obj));

Wynik działania powyższego skryptu będzie następujący:

string(3) "abc"
int(123)
bool(true)

Metoda __set_state()

Jest to metoda statyczna, która jest wywoływana w momencie użycia na klasie funkcji var_export(). Przyjmuje jeden parametr, zawierający eksportowane właściwości w formacie: array('wlasciwosc1' => wartosc, 'wlasciwosc2' => wartosc, …). Obrazuje to przykład zaczerpnięty z dokumentacji:

class MojaKlasa
{
    public $w1;
    public $w2;

    public static function __set_state($tab)
    {
        $obj = new MojaKlasa();
        $obj->w1 = $tab['w1'];
        $obj->w2 = $tab['w2'];
        return $obj;
    }
}

$obj = new MojaKlasa();
$obj->w1 = 123;
$obj->w2 = 'abc';

eval('$b = ' . var_export($obj, true) . ';'); 
var_dump($b);

object(MojaKlasa)#2 (2) {
  ["w1"]=>
  int(123)
  ["w2"]=>
  string(3) "abc"
}

Podsumowanie

To była ostatnia część z cyklu „Metody magiczne w PHP”. W poszczególnych artykułach omówiłem wszystkie, jakie występują w PHP 5.3. Mam nadzieję, że wyjaśniły one mechanizmy, które mogą być bardzo przydatne w programowaniu obiektowym.

Opisane poniżej metody są często stosowane podczas instalacji popularnych systemów CMS, forum itd. Podczas tego procesu sprawdzana jest wersja PHP i w przypadku wykrycia zbyt starej, proces  jest przerywany. Warto w ten sposób zabezpieczyć własne skrypty zwłaszcza, gdy nie oferują one pełnej zgodności wstecz i są rozpowszechniane publicznie.

Metody standardowe

Najprostszym sposobem na sprawdzenie wersji PHP jest wywołanie funkcji phpinfo(). Jej wynikiem jest jednak ogromna liczba danych dotyczących konfiguracji całego serwera. Jeśli natomiast mamy dostęp do wywołania poleceń shell, to możemy skorzystać z jednej z dwóch poniższych możliwości:

php -v
php -–version

Oczywiście nie jest to dobre rozwianie, gdyż nie zawsze jest taka możliwość. Po pierwsze musimy mieć dostęp do funkcji shell_exec() lub exec() a z tym może być kłopot. Po drugie do sprawdzania wersji PHP przyda się bardziej wyrafinowana metoda. Możemy to zrealizować na dwa sposoby: za pośrednictwem odpowiedniej funkcji oraz predefiniowanych stałych.

Funkcja phpversion()

Zwraca ona po prostu dostępną na serwerze wersję PHP. W przypadku podania jako parametr wywołania nazwy konkretnego rozszerzenia, efektem wywołania będzie jego „aktualny numerek”. Może to wyglądać następująco:

echo "Wersja PHP: ".phpversion();
echo "Wersja PDO MySQL: ".phpversion('pdo_mysql');

Efektem działania skryptu może być:

Wersja PHP: 5.3.4
Wersja PDO MySQL: 1.0.2

Stałe PHP_VERSION_*

Innym sposobem na określenie wersji PHP jest skorzystanie ze zmiennych predefiniowanych. Jest ich kilka, wszystkie poza pierwszą dostępne są od PHP 5.2.7 wzwyż:

• PHP_VERSION – (string) bieżąca wersja PHP przedstawiona w formacie GłównaWersja.MniejszaWersja.Wydanie[extra], np. 5.2.0[RC2]
• PHP_MAJOR_VERSION – (integer) określa „główną wersję” (pierwsza liczba)
• PHP_MINOR_VERSION – (integer) określa „mniejszą wersję” (druga liczba)
• PHP_RELEASE_VERSION – (integer) określa wydanie (trzecia liczba)
• PHP_VERSION_ID – (integer) pełna wersja przedstawiana jako liczba, przydatna do porównywania, np. 50304 (czyli 5.3.4)
• PHP_EXTRA_VERSION – (string) dodatkowe określenie wydania np. dev lub RC1

Wywołanie poszczególnych zmiennych może wyglądać następująco:

echo "Wersja PHP: " . PHP_VERSION . "<br />";
echo "- głowna wersja: " . PHP_MAJOR_VERSION . "<br />";
echo "- mniejsza wersja: " . PHP_MINOR_VERSION . "<br />";
echo "- wydanie: " . PHP_RELEASE_VERSION . "<br />";
echo "Wersja PHP jako liczba: " . PHP_VERSION_ID . "<br />";
echo "Określenie wersji: " . PHP_EXTRA_VERSION . "<br />";

Wersja PHP: 5.3.4
- główna wersja: 5
- mniejsza wersja: 3
- wydanie: 4
Wersja PHP jako liczba: 50304
Określenie wersji:

Jeśli korzystamy z wersji PHP starszej niż 5.2.7, a chcemy mieć dostępne wszystkie powyższe zmienne, możemy je sami zdefiniować (cytując dokumentację):

if (!defined('PHP_VERSION_ID')) {
    $version = explode('.', PHP_VERSION);

    define('PHP_VERSION_ID', ($version[0] * 10000 + $version[1] * 100 + $version[2]));
}

if (PHP_VERSION_ID < 50207) {
    define('PHP_MAJOR_VERSION',   $version[0]);
    define('PHP_MINOR_VERSION',   $version[1]);
    define('PHP_RELEASE_VERSION', $version[2]);

    // itd.
}

Porównywanie wersji PHP przy pomocy version_compare()

Oczywiście stosując przedstawione metody, możemy porównać wersję PHP tak, jak to zostało już pokazane w powyższym przykładzie przy pomocy instrukcji if oraz zmiennej  PHP_VERSION_ID. Możemy to także zrobić, korzystając ze specjalnie stworzonej w tym celu funkcji version_compare().

Może ona działać na dwa sposoby. W obu przyjmuje jako dwa pierwsze parametry wersje PHP do porównania w formacie X.X.X. Gdy podamy tylko tyle, zwróci ona -1 w przypadku, gdy pierwsza podana wersja jest niższa od drugiej, 0 jeśli są takie same lub 1 gdy druga jest mniejsza.

Funkcja może także przyjąć trzeci, opcjonalny parametr, określający rodzaj porównania: <=, le, >, gt, >=, ge, ==, =, eq, !=, <>, ne. W takim przypadku zwróci ona true gdy warunek jest spełniony lub, w przeciwnym wypadku, false.
Sposób użycia został przedstawiony na poniższym przykładzie:

if (version_compare(PHP_VERSION, '5.0.0') >= 0) {
    echo 'Używasz PHP5. Twoja wersja to' . PHP_VERSION;
}

if (version_compare(PHP_VERSION, '5.3.8', '<=')) {
    echo 'Twoja wersja PHP nie jest najnowsza! Używasz :' . PHP_VERSION;
}

Jeśli ostatni przykład jest nieaktualny, proszę zwrócić uwagę na datę powstania artykułu

Rozszerzenie do obsługi EXIF zawiera w PHP kilka ciekawych funkcji. Aby było ono dostępne, PHP musi zostać skompilowane z opcją -–enable-exif. Najbardziej przydatną w omawianym przykładzie będzie oczywiście exif_read_data(), która odczytuje nagłówek z plików JPG oraz TIFF. Zwraca ona tablicę z danymi określającymi urządzenie oraz szczegółowe parametry zdjęcia. Funkcja przyjmuje następujące parametry:

array exif_read_data ( string $filename [, string $sections = NULL [, bool $arrays = false [, bool $thumbnail = false ]]] )

Kolejno oznaczają one:

• filename – nazwa pliku, z którego odczytujemy dane
• sections – lista sekcji, jakie mają zostać odczytane, np. FILE, COMPUTED, THUMBNAIL, itd. Gdy parametr nie zostanie określony, odczytane zostaną wszystkie
• arrays – określa, czy poszczególne sekcje mają zostać tablicami. COMPUTED, THUMBNAIL oraz COMMENT zawsze zostają zwrócone w ten sposób, gdyż mogą zawierać nazwy powodujące konflikt z innymi sekcjami.
• thumbnail – gdy ustawiony na true, zostanie odczytana miniaturka

Standardowe wywołanie funkcji spowoduje pobranie wszystkich danych ze zdjęcia. W przypadku, gdy wykonano je urządzeniem z GPS, pojawią się dodatkowe pola. Pierwszym miejscem, gdzie je zauważymy, jest lista sekcji:

[SectionsFound] => ANY_TAG, IFD0, THUMBNAIL, EXIF, GPS

Wystarczy sprawdzić poszczególne pola, aby oprócz informacji na temat urządzenia oraz parametrów wykonanego zdjęcia, znaleźć także dane GPS. Mogą one wyglądać następująco:

    [GPSLatitudeRef] => N
    [GPSLatitude] => Array
        (
            [0] => 33/1
            [1] => 52/1
            [2] => 129675/4096
        )

    [GPSLongitudeRef] => W
    [GPSLongitude] => Array
        (
            [0] => 116/1
            [1] => 18/1
            [2] => 23882/4096
        )

    [GPSAltitudeRef] => 
    [GPSAltitude] => 304/1

Jak widać na przedstawionym przykładzie, możemy odczytać szczegółowe dane na temat współrzędnych geograficznych miejsca, w którym wykonano zdjęcie. Są one wyrażone w stopniach, GPSLatitude oraz GPSLongitude zawierają tablice z odpowiednimi danymi: [0] – stopnie, [1] – minuty, [2] – sekundy (należy podzielić dane liczby). Aby uzyskać stosowane częściej w Google Maps oraz innych serwisach wartości dziesiętne, musimy odpowiednio przeliczyć powyższe dane. Należy w tym celu skorzystać ze wzoru:

DD = D + M/60 + S/3600

gdzie D to stopnie, M to minuty, a S to sekundy.

Należy także pamiętać, że w zależności od szerokości i długości geograficznej określonej w GPSLatitudeRef oraz GPSLongitudeRef musimy postawić odpowiednio znak minus. W tym przypadku jest tak dla drugiej wartości, która wskazuje na zachód (podobnie należy zrobić dla południa).

Ostatecznie przeliczone współrzędne posiadają następujące wartości 33.87555556 oraz -116.30166667 (dla 33° 52' 32" N i 116° 18' 06" W).

Tablica z danymi GPS zawiera także wartość GPSAltitude, która określa wysokość w metrach, na jakiej wykonano zdjęcie.

Metoda __toString

Niniejsza metoda zwraca tekstową reprezentację obiektu i zostanie wywołana w momencie, gdy będziemy chcieli go wyświetlić, na przykład przy pomocy instrukcji echo lub print. Gdy nie zdefiniujemy __toString(), efektem takiego działania będzie błąd i zatrzymanie skryptu:

Catchable fatal error: Object of class MyClass could not be converted to string in /sciezka/do/skryptu/skrypt.php on line 13

Ważną rzeczą jest, że metoda musi na koniec działania zwracać wartość tekstową. Jeśli będzie to liczba, tablica lub obiekt, wygenerowany zostanie błąd. Można w takim przypadku skorzystać z konwersji typów (rzutowania). Na poniższym skrypcie przedstawiono zastosowanie omawianej metody:

class MyClass
{
	private $variable;
	
	public function __construct($parametr)
	{
		$this->variable = $parametr;
	}
	
	public function __toString()
	{
		return $this->variable;		
	}
}

$object = new MyClass("abc");
echo $object;

Efektem działania skryptu będzie po prostu wyświetlenie zawartości właściwości $variable, czyli abc.

Metoda __clone()

W PHP5 w odróżnieniu od wersji 4 wszystkie obiekty reprezentowane są przez referencję. Nie jest więc możliwe bezpośrednie tworzenie kopii obiektów. Poniższy kod spowoduje przypisanie pod  $anotherObject referencji do $object:

$object = new MyClass();
$anotherObject = $object;

W takim przypadku zmiana jednego z obiektów spowoduje więc jednoczesną zmianę drugiego.

Aby utworzyć kopię, musimy skorzystać z instrukcji clone:

$object = new MyClass();
$anotherObject = clone $object;

Utworzenie obiektu w powyższy sposób spowoduje, że w przypadku jakiejkolwiek modyfikacji, zmieniamy tylko jeden z nich.

Metoda __clone() jest wywoływana właśnie podczas klonowania obiektu. Dzięki temu możemy wprowadzić w nim określone zmiany. Przedstawiono to na poniższym przykładzie:

class MyClass
{
	private $id;
	
	private $variable;
		
	public function __construct($variable)
	{
		$this->id = md5(rand());
		$this->variable = $variable;
	}
	
	public function __clone()
	{
		$this->id = md5(rand());				
	}
}

$object = new MyClass("abc");
$object = clone $object;

var_dump($object);
var_dump($object);

Wynik działania skryptu będzie następujący:

object(MyClass)#2 (2) {
  ["id":"MyClass":private]=>
  string(32) "d204e0411e7921f0b468ddb52ea87fc7"
  ["variable":"MyClass":private]=>
  string(3) "abc"
}
object(MyClass)#2 (2) {
  ["id":"MyClass":private]=>
  string(32) "d204e0411e7921f0b468ddb52ea87fc7"
  ["variable":"MyClass":private]=>
  string(3) "abc"
}

Po utworzeniu obiektu $object z podaniem jednego parametru, następuje jego sklonowanie. Konstruktor klasy przypisuje przekazany parametr do odpowiedniej właściwości oraz dodatkowo generuje unikalny identyfikator. Jak jednak widać metoda __clone() wywoływana podczas kopiowania obiektu generuje nowy identyfikator. Widać to wyraźnie po wyświetleniu zawartości obiektów: oba mają tę samą wartość zmiennej $variable, jednak różne $id.

Metody __sleep() i __wakeup()

Kolejne dwie metody magiczne wywoływane są w przypadku serializacji obiektów. Polega ona (tak samo jak w przypadku tablic), na przekształceniu struktury danych na postać łańcucha znaków, możliwego do ponownego przekształcenia w obiekt. Wykorzystuje się do tego celu funkcje serialize() oraz unserialize().

Dzięki metodom __sleep() oraz __wakeup() możemy dokonać modyfikacji obiektu oraz wybrać właściwości, które będą poddane serializacji. Metody te nie przyjmują żadnych parametrów, ale __sleep() powinna zwracać indeksowaną tablicę zawierającą nazwy właściwości, jakie poddane zostaną operacji.

Na poniższym przykładzie przedstawiono działanie metod:

class MyClass
{
	private $id;
	private $variable1;
	private $variable2;
		
	public function __construct($variable1, $variable2)
	{
		$this->id = md5(rand());
		$this->variable1 = $variable1;
		$this->variable2 = $variable2;
	}
	
	public function __sleep()
	{
		return array("variable1");		
	}
	
	public function __wakeup()
	{
		$this->id = md5(rand());				
	}
}

$object = new MyClass(123, "abc");
$object_s = serialize($object);
$object_u = unserialize($object_s);

echo "Obiekt:";
var_dump($object);

echo "Obiekt po serialize():";
var_dump($object_s);

echo "Obiekt po unserialize():";
var_dump($object_u);

Efekt działania skryptu będzie następujący:

Obiekt:object(MyClass)#1 (3) {
  ["id":"MyClass":private]=>
  string(32) "c57ec22b3055e619b765e52dbe9dc5f1"
  ["variable1":"MyClass":private]=>
  int(123)
  ["variable2":"MyClass":private]=>
  string(3) "abc"
}

Obiekt po serialize():string(50) "O:7:"MyClass":1:{s:18:"MyClassvariable1";i:123;}"

Obiekt po unserialize():object(MyClass)#2 (3) {
  ["id":"MyClass":private]=>
  string(32) "857590827074cb64b4c0df198ecdc431"
  ["variable1":"MyClass":private]=>
  int(123)
  ["variable2":"MyClass":private]=>
  NULL
}

Na początku tworzony jest obiekt, którego konstruktor przypisuje do dwóch właściwości przekazane parametry, oraz dodatkowo ustala pseudolosowy identyfikator. Następuje później serializacja obiektu, która zmienia jego postać na łańcuch znaków. W tym momencie wywoływana jest metoda __sleep(), która wybiera tylko jedną z właściwości do przechowania. W kolejnym kroku wykonywana jest czynność przywrócenia obiektu, w wyniku której uruchomiona zostaje __wakeup(). Dzięki temu $variable1 zostaje odzyskana, jednak druga właściwość $variable2 już nie (została pominięta w __sleep()). Dodatkowo wylosowany zostaje nowy identyfikator.

Ciąg dalszy nastąpi…

W stosunku do poprzedniej wersji RC1 poprawiono błędy w jądrze PHP oraz Zend Engine. Dodatkowo od tej edycji PHP-FPM nie będzie oznaczone jako eksperymentalne. Pełną listę zmian można znaleźć tutaj.

Do czasu wydania ostatecznej wersji PHP 5.4.0 nie będą już dodawane nowe funkcjonalności, a prowadzone prace mają się skupić wyłącznie na wyeliminowaniu występujących błędów i poprawieniu stabilności działania.