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.

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.

Konstruktor i destruktor

Są to dwie podstawowe metody, których wywołanie następuje odpowiednio podczas tworzenia nowego obiektu oraz przy jego usuwaniu. Konstruktor służy do zainicjowania obiektu, przypisania właściwości oraz wykonania podstawowych operacji podczas jego tworzenia.

Destruktor jest wywoływany automatycznie w momencie usuwania obiektu. Bardzo ważne jest to, że samodzielne wywołanie tej metody nie usuwa obiektu. W przypadku takiego działania zostanie po prostu wykonany zdefiniowany w destruktorze kod, jednak obiekt będzie istniał dalej. Jeśli chcemy sami go usunąć , możemy skorzystać z jednej z następujących możliwości:

unset($object);
$object = null;

Nie mamy obowiązku definiowania konstruktora i destruktora, domyślnie są one puste.

Na poniższym przykładzie przedstawiono działanie konstruktora i destruktora:

class MyClass
{
   public $variable;
   public function __construct($variable)
   {
      $this->variable = $variable;
      echo "Obiekt został utworzony";
   }

   public function __destruct()
   {
      echo "Obiekt został zniszczony";
   }
}

$object = new MyClass(123);
$object->__destruct();
var_dump($object);

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

Obiekt został utworzony
Obiekt został zniszczony
object(MyClass)#1 (1) {
   ["variable"]=>
   int(123)
}
Obiekt został zniszczony

Jak  można zauważyć obiekt został utworzony, w wyniku czego nastąpiło wywołanie konstruktora, który przypisał odpowiednią właściwość. W kolejnym kroku wywołano destruktor, co jak widać w dalszej części nie usunęło obiektu, a jedynie wykonało jego kod (wyświetlenie komunikatu). Można to zaobserwować w wyniku funkcji var_dump(). Ostatecznie obiekt został usunięty w momencie zakończenia skryptu – destruktor został wywołany ponownie, tym razem automatycznie.

Metody __get() oraz __set()

Są to metody wywoływane w momencie, gdy następuje próba dostępu do nieistniejącej właściwości obiektu. Metoda __get() zostanie wykonana, gdy będziemy pobierali taką właściwość. Posiada ona jeden parametr, do którego zostaje przypisana nazwa wywoływanej właściwości.

Analogicznie metoda __set() wywoła się, gdy będziemy chcieli ustawić nieistniejącą właściwość obiektu. Przyjmuje ona dwa parametry, kolejno: nazwa oraz wartość.

Należy pamiętać, że gdy nie zdefiniujemy powyższych metod, to w przypadku odczytu nieistniejącej właściwości otrzymamy null, natomiast gdy będziemy chcieli do takiej przypisać wartość, zostanie ona w tym momencie utworzona.

Można to zobaczyć analizując działanie następującego skryptu:

class MyClass
{
   /* ... */
}

$object = new MyClass();
$object->undefinedVariable = 123;

var_dump($object);
var_dump($object->anotherUndefinedVariable);

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

object(MyClass)#1 (1) {
   ["undefinedVariable"]=>
   int(123)
}
NULL

Na poniższym przykładzie przedstawiono zasadę działania metod __get() oraz __set():

class MyClass
{
   public function __construct()
   {
      echo $this->undefinedVariable;
   }

   public function __get($name)
   {
      echo "Obiekt nie posiada właściwości $name";
   }

   public function __set($name,  $value)
   {
      echo "Obiekt nie posiada właściwości $name, nie można więc przypisać 
wartości $value";
   }
}

$object = new MyClass();
$object->anotherUndefinedVariable = 678;

Wynikiem działania skryptu będzie:

Obiekt nie posiada właściwości undefinedVariable
Obiekt nie posiada właściwości anotherUndefinedVariable, nie można więc 
przypisać wartości 678

W momencie tworzenia obiektu poprzez konstruktor nastąpiła próba odczytania zmiennej  undefinedVariable, co spowodowało wywołanie metody __get(). Gdy wykonano przypisanie do nieistniejącej właściwości anotherUndefinedVariable, aktywowana została metoda __set();

Metoda __call()

Metoda ta działa analogicznie do poprzednio omówionych, dotyczy jednak metod obiektu. W przypadku, gdy nie zdefiniujemy __cal() i wywołujemy nieistniejącą metodę, zostanie wyświetlony odpowiedni błąd, a działanie skryptu zatrzymane:

Fatal error:  Call to undefined method MyClass::undefinedMethod() 
in /sciezka/do/pliku/skrypt.php on line 13

Po zdefiniowaniu w klasie metody __call(), w takim przypadku błąd nie wystąpi i zostanie wykonany zawarty w niej kod. Przyjmuje ona dwa parametry: nazwę wywołanej metody oraz tablicę zawierającą przekazane zmienne. Przykładowe zastosowanie może być nastepujące:

class MyClass
{
   public function __call($name, $params)
   {
      echo "Metoda $name nie istnieje. Przekazane parametry:";
      print_r($params);
   }
}

$object = new MyClass();
$object->undefinedMethod(12, "a", "b");

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

Metoda undefinedMethod nie istnieje. Przekazane parametry:

Array
(
   [0] => 12
   [1] => a
   [2] => b
}

Ciąg dalszy nastąpi…

Sprawdzanie rozszerzenia pliku

Najprostszym możliwym testem dla pliku jest sprawdzenie jego rozszerzenia. Oczywiście w ten sposób jest on wykonywany niezwykle rzadko. Wystarczy, że rozdzielimy nazwę względem kropki i sprawdzimy ostatnią z części. Jest to oczywiście sposób bardzo zawodny, gdyż ktoś może zmienić rozszerzenie przed wgraniem na serwer. Na przykład plik PHP może zostać ukryty pod nazwą image.jpg. Wykorzystując następnie luki w naszym systemie, istnieje możliwość wykonania takiego kodu.

Sprawdzanie typu MIME w tablicy $_FILES

Znacznie częściej stosowanym sposobem na rozpoznawanie rodzaju pliku jest sprawdzenie typu MIME. Możemy to osiągnąć, analizując dane z formularza, konkretnie wartość $_FILES['type'].

Poniższy, bardzo uproszczony kod, wyświetla formularz HTML z jednym polem umożliwiającym wczytanie pliku. Po jego wysłaniu wyświetlone zostaną szczegółowe dane o pliku z tablicy $_FILES.

<html>
    <body>
        <form action="mime_test.php" method="post" enctype="multipart/form-data">
        	<label for="file">Filename:</label>
        	<input type="file" name="file" id="file" />
        	<input type="submit" name="submit" value="Submit" />
        </form>
    </body>
</html> 

<?php 
if($_POST){
    print_r($_FILES);    
}
?>

Wczytanie przykładowego zdjęcia zwróci w polu type wartość image/jpeg. Co się jednak stanie, gdy przez formularz wczytamy plik PHP ze zmienioną nazwą na jpg? Wynik może być dla niektórych zaskakujący – powyższy kod wyświetli informację, że wgrany został plik graficzny.

Dlaczego tak się dzieje? Otóż dane na temat pliku przekazywane są przez przeglądarkę, a większość z nich (wszystkie?) określa typ MIME po rozszerzeniu pliku. Tak więc wracamy do punktu wyjścia.

Wykrywanie pliku graficznego

Zawodność powyższych metod możemy naprawić jednym prostym rozwiązaniem. Wystarczy, że skorzystamy z funkcji getimagesize() z biblioteki GD, która zwraca wymiary pliku graficznego. Przykładowe wywołanie wraz z efektem może wyglądać nastepująco:

print_r(getimagesize('image.jpg'));

Array
(
    [0] => 979
    [1] => 734
    [2] => 2
    [3] => width="979" height="734"
    [bits] => 8
    [channels] => 3
    [mime] => image/jpeg
)

Otrzymujemy więc dane na temat wymiarów grafiki, palety kolorów, liczby kanałów oraz typu MIME. Jeśli spróbujemy naszego oszustwa ze zmianą rozszerzenia i użyjemy powyższej funkcji do sprawdzenia spreparowanego pliku PHP, funkcja zwróci wartość false.

var_dump(getimagesize('phpcode.jpg'));
bool(false)

Dzięki temu możemy sprawdzić, czy wgrywany plik jest faktycznie obrazkiem. Co jednak zrobić, gdy chcemy testować inne typy?

Sprawdzanie typu pliku po „magicznych bajtach”

Każdy plik zaczyna się od charakterystycznych bajtów, które identyfikują jego typ. Dla kilku popularnych typów, wyglądają one następująco (w zapisie szesnastkowym):

GIF87a:  47 49 46 38 37 61 
GIF89a:  47 49 46 38 39 61 
JFIF, JPE, JPEG, JPG: FF D8 FF E0 xx xx 4A 46 49 46 00 
AVI: 52 49 46 46 xx xx xx xx 41 56 49 20 4C 49 53 54 

Wystarczy więc je wczytać i sprawdzić, aby określić rodzaj. Na poniższym przykładzie przedstawiono sprawdzenie, czy dany plik to gif.

<?php
$file = fopen('image.gif', 'r');
$bytes = bin2hex(fread($file, 6));

if($bytes == '474946383761' || $bytes == '474946383961'){
    print 'To plik gif';
}
else{
    print 'To NIE JEST gif';
}

fclose($file);
?>

Działanie kodu jest niezwykle proste. Wczytujemy pierwsze 6 bajtów z pliku, po czym konwertujemy je na wartości hexadecymalne. Następnie porównujemy z odpowiednim schematem, który dla GIF może być 47 49 46 38 37 61 lub 47 49 46 38 39 61.

Długa lista „magicznych bajtów” dla najróżniejszych typów plików jest dostępna tutaj.

Możemy na jej podstawie stworzyć własną funkcję sprawdzającą. Oczywiście to także nie zabezpieczy nas w stu procentach. Możliwe jest bowiem stworzenie pliku z oszukanym nagłówkiem. Ten sposób, mimo że dość karkołomny, jest jednak znacznie lepszy od poprzednich.

Sprawdzanie typu przez Fileinfo

Niedogodności poprzednio opisanego sposobu można zlikwidować, stosując wbudowane w PHP funkcje Fileinfo. Są one obecne od wersji 5.3.0 języka, dla wcześniejszych możemy skorzystać z PECL. Oczywiście podczas kompilacji PHP należy się upewnić, że dołączamy powyższą bibliotekę.

Poniższe wywołanie pokazuje efekt sprawdzenia typu pliku jpg oraz PHP ze zmienionym rozszerzeniem.

<?php 
$file1 = 'image.jpg';
$file2 = 'phpcode.jpg';

$file_info = new finfo(FILEINFO_MIME);

print $file_info->file($file1, FILEINFO_MIME_TYPE); 
print $file_info->file($file2, FILEINFO_MIME_TYPE);
?>

Wynik wywołania skryptu:

image/jpeg
text/x-php

Wywołanie metody file posiada kilka innych wariantów, w zależności od drugiego parametru. Możemy między innymi sprawdzić kodowanie pliku oraz klika innych rzeczy.

Artykuł został oparty o tekst z bloga http://cakephp-php.blogspot.com.