Lis M. - PHP 5. Praktyczny kurs. Wydanie II

Spis treści Wstęp .............................................................................................. 7 Rozdział 1. Podstawy ....................................................................................... 11 Lekcja 1. Czym jest PHP? .............................................................................................. 11 Język skryptowy ....................................................................................................... 11 Krótka historia PHP ................................................................................................. 12 Jak to działa? ............................................................................................................ 12 Lekcja 2. Instalacja i konfiguracja narzędzi .................................................................... 14 Samodzielna instalacja narzędzi ............................................................................... 14 Korzystanie z pakietu XAMPP ................................................................................. 31 Plik konfiguracyjny PHP .......................................................................................... 38 PHP w wierszu poleceń ............................................................................................ 39

Rozdział 2. Elementy języka ............................................................................. 41 Lekcja 3. Pierwszy skrypt ............................................................................................... 41 Zaczynamy ............................................................................................................... 41 Znaczniki PHP ......................................................................................................... 45 Komentarze .............................................................................................................. 47 Wyświetlanie informacji .......................................................................................... 49 Instrukcja print ......................................................................................................... 50 Łączenie skryptów .................................................................................................... 51 Lekcja 4. Zmienne, typy danych i operatory .................................................................. 57 Czym są zmienne? .................................................................................................... 57 Rodzaje zmiennych, czyli typy danych .................................................................... 58 Zmienne w kodzie skryptu ....................................................................................... 62 Wyświetlanie wartości zmiennych ........................................................................... 64 Operacje na zmiennych ............................................................................................ 68 Operatory ................................................................................................................. 68 Zmienne globalne (superglobalne) ........................................................................... 83 Konwersje typów ...................................................................................................... 85 Ćwiczenia do samodzielnego wykonania ................................................................. 89 Lekcja 5. Instrukcje sterujące ......................................................................................... 90 Instrukcje warunkowe .............................................................................................. 90 Instrukcja wyboru ..................................................................................................... 97 Operator warunkowy ................................................................................................ 99 Pętle ........................................................................................................................ 100 Składnia alternatywna ............................................................................................ 111 Ćwiczenia do samodzielnego wykonania ............................................................... 113

4

PHP5. Praktyczny kurs Lekcja 6. Funkcje ......................................................................................................... 114 Definiowanie funkcji .............................................................................................. 114 Argumenty funkcji ................................................................................................. 115 Zwracanie wartości przez funkcje .......................................................................... 117 Zasięg zmiennych ................................................................................................... 118 Sposoby przekazywania argumentów ..................................................................... 123 Domyślne argumenty funkcji ................................................................................. 125 Ćwiczenia do samodzielnego wykonania ............................................................... 126 Lekcja 7. Obsługa daty i czasu ..................................................................................... 127 Wyświetlanie daty i czasu ...................................................................................... 127 Tworzenie znacznika czasu .................................................................................... 135 Pozostałe funkcje .................................................................................................... 138 Ćwiczenia do samodzielnego wykonania ............................................................... 141 Lekcja 8. Ciągi znaków ................................................................................................ 141 Rodzaje ciągów znaków ......................................................................................... 141 Wyrażenia złożone w ciągach znaków ................................................................... 143 Która metoda jest szybsza? .................................................................................... 144 Formatowanie ciągów ............................................................................................ 146 Przetwarzanie ciągów znaków ............................................................................... 152 Porównania ............................................................................................................. 154 Przeszukiwanie ....................................................................................................... 155 Ćwiczenia do samodzielnego wykonania ............................................................... 157 Lekcja 9. Tablice .......................................................................................................... 158 Proste tablice .......................................................................................................... 158 Tablice asocjacyjne ................................................................................................ 161 Operacje na tablicach ............................................................................................. 163 Ćwiczenia do samodzielnego wykonania ............................................................... 170

Rozdział 3. Współpraca z systemem plików .................................................... 171 Lekcja 10. Operacje na strukturze systemu plików ...................................................... 171 Odczyt zawartości katalogu .................................................................................... 171 Operacje na katalogach .......................................................................................... 176 Operacje na plikach ................................................................................................ 178 Miejsce na dysku .................................................................................................... 180 Rekurencyjne usuwanie zawartości katalogu ......................................................... 182 Nawigacja po katalogach ........................................................................................ 182 Ćwiczenia do samodzielnego wykonania ............................................................... 185 Lekcja 11. Operacje na plikach ..................................................................................... 186 Tworzenie i otwieranie plików ............................................................................... 186 Zamykanie plików .................................................................................................. 188 Odczyt danych ........................................................................................................ 188 Zapis danych .......................................................................................................... 195 Inne operacje .......................................................................................................... 201 Ćwiczenia do samodzielnego wykonania ............................................................... 204 Lekcja 12. Praktyczne wykorzystanie plików ............................................................... 204 Tekstowy licznik odwiedzin ................................................................................... 205 Licznik wykorzystujący grafikę ............................................................................. 207 Lista odnośników ................................................................................................... 209 Lista odwiedzin ...................................................................................................... 210 Ćwiczenia do samodzielnego wykonania ............................................................... 213

Spis treści

5

Rozdział 4. Współpraca z przeglądarką ........................................................... 215 Lekcja 13. Odbieranie danych z przeglądarki ............................................................... 215 Formularze HTML ................................................................................................. 215 Wysyłanie metodą GET ......................................................................................... 216 Metoda POST ......................................................................................................... 221 Wysyłanie plików do serwera ................................................................................ 223 Ćwiczenia do samodzielnego wykonania ............................................................... 227 Lekcja 14. Wysyłanie danych do przeglądarki ............................................................. 228 Sposoby wysyłania danych .................................................................................... 228 Wysyłanie zawartości plików ................................................................................. 228 Sposoby pobierania plików z serwisu .................................................................... 232 Ćwiczenia do samodzielnego wykonania ............................................................... 245 Lekcja 15. Obsługa cookies .......................................................................................... 245 Krótko o cookies .................................................................................................... 245 Obsługa cookies w PHP ......................................................................................... 246 Korzystanie z cookies ............................................................................................. 250 Ćwiczenia do samodzielnego wykonania ............................................................... 255 Lekcja 16. Sesje ............................................................................................................ 255 Wstęp do sesji ........................................................................................................ 255 Identyfikator sesji ................................................................................................... 256 Rozpoczynanie sesji ............................................................................................... 256 Kończenie sesji ....................................................................................................... 257 Zmienne sesji ......................................................................................................... 257 Konfiguracja sesji ................................................................................................... 258 Implementacja sesji ................................................................................................ 260 Śledzenie zachowań użytkownika .......................................................................... 264 Kontrola dostępu z wykorzystaniem sesji .............................................................. 266 System logowania z danymi w pliku ...................................................................... 271 Ćwiczenia do samodzielnego wykonania ............................................................... 274

Rozdział 5. Obiektowy PHP ............................................................................ 275 Lekcja 17. Podstawy obiektowości ............................................................................... 275 Czym jest obiekt? ................................................................................................... 275 Definicja klasy ....................................................................................................... 276 Tworzenie obiektów ............................................................................................... 279 Konstruktory i destruktory ..................................................................................... 281 Automatyczne ładowanie kodu klasy ..................................................................... 284 Obiektowa lista odwiedzin ..................................................................................... 286 Ćwiczenia do samodzielnego wykonania ............................................................... 288 Lekcja 18. Więcej o programowaniu obiektowym ....................................................... 288 Dziedziczenie ......................................................................................................... 288 Przesłanianie składowych ....................................................................................... 292 Klasy i składowe finalne ........................................................................................ 294 Konstruktory i destruktory klas bazowych ............................................................. 295 Specyfikatory dostępu ............................................................................................ 297 Składowe statyczne ................................................................................................ 299 Ćwiczenia do samodzielnego wykonania ............................................................... 302 Lekcja 19. Wyjątki ....................................................................................................... 303 Instrukcja throw ..................................................................................................... 303 Klasa Exception i pochodne ................................................................................... 304 Blok try...catch ....................................................................................................... 305 Przechwytywanie wielu wyjątków ......................................................................... 310 Własne wyjątki ....................................................................................................... 313 Ćwiczenia do samodzielnego wykonania ............................................................... 314

6

PHP5. Praktyczny kurs

Rozdział 6. Grafika i obrazy ............................................................................ 315 Lekcja 20. Obsługa grafiki ........................................................................................... 315 Biblioteka graficzna ............................................................................................... 315 Jak stworzyć galerię obrazów? ............................................................................... 316 Przetwarzanie grafiki .............................................................................................. 325 Ćwiczenia do samodzielnego wykonania ............................................................... 337

Rozdział 7. Obsługa sieci ............................................................................... 339 Lekcja 21. Połączenia, poczta i FTP ............................................................................. 339 Tablica $_SERVER ................................................................................................ 339 Adresy IP ................................................................................................................ 342 Jak rozpoznać przeglądarkę? .................................................................................. 345 Połączenie FTP ....................................................................................................... 347 Wysyłanie poczty ................................................................................................... 349 Ćwiczenia do samodzielnego wykonania ............................................................... 352

Rozdział 8. Współpraca z bazami danych ........................................................ 353 Lekcja 22. Podstawy baz danych .................................................................................. 353 MySQL i SQLite .................................................................................................... 353 Tabele, klucze i relacje ........................................................................................... 354 Bazy danych a PHP ................................................................................................ 358 Instalacja systemu bazy danych .............................................................................. 359 Obsługa serwera MySQL ....................................................................................... 365 Lekcja 23. Podstawy SQL ............................................................................................ 371 Czym jest SQL? ..................................................................................................... 371 Obsługa tabel .......................................................................................................... 372 Typy danych w kolumnach .................................................................................... 377 Zapytania ................................................................................................................ 382 Lekcja 24. PHP i bazy danych ...................................................................................... 394 PHP i MySQL ........................................................................................................ 394 PHP i SQLite .......................................................................................................... 402 Ćwiczenia do samodzielnego wykonania ............................................................... 409 Lekcja 25. Podejście obiektowe .................................................................................... 410 Korzystanie z PDO ................................................................................................. 410 PHP i SQLite .......................................................................................................... 418 Lekcja 26. Bazy danych w praktyce ............................................................................. 423 Licznik ................................................................................................................... 423 Logowanie .............................................................................................................. 426 Ankieta ................................................................................................................... 428 Lista odwiedzin ...................................................................................................... 433 Liczba osób na stronie ............................................................................................ 435 Ćwiczenia do samodzielnego wykonania ............................................................... 437

Skorowidz .................................................................................... 439

Wstęp O książce Nikogo nie trzeba chyba przekonywać, że w dzisiejszych czasach znajomość PHP to jedna z podstawowych umiejętności, jakie musi posiadać każdy webmaster. PHP po prostu nie można nie znać, chcąc tworzyć strony WWW i to zarówno te poważne, profesjonalne serwisy, jak i dużo prostsze strony domowe. Era statycznego HTML-a przeminęła już dawno, a standard obowiązujący obecnie to dynamiczne generowanie treści. Skoro tak, warto poznać składające się nań techniki już teraz. Książka PHP5. Praktyczny kurs przeznaczona jest dla każdego, kto chciałby nauczyć się tworzenia dynamicznych stron internetowych i poznać technologię związaną z językiem PHP. Materiał jest prezentowany od podstaw, a Czytelnik nie musi posiadać wiedzy dotyczącej języków skryptowych czy działania serwerów WWW. Konieczna jest natomiast znajomość podstaw języka HTML w zakresie umożliwiającym samodzielne tworzenie prostych, statycznych stron WWW. W książce przedstawiony został stosunkowo szeroki zakres materiału, począwszy od instalacji samego PHP wraz z serwerami WWW oraz podstawowych konstrukcji języka, poprzez bardziej zaawansowane zagadnienia takie jak współpraca z systemem plików czy obsługa sesji, aż po wykorzystywanie możliwości programowania obiektowego oraz obsługę baz danych. Nie pominięto również takich tematów jak obsługa grafiki czy protokołów sieciowych. Cały materiał omawiany jest od zagadnień najprostszych po coraz bardziej zaawansowane, zarówno w obrębie całej książki, jak i poszczególnych lekcji. Dzięki temu przyswojenie prezentowanych wiadomości nie będzie sprawiało trudności Czytelnikom dopiero rozpoczynającym swoją przygodę z PHP, a jednocześnie pozwoli na sprawne poruszanie się po treści książki osobom bardziej zaawansowanym. Prawie każda lekcja kończy się również zestawem ćwiczeń do samodzielnego wykonania, dzięki którym każdy będzie mógł w praktyce sprawdzić nabyte umiejętności. Przykładowe rozwiązania ćwiczeń zostały zamieszczone na ftp://ftp.helion.pl/przyklady/ph5pk_2.zip.

8

PHP5. Praktyczny kurs

Narzędzia PHP jest dostępne dla bardzo wielu systemów operacyjnych, żeby wspomnieć tylko niezmiernie popularne rodziny systemów Windows i Linux, praktycznie nie ma więc znaczenia, na jakim systemie operacyjnym będziemy pracować. Omawiane jest natomiast środowisko PHP w wersji 5 i 6 (wersja 6. nie była w pełni gotowa w trakcie przygotowywania materiałów do książki, jednak cały przedstawiony materiał jest z nią zgodny). Jedną z tych wersji należy zainstalować zgodnie z informacjami podanymi w pierwszym rozdziale. Część przykładów będzie co prawda działała poprawnie również i w wersji 4, nie będzie tak jednak w każdym przypadku, gdyż jest ona przestarzała i już bardzo rzadko spotykana. Kilka lekcji omawia także współpracę z bazami danych na przykładzie systemów MySQL i SQLite. W przypadku MySQL korzystać można z wersji 4., 5. lub wyższej (o ile jest dostępna), natomiast w przypadku SQLite wykorzystywane są moduły wbudowane w pakiet PHP. Dobrym rozwiązaniem jest również użycie pakietu XAMPP, który integruje niezbędne serwery, ułatwia ich instalację oraz zarządzanie nimi (opis znajduje się w rozdziale 1.). Wszystkie prezentowane w książce skrypty mogą być tworzone w dowolnym edytorze tekstowym zapisującym pliki jako czysty tekst, np. Notatnik w Windows. Najlepiej stosować jednak bardziej zaawansowane edytory, które oferują takie udogodnienia jak kolorowanie składni i numerowanie linii tekstu. Można tu polecić takie rozwiązania jak Notepad++ (http://notepad-plus-plus.org/) i Notepad2 dla Windows czy też wieloplatformowy (napisany w Javie1) jEdit (http://www.jedit.org/). Osoby bardziej zaawansowane mogą też skorzystać ze zintegrowanych środowisk programistycznych takich jak Eclipse, EasyEclipse for PHP czy też NetBeans. Początkujący powinni jednak skorzystać z wymienionych wyżej prostych edytorów tekstowych, tak aby na początku nauki skoncentrować się na nauce języka i związanej z nim technologii, a nie na obsłudze zaawansowanych narzędzi, które do pisania prostych skryptów zwyczajnie nie są potrzebne.

Niezbędne programy i pliki Niezbędne do pracy narzędzia to PHP w wersji 5.3, MySQL w wersji 5.5, Apache w wersji 2.2, klient SQLite w wersji 2.8 i 3.7 (pliki zawierające przykładowe bazy używane w rozdziale 8. zostały przygotowane w wersji 2.8) oraz pakiet XAMPP w wersji 1.7.4.

1

Osoby zainteresowane programowaniem w Javie znajdą opis tego języka w takich pozycjach jak: Java. Praktyczny kurs (http://helion.pl/ksiazki/pkjav3.htm) oraz Java. Ćwiczenia. Praktyczne (http://helion.pl/ksiazki/cpjav3.htm).

Wstęp

9

Produkty te są dostępne pod adresami: http://www.php.net, http://www.mysql.com, http://www.apache.org i http://www.sqlite.org. Listingi w postaci gotowej do uruchomienia i testowania, a także przykładowe rozwiązania ćwiczeń do samodzielnego wykonania można pobrać z ftp://ftp.helion.pl/przyklady/ph5pk_2.zip.

10

PHP5. Praktyczny kurs

Rozdział 1.

Podstawy Lekcja 1. Czym jest PHP? Język skryptowy PHP to skryptowy język programowania ogólnego przeznaczenia, czyli taki, który może być używany do rozwiązywania rozmaitych problemów i tworzenia aplikacji o różnorodnym przeznaczeniu. Najczęściej jest on jednak kojarzony z dynamicznym przetwarzaniem oraz generowaniem stron internetowych i jest to jego główne zastosowanie. Również niniejsza publikacja poświęcona jest głównie takim właśnie zagadnieniom. Przyjmuje się, że nazwa PHP powstała jako akronim rekursywny — PHP: Hypertext Preprocesor, choć pewne źródła podają, iż jest to skrót od jednej z pierwszych nazw tego narzędzia — Personal HomePage Tools. Niezależnie jednak od tego, w jaki sposób nazwa ta powstała, jest to obecnie najpopularniejsza technologia skryptowa wykorzystywana do współpracy z serwerami WWW. Możliwości PHP są naprawdę ogromne, od prostego przetwarzania danych z formularzy na witrynach internetowych, poprzez zaawansowane przetwarzanie tekstu, do tworzenia skomplikowanych projektów współpracujących z dużymi bazami danych. PHP obsługuje wiele protokołów sieciowych, takich jak NNTP, SMTP, POP3, IMAP itp., umożliwia również bezpośrednie wykorzystanie do komunikacji sieciowej gniazd (z ang. sockets). Pozwala także na dynamiczne tworzenie obrazów, dokumentów PDF czy animacji Flash. Można też wykorzystywać ogromną liczbę rozszerzeń, które dodatkowo zwiększają możliwości tego narzędzia. PHP rozwijane jest na zasadach open source i w związku z tym dostępny jest jego pełny kod źródłowy. Może współpracować z większością popularnych systemów operacyjnych, takich jak różne wersje Linuksa, Windows, MacOS czy komercyjne odmiany Uniksa. Współpracuje także z imponującą liczbą różnych baz danych, choć najczęściej jest wybierany MySQL, jako że jest to doskonale dopracowane, a przy tym darmowe rozwiązanie. Właśnie MySQL zostanie wykorzystane w kilku lekcjach pokazujących współpracę PHP z bazami danych.

12

PHP5. Praktyczny kurs

Krótka historia PHP Początki PHP sięgają końca roku 1994, kiedy to Rasmus Leadorf stworzył pierwotną wersję tego narzędzia. Służyło mu ono do śledzenia odwołań do jego prywatnej strony WWW. Był to zestaw skryptów, znany pod nazwą Personal HomePage Tools. Jego funkcjonalność była niewielka, ale zainteresowanie użytkowników spore i już na początku roku 1995 została opublikowana pierwsza publiczna wersja PHP/FI, czyli Personal HomePage/Form Interpreter. Prawie trzy lata później, pod koniec roku 1997, została opublikowana kolejna wersja PHP/FI 2.0. Wedle danych szacunkowych z PHP korzystało w tym czasie ok. 50 tys. serwisów internetowych. Popularność PHP rosła bardzo szybko, okazało się jednak, że projekt ten ma sporo ograniczeń, które mogą uniemożliwić jego stosowanie w dużych serwisach internetowych. Dlatego już w 1997 roku dwaj izraelscy programiści, Andi Gutmans i Zeev Suraski, rozpoczęli prace nad całkowitym przepisaniem kodu. Produkt okazał się na tyle dobry, że prace nad PHP/FI 2.0 zostały zarzucone. Nowy produkt został nazwany po prostu PHP 3.0. Wersja ta została oficjalnie opublikowana w czerwcu 1998 roku i od razu zdobyła ogromną rzeszę zwolenników. Szacuje się, że wersja 3.0 była zainstalowana na 10% serwerów internetowych na świecie. Prace nad udoskonalaniem PHP trwały nadal. Powstał między innymi nowy silnik (z ang. engine), znany pod nazwą Zend (nazwa powstała od połączenia części imion Zeev i Andi), który szybciej przetwarzał skrypty. Także do samego języka wprowadzone zostały nowe konstrukcje, obsługa większej liczby serwerów WWW oraz wiele innych udoskonaleń. Nowa wersja pojawiła się w połowie roku 2000 i nosiła numer 4.0. Na kolejną wersję trzeba było czekać aż 4 lata. PHP 5.0 oficjalnie pojawiło się w sieci w lipcu 2004 roku, wprowadzając m.in. nowy silnik Zend 2.0 oraz nowe możliwości programowania obiektowego. W roku 2005 zostało zapowiedziane PHP 6, które jednak przez kolejne 6 lat nie ujrzało światła dziennego i wciąż nie ma pewności, czy i kiedy oficjalnie się ukaże1. Sporo nowości przyniosła natomiast wersja 5.3 z połowy roku 2009. Zgodnie z zapowiedzią funkcjonalności planowane w wersji 6. będą sukcesywnie wprowadzane w kolejnych podwersjach wersji 5. Jak dalej będzie się rozwijać PHP, nie wiadomo — wiadomo natomiast, że obecnie jest to jedna z najpopularniejszych, jeśli nie najpopularniejsza technologia obsługi skryptów działających po stronie serwera WWW.

Jak to działa? Zanim rozpoczniemy pracę z PHP, zastanówmy się, jak to się dzieje, że zwykła, statyczna strona jest wyświetlana w przeglądarce? Wiadomo, że strona WWW to po prostu plik zawierający kod HTML. Taki plik jest umieszczany na serwerze WWW. Serwer WWW to z kolei nic innego jak komputer zawierający odpowiednie oprogramowanie2, którego zadaniem jest wysłanie zawartości wskazanego pliku na żądanie innego 1 2

Słowa te zostały napisane w pierwszej połowie 2011 roku. Obsługujące protokół HTTP.

Rozdział 1. ♦ Podstawy

13

programu (najczęściej przeglądarki). Takie przesyłanie plików jest realizowane przez protokół HTTP (z ang. HyperText Transfer Protocol). Zostało to zilustrowane na rysunku 1.1. Przeglądarka wysyła do serwera żądanie pobrania strony o danym adresie (1), serwer odczytuje dane (z dysku lub pamięci) i wysyła je do niej z powrotem (2). Przeglądarka po otrzymaniu danych interpretuje je i wyświetla na ekranie3. Rysunek 1.1. Ilustracja sposobu współpracy przeglądarki i serwera WWW

A zatem wpisanie w polu adresowym (na pasku adresu) przeglądarki ciągu znaków http://www.mojadomena.com/index.html oznacza: używając protokołu komunikacyjnego HTTP, połącz się z serwerem o adresie www.mojadomena.com i zażądaj od niego treści pliku o nazwie index.html znajdującego się w jego głównym katalogu (zgodnie z konwencją uniksową katalog główny oznaczany jest znakiem /). Opisana wyżej procedura nie zadziała w przypadku stron zawierających skrypty PHP. Otóż przeglądarka nie rozumie i nie interpretuje kodu PHP — musi on być w całości wykonany po stronie serwera. Zatem postępowanie w takim przypadku będzie wyglądało jak na rysunku 1.2. Zostały na nim zobrazowane następujące etapy:  Przeglądarka wysyła do serwera żądanie pobrania strony o danym adresie (1).  Serwer pobiera stronę z dysku (lub pamięci). Ponieważ plik ma rozszerzenie

.php (lub inne podane podczas konfiguracji serwera), serwer wysyła do modułu (aparatu wykonawczego, interpretera) PHP żądanie przetworzenia danych znajdujących się w pliku (2).  Moduł PHP przetwarza dane, inaczej mówiąc, wykonuje zawarty w pliku

skrypt, a następnie wysyła je z powrotem do serwera (3).  Na zakończenie serwer wysyła przetworzone dane do przeglądarki (4). Rysunek 1.2. Ilustracja sposobu współpracy przeglądarki, serwera WWW oraz PHP

3

Oczywiście w przypadku stron, które zawierają dodatkowe elementy, jak np. obrazy, przeglądarka podczas ich przetwarzania musi wysłać do serwera również dodatkowe żądania pobrania tych elementów.

14

PHP5. Praktyczny kurs

Zatem zadaniem PHP jest takie przetworzenie danych, aby została wygenerowana strona zawierająca kod HTML zrozumiały dla przeglądarki WWW.

Lekcja 2. Instalacja i konfiguracja narzędzi Zanim rozpoczniemy pracę z PHP, musimy zainstalować to narzędzie. Niezbędna będzie również instalacja oprogramowania serwera WWW. Oczywiście nie trzeba do tego celu osobnego komputera, serwer może z powodzeniem działać na naszej domowej maszynie. Mówimy wtedy, że serwer został zainstalowany lokalnie i możemy się do niego odwoływać poprzez lokalne adresy http://localhost/ lub http://127.0.0.1/. Na kolejnych stronach zostaną pokazane procedury instalacji popularnego serwera Apache w wersji dla Linuksa i Windowsa oraz instalacja i konfiguracja PHP dla tych systemów (punkt „Samodzielna instalacja narzędzi”). Zamiast samodzielnie instalować wszystkie narzędzia, można też skorzystać z gotowego pakietu oprogramowania, jakim jest np. XAMPP. To opcja polecana dla osób początkujących, gdyż wszelkie czynności instalacyjne i konfiguracyjne zostaną wtedy ograniczone do minimum (punkt „Korzystanie z pakietu XAMPP”).

Samodzielna instalacja narzędzi Linux Użytkownicy Linuksa są w najlepszej sytuacji, gdyż w większości dystrybucji wszystkie niezbędne narzędzia otrzymują wraz z systemem, co więcej — często są one domyślnie instalowane. Jeśli danego pakietu nie ma w konkretnej dystrybucji, z pewnością znajduje się on na liście dostępnego oprogramowania i może zostać pobrany automatycznie. Ponieważ istnieje bardzo wiele dystrybucji Linuksa, nie sposób ich wszystkich opisać; procedury instalacyjne zostaną zatem pokazane na dwóch popularnych dystrybucjach. Instalacja w powłoce graficznej (Gnome) będzie się odbywać na bazie Fedory (Core 14), a instalacja w trybie tekstowym — na bazie Ubuntu (10). W innych wersjach proces ten z reguły odbywa się na takich samych zasadach i wygląda bardzo podobnie.

Instalacja za pomocą narzędzi graficznych (Fedora) Instalacja serwera WWW Serwer WWW (Apache 2.2 lub nowszy) w Fedorze jest instalowany standardowo, zwykle nie trzeba więc wykonywać żadnych dodatkowych czynności. Aby jednak się upewnić, że to oprogramowanie na pewno jest w systemie, wystarczy uruchomić Menedżer pakietów (gpk-application), wybierając z menu System pozycję Administracja, a następnie Dodaj/usuń oprogramowanie (rysunek 1.3).

Rozdział 1. ♦ Podstawy

15

Rysunek 1.3. Uruchamianie Menedżera pakietów

W Menedżerze pakietów należy odszukać serwer Apache (serwer WWW) znajdujący się w grupie Serwery. Najprościej jest to zrobić, wpisując w polu wyszukiwania ciąg httpd i klikając przycisk Znajdź (lub wciskając klawisz Enter). Pozycja odpowiadająca serwerowi pojawi się na liście z prawej strony, tak jak zostało to zaprezentowane na rysunku 1.4. Widoczne przy niej pole wyboru powinno być zaznaczone, co oznacza, że oprogramowanie serwera jest zainstalowane. Jeżeli pole nie jest zaznaczone, należy je zaznaczyć i kliknąć przycisk Zastosuj, czyli dokonać instalacji serwera, która odbywa się na takiej samej zasadzie jak instalacja każdej innej aplikacji (patrz też opis instalacji PHP). Rysunek 1.4. Serwer Apache w Menedżerze pakietów dystrybucji Fedora

Instalacja PHP Oprogramowanie PHP z reguły nie jest standardowo instalowane, choć zwykle jest obecne w systemie. Należy zatem uruchomić Menedżer pakietów (tak jak zostało to opisane w punkcie Instalacja serwera WWW) i odszukać ten związany z PHP. Znajduje się on w grupie Serwery. Aby go odnaleźć, najlepiej po prostu wpisać w polu wyszukiwania ciąg php i kliknąć przycisk Znajdź (lub wcisnąć Enter). Zostanie wyświetlona pozycja odpowiadająca PHP (rysunek 1.5). Należy wtedy zaznaczyć pole wyboru znajdujące się z jej lewej strony i kliknąć przycisk Zastosuj (prawa dolna część okna). Po chwili niezbędnej na sprawdzenie zależności między pakietami zostanie wyświetlone okno z listą niezbędnych komponentów, które również muszą być zainstalowane (rysunek 1.6). Należy w nim kliknąć przycisk Kontynuuj. Do zainstalowania nowego programu niezbędne są uprawnienia administratora systemu. Jeżeli bieżący użytkownik ich nie posiada (to typowa sytuacja), pojawi się okno pozwalające na wprowadzenie hasła użytkownika root (rysunek 1.7). Hasło należy wpisać do pola tekstowego i kliknąć przycisk Uwierzytelnij.

16

PHP5. Praktyczny kurs

Rysunek 1.5. PHP 5 w Menedżerze pakietów dystrybucji Fedora Rysunek 1.6. Lista pakietów powiązanych z PHP

Rysunek 1.7. Okno pozwalające na wprowadzenie hasła administratora

Po kliknięciu przycisku rozpocznie się procedura pobierania danych oraz instalacji programowania. Postęp tego procesu będzie sygnalizowany na pasku postępu w lewym dolnym rogu okna (rysunek 1.8). Gdy instalacja zostanie zakończona, można zamknąć okno Menedżera pakietów i zająć się kwestiami konfiguracyjnymi (patrz punkt „Uruchamianie serwera”).

Rozdział 1. ♦ Podstawy

17

Rysunek 1.8. Postęp procedury instalacyjnej

Uruchamianie serwera Serwer WWW jest usługą działającą w tle. Po instalacji jest on domyślnie wyłączony. Aby go włączyć, najlepiej skorzystać z Menedżera usług. W tym celu z menu System należy wybrać pozycję Administracja, a następnie Usługi (rysunek 1.9). Jeżeli pozycji usługi nie ma w menu Administracja, najpierw trzeba zainstalować pakiet system-config-services (znajduje się w Menedżerze pakietów w grupie System; instalacja odbywa się na takich samych zasadach, jakie opisano w punkcie „Instalacja PHP”). Rysunek 1.9. Uruchamianie Menedżera usług

Po wybraniu wskazanej pozycji menu otworzy się okno Menedżera usług (rysunek 1.10). Na liście z prawej strony należy odszukać pozycję o nazwie httpd. Czerwona kropka z lewej strony sygnalizuje, że ten serwer (usługa) jest wyłączony. Tekstowy opis stanu usługi można znaleźć z prawej strony panelu. Aby uruchomić usługę, należy ją zaznaczyć i kliknąć przycisk Uruchom. Niezbędne będzie potwierdzenie chęci wykonania czynności poprzez podanie hasła administratora (pojawi się takie samo okno jak na rysunku 1.7). Serwer Apache rozpocznie działanie. Jeżeli usługa ma być również uruchamiana automatycznie po każdym restarcie systemu, należy dodatkowo kliknąć przycisk Włącz. Wykonanie tej czynności również będzie musiało być potwierdzone hasłem administratora. Po prawidłowym uwierzytelnieniu ikona z lewej strony nazwy zmieni kolor na zielony, zmienią się też opisy w prawej części okna (rysunek 1.11). To wszystko (okno konfiguracji może zostać zamknięte). Można już zacząć testowanie instalacji.

Testowanie instalacji Aby sprawdzić, czy serwer działa poprawnie, wystarczy uruchomić dowolną przeglądarkę WWW, np. Firefox, i na pasku adresu wpisać adres lokalny http://localhost/ (lub http://127.0.0.1/). Na ekranie powinien pojawić się ekran powitalny zaprezentowany na rysunku 1.12. Jak widać, na stronie znajduje się również informacja o tym, który katalog na dysku twardym będzie traktowany jako główny katalog serwera WWW

18

PHP5. Praktyczny kurs

Rysunek 1.10. Uruchamianie serwera WWW

Rysunek 1.11. Menedżer usług po włączeniu i uruchomieniu serwera

— jest to /var/www/html. W tym katalogu należy zatem zapisywać pliki zawierające kod strony WWW. Uwaga! W standardowej konfiguracji prawa dostępu do tego katalogu ma administrator systemu (użytkownik root), a zatem aby zapisać w nim dane, potrzebne są stosowne uprawnienia. Sprawdźmy więc dodatkowo, czy działa również PHP — we wspomnianym katalogu zapisujemy tekstowy plik o nazwie index.php (do utworzenia pliku można użyć dowolnego edytora zapisującego czysty tekst, np. dostępnego standardowo gedit)4 i treści:

W polu adresowym przeglądarki wpisujemy tym razem http://localhost/index.php (lub http://127.0.0.1/index.php). Na ekranie zobaczymy wtedy to, co znajduje się na rysunku 1.13. To dowód, że również PHP współdziała z serwerem bez problemów. 4

To jedynie test poprawności działania serwera WWW i PHP. Wyjaśnienie znaczenia tego zapisu znajdzie się w rozdziale 2.

Rozdział 1. ♦ Podstawy

19

Rysunek 1.12. Testowa strona serwera WWW w Fedorze Rysunek 1.13. Test działania PHP w Fedorze

Instalacja w trybie tekstowym (Ubuntu) Instalacja serwera WWW Jeżeli pracujemy w trybie tekstowym, można od razu zacząć wydawać polecenie. Jeżeli natomiast jesteśmy w trybie graficznym, należy najpierw uruchomić konsolę (inaczej: wiersz poleceń, terminal). Można to zrobić, wybierając z menu Programy pozycję Akcesoria, a następnie Terminal (rysunek 1.14). W konsoli wydajemy polecenie w postaci: sudo apt-get install apache2

i wciskamy klawisz Enter. Nastąpi sprawdzenie zależności między pakietami oraz wyświetlone zostanie podsumowanie z pytaniem, czy na pewno chcemy kontynuować (rysunek 1.15). Potwierdzamy chęć instalacji, wciskając klawisze T i Enter. Rozpocznie się proces instalacji, a po jego zakończeniu serwer WWW zostanie uruchomiony.

20

PHP5. Praktyczny kurs

Rysunek 1.14. Uruchamianie konsoli

Rysunek 1.15. Instalacja serwera WWW

Poleceniem instalującym oprogramowanie Apache może być również aptitude: sudo aptitude install apache2

bądź yum5: sudo yum install apache2

Instalacja PHP Instalacja PHP jest równie prosta jak instalacja serwera WWW. Po uruchomieniu konsoli należy wydać polecenie: sudo apt-get install php5

Nastąpi wtedy sprawdzenie zależności między pakietami, a po jego zakończeniu na ekranie pojawi się podsumowanie z pytaniem, czy chcemy kontynuować (rysunek 1.16). Wystarczy wtedy odpowiedzieć T, aby po chwili PHP zostało zainstalowane. Można wówczas przejść do sprawdzenia poprawności działania serwera (Uwaga. Po instalacji PHP konieczne może być zrestartowanie serwera WWW — patrz punkt „Uruchamianie i zatrzymywanie serwera”). 5

W Ubuntu yum nie jest standardowo instalowany, jednak w razie potrzeby można go doinstalować. Zwykle nie ma jednak takiej konieczności. W zupełności wystarczający jest apt-get lub aptitude.

Rozdział 1. ♦ Podstawy

21

Rysunek 1.16. Instalowanie PHP5

Podobnie jak w opisywanym wyżej przypadku serwera Apache alternatywne polecenia pozwalające na instalację to aptitude: sudo aptitude install php5

oraz yum: sudo yum install php5

Uruchamianie i zatrzymywanie serwera Serwer może być w dowolnej chwili uruchamiany bądź zatrzymywany. Aby go uruchomić, należy wywołać skrypt apache2 z opcją start, pisząc: sudo /etc/init.d/apache2 start

Aby zatrzymać serwer, należy użyć tej samej komendy, ale z opcją stop: sudo /etc/init.d/apache2 stop

Dostępna jest także opcja restart pozwalająca na zrestartowanie serwera WWW: sudo /etc/init.d/apache2 restart

Testowanie instalacji Poprawność instalacji testujemy, podobnie jak w przypadku opisanej wyżej instalacji, za pomocą narzędzi graficznych. Należy uruchomić przeglądarkę i w polu adresowym wpisać adres lokalny http://localhost/ (lub http://127.0.0.1/). Na ekranie pojawi się wtedy widok zaprezentowany na rysunku 1.17. Jak widać, w zależności od dystrybucji Linuksa ekran powitalny może różnie wyglądać (por. rys. 1.12). Skoro serwer działa poprawnie, można też przetestować jego współpracę z PHP. W katalogu /var/www/html/ zapisujemy plik tekstowy (Uwaga. Podobnie jak w poprzednio opisywanym przypadku, zapis do tego katalogu wymaga uprawnień administratora) o nazwie index.php i treści:

22

PHP5. Praktyczny kurs

Rysunek 1.17. Domyślna strona oznaczająca poprawne działanie serwera

Następnie uruchamiamy przeglądarkę i na pasku adresu wpisujemy http://localhost/ index.php (lub http://127.0.0.1/index.php). Jeśli wszystkie czynności instalacyjne zostały przeprowadzone poprawnie, na ekranie powinniśmy zobaczyć widok zaprezentowany na rysunku 1.18. Rysunek 1.18. Test poprawności instalacji serwera WWW i PHP

Windows Użytkownicy systemów Windows są w nieco gorszej sytuacji niż korzystający z Linuksa, gdyż te systemy w wersjach instalacyjnych nie zawierają ani serwera Apache, ani PHP. Nie oznacza to jednak, że proces instalacji jest skomplikowany. Zarówno Apache, jak i PHP5 istnieją w wersjach dla Windows6. W tej części lekcji zostanie pokazane, jak zainstalować niezbędne oprogramowanie dla tego systemu.

Instalacja serwera WWW Apache Serwer Apache 2 w wersji dla Windows jest dystrybuowany w postaci pliku instalacyjnego msi (dostępne są także kody źródłowe, którymi nie będziemy się zajmować). Może zostać pobrany z serwisu dostępnego pod adresem http://www.apache.org. Należy odszukać sekcję Apache HTTP Server, wejść do działu zatytułowanego Download (w trakcie powstawania materiałów do książki bezpośrednim adresem był http://httpd. apache.org/download.cgi) oraz pobrać plik instalacyjny dla Windows (Win32). Plik

6

PHP może również współpracować z serwerami IIS (Internet Information Services) i PSW (Personal Web Server) dostępnymi w niektórych wersjach Windows, jednak ich konfiguracja nie będzie omawiana.

Rozdział 1. ♦ Podstawy

23

będzie miał nazwę podobną do httpd-2.2.17-win32-x86-no_ssl.msi — w zależności od tego, jaka najnowsza wersja jest aktualnie dostępna (rysunek 1.19)7.

Rysunek 1.19. Pobieranie wersji instalacyjnej serwera WWW

Pobrany plik instalacyjny należy uruchomić. Proces instalacji jest typowy i przebiega podobnie jak w przypadku każdej innej dla Windows. Podczas instalacji w oknie konfiguracyjnym widocznym na rysunku 1.20 można wprowadzić własne nazwy dla domeny i serwera lub też pozostawić wartości domyślne proponowane przez program instalacyjny. Rysunek 1.20. Konfiguracja nazw dla domeny i serwera

7

Można również pobrać wersję zawierającą oprogramowanie kryptograficzne OpenSSL (plik będzie miał nazwę httpd-2.2.17-win32-x86-openssl-0.9.8o.msi lub podobną) — przy nauce PHP nie ma to znaczenia.

24

PHP5. Praktyczny kurs

Instalacja PHP PHP5 w wersji dla Windows dostępne jest pod adresem http://windows.php.net (ogólna wersja PHP znajduje się pod adresem http://www.php.net). Należy wejść do działu Download i pobrać plik instalacyjny. Uwaga. Istnieje kilka wersji. Do poprawnej współpracy z serwerem Apache8 potrzebna będzie wersja opisana jako VC6 Thread-Safe9. Plik będzie miał przykładową nazwę (dla PHP 5.3.5) php-5.3.5-Win32-VC6-x86.msi. Po pobraniu pliku należy go uruchomić. Instalacja przebiega typowo, podobnie jak w przypadku innych aplikacji dla Windows. W jej trakcie należy zaakceptować treść licencji (licencja typu GPL — produkt rozpowszechniany na zasadach wolnego oprogramowania, może być stosowany nieodpłatnie nawet w projektach komercyjnych), wybrać katalog docelowy (typowo C:\Program Files\PHP\), pojawi się także ekran umożliwiający wybór serwera WWW, z którym ma współpracować PHP — należy wybrać opcję Apache 2.2.X Module10 (rysunek 1.21). Rysunek 1.21. Wybór serwera, z którym ma współpracować PHP

Na kolejnym ekranie niezbędne będzie wskazanie katalogu zawierającego plik konfiguracyjny serwera Apache (rysunek 1.22). Jest to niezbędne, aby instalator mógł automatycznie zintegrować PHP z Apache’em11. Jest to podkatalog o nazwie conf znajdujący się w katalogu, w którym został zainstalowany serwer WWW (typowo C:\Program Files\Apache Software Foundation\Apache2.2\). W typowej sytuacji jest to więc katalog C:\Program Files\Apache Software Foundation\Apache2.2\conf\. 8

Do współpracy z serwerami IIS lub PWS należy wybrać wersje oznaczone jako VC9.

9

W przyszłych wersjach PHP i Apache te dane mogą ulec zmianie. Odpowiednie informacje zawsze jednak znajdują się na stronie projektu PHP.

10

Mowa jest oczywiście o sytuacji, w której PHP ma współpracować z serwerem Apache zainstalowanym zgodnie ze wskazówkami podanymi w punkcie „Instalacja serwera WWW Apache”. W innych przypadkach należy dokonać odpowiednich korekt.

11

To, czy konieczne będzie samodzielne wskazanie katalogu, zależy od wersji instalatora i konfiguracji systemu. Niektóre wersje mogą dokonać automatycznej identyfikacji serwera i katalogu konfiguracyjnego.

Rozdział 1. ♦ Podstawy

25

Rysunek 1.22. Wybór katalogu zawierającego plik konfiguracyjny

Kolejny ekran pozwala wybrać elementy pakietu do zainstalowania (rysunek 1.23). Można na nim pozostawić ustawienia domyślne. Po zakończeniu instalacji można przystąpić do uruchomienia serwera i przetestowania, czy wszystko działa poprawnie. Uwaga: konieczne będzie zrestartowanie serwera Apache’a, tak aby mogły zostać uwzględnione zmiany konfiguracyjne wprowadzone przez instalator PHP. Rysunek 1.23. Wybór elementów pakietu, które mają być instalowane

Uruchamianie i zatrzymywanie serwera Po instalacji (zakładając, że nie zostały zmienione opcje standardowe) serwer jest uruchamiany automatycznie i będzie też uruchamiany przy każdym starcie systemu. Bieżący stan serwera jest sygnalizowany przez ikonę aplikacji Apache Service Monitor lewym przyciskiem myszy, uzyskuznajdującą się na pasku zadań. Klikając ikonę jemy dostęp do menu, które pozwala na kontrolę stanu serwera WWW: uruchomienie, zatrzymanie, zrestartowanie (rysunek 1.24).

26

PHP5. Praktyczny kurs

Rysunek 1.24. Kontrola stanu serwera za pomocą ikony na pasku zadań

Klikając ikonę prawym przyciskiem myszy, uzyskujemy dostęp do menu umożliwiającego wywołanie okna aplikacji Apache Service Monitor (rysunek 1.25). Ten program może być wywołany również z menu Start/Programy/Apache 2.2 HTTP Server Monitor Apache Servers. Po jego uruchomieniu zobaczymy na ekranie okno widoczne na rysunku 1.26, które pozwala uruchamiać i zatrzymywać serwer. Operacje te można również wykonywać bezpośrednio z menu, wybierając w grupie Control Apache Server pozycje Start i Stop (rysunek 1.27). Jak widać, możliwości jest sporo i należy skorzystać z tych, które są dla nas wygodniejsze. Rysunek 1.25. Uruchamianie aplikacji Apache Service Monitor

Rysunek 1.26. Okno monitora serwera

Rysunek 1.27. Kontrola serwera bezpośrednio z menu

Rozdział 1. ♦ Podstawy

27

Testowanie instalacji Aby sprawdzić poprawność działania serwera WWW (musi być oczywiście wcześniej uruchomiony), wystarczy uruchomić dowolną przeglądarkę i na pasku adresowym wpisać adres lokalny http://localhost/ (lub http://127.0.0.1/). Zobaczymy wtedy widok przedstawiony na rysunku 1.28. Rysunek 1.28. Test działania serwera WWW

Jeśli serwer WWW działa prawidłowo, można przystąpić do sprawdzenia, jak współdziała z PHP. W tym celu w katalogu głównym Apache’a w podkatalogu htdocs (typowo C:\Program Files\Apache Software Foundation\Apache2.2\htdocs) umieszczamy plik tekstowy index.php (utworzony np. za pomocą Notatnika) zawierający taką samą treść jak w przypadku instalacji linuksowych, czyli wiersz:

Po wpisaniu na pasku tytułu przeglądarki adresu http://localhost/index.php (lub http://127.0.0.1/index.php) na ekranie powinniśmy zobaczyć napis Test PHP (rysunek 1.29). Rysunek 1.29. Test działania PHP

Gdy wystąpią problemy Choć instalacja i konfiguracja Apache’a i PHP zwykle przebiegają bezproblemowo i w dużej części odbywają się automatycznie, może się zdarzyć, że nie wszystko będzie działało zgodnie z założeniami. Niestety nie da się w tym miejscu opisać wszystkich możliwych sytuacji i ich rozwiązań, zostanie jednak przedstawione kilka typowych problemów, które mogą się pojawić w trakcie sprawdzania poprawności konfiguracji zainstalowanego oprogramowania.

28

PHP5. Praktyczny kurs

Brak połączenia z serwerem Może się zdarzyć, że po wpisaniu adresu lokalnego http://localhost/ na pasku adresowym przeglądarki połączenie nie zostanie nawiązane i zamiast strony testowej zobaczymy komunikat podobny do przedstawionego na rysunku 1.30. Zazwyczaj oznacza to po prostu, że serwer nie został uruchomiony, trzeba więc wykonać czynności opisane w punkcie „Uruchamianie i zatrzymywanie serwera” (odpowiednio dla danego systemu operacyjnego). Inną przyczyną może być niestandardowa konfiguracja serwera (np. inny port, zablokowanie wybranych połączeń itp.), nie będzie to jednak miało miejsca w przypadku standardowych (domyślnych) konfiguracji. Rysunek 1.30. Brak połączenia z serwerem WWW

Serwer nie chce się uruchomić Przy próbie uruchamiania serwera może zostać zgłoszony błąd, np. w wersji dla Windows pojawi się komunikat przedstawiony na rysunku 1.31. To może oznaczać, że w systemie już działa inny serwer WWW12. To częste, o ile dysponujemy wersjami Windows z uruchomionymi usługami IIS lub PWS, czy też w Linuksie, jeśli zainstalowany został wcześniej inny serwer, a nie Apache. W takiej sytuacji należy wyłączyć dodatkową usługę13 i ponownie spróbować uruchomić Apache’a. Rysunek 1.31. Błąd podczas uruchamiania serwera

Serwer nie działa po instalacji PHP Zdarza się, że serwer WWW, który działał prawidłowo przed instalacją PHP, po tej instalacji nie chce się uruchomić. To niestety stosunkowo częste w środowisku Windows 12 13

Uruchomiony na standardowym porcie 80. Można też jeden z serwerów uruchomić na innym porcie. Omawianie tego zagadnienia wykracza jednak poza ramy tematyczne tej publikacji.

Rozdział 1. ♦ Podstawy

29

i przy automatycznej instalacji. Winne są tu najczęściej rozszerzenia PHP, które nie zawsze dobrze współpracują z daną wersją serwera lub też w danej konfiguracji systemowej. Trzeba wtedy sprawdzić, które z rozszerzeń powoduje problemy i wyłączyć je lub zamienić na inną wersję. Aby to zrobić, trzeba odszukać plik konfiguracyjny PHP — php.ini (patrz punkt „Opcje konfiguracyjne PHP”), a w nim sekcję zatytułowaną Dynamic Extensions. Przed każdym wierszem w postaci: extension=nazwa.dll

należy postawić znak średnika (rysunek 1.32), co oznacza wyłączenie danego rozszerzenia (ujęcie w komentarz). Następnie należy zapisać tak zmieniony plik i uruchomić serwer WWW. Najprawdopodobniej czynność ta zakończy się sukcesem, pozbawieni zostaniemy jednak części funkcji rozszerzających standardowe możliwości PHP. Teraz usuwając po kolei każdy z dodanych średników i restartując serwer WWW (po każdym usunięciu średnika i zapisaniu pliku konfiguracyjnego), odnajdziemy rozszerzenie powodujące problemy (po prostu po jego włączeniu serwer się nie uruchomi). Najlepiej pozostawić je w postaci wyłączonej. Można też, o ile jest nam ono niezbędne do pracy, poszukać w internecie innych wersji (lub informacji o tym, jakie są możliwe przyczyny niedziałania rozszerzenia). Rysunek 1.32. Sekcja rozszerzeń w pliku konfiguracyjnym PHP

Jeżeli to nie pomoże, warto odszukać wiersz odpowiedzialny za ładowanie modułu obsługi PHP (patrz też punkt „Serwer działa, ale nie obsługuje PHP”). Jeżeli wiersz ten wygląda w sposób następujący: LoadModule php5_module "php5apache2_2.dll"

pomóc może dodanie pełnej ścieżki dostępu do pliku php5apache2_2.dll. Typowa lokalizacja tego pliku to C:/Program Files/PHP/php5apache2_2.dll, zatem tekst należy zamienić na: LoadModule php5_module "C:/Program Files/PHP/php5apache2_2.dll"

Serwer działa, ale nie obsługuje PHP Jeżeli serwer WWW działa, to znaczy po wpisaniu adresu http://localhost/ pojawiła się strona testowa, ale po odwołaniu się do pliku testowego index.php (z punktu „Testowanie instalacji”), czyli podaniu adresu http://localhost/index.php, zamiast napisu Test PHP pojawia się pełna treść pliku (jak na rysunku 1.33) bądź też przeglądarka proponuje nam zapisanie pliku na dysku, oznacza to niepoprawną współpracę PHP z serwerem Apache. Najprawdopodobniej automatyczny instalator PHP nie dokonał zmian w pliku konfiguracyjnym serwera. Trzeba więc zrobić to samodzielnie.

30

PHP5. Praktyczny kurs

Rysunek 1.33. Przeglądarka wyświetliła pełną treść pliku PHP

Trzeba odszukać plik konfiguracyjny. W typowych instalacjach ma on nazwę httpd.conf i w przypadku Linuksa znajduje się zwykle w katalogu /etc/httpd/conf/httpd.conf, a w przypadku Windowsa w podkatalogu conf katalogu, w którym został zainstalowany serwer (typowo C:\Program Files\Apache Software Foundation\Apache2.2\conf\). W Linuksie nie jest to regułą — lokalizacja pliku konfiguracyjnego zależy od użytej dystrybucji i wersji serwera, np. w wersjach dla Ubuntu główny plik konfiguracyjny ma nazwę apache2.conf i znajduje się w katalogu /etc/apache2/. W razie wątpliwości należy sprawdzić to w dokumentacji danego systemu (danej wersji oprogramowania).

W przypadku Windows na końcu wspomnianego pliku powinna znajdować się sekcja ładująca moduł obsługi PHP wyglądająca tak jak na rysunku 1.34 lub podobnie. Ponadto w tym pliku powinien znajdować się wiersz dodający do serwera obsługę plików z rozszerzeniem .php: AddType application/x-httpd-php .php

Rysunek 1.34. Sekcja PHP w pliku konfiguracyjnym serwera Apache

Jeżeli tych danych nie ma, należy dopisać następujące linie: AddType application/x-httpd-php .php PHPIniDir "C:/Program Files/PHP/" LoadModule php5_module "C:/Program Files/PHP/php5apache2_2.dll"

a następnie zapisać plik i zrestartować serwer. Apache zacznie wtedy obsługiwać PHP. Jeśli PHP zostało zainstalowane w innej lokalizacji niż podana (C:\Program Files\PHP\), należy oczywiście dokonać odpowiednich korekt (jako separatora katalogów używamy znaku /, tak jak zostało to podane w powyższym przykładzie). W przypadku Linuksa w pliku konfiguracyjnym powinna znaleźć się linia ładująca moduł PHP: LoadModule php5_module modules/libphp5.so

Rozdział 1. ♦ Podstawy

31

a jeżeli plik index.php ma być traktowany jako jeden z domyślnych (plik ładowany przy odwołaniu się do danego katalogu WWW, bez określania nazwy pliku), należy dodać nazwę index.php w dyrektywie DirectoryIndex, np.: DirectoryIndex index.html index.php

Aby przetwarzane były pliki z rozszerzeniem .php, dodaje się również sekcję FilesMatch w postaci: SetHandler application/x-httpd-php

Korzystanie z pakietu XAMPP XAMPP to pakiet oprogramowania pozwalający na prostą zamianę komputera domowego w serwer internetowy. Najważniejsze jego składniki to serwer WWW Apache, baza danych MySQL oraz język skryptowy PHP. Zamiast zatem instalować i konfigurować wszystkie te składniki oddzielnie, można skorzystać z takiej gotowej paczki. Jest to szczególnie wygodne, jeśli potrzebujemy serwerów tylko do celów testowych. Całe oprogramowanie można bowiem równie szybko usunąć z systemu. Pakiet XAMPP w wersjach dla Linuksa i Windows dostępny jest pod adresem http:// www.apachefriends.org/en/xampp.html. Aktualne oraz archiwalne pliki pakietu powinny być też dostępne w lokalizacji http://sourceforge.net/projects/xampp/files/. Dalszy opis dotyczy wersji 1.7.4 (najnowszej dostępnej w trakcie powstawania książki).

Linux Instalacja Jeżeli w naszej wersji Linuksa nie zostały standardowo zainstalowane Apache, PHP i MySQL14, można rozważyć zainstalowanie XAMPP-a. Po pobraniu pakietu instalacyjnego (plik będzie miał nazwę xampp-linux-1.7.4.tar.gz lub podobną) należy uruchomić konsolę (terminal) i wydać komendę: tar xvfz xampp-linux-1.7.4.tar.gz -C /opt

Spowoduje to rozpakowanie plików pakietu do katalogu /opt/lampp. Co prawda pakiet jest wtedy gotowy do pracy, warto jednak wcześniej wykonać kilka czynności konfiguracyjnych związanych z bezpieczeństwem (patrz punkt „Bezpieczeństwo pakietu”.

Uruchamianie i zatrzymywanie serwerów Aby uruchomić serwer, należy wydać komendę: sudo /opt/lampp/lampp start

14

Kwestia bazy danych została dokładniej wyjaśniona w rozdziale 8.

32

PHP5. Praktyczny kurs

Uruchomienie serwerów składowych zostanie potwierdzone za pomocą komunikatów (ze względu na użycie polecenia sudo konieczne może być również podanie hasła użytkownika), tak jak zaprezentowano to na rysunku 1.35. Rysunek 1.35. Uruchamianie serwerów XAMPP

Na standardowych portach nie mogą być równocześnie uruchomione inne serwery WWW i MySQL (np. zainstalowane standardowo lub dodane do systemu według opisu z początku lekcji). Jeżeli XAMPP wykryje działanie innego serwera, nie uruchomi danej składowej pakietu. Pojawi się też wtedy odpowiedni komunikat. Aby pakiet XAMPP zadziałał poprawnie, należy najpierw wyłączyć inne serwery.

Do zatrzymywania serwerów służy polecenie: sudo /opt/lampp/lampp stop

a do restartowania — komenda: sudo /opt/lampp/lampp restart

Testowanie instalacji Aby sprawdzić poprawność instalacji i uruchomienia serwerów, wystarczy uruchomić przeglądarkę i wpisać adres lokalny http://localhost/ lub http://127.0.0.1/. Nastąpi wtedy przeniesienie pod adres http://localhost/xampp/splash.php, a na ekranie pojawi się widok zaprezentowany na rysunku 1.36. To dowód na to, że XAMPP działa prawidłowo.

Rysunek 1.36. Ekran tytułowy pakietu XAMPP

Rozdział 1. ♦ Podstawy

33

Główny katalog serwera WWW, czyli ten, do którego będziemy wgrywać nasze pliki PHP, to /opt/lampp/htdocs/. W tym katalogu znajduje się już plik index.php, ale nie jest nam do niczego potrzebny (wykonuje on jedynie przekierowanie na podany wyżej adres). Można go więc usunąć lub też wymienić treść na wiersz testowy:

Wtedy po wpisaniu do przeglądarki adresu http://localhost/ lub http://localhost/index. php na ekranie będzie pojawiał się znany nam napis Test PHP (jak na rysunku 1.18).

Bezpieczeństwo pakietu XAMPP tuż po zainstalowaniu jest skonfigurowany w taki sposób, że każdy ma pełny dostęp do jego składowych. Nie jest to rozwiązanie bezpieczne. Należy zatem utworzyć konta użytkowników i nadać hasła dla poszczególnych składowych. W konsoli należy wydać komendę (wcześniej powinien zostać uruchomiony XAMPP, tak jak zostało to opisane w poprzednim punkcie lekcji): sudo /opt/lampp/lampp security

Skrypt rozpocznie sprawdzanie stanu zabezpieczeń i dla nowej instalacji konieczne będzie podanie czterech haseł (rysunek 1.37). Pierwsze dotyczy dostępu do panelu konfiguracyjnego XAMPP (dostępnego pod adresem http://localhost/xampp/; nazwą użytkownika będzie lampp), drugie — dostępu do oprogramowania phpMyAdmin służącego do zarządzania bazą danych z poziomu WWW (nie będziemy z tej możliwości korzystać), trzecie — konta administracyjnego bazy danych MySQL (patrz rozdział 8.), czwarte — dostępu do serwera FTP (nie będziemy z niego korzystać).

Rysunek 1.37. Zabezpieczanie składowych pakietu XAMPP

34

PHP5. Praktyczny kurs

Windows Instalacja Plik instalacyjny XAMPP-a w wersji dla Windows będzie miał nazwę xampp-win32-1.7.4-VC6-installer.exe (lub podobną). Należy go pobrać na dysk i uruchomić. Instalacja przebiega typowo, podobnie jak w przypadku innych aplikacji dla tego systemu. W jej trakcie będzie można wybrać katalog docelowy (domyślnie jest to c:\xampp), pojawi się też okno widoczne na rysunku 1.38. Pozwala ono na ustalenie, czy na pulpicie ma zostać umieszczona ikona panelu kontrolnego oraz czy grupa XAMPP-a ma się pojawić w menu Start, a także czy poszczególne serwery mają być zainstalowane jako usługi systemowe. W typowych sytuacjach nie jest to konieczne, można więc pola wyboru w sekcji SERVICE SECTION pozostawić niezaznaczone. Rysunek 1.38. Ekran instalatora XAMPP

Po zakończeniu instalacji pojawi się okno (przedstawione na rysunku 1.39) z pytaniem, czy chcemy uruchomić panel kontrolny. Można zaznaczyć odpowiedź Tak lub Nie w zależności od tego, czy od razu chcemy przejść do uruchamiania i konfiguracji oprogramowania. W przypadku odpowiedzi Nie panel kontrolny będzie można uruchomić w każdej chwili za pomocą umieszczonej na pulpicie ikony lub przez menu Start (o ile nie zostały zmienione opcje domyślne z rysunku 1.38). Rysunek 1.39. Okno z pytaniem o chęć uruchomienia panelu kontrolnego

Zarządzanie serwerami W środowisku Windows oprogramowaniem XAMPP najwygodniej zarządza się za pomocą panelu kontrolnego. Można go uruchomić, klikając ikonę XAMPP Control Pa-

Rozdział 1. ♦ Podstawy

35

nel umieszczoną przez instalator na pulpicie lub wybierając z menu startowego grupę XAMPP (typowo Start/Programy (Wszystkie programy)/Apache Friends/XAMPP), a w niej pozycję XAMPP Control Panel. W przypadku braku ikony i grupy XAMPP w menu (np. jeśli w trakcie instalacji wyłączone zostały odpowiednie opcje) należy uruchomić program xampp-control.exe znajdujący się w katalogu, do którego został zainstalowany XAMPP (typowo c:\xampp\). Panel kontrolny ma postać przedstawioną na rysunku 1.40. Aby uruchomić serwer WWW, należy kliknąć ikonę Start znajdującą się przy opcji Apache. Serwer zostanie uruchomiony, a napis na przycisku zmieni się na Stop, w wierszu Apache pojawi się też słowo Running (rysunek 1.41). W polu tekstowym poniżej przycisków będą się pojawiały informacje diagnostyczne. W celu zatrzymania serwera trzeba, co wydaje się oczywiste, kliknąć przycisk Stop. Rysunek 1.40. Wygląd panelu kontrolnego XAMPP-a

Rysunek 1.41. Panel kontrolny XAMPP-a po uruchomieniu serwera Apache

36

PHP5. Praktyczny kurs

Jeśli serwer się nie uruchomi, a w polu tekstowym pojawi się komunikat o błędzie, najprawdopodobniej oznacza to, że w systemie już działa inny serwer WWW, np. serwer IIS czy też Apache zainstalowany w sposób przedstawiony w pierwszej części lekcji. W takiej sytuacji należy wyłączyć ten serwer i ponownie spróbować uruchomić Apache’a z pakietu XAMPP. W tej chwili można też uruchomić serwer bazy danych (potrzebny w lekcjach z rozdziału 8.). Jest to konieczne, jeśli od razu będziemy chcieli w pełni zabezpieczyć serwery XAMPP (patrz punkt „Ustalenie haseł dostępowych”). Robimy to, klikając przycisk Start w wierszu MySql (analogicznie do przypadku z serwerem Apache).

Testowanie konfiguracji W celu przetestowania poprawności konfiguracji wystarczy w przeglądarce wpisać adres lokalny http://localhost/. Nastąpi wtedy przekierowanie pod adres http://localhost/ xampp/splash.php i zobaczymy widok podobny do zaprezentowanego na rysunku 1.36. To dowód na to, że serwer WWW i PHP działają prawidłowo. Główny katalog serwera WWW, czyli ten, gdzie należy wgrywać nasze pliki PHP, ma nazwę htdocs i jest podkatalogiem katalogu, w którym został zainstalowany XAMPP (typowo c:\xampp). A zatem w konfiguracji domyślnej nasze pliki PHP (czy też HTML) należy umieszczać w folderze c:\xampp\htdocs\. Znajduje się w nim już plik index.php, ale nie będzie on potrzebny w takiej postaci (wykonuje on jedynie przekierowanie na podany wyżej adres http://localhost/xampp/splash.php). Można go więc usunąć lub też wymienić treść na wiersz testowy (najlepiej również usunąć wszelkie inne pliki z tego katalogu):

Wtedy po wpisaniu do przeglądarki adresu http://localhost/ lub http://localhost/index. php na ekranie będzie pojawiał się znany nam napis Test PHP (jak na rysunku 1.18).

Ustalenie haseł dostępowych W konfiguracji domyślnej dostęp do składowych XAMPP-a jest nieograniczony. Dlatego też ze względów bezpieczeństwa należy ustalić hasła dla strony konfiguracyjnej oraz bazy danych. Stan zabezpieczeń można sprawdzić, wpisując do przeglądarki adres http://localhost/security/index.php. Status poszczególnych usług składowych zostanie podany w kolumnie Stan (rysunek 1.42). Poniżej znajduje się odnośnik do strony pozwalającej na dokonanie zabezpieczeń (strona o adresie http://localhost/security/xamppsecurity.php). Po jego kliknięciu pojawi się widok przedstawiony na rysunkach 1.43 i 1.44. Górna część formularza (rysunek 1.43) służy do ustalania hasła administratora bazy danych (użytkownika root). Należy je wpisać w polach New password oraz Repeat the new password, a następnie kliknąć przycisk Password changing. Wtedy hasło zostanie ustalone. W dolnej części strony (rysunek 1.44) znajduje się formularz pozwalający na wprowadzenie nazwy użytkownika oraz hasła, które będą zabezpieczały dostęp do stron konfiguracyjnych (podkatalogu xampp serwera WWW). Nazwę użytkownika (dowolnie

Rozdział 1. ♦ Podstawy

Rysunek 1.42. Status bezpieczeństwa poszczególnych usług XAMPP Rysunek 1.43. Ustalanie hasła administratora bazy danych

Rysunek 1.44. Ustalanie nazwy użytkownika oraz hasła dostępowego do katalogu xampp

37

38

PHP5. Praktyczny kurs

wymyśloną) należy wprowadzić do pola User, hasło — do pola Password, a następnie kliknąć przycisk Make safe the XAMPP directory. Od tej chwili przy odwołaniu do stron konfiguracyjnych (http://localhost/xampp, http://localhost/security) będzie się pojawiało okno, w którym należy podawać nazwę użytkownika oraz hasło. Będzie miało postać przedstawioną na rysunku 1.45 lub podobną (zależy to od używanej przeglądarki). Rysunek 1.45. Okno służące do podawania nazwy użytkownika oraz hasła dostępowego

Plik konfiguracyjny PHP Opcje konfiguracyjne środowiska wpływające na zachowanie PHP zawarte są w pliku php.ini. Lokalizacja tego pliku jest różna i zależy od systemu, z jakiego korzystamy, oraz wersji oprogramowania. W przypadku Windows zwykle jest to katalog, do którego został zainstalowany PHP (typowo C:\Program Files\PHP\php.ini), natomiast w przypadku Linuksa zwykle jest to jedna z następujących ścieżek: /usr/local/lib/php. ini, /etc/php.ini, /etc/php5/php.ini, /etc/php5/apache2/php.ini. W przypadku korzystania z oprogramowania XAMPP dla Windows plik konfiguracyjny php.ini znajduje się w katalogu XAMPP-a w podkatalogu php (typowo c:\xampp\ php\php.ini), natomiast w przypadku Linuksa jest to katalog /opt/lampp/etc/. Opcje zawarte w pliku konfiguracyjnym pozwalają np. decydować o tym, czy i jakie komunikaty środowiska PHP mają być wyświetlane, a także na korzystanie z rozmaitych rozszerzeń (fragment treści pliku php.ini otwartego w edytorze gedit został przedstawiony na rysunku 1.46). W razie konieczności modyfikacji opcji będzie to zaznaczane w dalszych lekcjach. Uwaga! Należy pamiętać, że po każdej zmianie konfiguracji konieczne jest zrestartowanie serwera WWW. Rysunek 1.46. Fragment pliku konfiguracyjnego php.ini

Rozdział 1. ♦ Podstawy

39

PHP w wierszu poleceń Chociaż PHP jest zwykle kojarzone z generowaniem dynamicznych stron WWW, jest to narzędzie, które może również działać lokalnie, skrypty mogą być bowiem uruchamiane bezpośrednio w wierszu poleceń (rysunek 1.47). Z takiej możliwości będziemy korzystać również w niektórych lekcjach niniejszego kursu. Jeśli zatem chcielibyśmy zobaczyć efekty działania wymienionego wcześniej skryptu testowego na konsoli, należy wydać polecenie w ogólnej postaci15: ścieżka_dostępu_do_php/php ścieżka_dostępu_do_skryptu/nazwa_skryptu

Rysunek 1.47. PHP w wierszu poleceń Linuksa

Jeśli dla przykładu założymy, że mamy do czynienia z systemem Linux i że plik wykonywalny php został zainstalowany w katalogu /usr/local/bin, a skrypt o nazwie index. php znajduje się w katalogu /home/jkowalski/, to należałoby wydać polecenie: /usr/local/bin/php /home/jkowalski/index.php

W przypadku gdy katalog, w którym znajduje się plik wykonywalny php, jest wpisany do zmiennej środowiskowej PATH, a skrypt index.php jest zapisany w katalogu bieżącym, wystarczy polecenie (rysunek 1.47): php ./index.php

Podobnie jest w Windows. W wierszu poleceń należy wpisać ścieżkę dostępu do pliku php.exe, a po nim — ścieżkę dostępu do pliku ze skryptem (jeżeli ścieżki dostępu zawierają znaki spacji, należy je ująć w cudzysłów), np.: "c:\Program Files\php\php.exe" c:\skrypty\index.php

Gdy ścieżka dostępu do php.exe znajduje się w zmiennej środowiskowej PATH, a skrypt w katalogu bieżącym, wystarczy użyć wersji skróconej (rysunek 1.48): php.exe index.php

Rysunek 1.48. PHP w wierszu poleceń Windowsa

15

Może to wymagać samodzielnej instalacji pakietu PHP. Niektóre dystrybucje Linuksa standardowo instalują jedynie PHP jako moduł serwera.

40

PHP5. Praktyczny kurs

W Linuksie korzystanie z PHP w wierszu poleceń może wymagać zainstalowania pakietu php5-cli. Można to zrobić za pomocą jednego z poleceń (w zależności od tego, z jakiego menedżera pakietów chcemy skorzystać): sudo apt-get install php5-cli sudo aptitude install php5-cli sudo yum install php5-cli

Rozdział 2.

Elementy języka Lekcja 3. Pierwszy skrypt Zaczynamy Poznawanie nowego języka programowania, niezależnie od tego, czy jest to język skryptowy (tak jak PHP), czy też klasyczny, najlepiej rozpocząć od przykładu, który spowoduje wyświetlenie dowolnego napisu. Napiszemy zatem skrypt, który spowoduje pojawianie się w przeglądarce pewnego ciągu znaków — niech będzie to ciąg o treści Pierwszy skrypt w PHP. Kod przykładu realizującego to zadanie został przedstawiony na listingu 2.1. Przyjrzyjmy mu się uważnie. Listing 2.1. Skrypt wyświetlający w przeglądarce wybrany tekst (HTML)

Większa część kodu to standardowe znaczniki HTML tworzące strukturę najprostszej (poprawnej) strony zgodnej ze standardem HTML 4.01. Jak już zostało to wspomniane wcześniej, nie będziemy omawiać typowych konstrukcji HTML-a. Przypomnijmy

42

PHP5. Praktyczny kurs

tylko, że składa się on z deklaracji typu dokumentu ()1, nagłówka () oraz treści (). W sekcji określany jest sposób kodowania znaków (w tym przypadku jest to standard ISO-8859-2) oraz tytuł strony (znacznik

Oczywiście różnice są czysto kosmetyczne. Zmieniła się bowiem jedynie deklaracja typu dokumentu2 oraz treść znacznika określającego kodowanie znaków. Dla dalszych rozważań nie ma znaczenia, czy użyty zostanie kod HTML, czy XHTML. Podane w książce przykłady będą zgodne z oboma standardami3, choć będą używane nagłówki charakterystyczne dla standardu HTML 4.01 Strict. W obu przykładach (listingi 2.1 i 2.2) w sekcji wewnątrz znacznika

jest umieszczona treść skryptu PHP. Znajduje się ona między znacznikami . Wszystko to, co znajduje się między nimi, stanowi kod PHP i jest przetwarzane przez aparat wykonawczy PHP. W przypadku listingu 2.1 cała treść skryptu to: echo("Pierwszy skrypt w PHP.");

Jest to instrukcja, czyli coś, co możemy traktować jako polecenie do wykonania. To polecenie oznacza: wyślij do przeglądarki ciąg znaków znajdujący się pomiędzy znakami cudzysłowu4. Zwróćmy uwagę na występujący na końcu znak średnika. Oznacza on koniec instrukcji i jest niezbędny.

1

W deklaracji został pominięty opcjonalny element wskazujący położenie pliku z definicją standardu (http://www.w3.org/TR/html4/strict.dtd).

2

Podobnie jak w przykładzie z listingu 2.1, nie zostało uwzględnione wskazanie do definicji standardu (http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd).

3

Jeżeli uzyskanie zgodności z HTML i XHTML nie będzie możliwe, zostanie to zaznaczone w tekście.

4

Jest to pewne uproszczenie. W rzeczywistości instrukcja echo powoduje wysłanie danych do standardowego wyjścia, co akurat w omawianym przypadku będzie równoznaczne z wysłaniem tekstu do przeglądarki (za pośrednictwem serwera WWW). Gdyby skrypt został uruchomiony na konsoli, tekst pojawiłby się właśnie na niej.

Rozdział 2. ♦ Elementy języka

43

Zobaczmy teraz, jak zadziała taki skrypt po wczytaniu do przeglądarki. Całą treść listingu 2.1 zapisujemy w pliku o nazwie index.php, po czym umieszczamy go w katalogu głównym serwera WWW (patrz rozdział 1., lekcja 2.). Odwołujemy się następnie do pliku index.php, wpisując na pasku adresu: http://localhost/index.php lub http:// 127.0.0.1/index.php. Zobaczymy widok taki jak na rysunku 2.1, a zatem skrypt działa zgodnie z założeniami. Rysunek 2.1. Efekt działania skryptu z listingu 2.1

Obejrzyjmy dodatkowo, jak wygląda kod źródłowy tak wygenerowanej strony. W większości przeglądarek należy w tym celu z menu Widok (ang. View) wybrać pozycję Źródło (ang. Source) lub Źródło strony (ang. Page source). Sposób wyświetlania kodu źródłowego strony zależy od rodzaju przeglądarki, np. w przypadku Firefoksa postać ta będzie taka jak na rysunku 2.2, sam tekst zawsze będzie miał natomiast postać widoczną na listingu 2.3. Rysunek 2.2. Kod źródłowy strony w przeglądarce Mozilla FireFox

Listing 2.3. Kod HTML strony generowanej przez skrypt 2.1

44

PHP5. Praktyczny kurs

Pierwszy skrypt w PHP.

Widać wyraźnie, że zniknęły wszelkie znaczniki PHP i pozostał jedynie czysty kod HTML. Taka jest bowiem istota działania języków skryptowych pracujących po stronie serwera. Zadaniem skryptu PHP jest wygenerowanie takiego kodu, który będzie mógł być zrozumiały dla przeglądarki. W tym przypadku w miejsce skryptu zawartego pomiędzy znacznikami została wstawiona wytworzona przez niego treść, czyli napis Pierwszy skrypt PHP. A zatem, powtarzając raz jeszcze: skrypt PHP musi wygenerować taką treść, która zostanie zrozumiana przez przeglądarkę. Najczęściej jest to kod HTML, ale może to być również dokument pdf, plik skompresowany, obraz czy dowolne inne dane. Ważne jest to, żeby dane te zostały wysłane do przeglądarki w taki sposób, aby mogła ona je poprawnie zinterpretować. Zwróćmy w tym miejscu uwagę, że znacznik kończący akapit (

) znalazł się w tej samej linii co napis wygenerowany przez skrypt. Dlaczego tak się stało? Otóż wynika to ze sposobu interpretacji kodu przez PHP. Po prostu jako skrypt traktowany jest cały fragment:

włącznie ze znajdującym się za znacznikiem ?> znakiem końca linii. Cały ten fragment jest zamieniany na treść wygenerowaną przez skrypt. Skoro tą treścią jest napis Pierwszy skrypt PHP, który nie zawiera znaku końca linii, łączy się on z następującym po ?> znacznikiem HTML. Tym znacznikiem jest

, a zatem powstaje połączona linia: Pierwszy skrypt w PHP.

Nie ma to znaczenia dla przeglądarki, która w trakcie interpretacji kodu i tak pomija znaki końca linii, ale ma znaczenie dla osoby przeglądającej czy analizującej kod, bo w takiej postaci jest on mniej czytelny. Jak więc zapobiec temu zjawisku? Logika podpowiada, że trzeba po prostu wprowadzić dodatkowy znak końca linii. Można to zrobić na dwa sposoby — albo w instrukcji echo, albo w kodzie HTML. Pierwsze rozwiązanie będzie wymagało zastosowania sekwencji znaków specjalnych. Ta tematyka zostanie przedstawiona w kolejnej lekcji. Na razie można powiedzieć tyle, że instrukcja echo wyprowadzająca dodatkowy znak końca linii powinna mieć postać: echo("Pierwszy skrypt w PHP.\n");

Drugi sposób to wprowadzenie do kodu dodatkowej pustej linii. Cały skrypt miałby w takiej sytuacji postać widoczną na listingu 2.4. Kod źródłowy wygenerowanej przez niego strony (w interpretacji przeglądarki Firefox) jest natomiast widoczny na rysunku 2.3. Tym razem do czytelności listingu nie powinniśmy mieć już żadnych zastrzeżeń. Listing 2.4. Skrypt po wprowadzeniu do kodu dodatkowej pustej linii

Rozdział 2. ♦ Elementy języka

45

Rysunek 2.3. Kod źródłowy strony generowanej przez skrypt 2.3

Znaczniki PHP Wiemy już, że treść skryptu PHP musi być oddzielona od kodu HTML specjalnymi znacznikami. Dokładniej rzecz ujmując, każdy fragment kodu PHP (nawet jeśli nie ma wokół niego kodu HTML) musi być ujęty w znaczniki, tak aby aparat wykonawczy PHP wiedział, że dana sekcja to instrukcje PHP, a nie inne dane. Podstawowe znaczniki poznaliśmy w poprzedniej sekcji, tak naprawdę jest ich jednak nieco więcej. W sumie można wyróżnić cztery różne typy:  znaczniki kanoniczne,  znaczniki typu SGML,  znaczniki typu ASP,  znaczniki skryptów HTML.

Znaczniki kanoniczne Znaczniki kanoniczne to standardowe znaczniki PHP, które poznaliśmy już wcześniej. Znacznik otwierający to . Schematyczna konstrukcja wykorzystująca ten typ ma zatem następującą postać:

46

PHP5. Praktyczny kurs

Znaczniki kanoniczne są rozpoznawane zawsze, niezależnie od tego, jakie opcje są włączone w pliku konfiguracyjnym PHP (php.ini). Jest to również zalecany sposób umieszczania skryptów w kodzie HTML i właśnie ten sposób będzie wykorzystywany w przykładach w dalszej części książki.

Znaczniki typu SGML Znaczniki typu SGML to znaczniki w postaci skróconej. Znacznik otwierający to . Schematyczna konstrukcja wykorzystująca ten typ będzie miała postać:

Jest to najkrótsza forma znaczników bloku PHP, jakie można zastosować. Aby jednak móc korzystać z tego sposobu, należy włączyć rozpoznawanie tych znaczników. Można to zrobić, wykorzystując jeden z przedstawionych niżej sposobów: 1. Można włączyć opcję enable-short-tags przed kompilacją pakietu (./configure --enable-short-tags). 2. W pliku konfiguracyjnym php.ini można umieścić linię short_open_tag = On.

Wykorzystywanie tego typu znaczników, choć możliwe, nie jest jednak zalecane.

Znaczniki typu ASP Znaczniki typu ASP są znane użytkownikom technologii ASP. Znacznik otwierający to <%, a zamykający — %>. Schematyczna konstrukcja wykorzystująca ten typ będzie miała więc postać: <% //tutaj kod skryptu %>

Aby móc korzystać z tego typu wyróżnienia bloków PHP, należy w pliku konfiguracyjnym włączyć opcję asp_tags = On. Używanie tego typu znaczników również nie jest zalecane.

Znaczniki skryptów HTML Ta postać jest dobrze znana użytkownikom HTML. Jest to typowy znacznik . W związku z tym schematyczna konstrukcja wykorzystująca ten typ znaczników to:

Postać ta, podobnie jak kanoniczna, jest rozpoznawana standardowo i nie wymaga włączania żadnych dodatkowych opcji konfiguracyjnych. Należy jednak zwrócić uwagę,

Rozdział 2. ♦ Elementy języka

47

że ta postać uniemożliwia uzyskanie zgodności ze ścisłą (z ang. strict) wersją standardu HTML 4.01, w której nie występuje atrybut language (należy stosować atrybut type, który z kolei nie jest rozpoznawany przez aparat wykonawczy PHP). Dlatego też zdecydowanie najlepszym rozwiązaniem jest używanie znaczników kanonicznych.

Komentarze W kodzie PHP można, tak jak w większości innych, zarówno skryptowych, jak i klasycznych języków programowania, stosować komentarze. Są one ignorowane i usuwane w trakcie przetwarzania skryptu, pozwalają za to umieścić w kodzie uwagi, które mogą być dla nas przydatne podczas jego analizy. W pliku wynikowym, który wędruje do użytkownika (przeglądarki), na pewno ich nie będzie. Do wyboru mamy trzy rodzaje komentarzy — dwa zapożyczone są z języków takich jak C i C++, a jeden z powłok (ang. system shell) uniksowych. Są to:  komentarz blokowy,  komentarz jednowierszowy,  komentarz jednowierszowy uniksowy.

Komentarz blokowy Ten typ komentarza zaczyna się od sekwencji znaków /∗, a kończy się sekwencją ∗/. Wszystko to, co znajduje się pomiędzy tymi znakami, zostanie zignorowane przez PHP. Przykład poprawnego zastosowania wyglądać może następująco:

Po przetworzeniu takiego kodu przez PHP do przeglądarki zostanie wysłana jedynie linia zawierająca ciąg znaków: Witamy na stronie

Należy pamiętać, że komentarze tego typu koniecznie muszą znaleźć się w bloku PHP (co wydaje się zrozumiałe, jako że dotyczy on kodu PHP) oraz że nie wolno ich zagnieżdżać, czyli we wnętrzu jednego komentarza blokowego nie wolno umieszczać kolejnego. Zabroniona jest zatem taka sytuacja, jak przedstawiona poniżej:

48

PHP5. Praktyczny kurs

Próba zastosowania takiej konstrukcji spowoduje powstanie błędu, który objawi się komunikatem przedstawionym na rysunku 2.45. Wewnątrz komentarza blokowego może natomiast znaleźć się komentarz jednowierszowy lub uniksowy, co zostanie pokazane na kolejnych stronach. Rysunek 2.4. Próba zagnieżdżenia komentarzy blokowych powoduje wyświetlenie komunikatu o błędzie

Komentarz jednowierszowy Pierwszy typ komentarza jednowierszowego został zaczerpnięty ze składni klasycznych języków programowania takich jak C i C++. Rozpoczyna się on od sekwencji znaków // i kończy w bieżącej linii skryptu. Wszystko to, co znajduje się pomiędzy tymi znakami a końcem linii, jest traktowane jako komentarz i ignorowane przez analizator składniowy. Przykład wykorzystania tego typu komentarza wygląda następująco:

Jak zostało to już wspomniane wcześniej, komentarze jednowierszowe mogą być zagnieżdżane wewnątrz komentarza blokowego, np.:

Taka konstrukcja formalnie jest w pełni dopuszczalna i nie spowoduje powstania błędu, jednak w praktyce zazwyczaj nie ma potrzeby jej stosowania.

Komentarz jednowierszowy uniksowy Komentarz jednowierszowy typu uniksowego ma takie samo działanie jak komentarz jednowierszowy omówiony wyżej, jedynie jego wygląd jest inny. Zaczyna się on od znaku # i obowiązuje do końca danej linii skryptu. Przykład wykorzystania tego typu komentarza wygląda następująco:
O ile w opcjach konfiguracyjnych PHP nie zostało wyłączone wyświetlanie komunikatów o błędach.

Rozdział 2. ♦ Elementy języka

49

echo ("Witamy na stronie."); # Koniec kodu PHP ?>

Komentarz jednowierszowy uniksowy może być również zagnieżdżony wewnątrz blokowego. Taka konstrukcja będzie miała postać:

Wyświetlanie informacji Tak jak zostało to pokazane na wcześniejszych stronach, aby wysłać do przeglądarki dowolny ciąg znaków, należy skorzystać z instrukcji echo. Dotychczas stosowaliśmy konstrukcję, którą schematycznie można przedstawić jako: echo ("ciąg znaków");

Istnieje również możliwość pominięcia występującego w takiej instrukcji nawiasu okrągłego. Będzie miała ona wtedy postać: echo "ciąg znaków";

Obie postaci mają takie samo znaczenie. Ciąg znaków do wyświetlenia musi być natomiast zawsze ujęty w znaki apostrofu lub cudzysłowu. Nie są to co prawda formy równoważne, ale różnice między nimi będą podane dopiero w kolejnych lekcjach podczas omawiania zmiennych typu string. Tutaj przyjmijmy, że zastosowanie instrukcji w postaci: echo ('ciąg znaków');

lub echo 'ciąg znaków';

da taki sam efekt jak instrukcji przedstawionych wyżej. Jeśli chcemy wysłać do przeglądarki wartość liczbową, nie trzeba jej ujmować w znaki cudzysłowu, można zastosować konstrukcję w postaci: echo wartość;

np.: echo 24;

Istnieje także możliwość wysłania za pomocą instrukcji echo wielu wartości, zarówno liczbowych, jak i ciągów znaków, które w takim przypadku należy oddzielić od siebie znakami przecinka6, schematycznie: 6

W takim przypadku nie można jednak ujmować wszystkich wartości w zbiorczy nawias okrągły.

50

PHP5. Praktyczny kurs echo wartość1, wartość2,..., wartośćN

np.: echo "Liczba ", 24, " jest", " dwucyfrowa.";

W ciągach wysyłanych do przeglądarki mogą występować znaczniki HTML, np.: echo "

Witamy na stronie!

";

Problem pojawia się wtedy, gdy znacznik musi zawierać argument wymagający ujmowania wartości w znaki apostrofu lub cudzysłowu. Rozważmy znacznik

z parametrem style równym color:blue. Powinien on być zapisany jako:

Jeśli taki ciąg wstawimy do instrukcji echo, miałaby ona postać: echo "

";

PHP nie będzie wtedy w stanie odróżnić znaków cudzysłowu oznaczających początek i koniec ciągu od znaków cudzysłowu obejmujących słowa color:blue. Tym samym próba zastosowania takiej instrukcji zakończy się wystąpieniem błędu. W takiej sytuacji przed znakami cudzysłowów występującymi wewnątrz ciągu należy wstawić znaki ukośnika: echo "

";

Alternatywnie zamiast znaków cudzysłowu można zastosować znaki apostrofu: echo "

";

Zwróćmy jednak uwagę, że w przypadku pierwszego rozwiązania przeglądarka otrzyma znacznik

w postaci:

Natomiast w przypadku drugim w postaci:

Instrukcja print W PHP obok instrukcji echo istnieje również instrukcja print. Główna różnica między nimi jest taka, że print zachowuje się tak jak funkcja (pojęcie funkcji zostanie omówione w lekcji 6.) i zwraca wartość, w związku z czym może być wykorzystywana w bardziej złożonych wyrażeniach, podczas gdy echo — nie. Jednak na tym etapie uczenia się PHP raczej nie zauważymy różnic pomiędzy echo i print, z wyjątkiem tego, że w przypadku print nie można wyświetlanych wartości oddzielać od siebie znakami przecinka. Zabroniona jest zatem konstrukcja: print "Liczba ", 24, " jest", " dwucyfrowa".;

Prawidłowe będą natomiast zapisy:

Rozdział 2. ♦ Elementy języka print print print print print

51

"Wartość"; 24; ("Słowo"); (24); "

";

Łączenie skryptów Skrypty PHP mogą zawierać dużą ilość kodu i być bardzo skomplikowane. W takiej sytuacji najczęściej kod jest dzielony i zapisywany w kilku oddzielnych plikach, którymi łatwiej zarządzać i które łatwiej analizować. Dzięki temu daje się zapanować nawet nad dużymi projektami. Skoro jednak można pliki dzielić na mniejsze jednostki, musi także istnieć możliwość ich ponownego połączenia. Służą do tego instrukcje include i require. Obie wykonują praktycznie identyczne zadanie — w miejscu swojego wystąpienia wstawiają treść wskazanego pliku. Schematyczne wywołanie include ma postać: include("nazwa pliku");

a require: require("nazwa pliku")

W obu przypadkach istnieje możliwość pominięcia nawiasów okrągłych, czyli prawidłowe będą również wywołania: include "nazwa pliku"; require "nazwa pliku";

Instrukcja include Zobaczmy teraz, jak wygląda w praktyce wykorzystanie instrukcji include. Napiszemy skrypt, którego zadaniem będzie wyświetlenie dowolnej informacji w przeglądarce w taki sposób, że struktura strony HTML będzie zapisana w jednym pliku, natomiast instrukcje echo w drugim. Kod wyświetlający informacje będzie miał bardzo prostą postać. Została ona przedstawiona na listingu 2.5. Przedstawione instrukcje należy zapisać w pliku o nazwie skrypt.php. Listing 2.5. Treść pliku skrypt.php "; echo "Witamy na stronie!"; echo "

"; ?>

Utworzymy teraz plik, w skład którego będzie wchodził kod HTML realizujący strukturę strony i zawierający dodatkowo instrukcję PHP — include. Treść tego pliku (należy go zapisać pod nazwą index.php) została przedstawiona na listingu 2.6. Oba pliki, zarówno skrypt.php, jak i index.php, należy umieścić w katalogu głównym serwera WWW. Jeśli teraz w przeglądarce wpiszemy adres http://localhost/index.php, zobaczymy

52

PHP5. Praktyczny kurs

widok jak na rysunku 2.5. Widać wyraźnie, że faktycznie została uwzględniona treść pliku skrypt.php, zostały bowiem wykonane znajdujące się w nim instrukcje echo. Listing 2.6. Treść pliku index.php

Rysunek 2.5. Strona wygenerowana przez łączenie skryptów

Ważne jest jednak, abyśmy dobrze zdawali sobie sprawę z tego, jak w rzeczywistości zadziała instrukcja include znajdująca się w pliku index.php. Otóż dokument index.php jest przetwarzany jako kod HTML, aż do napotkania znacznika otwierającego . Treść za znacznikiem ?> jest oczywiście traktowana jako kod HTML. Oznacza to, że każda instrukcja include o schematycznej postaci: include "nazwa_pliku";

jest w rzeczywistości traktowana jako konstrukcja:

Rozdział 2. ♦ Elementy języka

53

?> treść pliku nazwa_pliku
Jeśli więc chcemy, aby treść dołączanego pliku była traktowana jako kod PHP, musimy koniecznie ująć ją w znaczniki trybu PHP, dokładnie tak jak zostało to wykonane na listingu 2.5. Nasze skrypty z listingów 2.5 i 2.6 zostały bowiem złączone przez PHP tak, jakby to był kod widoczny na listingu 2.7. Listing 2.7. Kod po złączeniu skryptów 2.5 i 2.6 "; echo "Witamy na stronie!"; echo ""; ?>

O tym, że instrukcja include faktycznie powoduje opuszczenie trybu PHP i przetwarzanie treści dołączonego pliku odbywa się w trybie HTML, można się naocznie przekonać, usuwając z kodu pliku skrypt.php znaczniki , czyli poprzez zmienienie go tak, aby miał postać: echo "

"; echo "Witamy na stronie!"; echo "

";

Przy takiej treści skryptu skrypt.php wczytanie do przeglądarki pliku index.php spowoduje efekt widoczny na rysunku 2.6. Tym razem instrukcje PHP zostały potraktowane jako treść strony, o czym możemy się dodatkowo przekonać, oglądając jej kod źródłowy (rysunek 2.7). Dociekliwi Czytelnicy zastanawiają się zapewne, dlaczego treść pliku dołączanego za pomocą instrukcji include nie jest automatycznie traktowana jako instrukcje PHP. Odpowiedź jest w tym przypadku prosta — ograniczałoby to możliwości tej instrukcji. Gdyby bowiem zawartość dołączanego pliku miała być obligatoryjnie traktowana jako kod PHP, nie byłoby można za jej pomocą dołączać innych rodzajów plików, np. zawierających fragmenty kodu HTML.

54

PHP5. Praktyczny kurs

Rysunek 2.6. Efekt usunięcia znaczników

Rysunek 2.7. Instrukcje PHP pojawiły się w kodzie HTML

Instrukcja require Instrukcja require ma działanie bardzo podobne do include — wczytuje plik zewnętrzny o wskazanej nazwie. Różnica ujawnia się w momencie, gdy wybrany plik nie może zostać wczytany (np. nie ma go na dysku lub PHP nie ma do niego praw dostępu). W takiej sytuacji w przypadku include wygenerowane zostanie ostrzeżenie, ale skrypt, w którym zawarte było jej wywołanie, będzie kontynuował działanie. Tymczasem w przypadku require skrypt wywołujący zakończy działanie, zgłaszając błąd. Jak w praktyce wygląda różnica między tymi instrukcjami, zobrazowano w skrypcie widocznym na listingu 2.8. Efekt jego działania został z kolei zaprezentowany na rysunku 2.8. Oczywiście pliku o nazwie abc.php nie powinno być na dysku. Listing 2.8. Różnice między instrukcjami include i require

Rozdział 2. ♦ Elementy języka

55



Rysunek 2.8. Ilustracja różnicy w działaniu instrukcji include i require

Pierwsza instrukcja echo została wykonana bez problemów. Występująca po niej instrukcja include "abc.php"; próbowała wczytać nieistniejący plik abc.php. Ponieważ takiego pliku nie było na dysku, zostały wygenerowane dwa ostrzeżenia (ang. warning)7, niemniej skrypt kontynuował działanie, o czym świadczą efekty wykonania dwóch występujących dalej instrukcji echo. Kolejną instrukcją jest jednak require "abc.php";. Ponieważ pliku abc.php wciąż nie ma na dysku, generuje ona ostrzeżenie oraz błąd (fatal error), a także, co najważniejsze, przerywa działanie kodu. Tym samym ostatnia instrukcja echo (echo ("Po wywołaniu require...
");) nie została wykonana. Takie zachowanie skryptu, czyli przerwanie działania w przypadku braku określonego pliku, jest w niektórych sytuacjach bardzo pożądane.

7

Komunikaty pojawią się w przeglądarce (tak jak zostało to zaprezentowane na rysunku), o ile w pliku konfiguracyjnym php.ini nie zostało wyłączone wyświetlanie ostrzeżeń.

56

PHP5. Praktyczny kurs

Lokalizacja dołączanych plików Jeśli korzystamy z instrukcji include lub require, musimy wiedzieć, w jaki sposób PHP poszukuje plików, które mają być dołączane za ich pomocą. Otóż konkretną lokalizację pliku można podać w wywołaniu jednej z tych instrukcji (funkcji). Po prostu nazwę pliku należy uzupełnić o ścieżkę dostępu do niego (względną lub bezwzględną). Prawidłowe będą zatem przykładowe wywołania:  include (./pliki/abc.php) — dołączony zostanie plik o nazwie abc.php znajdujący się w podkatalogu pliki (/pliki/) katalogu bieżącego (./).  require (/temp/pliki/abc.php) — dołączony zostanie plik o nazwie abc.php znajdujący się w podkatalogu (temp/pliki) katalogu głównego (/).

W obu przedstawionych przypadkach lokalizacja pliku jest jasno określona. Inaczej jednak jest wtedy, gdy posługujemy się tylko nazwą pliku (jak miało to miejsce w przykładach z poprzedniego punktu lekcji). Skąd wtedy PHP ma wiedzieć, gdzie szukać plików? Otóż w takiej sytuacji obowiązują następujące zasady:  najpierw przeszukiwane są katalogi zdefiniowane w zmiennej konfiguracyjnej include_path,  w drugiej kolejności sprawdzany jest katalog, w którym znajduje się skrypt PHP,  na zakończenie sprawdzany jest katalog bieżący.

Jeżeli wskazanego pliku nie będzie w żadnej z wymienionych lokalizacji, zostanie zgłoszone ostrzeżenie (instrukcja include) lub błąd (instrukcja require). Wspomniana zmienna include_path powinna znajdować się w pliku konfiguracyjnym php.ini8 i w przypadku systemów z rodziny Linuksa będzie miała postać: include_path = "katalog1:katalog2:katalog3"

a w przypadku systemów z rodziny Windows jej postać będzie następująca: include_path = "katalog1;katalog2;katalog3"

Ponieważ dołączany plik często jest umieszczany w tym samym katalogu co plik, do którego ma on być dołączony (tak jak we wcześniejszym przykładzie, gdzie pliki index.php i skrypt.php były w katalogu głównym serwera WWW), często w zmiennej include_path umieszcza się określenie katalogu bieżącego, czyli znak kropki (.), np.: include_path = ".:/php/includes"

dla systemu Linux i: include_path = ".:c:\php\includes"

dla systemu Windows (jednak bardziej efektywnym rozwiązaniem jest bezpośrednie podawanie relatywnej ścieżki dostępu, np. ./abc.php).

8

Aby zmienić zawartość zmiennej include_path na czas działania konkretnego skryptu, można użyć funkcji set_include_path.

Rozdział 2. ♦ Elementy języka

57

W większości wersji instalacyjnych omawiana zmienna jest wstępnie skonfigurowana i nie wymaga modyfikacji, jeśli jednak użyjemy include lub require i dołączany plik będzie na dysku, a otrzymamy jeden z komunikatów z poprzedniego przykładu (listing 2.8, rysunek 2.8), warto do niej zajrzeć i sprawdzić, czy aby na pewno zmienna ta wskazuje na właściwe katalogi.

Lekcja 4. Zmienne, typy danych i operatory Czym są zmienne? Zmienne są to konstrukcje programistyczne pozwalające na przechowywanie danych. Każda zmienna posiada swoją nazwę, dzięki której można się do niej odwoływać w kodzie skryptu, oraz typ określający, jakiego rodzaju dane może przechowywać. Nazwa nadawana jest zmiennej przez programistę. Może być ona dowolna, choć musi spełniać następujące warunki:  Musi zaczynać się od litery lub znaku podkreślenia.  Może zawierać jedynie litery, cyfry i znaki podkreślenia.

Przed nazwą zmiennej należy postawić znak $. Schematyczna konstrukcja zmiennej ma zatem postać: $nazwa_zmiennej

Prawidłowe są więc następujące zmienne: $liczba $_liczba $liczba12 $wartosc_1

Należy zwrócić uwagę, że rozróżniane są wielkie i małe litery, a zatem przykładowo $Liczba i $liczba to dwie różne zmienne! Warto też pamiętać, że jako litery w nazwach zmiennych9 rozumiane są zarówno znaki alfabetu łacińskiego od a do z i od A do Z, jak również wszystkie znaki ASCII o kodach od 127 do 255. To oznacza, że w nazwach zmiennych można używać polskich znaków (a także znaków z innych języków) w standardach takich jak ISO-8859-2 i WINDOWS-1250. Prawidłową nazwą będzie zatem również np.: $wartość_1

Częstą praktyką jest jednak pomijanie polskich znaków bądź stosowanie nazw pochodzących z języka angielskiego. Zależy to jednak tylko od preferencji i potrzeb danego programisty. 9

Szerzej rzecz ujmując — we wszelkich identyfikatorach.

58

PHP5. Praktyczny kurs

Zanim jednak przejdziemy do tematu przypisywania zmiennym wartości oraz sposobu ich wykorzystywania, musimy się dowiedzieć, jakie mogą być ich rodzaje. Temu tematowi poświęcone są kolejne strony.

Rodzaje zmiennych, czyli typy danych W klasycznych językach programowania każda zmienna ma swój typ. Typ zmiennej określa wartości, jakie mogą być jej przypisywane. Przykładowo zmiennej typu całkowitoliczbowego można przypisywać liczby całkowite, a zmiennej typu łańcuchowego — łańcuchy znaków (napisy). W PHP, podobnie jak w wielu innych językach skryptowych, jest nieco inaczej. Otóż zmienna może przechowywać dowolne wartości. Nie oznacza to jednak, że nie ma ona typu, ale to, że jej typ może się dynamicznie zmieniać w trakcie działania kodu. Poznajmy zatem występujące w PHP typy danych. Możemy je podzielić na trzy ogólne rodzaje:  typy skalarne,  typy złożone,  typy specjalne.

Typy skalarne Typy skalarne (z ang. scalar types) to inaczej typy proste (z ang. primitive types). Dzielimy je na następujące rodzaje:  typ boolean,  typ integer,  typ float,  typ string.

Typ boolean Jest to typ logiczny, który może przyjmować tylko dwie wartości — true (prawda) oraz false (fałsz). Ten typ wykorzystywany jest przy konstruowaniu wyrażeń logicznych oraz sprawdzaniu warunków.

Typ integer Jest to typ całkowitoliczbowy, dzięki któremu można reprezentować zarówno dodatnie, jak i ujemne liczby całkowite. Liczby te mogą być zapisane w trzech różnych formatach: dziesiętnym, ósemkowym (oktalnym) lub szesnastkowym (heksadecymalnym). Domyślnie stosowany jest format dziesiętny. Jeżeli chcemy uzyskać liczbę ósemkową, poprzedzamy ją znakiem 0 (zero). Liczbę szesnastkową należy poprzedzić znakami 0x. Przy zapisie wartości szesnastkowych można wykorzystywać zarówno wielkie, jak i małe litery od a do f. Przykładowo, wszystkie zaprezentowane poniżej wartości są typu integer:

Rozdział 2. ♦ Elementy języka

59

 123 dodatnia całkowita wartość dziesiętna 123,  -123 ujemna całkowita wartość dziesiętna –123,  012 dodatnia całkowita wartość ósemkowa równa 10 dziesiętnie,  -024 ujemna całkowita wartość ósemkowa równa 20 dziesiętnie,  0xFF dodatnia całkowita wartość szesnastkowa równa 255 dziesiętnie,  -0x0f ujemna całkowita wartość szesnastkowa równa –15 dziesiętnie.

Maksymalny zakres typu całkowitego (czyli zakres wartości, jaki można za jego pomocą przedstawić), podobnie jak w języku C, zależy od platformy sprzętowo-systemowej, na jakiej uruchamiane jest PHP. Typowo jest to 32-bitowa liczba ze znakiem, czyli zakres wartości od –231 do 231 – 1. W przypadku przekroczenia zakresu wartość jest konwertowana do typu float.

Typ float Typ float10 reprezentuje zarówno dodatnie, jak i ujemne liczby rzeczywiste (zmiennopozycyjne, zmiennoprzecinkowe). Ich zakres, podobnie jak dla typu integer, jest zależny od platformy sprzętowo-systemowej, z reguły są to wartości od –1,8×10308 do 1,8×10308. Typową reprezentacją jest zapis z kropką dziesiętną, czyli np. 1.5. Można również używać notacji wykładniczej w postaci X.YeZ, gdzie X to część całkowita, Y — dziesiętna, natomiast Z to wykładnik potęgi liczby 10. Zapis taki oznacza to samo, co X.Y×10Z. Przykładowo, wszystkie zaprezentowane poniżej wartości są typu float:  1.1 dodatnia wartość rzeczywista 1,1,  -1.1 ujemna wartość rzeczywista –1,1,  0.1E2 dodatnia wartość rzeczywista 10,  -1.0E-2 ujemna wartość rzeczywista –0,01.

Typ string Typ string to typ łańcuchowy, który służy do zapamiętywania sekwencji znaków. Nie ma ograniczenia długości tego ciągu. Do zapamiętywania pojedynczego znaku jest wykorzystywany jeden bajt. Wynika z tego, że PHP bezpośrednio nie obsługuje standardu Unicode, choć istnieją odpowiednie rozszerzenia pozwalające na manipulację ciągami ze znakami Unicode11. Łańcuch znaków można utworzyć na cztery sposoby:  używając znaków apostrofu,  używając znaków cudzysłowu,  używając składni heredoc,  używając składni newdoc. 10

W innych językach programowania występują z reguły dwa rodzaje liczb zmiennoprzecinkowych: float — pojedynczej precyzji i double — podwójnej precyzji. Różnią się zakresem wartości, które mogą reprezentować. W PHP jest jednak tylko jeden typ zmiennoprzecinkowy.

11

Zgodnie z zapowiedzią pełna obsługa Unicode ma być wprowadzona w oficjalnej wersji PHP6.

60

PHP5. Praktyczny kurs

Wykorzystanie znaków apostrofu Pierwszym sposobem deklaracji łańcucha znakowego jest ujęcie go w znaki apostrofu. PHP praktycznie nie dokonuje interpretacji takiego ciągu znaków, jeśli zatem na przykład wyświetlamy go na ekranie, pojawi się w większości przypadków w niezmienionej postaci. Przykładem takiego ciągu jest 'abc'. Wyjątkiem od tej zasady jest specjalne traktowanie samego znaku apostrofu. Jeśli chcemy uzyskać go w napisie, koniecznie musimy poprzedzić go znakiem \ (lewy ukośnik, z ang. backslash). Podobnie jeżeli chcemy uzyskać sekwencję \', należy napisać \\'. Ta zasada dotyczy także samego znaku ukośnika. Zilustrowano to w przykładzie widocznym na listingu 2.9. Efekt działania kodu został zaprezentowany na rysunku 2.9. Listing 2.9. Sposób wyświetlania znaków apostrofu i lewego ukośnika

Rysunek 2.9. Wynik działania skryptu 2.9

Wykorzystanie znaków cudzysłowu Drugim sposobem deklaracji łańcucha znakowego jest ujęcie go w znaki cudzysłowu. Przykładem takiego ciągu jest "abc". Takie ciągi są przetwarzane przez PHP. Najważniejsze jest to, że jeśli w tego typu sekwencji znajdzie się określenie zmiennej, zostanie ono zmienione na wartość przez nią reprezentowaną (ten temat zostanie bliżej omówiony w sekcji „Wyświetlanie wartości zmiennych”). Wykorzystanie składni heredoc W przypadku składni heredoc łańcuch znakowy należy rozpocząć od sekwencji <<<, po której musi nastąpić identyfikator. Tego identyfikatora należy następnie użyć w ce-

Rozdział 2. ♦ Elementy języka

61

lu zasygnalizowania końca łańcucha znakowego. Dla nazwy identyfikatora obowiązują takie same zasady jak przy nazewnictwie zmiennych. Może się ona zaczynać wyłącznie od znaku podkreślenia lub litery i może zawierać dowolną kombinację liter, cyfr i znaków podkreślenia. Linia kończąca nie może natomiast zawierać żadnych innych znaków oprócz identyfikatora i średnika. Uwaga ta dotyczy wszystkich znaków, również spacji, tabulatorów itp.! Przykład definicji łańcucha znakowego korzystającej ze składni heredoc jest następujący: $napis = <<
Zmienne zawarte w ciągu znaków korzystającym z opisywanej składni, podobnie jak w przypadku składni z cudzysłowami, zostaną zamienione na odpowiadające im wartości. Jak łatwo się domyślić, ten sposób tworzenia napisów jest wykorzystywany najczęściej wtedy, gdy mają one mieć znaczną długość i składają się z wielu linii. Przykładowy skrypt wykorzystujący opisywany rodzaj składni do definicji łańcucha znakowego oraz wyświetlający ten łańcuch na ekranie został przedstawiony na listingu 2.10. Listing 2.10. Wykorzystanie składni heredoc do utworzenia łańcucha znakowego

Składa się on z kilku linii.
Dlatego też została wykorzystana składnia heredoc.
ID1; echo $napis; ?>

Wykorzystanie składni newdoc Składnia newdoc jest bardzo podobna do heredoc. Różnica jest taka, że w przypadku newdoc ciąg nie jest interpretowany, a zatem nazwy zmiennych nie są zamieniane na odpowiadające im wartości. Zatem różnica między hewdoc a heredoc jest taka jak między użyciem znaków apostrofu i cudzysłowu. Składnia newdoc została wprowadzona do PHP w wersji 5.3.0. Wersje wcześniejsze jej nie obsługują. Schemat zastosowania jest następujący: $napis = <<<'ID2' Tutaj rozpoczyna się napis ID2;

62

PHP5. Praktyczny kurs

Jak widać, jedyną różnicą w definicji w stosunku do heredoc jest ujęcie identyfikatora w znaki apostrofu. Powstała w ten sposób zmienna $napis może być używana tak, jak i inne zmienne typu string. Skrypt ilustrujący różnice pomiędzy wszystkimi przedstawionymi wyżej rodzajami składni zostanie przedstawiony w lekcji 7.

Typy złożone Typy złożone dzielą się na dwa rodzaje. Są to:  typ array (tablicowy),  typ object (obiektowy).

Tablice zostaną omówione w lekcji 9., natomiast obiektom i programowaniu obiektowemu poświęcony jest cały rozdział 5.

Typy specjalne Wyróżniamy dwa rodzaje typów specjalnych. Są to:  typ resource,  typ null.

Typ resource Typ resource jest typem specjalnym wskazującym, że zmienna przechowuje odwołanie do zasobu zewnętrznego utworzonego za pomocą specjalnych funkcji. W niniejszej publikacji tego rodzaju dane nie będą omawiane.

Typ null Typ null jest typem specjalnym informującym o tym, że dana zmienna nie przechowuje żadnej wartości (jest pusta). Został on wprowadzony w PHP w wersji 4. Jego użycie jest praktycznie takie samo jak w innych językach programowania. Jeżeli chcemy ustawić zmienną na null, piszemy: $zmienna = null;

Wielkość liter nie ma przy tym znaczenia, prawidłowe są zatem zapisy: null, NULL, Null czy nawet całkowicie niepraktyczny nUlL. Nieco więcej informacji o tym typie zostanie podane w rozdziale 5. traktującym o programowaniu obiektowym.

Zmienne w kodzie skryptu Utworzenie zmiennej polega na umieszczeniu w kodzie skryptu jej nazwy poprzedzonej znakiem $ i przypisaniu jej wartości. Odmiennie niż w klasycznych językach programowania nie ma konieczności deklarowania zmiennych, co więcej, nie ma nawet

Rozdział 2. ♦ Elementy języka

63

konstrukcji języka pozwalającej na taką deklarację. Prawidłowa konstrukcja tworząca zmienną ma postać: $nazwa_zmiennej = wartość_zmiennej;

Oznacza ona: utwórz zmienną o nazwie nazwa_zmiennej oraz przypisz jej wartość wartość_zmiennej, gdzie wartość_zmiennej może być wartością jednego z typów przedstawionych na wcześniejszych stronach. Zobaczmy, jak będzie to wyglądało w praktyce. Utworzymy trzy zmienne, którym przypiszemy wartość liczbową całkowitą i rzeczywistą (z częścią dziesiętną) oraz łańcuch znaków. Następnie zawartość tak utworzonych zmiennych wyświetlimy na ekranie. Skrypt działający w opisany sposób został przedstawiony na listingu 2.11, natomiast efekt jego działania — na rysunku 2.10. Listing 2.11. Umieszczanie zmiennych w kodzie skryptu

"; echo "Zawartość zmiennej liczba2 = ", $liczba2, "
"; echo "Zawartość zmiennej napis = ", $napis, "
"; ?>

Rysunek 2.10. Efekt działania skryptu 2.11

Powstały trzy zmienne o nazwach $liczba1, $liczba2 i $napis. Zmiennej $liczba1 została przypisana wartość 10, zmiennej $liczba2 — 1.5, a zmiennej $napis — ciąg znaków Przykładowy napis. Wartości te zdeterminowały typ zmiennych. Skoro bowiem zmiennej $liczba1 została przypisana wartość całkowita, jej typem stał się integer, skoro zmiennej $liczba2 została przypisana wartość zmiennoprzecinkowa (z częścią

64

PHP5. Praktyczny kurs

dziesiętną), jej typem stał się float, a skoro zmiennej $napis został przypisany ciąg znaków, jej typem stał się string. Do wyświetlenia informacji zostały użyte instrukcje echo. Wykorzystana została składnia, w której poszczególne elementy wyświetlanego ciągu są od siebie oddzielane znakami przecinka. Na rysunku 2.10 widać wyraźnie, że na ekranie wszystkie wartości pojawiły się prawidłowo.

Wyświetlanie wartości zmiennych Do wyświetlenia wartości zmiennej, a dokładniej do wysłania tej wartości w postaci ciągu znaków do przeglądarki, posługujemy się zazwyczaj instrukcją echo. Taka instrukcja ma ogólną postać: echo $nazwa_zmiennej;

Jeśli wartość zmiennej ma być częścią dłuższego ciągu znaków, możemy skorzystać z serii instrukcji echo, np.: echo "napis1"; echo $nazwa_zmiennej; echo "napis2";

Można też użyć składni, w której poszczególne ciągi są od siebie oddzielane znakami przecinka, tak jak zostało to wykonane w przykładzie widocznym na listingu 2.11. Taka konstrukcja ma schematyczną postać: echo "napis1", $nazwa_zmiennej, "napis2";

To jednak nie wszystkie możliwości. Kilka stron wcześniej zostało napisane, że ciąg znaków może być utworzony na trzy sposoby:  za pomocą składni ze znakami apostrofu,  za pomocą składni ze znakami cudzysłowu,  za pomocą składni heredoc.

Teraz możemy dokładniej sprawdzić, jakie występują między nimi różnice w praktyce. Wiemy, że w przypadku znaków apostrofu zawartość ciągu prawie nie podlega modyfikacjom, natomiast w dwóch pozostałych przypadkach są one przetwarzane. Dokładniej rzecz ujmując, jeżeli w łańcuchu znakowym utworzonym za pomocą składni wykorzystującej znaki cudzysłowu lub składni heredoc znajdzie się określenie zmiennej, to w ciągu wynikowym określenie to zostanie zamienione na jej wartość. Spójrzmy na listing 2.12. Zawiera on przykładowy kod ilustrujący to zagadnienie. Listing 2.12. Różna interpretacja ciągów znakowych

Rozdział 2. ♦ Elementy języka

65

"; echo "Wartość zmiennej = $liczba"; ?>

Efekt działania kodu został zaprezentowany na rysunku 2.11. W skrypcie została umieszczona zmienna $liczba, której została przypisana wartość 100. Ponieważ ciąg znaków przeznaczony do wyświetlenia w pierwszej instrukcji echo został ujęty w znaki apostrofu, PHP nie zinterpretowało go, tylko wyświetliło w oryginalnej postaci. Druga instrukcja echo umieszcza po prostu w danych wyjściowych znacznik
. Trzecia wyświetla ciąg znaków, który został ujęty w znaki cudzysłowu, a zatem przed wyświetleniem został on przetworzony, tak że zamiast nazwy zmiennej $liczba została wstawiona jej wartość. Podczas przetwarzania takiego ciągu obowiązują następujące zasady:  Jeżeli zmienna jest typu znakowego, to zawarty w niej ciąg znaków jest

wklejany do ciągu bieżącego.  Jeżeli zmienna jest innego typu niż znakowy, to najpierw następuje jej konwersja do typu string (patrz sekcja „Konwersje typów”), a następnie

zostaje ona wklejona do ciągu bieżącego.  Jeżeli zmienna nie zawiera żadnej wartości, to jest traktowana jak pusty

ciąg znaków. Rysunek 2.11. Różne interpretacje ciągów znakowych

Podobnie jest przy korzystaniu ze składni heredoc. Również i w tym wypadku występujące w ciągu zmienne zostaną zamienione na przechowywane przez nie wartości. Ilustruje to przykład widoczny na listingu 2.13. W kodzie zostały utworzone trzy zmienne: $liczba1 i $liczba2 przechowujące dwie wartości całkowite oraz $napis przechowująca ciąg znaków zdefiniowany za pomocą składni heredoc. Ponieważ do tego ciągu zostały wstawione określenia dwóch pierwszych zmiennych, w napisie, który zostanie wysłany do przeglądarki za pomocą instrukcji echo, pojawią się ich wartości. Listing 2.13. Interpretacja ciągu zapisanego za pomocą składni heredoc

66

PHP5. Praktyczny kurs

Warto również wiedzieć, że w przypadkach podobnych do zaprezentowanego na listingu 2.13 nie ma konieczności tworzenia dodatkowej zmiennej typu string (czyli zmiennej $napis). Tekst może być wysłany bezpośrednio przy użyciu instrukcji echo. W takim wypadku miałaby ona postać: echo <<
Dzięki temu, że ciągi budowane za pomocą znaków cudzysłowu lub składni heredoc są interpretowane przez PHP, można w nich stosować sekwencje znaków specjalnych. Sekwencje te zostały przedstawione w tabeli 2.1 (sekwencje \v i \f są dostępne, począwszy od PHP w wersji 5.2.5). Dodatkowo jeśli poprzedzimy liczbę ukośnikiem, zostanie ona potraktowana jako kod znaku w notacji ósemkowej. Podobnie poprzedzenie liczby sekwencją \x (np. \xf, \x61) spowoduje, że zostanie ona potraktowana jako kod w notacji szesnastkowej. Należy jedynie pamiętać, że do dyspozycji mamy jedynie 256 różnych wartości (od 0 do 255), zatem liczba ósemkowa może mieć co najwyżej trzy, a liczba szesnastkowa maksymalnie dwie cyfry. Sposób wykorzystania sekwencji znaków specjalnych ilustruje skrypt widoczny na listingu 2.14. Tabela 2.1. Kodowanie znaków specjalnych Sekwencja znaków

Znaczenie

\n

Nowa linia (z ang. new line)

\r

Powrót karetki (powrót na początek wiersza, z ang. carriage return)

\t

Tabulator poziomy

\v

Tabulator pionowy

\f

Przewinięcie (wysunięcie) strony (z ang. form feed)

\\

Lewy ukośnik (z ang. backslash)

\$

Znak dolara

\"

Znak cudzysłowu

Rozdział 2. ♦ Elementy języka

67

Listing 2.14. Ilustracja wykorzystania sekwencji znaków specjalnych

"; echo "Znak dolara \$"; echo "
"; echo "\x61\x62\x63\x64 \144\143\142\141"; ?>

Pierwsza instrukcja echo powoduje wyświetlenie tekstu ujętego w znaki cudzysłowu. Aby taki znak mógł być umieszczony wewnątrz łańcucha znaków, niezbędne było zastosowanie sekwencji specjalnej \". Druga instrukcja echo wysyła do przeglądarki znacznik
, natomiast trzecia — ciąg zawierający znak $. Do uzyskania tego znaku została użyta sekwencja specjalna \$. Kolejna instrukcja to ponowne wysłanie do przeglądarki znacznika
. Ostatnia instrukcja echo jest zapewne najmniej zrozumiała. Przy pierwszym spojrzeniu trudno się zapewne domyślić, że powoduje ona wyświetlenie ciągu znaków abcd dcba. Został on skonstruowany z kodów ASCII poszczególnych liter. Pierwsze cztery znaki zostały przedstawione jako sekwencje specjalne wykorzystujące kody szesnastkowe (61 szesnastkowo to znak a, 62 to znak b itd.), po nich następuje spacja, a kolejne cztery znaki zostały przedstawione jako sekwencje wykorzystujące kody ósemkowe (141 ósemkowo to znak a, 142 znak b itd.). Ostatecznie po uruchomieniu skryptu w przeglądarce zobaczymy taki widok jak na rysunku 2.12. Rysunek 2.12. Efekt działania kodu z listingu 2.14

Zwróćmy również uwagę, że jeśli chcemy wyświetlić samą nazwę zmiennej, możemy to zrobić bezpośrednio tylko przy użyciu składni ze znakami apostrofu lub nowdoc. W dwóch pozostałych przypadkach trzeba będzie ją poprzedzić znakiem \ (inaczej zamiast nazwy pojawi się wartość zmiennej). A zatem jeśli w kodzie pojawi się instrukcja: $liczba = 20;

68

PHP5. Praktyczny kurs

tworząca zmienną $liczba i przypisująca jej wartość 20, to jeśli zechcemy wyświetlić tekst: Wartością zmiennej $liczba jest 20

powinniśmy użyć jednej z poniższych konstrukcji: echo 'Wartością zmiennej $liczba jest ', $liczba, '
'; echo "Wartością zmiennej \$liczba jest $liczba
"; echo << ID1;

Operacje na zmiennych Na zmiennych można wykonywać różne operacje. Jedną z nich już wykorzystywaliśmy. Była to operacja przypisania wykonywana za pomocą operatora =. Jeśli w kodzie skryptu pojawiała się instrukcja w postaci: $nazwa_zmiennej = wartość;

oznaczała ona: przypisz wartość wartość zmiennej nazwa_zmiennej. Czyli wykonanie instrukcji: $liczba = 5;

spowodowałoby przypisanie wartości 5 zmiennej $liczba. To oczywiście nie jedyny rodzaj możliwych do wykonywania operacji. Zmienne można dodawać, odejmować mnożyć, wykonywać na nich operacje bitowe, logiczne i inne. Każda taka operacja jest wykonywana za pomocą operatora. Operator przypisania już znamy, jest to znak równości. Jest ich jednak o wiele więcej. Przejdźmy więc od razu do sekcji „Operatory”, w której będzie kontynuowane to zagadnienie.

Operatory Występujące w PHP operatory, które służą do wykonywania różnorodnych operacji, można podzielić na kilka grup:  arytmetyczne,  bitowe,  logiczne,  przypisania,  relacyjne (porównywania),  inkrementacji/dekrementacji,  pozostałe.

Rozdział 2. ♦ Elementy języka

69

Operatory arytmetyczne Nietrudno się domyślić, że operatory z tej grupy służą do wykonywania operacji arytmetycznych, czyli dodawania, odejmowania, mnożenia itp. Zostały one zebrane w tabeli 2.2. Do operatorów arytmetycznych można także zaliczyć operatory inkrementacji i dekrementacji. Ponieważ jednak nie są one typowe dla osób, które nie miały do czynienia z programowaniem, omówimy je w osobnej sekcji. Tabela 2.2. Operatory arytmetyczne w PHP Operator

Wykonywane działanie

*

Mnożenie

/

Dzielenie

+

Dodawanie

-

Odejmowanie

%

Dzielenie modulo (reszta z dzielenia)

Działanie przedstawionych w tabeli 2.2 operatorów sprowadza się do wykonywania typowych działań arytmetycznych znanych każdemu, kto uczęszczał w szkole na lekcje matematyki. Jeśli zatem chcemy dodać do siebie dwie zmienne lub liczbę do zmiennej, wykorzystujemy operator +, do mnożenia operator * itd. W skrypcie z listingu 2.15 został pokazany sposób wykonywania podstawowych operacji. Listing 2.15. Wykonywanie operacji arytmetycznych

"; echo "Wartość zmiennej \$liczba2 = $liczba2
"; echo "Wartość zmiennej \$liczba3 = $liczba3
"; ?>

Zmiennej $liczba1 została przypisana wartość wynikająca z działania 2 * 5 + 18, czyli 28. Zwróćmy uwagę, że najpierw zostało wykonane działanie arytmetyczne znajdujące się z prawej strony operatora = i dopiero jego wynik został przypisany zmiennej. Tak samo będzie w przypadku innych instrukcji przypisania. Przetwarzanie wyrażeń będzie się odbywało od strony prawej do lewej.

70

PHP5. Praktyczny kurs

Zmiennej $liczba2 została przypisana wartość wynikająca z działania $liczba1 / 2, czyli 14, natomiast zmiennej $liczba3 wartość wynikająca z $liczba2 - $liczba1, czyli -14. Wartości wszystkich zmiennych zostały ostatecznie wyświetlone na ekranie. Przykład ten pokazuje, że operacje arytmetyczne mogą być wykonywane na samych liczbach, na zmiennych i liczbach oraz na samych tylko zmiennych. Do operatorów arytmetycznych należy również %, przy czym, jak zostało to zaznaczone w tabeli 2.2, nie oznacza on obliczania procentów, ale dzielenie modulo, czyli resztę z dzielenia. Przykładowo, działanie 10 % 3 da w wyniku 1. Trójka zmieści się bowiem w dziesięciu 3 razy, pozostawiając resztę 1 (3 * 3 = 9, 9 + 1 = 10). Podobnie 21 % 8 = 5, bowiem 2 * 8 = 16, 16 + 5 = 21.

Operatory bitowe Operatory bitowe służą, jak sama nazwa wskazuje, do wykonywania operacji na bitach. Aby się z nimi bliżej zapoznać, warto jednak przypomnieć sobie przynajmniej podstawowe informacje na temat systemu dwójkowego. W systemie dziesiętnym, z którego korzystamy na co dzień, jest wykorzystywane dziesięć cyfr od 0 do 9. W systemie dwójkowym będą zatem wykorzystywane jedynie dwie cyfry — 0 i 1. Kolejne liczby są budowane z tych dwóch cyfr dokładnie tak samo jak w systemie dziesiętnym, co przedstawia tabela 2.3. Łatwo sprawdzić, że np. 4 dziesiętnie to 100 dwójkowo, a 10 dziesiętnie to 1010 dwójkowo. Tabela 2.3. Kolejne 15 liczb w systemie dwójkowym i ich odpowiedniki w systemie dziesiętnym System dwójkowy

System dziesiętny

0

0

1

1

10

2

11

3

100

4

101

5

110

6

111

7

1000

8

1001

9

1010

10

1011

11

1100

12

1101

13

1110

14

1111

15

W PHP występuje sześć operatorów bitowych, które zostały przedstawione w tabeli 2.4. Są to: iloczyn bitowy (inaczej koniunkcja bitowa, operacja AND), suma bitowa (inaczej

Rozdział 2. ♦ Elementy języka

71

alternatywa bitowa, operacja OR), negacja bitowa (inaczej uzupełnienie do jedynki, operacja NOT), suma bitowa modulo 2 (inaczej alternatywa bitowa wykluczająca, różnica symetryczna, operacja XOR) oraz operacje przesunięć bitów. Wszystkie operacje z wyjątkiem jednoargumentowej negacji bitowej wymagają dwóch argumentów. Tabela 2.4. Operatory bitowe występujące w PHP Operator

Wykonywane działanie

&

Przykład

Iloczyn bitowy AND

a & b

|

Suma bitowa OR

a | b

~

Negacja bitowa NOT

~a

^

Bitowa różnica symetryczna XOR

a ^ b

>>

Przesunięcie bitowe w prawo

a >> n

<<

Przesunięcie bitowe w lewo

a << n

Iloczyn bitowy Iloczyn bitowy to operacja powodująca, że włączone pozostają tylko te bity, które były włączone w obu argumentach. Wynik operacji AND na pojedynczych bitach został zobrazowany w tabeli 2.5. Jeśli zatem wykonamy operację: $liczba = 179 & 38;

to zmiennej $liczba zostanie przypisana wartość 34. Tabela 2.5. Wyniki operacji AND dla pojedynczych bitów Argument 1

Argument 2

Wynik

1

1

1

1

0

0

0

1

0

0

0

0

Dlaczego 34? Najłatwiej pokazać to, jeśli obie wartości (czyli 179 i 38) przedstawi się w postaci dwójkowej. 179 w postaci dwójkowej to 10110011, natomiast 38 to 00100110. Operacja AND będzie zatem miała postać: 10110011 (179) 00100110 (38) -------00100010 (34)

Wynikiem jest więc 34.

Suma bitowa Suma bitowa to operacja powodująca, że pozostają włączone te bity, które były włączone przynajmniej w jednym z argumentów. Wynik operacji OR na pojedynczych bitach został zobrazowany w tabeli 2.6. Jeśli zatem wykonamy operację:

72

PHP5. Praktyczny kurs $liczba = 34 | 65;

to zmiennej $liczba zostanie przypisana wartość 99. Tabela 2.6. Wyniki operacji OR dla pojedynczych bitów Argument 1

Argument 2

Wynik

1

1

1

1

0

1

0

1

1

0

0

0

Gdy obie liczby rozpiszemy w postaci dwójkowej, otrzymamy 00100010 (34) i 01000001 (65). Zatem całe działanie będzie miało postać: 00100010 (34) 01000001 (65) -------01100011 (99)

Negacja bitowa Negacja bitowa powoduje zmianę stanu bitów. Czyli tam, gdzie dany bit miał wartość 0, będzie miał 1, natomiast tam, gdzie miał wartość 1, będzie miał 0. Działanie operacji NOT na pojedynczych bitach zobrazowano w tabeli 2.7. Tabela 2.7. Wyniki operacji NOT dla pojedynczych bitów Argument

Wynik

1

0

0

1

Bitowa różnica symetryczna Bitowa różnica symetryczna, czyli operacja XOR, powoduje, że włączone zostają te bity, które miały różne stany w obu argumentach, a pozostałe zostają wyłączone. Wynik operacji XOR na pojedynczych bitach zobrazowano w tabeli 2.8. Tabela 2.8. Wyniki operacji XOR dla pojedynczych bitów argument 1

argument 2

wynik

1

1

0

1

0

1

0

1

1

0

0

0

Wykonanie przykładowej operacji: $liczba = 34 ^ 118;

Rozdział 2. ♦ Elementy języka

73

spowoduje przypisanie zmiennej $liczba wartości 84. Jeśli bowiem zapiszemy obie wartości w postaci dwójkowej, to 34 przyjmie postać 00100010, natomiast 118 — 01110110. Operacja XOR będzie zatem wyglądała następująco: 00100010 (34) 01110110 (118) -------01010100 (84)

Przesunięcie bitowe w lewo Przesunięcie bitowe w lewo to operacja polegająca na przesunięciu wszystkich bitów argumentu znajdującego się z lewej strony operatora w lewo o liczbę miejsc wskazaną przez argument znajdujący się z jego prawej strony. Tym samym wykonanie przykładowej operacji: $liczba = 84 << 1;

spowoduje przypisanie zmiennej $liczba wartości 168. Działanie 84 << 1 oznacza bowiem: przesuń wszystkie bity wartości 84 o jedno miejsce w lewo. Skoro 84 w postaci dwójkowej ma postać 01010100, to po przesunięciu powstanie 10101000, czyli 168. Warto zauważyć, że przesunięcie bitowe w lewo odpowiada mnożeniu wartości przez wielokrotność liczby 2. Czyli przesunięcie w lewo o jedno miejsce to pomnożenie przez 2, o dwa miejsca — przez 4, o trzy miejsca — przez 8 itd.

Przesunięcie bitowe w prawo Analogicznie do powyższego przesunięcie bitowe w prawo polega na przesunięciu wszystkich bitów argumentu znajdującego się z lewej strony operatora w prawo o liczbę miejsc wskazaną przez argument, który znajduje się z prawej strony operatora. A zatem wykonanie operacji: $liczba = 84 >> 1;

spowoduje przypisanie zmiennej $liczba wartości 42. Oznacza to bowiem przesunięcie wszystkich bitów wartości 01010100 o jedno miejsce w prawo, czyli powstanie wartości 00101010 dwójkowo (42 dziesiętnie). Tu również należy zwrócić uwagę, że przesunięcie bitowe w prawo odpowiada podzieleniu wartości przez wielokrotność liczby 2. Czyli przesunięcie w prawo o jedno miejsce to podzielenie przez 2, o dwa miejsca — przez 4, o trzy miejsca — przez 8 itd.12.

Operatory logiczne Operatory logiczne pozwalają na wykonywanie operacji logicznych. Można je wykonywać na argumentach, które posiadają wartość logiczną prawda lub fałsz. W PHP wartości te są oznaczane jako true i false. Przykładowe wyrażenie 0 < 1 ma wartość logiczną true (prawda), jako że 0 jest mniejsze od jedności, natomiast wyrażenie 10 > 12

Należy jednak pamiętać, że jeżeli dzielona liczba będzie nieparzysta, wówczas w wyniku takiego dzielenia zostanie utracona część ułamkowa.

74

PHP5. Praktyczny kurs 20 ma na pewno wartość false (fałsz), jako że 10 jest mniejsze niż 20, a nie większe. Operacje logiczne nie różnią się od tych znanych ze szkolnych lekcji matematyki. Są to AND (iloczyn logiczny), OR (suma logiczna), XOR (logiczna alternatywa wykluczająca) oraz NOT (negacja logiczna). To, jak wyglądają te operatory w PHP, zostało przedstawione w tabeli 2.9. Występujące w niej dwa rodzaje iloczynu logicznego i sumy logicznej wykonują takie same operacje, mają jednak różny priorytet (zobacz sekcja „Priorytety operatorów”). Wszystkie operatory logiczne, z wyjątkiem jednoargumentowej negacji, są dwuargumentowe.

Tabela 2.9. Operatory logiczne w PHP Operator

Wykonywane działanie

Przykład

and

Iloczyn logiczny (1)

$a and $b

or

Suma logiczna (1)

$a or $b

xor

Logiczna alternatywa wykluczająca

$a xor $b

!

Negacja logiczna

!$a

&&

Iloczyn logiczny (2)

$a && $b

||

Suma logiczna (2)

$a || $b

Iloczyn logiczny Wynikiem operacji AND (iloczyn logiczny) jest wartość true wtedy i tylko wtedy, gdy oba argumenty mają wartość true. W każdym innym przypadku wynikiem jest false. Przedstawiono to w tabeli 2.10. Tabela 2.10. Logiczny iloczyn Argument 1

Argument 2

Wynik

true

true

true

true

false

false

false

true

false

false

false

false

Suma logiczna Wynikiem operacji OR (suma logiczna, alternatywa logiczna) jest wartość true wtedy i tylko wtedy, gdy przynajmniej jeden z argumentów ma wartość true. W przypadku gdy oba argumenty mają wartość false, jest ona również wynikiem całej operacji. Przedstawiono to w tabeli 2.11. Tabela 2.11. Logiczna suma Argument 1

Argument 2

Wynik

true

true

true

true

false

true

false

true

true

false

false

false

Rozdział 2. ♦ Elementy języka

75

Logiczna alternatywa wykluczająca Wynikiem operacji XOR (logiczna alternatywa wykluczająca, różnica symetryczna) jest wartość true wtedy i tylko wtedy, gdy oba argumenty mają różną wartość. W przypadku gdy argumenty mają równą wartość, wynikiem jest false. Przedstawiono to w tabeli 2.12. Tabela 2.12. Logiczna alternatywa wykluczająca Argument 1

Argument 2

Wynik

true

true

false

true

false

true

false

true

true

false

false

false

Negacja logiczna Operacja NOT (logiczna negacja) zamienia wartość argumentu na przeciwną. Jeśli więc argument miał wartość true, będzie miał false i odwrotnie — jeśli miał wartość false, będzie miał true. Zobrazowano to w tabeli 2.13. Tabela 2.13. Logiczna negacja Argument

Wynik

true

false

false

true

Operatory przypisania Operatory są dwuargumentowe i powodują przypisanie wartości argumentu znajdującego się z prawej strony operatora temu znajdującemu się z lewej. Taką najprostszą operację już poznaliśmy. Odbywa się ona przy wykorzystaniu operatora = (równa się). Jeśli napiszemy $liczba = 10, oznacza to, że zmiennej $liczba chcemy przypisać wartość 10. W PHP istnieje jednak również cały zestaw operatorów łączących operację przypisania z inną — arytmetyczną, bitową lub łańcuchową. Przykładowo istnieje operator +=, który oznacza: przypisz argumentowi umieszczonemu z lewej strony wartość wynikającą z dodawania argumentów znajdujących się z lewej i prawej strony operatora. Choć być może brzmi to z początku nieco zawile, w rzeczywistości jest bardzo proste i znacznie upraszcza niektóre konstrukcje programistyczne. Po prostu przykładowy zapis: $a += 5

tłumaczymy jako: $a = $a + 5

Oznacza on: przypisz zmiennej $a wartość wynikającą z dodawania $a + 5.

76

PHP5. Praktyczny kurs

W PHP występuje cała grupa tego typu operatorów (są one zebrane w tabeli 2.14). Schematycznie możemy przedstawić ich znaczenie następująco: arg1 op= arg2

oznacza działanie arg1 = arg1 op arg2

czyli $a += $b oznacza $a = $a + $b, $a ∗= $b oznacza $a = $a ∗ $b, $a %= $b oznacza $a = $a % $b itd. Tabela 2.14. Operatory przypisania i ich znaczenie w PHP Argument 1

Operator

Argument 2

Znaczenie

x

=

y

x = y

x

+=

y

x = x + y

x

-=

y

x = x – y

x

*=

y

x = x ∗ y

x

/=

y

x = x / y

x

%=

y

x = x % y

x

.=

y

x = x . y

x

<<=

y

x = x << y

x

>>=

y

x = x >> y

x

&=

y

x = x & y

x

|=

y

x = x | y

x

^=

y

x = x ^ y

Operatory relacyjne Operatory relacyjne służą do porównywania argumentów (stąd też nazywane są również operatorami porównywania). Wynikiem ich działania jest wartość logiczna true lub false, czyli prawda lub fałsz. Zatem wynikiem operacji argument1 == argument2 będzie true, jeżeli argumenty są sobie równe, oraz false, jeżeli są różne. Oznacza to, że wyrażenie 4 == 5 ma wartość false (bowiem 4 nie jest równe 5), natomiast 2 == 2 ma wartość true (bowiem 2 jest równe 2). Podobnie 2 < 3 ma wartość true (bowiem 2 jest mniejsze od 3), ale 4 < 1 ma wartość false (bowiem 4 jest większe, a nie mniejsze od 1). Operatory tego typu najczęściej wykorzystywane są w połączeniu z instrukcjami warunkowymi, które zostaną omówione w lekcji 4. Występujące w PHP operatory relacyjne zostały zebrane w tabeli 2.15.

Operatory inkrementacji i dekrementacji Operatory inkrementacji, czyli zwiększania (++), oraz dekrementacji, czyli zmniejszania (--), nieobce są z pewnością osobom znającym języki takie jak C, C++ czy Java. Operator ++ zwiększa po prostu wartość zmiennej o jeden, a -- zmniejsza o jeden. Oba mogą występować w formie przedrostkowej lub przyrostkowej. Jeśli na przykład istnieje zmienna $liczba, forma przedrostkowa będzie miała postać: ++$liczba, natomiast przyrostkowa — $liczba++.

Rozdział 2. ♦ Elementy języka

77

Tabela 2.15. Operatory relacyjne w PHP Operator

Opis

Przykład

==

Wynikiem jest true, jeśli argumenty są sobie równe.

$a == $b

===

Wynikiem jest true, jeśli argumenty są sobie równe i są tego samego typu.

$a === $b

<>

Wynikiem jest true, jeśli argumenty są różne.

$a <> $b

!=

Wynikiem jest true, jeśli argumenty są różne.

$a != $b

!==

Wynikiem jest true, jeśli argumenty są różne lub są różnych typów.

$a !== $b

>

Wynikiem jest true, jeśli argument prawostronny jest mniejszy od lewostronnego.

$a > $b

<

Wynikiem jest true, jeśli argument prawostronny jest większy od lewostronnego.

$a < $b

>=

Wynikiem jest true, jeśli argument prawostronny jest mniejszy od lewostronnego lub równy mu.

$a >= $b

<=

Wynikiem jest true, jeśli argument prawostronny jest większy od lewostronnego lub równy mu.

$a <= $b

Obie postacie powodują zwiększenie wartości zapisanej w $liczba o jeden, ale w przypadku formy przedrostkowej (++$liczba) odbywa się to przed wykorzystaniem zmiennej, a w przypadku przyrostkowej ($liczba++) dopiero po jej wykorzystaniu. Mimo że dla osób początkujących może to być niezrozumiałe, wszelkie wątpliwości rozwieje przykład widoczny na listingu 2.16 (dla ułatwienia opisu poszczególne wiersze kodu zostały ponumerowane). Jakie będzie jego działanie? Listing 2.16. Ilustracja działania operatora ++

78

PHP5. Praktyczny kurs

Po uruchomieniu kodu na ekranie przeglądarki pojawi się ciąg liczb 244467. Dlaczego? Otóż w linii 1. deklarujemy zmienną $x oraz przypisujemy jej wartość 2. W linii 2. stosujemy formę przyrostkową operatora ++, zatem najpierw wyświetlamy wartość zmiennej $x ($x = 2) na ekranie, a dopiero potem zwiększamy ją o jeden ($x = 3). W linii 3. postępujemy dokładnie odwrotnie, to znaczy przez zastosowanie formy przedrostkowej najpierw zwiększamy wartość zmiennej $x o jeden ($x = 4), a dopiero potem wyświetlamy ją na ekranie. W linii 4. jedyną operacją jest ponowne wyświetlenie wartości $x ($x = 4). W linii 5. najpierw przypisujemy aktualną wartość $x ($x = 4) zmiennej $y ($y = 4), a dopiero potem zwiększamy $x o jeden ($x = 5). W linii 6. wyświetlamy wartość $y. W linii 7. najpierw zwiększamy $x o jeden ($x = 6), a następnie przypisujemy tę wartość $y ($y = 6). W linii 8. wyświetlamy wartość $y na ekranie. W linii 9. najpierw zwiększamy $y o jeden ($y = 7), a dopiero potem wyświetlamy tę wartość na ekranie. W ten sposób powstaje wymieniony wyżej ciąg liczb. Operator dekrementacji (--) działa analogicznie do ++, z tą różnicą, że zmniejsza wartość zmiennej o jeden. Zmodyfikujmy zatem program z listingu 2.16 w taki sposób, aby wszystkie wystąpienia ++ zostały zamienione na --. Otrzymamy wtedy skrypt widoczny na listingu 2.17. Tym razem wynikiem będzie ciąg liczb 2000-2-3. Prześledźmy jego działanie. Listing 2.17. Ilustracja działania operatora -

W linii 1. deklarujemy zmienną $x i przypisujemy jej wartość 2, dokładnie tak jak w skrypcie z listingu 2.16. W linii 2. stosujemy formę przyrostkową operatora --, zatem najpierw wyświetlamy wartość zmiennej $x ($x = 2) na ekranie, a dopiero potem zmniejszamy ją o 1 ($x = 1). W linii 3. postępujemy dokładnie odwrotnie, to znaczy

Rozdział 2. ♦ Elementy języka

79

przez zastosowanie formy przedrostkowej najpierw zmniejszamy wartość zmiennej $x o jeden ($x = 0), a dopiero potem wyświetlamy ją na ekranie. W linii 4. jedyną operacją jest ponowne wyświetlenie wartości $x (x = 0). W linii 5. najpierw przypisujemy aktualną wartość $x ($x = 0) zmiennej $y ($y = 0), a dopiero potem zmniejszamy $x o jeden ($x = -1). W linii 6. wyświetlamy wartość $y ($y = 0). W linii 7. najpierw zmniejszamy $x o jeden ($x = -2), a następnie przypisujemy tę wartość $y ($y = -2). W linii 8. wyświetlamy wartość $y ($y = -2). W linii 9. najpierw zmniejszamy $y o jeden ($y = -3), a dopiero potem wyświetlamy tę wartość na ekranie.

Operatory tablicowe Operatory tablicowe wykonują operacje na tablicach, które zostaną omówione dopiero w lekcji 9. (osoby, które dotychczas nie programowały i nie znają pojęcia tablic, powinny najpierw zapoznać się z materiałem z tej lekcji). Możemy wyróżnić trzy grupy operatorów tablicowych:  operator łączenia tablic,  operator indeksowania tablic,  operatory porównywania tablic.

Operator łączenia tablic W PHP istnieje jeden operator łączenia tablic, który ma taką samą postać jak operator arytmetycznego dodawania, czyli jest to znak plus (+). Jest on dwuargumentowy i dokonuje złączenia dwóch tablic. Dokładniej mówiąc, do tablicy znajdującej się po lewej stronie operatora zostanie dodana zawartość tablicy znajdującej się po jego prawej stronie. Jeżeli w obu tablicach znajdą się elementy o takich samych indeksach, to po wykonaniu operacji złączenia będą miały takie same wartości jak elementy z tablicy znajdującej się po lewej stronie. Taką sytuację zobrazowano w przykładzie widocznym na listingu 2.18. Listing 2.18. Przykład operacji złączenia tablic 1, 2 => 2, 3 => 3 ); $b = array( 3 => "trzy", 4 => "cztery", 5 => "pięć" ); $c = $a + $b; var_dump($c); ?>

80

PHP5. Praktyczny kurs

W wyniku działania skryptu13 powstanie tablica $c o zawartości: [1] = 1, [2] = 2, [3] = 3, [4] = "cztery", [5] = "pięć". Jak widać, zdublowany był tu indeks 3. i jego zawartość pozostała taka sama jak w tablicy $a.

Operator indeksowania tablic Operator indeksowania tablicy składa się z dwóch znaków nawiasu kwadratowego i umożliwia dostęp do jej poszczególnych komórek. Schematyczna postać (dla tablicy jednowymiarowej) wygląda następująco: nazwa_tablicy[indeks]

Operatory porównywania tablic PHP oferuje również 5 operatorów służących do porównywania tablic. Są one podobne do zwykłych operatorów porównywania przedstawionych wyżej, choć występują między nimi pewne różnice. Operatory porównywania tablic zostały zebrane w tabeli 2.16. Tabela 2.16. Operatory porównywania tablic Operator

Znaczenie

Przykład

==

Wynikiem jest true, jeśli tablice zawierają takie same pary klucz – wartość.

$a == $b

===

Wynikiem jest true, jeśli tablice zawierają takie same pary klucz – wartość ustawione w takiej samej kolejności i tych samych typów.

$a === $b

<>

Odwrotność operatora ==. Wynikiem jest true, jeśli tablice są różne (nie zawierają takich samych par klucz-wartość).

$a <> $b

!=

Odwrotność operatora ==. Wynikiem jest true, jeśli tablice są różne (nie zawierają takich samych par klucz-wartość).

$a != $b

!==

Odwrotność operatora ===. Wynikiem jest true, jeśli tablice nie zawierają takich samych par klucz – wartość, pary te są ustawione w innej kolejności lub też są innych typów.

$a !== $b

Pozostałe operatory Łańcuchowy Operator łańcuchowy dokonuje złączenia, inaczej konkatenacji, łańcuchów znakowych. Jest wyrażany za pomocą znaku kropki. Za jego pomocą można łączyć bezpośrednio łańcuchy znaków ze sobą, ze zmiennymi typu string, a także same zmienne typu string. Przykład zastosowania operatora . we wszystkich trzech wymienionych sytuacjach zobrazowano w kodzie z listingu 2.19. Po jego wykonaniu w przeglądarce ukaże się widok zaprezentowany na rysunku 2.13. Listing 2.19. Skrypt wykonujący złączenia łańcuchów znakowych 13

Użyta w skrypcie funkcja var_dump powoduje wyświetlenie zawartości tablicy.

Rozdział 2. ♦ Elementy języka

81

"; $str3 = $str1 . "Trzeci tekst"; echo $str3; echo "
"; $str4 = "Czwarty tekst" . "Piąty tekst"; echo $str4; ?>

Rysunek 2.13. Efekt działania kodu z listingu 2.19

Warunkowy Operator warunkowy ma ogólną postać: (wyrażenie1)?(wyrażenie2):(wyrażenie3) i zostanie opisany w lekcji 4. podczas omawiania instrukcji warunkowych.

Kontroli błędów Operator kontroli błędów to @ (ampersand). Jeżeli zostanie postawiony przed wyrażeniem, to w przypadku gdyby wygenerowało ono błąd, ten zostanie zignorowany i żaden komunikat nie zostanie wysłany do przeglądarki. Dodatkowo w sytuacji gdy w pliku konfiguracyjnym php.ini jest włączona opcja track_errors, komunikat o błędzie zostanie zapisany w zmiennej globalnej $php_errormsg. Należy jednak pamiętać, że ta zmienna jest nadpisywana przy każdym wystąpieniu kolejnego błędu.

Wykonania polecenia zewnętrznego Operator wykonania polecenia zewnętrznego składa się z dwóch znaków lewego apostrofu ` (znajduje się on na klawiaturze pod znakiem tyldy). Pozwala na wydanie polecenia, które zostanie wykonane w powłoce systemowej (z ang. system shell). Można w ten sposób wywołać również program działający w wierszu poleceń. Przykład zastosowania tego operatora jest widoczny na listingu 2.20. Wywołuje on polecenie ls –la

82

PHP5. Praktyczny kurs

(w przypadku skryptów działających w systemie Windows należy użyć polecenia dir), wynik jego działania przypisuje zmiennej $lista i wyświetla jej zawartość na ekranie. Dzięki temu w przeglądarce ukaże się lista plików znajdujących się w katalogu bieżącym serwera. Listing 2.20. Przykład użycia operatora wykonania polecenia zewnętrznego "; echo $pliki; echo ""; ?>

Kontroli typów Operatorem kontroli typów jest instanceof. Umożliwia on sprawdzenie, czy obiekt jest instancją danej klasy. Temat klas i obiektów zostanie omówiony jednak dopiero w rozdziale 5. Sposób działania tego operatora został zobrazowany w przykładzie widocznym na listingu 2.21. Listing 2.21. Zastosowanie operatora instanceof '; } if(!($obj2 instanceof Klasa1)){ echo 'Obiekt $obj2 nie jest instancją klasy Klasa1.'; } ?>

Rzutowania typów (konwersji) Operatory rzutowania typów pozwalają na zmianę typu zmiennych. Temat ten zostanie omówiony w sekcji „Konwersje typów”. Występujące w PHP operatory rzutowania zostały zebrane w tabeli 2.17.

Rozdział 2. ♦ Elementy języka

83

Tabela 2.17. Operatory rzutowania typów Operator

Znaczenie

(int)

Konwersja do typu int

(float)

Konwersja do typu float

(string)

Konwersja do typu string

(array)

Konwersja do typu tablicowego

(object)

Konwersja do typu obiektowego

Tworzenia obiektów Do tworzenia obiektów służy operator new. Dokładniejszy jego opis znajduje się w rozdziale 5. omawiającym zagadnienia programowania obiektowego. Schematyczne wywołanie operatora new wygląda następująco: new nazwa_klasy(argumenty konstruktora);

Rozdzielania wyrażeń Operator przecinek (,) pozwala na oddzielenie od siebie wyrażeń, które mają być przetwarzane od strony lewej do prawej. Najczęściej wykorzystywany jest w pętli typu for (pętle zostaną omówione w lekcji 4.), gdzie umożliwia użycie kilku instrukcji w wyrażeniach początkowych, warunkowych i modyfikujących, np.: for (i = 0, j = 100; i < 100, j > 0; i++, j--){/*instrukcje wnętrza pętli*/}

Priorytety operatorów Oprócz znajomości samych operatorów niezbędna jest jeszcze wiedza o tym, jakie mają one priorytety, czyli jaka jest kolejność wykonywania reprezentowanych przez nie operacji. Wiemy na przykład z matematyki, że mnożenie jest silniejsze od dodawania, zatem najpierw mnożymy, potem dodajemy. W PHP jest podobnie, siła każdego operatora jest ściśle określona. Przedstawiono to w tabeli 2.1814. Im wyższa pozycja w tabeli, tym wyższy priorytet operatora. Operatory znajdujące się na jednym poziomie (w jednym wierszu) mają ten sam priorytet.

Zmienne globalne (superglobalne) W PHP do dyspozycji jest zestaw zmiennych globalnych (nazywanych superglobalnymi lub autoglobalnymi), które są dostępne w każdej części skryptu. Większość z nich to tablice (patrz lekcja 9.), które pozwalają na uzyskanie najróżniejszych informacji konfiguracyjnych oraz związanych z bieżącym wywołaniem skryptu. Wiele z tych informacji będzie wykorzystywane w dalszej części książki. Poniżej znajduje się lista dostępnych zmiennych superglobalnych wraz z krótkimi opisami.

14

Za operator uznaje się również nieujęty w tabeli print.

84

PHP5. Praktyczny kurs

Tabela 2.18. Priorytety operatorów Lp.

Rodzaje operatorów

Symbole

1

Tworzenie obiektów

new

2

Indeks tablicy

[]

3

Inkrementacja, dekrementacja

++, --

4

Negacja bitowa, zmiana znaku wartości, konwersje typów, kontrola błędów

~, +, -, (int), (float), (string), (array), (object), @

5

Kontrola typów

instanceof

6

Negacja logiczna

!

7

Mnożenie, dzielenie, reszta z dzielenia

*, /, %

8

Dodawanie, odejmowanie, łączenie łańcuchów znakowych

+, -, .

9

Przesunięcia bitowe

<<, >>

10

Relacje (mniejsze, większe, mniejsze lub równe, większe lub równe)

<, >, <=, >=

11

Relacje (równe, identyczne, różne, nieidentyczne)

==, ===, !=, !==

12

Iloczyn bitowy

&

13

Bitowa różnica symetryczna

^

14

Suma bitowa

|

15

Iloczyn logiczny

&&

16

Suma logiczna

||

17

Warunkowy

? :

18

Operatory przypisania

=, +=, -=, *=, /=, .=, %=, &=, ^=, |=, <<=, >>=

19

Iloczyn logiczny

and

20

Logiczna różnica symetryczna

xor

21

Suma logiczna

or

22

Rozdzielanie wyrażeń

,

$GLOBALS

Jest to tablica zawierająca odniesienie do każdej zmiennej zdefiniowanej przez użytkownika, która ma zasięg globalny dla danego skryptu (temat zasięgu i widoczności zmiennych zostanie przedstawiony bliżej podczas omawiania funkcji w lekcji 6.). Kluczami tej tablicy są nazwy, a wartościami kluczy wartości zmiennych. Tablica $GLOBALS została wprowadzona w PHP 3. $_SERVER

Jest to tablica zawierająca informacje ustawiane przez serwer WWW. Można z niej odczytać m.in. dane dotyczące połączenia, które wywołało dany skrypt, np. adres IP, port, wartości nagłówków HTTP itp. (przykład użycia zostanie podany w lekcji 12.). Zmienna ta jest dostępna od PHP 4.1.0. W wersjach wcześniejszych wykorzystywana była do tego celu zmienna $HTTP_SERVER_VARS.

Rozdział 2. ♦ Elementy języka

85

$_GET

Tablica zawierająca dane przekazane do serwera WWW za pomocą metody GET. Zmienna $_GET jest dostępna od PHP 4.1.0. W wersjach wcześniejszych wykorzystywana była do tego celu zmienna $HTTP_GET_VARS. $_POST

Tablica zawierająca dane przekazane do serwera WWW za pomocą metody POST. Zmienna $_POST jest dostępna od PHP 4.1.0. W wersjach wcześniejszych wykorzystywana była do tego celu zmienna $HTTP_POST_VARS. $_COOKIE

Tablica zawiera cookies przekazane z serwera WWW. Zmienna $_COOKIE jest dostępna od PHP 4.1.0. W wersjach wcześniejszych wykorzystywana była do tego celu zmienna $HTTP_COOKIE_VARS. $_FILES

Tablica zawierająca elementy przekazane do skryptu za pomocą metody POST podczas przesyłania plików do serwera. Zmienna $_FILES jest dostępna od PHP 4.1.0. W wersjach wcześniejszych wykorzystywana była do tego celu zmienna $HTTP_POST_FILES. $_ENV

Tablica zawierająca wartości zmiennych środowiskowych przekazanych z systemu, na którym działa PHP. Zmienna $_ENV jest dostępna od PHP 4.1.0. W wersjach wcześniejszych wykorzystywana była do tego celu zmienna $HTTP_ENV_VARS. $_REQUEST

Tablica asocjacyjna zawierająca dane z $_GET, $_POST i $_COOKIE. Zmienna $_REQUEST jest dostępna od PHP 4.1.0, nie ma odpowiednika we wcześniejszych wersjach. Do wersji PHP 4.3.0 $_REQUEST zawierała również dane z tablicy $_FILES. $_SESSION

Tablica asocjacyjna zawierająca dane związane z bieżącą sesją (sesje zostały opisane w rozdziale 8.). Zmienna $_SESSION jest dostępna od PHP 4.1.0. W wersjach wcześniejszych wykorzystywana była do tego celu zmienna $HTTP_SESSION_VARS.

Konwersje typów Jak już wiadomo, w PHP nie ma instrukcji służących deklaracji zmiennych, a typ zmiennej jest determinowany przez typ przypisywanej do niej wartości. Oznacza to na przykład, że wykonanie instrukcji: $zmienna1 = "napis";

powoduje przypisanie zmiennej $zmienna1 ciągu znaków napis oraz ustalenie jej typu jako string. Jeśli ta zmienna nie była wcześniej użyta w kodzie, zostanie utworzona. Typ zmiennej nie jest jednak przypisany do niej na stałe. Może się on wielokrotnie

86

PHP5. Praktyczny kurs

zmieniać w trakcie działania skryptu. Wystarczy, jeśli jednej zmiennej będą przypisywane wartości różnych typów — wtedy jej typ będzie się zmieniał automatycznie. Obrazuje to następujący fragment kodu:

Istnieje jednak możliwość wymuszania typu zmiennej. Zanim jednak zobaczymy, w jaki sposób dokonać takiej operacji, spójrzmy na listing 2.22 i zastanówmy się, jaki będzie efekt jego działania. W pierwszej chwili może się wydawać, że w przeglądarce pojawią się połączone ciągi znaków zapisane w zmiennych $napis1 i $napis2. Tymczasem okazuje się, że wartością zmiennej $napis3 wcale nie będzie taki ciąg, ale wartość 0. Co się stało? Listing 2.22. Nieprawidłowe użycie operatora +

Popełniliśmy oczywiście błąd, na który szczególnie narażone są osoby piszące wcześniej skrypty w języku JavaScript. Otóż w kodzie został użyty operator +, który jest arytmetycznym operatorem dodawania i jako taki nie może być wykorzystywany do łączenia łańcuchów znakowych. Jak wiadomo z wcześniejszych stron, do takiej operacji należy wykorzystać operator konkatenacji (łączenia) łańcuchów, czyli znak kropki (.). Prawidłowa byłaby zatem instrukcja: $napis3 = $napis1 . $napis2;

Skąd jednak w wyniku wzięła się wartość 0? Skoro operator + służy do wykonywania dodawania arytmetycznego, PHP oczekuje, że argumentami będą wartości arytmetyczne (czyli wartości jednego z typów arytmetycznych). W tym wypadku jednak argu-

Rozdział 2. ♦ Elementy języka

87

mentami są zmienne $napis1 i $napis2 typu łańcuchowego. Została zatem wykonana automatyczna konwersja (czyli zmiana) typów. Ponieważ jednak żadna ze zmiennych łańcuchowych nie zawierała danych, które mogłyby reprezentować wartości liczbowe (całkowite lub rzeczywiste), w obu przypadkach wynikiem konwersji była wartość 0. A zatem zmienne $napis1 i $napis2 zostały potraktowane tak, jakby zawierały wartości arytmetyczne 0. Oczywiście wynikiem dodawania 0+0 jest również 0. Stąd wynik całej operacji. To, jakie zasady rządzą konwersjami pomiędzy różnymi typami danych, zostanie opisane w sekcji „Zasady konwersji”.

Wymuszanie konwersji W PHP nie jesteśmy zdani jedynie na konwersje automatyczne. Można je również wykonywać samodzielnie. Technikę tę nazywamy rzutowaniem typów. Może się np. zdarzyć, że będziemy chcieli zmienić typ danych tak, aby mieć pewność, iż nowa zmienna będzie określonego typu. Odbywa się to podobnie jak w klasycznych językach programowania, takich jak C i C++. Zmienną należy poprzedzić ujętą w nawias okrągły nazwą typu, na który dokonujemy rzutowania. Taka operacja schematycznie mogłaby wyglądać następująco: $pierwsza_zmienna = (nazwa_typu) $druga_zmienna;

Ten zapis należy rozumieć jako: wykonaj konwersję wartości przechowywanej przez zmienną $druga_zmienna do typu nazwa_typu i przypisz ją następnie do zmiennej pierwsza_zmienna. Zobaczmy, jak to działa na konkretnym przykładzie. Został on przedstawiony na listingu 2.23. Listing 2.23. Wykonanie konwersji typów

"; echo "Zmienna \$liczba2 ma wartość $liczba2."; ?>

Zmiennej $liczba1 została przypisana wartość rzeczywista 1.5, a tym samym jej typem stał się float. Następnie została wykonana instrukcja: $liczba2 = (int) $liczba1;

88

PHP5. Praktyczny kurs

Oznacza ona: pobierz wartość zmiennej $liczba1, wykonaj konwersję tej wartości do typu integer, a następnie przypisz ją do zmiennej $liczba2 (sam stan zmiennej $liczba1 nie ulega w trakcie tych operacji żadnym modyfikacjom). Ponieważ typ integer pozwala jedynie na przechowywanie wartości całkowitych, wartość przypisana zmiennej $liczba2 zostanie pozbawiona części ułamkowej. Tym samym na ekranie ujrzymy wartości 1,5 i 1. Operacja zmiany typu może zostać również wykonana za pomocą jednej z funkcji (pojęcie funkcji omawiamy w lekcji 6.) konwersji. Są to funkcje:  intval — wykonująca konwersję do typu int,  floatval — wykonująca konwersję do typu float,  doubleval — wykonująca konwersję do typu float 15,  strval — wykonująca konwersję do typu string.

Zamiast zatem pisać (int) $liczba, można też skorzystać z konstrukcji intval($liczba), co da takie same rezultaty16.

Zasady konwersji Podczas dokonywania konwersji pomiędzy różnymi typami danych, niezależnie od tego, czy jest to konwersja automatyczna czy też wymuszana przez użytkownika, obowiązują pewne zasady. Dzięki nim wiadomo, jakie uzyskamy wyniki. Zasady konwersji obowiązujące dla poszczególnych typów danych zostały podane poniżej.

Typ boolean W przypadku konwersji z innych typów danych do boolean obowiązuje zasada, że wartość false otrzymujemy, gdy dokonujemy konwersji z:  typu integer o wartości 0,  typu double o wartości 0.0,  typu łańcuchowego o wartości pustej "",  typu łańcuchowego o wartości "0",  tablicy o zerowej liczbie elementów,  typu obiektowego o zerowej liczbie elementów,  typu specjalnego null,  zmiennych, których wartość nie została ustawiona.

W każdym innym przypadku konwersja da wartość true. 15

Począwszy od PHP 4.2.0 funkcja doubleval jest aliasem funkcji floatval, tzn. użycie doubleval jest równoznaczne z użyciem floatval.

16

Trzecią możliwością zmiany typu jest użycie funkcji setType, która jednak nie będzie używana w książce.

Rozdział 2. ♦ Elementy języka

89

Typ integer W przypadku konwersji z innych typów do integer obowiązują następujące zasady:  Konwersja z typu boolean o wartości true daje wynik 1.  Konwersja z typu boolean o wartości false daje wynik 0.  Konwersja z typu double powoduje zaokrąglenie w dół do najbliższej liczby

całkowitej (utratę części ułamkowej).  W przypadku konwersji z typu string wartość typu integer otrzymamy, jeżeli łańcuch znaków zaczyna się od poprawnej liczby niezawierającej znaków e, E, ., po której mogą występować inne znaki (np. 123, –123, 15arfgh).

W pozostałych przypadkach zwrócona zostanie wartość 0 (zero).

Typ float W przypadku konwersji z typu string wartość typu float otrzymamy, jeśli łańcuch znaków zaczyna się od poprawnej liczby (może ona zawierać znaki e, E lub .), po której występują inne znaki bądź nie, np. 123.1, –12.3, 1.455E2abc. W pozostałych przypadkach zachowanie jest takie, jakby najpierw została wykonana konwersja do typu integer, a dopiero potem do typu double.

Typ string W przypadku konwersji z innych typów do string obowiązują następujące zasady:  Konwersja z typu boolean o wartości true daje w wyniku ciąg "1".  Konwersja z typu boolean o wartości false daje w wyniku ""

(pusty ciąg znaków).  Konwersja z typu integer daje w wyniku ciąg znaków reprezentujący

wartość całkowitą.  Konwersja z typu float daje w wyniku ciąg znaków reprezentujący

wartość rzeczywistą.  Konwersja z typu null daje w wyniku "" (pusty ciąg znaków).  Konwersja z typu tablicowego daje w wyniku ciąg znaków "Array".  Konwersja z typu obiektowego daje w wyniku ciąg znaków "Object".  Konwersja z typu resource daje w wyniku ciąg znaków "Resource id #n", gdzie n to unikalny numer zasobu przydzielony przez PHP.

Ćwiczenia do samodzielnego wykonania Ćwiczenie 4.1. Napisz przykładowy skrypt ilustrujący działanie operatorów bitowych.

90

PHP5. Praktyczny kurs

Ćwiczenie 4.2. Napisz przykładowy skrypt ilustrujący działanie kilku złożonych operatorów przypisania. Ćwiczenie 4.3. Napisz przykładowy skrypt ilustrujący zasadę działania priorytetów operatorów.

Lekcja 5. Instrukcje sterujące Instrukcje warunkowe Podczas pisania skryptów bardzo często zachodzi konieczność wykonywania różnych operacji w zależności od prawdziwości jakiegoś warunku. Najprostszym przykładem może być wyświetlanie różnych tekstów w zależności od tego, czy wybrana zmienna ma wartość mniejszą czy większą od 0. Na takie rozwidlenie kodu programu pozwalają instrukcje warunkowe. W PHP, tak jak i w innych popularnych językach skryptowych oraz klasycznych językach programowania, do badania warunków służą różne postacie instrukcji if.

Instrukcja if Instrukcja if występuje w kilku wersjach, najprostsza z nich ma schematyczną postać: if (warunek){ instrukcja1; instrukcja2; instrukcja3; }

Zapis ten należy rozumieć jako: jeśli warunek (umieszczony w nawiasie okrągłym za słowem if) jest prawdziwy, wykonaj blok instrukcji znajdujący się pomiędzy znakami nawiasu klamrowego. Czyli w przedstawionym przypadku, jeżeli warunek jest prawdziwy, zostaną wykonane instrukcje: instrukcja1, instrukcja2 i instrukcja3. Każda pojedyncza instrukcja w bloku w nawiasie klamrowym musi się kończyć znakiem średnika, natomiast za instrukcją if — za znakiem zamykającym nawiasu klamrowego (}) — średnik nie jest potrzebny (umieszczenie w takim miejscu średnika nie spowoduje wprawdzie powstania błędu, ale nie ma praktycznego znaczenia; najlepiej go pominąć17). W sytuacji gdy w bloku instrukcji if miałaby się znaleźć tylko jedna instrukcja, czyli miałby on postać: if (warunek){ instrukcja; }

17

Z formalnego punktu widzenia użycie znaku średnika za znakiem zamykającym nawiasu klamrowego zostałoby potraktowane jak umieszczenie w tym miejscu dodatkowej pustej instrukcji.

Rozdział 2. ♦ Elementy języka

91

dopuszczalne jest pominięcie nawiasu klamrowego, jednak obligatoryjny jest wtedy średnik kończący. Zatem prawidłowy jest zapis: if (warunek) instrukcja;

lub if (warunek) instrukcja;

Do skonstruowania warunku używane są operatory relacyjne przedstawione w lekcji 4. Zobaczmy, jak taka konstrukcja będzie wyglądała w praktyce. Przykładowy kod wykorzystujący instrukcję warunkową if został zaprezentowany na listingu 2.2418. Listing 2.24. Proste zastosowanie instrukcji if = 0){ echo "Wartość zmiennej \$liczba nie jest mniejsza od 0."; } ?>

Powstała zmienna $liczba, której została przypisana wartość –1. Pierwsza instrukcja warunkowa if sprawdza, czy wartość zapisana w tej zmiennej jest mniejsza od 0 ($liczba < 0) i jeśli tak, wyświetla stosowną informację. Druga instrukcja if sprawdza, czy zmienna $liczba jest większa lub równa 0 i jeśli tak, również wyświetla informację o tym fakcie. Ponieważ wartość zmiennej jest mniejsza od 0, na ekranie pojawi się jedynie napis Wartość zmiennej $liczba jest mniejsza od 0. Gdybyśmy zmienili pierwszą instrukcję np. na: $liczba = 10;

na ekranie pojawiłby się oczywiście napis: Wartość zmiennej $liczba nie jest mniejsza od 0.

Instrukcja if...else W przykładzie zaprezentowanym na listingu 2.24 zostały użyte dwie instrukcje if do sprawdzenia dwóch przeciwstawnych, wykluczających się wzajemnie warunków. Wykluczających się, ponieważ zmienna $liczba mogła być albo mniejsza, albo większa lub równa 0 (czyli nie mniejsza od 0). W takiej sytuacji można jednak użyć również rozbudowanej instrukcji if, której ogólna postać jest następująca: if (warunek){ //instrukcje do wykonania, gdy warunek jest prawdziwy }

18

Od tego miejsca w przykładach prezentujących różne struktury języka będą pomijane fragmenty kodu HTML, które nie są niezbędne do ich prawidłowego działania.

92

PHP5. Praktyczny kurs else{ //instrukcje do wykonania, gdy warunek jest fałszywy }

Jak widać, został dodany blok else, który jest wykonywany w sytuacji, gdy warunek jest fałszywy. Napiszmy zatem funkcjonalny odpowiednik skryptu z listingu 2.24 wykorzystujący tę formę instrukcji if. Kod realizujący to zadanie został przedstawiony na listingu 2.25. Listing 2.25. Wykorzystanie instrukcji if...else

Złożona instrukcja if...else if Trzecia wersja instrukcji if pozwala na badanie wielu warunków. Otóż po if może wystąpić wiele dodatkowych bloków else if. Schematyczna postać takiej konstrukcji to: if (warunek1){ instrukcje1; } else if (warunek2){ instrukcje2; } else if (warunek3){ ..instrukcje3; } ... else if (warunekN){ ..instrukcjeN; } else{ ..instrukcjeM; }

Oznacza to: jeżeli warunek1 jest prawdziwy, to zostaną wykonane instrukcje1. W przeciwnym wypadku, jeżeli jest prawdziwy warunek2, to zostaną wykonane instrukcje2. W przeciwnym wypadku (czyli gdy warunek1 i warunek2 są fałszywe), jeżeli jest prawdziwy warunek3, to zostaną wykonane instrukcje3 itd. Jeżeli żaden z warunków nie będzie prawdziwy, to zostaną wykonane instrukcjeM. Ostatni blok else jest jednak opcjonalny i nie musi być stosowany. Taka konstrukcja może być wykorzystana w sytuacji, gdy chcemy na przykład wykonać wiele różnych instrukcji w zależności od stanu zmiennej. W skrypcie widocznym na listingu 2.26 zobrazowano, w jaki sposób to zrobić.

Rozdział 2. ♦ Elementy języka

93

Listing 2.26. Przykład wykorzystania złożonej instrukcji if

\$liczba jest równa 0.";

\$liczba jest równa 10.";

\$liczba jest równa 20.";

\$liczba nie jest równa ani 0, ani 10, ani 20.";

W PHP instrukcję if…else if można również zapisać w taki sposób, w którym ciąg elseif to jedno słowo. Znaczenie takiej instrukcji nie zmienia się, jest to tylko inny sposób zapisu. Prawidłowa jest więc również postać: if (warunek1){ instrukcje1; } elseif (warunek2){ instrukcje2; }

Zagnieżdżanie instrukcji warunkowych Zarówno w bloku if, jak i w else mogą wystąpić dowolne instrukcje PHP. Oznacza to zatem, że można tam umieścić kolejne instrukcje if, a więc że mogą być one zagnieżdżane. Schematycznie taka konstrukcja będzie wyglądała następująco: if (warunek1){ if (warunek2){ instrukcje1; } else{ instrukcje2; } } else{ if (warunek3){ instrukcje3; } else{ instrukcje4; } }

Taka struktura ma następujące znaczenie: instrukcje1 zostaną wykonane, kiedy prawdziwe są warunki warunek1 i warunek2; instrukcje2 — kiedy prawdziwy jest warunek

94

PHP5. Praktyczny kurs warunek1, a fałszywy — warunek2; instrukcje3 — kiedy fałszywy jest warunek warunek1 i prawdziwy jest warunek3; a instrukcje instrukcje4, kiedy są fałszywe warunki warunek1 i warunek3. Oczywiście nie trzeba się ograniczać do przedstawionych tu

dwóch poziomów zagnieżdżenia — może ich być dużo więcej. Spróbujmy wykorzystać taką zagnieżdżoną instrukcję if w pierwszym „poważnym” skrypcie. Będzie on obliczał rozwiązania równania kwadratowego o zadanych parametrach19. Przypomnijmy, że równanie takie ma ogólną postać: A * x 2 + B * x + C = 0 , gdzie A, B i C to parametry równania. Równanie ma rozwiązanie w zbiorze liczb rzeczywistych, jeśli parametr Δ (delta) równy B 2 − 4 ∗ A ∗ C jest większy lub równy 0. Jeśli Δ równa jest 0, mamy jedno rozwiązanie równe − B ; jeśli Δ jest większa od 0, 2* A − B + Δ − B − Δ . Taka liczba warunków doi x2 = mamy dwa rozwiązania: x1 = 2* A 2* A skonale nadaje się do przećwiczenia działania instrukcji if…else. Jedyną niedogodnością skryptu będzie to, że parametry A, B i C będą musiały być wprowadzone bezpośrednio w jego kodzie, nie znamy bowiem jeszcze sposobu na przekazanie danych z przeglądarki (temat ten zostanie omówiony w lekcji 10. w rozdziale 3.). Skrypt wykonujący przedstawione zadania został zaprezentowany na listingu 2.27. Listing 2.27. Skrypt rozwiązujący równania kwadratowe "; echo "A = $A, B = $B, C = $C
"; //sprawdzenie, czy jest to równanie kwadratowe if ($A == 0){ //$A jest równe zero, równanie nie jest kwadratowe echo "To nie jest równanie kwadratowe: A = 0!"; } else{ //A jest różne od zera, równanie jest kwadratowe //obliczenie delty $delta = $B * $B - 4 * $A * $C; //jeśli delta mniejsza od zera if ($delta < 0){ echo "Delta < 0
";

19

Czytelnicy moich publikacji mogą odnieść wrażenie, że rozwiązywanie równań kwadratowych jest moim hobby. Zapewniam jednak, że to jedynie dobry przykład do ćwiczenia zagnieżdżonych instrukcji warunkowych.

Rozdział 2. ♦ Elementy języka

95

echo "To równanie nie ma rozwiązania w zbiorze liczb rzeczywistych!"; } //jeśli delta większa lub równa zero else{ //jeśli delta jest równa zero if ($delta == 0){ //obliczenie wyniku $wynik = - B / (2 * A); echo "Rozwiązanie: x = $wynik"; } //jeśli delta jest większa od zera else{ //obliczenie wyników $wynik = (- $B + sqrt($delta)) / (2 * $A); echo "Rozwiązanie: x1 = $wynik"; $wynik = (- $B - sqrt($delta)) / (2 * $A); echo ", x2 = $wynik"; } } } ?>

Zaczynamy od zadeklarowania i zainicjowania trzech zmiennych: A, B i C, które odzwierciedlają parametry równania, oraz wyświetlenia ich wartości na ekranie. Za pomocą instrukcji if sprawdzamy, czy zmienna A jest równa 0. Jeśli tak, oznacza to, że równanie nie jest kwadratowe, jest więc wyświetlana stosowna informacja i... jest to koniec działania skryptu. Jeśli jednak A jest różne od 0, można przystąpić do obliczenia delty. Wynik obliczeń przypisujemy zmiennej $delta. Kolejny krok to sprawdzenie, czy $delta nie jest mniejsza od 0. Jeśli jest, oznacza to, że równanie nie ma rozwiązań w zbiorze liczb rzeczywistych, wyświetlamy więc odpowiedni komunikat — po jego wyświetleniu skrypt kończy działanie. Kiedy jednak delta nie jest mniejsza od 0, przystępujemy do sprawdzenia kolejnych warunków. Jeśli jest równa 0, można od razu obliczyć rozwiązanie równania ze wzoru –B / 2 * A. Wynik tych obliczeń przypisujemy zmiennej pomocniczej $wynik i wyświetlamy komunikat z rozwiązaniem na ekranie. W przypadku, gdy delta jest większa od 0, istnieją dwa pierwiastki (rozwiązania) równania. Obliczamy je w liniach: $wynik = (- $B + sqrt($delta)) / (2 * $A);

oraz: $wynik = (- $B - sqrt($delta)) / (2 * $A);

Rezultat obliczeń wyświetlamy, rzecz jasna, na ekranie, tak jak jest to widoczne na rysunku 2.14. Nieznana nam instrukcja sqrt($delta) powoduje obliczenie pierwiastka kwadratowego (drugiego stopnia) z wartości zawartej w zmiennej $delta.

96

PHP5. Praktyczny kurs

Rysunek 2.14. Przykładowy wynik działania skryptu rozwiązującego równania kwadratowe

Złożone wyrażenia warunkowe Warunki, a dokładniej wyrażenia warunkowe, stosowane w instrukcji if mogą być bardziej złożone niż te dotychczas prezentowane. Mogą się składać z wielu członów połączonych operatorami logicznymi. Załóżmy, że mamy wykonać pewne czynności, np. wyświetlić napis, kiedy dana zmienna jest większa od 0, ale jednocześnie mniejsza od 10. Istnieją dwa sposoby realizacji tego zadania. Pierwszy to wykorzystanie zagnieżdżonej instrukcji if w postaci: if($liczba > 0){ if($liczba < 10){ echo("Liczba jest większa od 0 i mniejsza od 10."); } }

Drugi to wykorzystanie pojedynczej instrukcji if ze złożonym wyrażeniem warunkowym. Jak zbudować takie wyrażenie? Na takiej samej zasadzie jak na szkolnych lekcjach matematyki. Skoro interesuje nas sytuacja, kiedy liczba jest większa od 0 i mniejsza od 10, trzeba skorzystać z iloczynu logicznego, który w PHP jest wyrażany za pomocą operatora &&. A zatem wyrażenie warunkowe będzie miało postać: ($liczba > 0) && ($liczba < 10)

Cała instrukcja if będzie więc wyglądała następująco: if(($liczba > 0) && ($liczba < 10)){ echo("Liczba jest większa od 0 i mniejsza od 10."); }

Jeśli zajrzymy na chwilę do tablicy 2.16 przedstawiającej priorytety operatorów, przekonamy się, że operatory relacyjne > i < mają większy priorytet (są silniejsze) niż operator iloczynu logicznego &&. Wynika z tego, że można pominąć nawiasy w wyrażeniu warunkowym, które równie dobrze może mieć postać: $liczba > 0 && $liczba < 10

Jest to w pełni dopuszczalne, aczkolwiek nie zaleca się tego rozwiązania, gdyż zaciemnia kod i utrudnia jego analizę, szczególnie w przypadku bardziej złożonych wyrażeń. Wykonajmy jeszcze jeden przykład. Tym razem napis powinien zostać wyświetlony, gdy wartość zmiennej $liczba jest większa od 0, ale różna od 5 i różna od 10, lub też gdy jest równa –8. Możemy tu wyróżnić 4 wyrażenia składowe:

Rozdział 2. ♦ Elementy języka

97

 $liczba > 0,  $liczba != 5,  $liczba != 10,  $liczba == -8,

Należy je połączyć za pomocą operatorów logicznych, jak następuje: ($liczba > 0) && ($liczba != 5) && ($liczba != 10)) || ($liczba == -8)

Instrukcja if przyjmie zatem postać: if((($liczba > 0) && ($liczba != 5) && ($liczba != 10)) || ($liczba == -8)){ echo("Zmienna \$liczba spełnia wszystkie warunki."); }

Instrukcja wyboru Instrukcja wyboru switch (nazywana również instrukcją switch…case) pozwala w wygodny sposób sprawdzić ciąg warunków i wykonać różne instrukcje w zależności od wyników porównywania. Ma ona ogólną postać: switch(wyrażenie){ case wartość1 : instrukcje1; break; case wartość2 : instrukcje2; break; case wartość3 : instrukcje3; break; default : instrukcje4; }

Postać tę należy rozumieć następująco: sprawdź wartość wyrażenia wyrażenie. Jeśli wynikiem jest wartość1, to wykonaj intrukcje1 i przerwij wykonywanie bloku switch (instrukcja break). Jeśli wynikiem jest wartość2, to wykonaj intrukcje2 i przerwij wykonywanie bloku switch, jeśli jest wartość3, to wykonaj intrukcje3 i przerwij wykonywanie bloku switch. Jeśli nie zachodzi żaden z wymienionych przypadków, wykonaj instrukcje4 i zakończ blok switch. Blok default jest jednak opcjonalny i może zostać pominięty. Łatwo zauważyć, że jest to odpowiednik złożonej instrukcji if…else if w postaci: if(wyrażenie == wartość1){ instrukcje1; } else if(wyrażenie == wartość2){ instrukcje2; }

98

PHP5. Praktyczny kurs else if(wyrażenie == wartość3){ instrukcje3; } else{ instrukcje4; }

Zobaczmy jednak, jak wykorzystać instrukcję wyboru w praktyce. Przykład jest widoczny na listingu 2.28. Na początku została utworzona zmienna $liczba o wartości 10. Instrukcja switch najpierw oblicza wartość wyrażenia występującego w nawiasie okrągłym. Ponieważ w tym przypadku jako wyrażenie występuje nazwa zmiennej, wartością wyrażenia staje się jej wartość. Wartość ta jest porównywana do wartości występujących po słowach case, czyli 10 i 20. Jeśli zgodność zostanie stwierdzona, zostaną wykonane instrukcje występujące w danym bloku case. Jeśli nie uda się dopasować wartości wyrażenia do żadnej z wartości występujących po słowach case, jest wykonywany blok default. Ponieważ wartością wyrażenia jest 10, zgodność jest stwierdzana już w pierwszym przypadku, więc zostanie wykonana instrukcja echo wyświetlająca napis: Zmienna $liczba = 10. Występująca po echo instrukcja break przerywa wykonywanie bloku case. Listing 2.28. Wykorzystanie instrukcji wyboru

Na instrukcję break należy zwrócić szczególną uwagę. Jej przypadkowe pominięcie może doprowadzić do nieoczekiwanych wyników i błędów w skrypcie. Aby się przekonać, w jaki sposób działa instrukcja switch bez instrukcji break, zmodyfikujmy skrypt z listingu 2.28, usuwając z niego wszystkie instrukcje break. Powstanie wtedy kod widoczny na listingu 2.29. Listing 2.29. Kod po usunięciu instrukcji break
Rozdział 2. ♦ Elementy języka

99

default : echo "Zmienna \$liczba nie jest równa ani 10, ani 20."; } ?>

Gdy go uruchomimy, w przeglądarce zobaczymy widok zaprezentowany na rysunku 2.15. Skrypt wyraźnie nie spełnia swojego zadania. Zmienna nie może przecież jednocześnie spełniać trzech przeciwstawnych warunków. Jak więc działa przedstawiony kod? Otóż jeśli w którymś z bloków (przypadków) case zostanie wykryta zgodność z wyrażeniem występującym za switch, zostaną wykonane wszystkie dalsze instrukcje aż do napotkania instrukcji break lub dotarcia do końca instrukcji switch. W kodzie z listingu 2.29 zgodność jest stwierdzana już w pierwszym bloku case, jest więc wykonywana znajdująca się w nim instrukcja echo. Ponieważ jednak w bloku tym nie ma instrukcji break, są wykonywane instrukcje znajdujące się w kolejnym bloku case (case 20). W tym bloku również brakuje break, a zatem są wykonywane instrukcje znajdujące się po słowie default. Tym samym wykonane zostaną wszystkie znajdujące się w kodzie instrukcje echo. Rysunek 2.15. Ilustracja błędu polegającego na pominięciu niezbędnych instrukcji break

Operator warunkowy Operator warunkowy pozwala na ustalenie wartości wyrażenia w zależności od prawdziwości danego warunku. Ma on postać: warunek ? wartość1 : wartość2

Oznacza to: jeśli warunek jest prawdziwy, podstaw za wartość całego wyrażenia wartość1, w przeciwnym wypadku za wartość wyrażenia podstaw wartość2. Spójrzmy na kod z listingu 2.30 i zastanówmy się, jaka wartość zostanie wyświetlona w instrukcji echo. Innymi słowy, jaka będzie wartość zmiennej $wynik. Listing 2.30. Użycie operatora warunkowego

Najważniejsza jest tu oczywiście linia $wynik = ($liczba < 0) ? –1 : 1;. Po lewej stronie operatora przypisania = znajduje się zmienna ($wynik), natomiast po stronie

100

PHP5. Praktyczny kurs

prawej wyrażenie warunkowe, czyli linia ta oznacza: przypisz zmiennej $wynik wartość wyrażenia warunkowego. Jaka jest ta wartość? Trzeba przeanalizować samo wyrażenie: ($liczba < 0) ? –1 : 1. Zgodnie z tym, co zostało napisane wyżej, oznacza ono: jeżeli wartość zmiennej $liczba jest mniejsza od 0, przypisz wyrażeniu wartość –1, w przeciwnym razie (zmienna $liczba większa lub równa 0) przypisz wyrażeniu wartość 1. Ponieważ zmiennej $liczba przypisaliśmy wcześniej wartość 100, wartością całego wyrażenia będzie 1 i ta właśnie wartość zostanie przypisana zmiennej $wynik. W tym miejscu ponownie zajrzyjmy do tabeli 2.16. Z informacji tam podanych wynika, że operator warunkowy ma mniejszy priorytet niż operatory relacyjne. W związku z tym nawias okrągły, wprowadzony do wyrażenia w celu zwiększenia czytelności zapisu, może zostać pominięty i wyrażenie może mieć również postać: $liczba < 0 ? -1 : 1;

Pętle Pętlami nazywamy konstrukcje języka, które pozwalają na wielokrotne wykonywanie powtarzających się instrukcji. Przykładowo, jeśli chcemy 10 razy wyświetlić na ekranie napis, to możemy wykorzystać w tym celu 10 instrukcji echo "napis", jednak zdecydowanie lepiej i prościej użyć jednej z pętli. W PHP występują cztery rodzaje pętli:  typu for,  typu while,  typu do…while,  typu foreach.

Pętla for Pętla typu for ma ogólną postać: for(wyrażenie początkowe; wyrażenie warunkowe; wyrażenie modyfikujące){ instrukcje do wykonania }

wyrażenie początkowe jest stosowane do zainicjalizowania zmiennej używanej jako licznik liczby wykonań pętli. wyrażenie warunkowe określa warunek, jaki musi być spełniony, aby dokonać kolejnego przejścia w pętli, natomiast wyrażenie modyfikujące jest zwykle używane do modyfikacji zmiennej będącej licznikiem.

Nawias klamrowy może być pominięty, o ile w pętli ma się znaleźć tylko jedna instrukcja do wykonania (ta uwaga dotyczy również wszystkich pozostałych pętli). Wtedy taka instrukcja musi się kończyć znakiem średnika (patrz też opis instrukcji warunkowej if). Schematycznie wygląda to tak: for(wyrażenie początkowe; wyrażenie warunkowe; wyrażenie modyfikujące) instrukcja do wykonania;

Rozdział 2. ♦ Elementy języka

101

Całość może być też wtedy zapisana w jednym wierszu. W książce (w celu ujednolicenia zapisu) będzie jednak stosowany wyłącznie sposób z nawiasem klamrowym. Sposób działania pętli for najłatwiej pokazać na konkretnym przykładzie. Jest on widoczny na listingu 2.31. Listing 2.31. Sposób wykorzystania pętli typu for "; } ?>

Taką konstrukcję należy rozumieć następująco: utwórz zmienną $i i przypisz jej wartość 0 ($i = 0), następnie tak długo, dopóki wartość $i jest mniejsza od 10 ($i < 10), wykonuj instrukcje znajdujące się wewnątrz pętli (obie instrukcje echo) oraz zwiększaj $i o jeden ($i++). Tym samym na ekranie pojawi się 10 razy napis Pętla typu for (rysunek 2.16). Zmienna $i jest nazywana zmienną iteracyjną, czyli kontrolującą kolejne przebiegi (iteracje) pętli. Rysunek 2.16. Efekt wykorzystania pętli for do wielokrotnego wyświetlenia napisu

Jeśli chcemy zobaczyć, jak zmienia się stan zmiennej $i w trakcie kolejnych przebiegów, możemy zmodyfikować instrukcję wyświetlającą napis, tak aby podawała również i tę informację. Wystarczy niewielka zmiana w postaci: for($i = 0; $i < 10; $i++){ echo "Pętla typu for [i = $i]"; echo "
"; }

Po jej wprowadzeniu w każdej linii będzie wyświetlana również wartość $i, tak jak zostało to przedstawione na rysunku 2.17.

102

PHP5. Praktyczny kurs

Rysunek 2.17. Efekt działania pętli wyświetlającej stan zmiennej iteracyjnej

Pętla while Pętla typu while służy, podobnie jak for, do wykonywania powtarzających się czynności. Pętlę for wykorzystuje się najczęściej, gdy liczba powtarzanych operacji jest znana (np. jest zapisana w pewnej zmiennej), natomiast pętlę while, gdy liczby powtórzeń z góry nie znamy, a zakończenie pętli jest uzależnione od spełnienia pewnego warunku (np. zwrócenia konkretnej wartości przez pewną funkcję20). Taki podział jest jednak dosyć umowny, gdyż oba typy pętli można zapisać w taki sposób, aby były swoimi funkcjonalnymi odpowiednikami. Ogólna postać pętli while wygląda następująco: while (warunek){ instrukcje; }

Oznacza ona: dopóki warunek jest prawdziwy, wykonuj instrukcje. Wykorzystajmy więc pętlę while do wyświetlenia powtarzającego się napisu. Takie zadanie wykonuje skrypt widoczny na listingu 2.32. Listing 2.32. Sposób użycia pętli typu while "; $i++; } ?>

W tym przypadku instrukcje znajdujące się wewnątrz pętli wykonywane są tak długo, dopóki wartość zmiennej $i jest mniejsza od 10, warunkiem zakończenia pętli jest bowiem $i < 10. Ponieważ początkową wartością $i jest 0, a wewnątrz pętli znajduje się 20

Pojęcie funkcji zostanie omówione już w kolejnej lekcji.

Rozdział 2. ♦ Elementy języka

103

instrukcja zwiększająca w każdym jej przebiegu wartość $i o 1 ($i++), mamy pewność, że pętla się zakończy. W przypadku pętli while trzeba zwracać szczególną uwagę na warunek zakończenia, gdyż łatwo napisać pętlę wykonującą się w nieskończoność. Zmodyfikujmy teraz nasz przykład w taki sposób, aby modyfikacja zmiennej $i odbywała się w wyrażeniu warunkowym, a nie we wnętrzu pętli. Taka konstrukcja została zaprezentowana na listingu 2.33. Jak widać, nie było to bardzo skomplikowane zadanie. Zwróćmy jednak uwagę, że nie uzyskaliśmy w ten sposób w pełni funkcjonalnego odpowiednika kodu z listingu 2.32. Co prawda napis zostanie wyświetlony 10 razy, tak jak w poprzednim przypadku, ale wartość zmiennej wewnątrz pętli zmieniać się będzie od 1 do 10, a nie od 0 do 9! Gdyby zmienna $i była wykorzystywana do jakichś czynności, np. do indeksowania tablicy, byłaby to bardzo poważna zmiana. Takimi zagadnieniami zajmiemy się w dalszej części książki. Listing 2.33. Modyfikacja zmiennej iteracyjnej w wyrażeniu warunkowym "; } ?>

Pętla do...while Kolejny rodzaj pętli występującej w PHP to do...while. Jak łatwo się domyślić, jest ona blisko spokrewniona ze zwykłą pętlą while. Jej ogólna postać jest następująca: do{ instrukcje; } while(warunek);

Oznacza to: wykonuj instrukcje, dopóki warunek jest prawdziwy. A zatem, skoro wyświetlanie dziesięciu napisów szło nam do tej pory tak dobrze, zobaczmy, jak to zrobić za pomocą tego rodzaju pętli. Przykład jest widoczny na listingu 2.34. Listing 2.34. Przykład wykorzystania pętli do...while "; } while($i++ < 9); ?>

Główna różnica w stosunku do pętli while jest taka, że w tym przypadku najpierw są wykonywane instrukcje, a dopiero potem sprawdzany jest warunek. Wynika z tego, że

104

PHP5. Praktyczny kurs

instrukcje z wnętrza pętli while są wykonywane zawsze przynajmniej jeden raz, nawet jeśli warunek będzie fałszywy. Zwróćmy również uwagę, że w związku z odmienną konstrukcją pętli nieco inaczej wygląda wyrażenie warunkowe ($i++ < 9). Tym razem sprawdzamy, czy $i jest mniejsze od 9. Gdybyśmy pozostawili taki sam warunek jak w przypadku pętli while ($i++ < 10), instrukcje echo zostałyby wykonane 11 razy.

Pętla foreach Pętla foreach pozwala na dostęp do kolejnych elementów tablicy (tablice zostaną omówione w lekcji 9.; osoby, które nie znają tej struktury danych, powinny na razie pominąć tę sekcję i powrócić do niej później) lub właściwości obiektu (kwestie programowania obiektowego zostaną poruszone w rozdziale 5.). Może ona występować w dwóch postaciach: foreach($tablica as $wartość){ instrukcje; }

oraz foreach($tablica as $klucz => $wartość){ instrukcje; }

Różnica pomiędzy obiema postaciami jest taka, że w drugim przypadku otrzymujemy dodatkowo wartość aktualnego klucza. Jeśli te wartości nie są potrzebne, można skorzystać z pierwszej formy pętli. Na listingu 2.35 pokazano, jak ją zastosować. Listing 2.35. Zastosowanie pierwszej wersji pętli foreach 'jeden', 2 => 'dwa', 'trzy' => 3, 'cztery' => 4 ); foreach($tab as $v){ echo "$v
"; } ?>

Tablica $tab zawiera cztery komórki o indeksach (kluczach) 1, 2, trzy oraz cztery, w których zapisane są ciągi znaków oraz wartości liczbowe. Wewnątrz pętli pod zmienną $v są podstawiane wartości kolejnych komórek, stąd na ekranie pojawią się wartości: jeden, dwa, 3, 4, tak jak jest to widoczne na rysunku 2.18. Jeśli chcemy uzyskać dodatkowo nazwy indeksów, musimy skorzystać z drugiej z przedstawionych konstrukcji. Jak to zrobić, pokazano w skrypcie widocznym na listingu 2.36. Wynik jego działania został natomiast zaprezentowany na rysunku 2.19. Tym razem w każdym przebiegu pętli pod zmienną $key jest podstawiana nazwa aktualnego klucza, natomiast pod zmienną $v — jego wartość.

Rozdział 2. ♦ Elementy języka

105

Rysunek 2.18. Efekt działania skryptu z listingu 2.35

Listing 2.36. Wykorzystanie drugiej wersji pętli foreach 'jeden', 2 => 'dwa', 'trzy' => 3, 'cztery' => 4 ); foreach($tab as $key => $v){ echo "tab[$key] = $v
"; }; ?>

Rysunek 2.19. Efekt działania pętli uwzględniającej nazwy kluczy

Instrukcje break i continue Instrukcje break i continue pozwalają na modyfikacje zachowań pętli i można je stosować z każdym ich rodzajem, niezależnie od tego, czy będzie to for, while, do…while czy foreach. Jak pamiętamy, break jest również stosowana w przypadku instrukcji wyboru switch. Pozwala ona również na uzyskanie ciekawych wersji pętli for, czym zajmiemy się już niedługo.

Instrukcja break Instrukcja break powoduje przerwanie działania pętli (w języku angielskim break znaczy właśnie przerywać). Przykład zastosowania tej instrukcji został zaprezentowany na listingu 2.37. W kodzie została umieszczona specyficzna pętla while, która powoduje (jakżeby inaczej) wyświetlenie dziesięciu napisów. Zwróćmy jednak uwagę na warunek pętli — jest to true, a zatem jest on zawsze prawdziwy. Oczywiście taka pętla wykonywałaby się w nieskończoność, gdyby nie znajdująca się wewnątrz instrukcja break.

106

PHP5. Praktyczny kurs

Z kolei warunkiem wykonania instrukcji break jest $i >= 9, czyli przerwanie pętli następuje wtedy, gdy zmienna $i osiągnie wartość 9. Ponieważ $i jest zwiększane o jeden w każdym przebiegu pętli ($i++), a jego początkowa wartość to 0, mamy pewność, że pętla zostanie wykonana 10 razy, po czym będzie przerwana. Listing 2.37. Wykorzystanie instrukcji break do przerwania pętli "; if($i >= 9) break; $i++; } ?>

Kolejna rzecz warta uwagi to sama postać warunku, w którym występuje operator relacyjny >=. Instrukcja break faktycznie jest więc wykonywana, gdy $i będzie równe lub większe od 9. Dlaczego jednak nie użyliśmy zwykłego operatora ==? Wszak instrukcja warunkowa w postaci: if($i == 9) break;

też byłaby prawidłowa. Odpowiedź w pierwszej chwili zapewne wyda się dziwna. Brzmi ona: na wszelki wypadek. I jest to jak najbardziej poważna odpowiedź. Oczywiście w przypadku kodu z listingu 2.37 wartość $i nigdy nie przekroczy 9, a zatem nigdy też nie będzie prawdziwy warunek $i > 9. W praktyce programistycznej warto jednak brać pod uwagę warunki, które podczas pisania kodu wydają nam się niemożliwe do spełnienia. Sprawdzi się to, gdy będziemy tworzyć dużo bardziej skomplikowane kody. Nawet jednak na tym prostym przykładzie można pokazać, że lepiej było zastosować warunek >= niż ==. Wyobraźmy sobie bowiem, że pierwotnie napisaliśmy kod: "; if($i == 9) break; $i++; } ?>

Po pewnym czasie jednak dokonaliśmy pewnej drobnej modyfikacji. Otóż w każdym przebiegu zaczęliśmy zwiększać zmienną $i nie o jeden, ale o dwa, nie korygując jednocześnie (nawet przez zwykłe zapomnienie) warunku zakończenia pętli. Powstał więc kod widoczny na listingu 2.38. Co się stało? Otóż to, czego koniecznie musimy unikać. Powstała pętla nieskończona. I będzie ona wykonywana tak długo, aż czas wykonania skryptu przekroczy wartość maksymalną zdefiniowaną w opcjach konfiguracyjnych i PHP nie przerwie jego działania (lub też serwer WWW nie przerwie działania skryptu). Dodatkowo taki skrypt zajmie mnóstwo zasobów systemowych, a użytkownik na pewno nie będzie zadowolony, gdy w przeglądarce zobaczy tysiące napisów. Użycie operatora >= zapobiegłoby powstaniu takiego problemu. Skrypt być może nie działałby wtedy (po wstawieniu instrukcji $i = $i + 2;) w pełni zgodnie z założenia-

Rozdział 2. ♦ Elementy języka

107

mi, gdyż zapewne wymagałby również odpowiedniej zmiany warunku, jednak nie doprowadzilibyśmy do tak poważnej awarii jak w prezentowanym przypadku. Listing 2.38. Nieprawidłowy warunek zakończenia pętli "; if($i == 9) break; $i = $i + 2; } ?>

Instrukcja continue O ile instrukcja break powodowała przerwanie wykonywania pętli oraz jej opuszczenie, o tyle continue powoduje przejście do jej kolejnej iteracji. Jeśli zatem wewnątrz pętli znajdzie się instrukcja continue, bieżąca iteracja (przebieg) zostanie przerwana oraz rozpocznie się kolejna (chyba że bieżąca była ostatnią). Zobaczmy na konkretnym przykładzie, jak to działa. Na listingu 2.39 jest widoczna pętla for, która wyświetla liczby całkowite z zakresu 1 – 20 podzielne przez 2. Listing 2.39. Pętla for wyświetlająca liczby podzielne przez dwa

Pętla jest skonstruowana w dobrze nam już znany sposób. W środku znajduje się jednak instrukcja warunkowa sprawdzająca warunek $i % 2 != 0, czyli badająca, czy reszta z dzielenia $i przez 2 jest równa 0. Jeśli ten warunek jest fałszywy (reszta jest różna od 0), oznacza to, że wartość zapisana w $i nie jest podzielna przez 2, jest zatem wykonywana instrukcja continue. Jak już wiemy, powoduje ona rozpoczęcie kolejnej iteracji pętli, czyli zwiększenie wartości zmiennej $i o jeden i przejście na początek pętli (do pierwszej instrukcji). Tym samym, jeśli wartość $i jest niepodzielna przez dwa, wówczas znajdująca się za warunkiem instrukcja echo($i) nie zostanie wykonana, dana wartość nie pojawi się więc na ekranie, a to właśnie było naszym celem. Rzecz jasna, zadanie to można wykonać bez użycia instrukcji continue (patrz ćwiczenia na końcu lekcji), ale bardzo dobrze ilustruje ono istotę jej działania. Efekt działania skryptu został zaprezentowany na rysunku 2.20. Rysunek 2.20. Wynik działania pętli wyświetlającej parzyste liczby z zakresu 1 – 20

108

PHP5. Praktyczny kurs

Różne warianty pętli for Składnikiem pętli for są trzy wyrażenia: początkowe, warunkowe i modyfikujące. Okazuje się jednak, że można je umieszczać w dość dowolnych miejscach, a w przypadku ekstremalnym z nawiasu okrągłego znajdującego się za słowem for można wyrzucić wszystkie trzy wyrażenia. Są to raczej ciekawostki rzadko stosowane w praktyce, warto jednak wiedzieć, jak elastyczny jest język PHP21. Napiszemy zatem kilka skryptów wykorzystujących różne wersje pętli for, których zadaniem będzie wyświetlanie kolejnych liczb od 0 do 9. Na początek spróbujmy więc pozbyć się wyrażenia początkowego. Taka konstrukcja jest widoczna na listingu 2.40. Listing 2.40. Pętla for bez wyrażenia początkowego "; } ?>

Jak widać, nie było to trudne zadanie. Wyrażenie początkowe inicjalizujące zmienną $i zostało usunięte z pętli i przeniesione przed nią. Tym samym stan zmiennej iteracyjnej jest ustalany jeszcze przed rozpoczęciem pętli. Zwróćmy uwagę, że w nawiasie okrągłym pętli wciąż są obecne dwa znaki średnika. Oba te znaki muszą występować zawsze, nawet wtedy gdy (jak przekonamy się już niedługo) usunięte zostaną wszystkie wyrażenia. Na listingu 2.41 widoczny jest kolejny przykład. Tym razem zostało usunięte wyrażenie początkowe oraz modyfikujące. Pierwsze z nich zostało przesunięte poza pętlę, natomiast drugie do jej wnętrza, modyfikacja zmiennej iteracyjnej jest bowiem niezbędna, gdyż inaczej pętla byłaby nieskończona. Listing 2.41. Usunięcie wyrażenia początkowego i modyfikującego "; $i++; } ?>

Kolejny przykład pokazuje, w jaki sposób można połączyć wyrażenie warunkowe z modyfikującym. Jest on widoczny na listingu 2.42. Jak widać, takie połączenie jest możliwe dzięki zastosowaniu operatora inkrementacji ++. W tym przypadku musimy zwrócić uwagę na początkowy stan zmiennej $i. Jest ona inicjowana wartością –1. Dlaczego? Otóż w momencie, gdy jej stan jest zwiększany już w wyrażeniu modyfikują21

Jak również inne języki programowania oparte na podobnej koncepcji składni. Takie same efekty można też osiągnąć w C, C++, JavaScripcie, Javie itp.

Rozdział 2. ♦ Elementy języka

109

cym, czynność ta jest wykonywana jeszcze przed wejściem do pętli (wykonaniem instrukcji wewnątrz pętli). Skoro więc mamy wyświetlić wartości od 0 do 9, wartością początkową musi być –1. Listing 2.42. Wyrażenie warunkowe będące jednocześnie wyrażeniem modyfikującym "; } ?>

W ostatnim przykładzie tej części lekcji zostanie pokazane, w jaki sposób usunąć wszystkie wyrażenia z nawiasów okrągłych pętli for. Jest on widoczny na listingu 2.43. Okazuje się, że nawet taka dziwna pętla jest możliwa. Widać, że wyrażenie początkowe zostało przesunięte przed pętlę, natomiast warunkowe i modyfikujące do jej wnętrza. Niezbędne było również użycie instrukcji break. Zwróćmy także uwagę, jak w tym wypadku wygląda sam warunek ($i++ >= 9). Można powiedzieć, że w stosunku do poprzednich przykładów jest on odwrócony. Badamy, kiedy $i jest mniejsze bądź równe 9. Dzieje się tak, ponieważ wcześniej badaliśmy warunek kontynuacji pętli, a tym razem badamy warunek jej zakończenia (przerwania). Instrukcja: if($i++ >= 9) break;

oznacza bowiem: przerwij pętlę, kiedy $i jest równe 9 lub większe. Listing 2.43. Pętla for z usuniętymi wszystkimi wyrażeniami "; if($i++ >= 9) break; } ?>

Nazewnictwo zmiennych iteracyjnych Nazwy zmiennych iteracyjnych z formalnego punktu widzenia mogą być dowolne, o ile tylko spełniają ogólne zasady nazewnictwa tych konstrukcji programistycznych. Niemniej zwyczajowo przyjmuje się, że są one jednoliterowe i zaczynają się od litery i. Kolejne litery (j, k itd.) alfabetu są natomiast wykorzystywane w sytuacji, gdy pojawiają się pętle zagnieżdżone, którymi zajmiemy się w następnym punkcie.

Zagnieżdżanie pętli Wewnątrz każdej pętli można umieścić dowolne instrukcje, a więc i kolejną pętlę. Mogą więc one być zagnieżdżane. Najczęściej zagnieżdżane są pętle for. Taka konstrukcja ma następującą postać:

110

PHP5. Praktyczny kurs for(wyrażenie początkowe 1; wyrażenie warunkowe 1; wyrażenie modyfikujące 1){ for(wyrażenie początkowe 2; wyrażenie warunkowe 2; wyrażenie modyfikujące 2){ instrukcje do wykonania } }

W takiej sytuacji w każdym przebiegu pętli zewnętrznej są wykonywane wszystkie przebiegi pętli wewnętrznej. Zobaczmy to na przykładzie, który został przedstawiony na listingu 2.44, a którego efekt działania zobrazowano na rysunku 2.21. W pętli zewnętrznej zmienną iteracyjną jest $i, natomiast w wewnętrznej — $j. W pętli wewnętrznej znajduje się instrukcja echo("$i $j");, która wyświetla aktualny stan tych zmiennych. W pierwszej iteracji zewnętrznej $i jest stała i równa 0, a $j zmienia się od 0 do 2. W drugiej iteracji zewnętrznej $i jest stała i równa 1, a $j zmienia się od 0 do 2. Natomiast w trzeciej iteracji zewnętrznej $i jest stała i równa 2, a $j zmienia się od 0 do 2. Tym samym na rysunku 2.21 pierwsza kolumna obrazuje kolejne stany zmiennej $i, a druga kolumna — $j. Listing 2.44. Zagnieżdżanie pętli for "; } echo "----"; echo "
"; } ?>

Rysunek 2.21. Efekt działania zagnieżdżonych pętli for

W podobny sposób można zagnieżdżać pętle while (jak i do…while), choć tego typu konstrukcje są rzadziej spotykane. Istnieje również możliwość mieszania typów zagnieżdżonych pętli, tzn. w pętli while może być zagnieżdżona pętla for i odwrotnie — w pętli for może być zagnieżdżona pętla while (do…while).

Rozdział 2. ♦ Elementy języka

111

Składnia alternatywna Zarówno pętle, jak i instrukcje warunkowe mogą w PHP mieć postać klasyczną, taką jak przedstawiona w poprzednich akapitach, i alternatywną, zwaną składnią alternatywną. Postać ta schematycznie wygląda następująco: instrukcja(wyrażenie): blok instrukcji; endinstrukcja;

Zobaczmy, jak stosować ten typ składni w przypadku konkretnych instrukcji. (Ze względu na wyraźne wyróżnienie tego, gdzie i jaka instrukcja się kończy, ten często niedoceniany sposób zapisu jest wygodny, gdy w kodzie strony wielokrotnie przeplatane są instrukcje HTML i PHP. Zwiększa to czytelność kodu).

Instrukcje warunkowe Instrukcja if Jeśli mamy zwykłą instrukcję if w przykładowej, klasycznej postaci: if($a < $b){ echo "a jest mniejsze od b."; }

możemy ją zapisać z zastosowaniem składni alternatywnej, która będzie miała postać: if($a < $b): echo "a jest mniejsze od b."; endif;

Instrukcja if...else W przypadku instrukcji if…else składnia alternatywna wygląda podobnie jak w poprzednim przypadku. Jeśli instrukcja ma postać: if($a < $b){ echo "a jest mniejsze od b."; } else{ echo "a nie jest mniejsze od b."; }

możemy ją przetworzyć i zapisać jako: if($a < $b): echo "a jest mniejsze od b."; else: echo "a nie jest mniejsze od b."; endif;

Instrukcja if...else if W przypadku instrukcji if…else if postępowanie jest analogiczne jak w poprzednich przykładach. Instrukcję w postaci:

112

PHP5. Praktyczny kurs if($a < $b){ echo "a jest mniejsze od b."; } else if($a > $b){ echo "a jest większe od b."; } else{ echo "a jest równe b."; }

możemy zapisać jako: if($a < $b): echo "a jest mniejsze od b."; elseif($a > $b): echo "a jest większe od b."; else: echo "a jest równe b."; endif;

Należy zwrócić uwagę, że w tym przypadku elseif musi być zapisane jako jedno słowo.

Pętle Pętla for Jeśli mamy zwykłą pętlę typu for w przykładowej postaci: for($i = 0; $i < 10; $i++){ echo "$i
"; }

możemy ją zapisać z zastosowaniem składni alternatywnej jako: for($i = 0; $i < 10; $i++): echo "$i
"; endfor;

Pętla foreach W przypadku pętli foreach składnia alternatywna wygląda analogicznie jak w przypadku pętli typu for. Pętlę w postaci klasycznej: foreach($tab as $key => $v){ echo "tab[$key] = $v
"; };

można również zapisać jako: foreach($tab as $key => $v): echo "tab[$key] = $v
"; endforeach;

Pętla while Składnia alternatywna dla pętli for również nie jest skomplikowana. Przykładową pętlę:

Rozdział 2. ♦ Elementy języka

113

while($i < 10){ echo "$i
"; $i++; }

można przedstawić w postaci: while($i < 10): echo "$i
"; $i++; endwhile;

Ćwiczenia do samodzielnego wykonania Ćwiczenie 5.1. Zmodyfikuj skrypt z listingu 2.27 (pierwiastki) w taki sposób, aby wykorzystywana była instrukcja if…else if. Ćwiczenie 5.2. Na podstawie kodu z listingu 2.28 napisz skrypt, który zawiera instrukcję wyboru switch i rozpoznaje dwie sytuacje — gdy zmienna $liczba jest równa 10 lub 20 oraz gdy jest różna od 10 i od 20. Ćwiczenie 5.3. Zmodyfikuj kod z listingu 2.33 w taki sposób, aby modyfikacja zmiennej $i odbywała się w wyrażeniu warunkowym pętli, ale aby to był funkcjonalny odpowiednik kodu z listingu 2.32. Czyli wartość zmiennej $i wewnątrz pętli ma się zmieniać od 0 do 9. Ćwiczenie 5.4. Napisz skrypt pokazujący, że pętla do…while jest wykonywana przynajmniej jeden raz — nawet wtedy, gdy warunek jej zakończenia jest prawdziwy. Ćwiczenie 5.5. Zmodyfikuj kod skryptu z listingu 2.37 w taki sposób, aby instrukcja warunkowa była pierwszą w pętli, modyfikacja zmiennej $i odbywała się w wyrażeniu warunkowym instrukcji if, ale jednocześnie efekty działania kodu byłyby zgodne z pierwowzorem. Ćwiczenie 5.6. Zmień kod z listingu 2.39 tak, aby nie zmienił się sposób działania skryptu (mają być wyświetlane liczby z zakresu 1 – 20 podzielne przez dwa), ale nie było konieczności używania instrukcji continue. Ćwiczenie 5.7. Napisz pętlę for wyświetlającą liczby od 30 do 0 (w porządku malejącym) podzielne przez 3. Ćwiczenie 5.8. Napisz skrypt wyświetlający dwie sąsiadujące kolumny liczb. Pierwsza kolumna ma zawierać wartości od 1 do 10, a druga od 10 do 1. Użyj pojedynczej pętli for i tylko jednej zmiennej.

114

PHP5. Praktyczny kurs

Lekcja 6. Funkcje Definiowanie funkcji Funkcje są to wydzielone bloki kodu przeznaczone do wykonywania konkretnych zadań. Dzięki nim unikniemy wielokrotnego powtarzania w skrypcie tych samych instrukcji, a kod stanie się krótszy i bardziej czytelny. Przykładowo, jeżeli w skrypcie kilkakrotnie trzeba policzyć np. pierwiastki równania kwadratowego, to nie ma sensu umieszczania w każdym takim miejscu wszystkich instrukcji ze znanego nam już listingu 2.27. Lepiej utworzyć funkcję zajmującą się tym problemem i korzystać z niej, kiedy tylko zajdzie taka potrzeba. W celu utworzenia funkcji należy użyć słowa kluczowego function. Taka konstrukcja ma schematyczną postać: function nazwa_funkcji() { //instrukcje wnętrza funkcji }

Przy nazywaniu funkcji obowiązują podobne zasady jak przy zmiennych. Nazwa może się składać z liter, cyfr oraz znaków podkreślenia, nie może się jednak zaczynać od cyfry. Aby wykonać instrukcje znajdujące się wewnątrz funkcji (pomiędzy znakami nawiasu klamrowego), należy ją wywołać. Wywołanie polega na umieszczeniu w kodzie skryptu nazwy funkcji wraz z występującym po niej nawiasem okrągłym. Zobaczmy, jak tego typu konstrukcja będzie działała w praktyce. Prosty przykład jest widoczny na listingu 2.45. Listing 2.45. Ilustracja wywołania prostej funkcji

W skrypcie najpierw została zdefiniowana funkcja o nazwie func, a następnie została ona wywołana przez podanie jej nazwy zakończonej nawiasami okrągłymi. Wewnątrz funkcji (stosuje się też termin w ciele funkcji) umieszczona jest instrukcja echo. Ponieważ wywołanie funkcji jest równoznaczne z wykonaniem znajdujących się w niej instrukcji, w przeglądarce zobaczymy napis, taki jak ten widoczny na rysunku 2.22.

Rozdział 2. ♦ Elementy języka

115

Rysunek 2.22. Efekt wywołania funkcji ze skryptu 2.45

Argumenty funkcji Funkcjom można przekazywać argumenty, czyli wartości (dane), które mogą wpływać na ich zachowanie lub też być przez nie przetwarzane. Listę argumentów należy umieścić w nawiasie okrągłym za nazwą funkcji, oddzielając je od siebie przecinkami. A zatem taka konstrukcja ma schematyczną postać: function nazwa_funkcji(argument1, argument2, ... , argumentN) { //instrukcje wnętrza funkcji }

Napiszmy zatem funkcję, której zadaniem będzie wyświetlenie wartości przekazanego jej argumentu, i wywołajmy ją w kodzie skryptu. Działający w taki sposób kod został zaprezentowany na listingu 2.46. Listing 2.46. Funkcja wyświetlająca wartość przekazanego jej argumentu "; wyswietl (256); echo "
"; wyswietl (3.14); ?>

Powstała tu funkcja wyswietl, która przyjmuje jeden argument o nazwie $arg1. Wewnątrz funkcji można odczytać wartość tego argumentu, odwołując się do jego nazwy. Tym samym instrukcja echo($arg1) powoduje wyświetlenie tej wartości na ekranie. Warto wspomnieć, że w ten sposób można przekazać argument dowolnego typu, typ nie jest bowiem z góry określony. W dalszym kodzie skryptu funkcja wyswietl została wywołana trzykrotnie, za każdym razem z innym argumentem. W pierwszym przypadku był to ciąg znaków, w drugim — liczba całkowita, a w trzecim — liczba rzeczywista. Po uruchomieniu kodu w przeglądarce zobaczymy zatem taki widok jak na rysunku 2.23.

116

PHP5. Praktyczny kurs

Rysunek 2.23. Działanie funkcji wyswietl z różnymi argumentami

Funkcja może również przyjmować więcej argumentów niż jeden i wykonywać na nich operacje. Na listingu 2.47 został zaprezentowany skrypt zawierający funkcję o nazwie dodaj, która przyjmuje dwa argumenty — $wart1 i $wart2, a jej zadaniem jest wyświetlenie wyniku ich dodawania. W dalszej części skryptu została ona wywołana z argumentami 10 i 20, a zatem wynik działania skryptu będzie taki, jak zaprezentowany na rysunku 2.24. Listing 2.47. Funkcja dodająca dwie wartości

Rysunek 2.24. Wynik wywołania funkcji dodaj z argumentami 10 i 20

Warto tu ponownie zwrócić uwagę na sposób przetwarzania zmiennych. W pierwszej instrukcji echo występuje ciąg znaków ujęty w cudzysłów. W tym ciągu znajduje się zapis $wart1 + $wart2, ale wiadomo, że w takim przypadku zmienne są zamieniane na ich wartości, a więc wynikiem będzie ciąg 10 + 20 (zmienna $wart ma bowiem wartość 10, a zmienna $wart2 — 20). Nie jest oczywiście wykonywane dodawanie. Inaczej jest w drugiej instrukcji echo. Zapis echo $wart1 + $wart2; oznacza, że najpierw zostanie wykonana arytmetyczna operacja dodawania wartości zmiennych $wart1 i $wart2, a następnie wynik tego działania zostanie przekazany instrukcji echo, czyli wyświetlony na ekranie (wysłany do przeglądarki). Dlatego właśnie ostateczny napis wygląda tak jak na rysunku 2.24.

Rozdział 2. ♦ Elementy języka

117

Zwracanie wartości przez funkcje Przyjmowanie argumentów to nie jedyna cecha funkcji — mogą one również zwracać różne wartości. Czynność ta jest wykonywana za pomocą instrukcji return. Jeśli wystąpi ona wewnątrz funkcji, ta jest przerywana i zwraca wartość występującą po return. Schematycznie tego typu konstrukcja wygląda następująco: function nazwa_funkcji(argumenty) { //instrukcje wnętrza funkcji return wartość; }

Jeśli wywołamy tego typu funkcję, to w miejscu jej wywołania zostanie wstawiona zwrócona przez nią wartość, która będzie mogła być wykorzystana w dalszej części skryptu. Warto też wiedzieć, że użycie samej instrukcji return bez żadnych argumentów również powoduje przerwanie działania funkcji. Żeby zobaczyć, jak opisana technika działa w praktyce, napiszemy funkcję, której zadanie będzie podobne jak w przypadku skryptu z listingu 2.47. Będzie ona przyjmowała dwa argumenty i dodawała je do siebie. Różnica będzie taka, że tym razem wynik dodawania będzie przez funkcję zwracany do miejsca wywołania. Kod działający w taki sposób został zaprezentowany na listingu 2.48. Listing 2.48. Funkcja dodająca argumenty i zwracająca wynik działania

Funkcja dodaj przyjmuje argumenty $wart1 i $wart2. W jej wnętrzu są one dodawane za pomocą arytmetycznego operatora +, a wynik tego działania jest przypisywany zmiennej pomocniczej $wynik. Wartość tej zmiennej jest z kolei zwracana za pomocą instrukcji return. W dalszej części kodu funkcja dodaj jest wywoływana z argumentami 10 i 20, a wynik jej działania (czyli zwrócona przez nią wartość) jest przypisywany zmiennej $wartosc, która jest następnie używana w instrukcji echo do wyświetlania rezultatu na ekranie. Instrukcja $wartosc = dodaj (10, 20);

działa następująco:

118

PHP5. Praktyczny kurs  Najpierw jest wywoływana funkcja dodaj, a zatem są wykonywane

jej instrukcje.  Następnie wynik działania funkcji dodaj jest podstawiany w miejscu jej wywołania. Ponieważ w tym przypadku jest to 30, instrukcja jest traktowana jako $wartosc = 30;.  Zmiennej $wartosc jest przypisywana wartość zwrócona przez funkcję.

Przekonajmy się jeszcze, że wykonanie instrukcji return bez argumentu również jest możliwe i powoduje przerwanie działania funkcji. Zilustrowano to w skrypcie widocznym na listingu 2.49. Zdefiniowana została funkcja func zawierająca dwie instrukcje echo, pomiędzy którymi występuje instrukcja return. Zgodnie z tym, co zostało napisane wyżej, po wywołaniu funkcji func druga instrukcja echo nie zostanie wykonana, o czym można się przekonać, uruchamiając kod. Listing 2.49. Ilustracja działania pustej instrukcji return

Zasięg zmiennych Zmienne globalne Lekcja dotycząca funkcji to dobra okazja do omówienia tematu zasięgu zmiennych (używa się również terminu widoczność zmiennych). Zasięg możemy określić jako miejsca, w których zmienna jest ważna i można się do niej bezpośrednio odwoływać. W dotychczas prezentowanych przykładach większość zmiennych miała tzw. zasięg globalny, czyli można było z nich bezpośrednio korzystać w każdym miejscu skryptu z wyjątkiem wnętrz funkcji22. O tym, że tak jest w istocie, przekona nas skrypt widoczny na listingu 2.50. Listing 2.50. Ilustracja zachowania zmiennych globalnych
Jest to zachowanie charakterystyczne dla PHP. W większości popularnych języków programowania do zmiennych globalnych można się odwoływać bez używania specjalnych konstrukcji również we wnętrzach funkcji.

Rozdział 2. ♦ Elementy języka

119

{ echo("Wartość zmiennej \$liczba w funkcji func to $liczba.
"); } func(); echo("Wartość zmiennej \$liczba poza funkcją func to $liczba.
"); ?>

Efekt działania tego skryptu został zaprezentowany na rysunku 2.2523. Skąd taki wynik? Otóż zmienna $liczba ma zasięg globalny — została zdefiniowana poza funkcją func. W związku z tym funkcja ta nie ma do niej bezpośredniego dostępu i próba odwołania nie może zakończyć się sukcesem. Stąd wyświetlenie ostrzeżenia i brak wartości zmiennej w napisie będącym wynikiem działania pierwszej instrukcji echo. Druga instrukcja echo, która znajduje się poza funkcją, ma pełny dostęp do zmiennej $liczba, dlatego też działa prawidłowo.

Rysunek 2.25. Efekt odwołania do zmiennej globalnej wewnątrz funkcji

Jeśli jednak musimy odwołać się do zmiennej globalnej wewnątrz funkcji, mamy taką możliwość. Wymaga ona jednak skorzystania z dodatkowych konstrukcji programistycznych i można to zrobić na dwa sposoby. Pierwszy z nich to odwołanie się do superglobalnej (z ang. superglobal) tablicy $GLOBAL (pojęcie tablicy zostanie dokładniej omówione w lekcji 9., natomiast temat zmiennych superglobalnych — w rozdziale 3.). Zawiera ona odwołania do wszystkich zdefiniowanych w skrypcie zmiennych o zasięgu globalnym. Nazwy tych zmiennych są indeksami tej tablicy. Schematyczne odwołanie będzie miało więc postać: $GLOBALS['nazwa_zmiennej']

Jeśli zatem chcemy poprawić skrypt z listingu 2.50 w taki sposób, aby w funkcji func można było odczytać wartość zmiennej $liczba, możemy to zrobić w sposób widoczny na listingu 2.51.

23

Pojawianie się informacji o niezdefiniowanej zmiennej (undefined variable) jest uzależnione od tego, czy konfiguracja środowiska PHP umożliwia ich wyświetlanie. Domyślnie wyświetlanie błędów zazwyczaj jest włączone. Opcje związane z obsługą komunikatów o błędach znajdują się w sekcji Error handling and logging pliku php.ini.

120

PHP5. Praktyczny kurs

Listing 2.51. Użycie tablicy $GLOBALS "; } func(); echo "Wartość zmiennej \$liczba poza funkcją func to $liczba.
"; ?>

Jak widać, w fukcji func wartość odczytana z tablicy $GLOBALS została bezpośrednio przekazana instrukcji echo. Po uruchomieniu skryptu zobaczymy zatem widok taki jak na rysunku 2.26. Tym razem wartość została prawidłowo wyświetlona w obu przypadkach. Należy zwrócić uwagę, że w drugiej instrukcji echo dwukrotnie występuje ciąg $liczba. W pierwszym przypadku ma jednak zostać wyświetlona nazwa zmiennej, a więc PHP NIE powinien interpretować zapisu, dlatego ciąg poprzedzony jest znakiem lewego ukośnika \. Jak wiadomo, w ten sposób powstała sekwencja specjalna \$ (por. tabela 2.1), dzięki której na ekran wyprowadzany jest znak $ (a po nim ciąg liczba). W drugim przypadku ciąg $liczba występuje bez żadnych dodatkowych znaków, a zatem (ponieważ całość jest ujęta w cudzysłów) PHP dokona interpretacji i w miejscu nazwy zmiennej wstawi jej wartość. Rysunek 2.26. Odwołanie wykorzystujące tablice $GLOBALS

Drugi sposób odwołania się do zmiennej globalnej wewnątrz funkcji wymaga użycia słowa kluczowego global. Przed odwołaniem należy użyć konstrukcji w postaci: global $nazwa_zmiennej;

Można też w jednym wierszu zarejestrować więcej zmiennych, wtedy ich nazwy należy oddzielić przecinkami: global $nazwa_zmiennej_1, $nazwa_zmiennej_2, $nazwa_zmiennej_3;

W kodzie widocznym na listingu 2.52 zilustrowano, w jaki sposób można użyć tego sposobu odwoływania.

Rozdział 2. ♦ Elementy języka

121

Listing 2.52. Użycie słowa kluczowego global "; } func(); echo "Wartość zmiennej \$liczba poza funkcją func to $liczba.
"; ?>

Zmienne lokalne Oprócz zmiennych globalnych istnieją także zmienne lokalne funkcji. Jak sama nazwa wskazuje, ich zasięg jest ograniczony jedynie do wnętrza funkcji, w której zostały zdefiniowane. Próba odwołania w innym miejscu nie będzie możliwa. Taka sytuacja została stworzona w kodzie widocznym na listingu 2.53. Została w nim zdefiniowana funkcja func, a w niej zmienna o nazwie $liczba. Poza funkcją nastąpiła próba odwołania do tej zmiennej. Takiej zmiennej nie ma jednak poza funkcją func. W efekcie w drugim napisie nie pojawiła się wartość, został natomiast wyświetlony dodatkowy komunikat (o ile wyświetlanie komunikatów nie zostało wyłączone w opcjach konfiguracyjnych PHP). Jest to widoczne na rysunku 2.27. Listing 2.53. Skrypt odwołujący się w nieprawidłowy sposób do zmiennej lokalnej ".; } func(); echo "Wartość zmiennej \$liczba poza funkcją func to $liczba.
".; ?>

Zmienne statyczne Nazwa zmienna statyczna może brzmieć nieco dziwnie, chodzi jednak o takie zmienne lokalne funkcji, które zachowują swoją wartość pomiędzy wywołaniami funkcji. Zwykła zmienna lokalna jest widoczna tylko w obrębie funkcji i jest tworzona tylko w momencie wywołania tej funkcji. Gdy funkcja zakończy działanie, zmienna znika. Co więcej, aby utworzyć zmienną, trzeba jej przypisać wartość początkową. Zatem

122

PHP5. Praktyczny kurs

Rysunek 2.27. Efekt odwołania się do zmiennej lokalnej poza funkcją, w której została ona zdefiniowana

nawet gdyby jej wartość była przechowywana między wywołaniami funkcji, to i tak przy każdym wywołaniu zmienna byłaby ponownie inicjalizowana. Rozważmy przykład przedstawiony na listingu 2.54. Listing 2.54. Odwołania do zmiennej lokalnej "; $liczba += 20; } func(); func(); ?>

W funkcji func jest tworzona zmienna $liczba o wartości początkowej 10. Wartość zmiennej jest następnie wyświetlana na ekranie za pomocą instrukcji echo. W ostatniej instrukcji funkcji zmienna jest zwiększana o 20 (jest używany operator +=). Tym samym na końcu wartością zmiennej jest 30, jednak nie jest ona nigdzie używana i po zakończeniu działania funkcji jest tracona. Funkcja func w skrypcie została wywołana dwukrotnie, zatem dwukrotnie zostanie wykonana opisana procedura, a na ekranie pojawią się dwa napisy $liczba = 10. Zupełnie inaczej będzie jednak, jeśli przy tworzeniu zmiennej zostanie użyte słowo static, schematycznie: static $nazwa_zmiennej = $wartość;

Wtedy wartość zmiennej będzie przechowywana pomiędzy wywołaniami funkcji. Tzn. pierwsze wywołanie funkcji spowoduje utworzenie zmiennej statycznej i zapamiętanie jej ostatecznej wartości. Natomiast w każdym kolejnym wywołaniu instrukcja przypisująca pierwotną wartość zmiennej będzie ignorowana, a używana będzie wartość z poprzedniego wywołania. Zostało to zilustrowane w kodzie z listingu 2.55.

Rozdział 2. ♦ Elementy języka

123

Listing 2.55. Użycie zmiennej statycznej "; $liczba += 20; } func(); func(); ?>

Jedyną różnicą w stosunku do przykładu z listingu 2.54 jest użycie słowa static przy definicji zmiennej $liczba w funkcji func. Zmienia to jednak sposób działania skryptu. Pierwsze wywołanie funkcji da taki sam efekt jak w poprzednim przykładzie, jednak wartość zmiennej $liczba zostanie zapamiętana. Dlatego w drugim wywołaniu instrukcja: static $liczba = 10;

nie zostanie wykonana, bo zmienna $liczba już istnieje. W kolejnych wierszach kodu funkcji zostanie więc użyta istniejąca wartość zmiennej (czyli ta wynikająca z pierwszego wywołania). Będzie to więc 30 (pierwotna wartość 10 zwiększona o 20 w pierwszym wywołaniu funkcji). Tym samym na ekranie pojawią się dwa napisy: $liczba = 10 $liczba = 30

natomiast wartość zmiennej zmieni się na 50 (aktualna wartość 30 zwiększona o 20 w drugim wywołaniu funkcji). Wartość ta mogłaby zostać ujawniona (wyświetlona na ekranie) w kolejnym wywołaniu funkcji func.

Zmienne superglobalne Zmienne superglobalne (stosuje się również termin autoglobalne, z ang. autoglobal) to zestaw predefiniowanych tablic, do których można odwoływać się w każdym miejscu skryptu. Zostały one przedstawione w lekcji 2., z niektórych z nich będziemy korzystać w dalszej części książki. Wspomnijmy jedynie, że użytkownik nie ma możliwości samodzielnego definiowania takich zmiennych oraz że istnieje możliwość wyłączenia obsługi przestarzałych konstrukcji znanych z PHP3 i PHP4, czyli: $HTTP_SERVER_VARS, $HTTP_ENV_VARS, $HTTP_COOKIE_VARS, $HTTP_GET_VARS, $HTTP_POST_VARS, $HTTP_POST_ FILES, $HTTP_SESSION_VARS. W tym celu w pliku php.ini należy wyłączyć opcję register_long_arrays: register_long_arrays = Off

Sposoby przekazywania argumentów Argumenty funkcji mogą być przekazywane na dwa sposoby:  przez wartość (z ang. by value),  za pomocą referencji (z ang. by reference).

124

PHP5. Praktyczny kurs

W prezentowanych do tej pory przykładach wykorzystywane było domyślne przekazywanie argumentów przez wartość. Oznacza to, że w rzeczywistości funkcja otrzymuje kopię argumentów źródłowych i wszelkie operacje wykonuje na tych kopiach. Nie jest więc w stanie dokonać żadnej modyfikacji oryginału. Ten problem zilustrowano w przykładzie widocznym na listingu 2.56. Listing 2.56. Przekazywanie argumentów przez wartość "; dodajJeden($liczba); echo "Po wywołaniu funkcji \$liczba = $liczba.
"; ?>

Widoczna w skrypcie funkcja dodajJeden przyjmuje argument o nazwie $liczba, a wewnątrz jej kodu wartość argumentu jest zwiększana o jeden. W dalszej części kodu powstała zmienna $liczba, której przypisano wartość 1 i została ona przekazana funkcji dodajJeden. Instrukcje echo pozwalają na śledzenie stanu zmiennej przed wywołaniem funkcji i po jej wywołaniu. Moglibyśmy oczekiwać, że przed wywołaniem wartością $liczba będzie 1, natomiast po wywołaniu — 2. Jak jednak widać na rysunku 2.28, w obu przypadkach jest to 1. Skoro bowiem argument został przekazany przez wartość, to funkcja dodajJeden otrzymała tylko kopię zmiennej $liczba zawierającą jej wartość (innymi słowy, funkcja otrzymała wartość zmiennej, a nie zmienną). Wszystkie operacje wewnątrz funkcji odbywały się właśnie na tej kopii, dlatego oryginalna wartość zmiennej pozostała nienaruszona. Rysunek 2.28. Wywołanie funkcji z argumentem przekazanym przez wartość

Taki sposób przekazywania argumentów jest najczęściej wystarczający. Jeśli jednak chcemy mieć możliwość modyfikowania w funkcji argumentu oryginalnego, trzeba zastosować sposób drugi — przekazywanie przez referencję. W tym celu przed nazwą argumentu należy umieścić znak & (ampersand). Jeśli zatem funkcja dodajJeden z listingu 2.56 miałaby modyfikować oryginalną zmienną $liczba, całość powinna mieć postać zaprezentowaną na listingu 2.57. Jak widać na rysunku 2.29, po takiej modyfikacji funkcja dodajJeden faktycznie zwiększyła wartość zmiennej $liczba o 1.

Rozdział 2. ♦ Elementy języka

125

Listing 2.57. Przekazywanie argumentów przez referencję "); dodajJeden($liczba); echo("Po wywołaniu funkcji \$liczba = $liczba.
"); ?>

Rysunek 2.29. Wywołanie funkcji z argumentem przekazanym przez referencję

Domyślne argumenty funkcji PHP pozwala na konstruowanie funkcji o domyślnych wartościach argumentów. Dzięki temu część parametrów lub nawet wszystkie będą mogły być pominięte w wywołaniu, a w ich miejsce zostaną wstawione wartości zdefiniowane podczas tworzenia funkcji. Aby zastosować tę technikę, należy skorzystać z konstrukcji o schematycznej postaci: function nazwa_funkcji ($argument1 = wartość, $argument2 = wartość2, ..., $argumentN = wartośćN) { //treść funkcji }

Sposób wykorzystania tej techniki zobrazowano w skrypcie widocznym na listingu 2.58. Listing 2.58. Funkcja wykorzystująca argumenty domyślne '; $liczba2 = dodaj($liczba1); echo $liczba2 , '
';

126

PHP5. Praktyczny kurs $liczba2 = dodaj(5, 3); echo $liczba2, '
'; $liczba2 = dodaj(5); echo $liczba2, '
'; ?>

W skrypcie została umieszczona funkcja dodaj przyjmująca dwa argumenty, a jej zadaniem jest zwrócenie wartości będącej ich sumą. Oba argumenty są przekazywane przez wartość, przy czym drugi z nich ma wartość domyślną równą 1. Dzięki temu jeśli w wywołaniu drugi argument nie zostanie podany, funkcja zadziała tak, jakby miał on wartość 1. W dalszej części skryptu znajduje się kilka przykładowych wywołań dodaj z różnymi parametrami. W przypadku pierwszym jest to: $liczba2 = dodaj($liczba1, 5);

W wyniku działania tej instrukcji zmiennej $liczba2 zostanie przypisana wartość 15, bowiem pierwszy argument to zmienna $liczba1 i zawiera on wartość 10, a drugi to wartość 5. Kolejne wywołanie to: $liczba2 = dodaj($liczba1);

Zgodnie z wcześniejszymi informacjami zostanie ono potraktowane jako: $liczba2 = dodaj($liczba1, 1);

Efekt działania jest zatem oczywisty — zmienna $liczba2 otrzyma wartość 11 (wynik działania 10+1). Kolejne wywołanie to: $liczba2 = dodaj(5, 3);

Zostały tu zatem wykorzystane argumenty o bezwzględnych wartościach. W tym przypadku zmiennej $liczba2 zostanie przypisana wartość 8. Ostatnie wywołanie to: $liczba2 = dodaj(5);

Jak już wiemy, zostanie ono potraktowane jako: $liczba2 = dodaj(5, 1);

W związku z tym zmienna $liczba2 otrzyma wartość 6.

Ćwiczenia do samodzielnego wykonania Ćwiczenie 6.1. Zmodyfikuj kod z listingu 2.47 w taki sposób, aby nie było konieczności wykorzystywania pomocniczej zmiennej $wynik. Ćwiczenie 6.2. Napisz funkcję, której zadaniem będzie zwrócenie wyniku mnożenia przekazanych jej argumentów.

Rozdział 2. ♦ Elementy języka

127

Ćwiczenie 6.3. Napisz funkcję, której zadaniem będzie podniesienie wartości przekazanego jej poprzez referencję argumentu do trzeciej potęgi. Ćwiczenie 6.4. Napisz funkcję przyjmującą dwa argumenty całkowite, której zadaniem będzie zwrócenie wartości wynikającej z podniesienia argumentu pierwszego do potęgi wynikającej z wartości drugiego. W przypadku jeśli w wywołaniu nie zostanie podany drugi argument, funkcja powinna zachować się tak, jakby miał on wartość 1. Ćwiczenie 6.5. Napisz funkcję, która będzie przyjmowała dwa argumenty liczbowe i będzie zwracała mniejszy z nich.

Lekcja 7. Obsługa daty i czasu Wyświetlanie daty i czasu W trakcie pisania skryptów często będziemy chcieli uzyskać aktualną datę i (lub) czas. PHP dysponuje na szczęście odpowiednimi funkcjami, które pozwalają na wykonywanie tego typu operacji. Podstawową funkcją pozwalającą na uzyskiwanie informacji o dacie jest date. Jej wywołanie ma postać: date(format[, znacznik_czasu])

Zwraca ona ciąg znaków we wskazanym formacie. Parametr format określa, jakie dane nas interesują, natomiast znacznik_czasu to argument opcjonalny24 zawierający znacznik czasu Uniksa (timestamp) i określający interesującą nas datę. Znacznik czasu w rzeczywistości określa liczbę sekund, które upłynęły od północy (godzina 0:00:00) 1 stycznia 1970 roku. Ten sposób określania daty jest powszechnie wykorzystywany w systemach z rodziny Uniksa. Na razie jednak nie musimy go stosować. Jeśli bowiem parametr znacznik_czasu zostanie pominięty, funkcja date będzie wykorzystywała czas bieżący. Skoro tak, najważniejszy dla nas w tej chwili jest parametr format, który jest ciągiem znaków mogącym zawierać znaczniki przedstawione w tabeli 2.19. Tabela 2.19. Znaczniki formatujące dla funkcji date Znacznik

Opis

Przykładowe wartości

a

Określenie przed południem (am) lub po południu (pm)

am, pm

A

Określenie przed południem (AM) lub po południu (PM)

AM, PM

B

Czas internetowy w formacie Swatch

od 000 do 999

c

Data i czas zgodne z formatem ISO 8601

2012-05-12T15:19:21+00:00

d

Dzień miesiąca w formacie dwucyfrowym z zerem na początku (jeśli konieczne)

od 01 do 31

D

Dzień miesiąca w formie trzyliterowego skrótu

od Mon do Sun

24

Argumenty, czy też szerzej wszelkie konstrukcje języka, które są opcjonalne, w opisach ujmuje się w nawiasy kwadratowe.

128

PHP5. Praktyczny kurs

Tabela 2.19. Znaczniki formatujące dla funkcji date — ciąg dalszy Znacznik

Opis

Przykładowe wartości

e

Identyfikator strefy czasowej; znacznik dostępny od wersji 5.1.0

GMT, UTC

F

Pełna nazwa miesiąca

od January do December

g

Godzina w formacie dwunastogodzinnym, bez zera na początku

od 1 do 12

G

Godzina w formacie dwudziestoczterogodzinnym, bez zera na początku.

od 1 do 24

h

Godzina w formacie dwunastogodzinnym, z zerem na początku (jeśli konieczne)

od 01 do 12

H

Godzina w formacie dwudziestoczterogodzinnym, z zerem na początku (jeśli konieczne)

od 01 do 24

i

Liczba minut, z zerem na początku (jeśli konieczne)

od 01 do 59

I

Znacznik czasu zimowego (1) i letniego (0)

0 lub 1

j

Dzień miesiąca, bez zera na początku

od 1 do 31

l

Nazwa dnia tygodnia

od Monday do Sunday

L

Znacznik roku przestępnego (1 oznacza rok przestępny)

0 lub 1

m

Miesiąc w postaci dwucyfrowej, z zerem na początku (jeśli konieczne)

od 01 do 12

M

Skrót nazwy miesiąca (trzyliterowy)

od Jan do Dec

n

Miesiąc w postaci liczbowej, bez zera na początku

od 1 do 12

N

Dzień tygodnia zgodnie ze standardem ISO-8601; znacznik dostępny od wersji 5.1.0

od 1 (poniedziałek) do 7 (niedziela)

o

Rok zgodnie ze standardem ISO-8601; znacznik dostępny od wersji 5.1.0

1995, 2015

O

Różnica w stosunku do czasu Greenwich (GMT)

+0200

P

Różnica w stosunku do czasu Greenwich (GMT); znacznik dostępny od wersji 5.1.3

+02:00

r

Data w postaci zgodnej ze standardem opisanym w rfc2822

Fri, 21 Dec 2012 16:01:07 +0200

s

Liczba sekund, z zerem na początku (jeśli konieczne)

od 00 do 59

S

Przyrostek literowy dla liczby określającej dzień tygodnia (dla jęz. ang.)

"st", "nd", "rd" lub "th"

t

Liczba dni w danym miesiącu

od 28 do 31

T

Określenie strefy czasowej

np. EST, MDT

u

Liczba mikrosekund; znacznik dostępny od wersji 5.2.2

291365

U

Znacznik czasu Uniksa

liczba sekund, które upłynęły od 1 stycznia 1970 00:00:00 GMT

w

Dzień tygodnia w postaci numerycznej

od 0 (niedziela) do 6 (sobota)

W

Numer tygodnia w roku zgodnie ze standardem ISO-8601 od 1 do 52

Rozdział 2. ♦ Elementy języka

129

Tabela 2.19. Znaczniki formatujące dla funkcji date — ciąg dalszy Znacznik

Opis

Przykładowe wartości

Y

Rok w postaci czteroliterowej

np. 2008

y

Rok w postaci dwuliterowej

np. 08

z

Numer kolejnego dnia w roku, numeracja od 0

od 0 do 365

Z

Przesunięcie strefy czasowej względem południka zerowego w sekundach

np. –43200, 43200

Jeżeli w ciągu formatującym znajdą się inne znaki niż wymienione w tabeli 2.19., zostaną one wyświetlone w niezmienionej postaci. Aby się przekonać, jakie efekty daje użycie różnych znaczników, można uruchomić skrypt widoczny na listingu 2.59. Wyświetla on przykładowe ciągi formatujące oraz odpowiadające im daty i (lub) czasy. Efekt działania kodu został zaprezentowany na rysunku 2.30. Listing 2.59. Przykładowe wywołania funkcji date '; echo 'date(\"d-m-Y\") = ' . date("d-m-Y") . '
'; echo 'date(\"j, M Y\") = ' . date("j, M Y") . '
'; echo 'date(\"jS, M Y\") = ' . date("jS, M Y") . '
'; echo 'date(\"G:i:s\") = ' . date("G:i:s") . '
'; echo 'date(\"h:i:sa\") = ' . date("h:i:sa") . '
'; echo 'date(\"Y-m-d G:i:s\") = ' . date("Y-m-d G:i:s") . '
'; ?>

Rysunek 2.30. Efekt działania różnych ciągów formatujących w funkcji date

Drugą funkcją pozwalającą na pobranie informacji dotyczących daty i czasu jest getdate. Jej wywołanie ma postać: getdate([znacznik_czasu])

Również w tym przypadku parametr znacznik_czasu jest opcjonalny, a jego użycie ma takie samo znaczenie jak w przypadku date. Wynikiem działania getdate nie jest jednak ciąg znaków, ale tablica asocjacyjna (patrz lekcja 9.) zawierająca pobrane dane. Indeksy tej tablicy wraz z ich znaczeniami i przykładowymi wartościami zostały wymienione w tabeli 2.20.

130

PHP5. Praktyczny kurs

Tabela 2.20. Indeksy tablicy zwracanej przez funkcję getdate Nazwa indeksu

Znaczenie

Przykładowe wartości

seconds

Liczba sekund

od 0 do 59

minutes

Liczba minut

od 0 do 59

hours

Godzina

od 0 do 23

mday

Dzień miesiąca

od 1 do 31

wday

Dzień tygodnia w postaci numerycznej

od 0 (niedziela) do 6 (sobota)

mon

Miesiąc w postaci liczbowej

od 1 do 12

year

Rok w postaci czterocyfrowej

1995, 2015

yday

Numer kolejnego dnia w roku

od 0 do 365

weekday

Dzień tygodnia w postaci tekstowej (dla jęz. ang.)

Sunday, Monday

month

Dzień miesiąca w postaci tekstowej (dla jęz. ang.)

January, February

0

Aktualny znacznik czasu Uniksa

zazwyczaj od -2147483648 do 2147483647

W skrypcie widocznym na listingu 2.60 zobrazowano, w jaki sposób wykorzystać getdate do wyświetlenia informacji o aktualnej dacie. Tablica zwrócona przez funkcję jest przypisywana zmiennej $data, a wartości odczytane z indeksów mday, mon i year są przypisywane zmiennym pomocniczym $dzien, $miesiac, $rok. W przypadku gdy wartości zapisane w $dzien i $miesiac są mniejsze od 10, jest do nich dodawany znak 0, tak aby były zawsze prezentowane w formie dwucyfrowej (jednocześnie następuje wtedy konwersja do typu string). Ostatecznie wszystkie zmienne są łączone w jeden ciąg znaków i wysyłane do przeglądarki za pomocą instrukcji echo. Listing 2.60. Wykorzystanie funkcji getdate

Jak wynika z tabeli 2.20, istnieje również możliwość uzyskania nazwy miesiąca w postaci tekstowej. Niestety dotyczy to jedynie języka angielskiego. Jeśli chcemy otrzymać polskie określenia, musimy sami zadbać o napisanie odpowiedniej procedury. W tym celu wartość zwróconą przez wywołanie getdate pod indeksem mon należy przetworzyć tak, aby zawierała polską nazwę miesiąca. Można tego dokonać za pomocą instrukcji wyboru switch…case, tak jak zostało to zaprezentowane na listingu 2.61. Zmienna $miesiac występuje tu w podwójnej roli — najpierw przechowuje numer miesiąca, a następnie (po wykonaniu instrukcji switch) ciąg znaków określający jego nazwę. Przykładowy efekt działania skryptu został zaprezentowany na rysunku 2.31.

Rozdział 2. ♦ Elementy języka

131

Listing 2.61. Uzyskanie polskich nazw miesięcy

Rysunek 2.31. Skrypt wyświetlający datę z polską nazwą miesiąca

W podobny sposób uzyskamy polską nazwę aktualnego dnia tygodnia. Można w tym celu użyć zarówno funkcji getdate, jak i date. Tym razem skorzystamy więc z tej drugiej możliwości. Skrypt wykonujący takie zadanie jest widoczny na listingu 2.62, a przykładowy efekt jego działania na rysunku 2.32. Podobnie jak w poprzednim przykładzie, pomocnicza zmienna $dzienTygodnia najpierw przechowuje numeryczną wartość określającą dzień, a następnie ciąg znaków opisujący nazwę dnia. Listing 2.62. Wyświetlenie nazwy aktualnego dnia tygodnia
= = = = = =

"niedziela"; break; "poniedziałek"; break; "wtorek"; break; "środa"; break; "czwartek"; break; "piątek"; break;

132

PHP5. Praktyczny kurs case 6 : $dzienTygodnia = "sobota"; break; } echo "Dziś jest $dzienTygodnia."; ?>

Rysunek 2.32. Efekt działania skryptu z listingu 2.62

Do uzyskiwania danych opisujących datę i czas w językach narodowych można również wykorzystać funkcję strftime, która zwraca ciąg znaków sformatowany zgodnie z szablonem przekazanym jako argument. Jej wywołanie ma postać: strftime(format[, timestamp])

Argument format to ciąg znaków, który może zawierać znaczniki przedstawione w tabeli 2.21. Parametr timestamp jest opcjonalny. Pozwala on na uzyskanie ciągu znaków, który odpowiada konkretnej dacie. Jeśli zostanie pominięty, będzie użyty bieżący czas lokalny. Tabela 2.21. Znaczniki formatujące dla funkcji strftime Znacznik

Znaczenie

Przykłady

%a

Nazwa dnia tygodnia w postaci skróconej

Pn, Wt, Śr

%A

Pełna nazwa dnia tygodnia

poniedziałek, wtorek

%b

Nazwa miesiąca w postaci skróconej

sty, lut, mar

%B

Pełna nazwa miesiąca

styczeń, luty, marzec

%c

Data i czas w formacie bieżącej lokalizacji

2008-02-17 18:35:46

%C

Określenie wieku; rok podzielony przez sto i zaokrąglony do liczby całkowitej z zakresu od 00 do 99

20, 21

%d

Dzień miesiąca w postaci numerycznej dwucyfrowej (z zerem na początku, jeśli konieczne)

od 01 do 31

%D

Znaczenie identyczne z %m/%d/%y

02/17/14

%e

Dzień miesiąca w postaci numerycznej, liczby jednocyfrowe poprzedzane są spacją (format nieobsługiwany w systemach Windows)

od 1 do 31

%F

Znaczenie identyczne z %Y-%m-%d

2014-02-17

%g

Znaczenie takie jak %G, bez uwzględnienia wieku

08, 09

%G

Czterocyfrowy rok powiązany z numerem tygodnia według standardu ISO-8601:1988

2008, 2009

%h

Znaczenie takie samo jak %b

sty, lut, mar

%H

Godzina w formacie dwudziestoczterogodzinnym, z zerem na początku (jeśli konieczne)

od 01 do 24

Rozdział 2. ♦ Elementy języka

133

Tabela 2.21. Znaczniki formatujące dla funkcji strftime — ciąg dalszy Znacznik

Znaczenie

Przykłady

%I

Godzina w formacie dwunastogodzinnym, z zerem na początku (jeśli konieczne)

od 01 do 12

%j

Numer dnia w roku w formacie trzycyfrowym, z zerami na początku, jeśli konieczne

od 001 do 366

%l

Godzina w formacie dwunastogodzinnym ze spacją poprzedzającą pojedyncze cyfry.

od 1 do 12

%m

Miesiąc w postaci numerycznej dwucyfrowej, z zerem na początku (jeśli konieczne)

od 01 do 31

%M

Bieżąca liczba minut w formacie dwucyfrowym

od 01 do 59

%n

Znak nowej linii

–

%p

Znacznik przed południem — po południu (wielkimi literami)

AM, PM

%P

Znacznik przed południem — po południu (małymi literami)

am, pm

%r

Znaczenie identyczne z %I:%M:%S %p

03:17:26 PM

%R

Znaczenie identyczne z %H:%M

15:17

%S

Bieżąca liczba sekund w formacie dwucyfrowym

od 00 do 59

%t

Znak tabulacji

-

%T

Znaczenie identyczne z %H:%M:%S

15:18:53

%u

Numer dnia tygodnia wg Standardu ISO-8601, 1 oznacza poniedziałek, 7 — niedzielę

od 1 do 7

%U

Numer tygodnia w roku, poczynając od pierwszej niedzieli jako pierwszego dnia pierwszego tygodnia

od 01 do 53

%V

Numer tygodnia w roku zgodnie ze standardem ISO8601:1998

od 01 do 53

%w

Numer dnia tygodnia, 0 oznacza niedzielę, 6 — sobotę

od 0 do 6

%W

Numer tygodnia w roku, poczynając od pierwszego poniedziałku jako pierwszego dnia pierwszego tygodnia

od 01 do 53

%x

Reprezentacja daty zgodna z bieżącymi ustawieniami lokalizacyjnymi

2014-02-17

%X

Reprezentacja czasu zgodna z bieżącymi ustawieniami lokalizacyjnymi

19:02:19

%y

Rok w postaci dwucyfrowej

od 00 do 99

%Y

Rok w postaci czterocyfrowej

od 1901 do 2038

%z

Przesunięcie dla bieżącej strefy czasowej lub skrót nazwy strefy czasowej (zależnie od systemu operacyjnego, na którym 25 działa PHP)

+0200, CET

%Z

Określenie strefy czasowej niezwracane przez znacznik %z 26

+0200, CET

%%

Znak %

%

25

W praktyce może być zwrócona również pełna nazwa strefy czasowej.

26

W praktyce zwrócony może zostać również ten sam wynik co przy znaczniku %z.

134

PHP5. Praktyczny kurs

Dane zwracane przez strftime, a więc m.in. nazwy dni tygodnia oraz miesięcy, będą zgodne z bieżącymi ustawieniami lokalnymi (narodowymi), które mogą być zmieniane za pomocą funkcji setlocale. Wywołanie setlocale ma postać: setlocale(kategoria, locale);

Parametr kategoria wskazuje, jakie informacje mają być pobierane z uwzględnieniem ustawień narodowych, natomiast locale określa, który zestaw narodowy ma być użyty. Możliwe wartości parametru kategoria zostały zaprezentowane w tabeli 2.22. Argument locale jest wyrażany w różny sposób w różnych systemach operacyjnych. W systemach uniksowych jest on oparty na normach opisanych w dokumentach RFC 1766 oraz ISO 639. Dla ustawień polskich należy użyć ciągu pl_PL. W systemach z rodziny Windows stosowana jest inna konwencja nazewnictwa i dla ustawień polskich należy użyć ciągu plk lub polish. Powodem takich różnic jest to, że funkcja setlocale zawarta w PHP bazuje na funkcjach systemu operacyjnego, które zachowują się różnie w zależności od systemu. Tabela 2.22. Wartości pierwszego parametru funkcji setlocale Parametr

Znaczenie

LC_ALL

Wpływa na wszystkie parametry

LC_COLLATE

Wpływa na porównywanie ciągów znaków

LC_CTYPE

Wpływa na klasyfikację i konwersję znaków

LC_MONETARY

Wpływa na postać ciągów numerycznych i walutowych

LC_NUMERIC

Wpływa na postać separatora dziesiętnego

LC_TIME

Wpływa na postać daty i czasu

Warto zwrócić uwagę, że zachowanie strftime również zależy od tego, na jakim systemie operacyjnym działa PHP. O ile zatem przedstawione wcześniej na listingach 2.61 i 2.62 skrypty będą działały tak samo niezależnie od środowiska PHP, to w przypadku wykorzystania strftime już tak być nie musi. Po pierwsze zwracane wartości mogą być różne w zależności od systemu, po drugie nie zawsze będą dostępne wszystkie znaczniki formatujące przedstawione w tabeli 2.21. Prosty skrypt wykorzystujący omawianą funkcję do wyświetlenia kilku podstawowych danych o dacie i czasie został zaprezentowany na listingu 2.63, a przykładowy efekt jego działania jest widoczny na rysunku 2.33. Listing 2.63. Wykorzystanie funkcji setlocale "); echo strftime("Data: %d-%m-%Y
"); echo strftime("Czas: %H:%M:%S
"); echo strftime("Mamy %U. tydzień i %j. dzień roku.
"); echo strftime("Dziś jest %A, %d %B %Y r.
"); ?>

Rozdział 2. ♦ Elementy języka

135

Rysunek 2.33. Efekt działania skryptu wykorzystującego funkcję strftime

Tworzenie znacznika czasu Do utworzenia znacznika czasu Uniksa, który może być wykorzystywany jako drugi parametr funkcji opisywanych w poprzedniej części lekcji, można wykorzystać funkcję mktime. W pełnej wersji przyjmuje ona aż siedem argumentów, chociaż w rzeczywistości wszystkie są opcjonalne. Schemat wywołania jest następujący: mktime([godzina[, minuta[, sekunda[, miesiąc[, dzień[, rok[, is_dst]]]]]]])

Znaczenie pierwszych sześciu argumentów jest zgodne z ich nazwami, natomiast is_dst powinien przyjąć wartość 1 dla czasu zimowego, 0 dla letniego lub -1, jeżeli nie wiadomo, jaki to jest czas. Jest to jednak pozostałość po poprzednich wersjach PHP i obecnie (począwszy od PHP 5.1.0) należy unikać jego stosowania. Parametry można pomijać wyłącznie od strony prawej do lewej, co oznacza, że jeśli chcemy zrezygnować z parametru dzień, to musimy również usunąć rok i ist_dst. Brakujące parametry są uzupełniane przez bieżący czas lokalny. Jeśli więc interesuje nas znacznik czasu odpowiadający godzinie 13:24:52 w aktualnym dniu, zastosujemy wywołanie: mktime(13, 24, 52)

Jeśli zaś znacznik ma odpowiadać aktualnemu czasowi i dacie, należy pominąć wszystkie parametry: mktime()

Należy przy tym zwrócić uwagę, że począwszy od PHP 5.1.0 pominięcie wszystkich argumentów (choć dopuszczalne) spowoduje wygenerowanie komunikatu sugerującego użycie funkcji time, zamiast mktime (rysunek 2.34). Taki komunikat będzie jednak widoczny tylko wtedy, gdy w pliku konfiguracyjnym php.ini została włączona opcja raportowania błędów E_STRICT (zmienna error_reporting w sekcji Error handling and logging). Parametr rok może być podawany w postaci dwu- lub czterocyfrowej. W pierwszym przypadku wartości od 0 do 69 są przekładane na lata 2000 – 2069, natomiast od 70 do 99 na lata 1970 – 1999. W tym miejscu trzeba zaznaczyć, że maksymalny możliwy zakres dat to lata 1901 – 2038, co wynika z tego, że znacznik czasu jest reprezentowany

136

PHP5. Praktyczny kurs

Rysunek 2.34. Komunikat systemowy po użyciu funkcji mktime bez argumentów wywołania

jako 32-bitowa liczba ze znakiem. Może więc on przyjmować wartości od –231 do 231 – 1. Skoro taka wartość oznacza liczbę sekund, które upłynęły od 1 stycznia 1970 (od tzw. epoki Uniksa, z ang. Unix epoch), zakres dat musi być ograniczony. Poza tym w niektórych wersjach systemu Windows nie są obsługiwane wartości ujemne znacznika, co w przypadku PHP w wersjach poniżej 5.1.0 ogranicza zakres do lat 1970 – 2038. Jak w praktyce można wykorzystać funkcję mktime, pokazuje skrypt widoczny na listingu 2.64. Pozwala on na obliczenie liczby dni występujących pomiędzy dwiema datami. Przykładowo pomiędzy 1 maja a 1 września 2014 roku. Listing 2.64. Skrypt obliczający liczbę dni pomiędzy dwiema datami

Pierwsza data jest zapisywana w zmiennych $r1, $m1, $d1, a druga — $r2, $m2, $d2. Nietrudno się domyślić, że zmienne z literą r określają rok, z literą m — miesiąc, a z d — dzień. Obie daty są przetwarzane na odpowiadające im znaczniki czasu Uniksa, następnie jest obliczana ich różnica, czyli liczba występujących pomiędzy nimi sekund ($time1 - $time2). Po wyliczeniu tej wartości wystarczy zamienić sekundy na dni, aby odnaleźć ich szukaną liczbę. Taka zamiana jest prosta — dzielimy różnicę przez liczbę sekund w dobie, czyli 86 400 (60 sekund×60 minut×24 godziny). Ponieważ w zależności od danych wejściowych uzyskana wartość może być ujemna oraz niecałkowita, stosujemy dodatkowo funkcję zaokrąglenia wyniku w górę (ceil) oraz funkcję podającą wartość bezwzględną argumentu (abs). Jeśli tak złożona instrukcja jest niezbyt czytelna, możemy ją rozbić na kilka etapów, np.:

Rozdział 2. ♦ Elementy języka

137

$time = ($time1 - $time2) / 86400; $time = ceil($time); $time = abs($time);

Ostatecznie po uruchomieniu skryptu zobaczymy widok taki jak na rysunku 2.35. Rysunek 2.35. Liczba dni pomiędzy dwiema datami

Znacznik czasu można również uzyskać poprzez konwersję ciągu znaków opisujących datę i (lub) czas. Służy do tego funkcja strtotime, której wywołanie jest następujące: strtotime(format[, timestamp]);

Argument format to opis daty (ciąg znaków), dla której chcemy uzyskać znacznik czasu. Natomiast timestamp to opcjonalny znacznik czasu, który zostanie wykorzystany przy obliczaniu wyniku. Opis daty to angielski opis zgodny ze składnią GNU. Nie będziemy omawiać tu pełnej składni tego standardu, gdyż zajęłoby to zbyt wiele miejsca. Wszelkie niezbędne informacje można znaleźć w dokumentacji PHP w sekcji Date and Time Related Extensions/Supported Date and Time Formats. Pokazanych zostanie jednak kilka przykładów zastosowania. Jeśli więc chcemy uzyskać aktualny znacznik czasu, napiszemy: strtotime("now");

Jeśli interesuje nas znacznik czasu dla 18 marca 1976 roku, napiszemy: strtotime("18 march 1978");

Jeśli potrzebujemy znacznika czasu sprzed 12 dni, wpiszemy: strtotime("-12 day");

Jeśli potrzebujemy znacznika czasu, który wystąpi za 2 dni 4 godziny 15 minut i 12 sekund od aktualnej godziny, wpiszemy: strtotime("+2 day 4 hours 15 minutes 12 seconds");

Jeśli chcemy uzyskać znacznik czasu dla następnego piątku, wtedy wpiszemy: strtotime("next friday")

Ostatnia funkcja, którą zajmiemy się w tej sekcji, to microtime. Ona również zwraca aktualny znacznik czasu, z tym że zawierający dodatkowo dane odnośnie liczby mikrosekund. Ogólne wywołanie ma postać: microtime([tryb])

tryb jest tu opcjonalnym parametrem typu boolean. W przypadku gdy jest obecny i równy true, zwracana jest wartość rzeczywista. W pozostałych przypadkach zwracany jest ciąg w postaci msec sec, gdzie msec oznacza liczbę mikrosekund, a sec liczbę

138

PHP5. Praktyczny kurs

sekund, które upłynęły od początku epoki Uniksa. Takie zachowanie pozwala np. na wykorzystanie tej funkcji do obliczenia czasu generowania strony. To, jak to zrobić, zaprezentowano w skrypcie widocznym na listingu 2.65. Listing 2.65. Skrypt obliczający czas generowania strony

Przed wykonaniem głównego kodu strony wywoływana jest funkcja microtime, a wynik jej działania jest przypisywany zmiennej $time1. Po wykonaniu kodu strony, który w tym przypadku jest symulowany przez zagnieżdżone pętle for, ponownie jest wywoływana funkcja microtime, a zwrócony wynik działania zapisywany w zmiennej $time2. Oznacza to, że czas generowania strony to nic innego jak $time2 - $time1. Wynik jest zaokrąglany za pomocą funkcji round do czterech miejsc po przecinku i wyświetlany w przeglądarce, tak jak jest to widoczne na rysunku 2.36. Rysunek 2.36. Wynik działania skryptu podającego czas generowania strony

Pozostałe funkcje Oprócz wspomnianych wyżej istnieje jeszcze wiele innych funkcji służących do obsługi daty i czasu. Nie ma potrzeby, aby je wszystkie omawiać — w tej części lekcji opisanych zostanie jedynie kilka. Będą to:  checkdate,  gmdate,  localtime,  time.

W razie potrzeby dodatkowe informacje można znaleźć w dokumentacji PHP w sekcji Date and Time Related Extensions/Date/Time Functions.

Rozdział 2. ♦ Elementy języka

139

Funkcja checkdate Zadaniem funkcji checkdate jest sprawdzenie, czy dane przekazane jej w postaci argumentów tworzą poprawną datę. Jej wywołanie ma postać: checkdate(miesiąc, dzień, rok)

Znaczenie argumentów jest zgodne z ich nazwami, wszystkie są typu integer. Funkcja zwraca wartość true, jeżeli podany dzień, miesiąc i rok tworzą poprawną datę, lub false w przeciwnym wypadku. Należy zwrócić uwagę na kolejność argumentów — jest ona zgodna z amerykańskim formatem prezentacji daty, w którym miesiąc znajduje się na pierwszym miejscu. Przykład wywołania (dla 25 maja 2014 roku): checkdate(5, 25, 2014)

Funkcja gmdate Funkcja gmdate zwraca ciąg znaków sformatowany zgodnie z szablonem podanym jako parametr format. Jej wywołanie ma postać: gmdate(format[, timestamp])

Jeśli podamy parametr timestamp, zostanie zwrócona odpowiadająca mu data. Jeżeli parametr ten zostanie pominięty, będzie użyty czas bieżący. W odróżnieniu od omawianej wcześniej date, w tym przypadku zwracany jest czas GMT (UTC), a nie lokalny. Szablon format może zawierać znaczniki formatujące podane w tabeli 2.19 przy opisie funkcji date. Różnice w wywołaniu date i gmdate zostaną pokazane po uruchomieniu skryptu z listingu 2.66. Przykładowy efekt jego działania znajduje się na rysunku 2.37. Listing 2.66. Porównanie funkcji date i gmdate

"
Wywołania "gmdate(\"G:i\") "gmdate(\"r\") = "gmdate(\"c\") = "gmdate(\"T\") = "gmdate(\"Z\") =

date:
"; . date("G:i") . "
"; date("r") . "
"; date("c") . "
"; date("T") . "
"; date("Z") . "
";

funkcji gmdate:
"; = " . gmdate("G:i") . "
"; " . gmdate("r") . "
"; " . gmdate("c") . "
"; " . gmdate("T") . "
"; " . gmdate("Z") . "
";

Funkcja localtime Funkcja localtime zwraca tablicę, której poszczególne elementy zawierają dane odnośnie daty i czasu (zawartość tablicy jest taka sama jak struktury zwracanej po wywołaniu funkcji localtime w języku C).

140

PHP5. Praktyczny kurs

Rysunek 2.37. Wyniki działania funkcji date i gmdate

Wywołanie funkcji w PHP ma postać: localtime([timestamp[, is_associative]])

Argumentem pierwszym jest uniksowy znacznik czasu. Jeżeli zostanie pominięty, to uwzględniony będzie bieżący czas lokalny. Ustawienie argumentu is_associative na false lub niepodanie go powoduje zwrócenie zwykłej tablicy indeksowanej liczbowo. Ustawienie na true powoduje zwrócenie tablicy asocjacyjnej o następujących kluczach:  tm_sec — liczba sekund,  tm_min — liczba minut,  tm_hour — godzina,  tm_mday — dzień miesiąca w postaci liczbowej,  tm_mon — numer miesiąca w roku w postaci liczbowej,  tm_year — liczba lat, które upłynęły od roku 1900,  tm_wday — dzień tygodnia,  tm_yday — dzień roku,  tm_isdst — znacznik czasu letniego i zimowego.

Funkcja time Funkcja time zwraca znacznik czasu Uniksa określający aktualną datę i czas. Wywołanie ma postać: time()

Rozdział 2. ♦ Elementy języka

141

Ćwiczenia do samodzielnego wykonania Ćwiczenie 7.1. Korzystając z funkcji date, napisz skrypt wyświetlający następujące dane: nazwa dnia tygodnia (w jęz. polskim), pełna data (rok w postaci czterocyfrowej), czas w formacie dwunastogodzinnym z oznaczeniem przed południem/po południu oraz różnicę w stosunku do czasu GMT (UTC). Ćwiczenie 7.2. Napisz skrypt, który będzie wyświetlał liczbę dni pozostałych do końca bieżącego roku. Ćwiczenie 7.3. Napisz skrypt, który pozwoli na stwierdzenie, jakim dniem tygodnia był dowolnie wybrany dzień. Ćwiczenie 7.4. Napisz skrypt obliczający czas generowania strony, w którym wartości sekund i mikrosekund są wyświetlane oddzielnie. Ćwiczenie 7.5. Napisz skrypt, który umożliwi wczytywanie różnych wersji strony w zależności od pory dnia. Wykorzystaj funkcję date oraz instrukcję include.

Lekcja 8. Ciągi znaków Rodzaje ciągów znaków Praktycznie każdy skrypt w PHP operuje na ciągach znaków, trzeba więc nauczyć się, jak wykonywać na nich różne operacje. Jak wiadomo z lekcji 4., ciągi mogą być tworzone na trzy różne sposoby przy użyciu składni:  ze znakami cudzysłowu,  ze znakami apostrofu,  heredoc,  nowdoc.

Jeśli w pierwszym i trzecim przypadku w ciągu wystąpi nazwa zmiennej, jest ona zamieniana na jej wartość, natomiast w przypadku składni ze znakami apostrofu oraz nowdoc taka zamiana nie występuje. Przypomnijmy, jak to wygląda w praktyce. Odpowiedni skrypt jest widoczny na listingu 2.67, a efekt jego działania na rysunku 2.38. Listing 2.67. Różne sposoby tworzenia ciągów znaków
142

PHP5. Praktyczny kurs Zmienna liczba = $liczba, a zmienna ciag = $ciag. ID1; $str4 = <<<'ID2' Zmienna liczba = $liczba, a zmienna ciag = $ciag. ID2; echo "Zmienna str1 (składnia ze znakami cudzysłowu):
"; echo $str1; echo "

"; echo "Zmienna str2 (składnia ze znakami apostrofu):
"; echo $str2; echo "

"; echo "Zmienna str3 (składnia heredoc):
"; echo $str3; echo "

"; echo "Zmienna str4 (składnia nowdoc):
"; echo $str4; echo "

"; ?>

Rysunek 2.38. Efekt działania skryptu 2.67

Przy pracy z łańcuchami znakowymi należy zwrócić uwagę na wykorzystanie operatorów . i +. Otóż pierwszy z nich (kropka) jest operatorem łączenia ciągów, natomiast drugi (plus) to arytmetyczny operator dodawania (por. materiał z lekcji 4., sekcja „Operatory”). Częstym błędem, szczególnie zdarzającym się u osób, które programowały w innych językach, jest próba wykorzystania operatora + do łączenia łańcuchów. Próba takiej operacji zakończy się niepowodzeniem. Jeśli wykonamy następujący kod: $str1 = "abc"; $str2 = "def"; $str3 = $str1 + $str2;

Rozdział 2. ♦ Elementy języka

143

zmienna str3 będzie zawierała wartość 0. Co więcej, będzie ona typu integer. Dlaczego? Otóż ponieważ operator + działa na argumentach arytmetycznych, a zmienne $str1 i $str2 są typu string (są łańcuchami znakowymi, napisami), przed wykonaniem dodawania nastąpi konwersja argumentów do typu arytmetycznego. Ponieważ ani łańcuch abc, ani def nie zawierają ciągu, który reprezentowałby prawidłową wartość liczbową, oba zostaną skonwertowane do typu integer o wartości 0 (por. opis zasad konwersji z lekcji 4.). Wynikiem dodawania 0 + 0 jest oczywiście 0 i ta wartość jest przypisywana zmiennej $str3. Zauważmy również, że jeśli dodawane ciągi będą się układały w prawidłowe wartości liczbowe, operator + wykona dodawanie arytmetyczne, podczas gdy operator . — łączenie łańcuchów. Oznacza to, że w efekcie wykonania operacji: $str1 $str2 $str3 $str4

= = = =

"123"; "456"; $str1 + $str2; $str1 . $str2;

1. Zmienna $str3 będzie typu integer i będzie zawierała wartość 579, co wynika z użycia operatora dodawania arytmetycznego i konwersji wartości $str1 i $str2 do typu integer. 2. Zmienna $str4 będzie typu string i będzie zawierała ciąg znaków 123456,

co wynika z użycia operatora łańcuchowego do złączenia ciągów zawartych w $str1 i $str2.

Wyrażenia złożone w ciągach znaków Jeśli w ciągu interpretowanym przez PHP znajduje się zmienna, nazwa jest przetwarzana na reprezentowaną przez nią wartość. Wiemy, że jest tak przy składni ze znakami cudzysłowu oraz heredoc. Za zmienną musi jednak wtedy zawsze znajdować się tzw. biały znak (spacja, tabulator, znak nowego wiersza) lub też znak niedopuszczalny w nazwie zmiennej (np. gwiazdka, ukośnik, nawias itp.). Jest to konieczne, inaczej PHP nie będzie w stanie odnaleźć końca nazwy zmiennej. To oznacza, że jeśli mamy zmienną $liczba o wartości 1.4, to zapis: echo "abc $liczba def";

zadziała zgodnie z przewidywaniami, podobnie jak: echo "abc$liczba def";

W pierwszym przypadku na ekranie pojawi się napis abc 1.4 def, a w drugim — abc1.4 def. Nie zadziała natomiast instrukcja w postaci: echo "abc$liczbadef";

gdyż PHP będzie wtedy szukało zmiennej o nazwie $liczbadef, której nie ma w skrypcie (o ile oczywiście nie została zdefiniowana, nie rozpatrujemy jednak takiego przypadku). Nie powstanie co prawda błąd, ale na ekranie pojawi się jedynie ciąg abc (chyba że włączona jest pełna diagnostyka, wtedy dodatkowo pojawi się informacja o niezdefiniowanej zmiennej $liczbadef).

144

PHP5. Praktyczny kurs

Sytuacja się komplikuje, gdy chcemy umieścić w napisie bardziej złożone wyrażenie, np. wartość komórki tablicy asocjacyjnej (patrz lekcja 9.) czy właściwość obiektu (patrz rozdział 5.). Wtedy tym bardziej PHP nie jest w stanie rozpoznać, co jest częścią wyrażenia, a co częścią napisu. W takiej sytuacji można albo rozbić ciąg i składać go z mniejszych części (tak jak zostało to pokazane w poprzednim punkcie lekcji), albo też użyć składni z nawiasem klamrowym. Wystarczy ująć w nawias klamrowy wyrażenie, które ma być przetworzone przez PHP na jego wartość. W przypadku zwykłej zmiennej wyglądałoby to np. tak: echo "abc{$liczba}def";

Efektem działania takiej instrukcji będzie (zakładając powyższą wartość zmiennej $liczba) ciąg znaków: abc1.4def

Przykład użycia takiej składni do odczytania wartości komórki tablicy zostanie przedstawiony w lekcji 9.

Która metoda jest szybsza? Do wyświetlania ciągów znaków na ekranie zwykle używana jest instrukcja echo. Jednak może być używana na kilka sposobów — jest to związane z różnymi sposobami tworzenia napisów i różnymi postaciami tej instrukcji (była o tym mowa w lekcji 4.). Załóżmy np., że w kodzie mamy trzy zmienne — jedną całkowitą, jedną rzeczywistą i jeden ciąg znaków — utworzone następująco: $zmienna1 = 1.7894321; $zmienna2 = 154643212; $zmienna3 = 'abcdEFGH';

Wartości są przykładowe i nie mają formalnego znaczenia. Chcielibyśmy teraz wyświetlić je na ekranie wewnątrz innego ciągu znaków w taki sposób, że ciąg będzie przeplatany wartościami zmiennych, np. tak: pierwsza: 1.7894321 druga: 154643212 trzecia: abcdEFGH koniec

To typowa czynność często wykonywana przy programowaniu w PHP na potrzeby WWW. To zadanie może być wykonane na kilka sposobów. Najwygodniejsze wydaje się użycie składni ze znakami cudzysłowu. Instrukcja echo przyjmie wtedy postać: echo "pierwsza: $zmienna1 druga: $zmienna2 trzecia: $zmienna3 koniec";

Wiadomo, że wartości zmiennych zostaną zamienione na odpowiadające im wartości, bowiem PHP dokona interpretacji takiego ciągu. Drugi sposób to ręczne składanie wartości całego ciągu za pomocą operatora łączenia łańcuchów. Wtedy instrukcja wyglądałaby następująco: echo 'pierwsza: '.$zmienna1.' druga: '.$zmienna2.' trzecia: '.$zmienna3.' koniec ';

Rozdział 2. ♦ Elementy języka

145

W tym przypadku zmienne będą konwertowane do typu string i doklejane do pozostałych fragmentów ciągu. Trzeci sposób to oddzielenie poszczególnych składowych instrukcji echo za pomocą przecinków. Przy takim zapisie otrzymalibyśmy wiersz: echo 'pierwsza: ', $zmienna1, ' druga: ', $zmienna2, ' trzecia: ', $zmienna3,' koniec ';

Wszystkie wymienione konstrukcje były już używane w przykładach z dotychczasowych lekcji, choć najczęściej stosowany był zapis ze znakami cudzysłowu. To jednak nie wszystko. Czwartym sposobem jest skorzystanie ze składni heredoc. Wystarczy przygotować dodatkową zmienną, np.: $str = <<
oraz użyć jej w instrukcji echo: echo $str;

Tego rozwiązania nie używa się jednak do wyprowadzania prostych ciągów znaków, gdyż nie do tego jest przeznaczone i po prostu nie byłoby to wygodne. Pytanie jednak brzmi: który z tych sposobów jest najszybszy? Dosyć powszechna jest opinia, że najwydajniejsza jest wersja z użyciem znaków apostrofu oraz operatora łączenia łańcuchów znakowych (.), gdyż PHP nie musi wtedy dokonywać interpretacji całego ciągu, tak jak ma to miejsce w przypadku składni ze znakami cudzysłowu, a także heredoc. W internecie można też znaleźć sugestie, że najszybsze jest użycie znaków przecinka, a najwolniejsza to składnia heredoc. Niestety wszystkie te opinie nie są prawdziwe, czy też nie do końca prawdziwe. Przede wszystkim zależy to od używanej wersji PHP, a w pewnym stopniu również od środowiska systemowego, w którym działa PHP. Pewne różnice w wydajności uwidaczniają się także wówczas, gdy zmieniamy kod testowy, w tym rodzaj i liczbę przetwarzanych zmiennych, długości ciągów itp. Najlepiej przeprowadzić własne testy, np. z użyciem kodu obliczającego czas wykonywania skryptu, przedstawionego w poprzedniej lekcji. Na przyklad dla PHP w wersji 5.3 działającej w środowisku Windows (kompilacja narzędziem VC6) oraz zmiennych przedstawionych w tym punkcie lekcji najszybsza okazuje się składnia heredoc, natomiast sposoby z użyciem znaków cudzysłowu i apostrofu (wraz z operatorem łączenia łańcuchów) są praktycznie równie szybkie, z niewielką (wręcz nieistotną) przewagą składni ze znakami cudzysłowu (na poziomie setnych części sekundy przy pełnym czasie wykonania rzędu 8 sekund). Z kolei instrukcja echo, w której do oddzielenia poszczególnych składowych ciągu zostały użyte znaki przecinka, jest kilkakrotnie wolniejsza od wszystkich pozostałych (zatem lepiej jej nie stosować).

146

PHP5. Praktyczny kurs

Formatowanie ciągów Podczas pracy z ciągami często trzeba je sformatować tak, aby mogły być prezentowane w określony sposób. Istnieje wiele funkcji formatujących, skupimy się na kilku przydatnych na początku nauki PHP. Najpierw zajmijmy się problemem wyświetlania akapitów tekstowych w przeglądarce. Jeżeli łańcuch znaków zawiera znaki końca linii, chcielibyśmy zapewne, aby w taki sam sposób był również prezentowany użytkownikowi. Przeglądarki jednak nie uwzględniają takiego sposobu formatowania i wyświetlają tego typu ciąg tak, jakby nie był podzielony na poszczególne wiersze. Możemy sobie poradzić z tym problemem, dodając znaczniki
(lub
), tak jak to miało wielokrotnie miejsce we wcześniejszych przykładach. Trudno jednak zastosować taką operację w przypadku dłuższego tekstu, np. wczytanego z pliku czy bazy danych. W takiej sytuacji można wykorzystać funkcję nl2br, która wykona za nas to zadanie, a konkretnie przed każdym znakiem końca linii wstawi znacznik
27. Jej wywołanie ma postać: nl2br("ciąg_znaków")

Oryginalny ciąg znaków nie jest przy tym modyfikowany, funkcja natomiast zwraca jego przetworzoną postać. Aby się przekonać o tym, jak zostanie wyświetlony zwykły ciąg, a jak ten po przetworzeniu przez nl2br, wystarczy uruchomić kod z listingu 2.68. Efekt jest widoczny na rysunku 2.39. Listing 2.68. Sposób wykorzystania funkcji nl2br Przed użyciem funkcji nl2br:
"); echo $str; echo "

Po użyciu funkcji nl2br:
"; echo nl2br($str); ?>

Jeśli chcemy dokładnie określić, w jaki sposób różne wartości mają być przedstawiane użytkownikowi, możemy skorzystać z funkcji printf. Jej wywołanie ma postać: printf("format"[, argument1[, argument2[, ..., argumentN]]])

format jest ciągiem formatującym i określa, w jaki sposób będą prezentowane argumenty. Ogólna postać tego ciągu to: %[z]['wypełnienie][-][długość][precyzja]kod

27

W wersjach PHP przed 4.0.5 był to znacznik
.

Rozdział 2. ♦ Elementy języka

147

Rysunek 2.39. Efekt zastosowania funkcji nl2br

Znaczenie poszczególnych elementów jest następujące:  % — znak rozpoczynający ciąg formatujący.  z — określenie znaku wartości; można użyć znaku + lub -.  wypełnienie — znak, który zostanie użyty jako wypełnienie.  – — znak określający, że ciąg wynikowy ma być wyrównywany do lewej

strony (domyślnie ciąg wyrównywany jest w prawo).  długość — wartość określająca długość ciągu wynikowego.  precyzja — wartość określająca liczbę miejsc po przecinku, o ile argument

ma być traktowany jako wartość rzeczywista.  kod — kod określający, w jaki sposób ma być traktowany argument. Możliwe

do zastosowania kody zostały przedstawione w tabeli 2.23. Na początku wygląda to nieco skomplikowanie, wykonajmy jednak prosty przykład, który lepiej nam uzmysłowi sposób działania ciągu formatującego. Spójrzmy na listing 2.69. Zawiera on skrypt pokazujący, w jaki sposób jest interpretowana jedna wartość, jeśli do jej formatowania są wykorzystywane różne kody formatujące. Efekt działania kodu został zaprezentowany na rysunku 2.40. Listing 2.69. Wykorzystanie różnych ciągów formatujących dla tej samej wartości

ciągu ciągu ciągu ciągu ciągu ciągu ciągu ciągu ciągu ciągu ciągu ciągu

%%b %%c %%d %%e %%E %%f %%F %%o %%s %%u %%x %%X

= = = = = = = = = = = =

%b

/>", />", />", />", />", />", />", />", />", />", />", />",

$wartosc); $wartosc); $wartosc); $wartosc); $wartosc); $wartosc); $wartosc); $wartosc); $wartosc); $wartosc); $wartosc); $wartosc);

148

PHP5. Praktyczny kurs

Tabela 2.23. Kody formatujące dla funkcji printf Kod

Znaczenie

%

Znak procentów

b

Argument będzie traktowany jako typ całkowity (integer) i prezentowany jako liczba binarna.

c

Argument będzie traktowany jako typ całkowity (integer) i prezentowany jako znak ASCII o danym kodzie.

d

Argument będzie traktowany jako typ całkowity (integer) i prezentowany jako liczba dziesiętna ze znakiem.

e

Argument traktowany jako wartość w notacji wykładniczej (naukowej). Użyta zostanie mała litera e.

E

Argument traktowany jako wartość w notacji wykładniczej (naukowej). Użyta zostanie wielka litera E.

f

Argument będzie traktowany jako typ rzeczywisty (float) i prezentowany jako liczba zmiennopozycyjna z uwzględnieniem ustawień lokalnych (narodowych).

F

Argument będzie traktowany jako typ rzeczywisty (float) i prezentowany jako liczba zmiennopozycyjna bez uwzględniania ustawień lokalnych (narodowych).

o

Argument będzie traktowany jako typ całkowity (integer) i prezentowany jako liczba ósemkowa.

s

Argument będzie traktowany jako typ łańcuchowy (string) i prezentowany jako ciąg znaków.

u

Argument będzie traktowany jako typ całkowity (integer) i prezentowany jako liczba dziesiętna bez znaku.

x

Argument będzie traktowany jako typ całkowity (integer) i prezentowany jako liczba szesnastkowa z małymi literami a – f.

X

Argument będzie traktowany jako typ całkowity (integer) i prezentowany jako liczba szesnastkowa z wielkimi literami A – F.

Rysunek 2.40. Wynik działania skryptu 2.69

Rozdział 2. ♦ Elementy języka

149

Każdy ciąg formatujący w postaci %kod jest zamieniany na odpowiadającą mu wartość. Zauważmy, że zgodnie z zawartością tabeli 2.23 ciągiem formatującym jest również %% i oznacza znak procentu, zatem zapis %%b oznacza wyświetlenie znaku procentu i następującego po nim znaku b. Każde wywołanie funkcji printf powoduje przedstawienie wartości zmiennej $wartosc pod inną postacią. W przypadku pierwszym jest ona interpretowana jako wartość typu integer i wyświetlana w postaci binarnej. W przypadku drugim wyświetlany jest znak o kodzie ASCII równym wartości zapisanej w zmiennej $wartosc. W przypadku trzecim, dziewiątym i dziesiątym wartość zmiennej jest wyświetlana w postaci liczby całkowitej, a w przypadku szóstym i siódmym jako wartość rzeczywista. W przypadku czwartym i piątym zastosowana została notacja wykładnicza. W przypadku ósmym wyświetlona została wartość ósemkowa, a w przypadku dziewiątym ciąg znaków. Przypadek jedenasty i dwunasty to wyświetlenie wartości zmiennej w postaci liczby szesnastkowej. Po takim wstępie możemy przejść do bardziej zaawansowanych konstrukcji formatujących. Załóżmy np., że chcemy wyświetlać liczby całkowite od 1 do 999 w taki sposób, aby dana wartość zawsze składała się z trzech cyfr, a wolne miejsca były wypełniane zerami. Przykładowo wartość 1 ma być prezentowana jako 001, a 15 jako 015. W takim wypadku należy zastosować ciąg formatujący: %'03d

np.: printf("%'03d", 15);

Gdybyśmy chcieli, aby znakiem wypełniającym było podkreślenie, a dopełnianie do trzech znaków odbywało się z prawej strony, musielibyśmy zastosować ciąg formatujący w postaci: %'_-3d

np.: printf("%'_-3d", 15);

Bardzo użyteczne jest stosowanie ciągów formatujących w przypadku wyświetlania wartości rzeczywistych, gdyż można wtedy określić precyzję (liczbę miejsc po przecinku), z jaką dana wartość ma być wyświetlana. Jeśli na przykład chcemy wyświetlać dane z dokładnością do dwóch miejsc po przecinku, możemy zastosować ciąg: %.2f

np.: printf("%.2f", 10.454647);

W przypadku wartości rzeczywistych można również stosować wypełnienie zerami lub innymi znakami, należy tylko pamiętać, że dotyczy ono całego ciągu. Jeśli zatem mamy mieć przykładowe trzy miejsca po przecinku i trzy miejsca dziesiętne, to razem z separatorem dziesiętnym cały ciąg będzie musiał mieć 7 znaków, a zatem trzeba stosować uzupełnienie do siedmiu: %'07.3f

150

PHP5. Praktyczny kurs

np. printf("%'07.3f", 10.454647);

Równie przydatnymi operacjami są zmiany wielkości liter w ciągach. Najczęściej stosuje się zmianę wszystkich liter na małe bądź na wielkie, jednak istnieją też inne możliwości. Funkcje wykonujące tego typu zadanie zostały przedstawione w tabeli 2.24. Sposób ich wykorzystania zaprezentowano w skrypcie z listingu 2.70, a efekt jego działania jest widoczny na rysunku 2.41. Tabela 2.24. Funkcje zmieniające wielkość liter Nazwa funkcji Opis

Przykład wywołania

strtolower

Przetwarza ciąg przekazany w postaci argumentu w taki sposób, że wszystkie litery zostaną zamienione na małe. Zwraca ciąg wynikowy.

$str = strtolower($str)

strtoupper

Przetwarza ciąg przekazany w postaci argumentu w taki sposób, że wszystkie litery zostaną zamienione na wielkie. Zwraca ciąg wynikowy.

$str = strtoupper($str)

ucfirst

Przetwarza ciąg przekazany w postaci argumentu w taki sposób, że pierwsza litera zostanie zamieniona na wielką. Zwraca ciąg wynikowy.

$str = ucfirst($str)

ucwords

Przetwarza ciąg przekazany w postaci argumentu w taki sposób, że wszystkie pierwsze litery wyrazów zostaną zamienione na wielkie. Zwraca ciąg wynikowy.

$str = ucwords($str)

Listing 2.70. Wykorzystanie funkcji zmieniających wielkość liter Po użyciu funkcji strtolower: "; echo strtolower($str); echo "
Po użyciu funkcji strtoupper: "; echo strtoupper($str); echo "
Po użyciu funkcji ucfirst: "; echo ucfirst($str); echo "
Po użyciu funkcji ucwords: "; echo ucwords($str); ?>

Oprócz wymienionych wyżej wykorzystuje się również funkcje usuwające z początków i końców ciągów tzw. białe znaki. Tego typu przetwarzanie ma miejsce najczęściej wtedy, gdy odbieramy dane z formularzy bądź też wczytujemy je z plików czy baz danych. Użyteczne funkcje to trim, ltrim i rtrim. Usuwają one następujące znaki:

Rozdział 2. ♦ Elementy języka

151

Rysunek 2.41. Efekt wykorzystania funkcji ze skryptu 2.70

 " " — znak spacji o kodzie 32 (0x20 szesnastkowo),  \t — znak tabulacji o kodzie 9,  \n — znak nowej linii o kodzie 10 (0x0A szesnastkowo),  \r — znak powrotu karetki (z ang. carriage return) o kodzie 13

(0x0D szesnastkowo),  \0 — znak o kodzie 0,  \0x0B — znak tabulacji pionowej o kodzie 11.

Funkcja trim usuwa wymienione znaki z początku i z końca ciągu, funkcja ltrim — tylko z początku, a funkcja rtrim — tylko z końca. Zamiast rtrim można również użyć nazwy chop, co ma identyczne znaczenie. Wszystkie funkcje przyjmują jako argument ciąg do przetworzenia i zwracają ciąg przetworzony. W przypadku gdy chcemy usuwać inne znaki niż wymienione wyżej, należy zastosować drugi parametr wywołania. Taka konstrukcja ma następującą postać: nazwa_funkcji("ciąg_przetwarzany", "znaki_do_usunięcia");

Oba argumenty są typu string. Czyli jeśli chcielibyśmy usuwać znaki (, ) i *, drugi argument miałby postać "()*". Przykładowy sposób działania trim, ltrim i rtrim został przedstawiony na listingu 2.71. Listing 2.71. Zastosowanie funkcji usuwających znaki z początku i końca ciągu "; echo "-$str-"; $str = ltrim($str); echo "
Po wywołaniu ltrim(\$str):
"; echo "-$str-"; $str = rtrim($str); echo "
Po wywołaniu rtrim(\$str):
"; echo "-$str-"; $str = trim($str, "_. "); echo "
Po wywołaniu trim(\$str, \"_. \"):
"; echo "-$str-"; ?>

152

PHP5. Praktyczny kurs

Przetwarzanie ciągów znaków Jeśli chcemy wymienić część łańcucha znaków na inny, możemy zastosować jedną z funkcji zamieniających podciągi: str_replace, str_ireplace, substr_replace lub strtr. Zobaczmy, do czego służą i jakie występują między nimi różnice. Zaczniemy od najczęściej wykorzystywanej funkcji str_replace, której schematyczne wywołanie ma postać: str_replace(str1, str2, str3[, &$ile]);

Funkcja ta zwraca ciąg str3 przetworzony w taki sposób, w którym wszystkie wystąpienia ciągu str1 zostały zamienione na ciąg str2. Przykładowe wywołanie: $str = str_replace("%imie%", "Ala", "%imie% ma kota.");

Jeżeli będzie podany opcjonalny argument ile, zostanie w nim zapisana liczba dokonanych zmian. Uwaga! Ten argument musi być przekazany przez referencję (por. punkt „Sposoby przekazywania argumentów” w lekcji 6.), a więc musi być wcześniej utworzoną zmienną, np.: $liczba_zmian = 0; $str = str_replace("Ala", "Ola", "Ala ma kota. Ala ma psa.", $liczba_zmian); echo "Liczba dokonanych zmian w ciągu: $liczba_zmian";

Każdy z argumentów str_replace może być również tablicą (czytelnicy, którzy nie mieli styczności z tablicami, powinni najpierw zajrzeć do lekcji 9.), co znacznie rozszerza możliwości funkcji. Niektóre z nich zilustrowano w kodzie widocznym na listingu 2.72. Listing 2.72. Wykorzystanie możliwości funkcji str_replace "; $str = str_replace($arr1, "Magda", "%imie1% ma kota. %imie2% ma psa."); echo "$str
"; $str = str_replace("%imie1%", "Ela", $arr3); foreach($str as $word) echo("$word "); ?>

Wynikiem działania skryptu będą trzy ciągi znaków: Ala ma kota. Ola ma psa. Magda ma kota. Magda ma psa. Ela ma kota.

W pierwszym przypadku wymieniane ciągi zawarte są w tablicy $arr1, a zatem są to %imie1% i %imie2%. Ciągi podstawiane zamiast nich są natomiast zawarte w tablicy $arr2,

Rozdział 2. ♦ Elementy języka

153

a więc są to Ala i Ola. W przypadku drugim wszystkie ciągi, które będą wymieniane, zawarte są w tablicy $arr1, natomiast ciąg, na który będą one wymieniane, to Magda. Przypadek trzeci jest nieco odmienny. Tym razem zamiana ciągów jest wykonywana w tablicy, każdy występujący w niej ciąg %imie1% jest zamieniany na Ela. W tym przypadku funkcja zwróci również nie ciąg wynikowy, ale tablicę wynikową, stąd do wyświetlenia zawartości na ekranie została wykorzystana pętla foreach. Odmianą funkcji str_replace jest str_ireplace. Można się domyślić, że jej działanie jest analogiczne do str_replace, nie bierze ona jednak pod uwagę wielkości liter (litera i w nazwie funkcji pochodzi od ang. zwrotu case-insensitive). Kolejną funkcją zamieniającą podciągi znaków jest substr_replace o schematycznej postaci: substr_replace(str1, str2, start[, ile]);

Zwraca ona ciąg str1, z którego począwszy od znaku o indeksie start, zostało wycięte ile znaków, a w powstałe miejsce został wstawiony ciąg str2. Parametr start może być dodatni lub ujemny. W tym drugim przypadku pozycja startowa obliczana jest od końca ciągu str1. Parametr ile jest opcjonalny. Jeśli go nie ma, są usuwane wszystkie znaki od indeksu start do końca ciągu str1. Jeśli parametr ile jest obecny i jest dodatni, określa liczbę wycinanych znaków. Jeśli parametr ile jest obecny i jest ujemny, określa, ile znaków z końca ciągu str1 ma być uwzględnionych w ciągu wynikowym. Kilka przykładowych wywołań funkcji substr_replace z różnymi argumentami zostało przedstawionych w skrypcie na listingu 2.73, a efekt działania tego kodu — na rysunku 2.42. Listing 2.73. Ilustracja sposobu działania funkcji substr_replace substr_replace(\"123456\", \"abc\", 2) = "; echo substr_replace("123456", "abc", 2); echo "
substr_replace(\"123456\", \"abc\", -3, 2) = "; echo substr_replace("123456", "abc", -3, 2); echo "
substr_replace(\"123456\", \"abc\", -3) = "; echo substr_replace("123456", "abc", -3); echo "
substr_replace(\"123456\", \"abc\", 2, -3) = "; echo substr_replace("123456", "abc", 2, -3); echo "
substr_replace(\"123456\", \"abc\", -5, -1) = "; echo substr_replace("123456", "abc", -5, -1); ?>

Na zakończenie wspomnijmy jeszcze jedną z funkcji — strtr. Jej schematyczne wywołanie to: strtr(str, znaki1, znaki2)

154

PHP5. Praktyczny kurs

Rysunek 2.42. Efekt przykładowych wywołań funkcji substr_replace

Zwraca ona ciąg str, w którym znaki zawarte w znaki1 zostały zamienione na odpowiadające im znaki z ciągu znaki2. Jeśli chcielibyśmy na przykład usunąć z dowolnego ciągu wszystkie pisane małymi literami tzw. polskie znaki i zamienić je na łacińskie odpowiedniki, należałoby zastosować wywołanie: $str = strtr("przykładowy ciąg", "ąćęłńóśżź", "acelnoszz")

Po wykonaniu tej instrukcji zmiennej $str zostanie zapisany ciąg "przykładowy ciąg" niezawierający polskich liter ("przykladowy ciag"). Gdy potrzebne jest uzyskanie fragmentu jakiegoś ciągu, można użyć funkcji substr. Jej schematyczne wywołanie ma postać: substr(str, start[, ile])

Funkcja zwraca fragment ciągu str rozpoczynający się od indeksu start (uwaga: indeks pierwszego znaku to 0!) i zawierający liczbę znaków wskazywaną przez argument ile. Przykładowe wywołanie: $str = substr("abc123", 1, 4);

spowoduje zatem przypisanie zmiennej $str ciągu bc12.

Porównania Kolejnymi czynnościami niezbędnymi do sprawnej pracy z PHP są porównania ciągów. Mogą być one wykonywane zarówno za pomocą operatorów porównywania zaprezentowanych w tabeli 2.15 w lekcji 4., jak i funkcji porównujących. Jedną z takich funkcji jest strcmp, której wywołanie ma schematyczną postać: strcmp("ciąg1", "ciąg2")

Zwraca ona wartość mniejszą od 0, jeśli ciąg1 jest mniejszy niż ciąg2; większą od 0, jeśli ciąg1 jest większy od ciąg2, lub 0, jeśli ciągi są sobie równe. Porównywanie odbywa się według porządku leksykograficznego, czyli przykładowo:  Ciąg abc jest mniejszy niż abd.  Ciąg edf jest większy niż abc.  Ciąg Abc jest większy niż abc.

Rozdział 2. ♦ Elementy języka

155

 Ciąg abc jest mniejszy niż aBc.  Ciąg 52 jest większy (!) niż 152.

Funkcją podobną do strcmp jest strcasecmp. Działa ona w prawie identyczny sposób, lecz nie bierze pod uwagę wielkości liter. Obie wymienione funkcje mają również swoje odmiany, które pozwalają na zdefiniowanie, ile znaków z pierwszego i drugiego ciągu będzie podlegało porównywaniu. Są to: strncmp i strncasecmp. Wywołanie strncmp (i analogicznie strncasecmp) ma schematyczną postać: strncmp("ciąg1", "ciąg2", ile)

Parametr ile określa tu liczbę porównywanych znaków. Zarówno strncmp, jak i strncasecmp zwraca wartość mniejszą od 0, jeśli ciąg1 jest mniejszy niż ciąg2; wartość większą od 0, jeśli ciąg1 jest większy od ciąg2, lub 0, jeśli ciągi są sobie równe. Ponieważ porządkowanie leksykograficzne nie zawsze daje wyniki zgodne z intuicją człowieka, w PHP4 wprowadzono dodatkowe funkcje, które umożliwiają porównywanie zgodne z tzw. porządkiem naturalnym (z ang. natural order). Są to strnatcmp i strnatcasecmp. Ich działanie jest analogiczne do funkcjonowania omawianych wyżej funkcji, z tą różnicą, że wykorzystywany jest inny algorytm porównujący. Zaleta porządkowania naturalnego ujawni się np. w sytuacji, gdy będziemy sortować nazwy plików zawierających ich numery. Taki przykład wykonamy jednak dopiero w lekcji traktującej o tablicach, gdzie poznamy również funkcje sortujące.

Przeszukiwanie Przeszukiwanie ciągów to kolejna przydatna operacja. Na jej wykonywanie pozwala cały zestaw funkcji, są to m.in.: strpos, strrpos, stripos, strripos, strstr i stristr. Funkcja strpos zwraca numer pierwszej pozycji poszukiwanego ciągu. Jej wywołanie ma postać: strpos("ciąg przeszukiwany", "ciąg poszukiwany"[, start])

Przeszukiwanie rozpoczyna się od początku ciągu lub od pozycji wskazywanej przez opcjonalny argument start (o ile jest obecny). Przy tym pozycje ciągu przeszukiwanego numerowane są od 0 (czyli pierwsza litera znajduje się na zerowej pozycji). Przykładowe wywołanie: $pos = strpos("abcdefg", "cde");

spowoduje przypisanie zmiennej $pos wartości 2. Odmianą strpos jest stripos. Działa ona prawie identycznie jak strpos, lecz nie rozróżnia wielkości liter. Jeśli chcemy przeszukiwać ciągi od końca, czyli uzyskać pozycję ostatniego wystąpienia poszukiwanego ciągu, należy skorzystać z funkcji strrpos lub strripos. Przykładowe wywołanie: $pos = strrpos("abcdabcd", "ab");

156

PHP5. Praktyczny kurs

spowoduje przypisanie zmiennej pos wartości 4. Funkcja strripos działa tak samo jak strrpos, nie rozróżnia jedynie wielkości liter. Jeżeli w przeszukiwanym ciągu nie ma poszukiwanego, każda z wymienionych funkcji zwraca wartość false typu boolean. Na tę kwestię należy zwrócić szczególną uwagę, aby nie doprowadzić do powstania błędów w skrypcie wykorzystującym te funkcje. Przeanalizujmy poniższy fragment kodu:

Chcemy sprawdzić, czy ciąg zapisany w zmiennej $str2 znajduje się w ciągu $str1. Wykorzystujemy zatem instrukcję warunkową if oraz fakt, że funkcja strpos w przypadku nieznalezienia poszukiwanego ciągu zwraca wartość false. Jeśli jednak uruchomimy powyższy kod, będziemy zaskoczeni. Wyświetlony zostanie napis stwierdzający, że ciągu ab nie ma w abcdabcd, co jest oczywistą nieprawdą. Dlaczego tak się dzieje? Wyjaśnienie kryje się w odpowiedzi na inne pytanie: jaką wartość zwraca wywołanie funkcji strpos z argumentami $str1 i $str2? Skoro ciąg przeszukiwany zawarty w $str1 zawiera łańcuch "abcdabcd", natomiast ciąg szukany $str2 zawiera łańcuch "ab", wywołanie strpos($str1, $str2) musi zwrócić wartość 0, ciąg ab występuje bowiem na samym początku ciągu abcdabcd (a numerowanie pozycji w tym ciągu zaczyna się od zera; pierwsza litera jest na pozycji zerowej). Co się zatem dzieje w instrukcji warunkowej if? Sprawdzany jest warunek 0 == false. Bezpośrednie porównanie jest niemożliwe, gdyż po lewej stronie występuje typ całkowity, a po prawej — boolean. Ponieważ jednak wynikiem porównania ma być wartość typu boolean (true lub false), lewy argument jest konwertowany do typu boolean. Konwersja wartości całkowitej 0 do typu boolean daje wartość false (por. opis konwersji typów w lekcji 4.). Ostatecznie sprawdzany jest warunek false == false, który jest prawdziwy! Dlatego też na ekranie zostanie wyświetlona nieprawdziwa informacja. Jeśli zatem chcemy korzystać z tego typu wywołań funkcji strpos (a także wszystkich od niej pochodnych opisanych w tej części lekcji), należy korzystać z operatorów === lub !== (czyli identyczny — nieidentyczny, por. opis operatorów w lekcji 4.). Te operatory sprawdzają zgodność nie tylko wartości, ale również typów. Prawidłowy warunek instrukcji if sprawdzającej, czy ciąg zawarty w $str2 występuje w ciągu znajdującym się w str1, będzie miał więc postać: (strpos($str1, $str2) === false)

Oprócz opisanych wyżej istnieją jeszcze dwie inne przydatne funkcje przeszukujące ciągi — strstr i stristr. Jak łatwo się domyślić, stristr to odmiana funkcji strstr,

Rozdział 2. ♦ Elementy języka

157

która nie uwzględnia wielkości znaków. Wywołanie strstr ma podobną postać do strpos, czyli: strstr("ciąg przeszukiwany", "ciąg poszukiwany"[, przed])

Inne jest natomiast jej działanie. Otóż zwraca ona część przeszukiwanego ciągu, która rozpoczyna się od ciągu poszukiwanego. Przykładowe wywołanie: $str = strstr("abcdefg", "de");

spowoduje przypisanie zmiennej $str wartości defg. Jeżeli zostanie podany opcjonalny trzeci argument i będzie miał wartość true, zwrócona zostanie część ciągu przeszukiwanego, która znajduje się przed ciągiem poszukiwanym. Przykładowe wywołanie: $str = strstr("abcdefg", "de", true);

spowoduje zatem przypisanie zmiennej $str wartość abc. W przypadku gdy drugi argument nie będzie typu string, zostanie on najpierw skonwertowany do typu int, a następnie potraktowany jako kod znaku. Przykładowo wywołanie: $str = strstr("[email protected]", 64);

spowoduje przypisanie zmiennej $str wartości @domena.com, gdyż 64 jest kodem ASCII znaku @.

Ćwiczenia do samodzielnego wykonania Ćwiczenie 8.1. Napisz funkcję, która będzie przetwarzała ciąg znaków w taki sposób, że wszystkie małe litery zostaną zamienione na wielkie, a wielkie na małe. Ćwiczenie 8.2. Napisz funkcję, która będzie pozwalała na konwersję polskich znaków między standardami ISO-8859-2 i Windows-1250. Ćwiczenie 8.3. Napisz funkcję wykonującą cenzurowanie tekstu. Powinna ona przyjmować dwa argumenty, z których pierwszym byłby ciąg podlegający cenzurowaniu, a drugim tablica zawierająca niepożądane zwroty. Każdy zwrot znajdujący się w tablicy powinien zostać zamieniony w tekście na ciąg [ocenzurowano]. Ćwiczenie 8.4. Napisz funkcję, która będzie przyjmowała jako argument ciąg znaków określający adres HTTP i będzie zwracała odnośnik HTML (znacznik ) do tego adresu. Ćwiczenie 8.5. Napisz funkcję, która będzie obliczała liczbę wystąpień określonego ciągu znaków w danym tekście. Tekst i szukany ciąg znaków powinny być przekazywane w postaci argumentów. Nie używaj funkcji substr_count.

158

PHP5. Praktyczny kurs

Lekcja 9. Tablice Proste tablice Tablice są to struktury danych pozwalające na przechowywanie uporządkowanego zbioru elementów. Najprostszą tablicę można sobie wyobrazić jako wektor elementów, taki jak zaprezentowany na rysunku 2.43. Poszczególne pola danych nazywamy wtedy komórkami, a każda z nich ma identyfikujący ją indeks (mówimy wtedy o tablicach indeksowanych numerycznie) i może zawierać pewną wartość. Pierwsza komórka (zawierająca wartość 1) ma indeks 0, druga — indeks 1, trzecia — indeks 2 itd. Rysunek 2.43. Struktura prostej tablicy

W celu utworzenia tablicy używamy słowa kluczowego array. Taka konstrukcja ma schematyczną postać: $tablica = array(wartość1, wartość2,..., wartośćN);

$tablica to zmienna typu tablicowego, dzięki której będziemy mogli się do tej struktury odwoływać, natomiast wartość1, wartość2 itd. to wartości znajdujące się w kolej-

nych komórkach. W celu zwiększenia czytelności w przypadku dużej liczby wartości można również zastosować zapis w postaci: $tablica = array( wartość1, wartość2, ..., wartośćN);

Przekonajmy się, jak to będzie wyglądało w praktyce. Spójrzmy na kod z listingu 2.74. Została w nim utworzona trójelementowa tablica, której kolejnym komórkom zostały przypisane ciągi znaków określające kolory: czerwony, zielony oraz niebieski i która została przypisana zmiennej $kolory. Upraszczając terminologię, można powiedzieć, że powstała tablica $kolory. Listing 2.74. Utworzenie tablicy "; echo "kolory[1] = ", $kolory[1], "
"; echo "kolory[2] = ", $kolory[2], "
"; ?>

Aby uzyskać dostęp do wartości zapisanej w danej komórce, należy podać jej numer (indeks) w nawiasie kwadratowym występującym za nazwą tablicy. Należy przy tym

Rozdział 2. ♦ Elementy języka

159

pamiętać, że indeksowanie tablicy zaczyna się od 0, co oznacza, że indeksem pierwszej komórki jest 0, a NIE 1. A zatem aby odczytać zawartość pierwszej komórki, napisaliśmy $kolory[0], drugiej — $kolory[1], a trzeciej — $kolory[2]. Dzięki temu po uruchomieniu skryptu na ekranie zobaczymy widok przedstawiony na rysunku 2.44. Rysunek 2.44. Zawartość tablicy $kolory

Jeśli tablica ma duży rozmiar, do odczytu jej zawartości lepiej użyć pętli. Może być to zarówno zwykła pętla for, jak i pętla typu foreach. Oba sposoby zostały zaprezentowane na listingu 2.75. W pierwszym przypadku zmienna iteracyjna $i, która zmienia się w przedziale 0 – 2, jest wykorzystywana jako indeks tablicy, w drugim przypadku pod zmienną $kolor w każdym kolejnym przebiegu pętli jest podstawiana wartość kolejnej komórki aż do osiągnięcia ostatniej komórki. Listing 2.75. Użycie pętli do odczytu zawartości tablicy "; } echo "
"; foreach($kolory as $kolor){ echo $kolor, "
"; } ?>

Warto wiedzieć, że ze względu na specyficzną budowę tablic w PHP wartości w poszczególnych komórkach tablicy nie muszą być tego samego typu (w odróżnieniu od wielu innych języków programowania). Prawidłowa będzie zatem konstrukcja w postaci: $tab = array("czerwony", 10, 1.14);

W takim przypadku tablica $tab będzie zawierała trzy dane: łańcuch znaków, wartość całkowitą oraz wartość rzeczywistą. Nie ma również konieczności, aby wypełniać tablice danymi już podczas ich tworzenia. Mogą być one także przypisywane w dalszej części skryptu. Zamiast na przykład pisać: $kolory = array("czerwony", "zielony", "niebieski");

można wykorzystać serię instrukcji w postaci: $kolory = array(); $kolory[0] = "czerwony";

160

PHP5. Praktyczny kurs $kolory[1] = "zielony"; $kolory[2] = "niebieski";

W ten sam sposób można również zmieniać zawartość poszczególnych komórek, tak jak zostało to przedstawione w skrypcie na listingu 2.76. Listing 2.76. Zmiana zawartości komórek tablicy "); for($i = 0; $i < 3; $i++){ $kolor = $kolory[$i]; echo "kolory[$i] = $kolor
"; } $kolory[0] = "żółty"; $kolory[1] = "fioletowy"; $kolory[2] = "czarny"; echo("
Zawartość tablicy po zmianach:
"); for($i = 0; $i < 3; $i++){ $kolor = $kolory[$i]; echo "kolory[$i] = $kolor
"; } ?>

W pierwszej części skryptu powstała tablica $kolory, której kolejnym indeksom są przypisywane wartości czerwony, zielony i niebieski. Po wykonaniu wymienionych operacji wykonywana jest pętla for wyświetlająca zawartość całej struktury w przeglądarce. Za pętlą znajduje się instrukcja $kolory[0] = "żółty";. Ponieważ istnieje już tablica $kolory, instrukcja ta powoduje przypisanie komórce o indeksie 0 ciągu znaków żółty. W tym momencie zostaje również utracona poprzednia zawartość tej komórki, czyli ciąg czerwony. Podobnie działają dwie kolejne instrukcje. Zamieniają występujące w tablicy wartości z komórek o indeksach 1 i 2 na ciągi znaków fioletowy i czarny. Po tych operacjach jest wykonywana druga pętla for, która wysyła do przeglądarki aktualną zawartość tablicy. Tym samym po wykonaniu skryptu zobaczymy na ekranie widok zaprezentowany na rysunku 2.45. Zwróćmy przy tym uwagę, że wielkość tablicy nie jest z góry ustalona i rośnie wraz z dodawaniem kolejnych elementów. To bardzo wygodna cecha języka. Otóż po napotkaniu instrukcji w postaci: $tablica[$indeks] = wartość;

PHP sprawdza, czy istnieje tablica $tablica oraz czy jest w niej indeks $indeks. Możliwe są trzy sytuacje: 1. Jeśli oba warunki są spełnione, elementowi wskazywanemu przez $indeks jest przypisywana wartość. Poprzednia zawartość tego elementu jest tracona.

Rozdział 2. ♦ Elementy języka

161

Rysunek 2.45. Efekt działania skryptu zmieniającego zawartość tablicy

2. Jeśli nie ma indeksu $indeks, jest on najpierw tworzony, a dopiero potem przypisuje się mu $wartość. 3. Jeśli nie ma samej tablicy, zostanie ona utworzona, a następnie wykonane

będą czynności z punktu 2. Warte podkreślenia jest również to, że nie ma konieczności przypisywania indeksów w uporządkowanej kolejności. Mogą istnieć w tablicy tylko wybrane indeksy, np.: 2, 5 i 8. Z powyższego opisu wynika również, że nie ma formalnej konieczności tworzenia tablicy za pomocą słowa array. Jeżeli w skrypcie zostanie napotkana instrukcja przypisująca dowolnemu indeksowi tablicy jakąś wartość, ale tablica o danej nazwie nie będzie istniała, zostanie ona niejawnie utworzona.

Tablice asocjacyjne Oprócz tablic indeksowanych numerycznie w PHP istnieją również tablice asocjacyjne28. W tablicach tego typu każdemu indeksowi można nadać unikalną nazwę, czyli zamiast indeksów 0, 1, 2 itd. mogą występować indeksy: kolor, autor, procesor itp. Najczęściej też zamiast terminu „indeks” stosuje się określenie „klucz”. Mówimy zatem, że w tablicy asocjacyjnej występują pary klucz – wartość, w których każdy klucz jednoznacznie identyfikuje przypisaną mu wartość. Kluczami mogą być ciągi znaków bądź wartości całkowite. Tablicę tego typu tworzy się, podobnie jak w przypadku tablic klasycznych indeksowanych numerycznie, za pomocą słowa kluczowego array, konstrukcja ta ma jednak nieco inną postać. Schematycznie wygląda to następująco: array( klucz1 => wartość1, klucz2 => wartość2, ... kluczN => wartośćN );

28

W rzeczywistości opisane w poprzedniej sekcji tablice indeksowane numerycznie to nic innego jak tablice asocjacyjne, w których kluczami są liczby całkowite.

162

PHP5. Praktyczny kurs

Na listingu 2.77 został przedstawiony krótki skrypt, który pokazuje, w jaki sposób utworzyć tablicę asocjacyjną i odczytać zapisane w niej wartości. Listing 2.77. Tworzenie tablicy asocjacyjnej "czerwony", "kolor2" => "zielony", "kolor3" => "niebieski" ); echo "Zawartość tablicy:
"; $kolory['kolor2'], "
"; $kolory['kolor3'], "
";

Została utworzona tablica $kolory zawierająca trzy klucze o nazwach kolor1, kolor2 i kolor3. Kluczowi kolor1 został przypisany ciąg znaków czerwony, kluczowi kolor2 — zielony, a kolor3 — niebieski. Dzięki temu po zastosowaniu konstrukcji w schematycznej postaci: nazwa_tablicy['nazwa_klucza']

otrzymamy wartość odpowiadającą danemu kluczowi. Ten fakt został wykorzystany do wyświetlenia zawartości tablicy w przeglądarce. Drugim ze sposobów tworzenia tablicy asocjacyjnej jest użycie składni z nawiasami kwadratowymi, podobnie jak miało to miejsce w przypadku tablic indeksowanych numerycznie. Schematycznie taka konstrukcja ma postać: $nazwa_tablicy['nazwa_klucza'] = wartość_klucza;

Utworzenie tablicy o zawartości takiej jak w skrypcie 2.77 można uzyskać przez wykonanie trzech następujących instrukcji: $kolory['kolor1'] = "czerwony"; $kolory['kolor2'] = "zielony"; $kolory['kolor3'] = "niebieski";

Do odczytu tablic asocjacyjnych można użyć pętli. Nie może być to jednak pętla typu for, gdyż nie jest ona w stanie stwierdzić, jakie są wartości kluczy. W związku z tym tablice asocjacyjne najczęściej są obsługiwane przez pętle typu foreach. Taka pętla potrafi pobrać kolejne wartości kluczy; w skrypcie widocznym na listingu 2.78 zobrazowano, jak to zrobić. Listing 2.78. Odczyt tablicy asocjacyjnej przy użyciu pętli foreach "czerwony", "kolor2" => "zielony", "kolor3" => "niebieski" );

Rozdział 2. ♦ Elementy języka

163

echo "Zawartość tablicy:
"; foreach($kolory as $kolor){ echo $kolor, "
"; } ?>

Konstrukcja tego typu pętli oznacza, że w każdym jej przebiegu pod zmienną $kolor będzie podstawiana wartość kolejnego klucza (analogicznie do przykładu z listingu 2.75). Czyli zmienna $kolor w pierwszym przebiegu pętli będzie zawierała ciąg znaków czerwony, w drugim — zielony, a w trzecim — niebieski. W momencie gdy odczytane zostaną wartości wszystkich kluczy, pętla zakończy działanie. W ten sposób uzyskamy wartości kluczy, ale nie ich nazwy. Jeśli również ta informacja jest nam potrzebna, trzeba zastosować drugą wersję pętli foreach. Będzie ona miała postać: foreach($kolory as $klucz => $kolor){ echo "\$kolory['$klucz'] = $kolor
"; }

Tym razem w każdym przebiegu pętli pod zmienną $klucz podstawiana jest nazwa kolejnego klucza, a pod zmienną $kolor przypisana mu wartość. Dzięki temu za pomocą instrukcji echo możemy wysłać do przeglądarki wszystkie istotne informacje o zawartości tablicy. Zwróćmy uwagę na zastosowanie sekwencji specjalnej \$ do wyświetlenia znaku $. Dzięki temu zapis \$kolory[' jest traktowany jako ciąg znaków, a nie jako zmienna. Interpretowany jest dopiero występujący dalej ciąg $klucz. Modyfikacji zawartości tablic asocjacyjnych dokonuje się w sposób analogiczny jak w przypadku tablic klasycznych. Oczywiście zamiast indeksów numerycznych trzeba zastosować wartości kluczy. Aby zatem przypisać nową wartość już istniejącemu kluczowi, trzeba skorzystać z konstrukcji, której schematyczna postać jest następująca: $tablica['klucz'] = wartość;

Jeśli więc istnieje tablica $kolory, a w niej klucz kolor1, to wykonanie instrukcji: $kolory['kolor1'] = 'zielony';

spowoduje zmianę jego wartości na ciąg znaków zielony.

Operacje na tablicach Wyświetlanie zawartości Gdy tworzymy ciągi znaków, korzystając ze składni ze znakami cudzysłowu, możemy w nich umieszczać nazwy zmiennych, które zostaną zamienione na odpowiadające im wartości. Sposób ten zadziała również w przypadku tablic indeksowanych numerycznie, poprawna będzie zatem instrukcja: echo("$tab[0]");

164

PHP5. Praktyczny kurs

Oczywiście musimy przy tym założyć, że istnieje tablica $tab, a w niej indeks 0. Nie zadziała to jednak w przypadku tablicy asocjacyjnej, w której kluczami są ciągi znaków, np. w przypadku prezentowanej wyżej tablicy $kolory. Instrukcja: echo("$kolory['kolor1']");

spowoduje powstanie błędu. Dzieje się tak dlatego, że $kolory['kolor1'] jest wyrażeniem złożonym i aby było ono poprawnie przetworzone, musi zostać ujęte w nawias klamrowy. Poprawna instrukcja miałaby więc postać: echo("{$kolory['kolor1']}");

Ustalanie liczby elementów Podczas pracy z tablicami często przydaje się informacja, ile mają one elementów. W jej uzyskaniu pomoże nam funkcja count29, której należy przekazać nazwę tablicy w postaci argumentu. Schematycznie: count($tablica);

Gdy poznamy rozmiar tablicy, możemy np. do wyświetlenia jej zawartości użyć pętli for zamiast foreach. Można to wykonać w sposób przedstawiony na listingu 2.79. Listing 2.79. Użycie pętli for do wyświetlenia zawartości tablicy

Sortowanie Sortowanie to czynność polegająca na ustawieniu elementów w określonym porządku, najczęściej rosnącym lub malejącym. PHP dysponuje kilkoma funkcjami sortującymi, które wykorzystujemy w zależności od tego, jakie sortowanie chcemy wykonać oraz z jakim typem tablicy mamy do czynienia — indeksowaną klasycznie czy asocjacyjną. W pierwszym przypadku, jeśli chcemy ustawić elementy w kolejności od najmniejszego do największego, użyjemy funkcji sort. Sposób jej użycia zobrazowano w skrypcie widocznym na listingu 2.80. Listing 2.80. Ilustracja wykorzystania funkcji sort "; foreach($tab1 as $val){ echo "$val "; 29

Zamiast count można również użyć sizeof, które ma identyczne znaczenie.

Rozdział 2. ♦ Elementy języka

165

} echo "
"; foreach($tab2 as $val){ echo "$val "; } sort($tab1); sort($tab2); echo "

Zawartość tablic po sortowaniu:
"; foreach($tab1 as $val){ echo "$val "; } echo "
"; foreach($tab2 as $val){ echo "$val "; } ?>

Efekt wykonania skryptu został przedstawiony na rysunku 2.46. Widać wyraźnie, że obie tablice zostały poprawnie posortowane. Oczywiście w przypadku tablicy $tab1 mieliśmy do czynienia z sortowaniem liczb i wartości zostały ustawione od najmniejszej do największej. Natomiast w przypadku tablicy $tab2 mieliśmy do czynienia z sortowaniem ciągów znaków, a zatem słowa zostały ustawione w porządku alfabetycznym (rzecz jasna, PHP nie interpretuje znaczenia słów). Rysunek 2.46. Zawartość tablic przed sortowaniem i po nim

Co jednak zrobić w sytuacji, gdybyśmy chcieli wykonać sortowanie odwrotne, czyli np. ustawić wartości z tablicy $tab1 od największej do najmniejszej? Nie ma z tym najmniejszego problemu. Zamiast sort należy wtedy użyć funkcji rsort (z ang. reverse sort), która wykona to zadanie. Przedstawiony sposób porządkowania elementów nie zadziała jednak poprawnie w przypadku tablic asocjacyjnych, gdyż funkcja sort modyfikuje oryginalne nazwy kluczy (indeksów). Aby zatem posortować tablicę asocjacyjną, musimy użyć innych funkcji. Są to asort i ksort. Pierwsza z nich sortuje tablice względem wartości poszczególnych kluczy, natomiast druga względem nazw kluczy. Zobrazowano to w kodzie widocznym na listingu 2.81. Efekt wykonania skryptu został natomiast zaprezentowany na rysunku 2.47.

166

PHP5. Praktyczny kurs

Listing 2.81. Sortowanie tablic asocjacyjnych 5, 'indeks9' => 1, 'indeks3' => 8, 'indeks5' => 2 ); echo "Zawartość tablicy przed sortowaniem:
"; foreach($tab as $key => $val){ echo("tab[$key] = $val"); echo("
"); } asort($tab); echo "
Po sortowaniu względem wartości:
"; foreach($tab as $key => $val){ echo("tab[$key] = $val"); echo("
"); } ksort($tab); echo "
Po sortowaniu względem kluczy:
"; foreach($tab as $key => $val){ echo "tab[$key] = $val"; echo "
"; } ?>

Rysunek 2.47. Efekt sortowania tablic asocjacyjnych

Rozdział 2. ♦ Elementy języka

167

Jeszcze inaczej musimy postąpić, jeśli chcemy ustawić elementy tablicy w specyficznej kolejności, odmiennej od standardowego porządku. Mamy wtedy do wyboru dwie drogi. Albo sami napiszemy całą funkcję wykonującą sortowanie, albo też wykorzystamy specjalne wersje funkcji sortujących i napisaną przez nas dodatkowo funkcję porównującą dwa elementy. Te wersje specjalne to:  usort — do sortowania tablic indeksowanych numerycznie,  uasort — do sortowania tablic asocjacyjnych względem wartości,  uksort — do sortowania tablic asocjacyjnych względem kluczy.

Wywołania wyglądają tak samo we wszystkich trzech przypadkach, dlatego też cała technika zostanie pokazana jedynie na przykładzie usort. Schematyczna konstrukcja jest następująca: usort($tablica, 'nazwa_funkcji')

tablica to nazwa tablicy, której elementy będą sortowane, a nazwa_funkcji to nazwa funkcji dokonującej porównania dwóch elementów. Ta ostatnia funkcja będzie otrzymywała w postaci argumentów dwa elementy sortowanej tablicy, musi natomiast zwracać:  Wartość mniejszą od 0, jeśli pierwszy argument jest mniejszy od drugiego.  Wartość większą od 0, jeśli pierwszy argument jest większy od drugiego.  Wartość równą 0, jeśli argumenty są sobie równe.

Napiszemy zatem przykładowy skrypt, który będzie sortował zawartość tablicy (przechowującej liczby całkowite) w taki sposób, że najpierw umieszczone będą wartości podzielne przez dwa, od najmniejszej do największej, a dopiero po nich wartości niepodzielne przez dwa, również od najmniejszej do największej. To zadanie realizuje kod z listingu 2.82. Listing 2.82. Sortowanie specjalne z użyciem funkcji usort
168

PHP5. Praktyczny kurs $tab1 = array(5, 7, 3, 1, 8, 2, 0, 4, 9, 6); echo "Zawartość tablicy przed sortowaniem:
"; foreach($tab1 as $val){ echo "$val "; } echo "
"; usort($tab1, 'sortuj'); echo "Zawartość tablicy po sortowaniu:
"; foreach($tab1 as $val){ echo "$val "; } ?>

Tablica jest tworzona w standardowy sposób, a jej początkowa zawartość jest wyświetlana na ekranie. Następnie wywoływana jest funkcja usort, która wykonuje operację sortowania, i na ekranie ponownie jest wyświetlana zawartość posortowanej tablicy. Tym samym po uruchomieniu skryptu w przeglądarce ukaże się obraz widoczny na rysunku 2.48. Jak widać, układ liczb jest zgodny z założeniami, czyli najpierw umieszczone są liczby podzielne przez dwa (od najmniejszej do największej), a za nimi liczby niepodzielne przez dwa (również od najmniejszej do największej). Za takie uporządkowanie elementów tablicy odpowiada kombinacja funkcji usort i sortuj. Rysunek 2.48. Wynik sortowania uwzględniającego podzielność liczb przez dwa

Funkcja usort realizuje algorytm sortowania typu QuickSort. Ponieważ chcemy, aby sortowanie odbywało się według niestandardowych zasad, musimy dostarczyć jej dodatkową funkcję, która będzie porównywała dwa dowolne elementy tablicy $tab1. Tą funkcją jest sortuj. Przy porównywaniu dwóch dowolnych elementów tablicy $tab1, możliwe są cztery różne sytuacje: 1. Pierwszy argument jest podzielny przez dwa (e1 % 2 równe 0) i drugi argument również jest podzielny przez dwa (e2 % 2 równe 0). W takiej

sytuacji należy zwrócić wartość mniejszą od 0, jeśli pierwszy argument jest mniejszy, większą od 0, jeśli drugi jest mniejszy, lub 0, jeśli są równe. Zapewnia to instrukcja return $e1 - $e2;. 2. Pierwszy argument jest podzielny przez dwa (e1 % 2 równe 0), a drugi nie (e2 % 2 różne od 0). W takiej sytuacji argument pierwszy zawsze powinien

znaleźć się przed drugim, a zatem należy zwrócić wartość mniejszą od 0. Zapewnia to instrukcja return -1;.

Rozdział 2. ♦ Elementy języka

169

3. Pierwszy argument nie jest podzielny przez dwa (e1 % 2 różne od 0), a drugi jest (e2 % 2 równe 0). W takiej sytuacji argument pierwszy zawsze powinien

znaleźć się za drugim, a zatem należy zwrócić wartość większą od 0. Zapewnia to instrukcja return 1;. 4. Pierwszy argument nie jest podzielny przez dwa (e1 % 2 różne od 0) i drugi argument również nie jest podzielny przez dwa (e2 % 2 różne od 0). W takiej

sytuacji należy zwrócić wartość mniejszą od 0, jeśli pierwszy argument jest mniejszy, wartość większą od 0, jeśli drugi jest mniejszy, lub wartość 0, jeśli argumenty są równe. Zapewnia to instrukcja return $e1 - $e2;. Na zakończenie rozważań o sortowaniu powróćmy do przykładu zapowiedzianego w lekcji 8. Chodziło o pokazanie różnic między porządkiem leksykograficznym (stosowanym w funkcji strcmp) a naturalnym (stosowanym w funkcji strnatcmp). Zaleta porządkowania naturalnego miała się ujawnić np. w sytuacji, gdy istnieje potrzeba sortowania nazw plików zawierających ich numery. Spójrzmy więc na kod z listingu 2.83. Listing 2.83. Wykorzystanie funkcji strcmp i strnatcmp do sortowania ciągów "; foreach($pliki1 as $plik) echo "$plik "; usort($pliki1, "strcmp"); echo "

Po sortowaniu z użyciem strcmp:
"; foreach($pliki1 as $plik) echo "$plik "; usort($pliki2, "strnatcmp"); echo "

Po sortowaniu z użyciem strnatcmp:
"; foreach($pliki2 as $plik) echo "$plik "; ?>

Przykładowe nazwy plików zostały zapisane w tablicy, a następnie posortowane na dwa różne sposoby za pomocą znanej nam już funkcji usort. Efekt działania skryptu jest widoczny na rysunku 2.49. W pierwszej kolejności została wyświetlona zawartość tablicy przed sortowaniem — poszczególne elementy są nieuporządkowane. Następnie zostały wyświetlone wyniki sortowania, w którym jako funkcję porównującą wykorzystano strcmp, oraz sortowania, w którym jako funkcja porównująca została użyta strnatcmp. Różnica między porządkiem leksykograficznym a naturalnym jest tu bardzo wyraźna. Dodatkowo należy zwrócić uwagę, że w celu skrócenia listingu tym razem wszystkie pętle foreach wraz z występującymi w nich instrukcjami echo zostały zapisane w pojedynczych wierszach. Nie zostały w nich również zastosowane nawiasy klamrowe. Jest to dopuszczalne. Otrzymujemy wtedy bardziej zwięzły kod, choć nie dla każdego jest równie czytelne jak postać stosowana do tej pory.

170

PHP5. Praktyczny kurs

Rysunek 2.49. Różnice w sposobie sortowania ciągów znaków

Ćwiczenia do samodzielnego wykonania Ćwiczenie 9.1. Napisz skrypt obliczający liczbę elementów w tablicy podzielnych i niepodzielnych przez dwa. Ćwiczenie 9.2. Napisz funkcję przetwarzającą tablicę zawierającą ciągi znaków w taki sposób, że polskie znaki zostaną wymienione na odpowiadające im znaki alfabetu łacińskiego. Ćwiczenie 9.3. Napisz kod, który z jednej tablicy zawierającej wartości liczbowe oraz ciągi znaków utworzy dwie oddzielne — jedną zawierającą wyłącznie ciągi znaków i drugą zawierającą wyłącznie wartości liczbowe. Ćwiczenie 9.4. Napisz funkcję wykonującą sortowanie tablicy zawierającej liczby całkowite, taką aby najpierw umieszczone były wartości podzielne przez trzy w porządku malejącym, a następnie wartości niepodzielne przez trzy w porządku rosnącym. Ćwiczenie 9.5. Napisz skrypt sortujący tablicę zawierającą ciągi znaków, tak aby najpierw zostały umieszczone ciągi rozpoczynające się małą literą w porządku malejącym, a następnie ciągi rozpoczynające się wielką literą również w porządku malejącym.

Rozdział 3.

Współpraca z systemem plików Lekcja 10. Operacje na strukturze systemu plików PHP pozwala na wykonywanie różnych operacji na strukturze systemu plików. Bez problemów można odczytywać rozmaite informacje, np. zawartość wskazanego katalogu lub wielkość pliku, jak również dokonywać modyfikacji samej struktury, czyli tworzyć, usuwać lub przenosić w inne miejsce na dysku pliki i katalogi. Każda taka operacja jest wykonywana przez dedykowaną funkcję.

Odczyt zawartości katalogu W celu odczytania zawartości wybranego katalogu należy wykonać w sumie trzy operacje:  otwarcie katalogu,  odczyt danych,  zamknięcie katalogu.

Otwarcie katalogu to rezerwacja zasobów oraz informacja dla systemu, że będziemy wykonywać dalsze operacje. Aby otworzyć katalog, używa się funkcji opendir, której wywołanie ma postać1: opendir('nazwa_katalogu') 1

Można również zastosować opcjonalny drugi argument wywołania, którym powinno być odwołanie do zasobu (typ resource) wskazujące obiekt opisujący parametry powiązanego strumienia danych. W typowych zastosowaniach drugi argument jest pomijany.

172

PHP5. Praktyczny kurs

Funkcja zwraca deskryptor katalogu, czyli specjalny identyfikator, którym należy się posługiwać przy wykonywaniu dalszych operacji. W przypadku gdy katalogu o nazwie podanej w postaci argumentu nazwa_katalogu nie da się otworzyć (np. nazwa jest błędna, nie są odpowiednio ustawione prawa dostępu), wywołanie opendir zwraca wartość false. Odczyt zawartości katalogu, czyli znajdujących się w nim podkatalogów i plików, przeprowadza się za pomocą funkcji readdir, której należy przekazać w postaci argumentu deskryptor uzyskany przy wywołaniu opendir. Funkcja readdir działa w taki sposób, że każde jej wywołanie powoduje zwrócenie nazwy kolejnego elementu znajdującego się w katalogu; po odczytaniu wszystkich elementów zwraca ona natomiast wartość false. Jak łatwo się domyślić, takie zachowanie funkcji powoduje, że najlepiej wywoływać ją w pętli typu while. Gdy odczytana zostanie zawartość katalogu, należy go zamknąć za pomocą funkcji closedir, przekazując jej w postaci argumentu deskryptor otrzymany przy wywołaniu opendir: closedir(deskryptor_katalogu);

Zamknięcie oznacza w tym przypadku zwolnienie zasobów pobranych przez skrypt podczas wywołań opendir i readdir. Funkcja closedir nie zwraca żadnej wartości. Jeśli nie zostanie użyta, zamknięcie katalogu (i zwolnienie zasobów) nastąpi po zakończeniu pracy skryptu. Jeżeli w wywołaniu closedir nie zostanie podany konkretny deskryptor, czyli zostanie zastosowana instrukcja: closedir();

zamknięty zostanie ostatnio otwarty katalog. Wykorzystując powyższe informacje, można już w prosty sposób napisać skrypt, który wyświetli zawartość wybranego katalogu. Odpowiedni kod został zaprezentowany na listingu 3.1, a przykładowy efekt jego działania jest widoczny na rysunku 3.1. Listing 3.1. Skrypt wyświetlający zawartość wybranego katalogu \n"; closedir($fd); ?>

Nazwa katalogu, którego zawartość ma zostać wyświetlona, jest zapisywana w zmiennej $dir. Jest to katalog bieżący oznaczany jako ./, choć można również wskazać inny katalog serwera. Do otwarcia i pobrania deskryptora wykorzystywana jest instrukcja złożona: if(!($fd = opendir($dir))) exit("Nie mogę otworzyć katalogu $dir!");

Rozdział 3. ♦ Współpraca z systemem plików

173

Rysunek 3.1. Wyświetlenie zawartości katalogu

Działa ona w ten sposób, że najpierw wywoływana jest funkcja opendir z argumentem $dir, a wynik jej wywołania jest przypisywany zmiennej $fd. Następnie jest sprawdzane, czy wartość zapisana w $fd jest różna od false. Jeśli tak, następuje przejście do kolejnej instrukcji skryptu. Jeśli jednak $fd jest równe false, wywoływana jest funkcja2 exit kończąca wykonywanie skryptu i wysyłająca do standardowego wyjścia (w prezentowanym przykładzie — do przeglądarki) komunikat o błędzie. W przypadku gdy otwarcie katalogu zakończy się sukcesem i w zmiennej $fd zostanie zapisany jego deskryptor, nastąpi odczyt zawartości katalogu, który odbywa się w pętli while. Wyrażenie warunkowe tej pętli ma również postać złożoną: ($file = readdir($fd)) !== false

Najpierw jest tu wywoływana funkcja readdir, której został przekazany w postaci argumentu deskryptor katalogu zapisany w zmiennej $fd. Wynik wywołania, czyli nazwa każdego kolejnego elementu katalogu, jest przypisywany zmiennej $file, której wartość jest porównywana z false za pomocą operatora !== (nieidentyczny). Kiedy wynikiem porównania jest true, czyli gdy $file jest równe false, oznacza to, że zostały odczytane wszystkie elementy katalogu wskazywanego przez $fd, a zatem pętla kończy działanie. Wewnątrz pętli while znajduje się tylko jedna instrukcja — echo — która wyświetla na ekranie wartość zmiennej $file, a więc nazwę pliku lub podkatalogu. Należy zwrócić uwagę, że do stwierdzenia, czy $file jest różne od false, jest wykorzystywany operator !== (a nie !=). Wykorzystanie operatora != mogłoby spowodować błędy wynikające z konwersji niektórych nazw plików do wartości false. Przykładowo[e1], gdyby w przetwarzanym katalogu znajdował się plik o nazwie 0 (cyfra zero), po jego odczytaniu pętla zakończyłaby działanie, gdyż konwersja ciągu 0 do typu boolean daje w wyniku wartość false. Zauważmy również, że pierwsze dwie pozycje na liście to . i .., które oznaczają katalog bieżący oraz katalog nadrzędny. Jeśli chcemy uniknąć ich wyświetlania, trzeba by

2

W rzeczywistości exit jest konstrukcją języka, której używa się tak jak funkcji. Zamiast exit często stosuje się również jej alias die.

174

PHP5. Praktyczny kurs

zastosować dodatkową instrukcję warunkową, np. umieszczoną wewnątrz pętli while. Taka pętla mogłaby mieć na przykład postać: while (($file = readdir($fd)) !== false){ if($file != "." && $file != "..") echo "$file
\n"; }

lub też: while (($file = readdir($fd)) !== false){ if($file == "." || $file == "..") continue; echo "$file
\n"; }

W PHP5 istnieje również funkcja o nazwie scandir, która za jednym wywołaniem pobiera zawartość całego katalogu i zwraca ją w postaci tablicy. Co więcej, uzyskane nazwy plików i katalogów są automatycznie sortowane. Schematyczne wywołanie funkcji scandir ma postać3: scandir('nazwa_katalogu'[, sortowanie])

Parametr nazwa_katalogu określa katalog, z którego będą pobierane dane, natomiast sortowanie — sposób sortowania. Ustawienie tego drugiego parametru na 0 powoduje, że nazwy plików i katalogów będą sortowane alfabetycznie w porządku rosnącym, a ustawienie na 1 lub inną wartość całkowitą niezerową — że nazwy będą sortowane w porządku malejącym. Jeśli parametr sortowanie zostanie pominięty, funkcja będzie się zachowywała tak, jakby miał on wartość 0. Wynikiem działania scandir jest tablica, w której kolejnych komórkach znajdują się nazwy wszystkich elementów katalogu. Jej zawartość można odczytać np. za pomocą pętli foreach. Przykład skryptu wykorzystującego omawianą funkcję do odczytu zawartości wskazanego katalogu został zaprezentowany na listingu 3.2. Listing 3.2. Wykorzystanie funkcji scandir \n"; } } ?>

W obu dotychczas zaprezentowanych przykładach pliki i podkatalogi były przemieszane ze sobą. Co zrobić, jeśli chcielibyśmy, aby najpierw były wyświetlane nazwy podkatalogów, a dopiero po nich nazwy plików i aby te dwie grupy były sortowane 3

Podobnie jak w przypadku opendir, można stosować również opcjonalny trzeci argument będący odwołaniem do kontekstu z parametrami dla strumienia danych.

Rozdział 3. ♦ Współpraca z systemem plików

175

niezależnie? Nie ma funkcji, która automatycznie wykona takie zadanie, odpowiedni kod trzeba napisać własnoręcznie. Można użyć zarówno funkcji readdir, jak i scandir. Sprawdźmy, jak by to wyglądało w tym pierwszym przypadku. Przykładowy skrypt został przedstawiony na listingu 3.3. Listing 3.3. Wyświetlanie oddzielnych list dla plików i katalogów Katalogi
\n"; foreach($katalogi as $name){ echo "$name
\n"; } echo "
Pliki
\n"; foreach($pliki as $name){ echo "$name
\n"; } closedir($fd); ?>

Pierwsze linie skryptu są takie same jak w przykładzie z listingu 3.1 — to utworzenie zmiennej pomocniczej wskazującej katalog oraz otwarcie katalogu. Następnie tworzone są dwie tablice:  $katalogi — będą w niej przechowywane nazwy katalogów.  $pliki — będą w niej przechowywane nazwy plików.

Dalej następuje pętla while odczytująca za pomocą funkcji readdir nazwy kolejnych elementów katalogu. Nazwy te są zapisywane w zmiennej $file. Wewnątrz pętli następuje sprawdzenie, czy odczytana nazwa odnosi się do pliku, czy też do katalogu.

176

PHP5. Praktyczny kurs

Wykorzystywane są w tym celu dwie funkcje is_dir — zwracająca wartość true, jeżeli ciąg znaków przekazany jej w postaci argumentu wskazuje na istniejący katalog, oraz is_file — zwracająca wartość true, jeżeli ciąg znaków przekazany jej w postaci argumentu wskazuje na istniejący plik. Jeśli zatem kolejnym elementem odczytanym z katalogu jest plik, jest on dopisywany do tablicy $pliki, jeśli natomiast jest to katalog — do tablicy $katalogi. Zwróćmy uwagę na sposób dopisywania kolejnych elementów do tablic. Stosowana jest konstrukcja w postaci: $tablica[] = $zmienna;

Pozwala ona na dodanie do tablicy kolejnego elementu bez konieczności podawania indeksu lub klucza. Dodawany element będzie miał indeks o jeden większy od ostatniego elementu tablicy przed wykonaniem tej operacji. Po zakończeniu pętli, czyli odczytaniu całej zawartości katalogu, tablice $pliki i $katalogi są sortowane za pomocą funkcji sort, a następnie ich zawartość jest wysyłana do przeglądarki w pętlach typu foreach. Ostatecznie po uruchomieniu skryptu zobaczymy na ekranie widok taki jak na rysunku 3.2. Rysunek 3.2. Przykładowy efekt działania skryptu 3.3

Operacje na katalogach Tworzenie Do tworzenia katalogów służy funkcja mkdir, której schematyczne wywołanie ma postać: mkdir('nazwa'[, tryb[, zagnieżdżone]])

Parametr nazwa określa tu nazwę katalogu, natomiast tryb — prawa dostępu. Parametr tryb określa prawa dostępu do tworzonego katalogu i jest opcjonalny oraz przyjmuje wartość domyślną 777 (oktalnie). Jego wartość ma znaczenie jedynie w przypadku systemów z rodziny Uniksa — jest ignorowana w systemach z rodziny Windows. Argument nazwa może określać zarówno względną, jak i bezwzględną ścieżkę dostępu. Jeżeli nie ma określenia ścieżki, nowy katalog zostanie utworzony w katalogu bieżą-

Rozdział 3. ♦ Współpraca z systemem plików

177

cym. Trzeci parametr ustawiony na true umożliwia utworzenie zagnieżdżonej struktury katalogów (domyślną wartością jest false). Należy pamiętać, że katalog zostanie utworzony jedynie wtedy, jeżeli zostaną odpowiednio ustawione prawa dostępu. Funkcja mkdir zwraca wartość true, jeżeli utworzenie katalogu zakończyło się sukcesem, lub wartość false w przeciwnym razie. Przykładowo, aby założyć podkatalog images w katalogu /var/www/, należy wykonać instrukcję: mkdir("/var/www/images");

Przy czym ta instrukcja zostanie wykonana prawidłowo, jeśli istnieje katalog /var/www/ (inaczej zostanie wygenerowany błąd, a funkcja zwróci wartość false). Gdyby go nie było, należałoby skorzystać z trzeciego argumentu, pamiętając, że wtedy nie wolno pominąć drugiego, a więc trzeba też jawnie określić prawa dostępu. Instrukcja miałaby postać (dla praw opisanych jako 777): mkdir("/var/www/images", 0777, true);

Po jej użyciu zostaną utworzone wszystkie brakujące składowe ścieżki dostępu. Znaczy to, że jeśli istnieją katalogi /var i /var/www, zostanie utworzony tylko podkatalog images, jeżeli istnieje tylko katalog /var, zostaną utworzone podkatalogi /var/www i /var/www/images, jeżeli natomiast nie ma żadnego ze składników ścieżki, powstaną katalogi: /var, /var/www i /var/www/images. Takiej postaci funkcji należy użyć również w Windows, mimo że drugi argument jest w tym systemie ignorowany.

Usuwanie Do usuwania katalogów służy funkcja rmdir. Nazwę katalogu do usunięcia należy jej przekazać w postaci argumentu. Schematyczne wywołanie ma zatem postać: rmdir('nazwa')

Funkcja rmdir zwraca wartość true, jeżeli procedura usuwania katalogu zakończyła się sukcesem, lub wartość false w przeciwnym razie. Usuwany katalog musi być pusty, tzn. nie może zawierać żadnych elementów. Jeżeli zatem chcielibyśmy usunąć utworzony poprzednio katalog images znajdujący się w lokalizacji /var/www, powinniśmy wykonać instrukcję: rmdir("/var/www/images");

Zmiana katalogu bieżącego Do zmiany katalogu bieżącego wykorzystywana jest funkcja chdir, której w postaci argumentu należy przekazać nazwę nowego katalogu bieżącego. Wywołanie tej funkcji ma postać: chdir('nazwa')

nazwa jest tu nazwą nowego katalogu bieżącego. Pamiętać należy oczywiście, że aparat wykonawczy PHP musi mieć prawa dostępu do katalogu wskazywanego przez nazwa,

178

PHP5. Praktyczny kurs

gdyż w przeciwnym razie operacja zmiany zakończy się niepowodzeniem. Funkcja chdir zwraca wartość true, o ile udało się zmienić katalog bieżący, lub false w przeciwnym razie. Standardowo katalogiem bieżącym jest katalog serwera, w którym znajduje się wywoływany skrypt. Jeśli chcielibyśmy, aby katalogiem bieżącym był katalog /var/www/images, powinniśmy wykonać instrukcję: chdir("/var/www/images");

Ustalenie katalogu bieżącego Jeżeli chcemy się dowiedzieć, jaki jest aktualny katalog bieżący, powinniśmy użyć funkcji getcwd (z ang. get current working directory), która zwraca jego nazwę w postaci ciągu znaków. Ta funkcja nie przyjmuje żadnych argumentów. Wyświetlenie aktualnego katalogu bieżącego uzyskamy zatem za pomocą instrukcji: echo getcwd();

Ustalenie, czy katalog istnieje Aby ustalić, czy dany katalog istnieje, należy użyć funkcji file_exists, której wywołanie ma postać: file_exists('nazwa_katalogu')

Zwracaną wartością jest true, jeśli katalog istnieje, lub false w przeciwnym razie. Ta sama funkcja jest wykorzystywana do sprawdzania istnienia plików.

Operacje na plikach Tworzenie plików Pliki są tworzone za pomocą funkcji fopen, która jednocześnie służy do ich otwierania, dlatego temat ten zostanie omówiony dopiero w kolejnej lekcji.

Usuwanie plików Do usuwania plików służy funkcja unlink, która w postaci argumentu przyjmuje nazwę usuwanego pliku, a zatem jej wywołanie ma schematyczną postać: unlink('nazwa_pliku')

Funkcja zwraca wartość true, o ile plik udało się usunąć, lub false w przeciwnym razie. Nazwa pliku do usunięcia może być podawana wraz ze względną lub bezwzględną ścieżką dostępu. Aby na przykład usunąć plik o nazwie image1.jpg, który znajduje się w katalogu bieżącym, należy zastosować instrukcję: unlink('./image1.jpg');

aby natomiast usunąć plik o nazwie image2, który znajduje się w katalogu /var/www/ images — instrukcję: unlink('/var/www/images/image2.jpg');

Rozdział 3. ♦ Współpraca z systemem plików

179

Ustalenie, czy plik istnieje Do ustalania, czy plik o zadanej nazwie istnieje na dysku, wykorzystywana jest funkcja file_exists. W postaci argumentu należy jej przekazać nazwę pliku, którego istnienie chcemy sprawdzić, wraz ze ścieżką dostępu (względną lub bezwzględną). Wywołanie ma więc schematyczną postać: file_exists('nazwa_pliku')

Funkcja zwraca wartość true, jeśli plik istnieje, lub false w przeciwnym razie.

Określanie rozmiaru pliku Rozmiar pliku można sprawdzić, wywołując funkcję o nazwie filesize, schematycznie: filesize('nazwa_pliku')

Funkcja zwraca wartość typu integer określającą wielkość pliku w bajtach. Należy zwrócić szczególną uwagę, że pozwala to na prawidłowy odczyt jedynie plików o wielkości do 2 GB lub (po zastosowaniu formatowania) do 4 GB. Dzieje się tak, ponieważ maksymalna wartość dla typu integer ze znakiem (czyli dodatnich i ujemnych) to 231–1, a dla wartości integer bez znaku (czyli tylko dodatnich) to 232–1. Zatem dla plików o wielkości do 2 GB wynik będzie prawidłowy bez stosowania dodatkowych zabiegów, natomiast dla plików o wielkościach od 2 GB do 4 GB prawidłowy rozmiar można uzyskać, stosując formatowanie wyniku za pomocą funkcji printf (lub sprintf). Zobrazowano to w kodzie z listingu 3.4. Listing 3.4. Sposoby wykorzystania funkcji filesize "; echo $size; echo "
Wynik sformatowany za pomocą funkcji printf:
"; printf("%u", $size); ?>

Do testów wykorzystany został plik o nazwie plik.temp zapisany w katalogu bieżącym o rozmiarze przekraczającym 2 GB. Jak widać na rysunku 3.3, zwykłe wywołanie funkcji filesize spowodowało pojawienie się wartości ujemnej. Dopiero sformatowanie tego wyniku za pomocą funkcji printf (patrz także lekcja 8., sekcja „Formatowanie ciągów”) spowodowało wyświetlenie prawidłowego rozmiaru. Zastosowany został ciąg formatujący %u. Rysunek 3.3. Zastosowanie funkcji printf do formatowania wyników funkcji filesize

180

PHP5. Praktyczny kurs

Informacje o pliku Oprócz informacji o wielkości pliku przydatnych może być również kilka innych danych pobieranych za pomocą odpowiednich funkcji. Oto niektóre z nich:  fileatime — zwraca znacznik czasu Uniksa określający czas ostatniego dostępu

do pliku. Należy pamiętać, że niektóre systemy pozwalają na wyłączenie aktualizacji tego parametru w celu zwiększenia wydajności systemu. W takich przypadkach wartość zwracana przez funkcje nie będzie użyteczna.  filectime — zwraca znacznik czasu Uniksa określający czas ostatniej zmiany

metadanych pliku (zmiana praw dostępu, właściciela, modyfikacja i-węzła itp.).  filemtime — zwraca znacznik czasu Uniksa określający czas ostatniej

modyfikacji pliku.  filetype — zwraca ciąg znaków określający typ pliku. Zwracane wartości to: fifo, char, dir, block, link, file i unknown.  fileperms — zwraca wartość określającą prawa dostępu do pliku.  fileowner — zwraca identyfikator właściciela pliku.

Wszystkie wymienione funkcje jako parametr przyjmują nazwę pliku, a w przypadku gdyby ich wykonanie zakończyło się niepowodzeniem, zwracają wartość false.

Miejsce na dysku Jeśli chcemy uzyskać informacje o ilości wolnego miejsca na dysku, możemy skorzystać z funkcji disk_free_space. Przyjmuje ona w postaci argumentu nazwę katalogu i zwraca ilość wolnego miejsca (w bajtach) na dysku logicznym (lub partycji), na którym znajduje się ten katalog. Poprawne są zatem wywołania: disk_free_space('/') disk_free_space('./') disk_free_space('/usr/tmp')

W przypadku pracy z systemem Windows mogą mieć one również postaci: disk_free_space('c:') disk_free_space('d:\\windows')

Jeżeli interesuje nas nie wolna, ale całkowita ilość miejsca, zamiast disk_free_space należy zastosować funkcję disk_total_space. Działa ona w sposób analogiczny, z tą różnicą, że zwraca całkowitą ilość miejsca na dysku. Ponieważ obie funkcje zwracają wartości typu float, przy korzystaniu z nich nie występują problemy opisane przy omawianiu funkcji filesize. Sposób wykorzystania tych funkcji zobrazowano w skrypcie widocznym na listingu 3.5. Listing 3.5. Uzyskanie informacji o miejscu na dysku
Rozdział 3. ♦ Współpraca z systemem plików

181

$zajete_miejsce = $calkowite_miejsce - $wolne_miejsce; echo "Całkowite miejsce na dysku: $calkowite_miejsce B
"; echo "Dostępne miejsce na dysku: $wolne_miejsce B
"; echo "Zajęte miejsce na dysku: $zajete_miejsce B
"; ?>

Nie ma niestety standardowej funkcji, która pozwoliłaby stwierdzić, ile miejsca na dysku zajmuje katalog wraz z podkatalogami. Jeśli zatem potrzebna jest taka informacja, należy samodzielnie napisać odpowiednią procedurę. Sposób realizacji takiego zadania został zaprezentowany na listingu 3.6. Obliczeniem, ile bajtów zajmuje wybrany katalog wraz z całą swoją zawartością, zajmuje się funkcja getDirSize. Listing 3.6. Obliczenie ilości miejsca zajmowanego przez katalog

Funkcja działa w sposób rekurencyjny, tzn. dla każdego podkatalogu wywołuje samą siebie. Nazwa katalogu jest przekazywana w postaci argumentu $dir i jest on otwierany za pomocą funkcji opendir. Zawartość katalogu odczytuje się w pętli while za pomocą funkcji readdir, tak jak miało to miejsce w przypadku wcześniej prezentowanych przykładów. Wewnątrz pętli najpierw jest sprawdzane, czy nazwa odczytanego elementu to nazwa katalogu bieżącego lub nadrzędnego. Jeśli tak, wywoływana jest instrukcja continue powodująca przejście do kolejnej iteracji pętli. Jeśli jednak odczytana nazwa jest różna zarówno od ., jak i od.., następuje sprawdzenie, czy jest to katalog (is_dir), czy plik (is_file). W pierwszym przypadku wywoływana jest ponownie funkcja getDirSize obliczająca ilość miejsca zajmowanego przez podkatalog. Nazwę podkatalogu tworzy się przez dodanie do parametru $dir nazwy zawartej w zmiennej $file (nazwy oddzielane są od siebie znakiem separatora — /). W przypadku drugim, czyli kiedy $file wskazuje na plik, jego wielkość jest odczytywana za pomocą funkcji filesize. Sumaryczny rozmiar wszystkich plików jest zapisywany w zmiennej $count, a wartość tej zmiennej jest ostatecznie zwracana jako wynik działania getDirSize. Przykładowe wywołanie tej funkcji może mieć postać:

182

PHP5. Praktyczny kurs getDirSize("/var/www/public_html");

lub: getDirSize("c:\\dokumenty");

Rekurencyjne usuwanie zawartości katalogu Konstrukcję bardzo podobną do użytej w skrypcie z listingu 3.6 można zastosować do usuwania zawartości całego katalogu wraz z podkatalogami. Kod realizujący takie zadanie został zaprezentowany na listingu 3.7. Przykładowe wywołanie zaprezentowanej tam funkcji delDir może mieć postać: delDir('/usr/tmp');

Listing 3.7. Funkcja usuwająca zawartość katalogu

Sposób otwarcia katalogu oraz odczytywania jego kolejnych elementów jest analogiczny do przedstawionego w poprzednim przykładzie. W identyczny sposób stosowane są także wywołania rekurencyjne. Jeśli stwierdzone zostanie, że odczytanym elementem katalogu jest kolejny katalog, następuje ponowne wywołanie funkcji delDir, której w postaci argumentu jest przekazywana jego nazwa połączona z nazwą wskazywaną przez argument $dir. Po jej wykonaniu katalog jest usuwany za pomocą funkcji rmdir. Jeśli jednak odczytanym elementem katalogu jest plik, jest on usuwany za pomocą funkcji unlink. Należy pamiętać, że czynność usuwania plików i katalogów zakończy się sukcesem jedynie wtedy, jeśli będą one miały odpowiednio ustawione prawa dostępu.

Nawigacja po katalogach Wykorzystując wiadomości przedstawione do tej pory, można w ramach treningu napisać ciekawy skrypt, który będzie pozwalał na przeglądanie w przeglądarce zawartości dysku serwera. Na stronie wyświetlane będą nazwy plików i katalogów. Katalogi

Rozdział 3. ♦ Współpraca z systemem plików

183

będą miały postać odnośników (rysunek 3.4). Kliknięcie takiego katalogu – odnośnika spowoduje wyświetlenie jego zawartości. Skrypt realizujący przedstawione zadanie został zaprezentowany na listingu 3.8. Rysunek 3.4. Zawartość wybranego katalogu serwera

Listing 3.8. Skrypt umożliwiający nawigację po katalogach

0){ if($dir[$count - 1] == '/'){ $dir = substr($dir, 0, $count - 1); } } while (($file = readdir($fd)) !== false){ if($file == ".") continue; if(is_dir($dir."/".$file)){ $path = urlencode($dir."/".$file); $link = "$file\n"; echo $link; }

184

PHP5. Praktyczny kurs else{ echo $file; } echo "
"; } closedir($fd); } if(isSet($_GET['dir'])){ $dir = $_GET['dir']; } else{ $dir = "/"; } if($dir == '') $dir = "/"; listDir($dir); ?>

Nazwa katalogu, którego zawartość ma być zaprezentowana, jest przekazywana do skryptu metodą GET w postaci parametru dir. Odczytuje się ją zatem z tablicy $_GET z indeksu dir ($dir = $_GET['dir']), badając najpierw, czy ten indeks został ustawiony (isSet($_GET['dir'])). Jeżeli parametr został przekazany, jego wartość jest przypisywana zmiennej $dir ($dir = $_GET['dir']). Jeśli nie został przekazany, przyjmuje się, że ma zostać wyświetlona zawartość katalogu głównego /, czyli zmienna $dir otrzymuje wartość / ($dir = "/"). Pobraniem i wysłaniem danych do przeglądarki zajmuje się funkcja listDir. Jako argument otrzymuje ona nazwę katalogu, którego zawartość ma być wyświetlona. Funkcja najpierw próbuje zmienić katalog bieżący na katalog przekazany jej w postaci argumentu. Jeśli się to nie uda, wyświetla komunikat o braku dostępu i kończy działanie. Jeżeli katalog uda się zmienić, zmiennej $dir jest przypisywany wynik działania funkcji getcwd pobierającej aktualny katalog bieżący. Dzięki temu w dalszej części kodu będzie wykorzystywana bezwzględna nazwa katalogu. Jeśli zatem przekazany do skryptu argument miał postać /usr/tmp/abc/../bcd/, zostanie on zamieniony w tym miejscu na /usr/tmp/bcd/ (zakładając, że w systemie plików serwera znajduje się katalog /usr/tmp/, a w nim podkatalogi o nazwach abc i bcd). Kolejna instrukcja skryptu to otwarcie katalogu za pomocą funkcji opendir. W przypadku gdy jej wywołanie zakończy się niepowodzeniem, do przeglądarki jest wysyłany komunikat o braku dostępu do katalogu i skrypt kończy działanie. Jeśli jednak katalog uda się otworzyć, ciąg zapisany w zmiennej $dir jest przetwarzany w taki sposób, aby w dalszej części skryptu miał jednolitą postać. Będzie ona niezależna od tego, w jakim systemie działa PHP oraz w jakim formacie nazwa została przekazana do skryptu (ścieżka dostępu w stylu Windowsa lub Uniksa). Najpierw wszystkie znaki \ zostają zamienione na /, za co odpowiada funkcja str_replace, następnie sprawdzane jest, czy na końcu ciągu znajduje się znak /. Jeśli tak, jest on usuwany, za co odpowiada wywołanie funkcji substr.

Rozdział 3. ♦ Współpraca z systemem plików

185

Ta ostatnia czynność jest potrzebna, bowiem w dalszej części skryptu nazwa katalogu bieżącego zapisana w zmiennej $dir jest łączona z nazwami znajdujących się w nim podkatalogów. Pomiędzy te dwie nazwy wstawiony jest znak /. Gdyby się tak zdarzyło, że w nazwie zapisanej w $dir na końcu występowałby znak /, to po czynności łączenia w ciągu wynikowym zamiast /usr/tmp) znalazłyby się dwa znaki / występujące po sobie (np. //usr/tmp. Odczyt zawartości katalogu odbywa się w pętli while na takiej samej zasadzie jak we wcześniej prezentowanych przykładach. Nazwa każdego elementu jest zapisywana w zmiennej $file. Jeśli jest to plik (co jest sprawdzane za pomocą funkcji is_file), nazwa jest po prostu wyświetlana na ekranie (echo $file;), jeśli jednak jest to katalog (co jest sprawdzane za pomocą funkcji is_dir), konstruowany jest znacznik w schematycznej postaci: nazwa_katalogu

przykładowo: abc

Fragment odnośnika będący wartością parametru dir (za znakiem =), czyli wartość zmiennej pomocniczej $path, jest dodatkowo przetwarzany za pomocą funkcji urlencode. Jest to konieczne, aby otrzymać prawidłowy kod HTML, w nazwach katalogów mogą bowiem występować różne znaki spoza alfabetu łacińskiego (a także inne niedopuszczalne znaki alfanumeryczne, w tym znak separatora katalogów /, który nie powinien występować w ciągu URL za znakiem ?). Funkcja urlencode zamieni takie znaki na ciągi w postaci %XX, gdzie XX jest kodem znaku. Ostatecznie znacznik odpowiadający za konstrukcję odnośnika jest wysyłany do przeglądarki za pomocą instrukcji echo (echo $link;), dzięki czemu na stronie pojawia się lista katalogów.

Ćwiczenia do samodzielnego wykonania Ćwiczenie 10.1. Zmień kod z listingu 3.1 tak, aby wywołanie funkcji readdir znajdowało się wewnątrz pętli, a nie w wyrażeniu warunkowym. Ćwiczenie 10.2. Napisz skrypt odczytujący zawartość wskazanego katalogu za pomocą funkcji readdir i wyświetlający odczytane dane w porządku alfabetycznym rosnącym. Ćwiczenie 10.3. Napisz skrypt, który wyświetli zawartość katalogu w taki sposób, że najpierw wyświetlane będą nazwy podkatalogów, a następnie nazwy plików. Do odczytu elementów katalogu wykorzystaj funkcję scandir. Ćwiczenie 10.4. Napisz dwuargumentową funkcję, która będzie obliczała ilość miejsca zajmowanego przez katalog. Pierwszy argument ma wskazywać ścieżkę dostępu do katalogu, natomiast drugi, typu boolean, powinien wskazywać, czy w obliczeniach mają być brane pod uwagę podkatalogi. Ćwiczenie 10.5. Napisz skrypt wyświetlający datę jego ostatniej modyfikacji.

186

PHP5. Praktyczny kurs

Lekcja 11. Operacje na plikach Informacje z lekcji 10. dotyczyły operacji na strukturze systemu plików. Równie ważne są jednak operacje wykonywane na samych plikach i zawartych w nich danych. Na kolejnych stronach zostaną więc pokazane sposoby wykonywania takich zadań jak tworzenie plików na dysku oraz odczyt i zapisy danych.

Tworzenie i otwieranie plików Czynności tworzenia plików na dysku oraz ich otwierania są ze sobą związane i wykonuje je jedna funkcja — fopen. Termin otwarcie pliku oznacza tu to samo co w przypadku katalogów — jest to informacja dla systemu, że będziemy korzystać z danego pliku, oraz związana z tym rezerwacja odpowiednich zasobów. W wyniku tej czynności otrzymamy deskryptor, czyli identyfikator pliku, którego należy używać przy wykonywaniu na nim wszelkich kolejnych operacji. Wywołanie fopen ma schematyczną postać: fopen('nazwa_pliku', 'tryb_otwarcia'[, użyj_include_path])

Argument nazwa_pliku to ciąg znaków wskazujący nazwę pliku, który należy otworzyć. Może on zawierać zarówno względną, jak i bezwzględną ścieżkę dostępu. Jeśli ścieżka dostępu nie zostanie podana, plik będzie poszukiwany w katalogu bieżącym, a jeżeli został użyty trzeci argument o wartości true (wartością domyślną jest false), również w katalogach wymienionych w opcji include_path w pliku php.ini. Prawidłowe są zatem przykładowe wartości: /usr/tmp/abc/plik1.zip ../bcd/plik2.zip ./plik3.zip plik4.zip

Podczas określania ścieżki dostępu należy pamiętać o tym, że w systemach z rodziny Windows wygląda ona inaczej niż w systemach uniksowych. W Windows jako separator poszczególnych elementów ścieżki dostępu występuje znak \, podczas gdy w systemach z rodziny Uniksa znak /. W Windows stosowane jest również określenie dysku logicznego jako c:, d: itp., podczas gdy w Uniksie mamy katalog główny /. Warto jednak wiedzieć, że nawet jeśli PHP działa na serwerze opartym na systemie Windows, można stosować uniksowe separatory, np.: c:/users/documents/ e:/php/temp/

Co więcej, można również zastosować ścieżkę odwołującą się do katalogu głównego /, np.: /php/temp/

W takim wypadku będzie ona oznaczała katalog php/tmp znajdujący się na logicznym dysku bieżącym. Czyli, jeżeli dyskiem bieżącym jest c:, określenie /php/temp/ będzie oznaczało w rzeczywistości c:\php\temp, a jeżeli dyskiem bieżącym jest d:, będzie oznaczało d:\php\temp itd.

Rozdział 3. ♦ Współpraca z systemem plików

187

Parametr tryb_otwarcia określa tryb otwarcia pliku i może przyjmować wartości przedstawione w tabeli 3.1. Tabela 3.1. Tryby otwarcia pliku dla funkcji fopen Tryb

Opis

r

Plik zostanie otwarty w trybie tylko do odczytu. Wskaźnik pozycji w pliku zostanie ustawiony na jego początku. Plik musi istnieć we wskazanej lokalizacji, inaczej zostanie zgłoszony błąd.

r+

Plik zostanie otwarty w trybie do odczytu i do zapisu. Wskaźnik pozycji w pliku zostanie ustawiony na jego początku. Plik musi istnieć we wskazanej lokalizacji, inaczej zostanie zgłoszony błąd.

w

Plik zostanie otwarty w trybie tylko do zapisu, jego długość zostanie obcięta do zera, znajdujące się w nim dane zostaną tym samym skasowane. Jeżeli pliku o podanej nazwie nie będzie na dysku, zostanie podjęta próba jego utworzenia.

w+

Plik zostanie otwarty w trybie do zapisu i do odczytu, jego długość zostanie obcięta do zera, znajdujące się w nim dane zostaną tym samym skasowane. Jeżeli pliku o podanej nazwie nie będzie na dysku, zostanie podjęta próba jego utworzenia.

a

Plik zostanie otwarty w trybie tylko do zapisu. Wskaźnik pozycji w pliku zostanie przesunięty na jego koniec, znajdujące się w nim dane nie zostaną skasowane. Jeżeli pliku o podanej nazwie nie będzie na dysku, zostanie podjęta próba jego utworzenia.

a+

Plik zostanie otwarty w trybie do zapisu i odczytu. Wskaźnik pozycji w pliku zostanie przesunięty na jego koniec, znajdujące się w nim dane nie zostaną skasowane. Jeżeli pliku o podanej nazwie nie będzie na dysku, zostanie podjęta próba jego utworzenia.

x

Zostanie utworzony i otwarty plik w trybie tylko do zapisu. Jeżeli plik istnieje, funkcja wygeneruje błąd i zwróci wartość false.

x+

Zostanie utworzony i otwarty plik w trybie do zapisu i do odczytu. Jeżeli plik istnieje, funkcja wygeneruje błąd i zwróci wartość false.

c

Otwiera plik w trybie tylko do zapisu. Jeżeli plik nie istnieje, zostanie utworzony, jeśli zaś istnieje, wskaźnik pozycji zostanie umieszczony na początku — zawartość pliku nie jest tracona. Opcja dostępna od PHP 5.2.6.

c+

Otwiera plik w trybie do zapisu i do odczytu. Jeżeli plik nie istnieje, zostanie utworzony, jeśli zaś istnieje, wskaźnik pozycji zostanie umieszczony na początku — zawartość pliku nie jest tracona. Opcja dostępna od PHP 5.2.6.

Parametr tryb_otwarcia może również zawierać określenie typu pliku: b — dla plików binarnych bądź t — dla plików tekstowych, np. rb, at, x+t. Określenie to ma znaczenie jedynie w przypadku systemów operacyjnych, które dokonują rozróżnienia między trybem binarnym i tekstowym (jak np. systemy Windows). W przypadku otwarcia w trybie binarnym dane są odczytywane i zapisywane w plikach bez żadnych modyfikacji. W przypadku otwarcia w trybie tekstowym przetwarzane są znaki końca linii. Dzieje się tak dlatego, że różne systemy w różny sposób określają koniec linii tekstu, np. w przypadku Windows jest to sekwencja \r\n, w przypadku Uniksa sekwencja \n, a w przypadku MacOS sekwencja \r4. W PHP55 domyślnym trybem otwarcia pliku jest tryb binarny, nie ma zatem potrzeby stosowania znaku b w parametrze tryb_otwarcia. Jest to również zalecany sposób otwierania plików. 4 5

Gdzie \n oznacza znak o kodzie szesnastkowym 10, natomiast \r znak o kodzie szesnastkowym 13. A dokładniej we wszystkich wersjach, począwszy od 4.3.2.

188

PHP5. Praktyczny kurs

Słowo komentarza należy się sposobowi tworzenia plików. Otóż jak wynika z opisów z tabeli 3.1, plik można utworzyć poprzez wywołanie funkcji fopen, wykorzystując jeden z trybów: w, w+, a, a+, c, c+. W PHP nie ma więc oddzielnej funkcji do wykonywania tej czynności, tak jak to jest w niektórych innych językach programowania.

Zamykanie plików Gdy zakończą się wykonywane na pliku operacje (np. odczytu lub zapisu), powinien on zostać zamknięty za pomocą funkcji fclose, której typowe wywołanie ma postać: fclose(deskryptor);

deskryptor to oczywiście wartość uprzednio zwrócona przez fopen. Zamknięcie ozna-

cza zwolnienie zasobów zaalokowanych przy otwarciu pliku. Jeśli nie zostanie to zrobione, plik zostanie automatycznie zamknięty, gdy skrypt zakończy działanie. Kod wykonujący operacje na pliku zwykle ma schematyczną konstrukcję: if(!($fd = fopen('nazwa_pliku', 'tryb_otwarcia'))){ //operacje wykonywane, kiedy nie uda się otwarcie pliku } else{ //operacje na pliku fclose($fd); }

lub też: if(!($fd = fopen('nazwa_pliku', 'tryb_otwarcia'))){ //operacje wykonywane, kiedy nie uda się otwarcie pliku exit(); // lub return, jeśli wywołanie nastąpiło wewnątrz funkcji } //operacje na pliku fclose($fd);

Odczyt danych Dane z pliku da się odczytywać na wiele różnych sposobów, korzystając przy tym z rozmaitych funkcji. Można pobierać pojedyncze znaki, wiersze tekstu, dowolne fragmenty pliku lub też jednocześnie całą jego zawartość. Oczywiście nie będą tu omawiane wszystkie dostępne możliwości, ale jedynie te najbardziej przydatne i najczęściej stosowane.

Odczyt pojedynczych wierszy Pojedyncze wiersze tekstu można odczytać z pliku za pomocą funkcji o nazwie fgets (za wiersz jest uznawany ciąg znaków zakończony znakiem końca linii), której schematyczne wywołanie ma postać: fgets(deskryptor[, ile])

Rozdział 3. ♦ Współpraca z systemem plików

189

deskryptor określa tu plik otworzony za pomocą funkcji fopen, a argument ile jest

opcjonalny i określa maksymalną liczbę znaków do odczytu. Jeśli jest obecny, funkcja będzie odczytywała dane aż do odczytania znaku końca linii lub gdy liczba odczytanych znaków osiągnie wartość ile – 1. Jeśli zostanie pominięty, odczyt z pliku będzie kontynuowany tak długo, aż zostanie odnaleziony znak końca linii lub zostanie osiągnięty koniec pliku. Wartością zwracaną przez fgets jest wartość typu string zawierająca odczytane dane. A zatem każde wywołanie funkcji zwraca jeden wiersz tekstu nie dłuższy niż ile - 1 znaków i przesuwa wskaźnik pozycji w pliku o liczbę odczytanych znaków (wskaźnik pozycji to wartość używana przez system podczas operacji na pliku i określająca, w którym jego miejscu ma się rozpocząć kolejna operacja). Tym samym funkcję fgets najczęściej stosuje się w pętli while testującej osiągnięcie końca pliku. Ten test przeprowadza się z kolei za pomocą funkcji feof, która zwraca wartość true w przypadku wykrycia, że wskaźnik pozycji pliku znajduje się na jego końcu. Zobaczmy to na konkretnym przykładzie, który został przedstawiony na listingu 3.9. Działanie skryptu polega na odczytaniu wiersz po wierszu zawartości pliku test.txt umieszczonego w katalogu bieżącym. Listing 3.9. Odczyt danych za pomocą funkcji fgets

Plik test.txt jest otwierany za pomocą funkcji fopen w trybie r, czyli tylko do odczytu. W przypadku niepowodzenia tej operacji (kiedy funkcja zwróci wartość false) skrypt kończy działanie, wysyłając do przeglądarki komunikat informujący o błędzie. Jeśli jednak otwarcie pliku zakończy się sukcesem, w pętli while za pomocą funkcji fgets są odczytywane i przypisywane zmiennej $str kolejne wiersze tekstu. Każdy odczytany wiersz jest przetwarzany w taki sposób, aby występujący w nim znak końca linii został zamieniony na znacznik
, dzięki czemu w przeglądarce zostanie zaprezentowany taki sam układ wierszy jak w pliku tekstowym (rysunek 3.5). Wykorzystywana jest w tym celu poznana w lekcji 8. funkcja nl2br. Gdyby taka zamiana nie została wykonana, cała treść pliku zostałaby wyświetlona w przeglądarce jako jeden długi wiersz. Łatwo się o tym przekonać, usuwając ze skryptu wiersz wywołujący nl2br. Osiągnięty zostanie wtedy efekt zaprezentowany na rysunku 3.6. Pętla while kończy działanie wtedy, gdy funkcja feof zwróci wartość true, czyli gdy zostanie osiągnięty koniec pliku (kiedy zostanie odczytany ostatni wiersz tekstu). Dokładniej rzecz ujmując, funkcja ta testuje położenie wskaźnika pozycji w pliku. Ten wskaźnik (zapamiętywany przez system) po otwarciu pliku w trybie r znajduje się na

190

PHP5. Praktyczny kurs

Rysunek 3.5. Przykładowy efekt działania skryptu odczytującego zawartość pliku tekstowego

Rysunek 3.6. Brak znaczników końca linii powoduje, że cała treść pliku jest wyświetlana w jednym wierszu

jego początku (na pozycji zerowej). Każde wywołanie funkcji fgets przesuwa wskaźnik do przodu o liczbę odczytanych bajtów. Tym samym po każdym odczytaniu jednego wiersza tekstu wskazuje on początek kolejnego. Po odczytaniu wszystkich wierszy wskaźnik znajduje się na końcu pliku, co wykrywa funkcja feof. Jeżeli spodziewamy się, że w pliku, z którego będziemy odczytywać dane, znajdują się niepotrzebne nam znaczniki HTML, możemy do odczytu danych zamiast fgets wykorzystać funkcję fgetss. Jej wywołanie ma schematyczną postać: fgetss(deskryptor[, ile[, tagi]])

deskryptor to deskryptor pliku zwrócony przez wywołanie funkcji fopen, ile to określenie maksymalnej liczby znaków do odczytu (takie samo znaczenie jak w przypadku fgets), a parametr tagi określa znaczniki, które mają nie być usuwane. Argumenty ile i tagi są — tak jak zostało to zaznaczone za pomocą nawiasów kwadratowych — opcjonalne. Jeśli mamy na przykład plik index.html zawierający dane jak na listingu 3.10, to wykonanie skryptu widocznego na listingu 3.11 spowoduje wyświetlenie w przeglądarce tekstu widocznego na rysunku 3.7, usunięte zostaną bowiem wszystkie znaczniki HTML (dla ułatwienia orientacji skrypt numeruje odczytane z pliku wiersze nawet wtedy, gdy po usunięciu znaczników są one puste). Listing 3.10. Przykładowy plik zawierający znaczniki HTML

Pierwszy akapit tekstowy

Drugi akapit tekstowy

Trzeci akapit tekstowy

Rozdział 3. ♦ Współpraca z systemem plików

191

Listing 3.11. Odczytanie zawartości pliku tekstowego z usunięciem znaczników HTML

Rysunek 3.7. Efekt działania skryptu usuwającego znaczniki HTML

Odczyt pojedynczych znaków Odczyt pojedynczych znaków z pliku umożliwia funkcja fgetc. Przyjmuje ona jeden argument, jakim jest deskryptor pliku, który będzie odczytywany, oraz zwraca ciąg zawierający pojedynczy odczytany znak. Wywołanie ma więc schematyczną postać: fgetc(deskryptor);

Po jej wykonaniu wskaźnik pliku przesuwany jest o jeden bajt do przodu. W przypadku gdy zostanie osiągnięty koniec pliku, fgetc zwraca wartość false. Skrypt odczytujący zawartość pliku tekstowego test.txt (odpowiednik skryptu 3.9) został zaprezentowany na listingu 3.12. Warto zauważyć, że w tym przypadku nie ma potrzeby stosowania funkcji feof, gdyż fgetc sama rozpoznaje koniec pliku. Trzeba jednak pamiętać, aby do testowania osiągnięcia końca pliku wykorzystywać operatory === lub !==. Inaczej

192

PHP5. Praktyczny kurs

mogłoby się okazać, że odczytany bajt (np. o wartości 0) zostanie błędnie uznany za koniec pliku. Tej metody nie należy też używać do odczytu całej zawartości dużych plików, gdyż będzie ona bardzo nieefektywna. Listing 3.12. Odczytanie zawartości pliku znak po znaku "; echo($str); } fclose($fd); } ?>

Warto zwrócić uwagę, w jaki sposób znaki końca linii są zamieniane na znacznik
. Otóż każdy odczytany z pliku znak \n jest zamieniany na ciąg
, który następnie wędruje do przeglądarki. To oznacza, że ta metoda zadziała w przypadku systemów, w których koniec wiersza jest oznaczany jako \n (np. w Linuksie) lub \r\n (np. w Windowsie). Nie sprawdzi się natomiast w systemach, gdzie jedynym wyznacznikiem końca jest znak \r (np. MacOS). Oczywiście skrypt można w łatwy sposób poprawić, tak aby poprawnie reagował we wszystkich wymienionych sytuacjach. To jednak pozostanie zadaniem do samodzielnego wykonania.

Odczyt bloków danych Kiedy chce się odczytać określoną liczbę bajtów lub też dane z pliku binarnego, należy użyć funkcji fread. Jej wywołanie ma postać: fread(deskryptor, ile)

deskryptor to deskryptor pliku zwrócony przez funkcję fopen, a ile określa liczbę bajtów do odczytania. Należy zwrócić uwagę, że w odróżnieniu od poprzednio prezentowanych funkcji tym razem parametr ile nie jest opcjonalny i należy go podać.

Funkcja zwraca odczytany fragment pliku w postaci ciągu typu string. Trzeba pamiętać, że w przypadku systemów rozróżniających pliki binarne i tekstowe (jak np. Windows) plik nie powinien być otwierany w trybie tekstowym, a zatem podczas jego otwierania parametr tryb nie może zawierać modyfikatora t (por. opis funkcji fopen). Przykład zastosowania funkcji fread do odczytania zawartości pliku i wysłania jej do przeglądarki jest widoczny na listingu 3.13 — dane odczytywane są w paczkach po 4096 bajtów. Listing 3.13. Odczyt danych za pomocą funkcji fread
Rozdział 3. ♦ Współpraca z systemem plików

193

} else{ while(!feof($fd)){ echo fread($fd, 4096); } fclose($fd); } ?>

Tego typu skrypt można również przekonstruować w taki sposób, aby nie było konieczności wywoływania funkcji feof testującej osiągnięcie końca pliku, co według niektórych źródeł powinno spowodować osiągnięcie nieco większej wydajności. Wystarczy zauważyć, że jeżeli ciąg zwrócony przez wywołanie fread będzie pusty (długość 0 bajtów), będzie to oznaczać, iż odczytane zostały już wszystkie dane z pliku. Pozwala to na skonstruowanie pętli while w postaci przedstawionej na listingu 3.14. Listing 3.14. Alternatywna metoda odczytu danych przy użyciu funkcji fread

Odczyt całej zawartości pliku Odczyt pełnej zawartości pliku można wykonać na kilka sposobów. Sposób pierwszy to wykorzystanie przedstawionej wyżej funkcji fread, której jako drugi argument zostanie przekazana wielkość pliku. Wartość tę można uzyskać, stosując omówioną wcześniej funkcję filesize. Przykładowy skrypt odczytujący tą metodą całą zawartość pliku o nazwie test.txt został przedstawiony na listingu 3.15. Listing 3.15. Odczyt pełnej zawartości pliku przy użyciu funkcji fread

194

PHP5. Praktyczny kurs

Czynność taka może również zostać przeprowadzona dużo prościej, jeśli skorzysta się z funkcji dedykowanych fpassthru, readfile lub file_get_contents. Wywołanie funkcji fpassthru ma schematyczną postać: fpassthru(deskryptor)

deskryptor to wskaźnik pliku zwrócony przez wywołanie fopen. Funkcja odczytuje

zawartość pliku i wysyła ją do standardowego wyjścia — w typowych zastosowaniach do przeglądarki. Zwracaną wartością jest liczba odczytanych bajtów lub też wartość false, jeżeli odczyt nie zakończył się powodzeniem. Odczyt i wysłanie do przeglądarki zawartości pliku testowego za pomocą fpassthru można zatem przeprowadzić, korzystając z kodu widocznego na listingu 3.16. Listing 3.16. Wykorzystanie funkcji fpassthru do wysłania zawartości pliku

Jeszcze prostsze jest użycie funkcji readfile. Przyjmuje ona jako argument ciąg znaków określający nazwę pliku i wysyła jego zawartość do bufora wyjściowego, co w opisywanych przypadkach będzie skutkowało wysłaniem danych do przeglądarki. Zwracaną wartością jest liczba odczytanych bajtów, czyli wielkość pliku, lub też wartość false, jeśli wykonanie operacji zakończyło się niepowodzeniem. Aby zatem wysłać zawartość pliku test.txt do przeglądarki, wystarczy wykonać tylko jedną instrukcję: readfile('test.txt');

W podobny sposób działa też file_get_contents. Jako argument przyjmuje ona nazwę pliku6, zwraca natomiast jego odczytaną zawartość w postaci wartości typu string lub wartość false, jeśli odczyt się nie udał. Odczytanie zawartości pliku test.txt za pomocą file_get_contents i wysłanie go do przeglądarki będzie zatem wymagało użycia instrukcji: echo file_get_contents('test.txt');

lub też dwóch instrukcji: $str = file_get_contents('test.txt'); echo $str;

6

Funkcja może przyjmować do pięciu argumentów. Pozwala ona m.in. na odczyt określonej liczby bajtów, poczynając od wskazanego miejsca w pliku. Jej dokładny opis można znaleźć w dokumentacji PHP.

Rozdział 3. ♦ Współpraca z systemem plików

195

Oprócz opisanych do tej pory funkcji istnieje jeszcze jedna o nazwie file, która odczytuje zawartość pliku o zadanej nazwie i zwraca jego zawartość w postaci takiej tablicy, gdzie każda jej kolejna komórka zawiera kolejny wiersz odczytanego tekstu. Wynika z tego oczywiście, że tę funkcję należy stosować do odczytu plików tekstowych. Aby zatem pobrać zawartość pliku o nazwie test.txt i wysłać go do przeglądarki, numerując dodatkowo każdy jego wiersz (od zera), można wykorzystać kod widoczny na listingu 3.17. Listing 3.17. Wykorzystanie funkcji file $val){ $str = nl2br("$key. $val"); echo $str; } ?>

W wywołaniu funkcji file można stosować opcjonalny drugi argument zawierający jedną z poniższych wartości lub listę tych wartości połączonych operatorem sumy bitowej |:  FILE_USE_INCLUDE_PATH — jeśli pliku o wskazanej nazwie nie będzie

w bieżącym katalogu, zostaną przeszukane foldery wymienione w opcji konfiguracyjnej INCLUDE_PATH.  FILE_IGNORE_NEW_LINES — zostaną zignorowane znaki końca linii.  FILE_SKIP_EMPTY_LINES — zostaną zignorowane puste linie.

Jeżeli zatem trzeba wczytać do tablicy $arr zawartość pliku test.txt, pomijając przy tym puste linie oraz znaki końca wiersza, można zastosować wywołanie: $arr = file('test.txt', FILE_IGNORE_NEW_LINES, FILE_SKIP_EMPTY_LINES);

Zapis danych Przydatne funkcje Zapis danych do pliku może być przeprowadzony za pomocą funkcji fwrite (można też korzystać z jej aliasu fputs) lub file_put_contents. Przyjrzyjmy się najpierw pierwszej z nich. Przyjmuje ona trzy argumenty, a jej schematyczne wywołanie ma postać: fwrite(deskryptor, str[, ile])

gdzie:  deskryptor — to deskryptor pliku zwrócony przez wywołanie funkcji fopen.  str — to ciąg typu string zawierający dane, które mają zostać zapisane.  ile — to opcjonalny parametr wskazujący, ile bajtów z ciągu str ma zostać

zapisanych.

196

PHP5. Praktyczny kurs

Ostatni argument jest opcjonalny i jeśli zostanie pominięty, do pliku zostanie zapisana cała zawartość ciągu str. Funkcja zwraca liczbę faktycznie zapisanych bajtów lub wartość false, jeśli zapis z jakichś względów się nie powiódł. Na listingu 3.18 został zaprezentowany fragment kodu, w którym użyto funkcji fwrite do zapisania przykładowego ciągu znaków do pliku o nazwie test.txt. Listing 3.18. Zapis do pliku

Drugą funkcją, która pozwala na zapis danych do pliku, jest file_put_contents. Upraszcza ona to zadanie, jako że jest swoistym połączeniem fopen, fwrite i fclose (nie była jednak dostępna we wcześniejszych wersjach PHP). Ta funkcja może przyjmować do czterech parametrów, dla nas jednak interesujące są trzy pierwsze. Schematyczne wywołanie jest więc następujące: file_put_contents("nazwa_pliku", dane[, flagi]);

Oznacza ono zapisanie danych wskazywanych przez argument dane do pliku o nazwie wskazywanej przez argument nazwa_pliku. Argument dane może być ciągiem znaków bądź tablicą7. Parametr flagi może przyjmować następujące wartości:  FILE_USE_INCLUDE_PATH — obecność pliku będzie sprawdzana w lokalizacjach wskazanych przez zmienną konfiguracyjną include_path.  FILE_APPEND — dane będą dopisywane na końcu pliku.  LOCK_EX — plik zostanie zablokowany na czas zapisu.

W codziennej pracy przyda się wartość FILE_APPEND, która pozwala na modyfikację zachowania funkcji w sytuacji, gdy plik istnieje na dysku. W takim przypadku, jeżeli parametr flagi nie zostanie zastosowany, dotychczasowe dane z pliku zostaną skasowane, jeśli zaś przyjmie wartość FILE_APPEND, nowe dane zostaną dopisane na końcu pliku. Zapis przykładowego ciągu za pomocą funkcji file_put_contents może zatem zostać zrealizowany przy wykorzystaniu fragmentu kodu przedstawionego na listingu 3.19. 7

Może też wskazywać strumień danych. Omówienie tego tematu wykracza poza ramy niniejszej publikacji.

Rozdział 3. ♦ Współpraca z systemem plików

197

Listing 3.19. Dopisywanie danych na końcu pliku

Napis zawarty w zmiennej $str będzie dopisywany na końcu pliku test.txt za każdym wywołaniem takiego skryptu. Przy pierwszym wywołaniu ten plik zostanie utworzony (o ile nie ma go w katalogu, w którym znajduje się kod skryptu). Gdyby podczas zapisu miała być kasowana poprzednia zawartość pliku test.txt, wywołanie file_put_ contents powinno mieć postać: file_put_contents("./test.txt", $str)

Zapis danych w praktyce Wykorzystajmy teraz zdobyte dotychczas w tej lekcji wiadomości do napisania kodu, który będzie zapisywał w pliku tekstowym opinie użytkowników o witrynie WWW. Na stronie będzie wyświetlany formularz umożliwiający wprowadzenie dowolnego tekstu (rysunek 3.8) oraz dotychczas wprowadzone opinie. Opinie wprowadzane przez użytkowników będą z kolei zapisywane w pliku o nazwie opinie.txt umieszczonym w tym samym katalogu co plik z kodem PHP (oczywiście nazwy i lokalizacje plików można dowolnie zmieniać we własnym zakresie). Rysunek 3.8. Wygląd formularza umożliwiającego wprowadzanie opinii

Skrypt będzie wykonywał trzy następujące zadania:

198

PHP5. Praktyczny kurs  dopisanie opinii na końcu pliku opinie.txt (o ile została ona przekazana

w postaci parametru);  wyświetlenie formularza;  wyświetlenie dotychczasowych opinii z pliku opinie.txt.

Kod działający w taki sposób został przedstawiony na listingu 3.20. Należy go zapisać w pliku index.php. W przypadku nadania plikowi innej nazwy konieczna będzie odpowiednia modyfikacja parametru action znacznika

. Listing 3.20. Skrypt zbierający i wyświetlający opinie

Wyraź swoją opinię:
(maksymalnie 255 znaków)

Dotychczasowe opinie:

Rozdział 3. ♦ Współpraca z systemem plików

199

?>

Treść pliku rozpoczyna się od kodu PHP, który sprawdza, czy za pomocą metody GET do skryptu został przekazany parametr o nazwie opinia. Jeśli tak, oznacza to, że użytkownik wypełnił formularz i przesłał opinię (lub użył bezpośredniego odwołania, wpisując na przykład opinię do adresu URL). Odczytywana jest zatem wartość tego parametru, a jego długość skracana do 255 znaków (przyjmujemy, że opinia nie może być dłuższa, oczywiście ten parametr może być dowolnie modyfikowany). Za wykonanie tej czynności odpowiada funkcja substr (por. lekcja 8. z rozdziału 2.). Po skróceniu ciągu jest on poddawany działaniu funkcji strip_tags, która usuwa ewentualne znaczniki HTML i PHP8. Ta czynność jest potrzebna, a wręcz niezbędna, gdyż wprowadzenie przez użytkownika znaczników HTML do opinii mogłoby spowodować różne niespodziewane efekty podczas wyświetlania danych (znaczniki zostałyby zinterpretowane przez przeglądarkę; por. przykład z cookies w lekcji 15. z rozdziału 4.). Funkcja zwróci ciąg, który został jej przekazany w postaci argumentu, pozbawiony znaczników. Jeżeli wartość otrzymana w wyniku tych wszystkich operacji (zawartość zmiennej $str) zawiera jakieś dane (nie jest pustym ciągiem znaków — $str != ""), jest zapisywana w pliku opinie.txt za pomocą funkcji file_put_contents. Ponieważ został użyty argument FILE_APPEND, dane zostaną dopisane na końcu pliku. Za pierwszym fragmentem kodu PHP znajduje się kod HTML generujący formularz. Wykorzystywane są w nim standardowe znaczniki

, i <input>. Dane z formularza są przesyłane za pomocą metody GET, na co wskazuje parametr method znacznika <form>. Za kodem formularza został umieszczony drugi fragment kodu PHP, który odpowiada za odczytanie danych z pliku opinie.txt i wyświetlenie ich na stronie. Rozpoczyna się on od wywołania funkcji file_exists sprawdzającej, czy plik z danymi faktycznie istnieje. Jeśli istnieje, wykonywane są dalsze czynności. Treść opinii jest odczytywana za pomocą funkcji file_get_contents i przypisywana zmiennej $str, która jest następnie poddawana działaniu dwóch funkcji — strip_tags oraz nl2br. Pierwsza z nich, jak już wiadomo, usuwa znajdujące się w ciągach znaków znaczniki HTML i PHP. Wydawać by się mogło, że skoro usuwamy je podczas zapisu danych, to w tym miejscu wywołanie tej funkcji jest niepotrzebne. Niestety nie możemy mieć 100% pewności, że dane w pliku opinie.txt na pewno są poprawne. Mogły być przecież, nawet przez nieuwagę, edytowane ręcznie. Funkcja strip_tags jest więc tu wywoływana na wszelki wypadek. 8<br /> <br /> Można też rozważyć odwrotną kolejność czynności, tzn. najpierw usunąć znaczniki, a dopiero potem skracać ciąg, o ile jest zbyt długi. Takie postępowanie byłoby jednak pewną niekonsekwencją. Skoro bowiem pozwalamy użytkownikowi wprowadzić co najwyżej 255 znaków, to powinniśmy uwzględniać wszystkie wprowadzone (otrzymane przez skrypt) dane.<br /> <br /> 200<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Druga funkcja — nl2br — jest już również dobrze znana i powoduje zamianę znaków końca linii na znaczniki <br />, które sprawiają, że tekst jest odpowiednio sformatowany. Po wykonaniu opisanych przekształceń treść zmiennej $str jest wysyłana do przeglądarki za pomocą instrukcji echo. Należy zwrócić uwagę, że w skrypcie została wykonana tylko bardzo podstawowa weryfikacja danych (sprawdzenie długości oraz usunięcie znaczników HTML i PHP). Dzięki niej użytkownik nie wprowadzi zbyt długiego wpisu ani kodu, który mógłby zostać zinterpretowany przez przeglądarkę. Ma jednak możliwość wysłania wszelkich dostępnych kodów znaków, w tym również takich, które nie mają odpowiedników alfanumerycznych. Wystarczy przygotować i wywołać odpowiedni URL, np.: http://localhost/index.php?opinia=abc%02%03%04%05%06<br /> <br /> W praktyce pozwala to na wysłanie dowolnych bajtów. Takie dane też zostaną zapisane w pliku opinie.txt i przeglądarka będzie próbowała je wyświetlać. Efekt zależy od rodzaju przeglądarki, np. w przypadku Firefoksa efekt może wyglądać tak jak na rysunku 3.9. A zatem w praktycznych zastosowaniach zasadne jest dodatkowe filtrowanie otrzymywanych danych. Można np. ograniczać dopuszczalne znaki do z góry ustalonego zestawu i usuwać wszelkie inne. Z reguły stosuje się w tym celu wyrażenie regularne. Aby na przykład pozostawić w ciągu tylko znaki alfabetu łacińskiego (duże i małe), białe znaki (spacje, znaki końca wiersza itp.), podkreślenie, kropkę wykrzyknik oraz łącznik (minus), można zastosować preg_replace w postaci: $str = preg_replace('/[^a-zA-Z0-9\s_.!\-]/', '', $str);<br /> <br /> Rysunek 3.9. Wyświetlone w przeglądarce Firefox niestandardowe znaki wprowadzone do pliku z opiniami<br /> <br /> Niestety dokładne omówienie tematu wyrażeń regularnych wykracza poza ramy tematyczne książki9.<br /> <br /> 9<br /> <br /> Stosowanie wyrażeń regularnych zostało omówione m.in. w publikacji JavaScript. Praktyczny kurs (http://helion.pl/ksiazki/jscpk.htm).<br /> <br /> Rozdział 3. ♦ Współpraca z systemem plików<br /> <br /> 201<br /> <br /> Inne operacje Zmiana pozycji wewnątrz pliku Jak zostało to już wspomniane, odczyt danych powoduje przesuwanie wskaźnika pozycji w pliku, dzieje się to jednak automatycznie, bez wiedzy programisty. Istnieje jednak możliwość odczytania aktualnej pozycji tego wskaźnika, a także zmiany jego wartości. Służą do tego trzy funkcje: ftell, fseek i rewind. Funkcja ftell zwraca aktualną pozycję w pliku w postaci wartości typu int. Przyjmuje ona jako argument deskryptor pliku otwartego za pomocą fopen. Na listingu 3.21 jest widoczny prosty skrypt, który odczytuje z pliku tekstowego kolejne wiersze i wyświetla je, podając jednocześnie aktualną pozycję wskaźnika. Listing 3.21. Uzyskanie informacji o położeniu wskaźnika pozycji w pliku <?php if(!$fd = fopen('test.txt', 'r')){ echo("Nie mogę otworzyć pliku test.txt."); } else{ while(!feof($fd)){ $str = fgets($fd); $str = trim($str); $pos = ftell($fd); echo("Po odczytaniu linii: \"$str\" "); echo("wskaźnik pozycji w pliku ma wartość $pos.<br \>"); } fclose($fd); } ?><br /> <br /> Przykładowy efekt działania kodu został zaprezentowany na rysunku 3.10. Zwróćmy uwagę, że w przypadku dwóch pierwszych linii wskaźnik pozycji w pliku był zwiększany o 5 (z 0 na 5, i z 5 na 10), gdy tymczasem każda z linii ma tylko po trzy znaki. Skąd ten efekt? Otóż wskaźnik pozycji uwzględnia wszystkie odczytane znaki, a więc również znaki końca linii (i inne tzw. białe znaki), które zostały usunięte za pomocą funkcji trim, gdyż i tak (z wyjątkiem znaku spacji) nie mogłyby być poprawnie wyświetlone. Co więcej, można się domyślać, że tekst zawarty w pliku test.txt był tworzony w którymś z systemów rodziny Windows, gdyż właśnie w nich znak końca linii składa się z dwóch znaków. W Linuksie i systemach z rodziny MacOS należy się spodziewać, że kolejnymi wartościami wskaźnika dla trójznakowych wierszy tekstu byłyby: 4 i 8. Rysunek 3.10. Odczyt danych z wyświetleniem wartości wskaźnika pliku<br /> <br /> 202<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Aktualna pozycja w pliku może zostać zmieniona za pomocą funkcji fseek. Jej schematyczne wywołanie ma postać: fseek(deskryptor, ile[, skąd])<br /> <br /> deskryptor to deskryptor pliku zwrócony przez funkcję fopen, ile określa liczbę bajtów przesunięcia, natomiast skąd określa pozycję, od której nastąpi przesunięcie. Parametr skąd jest opcjonalny i może przyjmować następujące wartości:  SEEK_SET — oznacza przesunięcie względem początku pliku,  SEEK_CUR — oznacza przesunięcie względem pozycji bieżącej,  SEEK_END — oznacza przesunięcie względem końca pliku.<br /> <br /> Jeżeli parametr ten nie zostanie podany, funkcja zachowa się tak, jakby miał on wartość SEEK_SET. Jeśli na przykład zmienna $fd zawiera deskryptor pliku zwrócony przez funkcję fopen, to wywołanie:  fseek($fd, 0) — ustawi wskaźnik na początku pliku.  fseek($fd, 0, SEEK_SET) — ustawi wskaźnik na początku pliku.  fseek($fd, 0, SEEK_END) — ustawi wskaźnik na końcu pliku.  fseek($fd, 20, SEEK_SET) — ustawi wskaźnik na 20 bajcie pliku.  fseek($fd, -10, SEEK_CURR) — ustawi wskaźnik na 10 bajcie przed<br /> <br /> aktualną pozycją w pliku.  fseek($fd, 10, SEEK_CURR) — ustawi wskaźnik na 10 bajcie za aktualną<br /> <br /> pozycją w pliku.  fseek($fd, -10, SEEK_END) — ustawi wskaźnik na 10 bajcie przed<br /> <br /> końcem pliku. Funkcja fseek zwraca wartość 0, jeżeli jej wywołanie zakończyło się sukcesem, lub wartość –1 w przeciwnym razie. Uwaga! Nie należy jej używać dla plików otwartych w trybach a i a+, gdyż w takim przypadku zwrócone wyniki są nieużyteczne. Ostatnia z omawianych funkcji — rewind — przesuwa wskaźnik pozycji w pliku na pozycję 0, czyli na jego początek. Jej wywołanie ma zatem takie samo znaczenie jak fseek($fd, 0, SEEK_SET). Funkcja rewind przyjmuje tylko jeden argument, którym jest deskryptor pliku, i zwraca wartość true, jeżeli wykonywana operacja zakończyła się sukcesem, lub wartość false, jeżeli ustawienie wskaźnika nie powiodło się.<br /> <br /> Synchronizacja dostępu do plików Jeżeli nie zadbamy o prawidłową synchronizację dostępu, przechowywanie danych w plikach może przysporzyć nam wielu problemów. Co się bowiem stanie, jeśli naszą witrynę odwiedzi naraz kilka osób i wszystkie wywołają skrypt operujący na danych zapisanych w jednym z plików? Rezultat niestety może być całkowicie nieprzewidywalny. Dane mogą wprawdzie zostać zapisane poprawnie, ale również mogą zostać<br /> <br /> Rozdział 3. ♦ Współpraca z systemem plików<br /> <br /> 203<br /> <br /> utracone lub przemieszane ze sobą. Nie będzie to miało tak wielkiego znaczenia, jeśli skrypt obsługuje jedynie licznik odwołań do strony (najwyżej zgubimy część odwołań), jednak już w przypadku skryptu obsługującego zamówienia w sklepie internetowym konsekwencje mogą być poważne. Jak rozwiązać ten problem? W przypadku bardziej złożonych serwisów po prostu najlepiej zrezygnować z przechowywania danych w plikach i skorzystać z systemów baz danych, co dodatkowo rozwiąże wiele innych problemów (współpraca PHP z bazami danych zostanie omówiona w rozdziale 8.). W praktyce często w przypadku serwisów pracujących pod małym obciążeniem i skryptów typu licznik lub księga gości problem synchronizacji po prostu się pomija (tak jest np. w przykładzie z listingu 3.20). Jeśli jednak koniecznie musimy użyć plików i chcemy być pewni, że nie wystąpią usterki, można do synchronizacji dostępu do pliku użyć funkcji flock. Wywołanie funkcji flock powoduje założenie takiej blokady na dany plik, że dostęp do niego będzie miał tylko skrypt, który tę funkcję wywołał. Wywołanie ma postać10: flock(deskryptor, operacja)<br /> <br /> deskryptor to deskryptor pliku zwrócony przez funkcję fopen, natomiast operacja określa rodzaj blokowania. Funkcja zwraca wartość true, jeżeli udało się uzyskać blokadę, lub też wartość false w przeciwnym razie.<br /> <br /> Parametr tryb może przyjmować następujące argumenty:  LOCK_SH — blokada zapisu, możliwy odczyt (shared lock).  LOCK_EX — pełna blokada (exclusive lock).  LOCK_UN — zwolnienie blokady.<br /> <br /> W przypadku gdy uzyskanie blokady nie jest możliwe w chwili wywołania (np. inny skrypt założył blokadę i dokonuje operacji na pliku), wykonywanie zostanie wstrzymane, aż blokada będzie możliwa (lub zostanie przekroczony maksymalny czas wykonania skryptu). To zachowanie można zmienić, łącząc za pomocą operatora | jedną z wymienionych wartości z ciągiem LOCK_NB (np. LOCK_EX | LOCK_NB). W efekcie w przypadku niemożności założenia blokady funkcja od razu zakończy działanie (ta opcja nie jest obsługiwana w systemach z Windows). Schematyczny kod wykorzystujący flock do blokady zapisu do pliku będzie miał postać: <?php if(!$fd = fopen('test.txt', 'tryb_otwarcia')){ echo "Nie mogę otworzyć pliku test.txt."; } else{ if(!flock($fd, LOCK_EX)){ echo "Nie mogę założyć blokady pliku test.txt.";<br /> <br /> 10<br /> <br /> W systemach innych niż Windows dopuszczalne jest przekazanie przez referencję opcjonalnego trzeciego argumentu, który zostanie ustawiony na true, jeżeli funkcja rozpocznie oczekiwanie na możliwość założenia blokady (blokada nie będzie możliwa od razu po wywołaniu).<br /> <br /> 204<br /> <br /> PHP5. Praktyczny kurs } else{ // //operacje na pliku // } if(!flock($fd, LOCK_UN)){ echo "Nie mogę zdjąć blokady pliku test.txt."; } fclose($fd); } ?><br /> <br /> Podczas korzystania z flock należy pamiętać, że w niektórych systemach flock może być zaimplementowana na poziomie procesu, co oznacza, że jeżeli wywołanie poszczególnych instancji skryptu odbywa się w różnych procesach, funkcja nie będzie działać poprawnie (taka sytuacja będzie miała miejsce np. podczas korzystania z ISAPI). Funkcja flock nie działa również w przypadku przestarzałych systemów plików, jak np. FAT.<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 11.1. Zmodyfikuj kod z listingu 3.12 w taki sposób, aby odczytane wiersze tekstu były kolejno numerowane. Ćwiczenie 11.2. Zmodyfikuj skrypt z listingu 3.20 tak, aby do zapisu danych zamiast file_put_contents była wykorzystywana funkcja fwrite. Ćwiczenie 11.3. Zmodyfikuj skrypt z listingu 3.20 w taki sposób, aby nowe opinie były zapisywane na początku pliku opinie.txt. Ćwiczenie 11.4. Napisz skrypt zamieniający polskie litery na ich łacińskie odpowiedniki w pliku tekstowym o zadanej nazwie. Ćwiczenie 11.5. Napisz skrypt odwracający kolejność wierszy w pliku tekstowym (tzn. ostatni wiersz ma się stać pierwszym, przedostatni drugim itd.).<br /> <br /> Lekcja 12. Praktyczne wykorzystanie plików W lekcji 11. zostało pokazane, w jaki sposób wykonuje się różne operacje na plikach. Spróbujmy więc wykorzystać tę wiedzę w praktyce do utworzenia kilku prostych skryptów. Zobaczymy, jak tworzyć licznik, ankietę, system logowania czy listę odwiedzin strony. Będą to więc proste skrypty, których realizacja może być bez problemów oparta na systemie plików. Zaczniemy od zwykłego tekstowego licznika odwiedzin witryny.<br /> <br /> Rozdział 3. ♦ Współpraca z systemem plików<br /> <br /> 205<br /> <br /> Tekstowy licznik odwiedzin Licznik ukazujący liczbę odwiedzin witryny to często spotykany element stron WWW. Jego realizacja za pomocą PHP jest bardzo prosta. Dane będą zapisywane w postaci tekstowej w pliku o nazwie counter.txt. Każde wywołanie skryptu będzie powodowało otwarcie tego pliku, odczyt znajdujących się w nim danych, zwiększenie odczytanej wartości o jeden i ponowny zapis — zaktualizowanych już danych — do pliku. Przykładowy skrypt działający w opisany sposób został przedstawiony na listingu 3.22. Listing 3.22. Realizacja prostego licznika tekstowego <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <div style='text-align:center;'> Treść witryny </div> <div><p style='text-align:center;'> <?php function getCounter() { if(!file_exists("./licznik.txt")){ //brak pliku licznika return false; } if(!$fd = fopen("./licznik.txt", "r+")){ //brak dostępu do pliku licznika return false; } flock($fd, LOCK_EX); $count = fgets($fd); if(is_numeric($count)){ $result = $count + 1; fseek($fd, 0); fputs($fd, $result); } else{ //nieprawidłowy format odczytanych danych $result = false; } flock($fd, LOCK_UN); fclose($fd); return $result; } if(($count = getCounter()) !== false){ if($count == 1){ $razy = 'raz'; } else{ $razy = 'razy'; }<br /> <br /> 206<br /> <br /> PHP5. Praktyczny kurs echo "Ta strona została odwiedzona $count $razy " . "od 20 maja 2012 roku."; } else{ echo "Licznik odwołań jest czasowo niedostępny."; } ?> </p></div> </body> </html><br /> <br /> Plik licznik.txt trzeba utworzyć samodzielnie i zapisać w tym samym katalogu co plik z kodem skryptu. Oczywiście ta lokalizacja może być dowolnie zmieniana, co jednak będzie wymagało zmiany odwołań w kodzie. Za przetwarzanie danych odpowiada funkcja getCounter, której zadaniem jest zwrócenie liczby odwołań lub wartości false w przypadku wystąpienia błędu. Działanie getCounter rozpoczyna się od sprawdzenia, czy plik o nazwie counter.txt istnieje. W tym celu wykorzystywana jest funkcja file_exists. Jeśli istnieje, jest otwierany w trybie r+ (czyli do odczytu i zapisu), w przeciwnym razie funkcja kończy działanie, zwracając wartość false. Podobnie jeśli otwarcie pliku (wykonywane za pomocą funkcji fopen) się nie powiedzie, czyli kiedy zmienna $fd przechowująca jego deskryptor będzie miała wartość false, funkcja zakończy działanie. Po uzyskaniu deskryptora (zmienna $fd) dostęp do pliku jest blokowany przez wywołanie funkcji flock (zgodnie z opisem z lekcji 11.). Nie jest przy tym badane, czy blokadę udało się uzyskać. Zakładamy, że nawet gdyby się to nie udało, ewentualne (i mało prawdopodobne) zafałszowanie danych z licznika nie ma większego znaczenia. Kolejny etap to odczytanie z pliku counter.txt za pomocą funkcji fgets zawartej w nim wartości opisującej liczbę odwołań. Po odczycie, na wszelki wypadek, wykonywane jest również sprawdzenie, czy odczytana wartość jest wartością numeryczną, czyli czy opisuje jakąś liczbę. To sprawdzenie jest wykonywane przez funkcję is_numeric, która zwraca wartość true, jeśli przekazany jej argument może być interpretowany jako wartość numeryczna, lub false w przeciwnym razie. Jeśli z pliku została odczytana wartość liczbowa, jest ona zwiększana o 1 ($result = $count + 1;) i zapisywana w zmiennej $result. Następnie wskaźnik pozycji w pliku jest przesuwany na jego początek [fseek($fd, 0);], a zaktualizowana liczba odwiedzin jest zapisywana ponownie w pliku counter.txt [fputs($fd, $count);]. Jeżeli z pliku nie została odczytana wartość liczbowa, zmiennej $result jest przypisywana wartość false. Na zakończenie zdejmowana jest blokada (flock($fd, LOCK_UN);), plik zamykany (fclose($fd);), a wartość zapisana w $result jest zwracana jako wynik działania funkcji getCounter. Wartość zwrócona przez getCounter jest wykorzystywana w dalszej części skryptu do wyświetlenia liczby odwiedzin, czego przykład został zaprezentowany na rysunku 3.11. W przypadku gdyby wymieniona funkcja zwróciła false, co oznaczałoby wystąpienie błędu w trakcie jej działania, na ekranie zamiast liczby odwiedzin pojawi się komunikat o niedostępności licznika.<br /> <br /> Rozdział 3. ♦ Współpraca z systemem plików<br /> <br /> 207<br /> <br /> Rysunek 3.11. Przykładowy wygląd licznika tekstowego<br /> <br /> Licznik wykorzystujący grafikę W poprzednim przykładzie zostało pokazane, w jaki sposób umieścić na stronie WWW prosty licznik tekstowy pokazujący liczbę odwiedzin. Rozwiązanie to można urozmaicić poprzez zaprezentowanie danych w postaci graficznej. W tym celu trzeba przygotować dziesięć obrazów przedstawiających kolejne cyfry od 0 do 9. Do ich wykonania można wykorzystać dowolny edytor graficzny lub poszukać gotowych grafik w internecie. Obrazy należy zapisać w plikach, których nazwy odpowiadają poszczególnym cyfrom, czyli 0.jpg, 1.jpg itd. Struktura skryptu generującego licznik w postaci graficznej będzie bardzo podobna do struktury prezentowanego wcześniej licznika tekstowego. Dane o liczbie odwiedzin będą przechowywane w pliku o nazwie licznik.txt, a za przetwarzanie danych będzie odpowiedzialna funkcja getCounter. Plik będzie otwierany za pomocą funkcji fopen, a pierwszy wiersz tekstu odczytywany za pomocą funkcji fgets. Odczytana liczba zostanie zwiększona o jeden i ponownie zapisana w pliku licznik.txt za pomocą funkcji fputs (nie jest przy tym używana zmienna pomocnicza $result, jak miało to miejsce w poprzednim przykładzie, ale wszystkie operacje są wykonywane na zmiennej $count). Dalsze postępowanie będzie jednak inne. Aby liczba odwiedzin została wyświetlona w postaci graficznej, zamiast tekstu muszą zostać wyświetlone przygotowane obrazy cyfr z plików. Zostaną one umieszczone na stronie za pomocą znaczników HTML — <img>. Do wygenerowania serii tych znaczników wykorzystywana będzie pętla for. Pobierze ona kolejne znaki z ciągu $count i doklei do nich końcówkę .jpg (jeśli pliki zostały zapisane w innym formacie, należy oczywiście zmienić odpowiednio nazwę rozszerzenia). W ten sposób powstaną nazwy plików zawierających cyfry, które mają stać się wartościami argumentów src znaczników <img>. Przykładowo dla liczby 123 zostanie wygenerowany ciąg znaczników w postaci: <img src='1.jpg' alt='1' /><img src='2.jpg' alt='2' /><img src='3.jpg' alt='3' /><br /> <br /> i taki ciąg zostanie wysłany do przeglądarki (dzięki użyciu atrybutu alt skrypt zadziała poprawnie nawet wtedy, gdy na serwerze nie będzie plików graficznych; zadziała wtedy tak jak licznik tekstowy). Kod skryptu działającego w opisany sposób został przedstawiony na listingu 3.23 (pominięta została część HTML, która będzie taka sama jak w przykładzie z listingu 3.22), a przykładowy efekt jego działania jest widoczny na rysunku 3.12.<br /> <br /> 208<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Listing 3.23. Graficzny licznik odwiedzin <?php function getCounter() { if(!file_exists("./licznik.txt")){ //brak pliku licznika return false; } if(!$fd = fopen("./licznik.txt", "r+")){ //brak dostępu do pliku licznika return false; } flock($fd, LOCK_EX); $count = fgets($fd); if(is_numeric($count)){ $count = $count + 1; fseek($fd, 0); fputs($fd, $count); } else{ //nieprawidłowy format odczytanych danych $count = false; } flock($fd, LOCK_UN); fclose($fd); if($count === false){ return false; } $imgStr = ""; $count = strval($count); $strLength = strlen($count); for($i = 0; $i < $strLength; $i++){ $temp = "{$count[$i]}" . '.jpg'; $imgStr .= "<img src='$temp' alt='{$count[$i]}' />"; } return $imgStr; } if(($count = getCounter()) !== false){ if($count == 1){ $razy = 'raz'; } else{ $razy = 'razy'; } echo "Ta strona została odwiedzona $count $razy " . "od 20 maja 2012 roku."; } else{ echo "Licznik odwołań jest czasowo niedostępny."; } ?><br /> <br /> Rozdział 3. ♦ Współpraca z systemem plików<br /> <br /> 209<br /> <br /> Rysunek 3.12. Przykładowy wygląd licznika graficznego<br /> <br /> Lista odnośników Nieodłącznym elementem wielu stron WWW jest lista odnośników do innych witryn. Taka lista często tworzona jest statycznie przez ręczne wpisanie do kodu HTML znaczników <a>. Dzięki zastosowaniu PHP można zautomatyzować tę czynność, co ułatwi zarządzanie serwisem. Wszystkie adresy, wraz z ich opisami, zostaną umieszczone w pliku tekstowym o nazwie np. links.txt. Każdy wiersz tego pliku będzie miał schematyczną postać: http://adres.odnośnika/ Opis adresu<br /> <br /> czyli będzie się zaczynał od adresu, po którym nastąpi znak spacji oraz opis tego adresu. Przykładowo wpis dla strony wydawnictwa Helion mógłby mieć postać: http://helion.pl/ Strona wydawnictwa Helion<br /> <br /> Skrypt pobierający tak przygotowane dane i tworzący z nich listę odnośników został przedstawiony na listingu 3.24, a przykładowy efekt jego działania jest widoczny na rysunku 3.13. Listing 3.24. Skrypt generujący listę odnośników <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <div> <?php if(!($fd = fopen("links.txt", "r"))){ echo "Lista odnośników jest w tej chwili niedostępna."; } else{ echo "<ul>\n"; while (!feof ($fd)){ $line = trim(fgets($fd)); if(!($pos = strpos($line, ' '))){ $link = $line;<br /> <br /> 210<br /> <br /> PHP5. Praktyczny kurs $desc = $line; } else{ $link = substr($line, 0, $pos); $desc = substr($line, $pos + 1); } if($link != "" && $desc != ""){ echo "<li><a href=\"$link\" rel="nofollow">$desc</a></li>\n"; } } fclose($fd); echo "</ul>\n"; } ?> </div> </body> </html><br /> <br /> Rysunek 3.13. Efekt działania skryptu generującego listę odnośników<br /> <br /> Plik links.txt jest otwierany za pomocą standardowej funkcji fopen. Jeżeli ta operacja zakończy się sukcesem, kolejne wiersze pliku odczytywane będą w pętli while za pomocą funkcji fgets. Ponieważ do oddzielenia odnośnika od jego opisu jest wykorzystywany znak spacji, indeks pierwszego wystąpienia tego znaku jest odszukiwany za pomocą funkcji strpos (por. lekcja 8. z rozdziału 2.) i zapamiętywany w zmiennej $pos. Następnie odczytany wiersz dzielony jest na dwie części względem odnalezionego indeksu. Część zawierająca adres WWW jest zapisywana w zmiennej $link, a zawierająca opis tego adresu — w zmiennej $desc. W przypadku, gdyby wywołanie funkcji strpos zwróciło wartość false, czyli gdyby znak spacji nie został odnaleziony, przyjmowane jest, że odczytana linia zawiera jedynie adres WWW bez opisu. W takiej sytuacji zarówno zmiennej $link, jak i $desc jest przypisywany odczytany adres. Wartości zmiennych $link i $desc są dalej wykorzystywane do utworzenia odnośnika w postaci: <a href="$link" rel="nofollow">$desc</a><br /> <br /> który jest wysyłany do przeglądarki jako część listy generowanej za pomocą znaczników <ul> i <li>.<br /> <br /> Lista odwiedzin Wiedza o tym, kto odwiedza naszą witrynę, niewątpliwie bardzo pomaga w jej prowadzeniu. Z pewnością będzie więc przydatny skrypt, który udostępnia tego typu informa-<br /> <br /> Rozdział 3. ♦ Współpraca z systemem plików<br /> <br /> 211<br /> <br /> cje. Takie zadanie realizuje kod przedstawiony na listingu 3.2511. W pliku tekstowym o nazwie stats.txt zapisywane są dane dotyczące:  daty i czasu odwiedzin,  adresu IP,  typu przeglądarki. Listing 3.25. Lista z informacjami o odwiedzinach na stronie <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <p>Lista odwiedzin:</p> <div> <?php $stat_file = "./stats.txt"; function writeData($stat_file) { $file_str = ""; if(file_exists($stat_file)){ if(($file_str = file_get_contents($stat_file)) === false){ //Błąd przy próbie odczytu zawartości pliku return false; } } if(!$fd = fopen($stat_file, "w")){ //Błąd przy próbie otwarcia pliku return false; } $str = date("Y-m-d:G:i")." "; $str .= $_SERVER['REMOTE_ADDR']." "; if(isSet($_SERVER['HTTP_USER_AGENT'])){ $str .= $_SERVER['HTTP_USER_AGENT']; } $str .= "\n"; fwrite($fd, $str); fwrite($fd, $file_str); fclose($fd); return true; } function printData($stat_file) { if(!$fd = fopen($stat_file, "r")){<br /> <br /> 11<br /> <br /> Skrypt jest tylko demonstracją odczytu danych o użytkowniku i przechowywania ich w pliku tekstowym. Pominięta została kwestia synchronizacji dostępu do pliku z danymi (omówiona w lekcji 11.). Mógłby więc być stosowany na stronach pracujących pod stosunkowo niedużym obciążeniem. W przypadku witryn o bardzo dużej liczbie odwiedzin należałoby dodać odpowiednie instrukcje, choć z reguły stosuje się wtedy rozwiązania oparte na bazach danych (por. rozdział 8.).<br /> <br /> 212<br /> <br /> PHP5. Praktyczny kurs //Błąd przy próbie otwarcia pliku return false; } echo "<ol>"; while (!feof($fd)){ if(($str = fgets($fd)) != "") echo("<li>$str</li>\n"); } echo "</ol>"; return true; } if(!printData($stat_file)){ echo("Lista nie jest w tej chwili dostępna.<br />"); } writeData($stat_file); ?> </div> </body> </html><br /> <br /> Za zapis danych odpowiada funkcja writeData, która jako argument przyjmuje nazwę pliku z danymi. Najpierw odczytuje ona wszystkie dane zapisane wcześniej w pliku i umieszcza je w zmiennej o nazwie $file_str. Odczyt przeprowadzany jest za pomocą funkcji file_get_contents i odbywa się tylko wtedy, gdy plik o nazwie wskazywanej przez $stat_file faktycznie istnieje na dysku (jest to sprawdzane za pomocą funkcji file_exists). Następnie plik z danymi jest otwierany w trybie do zapisu, a jego deskryptor przypisywany zmiennej $fd. Data i czas aktualnych odwiedzin odczytywane są za pomocą funkcji date (por. lekcja 7. z rozdziału 2.), natomiast adres IP odwiedzającego oraz dane dotyczące typu przeglądarki i systemu operacyjnego z superglobalnej tablicy $_SERVER (więcej informacji o danych z tej tablicy zostanie przedstawionych w lekcji 7.). Adres IP znajduje się pod kluczem REMOTE_ADDR, natomiast dane dotyczące przeglądarki pod HTTP_USER_AGENT. Ponieważ niektóre przeglądarki pozwalają na wyłączenie wysyłania identyfikacji, przed odczytem sprawdzane jest, czy klucz HTTP_ USER_AGENT faktycznie istnieje w tablicy $_SERVER (używana jest instrukcja warunkowa if i funkcja isSet). Poszczególne elementy opisu łączone są w jeden ciąg i przypisywane zmiennej $str. Zawartość tej zmiennej jest następnie zapisywana do pliku wskazywanego przez deskryptor [fwrite($fd, $str)]. Zaraz potem do tego samego pliku zapisywana jest jego poprzednia zawartość pochodząca ze zmiennej $file_str (fwrite($fd, $file_str)). Dzięki temu informacje dotyczące ostatnich odwiedzin zawsze będą znajdowały się na początku pliku12. Za odczytanie danych i wyświetlenie ich w oknie przeglądarki (rysunek 3.14) odpowiada funkcja printData. Za pomocą funkcji fopen otwiera ona plik o nazwie przekazanej w argumencie $stat_file, a następnie w pętli while odczytuje z niego kolejne 12<br /> <br /> Warto jednak zauważyć, że w przypadku awarii skryptu po zapisaniu zmiennej str, ale przed zapisaniem file_str, może nastąpić utrata danych. Przypadek taki jest jednak bardzo mało prawdopodobny.<br /> <br /> Rozdział 3. ♦ Współpraca z systemem plików<br /> <br /> 213<br /> <br /> wiersze tekstu. Każdy jest uzupełniany o znaczniki <li> i </li>, a zatem staje się elementem listy numerowanej (<ol>). Dzięki temu każdy wpis otrzyma kolejny numer. Przy stosowaniu skryptu w tej postaci należy zwrócić uwagę, że w przypadku witryn o bardzo dużej liczbie odwiedzin wielkość pliku stats.txt będzie szybko rosła, zasadne będzie więc ograniczenie liczby wyświetlanych zapisów. Pozostanie to jednak zadaniem do samodzielnego wykonania. Rysunek 3.14. Lista ostatnich odwiedzin strony<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 12.1. Napisz skrypt licznika przechowującego w pliku z danymi oprócz liczby odwiedzin także datę początkową. Ćwiczenie 12.2. Napisz skrypt licznika, który nie będzie uwzględniał przeładowań (odświeżania) strony. Wykorzystaj pliki cookie. Ćwiczenie 12.3. Zmodyfikuj kod skryptu z listingu 3.25 w taki sposób, aby liczba wyświetlanych wpisów była ograniczana przez parametr przekazywany do skryptu za pomocą metody GET, a w przypadku gdy taki parametr nie zostanie przesłany bądź będzie miał wartość ujemną — aby wyświetlane były wszystkie dane. Ćwiczenie 12.4. Zmodyfikuj kod skryptu z listingu 3.25, tak aby w pliku stats.txt zapisywane było jedynie ostatnich 10 odwiedzin. Ćwiczenie 12.5. Napisz skrypt, w którym użytkownikom łączącym się z wybranych adresów IP zapisanych w pliku tekstowym będzie wyświetlana inna strona niż wszystkim pozostałym.<br /> <br /> 214<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Rozdział 4.<br /> <br /> Współpraca z przeglądarką Lekcja 13. Odbieranie danych z przeglądarki Formularze HTML Skrypty PHP bardzo często są wykorzystywane do odbierania i przetwarzania danych pochodzących z przeglądarki użytkownika. Najczęściej polega to na tym, że osoba przeglądająca stronę WWW wprowadza różne informacje do formularza HTML, które następnie (zazwyczaj po kliknięciu przycisku) są wysyłane do serwera, gdzie zajmuje się nimi kod PHP. Formularz definiowany jest za pomocą znacznika <form>, w którym jedynym obligatoryjnym atrybutem jest action. W najprostszej postaci będzie więc miał schematyczną postać: <form action="adres_skryptu"> <!-- tutaj definicje elementów formularza --> </form><br /> <br /> Wartością atrybutu action powinien być adres skryptu PHP (lub innego, jeśli korzystamy z innej techniki przetwarzania danych; to jednak jest książka o PHP) zajmującego się przetwarzaniem danych. Można użyć adresu bezwzględnego, np. http://www. mojadomena.com/skrypt.php, lub względnego, np. /skrypty/skrypt.php. W pierwszym przypadku dane zostaną dostarczone do skryptu skrypt.php znajdującego się w głównym katalogu serwera o adresie http://www.mojadomena.com, natomiast w drugim — do skryptu o nazwie skrypt.php, który znajduje się w podkatalogu skrypty na serwerze ze stroną WWW zawierającą formularz.<br /> <br /> 216<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Często spotyka się również opcjonalne atrybuty formularza. Są to m.in.:  accept — typ MIME dla plików wysyłanych poprzez formularz (np. image/png),  accept-charset — sposoby kodowania znaków w przesyłanych danych (np. utf-8, ISO-8852-2),  enctype — sposób kodowania danych wysyłanych do serwera (zwykle application/x-www-form-urlencoded lub multipart/form-data),  method — metoda wysyłania danych (z reguły get lub post).<br /> <br /> Atrybut method wskazuje metodę, która zostanie użyta do przesłania danych do serwera, może to być metoda GET (określana jako get) lub POST (określana jako post). Jeżeli nie zostanie użyty parametr method, przyjmuje się, że użyta zostanie metoda GET. Elementami składowymi formularza mogą być:  button — klasyczny przycisk,  checkbox — pole wyboru,  file — formularz wysyłania plików,  hidden — element ukryty,  image — obraz,  password — pole tekstowe do wpisywania haseł,  radio — pole wyboru,  reset — przycisk reset,  select — lista wyboru,  submit — przycisk submit,  text — pole tekstowe,  textarea — rozszerzone pole tekstowe.<br /> <br /> Każdy z tych elementów powinien mieć określony parametr name, dzięki któremu będzie możliwa jego identyfikacja w skrypcie PHP.<br /> <br /> Wysyłanie metodą GET W przypadku metody GET dane są przesyłane w adresie URL, który będzie miał wtedy schematyczną postać: http://adres.serwera/skrypt.php?parametr1=wartość1¶metr2=wartość2<br /> <br /> Jeśli weźmiemy pod uwagę, że adres URL ma zwykle ograniczoną długość (zależy to od przeglądarki oraz serwera) oraz że może zawierać jedynie ograniczony zestaw znaków ASCII, jasnym jest, iż ta metoda jest wykorzystywana jedynie do wymiany sto-<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 217<br /> <br /> sunkowo niedużych ilości danych (nie przesyłamy za jej pomocą np. plików i innych danych binarnych). Wszelkie dane, które nie mogą być przesyłane bezpośrednio w adresie URL, muszą być odpowiednio zakodowane (np. spacje zmieniane są na znaki +, a znaki niestandardowe, np. polskie litery, na sekwencje %XX, gdzie XX to kod ASCII danego znaku1). Ta czynność zostanie wykonana automatycznie przez przeglądarkę. Aby zobaczyć, jak to działa w praktyce, napiszmy kod prostego formularza zawierającego jedno pole tekstowe, który będzie wysyłał dane do skryptu o nazwie skrypt.php umieszczonego w katalogu głównym naszego serwera WWW. Kod HTML zawierający taki formularz jest widoczny na listingu 4.1. Listing 4.1. Kod przykładowego formularza HTML <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <form method="get" action="http://localhost/skrypt.php"> <div> <input type="text" name="pole1" /> <input type="submit" /> </div> </form> </body> </html><br /> <br /> Formularz (widoczny na rysunku 4.1) zawiera jedno pole tekstowe o nazwie pole1 oraz przycisk typu Submit, którego kliknięcie powoduje przesłanie danych do serwera. Wartość parametru method to get, a zatem dane zostaną przesłane do serwera za pomocą metody GET. Nazwę skryptu oraz adres serwera wskazuje parametr action, zostanie więc wywołany skrypt o nazwie skrypt.php znajdujący się na serwerze o lokalnym adresie http://localhost (prawidłowe byłoby również użycie adresu http://127.0.0.1/skrypt. php). Ponieważ zarówno kod HTML, jak i kod skryptu będą się znajdowały w tym samym katalogu na tym samym serwerze, można również w parametrze action pominąć dane dotyczące serwera. Tym samym mógłby mieć on postać: action="skrypt.php"<br /> <br /> Rysunek 4.1. Formularz generowany przez kod z listingu 4.1<br /> <br /> 1<br /> <br /> Dokładna specyfikacja formatu URL znajduje się w dokumencie RFC1738.<br /> <br /> 218<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Jeśli do pola tekstowego wprowadzimy przykładowy ciąg znaków, np. test, oraz klikniemy przycisk Wyślij zapytanie (napis na przycisku może być inny w zależności od zastosowanej przeglądarki), wówczas powstanie URL w postaci http://localhost/skrypt. php?pole1=test tak jak na rysunku 4.2. Przetworzony zostanie zatem skrypt znajdujący się w pliku skrypt.php na serwerze lokalnym localhost i zostaną mu przekazane wartości znajdujące się za znakiem ? odnośnika. W skrypcie możemy te wartości odczytać i wykorzystać do własnych celów. Oczywiście żadna strona nie zostanie wyświetlona, dopóki nie przygotujemy tego skryptu. Sprawdźmy więc, jak to zrobić. Rysunek 4.2. Odnośnik generowany w metodzie GET<br /> <br /> Aby odczytać dane przekazane do skryptu, należy skorzystać z superglobalnej tablicy $_GET (superglobalnej czyli predefiniowanej i dostępnej w każdym miejscu skryptu). Jako indeks tablicy należy zastosować nazwę pola (wartość atrybutu name elementu formularza HTML), z którego dane chcemy odczytać. Schematycznie konstrukcja taka ma postać: $zmienna = $_GET['nazwa_pola'];<br /> <br /> Na listingu 4.2 został przedstawiony skrypt odczytujący wartość pola tekstowego z formularza z listingu 4.1. Należy go zapisać w pliku skrypt.php. Jeżeli teraz wczytamy do przeglądarki kod HTML z listingu 4.1 (czyli odwołamy się do adresu http://localhost/ index.html), wpiszemy do pola tekstowego ciąg test i klikniemy przycisk Wyślij zapytanie, zostanie wywołany skrypt skrypt.php (http://localhost/skrypt.php), a na ekranie pojawi się widok zaprezentowany na rysunku 4.3. Listing 4.2. Odczyt danych z formularza HTML <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <p> <?php $zmienna = $_GET['pole1']; echo("Wartość pola pole1: $zmienna <br />"); ?> </p> </body> </html><br /> <br /> Przy przetwarzaniu formularzy przydatna jest funkcja isSet, która pozwala stwierdzić, czy dane pole formularza zostało ustawione, innymi słowy, czy została przekazana do skryptu wartość odpowiadająca temu polu (dokładniej rzecz ujmując: funkcja ta pozwala stwierdzić, czy istnieje zmienna lub komórka albo klucz tablicy; w omawianym<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 219<br /> <br /> Rysunek 4.3. Wynik działania skryptu odczytującego dane z formularza<br /> <br /> przypadku będzie to równoznaczne z tym, czy do skryptu została przekazana dana wartość). Aby pokazać sposób wykorzystania tej funkcji, utwórzmy formularz składający się z trzech pól wyboru typu radio. Odpowiedni kod HTML został zaprezentowany na listingu 4.3, a wygląd formularza widoczny jest na rysunku 4.4. Każde z pól ma taką samą wartość parametru name, a zatem tworzą one jedną grupę. Dzięki temu jednocześnie może być zaznaczone tylko jedno pole, są to więc opcje wykluczające. Każde pole ma jednak inną wartość parametru value, dzięki czemu w skrypcie będziemy je mogli łatwo zidentyfikować. Parametr action formularza wskazuje, podobnie jak we wcześniejszych przykładach, na skrypt znajdujący się w pliku skrypt.php na serwerze lokalnym o adresie localhost. Listing 4.3. Formularz zawierający elementy typu radio <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <form method="get" action="http://localhost/skrypt.php"> <div> <input type="radio" name="radio1" value="opcja1" /> Opcja1 <br /> <input type="radio" name="radio1" value="opcja2" /> Opcja2 <br /> <input type="radio" name="radio1" value="opcja3" /> Opcja3 <br /><br /> <input type="submit" /> </div> </form> </body> </html><br /> <br /> Napiszmy więc teraz skrypt skrypt.php. Pozwoli on nam stwierdzić, czy została zaznaczona jakaś opcja, a jeśli tak, to która. W wykonaniu tego zadania pomoże nam wspomniana przed chwilą funkcja isSet. Spójrzmy na kod widoczny na listingu 4.4 — funkcja isSet jest tu używana do stwierdzenia, czy w tablicy $_GET jest ustawiony klucz o nazwie radio1, a tym samym, czy do skryptu została przekazana wartość pola typu radio o nazwie radio1. Jeśli tak, funkcja zwraca wartość true, jeśli nie — wartość<br /> <br /> 220<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Rysunek 4.4. Wygląd formularza generowanego przez kod z listingu 4.3<br /> <br /> false. Takie zachowanie pozwala na użycie instrukcji warunkowej if do wyświetlenia<br /> <br /> na ekranie właściwego komunikatu. Listing 4.4. Obsługa pól typu radio <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <p> <?php if(!isSet($_GET['radio1'])){ echo "Proszę zaznaczyć jedną z opcji!"; } else{ echo "Zaznaczona opcja to {$_GET['radio1']}."; } ?> </p> </body> </html><br /> <br /> A zatem, jeżeli do skryptu nie została przekazana wartość z formularza o nazwie radio1, funkcja isSet zwróci wartość false. Taka sytuacja zaistnieje wtedy, gdy w formularzu nie zostanie zaznaczone żadne pole radio i zostanie kliknięty przycisk Wyślij zapytanie lub też na przykład wtedy, gdy skrypt skrypt.php będzie wywołany bezpośrednio (w przeglądarce zostanie wpisany adres http://localhost/skrypt.php). Tym samym warunek !isSet($_GET['radio1'] będzie prawdziwy (użyty został operator logicznej negacji !, zatem isSet($_GET['radio1'] da wartość false, a !isSet($_GET['radio1'] — wartość true) i do przeglądarki powędruje tekst Proszę zaznaczyć jedną z opcji!. Jeśli jednak w tablicy $_GET będzie ustawiony klucz radio1, funkcja isSet zwróci wartość true. Będzie tak wtedy, gdy w formularzu zostało zaznaczone jedno z pól wyboru lub też skrypt skrypt.php został wywołany bezpośrednio z podaniem parametru radio1 (np. przez wpisanie do przeglądarki adresu http://localhost/skrypt.php?radio1=opcja2).<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 221<br /> <br /> Wtedy (analogicznie do poprzedniej sytuacji) warunek instrukcji if będzie fałszywy i zostanie wykonany blok else. Jest w nim wykonywana instrukcja echo: echo "Zaznaczona opcja to {$_GET['radio1']}.";<br /> <br /> w której za pomocą składni z nawiasem klamrowym odczytywana jest wartość klucza radio1 tablicy $_GET. Będzie to opcja1, opcja2 lub opcja3 (wartość atrybutu value znaczników <input> z listingu 4.3), w zależności od tego, które z pól formularza zostało zaznaczone. Warte uwagi jest to, że przy bezpośrednim wywołaniu skryptu, czyli użyciu wspomnianego już adresu w postaci: http://localhost/skrypt.php?radio1=wartość<br /> <br /> możliwe jest przekazanie do skryptu dowolnego ciągu znaków (nie tylko opcja1, opcja2 lub opcja3).<br /> <br /> Metoda POST Metoda POST to drugi sposób przesyłania danych do serwera. Główne różnice dla użytkownika to możliwość przesłania dużo większej ilości dowolnych danych (np. plików binarnych) oraz to, że nie można ich zobaczyć w polu adresu przeglądarki (co wydaje się całkiem logiczne). Maksymalna ilość danych, jakie mogą być przesłane za pomocą tej metody, jest ograniczona przez znajdującą się w pliku php.ini opcję konfiguracyjną post_max_size2. Domyślnie jest to 8 MB. Prosty formularz wykorzystujący przesyłanie danych metodą POST został przedstawiony na listingu 4.5. Jak widać, jedyną różnicą w stosunku do metody GET (formularz z listingu 4.1) jest zmiana wartości parametru method znacznika form na post. Również i w tym przypadku parametr action mógłby mieć postać: action="http://127.0.0.1/skrypt.php"<br /> <br /> lub po prostu: action="skrypt.php"<br /> <br /> Listing 4.5. Kod formularza HTML wysyłającego dane metodą POST <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <form method="post" action="http://localhost/skrypt.php"> <div> <input type="text" name="pole1" /> <input type="submit" /><br /> <br /> 2<br /> <br /> Na maksymalną ilość odbieranych danych mogą mieć wpływ również ustawienia serwera WWW.<br /> <br /> 222<br /> <br /> PHP5. Praktyczny kurs </div> </form> </body> </html><br /> <br /> Aby w skrypcie PHP wartości przesłane z formularza można było odczytać (podobnie jak miało to miejsce w przypadku metody GET), należy się odwołać do superglobalnej tablicy $_POST. Jako indeks tablicy należy zastosować również nazwę pola formularza, z którego chcemy odczytać dane. Schematycznie konstrukcja taka ma postać: $zmienna = $_POST['nazwa_pola'];<br /> <br /> Na listingu 4.6 został przedstawiony skrypt odczytujący wartość pola tekstowego z formularza z listingu 4.5. Jak widać, ten kod jest dokładnym odpowiednikiem przykładu z listingu 4.2, jednak dane są odczytywane z tablicy $_POST, a nie $_GET. Przykładowy efekt działania skryptu, w przypadku gdy do pola tekstowego formularza został wprowadzony ciąg znaków test, został przedstawiony na rysunku 4.5. Warto tylko zwrócić uwagę, że zgodnie z podanym opisem na pasku adresowym przeglądarki nie pojawiły się żadne dane (por. rysunek 4.3). Widać więc wyraźnie, że przy prostej obsłudze formularzy różnice pomiędzy metodami GET i POST są niewielkie, jednak ta druga pozwala wykonywać bardziej zaawansowane zadania, np. przesyłanie plików do serwera, co zostanie przedstawione już w kolejnej sekcji. Listing 4.6. Skrypt odczytujący dane przekazane z formularza za pomocą metody POST <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <p> <?php $zmienna = $_POST['pole1']; echo "Wartość pola pole1: $zmienna <br />"; ?> </p> </body> </html><br /> <br /> Rysunek 4.5. Odczyt danych przesłanych za pomocą metody POST<br /> <br /> Trzeba też wiedzieć, że odświeżenie strony skryptu (w omawianych przypadkach http:// localhost/skrypt.php), do którego dane zostały przesłane za pomocą metody GET, jest<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 223<br /> <br /> bezproblemowe, jest to bowiem po prostu ponowne wywołanie danego adresu URL. Przy metodzie POST jest jednak inaczej. Ponieważ dane nie są bezpośrednio widoczne, przeglądarka w standardowej konfiguracji wyświetli okno z zapytaniem, czy na pewno chcemy ponownie przesłać dane. W przypadku Firefoksa okno to wygląda tak, jak zaprezentowano to na rysunku 4.6. Z takiej operacji można się więc wycofać. Rysunek 4.6. Potwierdzanie chęci ponownego przesłania danych<br /> <br /> Wysyłanie plików do serwera Aby wysłać plik z komputera użytkownika na serwer, trzeba przygotować odpowiedni formularz HTML umożliwiający wybór pliku oraz skrypt PHP, który go odbierze. Również środowisko PHP musi być odpowiednio skonfigurowane. W pliku php.ini musi być włączona opcja file_uploads, zmienna upload_tmp_dir powinna wskazywać na katalog, w którym będą zapisywane dane tymczasowe, a zmienna upload_max_filesize powinna określać maksymalny rozmiar pojedynczego pliku (standardowo 2 MB). Jeżeli katalog tymczasowy nie zostanie podany, wykorzystany będzie katalog systemowy. Należy zwrócić uwagę, aby uprawnienia dostępu do katalogu tymczasowego były ustawione tak, aby PHP miało możliwość zapisywania w nim danych. Maksymalna wielkość pliku zależy również od opcji post_max_size (standardowo 8 MB) i memory_ limit (standardowo 8 MB). W większości przypadków ustawienia domyślne są jednak wystarczające i w standardowych zastosowaniach nie ma potrzeby ich modyfikować. Formularz HTML należy zdefiniować za pomocą znacznika <form>, który powinien zawierać następujące atrybuty (w razie potrzeby można oczywiście użyć również innych atrybutów znacznika):  enctype — określa typ kodowania MIME, w tym przypadku będzie to multipart/form-data.  action — określa adres skryptu PHP.  method — określa metodę wysyłania danych, w tym przypadku będzie to metoda POST.<br /> <br /> W formularzu należy umieścić dwa pola input, jedno typu file, a drugie typu submit. Polu typu file, służącemu do wyboru pliku, nadajemy nazwę (parametr name) pozwalającą na zidentyfikowanie danych z tego pola w skrypcie PHP. Zalecane jest także (choć nieobligatoryjne) użycie ukrytego pola o nazwie max_file_size i wartości wskazującej na maksymalny dopuszczalny rozmiar pliku (podawany w bajtach): <input type="hidden" name="max_file_size" value="wielkość_pliku" /><br /> <br /> Znacznik ten powinien występować przed definicją pola pozwalającego na wybór pliku (znacznik <input> z atrybutem type ustawionym na file). Pliki o wielkości większej<br /> <br /> 224<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> niż wskazywana przez atrybut value będą odrzucane przez PHP. Ponieważ jednak tak przekazywana wartość może być łatwo podmieniona przez użytkownika, nie należy na niej polegać, ale traktować bardziej jako wskazówkę dla przeglądarki i aparatu wykonawczego PHP. Jeżeli konieczne jest wprowadzenie faktycznego ograniczenia rozmiaru przekazywanego pliku, należy go weryfikować w skrypcie PHP odbierającym dane. Kod przykładowego formularza został zaprezentowany na listingu 4.7. Gdy zostanie wczytany do przeglądarki, będzie miał postać widoczną na rysunku 4.7 (lub podobną). Listing 4.7. Formularz HTML służący do wysyłania plików <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <form enctype = "multipart/form-data" action = "upload.php" method = "post"> <div> Nazwa pliku: <input type="hidden" name="max_file_size" value="20480" /> <input type="file" name="plik1" size="30" value="" /> <input type="submit" name="wyslij" value="Wyślij plik" /> </div> </form> </body> </html><br /> <br /> Rysunek 4.7. Wygląd formularza do wysyłania plików<br /> <br /> Plik wysłany za pomocą takiego formularza do serwera zostanie zapisany w katalogu służącym do przechowywania plików tymczasowych. Katalog ten możemy ustalić samodzielnie, ustawiając w pliku php.ini opcję konfiguracyjną upload_tmp_dir. W systemie Linux może mieć przykładową postać: upload_tmp_dir = /var/www/upload<br /> <br /> a w systemie Windows: upload_tmp_dir = c:\www\upload\<br /> <br /> W typowych sytuacjach zwykle jednak nie ma potrzeby zmiany ustawień tej opcji — można polegać na ustawieniach domyślnych.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 225<br /> <br /> Skrypt odbierający dane ma dostęp do globalnej tablicy $_FILES zawierającej informacje niezbędne do ich dalszego przetworzenia. Jest to tablica asocjacyjna, w której plik identyfikowany jest przez nazwę pola input (typu file) z formularza WWW. W przypadku formularza z listingu 4.7 ta nazwa to plik1. Pod tym indeksem znajduje się pięć innych, które pozwalają na odczytanie informacji o pliku. Są to:  $_FILES['plik1']['name'] — oryginalna nazwa pliku (którą miał on<br /> <br /> na komputerze użytkownika).  $_FILES['plik1']['type'] — typ MIME pliku (o ile przeglądarka<br /> <br /> dostarczyła tę informację).  $_FILES['plik1']['size'] — wielkość pliku w bajtach.  $_FILES['plik1']['tmp_name'] — nazwa tymczasowa, pod jaką plik<br /> <br /> został zapisany na serwerze.  $_FILES['plik1']['error'] — status operacji, kod błędu.<br /> <br /> Pole error może przyjmować jedną z następujących wartości:  UPLOAD_ERR_OK — brak błędu, operacja została zakończona sukcesem.  UPLOAD_ERR_INI_SIZE — wielkość pliku przekracza wielkość maksymalną zdefiniowaną w pliku php.ini (zmienna upload_max_filesize).  UPLOAD_ERR_FORM_SIZE — rozmiar pliku przekracza wielkość maksymalną zdefiniowaną w formularzu HTML (pole <input> o nazwie max_file_size).  UPLOAD_ERR_PARTIAL — została odebrana jedynie część pliku.  UPLOAD_ERR_NO_FILE — plik nie został pobrany.  UPLOAD_ERR_NO_TMP_DIR — niedostępny katalog tymczasowy<br /> <br /> (kod wprowadzony w wersji PHP 5.0.3).  UPLOAD_ERR_CANT_WRITE — wystąpił błąd przy próbie zapisu pliku na dysku<br /> <br /> (kod wprowadzony w wersji PHP 5.1.0).  UPLOAD_ERR_EXTENSION — ładowanie pliku zostało przerwane przez jedno<br /> <br /> z rozszerzeń PHP (kod wprowadzony w wersji PHP 5.2.0). Plik wysłany do serwera jest umieszczany w katalogu tymczasowym i należy go przenieść do właściwej lokalizacji docelowej (np. katalogu, który przeznaczyliśmy do przechowywania tego typu danych). Wykorzystuje się w tym celu funkcję move_uploaded_ file, która ze względów bezpieczeństwa oprócz zmiany lokalizacji pliku dodatkowo wykonuje sprawdzenie, czy na pewno został on wysłany do serwera za pomocą metody HTTP_POST. Powyższe informacje w zupełności wystarczają do napisania skryptu odbierającego pliki wysyłane z przeglądarki i zapisującego je w wybranym katalogu. Kod został przedstawiony na listingu 4.8 i należy go zapisać pod nazwą upload.php w głównym katalogu serwera WWW.<br /> <br /> 226<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Listing 4.8. Skrypt odbierający pliki wysłane do serwera <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Wynik odbioru pliku</title> </head> <body> <p> <?php $uploaddir = './'; if($_FILES['plik1']['error'] == UPLOAD_ERR_OK){ $new_name = $uploaddir.$_FILES['plik1']['name']; $temp_name = $_FILES['plik1']['tmp_name']; if(move_uploaded_file($temp_name, $new_name)){ echo "Plik został załadowany.\n"; } else{ echo "Nie udało się załadować pliku.\n"; } } else{ echo "Wystąpił błąd: "; switch($_FILES['plik1']['error']){ case UPLOAD_ERR_INI_SIZE : case UPLOAD_ERR_FORM_SIZE : echo "Przekroczony maksymalny rozmiar pliku!"; break; case UPLOAD_ERR_PARTIAL : echo "Odebrano tylko część pliku!"; break; case UPLOAD_ERR_NO_FILE : echo "Plik nie został pobrany!"; break; case UPLOAD_ERR_NO_TMP_DIR: echo "Brak dostępu do katalogu tymczasowego"; break; case UPLOAD_ERR_CANT_WRITE: echo "Nie udało się zapisać pliku na dysku serwera"; break; case UPLOAD_ERR_EXTENSION: echo "Ładowanie pliku przerwane przez rozszerzenie PHP"; default : echo "Nieznany typ błędu!\n"; } } ?> </p> </body> </html><br /> <br /> Katalog, w którym mają być zapisywane odbierane pliki, jest wskazywany przez zmienną $uploaddir. Oczywiście musi on istnieć w systemie plików serwera. W przykładzie<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 227<br /> <br /> został zastosowany ciąg ./, co oznacza katalog bieżący (katalog, w którym znajduje się skrypt upload.php). Należy również pamiętać, że musi on mieć odpowiednio ustawione prawa dostępu (aparat wykonawczy PHP musi mieć możliwość zapisu). Pierwszą czynnością wykonywaną w skrypcie jest sprawdzenie, czy pole error tablicy $_FILES zawiera wartość UPLOAD_ERR_OK, a zatem czy plik został odebrany bez problemów. Jeśli tak, z tablicy $_FILES jest odczytywana oryginalna nazwa pliku oraz nazwa tymczasowa, pod którą został on zapisany na serwerze. Do nazwy oryginalnej dołączana jest nazwa katalogu zawarta w zmiennej $uploaddir i całość jest zapisywana w zmiennej $new_name. Nazwa tymczasowa jest z kolei zapisywana w zmiennej $temp_ name. Zmienne te (zostały one wprowadzone do skryptu w celu zwiększenia przejrzystości kodu) są następnie wykorzystywane jako parametry funkcji move_uploaded_file. Jeśli wykonanie tej funkcji zakończy się sukcesem i plik zostanie przeniesiony pod oryginalną nazwą do katalogu wskazywanego przez $uploaddir, funkcja zwróci wartość true, a w przeciwnym razie — false. W zależności od tej wartości na ekranie jest wyświetlany odpowiedni komunikat. Jeżeli jednak wartość pola error tablicy $_FILES jest różna od UPLOAD_ERR_OK, wykonywana jest instrukcja switch pozwalająca na stwierdzenie, jakiego typu błąd wystąpił. Badane są wszystkie pozostałe możliwości stanu pola error i wyświetlany jest właściwy komunikat. Klauzula default instrukcji switch zabezpiecza przed sytuacją, gdy w polu error znalazłby się nieznany kod błędu (np. wprowadzony w kolejnych wersjach PHP). Dzięki niej również w takiej sytuacji zostanie wyświetlona odpowiednia informacja.<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 13.1. Napisz skrypt obliczający pierwiastki równania kwadratowego o parametrach wprowadzanych w formularzu HTML. Ćwiczenie 13.2. Napisz skrypt umożliwiający wykonywanie czterech podstawowych działań arytmetycznych na dwóch argumentach. Wartości argumentów mają być wprowadzane poprzez pola tekstowe formularza, a wybór działania ma następować poprzez pola wyboru typu radio. Ćwiczenie 13.3. Napisz skrypt wykonujący konwersję tekstu wprowadzonego w polu tekstowym formularza ze standardu Windows-1250 do ISO-8859-2. Ćwiczenie 13.4. Napisz skrypt pozwalający użytkownikowi na wysłanie do serwera pliku, który po transmisji danych wyświetli dane pliku: nazwę oryginalną, nazwę tymczasową (pod którą plik został zapisany na dysku serwera), rozmiar oraz typ MIME danych (o ile taka informacja została przekazana przez przeglądarkę). Ćwiczenie 13.5. Napisz skrypt umożliwiający użytkownikowi wysłanie pliku do serwera, umieszczający ten plik w wybranym katalogu i zwracający odnośnik do niego, tak aby było możliwe jego pobranie z poziomu przeglądarki.<br /> <br /> 228<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Lekcja 14. Wysyłanie danych do przeglądarki Sposoby wysyłania danych W celu wysyłania danych do przeglądarki wykorzystywaliśmy do tej pory najczęściej instrukcję echo, choć poznaliśmy również print i printf. Zarówno echo, jak i print to konstrukcje języka, przy czym print zachowuje się jak funkcja, zwracając zawsze wartość 1 w miejscu swojego wystąpienia, podczas gdy echo nie ma takich właściwości. Konsekwencją takiego stanu rzeczy jest to, że print może być użyte jako część większego wyrażenia, np. można dokonać przykładowego przypisania: $wartosc = print("ciąg znaków");<br /> <br /> po którym zmienna $wartosc będzie miała wartość 1, oraz to, że echo jest minimalnie szybsze. printf jest natomiast klasyczną funkcją pozwalającą na formatowanie ciągów znaków (zwraca liczbę znaków ciągu wynikowego). Oprócz wymienionych wyżej konstrukcji można również zastosować vprintf, która działa analogicznie do printf z tą różnicą że zamiast listy argumentów wykorzystuje zawartość tablicy. Jej wywołanie ma następującą postać: vprintf("ciąg formatujący", tablica);<br /> <br /> Oznacza to: wyślij do przeglądarki (standardowego wyjścia) ciąg formatujący przetworzony w taki sposób, że znaczniki specjalne zostały zamienione na odpowiadające im elementy tablicy tablica. Postać ciągu formatującego jest taka sama jak w przypadku funkcji printf opisanej w lekcji 8. Jeśli zatem wykonamy instrukcje: $tab = array("Ala", 3, "Ola", 2); vprintf("%s ma %d koty, a %s %d psy.", $tab);<br /> <br /> to do przeglądarki zostanie wysłany ciąg znaków w postaci: Ala ma 3 koty, a Ola 2 psy.<br /> <br /> Pod pierwszy znacznik został bowiem podstawiony pierwszy element tablicy, pod drugi — drugi itd.<br /> <br /> Wysyłanie zawartości plików Wyświetlanie tekstów to jednak nie koniec możliwości PHP. Nic nie stoi na przeszkodzie, aby do przeglądarki wysyłać dane binarne, np. zawartość plików. Można dzięki temu zrealizować na przykład różne mechanizmy pobierania plików z serwisu, czym zajmiemy się w dalszej części lekcji — najpierw trzeba poznać podstawy. Będą przy tym używane funkcje otwierające pliki i odczytujące ich zawartość, więc czytelnicy nieznający tych zagadnień powinni najpierw zapoznać się z materiałem zawartym w rozdziale 4.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 229<br /> <br /> Jak zatem wysłać pojedynczy plik? Najważniejszą sprawą jest poinformowanie przeglądarki o tym, jakiego typu dane będziemy jej przesyłać. Wykonujemy to przez wysłanie odpowiednich nagłówków protokołu HTTP. Należy skorzystać z nagłówków3:  Content-Type — określającego typ MIME danych,  Content-Length — określającego ilość danych (długość pliku),  Content-Disposition — określającego rodzaj (przeznaczenie) danych.<br /> <br /> Nagłówek Content-Type określa rodzaj danych, które będą przesyłane w formacie MIME (Multipurpose Internet Mail Extensions). Format MIME jest zdefiniowany w dokumentach RFC2045 i RFC2046. Typy danych są opisywane przez osiem typów głównych, z których każdy ma od kilku do kilkudziesięciu podtypów (przykładem jest image/gif, text/html itp.). Na szczęście do prostego przesyłania plików wystarczy, jeśli będziemy stosować określenie application/octet-stream. Nagłówek ContentDisposition powinien zawierać wartości informujące przeglądarkę, że otrzymuje dane, które mają być traktowane jako załącznik, a nie jako treść strony, dlatego też będziemy stosować format: attachment; filename=nazwa_pliku<br /> <br /> nazwa_pliku określa tu nazwę, która ma się pojawić w oknie dialogowym, jakie prze-<br /> <br /> glądarka wyświetli na ekranie z pytaniem, czy użytkownik chce zapisać plik na dysku. Okna te mogą się różnić w zależności od zastosowanej przeglądarki (rysunki 4.8 i 4.9). Rysunek 4.8. Okno odbierania plików przeglądarki Firefox<br /> <br /> Nagłówki protokołu HTTP wysyła się do przeglądarki za pomocą funkcji header w postaci: header("nagłówek");<br /> <br /> Wysłanie pierwszego nagłówka będzie miało na przykład postać: header("Content-Type: application/octet-stream");<br /> <br /> 3<br /> <br /> Nie wyklucza to stosowania również innych nagłówków (np. Content-Transfer-Encoding), jednak te trzy są wystarczające.<br /> <br /> 230<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Rysunek 4.9. Okno odbierania plików przeglądarki Internet Explorer<br /> <br /> Po wysłaniu nagłówków trzeba wysłać również zawartość samego pliku. Aby to zrobić, należy użyć kilku dodatkowych funkcji. Plik może zostać otwarty za pomocą funkcji fopen i odczytany za pomocą fread (istnieją także inne możliwości, które zostaną opisane w lekcji dotyczącej operacji na plikach). Kod przykładowego skryptu wykonującego postawione zadanie jest widoczny na listingu 4.9. Został on skonstruowany w taki sposób, aby nazwa pliku znajdującego się na serwerze mogła być różna od tej wysyłanej do przeglądarki. Dzięki temu plik o nazwie image1.jpg zostanie wysłany jako rysunek1.jpg. Przeanalizujmy jego działanie. Listing 4.9. Wysłanie pliku do przeglądarki <?php $katalog = "./"; $nazwa1 = "image1.jpg"; $nazwa2 = "rysunek1.jpg"; $fd = fopen($katalog.$nazwa1, "r"); $size = filesize($katalog.$nazwa1); $contents = fread($fd, $size); fclose($fd); header("Content-Type: application/octet-stream"); header("Content-Length: $size;"); header("Content-Disposition: attachment; filename=$nazwa2"); echo $contents; ?><br /> <br /> Kod rozpoczyna się od deklaracji trzech zmiennych pomocniczych. Są to:  $katalog — przechowuje nazwę katalogu, w którym jest zapisany plik.  $nazwa1 — przechowuje nazwę pliku do wysłania.  $nazwa2 — zawiera nazwę, pod jaką plik zostanie wysłany do przeglądarki.<br /> <br /> Po deklaracjach zmiennych wykonywana jest funkcja fopen otwierająca plik do wysłania w trybie do odczytu (r). Wynikiem działania tej funkcji jest deskryptor (czyli<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 231<br /> <br /> specjalny identyfikator), który jest przypisywany zmiennej $fd (z ang. file descriptor). Następnie za pomocą funkcji filesize jest pobierana i przypisywana zmiennej $size wielkość pliku. Zwróćmy uwagę na to, jak w obu przypadkach konstruowana jest nazwa pliku. Wykorzystujemy tu operator łączenia łańcuchów znakowych, czyli kropkę (.). Dzięki temu, skoro w zmiennej $katalog jest zapisana wartość ./, a plik ma nazwę image1.jpg, argumentem funkcji będzie ciąg ./image1.jpg określający dokładną lokalizację pliku (plik o nazwie image1.jpg znajdujący się w katalogu bieżącym, czyli tym, w którym umieszczony jest skrypt). Po pobraniu rozmiaru pliku jego zawartość jest odczytywana za pomocą funkcji fread. Wynikiem działania fread jest ciąg znaków zawierający treść pliku — jest on przypisywany zmiennej $contents. Po wykonaniu wymienionych czynności plik jest zamykany za pomocą funkcji fclose (jako argument jest jej przekazywany deskryptor uzyskany za pomocą wywołania fopen), a do przeglądarki wysyłane są nagłówki HTTP. Pierwszy nagłówek: header("Content-Type: application/octet-stream");<br /> <br /> określa typ danych jako application/octet-stream, a zatem informuje przeglądarkę, że będą przesyłane dane binarne. Nagłówek drugi: header("Content-Length: $size;");<br /> <br /> określa wielkość danych, czyli liczbę bajtów. Ponieważ do konstrukcji ciągu użyliśmy składni ze znakami cudzysłowu, w miejsce zmiennej $size zostanie podstawiona jej wartość, czyli rozmiar pliku uzyskany za pomocą wywołania funkcji filesize. Trzeci nagłówek HTTP: header("Content-Disposition: attachment; filename=$nazwa2");<br /> <br /> informuje przeglądarkę, że dane mają być traktowane jako załącznik, a nie np. treść strony, a zatem powinna ona dać użytkownikowi możliwość ich zapisu na dysku pod postacią pliku. Nazwa tego pliku jest sugerowana przez parametr filename. Podobnie jak w poprzednim przypadku, występująca w ciągu nazwa zmiennej zostanie zamieniona na jej wartość, czyli pod $nazwa2 zostanie podstawiony ciąg rysunek1.jpg. Ostatnia czynność to wysłanie zawartości pliku do przeglądarki. Jak pamiętamy, jego treść jest zawarta w zmiennej $contents. Samo wysłanie jest więc realizowane przez instrukcję echo $contents;<br /> <br /> Jak widać, zastosowanie instrukcji echo nie ogranicza się jedynie do przesyłania danych tekstowych. Gdy korzystamy z funkcji header i wysyłamy do przeglądarki dowolne nagłówki HTTP, muszą być one wysłane wcześniej niż jakakolwiek inna treść (nie można np. najpierw użyć instrukcji echo z treścią HTML). Ten problem zostanie poruszony w lekcji 15. omawiającej obsługę cookies.<br /> <br /> 232<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Sposoby pobierania plików z serwisu Skoro wiemy już, w jaki sposób można wysłać plik z serwera do użytkownika, możemy się zająć popularną funkcją skryptów PHP, jaką jest realizacja sekcji pobierania plików w serwisie WWW. Takie zadanie można wykonać na wiele różnych sposobów, kilka z nich zostanie przedstawionych na kolejnych stronach.<br /> <br /> Lista z nazwami plików Pierwszy przykład będzie działał w taki sposób, że do skryptu zostanie przekazana nazwa pliku, który ma zostać wysłany. Jeśli taki plik będzie obecny na serwerze, to zostanie wysłany do użytkownika, jeśli natomiast go nie będzie, zostanie wyświetlona odpowiednia informacja. Całość zostanie zatem rozbita na trzy części:  plik download.html — zawierający listę odnośników,  plik download.php — zawierający właściwy skrypt realizujący<br /> <br /> funkcję wysyłania,  plik nofile.html — zawierający stronę z informacją o błędzie.<br /> <br /> Lista odnośników będzie generowana za pomocą standardowych znaczników <a> w schematycznej postaci: <a href="http://adres.serwera/download.php?name=nazwa_pliku" rel="nofollow"><br /> <br /> Wynika z tego, że nazwa pliku, który ma zostać wysłany, będzie przekazywana do skryptu download.php metodą GET w postaci parametru o nazwie name. Zadaniem skryptu będzie odczytanie tej nazwy i wysłanie odpowiadającego jej pliku do przeglądarki. Kod HTML zawierający zrealizowaną w opisany sposób listę plików został przedstawiony na listingu 4.10, a wygląd listy po wczytaniu kodu do przeglądarki jest pokazany na rysunku 4.10. Listing 4.10. Kod wyświetlający listę odnośników <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Pobieranie plików</title> </head> <body> <div><ul> <li><a href="http://localhost/download.php?name=plik1.zip" rel="nofollow"> Pierwszy plik</a></li> <li><a href="http://localhost/download.php?name=plik2.zip" rel="nofollow"> Drugi plik</a></li> <li><a href="http://localhost/download.php?name=plik3.zip" rel="nofollow"> Trzeci plik</a></li> </ul></div> </body> </html><br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 233<br /> <br /> Rysunek 4.10. Lista odnośników wczytana do przeglądarki<br /> <br /> Równie nieskomplikowany będzie kod strony zawierającej informację o błędzie (plik nofile.html). Jest to zwykła strona HTML zawierająca akapit tekstowy z komunikatem o braku wskazanego pliku na serwerze oraz odnośnikiem pozwalającym na powrót do strony pobrań (download.html). Treść pliku nofile.html została przedstawiona na listingu 4.11, a wygląd tej strony zobrazowano na rysunku 4.11. Listing 4.11. Treść pliku z informacją o błędzie <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Pobieranie plików</title> </head> <body> <p style="text-align:center">Nie ma takiego pliku na serwerze!</p> <p style="text-align:center"> <a href="http://localhost/download.html" rel="nofollow">Powrót do strony pobrań</a> </p> </body> </html><br /> <br /> Rysunek 4.11. Wygląd strony z komunikatem o braku pliku<br /> <br /> Skrypt download.php będzie wykonywał trzy główne zadania:  odebranie nazwy przesłanego pliku,  sprawdzenie poprawności nazwy,  wysłanie pliku.<br /> <br /> 234<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> W szczególności należy zwrócić uwagę na punkt 2. Sprawdzenie poprawności przesłanych danych jest niezbędne, gdyż w przeciwnym razie możemy doprowadzić do sytuacji, gdy odpowiednio spreparowany ciąg znaków przesłany jako parametr dla skryptu pozwoli potencjalnemu włamywaczowi na pobranie dowolnego pliku z serwera. Jak sprawdzić poprawność danych? Można stosować różne metody weryfikacji, np. sprawdzanie, czy przesłany ciąg zawiera znaki potencjalnie niebezpieczne (jak ., .., \, /)4. Tutaj zostanie zastosowany sposób mało wygodny, ale za to bezpieczny. Sporządzimy listę wartości, które mogą być przesyłane jako parametr name i za każdym razem będziemy sprawdzać, czy przesłana nazwa znajduje się na tej liście. Listę umieścimy w skrypcie w tablicy. W związku z tym kod skryptu download.php będzie miał postać taką jak na listingu 4.12. Listing 4.12. Treść skryptu wysyłającego plik do użytkownika <?php $filesPath = "./"; /* funkcja sprawdzająca poprawność nazwy */ function checkFileName($name) { if(strlen($name) > 100){ return false; } $pliki = array( "plik1.zip", "plik2.zip", "plik3.zip" ); return array_search($name, $pliki); } /* funkcja wysyłająca plik */ function send($fileName, $filePath) { if(!file_exists($filePath.$fileName)){ return false; } $fd = fopen($filePath.$fileName, "r"); $size = filesize($filePath.$fileName); $contents = fread($fd, filesize($filePath.$fileName)); if($contents === false){ return false; } fclose($fd); header("Content-Type: application/octet-stream"); header("Content-Length: $size;"); header("Content-Disposition: attachment; filename=$fileName");<br /> <br /> } 4<br /> <br /> echo $contents; return true;<br /> <br /> Różne metody weryfikacji zostały zaprezentowane m.in. w książkach: PHP 101 praktycznych skryptów (http://helion.pl/ksiazki/php102.htm) oraz 505 praktycznych skryptów dla webmastera (http://helion.pl/ksiazki/505web.htm).<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 235<br /> <br /> /* odczytanie danych i wywołanie funkcji */ if(isSet($_GET['name'])){ if(checkFileName($_GET['name']) === false){ include "nofile.html"; } else{ if(!send($_GET['name'], $filesPath)){ include "nofile.html"; } } } else{ include "nofile.html"; } ?><br /> <br /> Znajdująca się na początku skryptu zmienna filesPath powinna wskazywać na katalog, w którym zapisane są pliki do pobrania. W tym przypadku jest to katalog bieżący ./, czyli ten, w którym jest zapisany skrypt download.php. Funkcja checkFileName otrzymuje w postaci argumentu nazwę pliku, która ma zostać zweryfikowana. Wszystkie poprawne nazwy plików, czyli tych, które mogą zostać pobrane z serwera i znajdują się na liście generowanej przez kod HTML z listingu 4.10, są zapisane w tablicy $pliki. Wystarczy zatem sprawdzić, czy nazwa przekazana w postaci argumentu name znajduje się w tej tablicy, czy też nie. To sprawdzenie wykonywane jest za pomocą funkcji array_serach. Pierwszym argumentem tej funkcji jest poszukiwana wartość, a drugim tablica do przeszukania. Ponieważ funkcja array_search zwraca wartość true, jeśli szukana wartość zostanie znaleziona, a w przeciwnym razie wartość false, wynik jej działania jest jednocześnie wynikiem działania funkcji checkFileName i jest on zwracany za pomocą instrukcji return. Jeśli nazwa jest więc poprawna, funkcja zwraca true, jeśli nie — false. Dodatkowo, jeszcze przed sprawdzeniem poprawności nazwy, za pomocą funkcji strlen badana jest długość przekazanego ciągu. Jeśli jest większa niż 100 znaków, wynik weryfikacji uznaje się również za negatywny. Oczywiście wartość ta może być zwiększana bądź zmniejszana według potrzeb. Wysłaniem pliku do użytkownika zajmuje się funkcja send. Otrzymuje ona w postaci argumentów nazwę pliku oraz nazwę katalogu, w którym ten plik się znajduje. Pierwszym jej zadaniem jest weryfikacja danych, czyli sprawdzenie, czy wskazany plik faktycznie istnieje. Odpowiada za to funkcja file_exists, która zwraca wartość true, jeśli plik znajduje się w podanej lokalizacji, lub wartość false w przeciwnym razie. Jeśli plik nie istnieje, funkcja send kończy działanie, zwracając wartość false. Jeśli plik istnieje, jest wysyłany za pomocą techniki analogicznej do zaprezentowanej we wcześniejszym przykładzie i send zwraca wartość true (chyba że będzie to plik pusty o zerowej długości — wtedy nie zostanie wysłany5). W porównaniu do przykładu z listingu 5<br /> <br /> W sytuacji gdy w konfiguracji PHP włączone jest wyświetlanie ostrzeżeń, na ekranie pojawi się komunikat związany z działaniem funkcji fread. Wyeliminowanie tego zjawiska może być ćwiczeniem do samodzielnego wykonania.<br /> <br /> 236<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> 4.9 dodatkowo jest sprawdzane, czy udało się odczytać zawartość pliku, czyli czy wartość zwrócona przez funkcję fread, a zapisana w zmiennej $contents, jest różna od false. Gdyby była równa [if($contents === false){], funkcja send zakończy działanie bez wysyłania danych, zwracając wartość false. Główna część kodu rozpoczyna się od sprawdzenia, czy do skryptu został przekazany parametr name. Zadanie to wykonuje wykorzystywana już we wcześniejszych przykładach funkcja isSet. Jeśli parametr nie został przekazany, za pomocą instrukcji include (por. lekcja 3. z rozdziału 2.) wczytywana jest treść pliku nofile.html i skrypt kończy działanie. Jeśli natomiast parametr name został przekazany, wykonywane są dalsze czynności. W pierwszej kolejności jest wywoływana funkcja checkFileName. Jej zadaniem jest sprawdzenie, czy przekazana do skryptu nazwa należy do pliku, który może zostać pobrany, czyli czy jest ona prawidłowa. Jeśli jest, funkcja zwraca wartość true, w przeciwnym wypadku — false. W zależności od wyniku działania checkFileName do przeglądarki jest wysyłana informacja o braku pliku lub też zawartość pliku (za pomocą funkcji send). Skrypt bada również wartość zwróconą przez send i jeśli jest ona równa false, wczytuje informację o braku pliku (stanie się tak wtedy, gdy nazwa zawarta w parametrze name okaże się prawidłowa, ale pliku nie będzie na serwerze bądź nie uda się go odczytać).<br /> <br /> Pobieranie w jednym skrypcie Przykład przedstawiony w poprzedniej sekcji charakteryzuje się tym, że w celu wyświetlenia listy plików trzeba wczytywać stronę download.html, a w celu pobrania konkretnego pliku — stronę download.php. Można to jednak w bardzo prosty sposób zmienić, tak aby użytkownik odwoływał się zawsze do strony download.php. Musimy tylko zdecydować, czy cały kod HTML będzie umieszczony w zmiennych tekstowych wewnątrz skryptu czy też będzie wczytywany za pomocą instrukcji include (tak jak było to wykonywane z kodem pliku nofile.html w poprzednim przykładzie). Zależy to wprawdzie od indywidualnych upodobań programisty, jednak lepszym rozwiązaniem wydaje się być sposób drugi, gdyż kod jest wtedy bardziej czytelny i łatwiejszy do opanowania. Niech więc pierwsze rozwiązanie pozostanie jako ćwiczenie do samodzielnego wykonania, a my zajmijmy się drugim. Jeśli dobrze się przyjrzeć skryptowi z listingu 4.12, da się zauważyć, że zmiany wprowadzające nową funkcjonalność będą naprawdę niewielkie, wręcz kosmetyczne. Jak więc teraz ma działać skrypt? Do rozpatrzenia mamy następujące sytuacje: 1. Do skryptu został przekazany parametr name wskazujący prawidłową<br /> <br /> nazwę pliku. 2. Do skryptu został przekazany parametr name wskazujący nieprawidłową<br /> <br /> nazwę pliku. 3. Do skryptu nie został przekazany parametr name.<br /> <br /> Dwie pierwsze sytuacje zostały już oprogramowane w poprzednim przykładzie, należy zatem jedynie rozpatrzyć punkt 3. Nie ma zatem konieczności modyfikowania funkcji send i checkFileName, wystarczy jedynie wymienić blok else instrukcji if(isSet($_GET ['name'])), to on bowiem odpowiada za obsługę sytuacji, gdy do skryptu nie został<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 237<br /> <br /> przekazany parametr name. Odpowiednio poprawiony fragment skryptu został przedstawiony na listingu 4.13. Zmodyfikować należy również odnośnik w pliku nofile.html (listing 4.11), tak aby miał on postać: <a href="http://localhost/download.php" rel="nofollow">Powrót do strony pobrań</a><br /> <br /> Listing 4.13. Zmodyfikowany kod skryptu do pobierania plików <?php /* W tym miejscu należy umieścić pierwszą część kodu skryptu z funkcjami checkFileName i send */ if(isSet($_GET['name'])){ if(checkFileName($_GET['name']) === false){ include "nofile.html"; } else{ if (!send($_GET['name'], $filesPath)){ include "nofile.html"; } } } else{ include "download.html"; } ?><br /> <br /> Automatyczne generowanie listy Gdy lista plików do pobrania była nieduża lub też niezbyt często modyfikowana, poprzednie dwa przykłady dobrze spełniały swoje zadanie. Zauważmy bowiem, że każda zmiana powodowała konieczność edycji zarówno modułu odpowiedzialnego za wyświetlanie listy plików, jak i skryptu zajmującego się wysyłaniem danych (funkcja checkFileName). Spróbujmy zatem napisać taki skrypt, który będzie automatycznie uwzględniał zmiany w zestawie plików. Całość będzie się składała z trzech części:  pliku download.php zarządzającego systemem pobierania,  pliku download_list.php zawierającego kod strony generującej listę,  pliku nofile.html zawierającego kod HTML z informacją o błędzie.<br /> <br /> Użytkownik będzie wywoływał jedynie stronę download.php. Jeżeli nie zostanie jej przekazany żaden parametr, będzie ona wyświetlała listę dostępnych do pobrania plików. Jeśli jednak za pomocą metody GET zostanie przekazany parametr o nazwie name, będzie to oznaczać, że do przeglądarki ma zostać wysłany plik o wskazanej nazwie. Gdyby takiego pliku z różnych względów nie można było wysłać, do przeglądarki powędruje treść pliku nofile.html zawierającego informację o błędzie. Wszystkie pliki, które mają znaleźć się na liście do pobrania, będą musiały być zapisane w oddzielnym katalogu. Przyjmiemy, że będzie to podkatalog downloads zapisany<br /> <br /> 238<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> w głównym katalogu serwera WWW. Dla każdego pliku zostanie wygenerowany znacznik <a> w ogólnej postaci: <a href="http://adres.serwera/download.php?name=nazwa_pliku" rel="nofollow"><br /> <br /> Pisanie kodu zacznijmy tym razem „od środka”, czyli od instrukcji generujących listę plików — download_list.php. Będą one wczytywane w skrypcie download.php w sytuacji, gdy w tablicy $_GET nie będzie ustawiony indeks name. Zauważmy, że podobna sytuacja była w poprzednim przykładzie. Kod będzie miał postać zaprezentowaną na listingu 4.14. Listing 4.14. Kod skryptu generującego listę plików <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Pobieranie plików</title> </head> <body> <div><ul> <?php $filesPath = "./downloads/"; function printList($path) { $fd = opendir($path); if(!$fd) return false; while (($file = readdir($fd)) !== false){ if(is_dir($path.$file)) continue; echo("<li><a href=\"http://localhost/download.php?name="); echo("$file\" rel="nofollow">$file</a></li>"); } closedir($fd); } printList($filesPath); ?> </ul></div> </body> </html><br /> <br /> Zmienna pomocnicza $filespath wskazuje katalog, w którym znajdują się pliki udostępniane osobom odwiedzającym stronę. Stosujemy ją po to, aby w przypadku konieczności zmiany umiejscowienia plików nie trzeba było wyszukiwać wszystkich odwołań w skrypcie, a jedynie wykonać prostą zmianę w jednym miejscu. Za wygenerowanie odnośników odpowiada funkcja printList. Wybrany katalog jest otwierany za pomocą funkcji opendir, a jego deskryptor przypisywany zmiennej $fd. Nazwy plików są odczytywane w pętli while za pomocą funkcji readdir. Każde wywołanie readdir zwraca nazwę jednego pliku (lub katalogu), która jest przypisywana zmiennej $file. Gdy zostaną odczytane nazwy wszystkich plików, wywołanie readdir zwróci wartość false i pętla zakończy działanie.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 239<br /> <br /> Wewnątrz pętli znajduje się instrukcja warunkowa if, która pozwala na pominięcie nazw podkatalogów, na wypadek gdybyśmy je przez pomyłkę umieścili na dysku. Za sprawdzenie, czy odczytana nazwa jest nazwą katalogu, odpowiada funkcja is_dir (zwraca wartość true, jeśli argument jest katalogiem, lub false w przeciwnym razie). W ten sposób skrypt PHP wygeneruje automatycznie kod HTML zawierający listę odnośników, który w poprzednich przykładach był tworzony ręcznie (listing 4.10). Tym samym zmiana zawartości katalogu z plikami do pobrania nie będzie wymagała żadnej modyfikacji kodu, nowa lista będzie zawsze generowana automatycznie. Warto jednak zwrócić uwagę, że zyskując na wygodzie, tracimy na wydajności. Trzeba pamiętać, że każdorazowe odczytywanie zawartości katalogu i generowanie na tej podstawie strony HTML pochłania więcej zasobów serwera niż zwykła statyczna lista plików. Kolejna część zadania to napisanie głównego skryptu — download.php — do którego odwołuje się każdy z odnośników generowanych przez kod download_list.php. Szybko odkryjemy, że jego realizacja będzie bardzo podobna do poprzedniego przykładu. Wymienić należy jedynie funkcję checkFileName — pozostałe elementy mogą pozostać bez zmian. Tym razem funkcja checkFileName będzie przyjmowała dwa argumenty, którymi są nazwa pliku ($file) oraz nazwa katalogu ($path). Kod, jak można się domyślić, będzie podobny do instrukcji z listingu 4.14, będzie przecież wykonywać podobne zadanie. Katalog wskazany argumentem $path zostanie otworzony za pomocą funkcji opendir, a następnie w pętli while będzie odczytywana jego zawartość. Każda odczytana nazwa będzie zapisana w zmiennej $file i, o ile nie jest katalogiem, porównana z argumentem $name. W ten sposób sprawdzimy, czy nazwa przekazana do skryptu w postaci parametru faktycznie odpowiada nazwie jednego z plików znajdujących się w katalogu wskazywanym przez $filesPath. Jeżeli plik uda się odnaleźć, funkcja checkFileName zwróci wartość true, w przeciwnym razie — false. Pełny kod skryptu został zaprezentowany na listingu 4.15. Listing 4.15. Kod skryptu download.php <?php $filesPath = "./downloads/"; function checkFileName($name, $path) { $fd = opendir($path); if(!$fd) return false; while (($file = readdir($fd)) !== false){ if(is_dir($path.$file)) continue; if($file == $name) return true; } closedir($fd); return false; } function send($fileName, $filePath) { //tutaj treść funkcji send }<br /> <br /> 240<br /> <br /> PHP5. Praktyczny kurs if(isSet($_GET['name'])){ if(!checkFileName($_GET['name'], $filesPath)){ include "nofile.html"; } else{ if(!send($_GET['name'], $filesPath)){ include "nofile.html"; } } } else{ include "download_list.php"; } ?><br /> <br /> Ostatnia część skryptu to kod pliku nofile.html zawierającego stronę HTML z informacją o braku pliku. Nie musimy go jednak tworzyć od nowa, wystarczy wykorzystać przykład z listingu 4.11, wymieniając odnośnik do pliku download.html na download.php.<br /> <br /> Lista z identyfikatorami Tworzone przez nas do tej pory systemy pobierania plików ze strony WWW opierały się na przekazywaniu nazwy pliku do skryptu wysyłającego dane. Co prawda stosowaliśmy różne funkcje zabezpieczające przed nieuprawnionym pobraniem danych, często stosowanym rozwiązaniem jest jednak przekazywanie do skryptu nie nazwy, ale ustalonego wcześniej identyfikatora pliku. A zatem opierając się na kodzie z ostatniego przykładu, spróbujmy napisać taką wersję witryny, w której pliki do pobrania są rozpoznawane poprzez przypisane im identyfikatory. Zmienione zostaną zasady przechowywania danych. Skoro bowiem i tak musimy przygotować strukturę przechowującą identyfikatory plików, można pokusić się od razu o zwiększenie możliwości całego systemu. Otóż informacje niezbędne do funkcjonowania skryptu będą przechowywane w pliku tekstowym o nazwie downloads.txt. Najlepiej, aby był zapisany poza strukturą plików dostępną przez serwer WWW albo w katalogu o zabronionym dostępie dla użytkowników serwisu (chodzi o to, aby nawet przez przypadek użytkownik witryny nie miał dostępu do nieprzeznaczonych dla niego danych). Każdy wiersz tego pliku będzie w następującym formacie opisywał jeden z plików do pobrania: identyfikator;nazwa;ścieżka dostępu;opis<br /> <br /> Znaczenie poszczególnych elementów opisu oddzielanych od siebie znakami średnika jest zgodne z ich nazwami. Przykładowy ciąg może mieć postać: 00001;zdjecia.zip;/www/picture/;Zdjęcia z wakacji<br /> <br /> gdzie:  00001 — to identyfikator pliku, może mieć on dowolną,<br /> <br /> wymyśloną przez nas postać.  zdjecia.zip — to nazwa pliku.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 241<br /> <br />  /www/pictures/ — to katalog, w którym plik się znajduje.  Zdjęcia z wakacji — to opis pliku.<br /> <br /> Dzięki temu każdy plik będzie mógł być umieszczony w dowolnym katalogu na dysku serwera (nie będzie więc ograniczeń do jednego katalogu, jak we wcześniejszych przykładach) oraz będzie mógł mieć swój własny opis. Należy jedynie pamiętać, że nazwa każdego katalogu musi się kończyć znakiem /6. Użytkownicy systemów z rodziny Windows mogą również zastosować wykorzystywany w tych systemach sposób zapisu ścieżki dostępu jako: dysk:\katalog\podkatalog\<br /> <br /> Przykładowo: c:\www\pictures\<br /> <br /> Postać identyfikatora można wymyślić dowolnie, może to być ciąg cyfr (jak w przykładzie powyżej), liter czy też kombinacja liter i cyfr oraz innych znaków alfanumerycznych. Skoro wiemy już, jak będziemy przechowywać dane, możemy napisać skrypt download_ list.php służący do generowania listy odnośników. Każdy z nich będzie miał postać: <a href="http://adres.serwera/download.php?fileid=identyfikator" rel="nofollow">opis (nazwa)</a><br /> <br /> adres.serwera to w naszym przypadku localhost lub 127.0.0.1, a identyfikator, opis i nazwa będą pobierane z pliku downloads.txt. Lista po przesłaniu będzie miała postać<br /> <br /> przedstawioną na rysunku 4.12, a generuje ją kod widoczny na listingu 4.16. Rysunek 4.12. Lista plików do pobrania<br /> <br /> Listing 4.16. Kod pliku download_list.php generującego listę plików <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Pobieranie plików</title> </head> <body> 6<br /> <br /> Lub też należy do kodu dopisać procedurę badającą obecność tego znaku i dokonującą ewentualnego uzupełnienia.<br /> <br /> 242<br /> <br /> PHP5. Praktyczny kurs <div> <?php $list_file = "downloads.txt"; function printList($list_file) { if(!($fd = fopen($list_file, "r"))){ return; } echo "<ul>"; while (!feof ($fd)){ $line = trim(fgets($fd)); $arr = explode(";", $line); if(count($arr) == 4){ echo "<li><a href='download.php?fileid=$arr[0]" . "' rel="nofollow">$arr[3] ($arr[1])</a> </li>\n"; } } echo "</ul>"; } printList($list_file); ?> </div> </body> </html><br /> <br /> Generowaniem odnośników zajmuje się funkcja printList. Jej pierwszym zadaniem jest otwarcie pliku o nazwie przekazanej w postaci argumentu $list_file (w tym przypadku jest to downloads.txt) za pomocą funkcji fopen. Zwrócony przez fopen deskryptor jest przypisywany zmiennej $fd. Gdyby otwarcie się nie udało, a więc wartością $fd byłoby false, printList zakończy działanie, wykonując instrukcję return. Kolejne wiersze tekstu są wczytywane w pętli while za pomocą funkcji fgets i przypisywane zmiennej $line. Każdy wiersz ma format zgodny z podanym wyżej schematem, a zatem powinien zostać podzielony na cztery części względem znaków średnika. Ta czynność jest wykonywana automatycznie przez funkcję explode. Wynikiem działania explode jest tablica zawierająca poszczególne części podzielonego wiersza tekstu. Ponieważ musimy założyć, że w pliku downloads.txt mogą znajdować się omyłkowe wpisy, które mają niepoprawny format, np. brakuje niektórych znaków średnika, sprawdzamy, czy tablica będąca wynikiem działania explode ma dokładnie 4 wpisy (if(count ($arr) == 4). Do zliczenia elementów tablicy używamy funkcji count. W przypadku gdy liczba ta jest równa 4, konstruujemy odnośnik, jeśli natomiast jest różna od 4 — przechodzimy do kolejnej iteracji pętli. Oczywiście jest to bardzo podstawowy sposób weryfikacji, pozwoli jednak uniknąć prostych błędów na liście. Kolejne indeksy tablicy $arr zawierają następujące dane:  0 — identyfikator pliku,  1 — nazwa pliku,  2 — katalog będący miejscem zapisania pliku,  3 — opis pliku.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 243<br /> <br /> Na podstawie tych danych konstruowany jest odnośnik zgodny z przedstawionym wyżej formatem. Uzyskany ciąg znaków jest wysyłany do przeglądarki za pomocą instrukcji echo w postaci: echo "<li><a href='download.php?fileid=$arr[0]' rel="nofollow">$arr[3] ($arr[1])</a> </li>";<br /> <br /> Na listingu jest ona podzielona na dwie części. Skoro opracowaliśmy kod odpowiedzialny za utworzenie listy odnośników, możemy przystąpić do napisania skryptu download.php zajmującego się wysyłaniem plików i zarządzającego całym systemem. Będzie on sprawdzał, czy został mu przekazany parametr name, czy też nie. W tym drugim przypadku jedynym działaniem będzie wczytanie treści pliku download_list.php (z listingu 4.16), czyli wyświetlenie listy odnośników. W przypadku pierwszym do użytkownika będzie wysyłany wybrany plik (oczywiście o ile przekazany został poprawny identyfikator, a plik faktycznie znajduje się na dysku serwera). Kod działający w opisany sposób jest widoczny na listingu 4.17. Listing 4.17. Treść skryptu download.php <?php $list_file = "downloads.txt"; function send($id, $list_file) { if(!($fd = fopen($list_file, "r"))){ return false; } $found = false; while (!feof ($fd)){ $line = trim(fgets($fd)); $arr = explode(";", $line); if(count($arr) == 4){ if($id === $arr[0]){ $found = true; $path = $arr[2]; $name = $arr[1]; break; } } } if((!$found) || (!file_exists($path.$name))){ return false; } if(!($fd = fopen($path.$name, "r"))){ return false; } $size = filesize($path.$name); $contents = fread($fd, $size); if($contents === false){ return false; }<br /> <br /> 244<br /> <br /> PHP5. Praktyczny kurs fclose($fd); header("Content-Type: application/octet-stream"); header("Content-Length: $size;"); header("Content-Disposition: attachment; filename=$name"); echo $contents; return true; } if(isSet($_GET['fileid'])){ if(!send($_GET['fileid'], $list_file)){ include "nofile.html"; } } else{ include "download_list.php"; } ?><br /> <br /> Główną część skryptu zajmuje funkcja send odpowiedzialna za wykonanie większości operacji, jednak wykonywanie kodu rozpoczyna się na końcu pliku od sprawdzenia, czy za pomocą metody GET został przekazany parametr o nazwie fileid. Innymi słowy, czy w tablicy $_GET znajduje się klucz fileid. Jeśli nie, za pomocą instrukcji include jest wczytywana treść pliku download_list.php, czyli do przeglądarki wysyłana jest lista odnośników. Jeśli jednak parametr fileid został przekazany skryptowi, wykonywana jest funkcja send. Przyjmuje ona w postaci argumentu identyfikator pliku, który ma zostać wysłany. Jej zadania to: sprawdzenie, czy identyfikator jest poprawny, czy faktycznie na dysku serwera istnieje wskazany plik oraz wysłanie pliku. Zwracaną wartością jest true, jeśli plik został wysłany, bądź też false, o ile na którymś z etapów działania funkcji wystąpił błąd. W tym drugim przypadku skrypt jedynie wczyta treść pliku nofile.html i zakończy działanie. Funkcja send zaczyna działanie od próby otwarcia pliku downloads.txt. Gdyby otwarcie się nie powiodło, kończy działanie, zwracając wartość false. Jeśli jednak plik uda się otworzyć, w pętli while odczytywane są jego kolejne wiersze. Jest to procedura analogiczna do zastosowanej w skrypcie z listingu 4.16. Każda linia rozbijana jest na cztery części względem znaków średnika. Jeśli zostanie stwierdzone, że odczytany z danej linii identyfikator (wartość klucza 0 tablicy $arr) jest taki sam jak ten przekazany funkcji send w postaci argumentu $id, zmiennym $path i $name przypisana zostanie ścieżka dostępu do pliku (wartość klucza 2) oraz jego nazwa (wartość klucza 1). Dodatkowo zmiennej pomocniczej $found przypisana będzie wartość true i pętla zostanie przerwana. Jeśli zatem identyfikator zostanie odnaleziony, zmienna $found będzie miała wartość true, a zmienne $path i $name będą zawierały niezbędne dane. Jeżeli natomiast identyfikator nie zostanie odnaleziony, zmienna $found będzie miała wartość false (wartość przypisaną przed rozpoczęciem pętli), a zmienne $path i $name będą nieustawione.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 245<br /> <br /> Po zakończeniu pętli while za pomocą instrukcji if są sprawdzane dwa warunki: czy zmienna $found ma wartość różną od false oraz czy istnieje plik wskazywany przez zmienne $path i $name. Jeśli $found ma wartość false lub plik nie istnieje, funkcja kończy działanie, zwracając wartość false. W przypadku gdy zmienna $found ma wartość true, a plik wskazywany przez $path i $name istnieje, jest on wysyłany do przeglądarki użytkownika za pomocą techniki analogicznej do wykorzystywanej we wcześniejszych przykładach. Na zakończenie pozostaje nam przygotować treść pliku nofile.html. Możemy ją spokojnie skopiować z listingu 11.3, pamiętając o zamianie odwołania w znaczniku <a> z: <a href="http://localhost/download.html" rel="nofollow">Powrót do strony pobrań</a><br /> <br /> na: <a href="http://localhost/download.php" rel="nofollow">Powrót do strony pobrań</a><br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 14.1. Zmodyfikuj przykład przedstawiony w sekcji „Pobieranie w jednym skrypcie” w taki sposób, aby cały kod (włącznie z instrukcjami HTML) znalazł się w jednym pliku — download.php. Ćwiczenie 14.2. Zmodyfikuj przykład przedstawiony w sekcji „Automatyczne generowanie listy”, tak aby cały kod znalazł się w jednym pliku. Ćwiczenie 14.3. Napisz skrypt, który będzie umożliwiał pobieranie plików określonego typu z wybranego podkatalogu (np. na liście dostępnych plików będą się pojawiały jedynie te o rozszerzeniu zip). Ćwiczenie 14.4. Zmodyfikuj kod funkcji send z listingu 4.12 (lub 4.17) w taki sposób, aby w przypadku gdy wysyłany ma być plik o zerowej długości, nie było generowane ostrzeżenie (o ile włączone jest wyświetlanie błędów PHP), ale by był on faktycznie wysyłany.<br /> <br /> Lekcja 15. Obsługa cookies Krótko o cookies Większość czytelników na pewno spotkała się już z pojęciem cookies i dobrze zna jego znaczenie. Przypomnijmy, że są to niewielkie tekstowe porcje danych wymieniane między serwerem a przeglądarką i przechowywane przez nią na dysku użytkownika. Cookies są częścią specyfikacji protokołu HTTP i są wysyłane do przeglądarki w postaci nagłówka HTTP o nazwie Set-Cookie. Schemat postępowania jest następujący:  Przy pierwszym nawiązaniu połączenia serwer wysyła do przeglądarki nagłówek Set-Cookie zawierający cookie.<br /> <br /> 246<br /> <br /> PHP5. Praktyczny kurs  Przeglądarka zapisuje cookie na dysku.  Podczas kolejnych połączeń z danym serwerem przeglądarka wysyła<br /> <br /> do niego przechowywane na dysku cookie. Zobaczmy zatem, jak należy obsługiwać cookies w PHP.<br /> <br /> Obsługa cookies w PHP Jak zapisać cookie? Aby zapisać cookie, czyli wysłać je do przeglądarki, należy użyć funkcji o nazwie setcookie, której wywołanie ma postać: setcookie(nazwa[, wartość[, czas_życia[, ścieżka_dost[, domena[, bezpieczne[, tylko_http]]]]]])<br /> <br /> Poszczególne argumenty mają następujące znaczenie:  nazwa — nazwa identyfikująca cookie.  wartość — wartość cookie.  czas_życia — znacznik czasu Uniksa określający, kiedy wygasa ważność<br /> <br /> cookie. Po tym czasie zostanie ono usunięte przez przeglądarkę. Ten argument bywa również określany jako czas ważności.  ścieżka_dost — ścieżka dostępu na serwerze, do której zostanie ograniczona dostępność cookie. Na przykład ustawienie tego parametru na / powoduje, że cookie dostępne jest w całej domenie, a ustawienie /www/example/, że będzie dostępne jedynie przy odwołaniu do katalogu /www/example/ i katalogów podrzędnych w stosunku do /www/example/.  domena — określa domenę, w której cookie będzie dostępne. Na przykład ustawienie na .domain.com powoduje, że cookie będzie dostępne we wszystkich poddomenach domeny domain.com, natomiast ustawienie na www.domain.com<br /> <br /> powoduje, że będzie dostępne jedynie w obrębie domeny www.domain.com.  bezpieczne — ustawienie na true wskazuje, że cookie powinno być przesyłane jedynie przez bezpieczne połączenia HTTPS; false — że będzie przesyłane również przez zwykłe połączenia HTTP. Ustawieniem domyślnym jest false.  tylko_http — ustawienie na true powoduje, że cookie będzie dostępne tylko<br /> <br /> poprzez protokół HTTP. Nie będzie więc dostępne przez języki skryptowe takie jak JavaScript (parametr wprowadzony w PHP 5.2.0). Jedynym argumentem obligatoryjnym jest nazwa, wszystkie pozostałe (tak jak zostało to oznaczone nawiasami kwadratowymi) są opcjonalne. Najczęściej wykorzystywany jest też zestaw trzech pierwszych parametrów. W przypadku gdy zostanie pominięty argument czas_życia, cookie będzie ważne jedynie do końca sesji, czyli aż do zamknięcia przeglądarki, po czym zostanie usunięte. Należy pamiętać, że ponieważ funkcja setcookie wysyła nagłówek HTTP, musi być wywołana przed wysłaniem jakichkol-<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 247<br /> <br /> wiek innych danych, w tym wszelkich danych będących składnikami strony (jest to taka sama sytuacja jak w przypadku funkcji header). Oznacza to, że kod w przykładowej postaci: <!-- tutaj nagłówek HTML --> <body> <div> <?php setCookie("example", "123"); ?> Treść strony </div> </body> </html><br /> <br /> lub: <?php //tutaj instrukcje wysyłające nagłówek HTML echo "<body>" echo "<div>" setCookie("example", "123"); echo "Treść strony" echo "</div>" echo "</body>" ?><br /> <br /> nie zadziała poprawnie. W takiej sytuacji cookie nie zostanie wysłane oraz (jeśli konfiguracja PHP na to pozwala) zostanie wyświetlone ostrzeżenie widoczne na rysunku 4.13. Rysunek 4.13. Nieprawidłowa konstrukcja kodu uniemożliwiła wysłanie cookie<br /> <br /> Poprawne są natomiast konstrukcje: <?php setCookie("example", "123"); ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <!-- dalsza część pliku HTML --><br /> <br /> oraz: <?php setCookie("example", "123"); echo "<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">";<br /> <br /> 248<br /> <br /> PHP5. Praktyczny kurs echo "<html>"; echo "<head>"; //tutaj dalsza część kodu ?><br /> <br /> Opisane zachowanie może być zmienione, jeśli w pliku konfiguracyjnym php.ini zostanie włączona opcja output_bufffering7: output_bufffering = On<br /> <br /> Zmniejsza to jednak wydajność przetwarzania skryptów. W niektórych wersjach PHP opcja ta jest domyślnie włączona, aby więc zobaczyć przedstawiony efekt, trzeba ją wyłączyć. W dalszym opisie przyjęto, że opcja buforowania jest wyłączona i wysyłanie cookies musi się odbywać przed wysłaniem innych danych. Jeśli jeden z powyższych skryptów zapiszemy np. w pliku index.php i wywołamy w przeglądarce, zapisze ona na dysku cookie o nazwie example i wartości 123 (będzie ono ważne jedynie do zakończenia sesji, czyli do zamknięcia programu). Możemy się o tym przekonać, jeśli korzystamy z przeglądarki pozwalającej na bezpośredni podgląd cookies. Na przykład w Firefoksie 4 z menu Narzędzia wybieramy pozycję Opcje, a w oknie, które się wtedy ukaże (rysunek 4.14), Prywatność oraz odnośnik usunąć pojedyncze ciasteczka (we wcześniejszych wersjach była to opcja Pokaż ciasteczka). Na ekranie zobaczymy wtedy okno Zachowane ciasteczka, w którym możemy odszukać cookies ustawione przez nasz skrypt (rysunek 4.15). Pamiętajmy, że nazwa witryny z lewej strony listy cookies będzie zgodna z wpisaną przez nas na pasku adresu przeglądarki. Jeśli zatem do skryptu odwołaliśmy się jako http://localhost/index.php, to nazwą witryny będzie localhost, jeśli natomiast było to http://127.0.0.1/index.php, to nazwą będzie 127.0.0.1. Rysunek 4.14. Okno opcji przeglądarki FireFox<br /> <br /> 7<br /> <br /> Możliwe jest również stosowanie funkcji buforujących, jednak ich opis wykracza poza ramy tematyczne książki.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 249<br /> <br /> Rysunek 4.15. Okno zarządzania cookies<br /> <br /> Jak usunąć cookie? Wiemy już, jak wysyłać do przeglądarki cookies. A jakie są zasady ich usuwania? Otóż jeśli został określony czas ważności, po jego upływie przeglądarka usunie cookie. Jeśli natomiast czas ważności nie był określony przy wywołaniu funkcji setCookie, jest ono ważne tylko do zamknięcia przeglądarki, po czym jest kasowane. Jeśli sami chcemy skasować cookie, możemy to zrobić albo poprzez ustawienie czasu ważności, który już upłynął, albo ustawiając jako wartość cookie pusty ciąg znaków lub wartość false. Co jednak ważne, pozostałe argumenty wywołania funkcji w celu usunięcia cookie muszą być takie same jak argumenty użyte do jego ustawienia. Przykładowo w celu usunięcia cookie o nazwie example z przykładów w pierwszej części lekcji można użyć jednej z konstrukcji: setCookie("example", "123", time() - 100); setCookie("example", ""); setCookie("example", false);<br /> <br /> Warto zwrócić uwagę, w jaki sposób w pierwszym przypadku jest konstruowany czas z przeszłości. Jest to wywołanie funkcji time zwracającej aktualny znacznik czasu Uniksa, od którego jest odejmowana wartość 100. Wynikiem jest znacznik opisujący czas przesunięty o 100 sekund wstecz w stosunku do czasu wywołania funkcji time (czyli czasu aktualnego).<br /> <br /> Dostęp do cookies Przeglądarka w trakcie łączenia z wybranym serwerem sprawdza, czy ma na dysku zapisane cookies tego serwera i jeśli tak, wysyła je w postaci nagłówka protokołu HTTP. W PHP mamy do nich dostęp poprzez superglobalną tablicę $_COOKIES. Jej indeksami są nazwy cookies, czyli dostęp do pojedynczego cookie można uzyskać za pomocą konstrukcji o schematycznej postaci: $_COOKIE['nazwa']<br /> <br /> 250<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Wykonajmy prosty przykład obrazujący zastosowanie takiej techniki. Jest on widoczny na listingu 4.18. Listing 4.18. Zapis i odczyt wartości cookie <?php if(!isSet($_COOKIE['visited'])){ setcookie("visited", "yes"); $str = "Cookie o nazwie visited nie jest ustawione."; } else{ $str = "Cookie o nazwie visited jest ustawione."; $str .= "Jego wartość to: {$_COOKIE['visited']}."; } ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Zapis i odczyt cookies</title> </head> <body> <?php echo("$str"); ?> </body> </html><br /> <br /> Najpierw za pomocą funkcji isSet skrypt sprawdza, czy w tablicy $_COOKIE został ustawiony indeks visited, tzn. czy do serwera zostało przesłane cookie o takiej nazwie. Jeśli nie, jest wykonywana funkcja setcookie ustawiająca cookie o nazwie visited i wartości yes, natomiast zmiennej $str jest przypisywany tekst informujący o braku cookie. Jeśli jednak indeks visited znajduje się w tablicy $_COOKIE, zmiennej $str jest przypisywany napis zawierający wartość odczytaną z cookie. Wartość zapisana w $str jest wykorzystywana wewnątrz kodu HTML do zbudowania treści strony.<br /> <br /> Korzystanie z cookies Zapamiętywanie danych Cookies można wykorzystywać na różne sposoby. Jednym z nich może być np. zapamiętywanie danych użytkownika. Wykonajmy taki przykład. Będzie się on składał z kilku plików:  index.php — zawiera skrypt zarządzający,  form.html — zawiera kod formularza,  header.html — zawiera kod HTML nagłówka strony,  footer.html — zawiera kod HTML stopki strony.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 251<br /> <br /> Formularz znajdujący się w pliku form.inc będzie zawierał jedno pole tekstowe oraz przycisk typu submit i pozwalał na wprowadzenie imienia i nazwiska bądź nazwy użytkownika, tak jak zostało to przedstawione na rysunku 4.16. Kod HTML został natomiast zaprezentowany na listingu 4.19. Rysunek 4.16. Formularz umożliwiający wprowadzenie imienia i nazwiska<br /> <br /> Listing 4.19. Kod formularza umożliwiającego wprowadzenie danych (form.html) <form method="get" action="http://localhost/index.php" > <div> Wprowadź imię i nazwisko: <input type="text" name="nazwa" /> <input type="submit" /> </div> </form><br /> <br /> Jak widać, formularz ten nie zawiera znaczników budujących strukturę strony (<html>, <head>, <body> itp.), gdyż w celu uniknięcia niepotrzebnego duplikowania kodu zostały one przeniesione do plików header.html i footer.html. Ich treść została zaprezentowana na listingach 4.20 oraz 4.21 i z pewnością nie wymaga bliższego objaśniania. Listing 4.20. Treść pliku header.html <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Zapamiętywanie danych</title> </head> <body><br /> <br /> Listing 4.21. Treść pliku footer.html </body> </html><br /> <br /> Do napisania pozostał nam zatem skrypt index.php. Będzie on działał w następujący sposób:  Jeśli za pomocą metody GET został przekazany parametr name, to jego wartość powinna być zapisana w cookie nazwa oraz powinien zostać wyświetlony tekst<br /> <br /> z podziękowaniem za podanie danych.<br /> <br /> 252<br /> <br /> PHP5. Praktyczny kurs  Jeśli przekazane zostało cookie nazwa, powinna zostać wyświetlona<br /> <br /> informacja o rozpoznaniu użytkownika (rysunek 4.17). Rysunek 4.17. Wygląd strony po rozpoznaniu użytkownika<br /> <br />  Jeśli nie został przekazany parametr name oraz nie zostało otrzymane cookie,<br /> <br /> to powinien zostać wyświetlony formularz umożliwiający wprowadzenie danych. Kod działający w opisany sposób został przedstawiony na listingu 4.22. Listing 4.22. Treść skryptu index.php <?php if(!isSet($_COOKIE['nazwa']) && !isSet($_GET['nazwa'])){ include("header.html"); include("form.html"); include("footer.html"); } else if(isSet($_GET['nazwa'])){ //w tym miejscu warto dodać instrukcje weryfikujące poprawność danych setcookie("nazwa", $_GET['nazwa'], time() + 60 * 60 * 24 * 365); include("header.html"); echo("<p>Dziękujemy za podanie danych.</p>"); include("footer.html"); } else{ //w tym miejscu warto dodać instrukcje weryfikujące poprawność danych include("header.html"); echo("Witamy, zostałeś rozpoznany jako {$_COOKIE['nazwa']}."); include("footer.html"); } ?><br /> <br /> W kodzie skryptu znajduje się złożona instrukcja warunkowa if...else if, która rozpatruje wymienione wyżej sytuacje. Na początku jest rozpatrywany przypadek, gdy nie zostało przesłane ani cookie, ani argument nazwa (!isSet($_COOKIE['nazwa']) && !isSet($_GET['nazwa'])). Strona jest wtedy budowana z nagłówka (header.html), kodu formularza (form.html) oraz stopki (footer.html). Druga z rozpatrywanych sytuacji ma miejsce wtedy, gdy w tablicy $_GET znajduje się indeks nazwa, co oznacza, że do skryptu zostały przesłane dane z formularza. W takiej sytuacji za pomocą funkcji setcookie do przeglądarki jest wysyłane cookie o nazwie nazwa, wartości odczytanej z tablicy $_GET i czasie ważności ustawionym na 365 dni (60 sekund * 60 minut * 24 godziny * 365 dni), począwszy od aktualnego czasu. Między nagłówkiem a stopką strony jest wtedy umieszczany akapit tekstowy (znacznik <p>)<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 253<br /> <br /> zawierający podziękowanie za wprowadzenie danych. W praktyce w miejscu oznaczonym komentarzem warto byłoby też dodać instrukcje weryfikujące dane otrzymane w parametrze nazwa. Można np. ograniczyć maksymalną długość ciągu lub (i) odrzucać znaki niebędące literami. Trzecia rozpatrywana sytuacja ma miejsce, gdy w tablicy $_COOKIES znajduje się indeks nazwa. Na stronie jest wtedy wyświetlana informacja o rozpoznaniu użytkownika. Oczywiście jest ona umieszczana pomiędzy zawartością plików header.html i footer.html. Tu również należałoby zweryfikować, jakie dane znajdują się pod indeksem nazwa. Zauważmy bowiem, że użytkownik może podmienić zawartość cookie, które jest przecież przechowywane na jego komputerze, i wprowadzić do niego, np. kod HTML. To można łatwo sprawdzić. Wystarczy w formularzu z rysunku 4.16 zamiast imienia i nazwiska wpisać np.: <script>alert('test');</script><br /> <br /> i kliknąć przycisk Wyślij zapytanie. Wtedy w cookie zostanie zapisany prosty skrypt JavaScript, a kolejne odwołanie się do adresu http://locahost/index.php spowoduje — uwaga — uruchomienie tego skryptu (rysunek 4.18)! To najlepszy dowód na to, że wszelkie dane otrzymywane od użytkownika (przeglądarki) zawsze trzeba weryfikować pod kątem ich poprawności. Rysunek 4.18. Wczytanie strony spowodowało uruchomienie kodu zawartego w cookie<br /> <br /> Zliczanie liczby odwiedzin Cookies możemy również wykorzystać do zliczania liczby odwiedzin danego użytkownika na naszej witrynie, a dokładniej do zliczania jej wywołań z danej przeglądarki (może się przecież zdarzyć, że z jednego profilu przeglądarki na danym komputerze korzysta wielu użytkowników). Takie zadanie realizuje skrypt widoczny na listingu 4.23. Listing 4.23. Skrypt zliczający liczbę odwiedzin <?php $dni = 30; if(!isSet($_COOKIE['hits'])){ $ile = 1;<br /> <br /> 254<br /> <br /> PHP5. Praktyczny kurs } else{ $ile = intval($_COOKIE['hits']); if($ile < 1) $ile = 1; $ile++; } setcookie("hits", "$ile", time() + 60 * 60 * 24 * $dni); ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Zliczanie liczby odwiedzin</title> </head> <body> <p> <?php if($ile == 1) $str = "raz"; else $str = "razy"; echo "Witamy, w ciągu ostatnich $dni dni byłeś na tej stronie $ile $str."; ?> </p> </body> </html><br /> <br /> Kod rozpoczyna się od przypisania wartości pomocniczej zmiennej o nazwie $dni. Określa ona, ile dni ważne będzie cookie przechowujące dane, a zatem również to, w jakim okresie będą zliczane wywołania strony. Następnie za pomocą funkcji isSet jest sprawdzane, czy w tablicy $_COOKIE istnieje indeks hits, a zatem czy przeglądarka przesłała cookie do serwera. Jeśli nie, wartość zmiennej $ile (wskazującej liczbę odwiedzin) jest ustawiana na 1, jeśli tak — wartość ta jest odczytywana z tablicy $_COOKIE, za pomocą funkcji intval zamieniana na wartość całkowitą (należy pamiętać, że z cookie zawsze odczytujemy ciąg znaków) i zwiększana o jeden. W obu przypadkach do przeglądarki wysyłane jest cookie o nazwie hits i wartości zapisanej w zmiennej $ile. Dzięki funkcji intval nie tylko uzyskujemy wartość całkowitą, ale także unikamy problemów, gdyby pod indeksem hits znajdował się ciąg niereprezentujący liczby całkowitej (np. użytkownik zmienił zawartość cookie na jakiś tekst). Wtedy funkcja zwróci wartość 0 i to ta wartość zostanie przypisana zmiennej $ile. Dalsze operacje porównywania i zwiększania wykonywane na tej zmiennej będą zatem poprawne. Wartość zmiennej $ile jest również wykorzystywana do wyświetlenia dotychczasowej liczby odwiedzin na ekranie (rysunek 4.19; ponieważ początkową wartością $ile jest 1, w zliczaniu uwzględniane jest już pierwsze odwołanie się do strony). Sprawdzamy przy tym dodatkowo, czy jest ona równa 1, czy różna od 1. Dzięki temu można poprawnie skonstruować wyświetlane zdanie. Jeśli więc $ile jest równe 1, zmiennej pomocniczej $str jest przypisywany ciąg znaków raz, a w przeciwnym wypadku — ciąg razy.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 255<br /> <br /> Rysunek 4.19. Przykładowy efekt działania skryptu zliczającego liczbę odwiedzin<br /> <br /> Należy przy tym podkreślić, że w żadnym wypadku nie jest to miarodajna metoda zliczania liczby odwiedzin (temat liczników odwiedzin witryny zostanie poruszony w rozdziale 4.), a jedynie ilustracja sposobu, w jaki można użyć cookie. Wartością cookies można bowiem dowolnie manipulować, a ich przyjmowanie może też zostać wyłączone zarówno w przeglądarce, jak i np. na poziomie firewalla.<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 15.1. Napisz skrypt, który za pomocą cookies zlicza liczbę odwiedzin strony przez danego użytkownika i po osiągnięciu zadanej wartości wyświetla stosowną informację. Ćwiczenie 15.2. Napisz skrypt, który zapisuje w cookies datę urodzin użytkownika (wprowadzoną przez dostępny na stronie formularz) i wyświetla życzenia, jeśli odwiedzi on stronę w tym dniu. Ćwiczenie 15.3. Zmień kod z listingu 4.22 tak, aby w sytuacji gdy w cookie zostały zapisane znaczniki HTML (np. przez wprowadzenie ich do formularza), zostały one usunięte, a strona działała poprawnie. Ćwiczenie 15.4. Zmodyfikuj kod z listingu 4.23 w taki sposób, aby w sytuacji gdy cookie zawiera wartość, która nie może być interpretowana jako liczba, wyświetlany był komunikat o nieprawidłowych danych.<br /> <br /> Lekcja 16. Sesje Wstęp do sesji Protokół HTTP, który obsługuje transmisje WWW, jest protokołem bezstanowym pracującym w trybie pytanie – odpowiedź. Oznacza to, że każde żądanie pobrania elementu strony WWW jest niezależne od innych. Taki protokół nie daje możliwości stwierdzenia, czy nadchodzące żądania pochodzą od tego samego, czy też od innego użytkownika. Pewnym rozwiązaniem problemu identyfikacji są opisane w poprzedniej lekcji cookies. Nie jest to jednak mechanizm doskonały. Przede wszystkim niektóre przeglądarki (co prawda obecnie rzadko spotykane) mogą nie obsługiwać cookies. Współcześnie większość z nich ma również opcję pozwalającą użytkownikom zabronić przyjmowania<br /> <br /> 256<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> tych plików, czasami są też one odrzucane np. przez zaawansowane programy typu firewall. Bezpośrednia obsługa cookies nie jest też zbyt wygodna. Dlatego w PHP został wprowadzony mechanizm identyfikacyjny, tzw. sesje. Pozwala on na śledzenie postępowań danego użytkownika na witrynie od pierwszego połączenia z nią aż do jej opuszczenia. Umożliwia to m.in. prostą obsługę logowania i uwierzytelniania użytkowników, śledzenie preferencji, wyświetlanie spersonalizowanych stron, realizację wirtualnych koszyków na zakupy itp.<br /> <br /> Identyfikator sesji Każda sesja użytkownika ma przypisany własny, unikalny identyfikator. Ten identyfikator to losowa liczba generowana przez PHP. Jest ona przechowywana na serwerze i na komputerze użytkownika. W tym drugim przypadku najczęściej w cookies. Jeśli jednak przeglądarka użytkownika nie akceptuje cookies lub jeśli autor witryny nie życzy sobie przechowywania identyfikatora w plikach tego typu, identyfikator jest dodawany do adresu URL. Z pewnością każdy spotkał się kiedyś z sytuacją, gdy kliknięcie odnośnika na stronie powodowało wywołanie adresu zawierającego długą listę wydawałoby się przypadkowych znaków (rysunek 4.20). Zazwyczaj jest to właśnie identyfikator sesji. Rysunek 4.20. Identyfikator sesji przekazywany w adresie URL<br /> <br /> Każdej sesji można przypisywać zmienne, które będą dostępne przez cały czas jej trwania. Jeśli zatem rozpoczniemy sesję wtedy, gdy użytkownik odwiedzi stronę główną naszej witryny, to zmienne sesji będą również dostępne na wszystkich podstronach, i to tak długo, aż zostanie ona zakończona. Wszystkie takie zmienne są przechowywane na serwerze, a użytkownik nie ma do nich dostępu. Jak takie rozwiązanie działa w praktyce, zostanie pokazane w dalszej części lekcji.<br /> <br /> Rozpoczynanie sesji Sesja może być rozpoczynana na kilka różnych sposobów. Pierwszy z nich, często stosowany, to po prostu wywołanie funkcji session_start. W przypadku gdy sesja wykorzystuje cookies, ta funkcja musi być wywołana, zanim jakiekolwiek dane zostaną wysłane do przeglądarki. Wynika to z faktu przesyłania cookies w nagłówkach protokołu HTTP. Dobrze jest umieścić wywołanie session_start na początku każdego skryptu korzystającego z sesji. Funkcja session_start nie przyjmuje żadnych parametrów, a zatem jej wywołanie ma postać: session_start();<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 257<br /> <br /> Zwracaną wartością w wersjach wcześniejszych niż 5.3.0 jest zawsze true. Począwszy od wersji 5.3.0, wartość true jest zwracana, jeśli sesję udało się utworzyć, w przeciwnym razie natomiast zwracana jest wartość false. W jednym skrypcie session_start należy wywoływać tylko raz. Ponowne wywołanie będzie bowiem zignorowane i zostanie wyświetlony stosowny komunikat (o ile w pliku php.ini zostało włączone wyświetlanie błędów — poziom błędu E_NOTICE). Istnieje również możliwość automatycznego rozpoczynania sesji podczas wywoływania każdego skryptu. W tym celu w pliku php.ini zmienną konfiguracyjną session. auto_start należy ustawić na 1. Wartością domyślną jest 0, czyli domyślnie opcja ta jest wyłączona.<br /> <br /> Kończenie sesji W celu zakończenia sesji należy wywołać funkcję session_destroy. Usuwa ona zasoby powiązane z sesją, nie usuwa jednak zarejestrowanych zmiennych ani cookie zapisanego na komputerze użytkownika. Zmienne należy usunąć ręcznie za pomocą przeznaczonych do tego funkcji (więcej o tym w kolejnej części lekcji), a cookie za pomocą funkcji setcookie (patrz przykład w dziale „Implementacja sesji”). Funkcja session_ destroy nie przyjmuje argumentów, a jej wywołanie ma postać: session_destroy();<br /> <br /> Zwracaną wartością jest true, jeżeli operacja zakończyła się sukcesem, lub false, jeśli zakończyła się niepowodzeniem.<br /> <br /> Zmienne sesji Tworzenie zmiennych Po rozpoczęciu sesji można stosować jej zmienne, które będą dostępne aż do jej zakończenia. Zmienne sesji są zapisywane w globalnej tablicy o nazwie $_SESSION, która może być wykorzystywana tak jak każda inna tablica. Aby zatem zapisać (zarejestrować) zmienną w sesji, należy skorzystać z konstrukcji: $_SESSION['nazwa_zmiennej'] = wartość;<br /> <br /> Aby natomiast odczytać wartość zmiennej, trzeba odwołać się do indeksu wskazującego jej nazwę, np.: $zmienna = $_SESSION['nazwa_zmiennej'];<br /> <br /> Gdy trzeba sprawdzić, czy istnieje dana zmienna sesji, stosuje się typową funkcję isSet w postaci: isSet($_SESSION['nazwa_zmiennej'])<br /> <br /> Jeśli zwróconą wartością będzie true, oznacza to, że zmienna jest zarejestrowana, a jeśli false, że nie jest.<br /> <br /> 258<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Usuwanie zmiennych Zmienne, które zostały zarejestrowane w sesji, należy przed jej zakończeniem wyrejestrować. Należy skorzystać z funkcji unset w schematycznej postaci: unset($_SESSION['nazwa_zmiennej'])<br /> <br /> Nastąpi wtedy wyrejestrowanie z sesji oraz usunięcie zmiennej.<br /> <br /> Konfiguracja sesji W pliku php.ini zawarty jest zestaw opcji konfiguracyjnych pozwalających wpływać na zachowanie sesji. Lista tych opcji wraz z opisami została przedstawiona w tabeli 4.1 (tabela nie zawiera opcji przestarzałych, które będą usunięte w przyszłych wersjach PHP). Tabela 4.1. Opcje konfiguracyjne sesji Wartość domyślna<br /> <br /> Nazwa opcji<br /> <br /> Znaczenie<br /> <br /> session.auto_start<br /> <br /> Określa, czy sesja ma się rozpoczynać automatycznie przy wywoływaniu skryptu. Wartość 1 oznacza tak, wartość 0 — nie.<br /> <br /> 0<br /> <br /> session.cache_expire<br /> <br /> Ustala, jak długo dane sesji mają być przechowywane w pamięci cache. Wartość ta jest podawana w minutach.<br /> <br /> 180<br /> <br /> session.cache_limiter<br /> <br /> Ustala, czy i w jaki sposób dane sesji mają być przechowywane w pamięci cache. Dopuszczalne wartości to: none, nocache, private, private_no_expire, public.<br /> <br /> nocache<br /> <br /> session.cookie_domain<br /> <br /> Określa domenę dla cookie sesji.<br /> <br /> ""<br /> <br /> session.cookie_httponly<br /> <br /> Zaznacza, że cookie sesji powinno być dostępne wyłącznie przez protokół HTTP. Opcja dostępna, począwszy od PHP 5.2.0.<br /> <br /> ""<br /> <br /> session.cookie_lifetime<br /> <br /> Określa, jak długo cookie przechowujące identyfikator sesji będzie przechowywane przez przeglądarkę użytkownika.<br /> <br /> 0<br /> <br /> session.cookie_path<br /> <br /> Określa ścieżkę dostępu przechowywaną w cookie sesji.<br /> <br /> /<br /> <br /> session.cookie_secure<br /> <br /> Określa, czy cookie sesji powinno być przesyłane wyłącznie przez bezpieczny protokół HTTPS (domyślnie — nie).<br /> <br /> ""<br /> <br /> session.entropy_file<br /> <br /> Ścieżka dostępu do pliku zawierającego dodatkowe, losowe dane wykorzystywane w procesie tworzenia identyfikatora sesji.<br /> <br /> ""<br /> <br /> session.entropy_length<br /> <br /> Określa, ile bajtów ma być pobranych z pliku wskazywanego przez session.entropy_file.<br /> <br /> 0<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 259<br /> <br /> Tabela 4.1. Opcje konfiguracyjne sesji — ciąg dalszy Wartość domyślna<br /> <br /> Nazwa opcji<br /> <br /> Znaczenie<br /> <br /> session.gc_divisor<br /> <br /> W połączeniu z session.gc_probability określa prawdopodobieństwo tego, że podczas inicjalizacji 8 sesji zostanie uruchomiony proces odśmiecacza (z ang. garbage collector). Wartość wyliczana jest ze wzoru session.gc_probability / session.gc_divisor.<br /> <br /> 1<br /> <br /> session.gc_maxlifetime<br /> <br /> Określa w sekundach czas, po jakim dane zostaną poddane procesowi odśmiecania.<br /> <br /> 1440<br /> <br /> session.gc_probability<br /> <br /> W połączeniu z session.gc_divisor określa prawdopodobieństwo tego, że podczas inicjalizacji sesji zostanie uruchomiony proces odśmiecacza. Wartość wyliczana jest ze wzoru<br /> <br /> 100<br /> <br /> session.gc_probability / session.gc_divisor.<br /> <br /> 8<br /> <br /> session.hash_bits_per_character<br /> <br /> Określa, ile bitów będzie przypisanych poszczególnym znakom podczas konwersji identyfikatora sesji na możliwy do odczytu ciąg. Dopuszczalne wartości to: 4 (wykorzystane zostaną znaki 0 – 9 i a – f), 5 (wykorzystane zostaną znaki 0 – 9 i a – v) i 6 (wykorzystane zostaną znaki 0 – 9, a – z, A – Z, - i ,).<br /> <br /> 4<br /> <br /> session.hash_function<br /> <br /> Określa, jaki algorytm zostanie wykorzystany do wygenerowania identyfikatora sesji. Wartość 0 oznacza algorytm MD5, wartość 1 — algorytm SHA-1. Począwszy od PHP 5.3.0, możliwe jest także użycie dowolnego zarejestrowanego algorytmu haszującego.<br /> <br /> 0<br /> <br /> session.name<br /> <br /> Określa nazwę sesji wykorzystywaną w cookie. Nazwa powinna zawierać jedynie znaki alfanumeryczne.<br /> <br /> PHPSESSID<br /> <br /> session.referer_check<br /> <br /> Określa ciąg znaków, który musi być zawarty w nagłówku HTTP_REFERER wysłanym przez przeglądarkę. Jeśli przeglądarka wysłała nagłówek i nie zawiera on ciągu wskazywanego przez session.referer_check, identyfikator sesji zostanie unieważniony.<br /> <br /> ""<br /> <br /> session.save_handler<br /> <br /> Określa, jaka procedura obsługi będzie wykorzystywana do zapisu i odczytu danych sesji. Domyślnie dane przechowywane są w plikach. Więcej informacji można znaleźć w dokumentacji PHP w opisie funkcji session_set_save_handler().<br /> <br /> files<br /> <br /> Odśmiecacz (garbage collector) zajmuje się procedurą odśmiecania (garbage collection), czyli zwalnianiem pamięci zajętej przez nieużywane już zmienne i obiekty. Dzięki temu programista nie musi zajmować się samodzielnym wykonywaniem tej procedury.<br /> <br /> 260<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Tabela 4.1. Opcje konfiguracyjne sesji — ciąg dalszy Wartość domyślna<br /> <br /> Nazwa opcji<br /> <br /> Znaczenie<br /> <br /> session.save_path<br /> <br /> Określa argument, który zostanie przekazany procedurze obsługi zdefiniowanej w opcji session.save_handler. Domyślnie jest to ścieżka dostępu do katalogu, w którym tworzone będą pliki z danymi.<br /> <br /> /temp<br /> <br /> session.serialize_handler<br /> <br /> Nazwa procedury obsługi wykorzystywanej do serializacji i deserializacji danych. Obsługiwane formaty to wewnętrzny format PHP oraz format wddx.<br /> <br /> php<br /> <br /> session.use_cookies<br /> <br /> Określa, czy identyfikator sesji ma być przechowywany w cookies. Wartość 1 oznacza tak, wartość 0 — nie.<br /> <br /> 1<br /> <br /> session.use_only_cookies<br /> <br /> Określa, czy do przechowywania identyfikatora sesji mają być wykorzystywane wyłącznie cookies. Wartość 1 oznacza tak, wartość 0 — nie.<br /> <br /> 0<br /> <br /> session.use_trans_sid<br /> <br /> Określa, czy identyfikator sesji ma być przekazywany w adresie URL. Wartość 1 oznacza tak, wartość 0 — nie.<br /> <br /> 0<br /> <br /> Implementacja sesji Wszystkie podane do tej pory wiadomości wystarczą już do napisania zestawu skryptów, które pozwolą na praktyczne zapoznanie się z mechanizmem sesji. Pierwszy z nich, czyli index1.php, rozpocznie sesję i ustawi przykładową zmienną; drugi, czyli index2.php, odczyta identyfikatory sesji i wartość zmiennej; trzeci, czyli index3.php, zakończy sesję i usunie zmienne. Zawartość pliku index1.php została przedstawiona na listingu 4.24. Aby przykład zadziałał prawidłowo, w przeglądarce musi być włączona obsługa cookies. W przypadku gdy przeglądarka nie obsługuje cookies, w pliku konfiguracyjnym php.ini należy włączyć opcję session.use_trans_sid. Listing 4.24. Rozpoczęcie sesji i ustawienie zmiennych <?php session_start(); $_SESSION['zmienna_sesji'] = "abcd"; ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Implementacja sesji</title> </head> <body><br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 261<br /> <br /> <div> Witamy na stronie. Została rozpoczęta sesja.<br /> Identyfikatorem sesji jest: <?php echo session_id(); ?> <br /> Została ustawiona zmienna o nazwie: zmienna_sesji <br /> Wartością zmiennej zmienna_sesji jest: <?php echo $_SESSION['zmienna_sesji']; ?><br /> <a href="index2.php" rel="nofollow">Następna strona</a> </div> </body> </html><br /> <br /> Na początku jest wywoływana funkcja session_start, która rozpoczyna sesję, oraz tworzona jest zmienna sesji o nazwie zmienna_sesji i przypisywany jest jej ciąg znaków abcd ($_SESSION['zmienna_sesji'] = "abcd";). W dalszej części skryptu kod HTML jest przeplatany z kodem PHP. Wyświetlane są: identyfikator przypisany sesji podczas wywołania funkcji session_start (do pobrania identyfikatora sesji wykorzystuje się funkcję session_id) oraz zawartość zmiennej zmienna_sesji. Na końcu witryny umieszczony jest natomiast odnośnik do kolejnej strony: index2.php. Po uruchomieniu skryptu zobaczymy to, co przedstawia rysunek 4.21. Oczywiście identyfikator sesji będzie w każdym przypadku inny. Rysunek 4.21. Dane sesji po jej rozpoczęciu<br /> <br /> Treść skryptu index2.php została zaprezentowana na listingu 4.25. Kod rozpoczyna się od wywołania funkcji session_start. Następnie, podobnie jak w skrypcie z listingu 4.24, wyświetlane są dane sesji. Ponieważ jest to kontynuacja sesji zapoczątkowanej skryptem index1.php, zarówno identyfikator, jak i wartość zmiennej zmienna_sesji pozostają niezmienne, co widać na rysunku 4.22 (wartość zmiennej jest odczytywana z tablicy $_SESSION). To właśnie bardzo ważna cecha tej techniki. Wartości ustawione przy wywołaniu strony index1.php pozostały niezmienione po wywołaniu index2.php. Na końcu kodu umieszczony został odnośnik do kolejnego pliku — index3.php. Listing 4.25. Kontynuacja sesji <?php session_start(); ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"><br /> <br /> 262<br /> <br /> PHP5. Praktyczny kurs <title>Implementacja sesji</title> </head> <body> <div> Witamy na drugiej stronie sesji.<br /> Trwa sesja o identyfikatorze: <?php echo session_id(); ?> <br /> Wartością zmiennej zmienna_sesji jest: <?php echo $_SESSION['zmienna_sesji']; ?><br /> <a href="index3.php" rel="nofollow">Następna strona</a> </div> </body> </html><br /> <br /> Rysunek 4.22. Efekt kontynuacji sesji<br /> <br /> Treść skryptu index3.php została przedstawiona na listingu 4.26. Kod rozpoczyna się, tak jak w poprzednich przykładach, od wywołania funkcji session_start, następnie jednak ma miejsce usunięcie zmiennej $zmienna_sesji, co jest wykonywane za pomocą funkcji unset. Potem następuje usunięcie cookie, które przechowuje nazwę oraz identyfikator sesji (oczywiście o ile takie cookie istnieje). Nazwa sesji jest pobierana przez funkcję session_name. Jest to ciąg znaków używany jako nazwa cookie lub parametru zawierającego identyfikator sesji — domyślnie jest to ciąg znaków PHPSESSID. Cookie jest usuwane za pomocą techniki opisanej w poprzedniej lekcji. Listing 4.26. Skrypt kończący sesję <?php session_start(); unset($_SESSION['zmienna_sesji']); if (isset($_COOKIE[session_name()])){ setcookie(session_name(), '', time() - 3600); } ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Implementacja sesji</title> </head> <body> <div> Witamy na trzeciej stronie sesji.<br /> Identyfikatorem sesji jest: <?php echo session_id(); ?> <br /> Została usunięta zmienna o nazwie: zmienna_sesji <br /><br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 263<br /> <br /> Wartością zmiennej zmienna_sesji jest: <?php echo $_SESSION['zmienna_sesji'] . "<br />"; if(session_destroy()){ echo("Sesja została zakończona."); } else{ echo("Próba zakończenia sesji nie powiodła się."); } ?> </div> </body> </html><br /> <br /> Następnie wyświetlane są dane sesji. Oczywiście próba wyświetlenia wartości zmiennej $zmienna_sesji kończy się niepowodzeniem. Jeśli środowisko PHP skonfigurowane jest tak, aby wyświetlane były ostrzeżenia i komunikaty o błędach, odpowiedni komunikat pojawi się również na ekranie (rysunek 4.23). Sesja jest kończona za pomocą funkcji session_destroy. Rysunek 4.23. Zakończenie sesji<br /> <br /> Warto przy tym wspomnieć, że istnieje możliwość uzyskania pełnych parametrów, z jakimi zostało ustawione cookie sesji. Służy do tego funkcja session_get_cookie_ params zwracająca tablicę asocjacyjną o następujących indeksach:  lifetime — czas ważności cookie (w sekundach),  path — ścieżka dostępu,  domain — domena ważności cookie,  secure — określa, czy cookie powinno być przysyłane tylko przez bezpieczne<br /> <br /> połączenia HTTPS,  httponly — określa, czy cookie powinno być dostępne tylko przez protokół<br /> <br /> HTTP (dostępne od PHP 5.2.0).<br /> <br /> 264<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Dzięki temu przy usuwaniu cookie można zastosować pełną wersję funkcji setcookie, np. w taki sposób: $params = session_get_cookie_params(); setcookie(session_name(), '', time() - 3600, $params['path'], $params['domain'], $params['secure'], $params['httponly']);<br /> <br /> Śledzenie zachowań użytkownika Sesje mogą być również wykorzystane do śledzenia zachowań użytkownika. W prosty sposób możemy na przykład sprawdzić, ile razy w ciągu jednej wizyty odwiedził on poszczególne strony naszego serwisu. Przygotujmy zatem dwa skrypty symulujące dwie podstrony serwisu. Treść pierwszej strony, którą należy zapisać w pliku index1.php, została przedstawiona na listingu 4.27, natomiast treść drugiej strony, którą należy zapisać w pliku index2.php, na listingu 4.28. Oba skrypty mają taką samą strukturę, różnią się jedynie występującymi w nich odwołaniami do zmiennych i odnośników. Listing 4.27. Treść pliku index1.php <?php session_start(); if(!isSet($_SESSION['page1hits'])){ $_SESSION['page1hits'] = 1; } else{ $_SESSION['page1hits']++; } if(!isSet($_SESSION['page2hits'])){ $_SESSION['page2hits'] = 0; } ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Implementacja sesji</title> </head> <body> <div> <?php echo "Liczba wizyt na pierwszej stronie: "; echo $_SESSION['page1hits']; echo "<br />"; echo "Liczba wizyt na drugiej stronie: "; echo $_SESSION['page2hits']; echo "<br />"; ?> <a href="index2.php" rel="nofollow">Druga strona</a> </div> </body> </html><br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 265<br /> <br /> Listing 4.28. Treść pliku index2.php <?php session_start(); if(!isSet($_SESSION['page2hits'])){ $_SESSION['page2hits'] = 1; } else{ $_SESSION['page2hits']++; } if(!isSet($_SESSION['page1hits'])){ $_SESSION['page1hits'] = 0; } ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Implementacja sesji</title> </head> <body> <div> <?php echo "Liczba wizyt na pierwszej stronie: "; echo $_SESSION['page1hits']; echo "<br />"; echo "Liczba wizyt na drugiej stronie: "; echo $_SESSION['page2hits']; echo "<br />"; ?> <a href="index1.php" rel="nofollow">Pierwsza strona</a> </div> </body> </html><br /> <br /> Liczba odwołań do pierwszej strony jest przechowywana w zmiennej sesji o nazwie page1hits, a do drugiej w page2hits. W związku z tym skrypt z listingu 4.27 rozpoczyna się od sprawdzenia, czy została ustawiona zmienna page1hits. Jeśli tak, jej wartość jest zwiększana o 1, jeśli nie — zmienna ta jest tworzona i jest jej przypisywana wartość 1. Dalej następuje sprawdzenie, czy jest ustawiona zmienna sesji page2hits, jeśli nie, jest ona tworzona i przypisuje się jej wartość 0. W dalszej części skryptu wartości zmiennych page1hits i page2hits są wyświetlane na ekranie, tak jak zostało to zaprezentowane na rysunku 4.24. Na dole strony za pomocą znacznika <a> został umieszczony odnośnik do witryny index2.php. Rysunek 4.24. Śledzenie liczby odwołań do poszczególnych podstron witryny<br /> <br /> 266<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Ponieważ liczba wywołań dotyczących drugiej strony jest zawarta w zmiennej sesji page2hits, kod skryptu z listingu 4.28 zaczyna się od sprawdzenia, czy została ona ustawiona. Jeśli tak, jej wartość jest zwiększana o jeden, jeśli nie, zmienna jest tworzona, a jej wartość ustawiana na 1. Potem ma miejsce sprawdzenie, czy istnieje zmienna page1hits, a jeśli nie, jest ona tworzona poprzez przypisanie wartości 0 indeksowi page1hits tablicy $_SESSION. Następnie na stronie wyświetlane są wartości zmiennych oraz odnośnik do witryny index1.php.<br /> <br /> Kontrola dostępu z wykorzystaniem sesji Kontrola dostępu do strony to jedno z zadań realizowanych za pomocą PHP, do którego bardzo przydają się sesje. Spróbujmy jednak najpierw wykonać to zadanie bez ich użycia. Jak by to mogło wyglądać? Serwis może składać się z dwóch plików — index. php i glowna.php. Pierwszy z nich będzie zawierał procedury weryfikacyjne, a drugi główną część witryny. Treść pliku index.php została zaprezentowana na listingu 4.29. Listing 4.29. Skrypt realizujący procedury weryfikacji <?php if(isSet($_POST['user']) && isSet($_POST['haslo'])){ if($_POST['user'] == 'user1' && $_POST['haslo'] == 'pass1'){ header("Location: glowna.php"); exit(); } } ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Logowanie użytkowników</title> </head> <body> <div> <form action = "http://localhost/index.php" method = "post" > <table border="0"><tr> <td>Użytkownik:</td> <td> <input type="text" name="user" /> </td> </tr><tr> <td>Hasło:</td> <td> <input type="password" name="haslo" /> </td> </tr><tr> <td colspan="2" align="center"> <input type="submit" value="Wejdź" /> </td> </tr></table><br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 267<br /> <br /> </form> </div> </body> </html><br /> <br /> Pierwsza część kodu to skrypt PHP, który sprawdza, czy zostały mu przekazane (za pomocą metody POST) parametry user i haslo zawierające nazwę i hasło użytkownika. W celu uproszczenia kodu przyjęto, że istnieje tylko jedna poprawna nazwa — user1 — oraz hasło — pass1. Jeśli parametry są obecne, a ich wartości są zgodne z występującymi w kodzie, za pomocą funkcji header następuje przekierowanie do pliku glowna.php zawierającego główną część serwisu. Treść tego pliku może być oczywiście dowolna. Jeśli jednak parametrów nie było bądź ich wartości były różne od podanych w skrypcie, kod PHP kończy działanie i następuje wyświetlenie zawartego w pliku formularza HTML (rysunek 4.25). Ten formularz zawiera pola user oraz haslo i wysyła ich wartości do skryptu index.php, a zatem jest wyświetlany tak długo, dopóki nie zostaną wprowadzone poprawne dane (do wyrównywania formularza została użyta zwykła tabela HTML9). Rysunek 4.25. Formularz umożliwiający wprowadzenie nazwy i hasła<br /> <br /> Podstawową wadą takiej realizacji uwierzytelniania jest to, że po pierwotnej weryfikacji danych dostęp do dalszej części witryny jest już nieograniczony. Jeśli osoba postronna poznałaby strukturę plików składających się na witrynę (a wystarczy dowiedzieć się, jaką nazwę ma główny plik strony, do którego dostęp uzyskiwany jest z poziomu skryptu index.php), uzyskałaby pełny dostęp bez konieczności podawania hasła. Skoro bowiem skrypt logowania znajdował się pod adresem http://localhost/index.php, a strona główna pod http://localhost/glowna.php, to wystarczyło wpisanie tego drugiego adresu do przeglądarki, aby ominąć cały mechanizm logowania. Jeśli jednak wykorzystamy poznaną w tej lekcji wiedzę dotyczącą mechanizmów sesji, możemy stworzyć o wiele bezpieczniejszy mechanizm logowania, którego nie da się tak łatwo ominąć, choć będziemy musieli liczyć się z tym, że kod witryny będzie bardziej rozbudowany. Całość będzie się składała z trzech plików:  index.php — zawiera procedury i formularz logowania, 9<br /> <br /> Zgodnie z obowiązującymi trendami do wyrównywania elementów witryny należałoby użyć stylów CSS, jednak nie to jest tematem niniejszej książki. Sposoby generowania układu witryny za pomocą CSS można znaleźć m.in. w publikacji Tworzenie stron WWW. Praktyczny kurs (http://helion.pl/ ksiazki/twwspk.htm).<br /> <br /> 268<br /> <br /> PHP5. Praktyczny kurs  glowna.php — zawiera główną część serwisu,  logout.php — zawiera procedury wylogowywania.<br /> <br /> Do przekazywania danych pomiędzy skryptami wykorzystana zostanie zmienna sesji o nazwie zalogowany, która będzie zawierała nazwę zalogowanego użytkownika. Skrypt logowania index.php został przedstawiony na listingu 4.30. Listing 4.30. Treść pliku index.php zawierającego procedury logowania <?php session_start(); if(isSet($_SESSION['zalogowany'])){ header("Location: glowna.php"); exit(); } else if(isSet($_POST['user']) && isSet($_POST['haslo'])){ if($_POST['user'] == 'user1' && $_POST['haslo'] == 'pass1'){ $_SESSION['zalogowany'] = 'user1'; header("Location: glowna.php"); exit(); } else{ $komunikat = "Niepoprawne dane logowania."; } } ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Logowanie użytkowników</title> </head> <body> <div> <form action = "http://localhost/index.php" method = "post" > <?php if(isSet($komunikat)): ?> <div><?php echo $komunikat; ?></div> <?php endif; ?> <table border="0"><tr> <!-- tutaj dalsza część kodu HTML z listingu 4.29 --><br /> <br /> W przedstawionym kodzie (pominięty został formularz logowania, który ma taką samą postać jak w poprzednim przykładzie) rozpatrywane są następujące sytuacje: 1. Najpierw następuje sprawdzenie, czy istnieje zmienna sesji o nazwie zalogowany. Jeśli tak, oznacza to, że strona została wywołana przez<br /> <br /> zalogowanego użytkownika, następuje zatem przekierowanie do strony głównej glowna.php i skrypt kończy działanie.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 269<br /> <br /> 2. Jeśli zmienna zalogowany nie jest ustawiona i jednocześnie nie są ustawione klucze haslo i user w tablicy $_POST, oznacza to, że niezalogowany<br /> <br /> użytkownik wywołał stronę index.php, trzeba więc wyświetlić formularz logowania znajdujący się za kodem PHP. 3. W przypadku gdy zmienna zalogowany nie jest ustawiona, ale ustawiona jest co najmniej jedna ze zmiennych user lub haslo, oznacza to, że niezalogowany<br /> <br /> użytkownik wypełnił formularz logowania, należy zatem dokonać weryfikacji danych. Weryfikacja danych odbywa się na takiej samej zasadzie jak w poprzednim przypadku. Jeśli jest pozytywna, ustawiana jest zmienna sesji o nazwie zalogowany i przypisywana jest jej nazwa użytkownika. Jeśli nie będziemy potrzebować tej nazwy na innych stronach witryny, można też zmiennej przypisać wartość 1, true lub inną, według potrzeb. Po ustawieniu zmiennej następuje przekierowanie do głównej strony serwisu glowna.php za pomocą funkcji header. W przypadku gdy weryfikacja podanych danych jest negatywna, czyli nie zgadza się nazwa użytkownika lub (i) hasło, tworzona jest zmienna $komunikat i jest jej przypisywany komunikat informujący o niepoprawnych danych. Ten komunikat zostanie wyświetlony na dodatkowej warstwie przed formularzem logowania. Warto zwrócić uwagę na ten fragment kodu, gdyż została w nim zastosowana nieprezentowana do tej pory technika przeplatania kodu HTML i PHP: <?php if(isSet($komunikat)): ?> <div><?php echo $komunikat; ?></div> <?php endif; ?><br /> <br /> Znacznik <div> znajduje się między dwoma blokami PHP, przy czym w bloku przed <div> znajduje się początek instrukcji if (zastosowana została składnia alternatywna), natomiast w bloku za <div> — koniec instrukcji if. To oznacza, że warstwa <div> pojawi się w kodzie strony tylko wtedy, gdy warunek instrukcji warunkowej isSet($komunikat) będzie prawdziwy, czyli gdy będzie istniała zmienna $komunikat. Jeżeli takiej zmiennej nie będzie (co by oznaczało, że do skryptu nie zostały przekazane parametry user i haslo), cały ten blok zostanie pominięty. Rzecz jasna, takie zachowanie skryptu można też osiągnąć bez stosowania takiego przeplatania bloków kodu. Wystarczy użyć przykładowych instrukcji: <?php if(isSet($komunikat)){ echo "<div>$komunikat</div>"; } ?><br /> <br /> Zaprezentowana technika jest jednak często stosowana w praktyce.<br /> <br /> 270<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Skrypt glowna.php generujący główną część serwisu — dostępną jedynie dla zalogowanych użytkowników — został przedstawiony na listingu 4.31. Kod rozpoczyna się od otwarcia sesji oraz sprawdzenia, czy ustawiona jest zmienna zalogowany. Jeśli nie jest ustawiona, oznacza to, że niezalogowany użytkownik próbuje dostać się do serwisu, jest więc przekierowywany do strony logowania. Jeżeli jednak zmienna zalogowany jest ustawiona, do przeglądarki wysyłana jest treść strony (tak jak przedstawiono to na rysunku 4.26). Na końcu strony za pomocą znacznika <a> został umieszczony odnośnik do skryptu logout.php, który umożliwia zakończenie sesji i wylogowanie użytkownika. Listing 4.31. Treść pliku glowna.php zawierającego główną część serwisu <?php session_start(); if(!isSet($_SESSION['zalogowany'])){ header("Location: index.php"); exit(); } ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <div> Witamy na stronie. </div> <p>Pamiętaj o wylogowaniu przed opuszczeniem strony.</p> <p><a href="http://localhost/logout.php" rel="nofollow">Wylogowanie</a></p> </body> </html><br /> <br /> Rysunek 4.26. Główna część serwisu po zalogowaniu użytkownika<br /> <br /> Skrypt wykonujący wylogowanie został przedstawiony na listingu 4.32. Również i w tym wypadku kod rozpoczyna się od sprawdzenia, czy użytkownik, który próbuje się wylogować, faktycznie był wcześniej zalogowany. Jeśli był (była ustawiona zmienna zalogowany), zmienna zalogowany jest usuwana za pomocą funkcji unset. Usuwane jest również cookie (o ile istnieje) związane z bieżącą sesją. Po wykonaniu tych czynności sesja jest kończona za pomocą funkcji session_destroy.<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 271<br /> <br /> Listing 4.32. Treść pliku logout.php zawierającego procedury wylogowania <?php session_start(); if(isSet($_SESSION['zalogowany'])){ unset($_SESSION['zalogowany']); } else{ header("Location: index.php"); exit(); } if(isset($_COOKIE[session_name()])){ setcookie(session_name(), '', time() - 360); } session_destroy(); ?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <p>Wylogowanie prawidłowe</p> <a href='http://localhost/index.php' rel="nofollow">Powrót do strony logowania</a> </body> </html><br /> <br /> W sytuacji gdy zmienna zalogowany nie była ustawiona, a użytkownik wywołał skrypt logout.php, przekierowywany jest on do strony logowania index.php.<br /> <br /> System logowania z danymi w pliku W poprzednim przykładzie nazwy i hasła użytkowników były przechowywane bezpośrednio w kodzie skryptu. Jeśli jednak poznane techniki połączyć z informacjami z rozdziału 3. dotyczącymi obsługi plików, można napisać kod realizujący takie samo zadanie, w którym dane będą przechowywane w pliku tekstowym. Dzięki temu skrypt będzie o wiele wygodniejszy w obsłudze. Pliki glowna.php i logout.php nie wymagają żadnych modyfikacji, zmienić trzeba natomiast procedury logowania. Nowa treść pliku index.php została zamieszczona na listingu 4.33. Listing 4.33. Skrypt index.php zawierający procedury logowania <?php session_start(); function checkPass($user, $pass) { if(!$fd = fopen("/secure/passwords.txt", "r")){ return false; } $result = false; while (!feof ($fd)){ $line = trim(fgets($fd));<br /> <br /> 272<br /> <br /> PHP5. Praktyczny kurs $arr = explode(":", $line); if(count($arr) < 2) continue; if($arr[0] != $user) continue; if($arr[1] == $pass){ $result = true; } break; } fclose($fd); return $result; } if(isSet($_SESSION['zalogowany'])){ header("Location: glowna.php"); exit(); } else if(isSet($_POST['user']) && isSet($_POST['haslo'])){ if(checkPass($_POST['user'], $_POST['haslo'])){ $_SESSION['zalogowany'] = $_POST['user']; header("Location: glowna.php"); exit(); } else{ $komunikat = "Niepoprawne dane logowania."; } } ?> <!-- tutaj kod HTML z listingu 4.31 --><br /> <br /> Kod HTML formularza pozostał taki sam jak w przykładzie z listingu 4.30, został więc pominięty. Zmienił się natomiast kod PHP. Dodana została funkcja checkPass, której zadaniem jest stwierdzenie, czy przekazane w postaci argumentów nazwa i hasło użytkownika są poprawne, czy też nie. W tym pierwszym przypadku funkcja zwraca wartość true, w drugim — false. Całość działa zatem w sposób następujący:  Jeśli jest ustawiona zmienna sesji o nazwie zalogowany (if(isSet($_SESSION['zalogowany'])){), wówczas następuje przekierowanie do strony głównej glowna.php.  Jeśli za pomocą metody POST zostały przekazane argumenty user oraz haslo (else if(isSet($_POST['user']) && isSet($_POST['haslo'])){) i są one poprawne (funkcja chekPass zwróciła wartość true; if(checkPass($_POST['user'], $_POST['haslo'])){), wówczas ustawiana jest zmienna zalogowany (otrzymuje wartość zgodną z nazwą użytkownika)<br /> <br /> i następuje przekierowanie do strony głównej.  Jeśli za pomocą metody POST zostały przekazane argumenty user oraz haslo i są one niepoprawne (funkcja chekPass zwróciła wartość false), wówczas<br /> <br /> wyświetlany jest formularz logowania wraz z komunikatem o błędnych danych.  Jeśli za pomocą metody POST nie zostały przekazane argumenty user i (lub) haslo, wyświetlany jest formularz logowania (bez dodatkowego komunikatu).<br /> <br /> Rozdział 4. ♦ Współpraca z przeglądarką<br /> <br /> 273<br /> <br /> Jak więc działa funkcja checkPass? Jej kod rozpoczyna się od próby otwarcia pliku passwords.txt znajdującego się w podkatalogu secure katalogu głównego. W tym pliku powinny być zapisane wszystkie nazwy użytkowników i przypisane im hasła — każdy wpis w oddzielnym wierszu, w formacie, w którym nazwa jest oddzielana od hasła znakiem dwukropka: nazwa_uzytkownika:hasło<br /> <br /> W celu zwiększenia bezpieczeństwa plik nie został umieszczony w tym samym katalogu co kod skryptu, tak aby nie można go było pobrać przez przeglądarkę. Lokalizacją pliku z hasłami powinien być katalog dostępny do odczytu dla aparatu wykonawczego PHP, jednak znajdujący się poza strukturą katalogów dostępnych przez serwer WWW. Zauważmy bowiem, że gdyby plik passwords.txt znajdował się razem z plikiem index. php w katalogu głównym serwera WWW (lub w którymś z podkatalogów), wówczas wpisanie w przeglądarce adresu naszego serwera i nazwy pliku, np. http://localhost/ passwords.txt spowodowałoby wyświetlenie jego zawartości, a tym samym możliwość uzyskania listy haseł przez osoby niepowołane (o ile prawa dostępu do pliku pozwalałyby na jego odczyt przez serwer WWW). Zmieniając lokalizację pliku, zwiększamy bezpieczeństwo naszego systemu. Jeśli pliku passwords.txt nie uda się otworzyć, w pętli while za pomocą funkcji fgets są odczytywane kolejne jego linie. Każdy odczytany wiersz jest poddawany działaniu funkcji trim usuwającej z jego końców białe znaki oraz funkcji explode, która dzieli ciąg na dwie części względem występującego w nim znaku średnika. To oznacza, że dane w pliku powinny mieć format: nazwa:hasło<br /> <br /> np.: jank:hasło1<br /> <br /> Efektem działania explode jest tablica, która w kolejnych komórkach (dokładniej w wartościach kolejnych kluczy) zawiera elementy składowe ciągu. Ponieważ każdy ciąg o prawidłowym formacie zostanie podzielony na dwie części, sprawdzamy, czy tablica wynikowa ma rzeczywiście dwa elementy. Jeśli nie, oznacza to błędne dane i jest wtedy wykonywana instrukcja continue, która powoduje rozpoczęcie kolejnej iteracji pętli. Jeśli jednak tablica będąca wynikiem działania explode zawiera dokładnie dwa elementy, oznacza to, że komórka o indeksie 0 zawiera nazwę użytkownika, a komórka o indeksie 1 — hasło. W takiej sytuacji sprawdzane jest, czy nazwa użytkownika przekazana w argumencie $user jest zgodna z wartością komórki o indeksie 0. Jeżeli wartości te są różne, wykonywana jest kolejna iteracja pętli (wymuszana przez instrukcję continue), czyli odczytywany jest kolejny wiersz tekstu. Jeśli jednak nazwy są zgodne, następuje sprawdzenie poprawności hasła. W tym celu wartość parametru $haslo jest porównywana z zawartością komórki tablicy o indeksie 1. Gdy hasło jest poprawne, zmiennej pomocniczej $result (która przed pętlą otrzymała wartość false) jest przypisywana wartość true. Niezależnie jednak od wyniku porównania pętla jest przerywana za pomocą instrukcji break.<br /> <br /> 274<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Tym samym po skończeniu pętli możemy mieć do czynienia z trzema różnymi sytuacjami:  Jeśli w pliku passwords.txt nie było nazwy użytkownika przekazanej w postaci argumentu $user, zmienna $result przyjmie wartość false.  Jeśli w pliku passwords.txt była nazwa użytkownika zgodna z nazwą przekazaną w postaci argumentu $user, jednak odczytane hasło nie było zgodne z argumentem $haslo, zmienna $result przyjmie wartość false.  Jeśli w pliku passwords.txt była nazwa użytkownika zgodna z tą przekazaną w postaci argumentu $user i odczytane hasło było zgodne z argumentem $haslo, zmienna $result przyjmie wartość true.<br /> <br /> Skoro tak, wartość zmiennej $result jest jednocześnie rezultatem działania funkcji checkPass, jest więc zwracana za pomocą instrukcji return jako sygnał poprawności bądź niepoprawności danych przekazanych do skryptu.<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 16.1. Zmodyfikuj skrypt z listingu 4.29 w taki sposób, aby możliwe było logowanie wielu różnych użytkowników. Ćwiczenie 16.2. Napisz skrypt zabezpieczający dostęp do treści witryny za pomocą hasła. Wykorzystaj mechanizm sesji. Ćwiczenie 16.3. Napisz kod witryny składającej się z kilku podstron. Wymuś takie zachowanie serwisu, aby rozpoczęcie przeglądania witryny odbywało się zawsze od strony głównej (czyli aby w trakcie jednej sesji dostęp do podstron był możliwy dopiero po odwiedzeniu strony głównej). Ćwiczenie 16.4. Zmodyfikuj kod z ćwiczenia 13.5 w taki sposób, aby w trakcie jednej sesji użytkownik miał możliwość wysłania do serwera tylko trzech plików. Ćwiczenie 16.5. Zmień przykład systemu logowania do serwisu w taki sposób, aby niezalogowany użytkownik, w sytuacji gdy wywoła stronę glowna.php lub logout.php, był przekierowywany na stronę logowania i aby na tej stronie był wyświetlany stosowny komunikat (inny dla każdej z tych sytuacji). Ćwiczenie 16.6. Zmodyfikuj przykład z listingu 4.33 w taki sposób, aby w haśle mogły być zawarte wszelkie znaki alfanumeryczne, w tym zabroniony w prezentowanym rozwiązaniu dwukropek, a także by jeden użytkownik mógł się logować za pomocą kilku haseł.<br /> <br /> Rozdział 5.<br /> <br /> Obiektowy PHP Lekcja 17. Podstawy obiektowości Obiekt jest traktowany jako byt programistyczny, który może przechowywać pewne dane (atrybuty) i wykonywać pewne zadania (funkcje). Nieco upraszczając to zagadnienie, można powiedzieć, że w obiekcie zawieramy zmienne przechowujące dane oraz funkcje realizujące przypisanie mu zadania. Lekcja 17. poświęcona jest właśnie podstawom tworzenia klas i obiektów oraz programowania obiektowego w PHP.<br /> <br /> Czym jest obiekt? Odpowiedź na pytanie, czym są obiekty, nie wydaje się skomplikowana. Chyba każdy intuicyjnie rozumie to pojęcie. Obiektem może być praktycznie wszystko: dom, samochód, ale także osoba czy nawet pojedynczy atom. W programowaniu jest podobnie — obiektem można nazwać każdy abstrakcyjny byt, który programista zapragnie utworzyć w pamięci komputera. Przykładowo, jeśli chcemy przechowywać informację dotyczącą współrzędnych pewnego punktu na ekranie, możemy utworzyć obiekt, który właśnie takie dane będzie zawierał. Jeszcze bardziej upraszczając to zagadnienie, można powiedzieć, że obiekt to coś, co może przechowywać dane oraz wykonywać różne operacje. Trzeba także wiedzieć, że jeden obiekt może zawierać inne obiekty — dokładnie tak, jak w świecie realnym. Przecież wewnątrz przykładowego samochodu mamy np. fotele, kierownicę, silnik itp., a w domu umieszczone są meble, okna, sprzęt AGD. Wszystko to są obiekty składowe. Takie wzajemne zawieranie się obiektów możemy schematycznie przedstawić w taki sposób, jak jest to widoczne na rysunku 5.1. Nie można jednak tworzyć obiektów bez ich wcześniejszego zaprojektowania. Czy da się bowiem skonstruować dom bez planu? Raczej nie. Tak jest też w PHP — aby utworzyć obiekt, najpierw trzeba go zaprojektować, utworzyć jego plan. Taki plan obiektu<br /> <br /> 276<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Rysunek 5.1. Jeden obiekt może zawierać inne obiekty składowe<br /> <br /> nazywamy klasą. Określa ona, jak będą zbudowane obiekty tworzone na jej podstawie. Innymi słowy, klasa to zdefiniowany przez programistę nowy typ danych.<br /> <br /> Definicja klasy Ogólna struktura Klasa jest definiowana za pomocą słowa kluczowego class. Ogólna postać takiej konstrukcji jest następująca: class nazwa_klasy { //definicja klasy }<br /> <br /> Klasa może zawierać nieograniczoną liczbę zmiennych (nazywanych polami, z ang. fields, lub właściwościami, z ang. properties) oraz funkcji (nazywanych metodami, z ang. methods) — te elementy nazywamy składowymi klasy (z ang. class members). Nazwa może zawierać dowolną kombinację liter (również znaków narodowych), cyfr i znaków podkreślenia, nie może się jednak zaczynać od cyfry. Nie wolno również jako nazwy klasy używać żadnego słowa kluczowego PHP (zarezerwowanego), np. if, while, array itp. Najprostsza klasa będzie miała postać: class klasa { }<br /> <br /> Jest ona — można powiedzieć — mało ciekawa, gdyż nie zostały zdefiniowane żadne jej składowe, niemniej jest to poprawna definicja. W ten sposób powstał nowy typ danych o nazwie klasa — po takiej definicji można tworzyć zmienne (obiekty) tego typu, o czym przekonamy się w dalszej części rozdziału.<br /> <br /> Składowe klasy — pola i metody Obiekty mogą przechowywać dane oraz wykonywać zadania. Dane mogą być przechowywane w zmiennych, które umieszczamy w projekcie obiektu, czyli w klasie. Takie zmienne nazywamy polami klasy (również: właściwościami). Aby obiekt mógł wyko-<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 277<br /> <br /> nywać zadania (operacje), potrzebny jest z kolei kod wykonywalny. Ten kod umieszczamy w funkcjach przynależnych do klasy. Takie funkcje nazywamy metodami klasy. Ogólnie pola i metody nazywamy składowymi klasy. Definicja pola klasy ma następującą postać: class nazwa_klasy { public $nazwa_pola; }<br /> <br /> przy czym słowo public to tzw. specyfikator dostępu oznaczający, że dostęp do wymienionego pola nie jest niczym ograniczony. Ten temat zostanie bliżej omówiony w kolejnej lekcji. Gdy trzeba użyć większej liczby pól, można je umieścić w jednym wierszu, oddzielając od siebie znakami przecinka: class nazwa_klasy { public $nazwa_pola_1, $nazwa_pola_2, ..., $nazwa_pola_N; }<br /> <br /> lub też w wielu wierszach: class nazwa_klasy { public $nazwa_pola_1; public $nazwa_pola_2; ... public $nazwa_pola_N; }<br /> <br /> przy czym każdy musi być zakończony znakiem średnika. Metody klasy tworzy się podobnie jak zwykłe funkcje, używając słowa kluczowego function. Typowa definicja będzie miała następującą postać: class nazwa_klasy { public function nazwa_metody(argumenty) { //wnętrze metody } }<br /> <br /> Aby lepiej przećwiczyć tego typu konstrukcje, utworzymy teraz prostą klasę o nazwie Uzytkownik, której zadaniem będzie obsługa danych związanych z użytkownikami serwisu internetowego. Będzie ona zawierała tylko dwa pola:  nazwa — przechowuje nazwę użytkownika,  id — przechowuje identyfikator użytkownika.<br /> <br /> Kod takiej klasy będzie miał postać widoczną na listingu 5.1. Jak widać, jest on bardzo prosty. Umieszczenie takiej definicji w kodzie oznacza: definiuję nowy typ danych o nazwie Uzytkownik. Obiekty tego typu będą miały postać określoną przez klasę Uzytkownik.<br /> <br /> 278<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Listing 5.1. Kod klasy Uzytkownik zawierającej dwa pola danych <?php class Uzytkownik { public $nazwa, $id; } ?><br /> <br /> Dostęp do składowych Do klasy Uzytkownik dodajmy teraz cztery metody:  ustawNazwe — zmienia wartość pola $nazwa;  pobierzNazwe — pobiera wartość pola $nazwa;  ustawId — zmienia wartość pola $id;  pobierzId — ustawia wartość pola $id.<br /> <br /> Przyjmie ona wtedy postać widoczną na listingu 5.2. Listing 5.2. Klasa Uzytkownik z dodanymi metodami <?php class Uzytkownik { public $nazwa, $id; public function ustawNazwe($wartosc) { $this->nazwa = $wartosc; } public function pobierzNazwe() { return $this->nazwa; } public function ustawId($wartosc) { $this->id = $wartosc; } public function pobierzId() { return $this->id; } } ?><br /> <br /> Metoda ustawNazwe przyjmuje jeden argument o nazwie $wartosc i przypisuje jego wartość polu $nazwa. Podobnie działa metoda ustawId, z tą różnicą, że przypisanie następuje do pola $id. Funkcje pobierzNazwe i pobierzId działają odwrotnie. Pierwsza z nich za pomocą instrukcji return zwraca wartość pola $nazwa, a druga wartość pola $id.<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 279<br /> <br /> Należy w tym miejscu zwrócić uwagę na użycie słowa kluczowego this. Oznacza ono odwołanie do obiektu bieżącego, czyli $this->nazwa oznacza pola nazwa z klasy Uzytkownik. Pominięcie słowa this, np. gdyby funkcja pobierzNazwe miała postać: public function pobierzNazwe() { return $nazwa; }<br /> <br /> spowodowałoby błąd w trakcie działania skryptu (podczas wywoływania wymienionej funkcji), gdyż $nazwa zostałaby potraktowana jako lokalna zmienna funkcji pobierzNazwa, a nie jako pole obiektu.<br /> <br /> Tworzenie obiektów Słowo kluczowe new Gdy mamy zdefiniowaną klasę (czyli nowy typ danych), możemy na jej podstawie tworzyć obiekty, czyli konkretne egzemplarze tej klasy, podobnie jak na podstawie planów samochodu marki X można utworzyć wiele konkretnych egzemplarzy danego modelu. Mówi się, że obiekt jest instancją (wystąpieniem) danej klasy. Aby go utworzyć, należy użyć słowa new, po którym musi wystąpić nazwa klasy zakończona nawiasem okrągłym, schematycznie: new nazwa_klasy();<br /> <br /> Aby jednak można było skorzystać z tak utworzonego obiektu, należy go przypisać do jakiejś zmiennej: $nazwa_zmiennej = new nazwa_klasy();<br /> <br /> Po takim przypisaniu $nazwa_zmiennej pozwala na odwoływanie się do nowego obiektu typu nazwa_klasy.<br /> <br /> Odwołania do składowych Aby odwołać się do dowolnej składowej klasy, należy użyć operatora ->. A zatem dla pól takie odwołanie będzie miało postać: $nazwa_obiektu->nazwa_pola;<br /> <br /> a dla metod: $nazwa_obiektu->nazwa_metody(argumenty_metody);<br /> <br /> W przypadku pól w ten sposób można zarówno odczytywać, jak i zapisywać ich wartości. Jeśli na przykład zmienna o nazwie $user zawiera obiekt klasy Uzytkownik, to aby odczytać wartość pola nazwa i przypisać ją zmiennej $wartość, należy wykonać instrukcję: $wartosc = $user->nazwa;<br /> <br /> 280<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> aby natomiast polu id tego obiektu przypisać wartość 123 — instrukcję: $user->id = 123;<br /> <br /> Sposób odwoływania się do składowych klasy Uzytkownik zobrazowano również w skrypcie widocznym na listingu 5.3. Listing 5.3. Odwołania do składowych obiektu klasy Uzytkownik <?php class Uzytkownik { //tutaj definicja klasy z listingu 5.2 } $user1 = new Uzytkownik(); $user2 = new Uzytkownik(); $user1->nazwa = 'j.kowalski'; $user2->ustawNazwe('a.nowak'); echo $user1->nazwa; echo "<br />"; echo $user2->pobierzNazwe(); ?><br /> <br /> Ponieważ definicja klasy pozostała taka sama jak w przypadku listingu 5.2, nie była ponownie publikowana. Tym razem jest to jednak pełny skrypt, który wykorzystuje obiekty klasy Uzytkownik i którego efekt działania można zobaczyć w przeglądarce. Utworzone zostały dwa obiekty wymienionej klasy i zostały przypisane zmiennym $user1 i $user2. Często też takie zmienne określa się mianem obiektów, możemy zatem powiedzieć, choć nie jest to do końca ścisła terminologia, że mamy do czynienia z obiektami $user1 i $user2 klasy (typu) Uzytkownik. Polu nazwa obiektu wskazywanego przez $user1 został bezpośrednio przypisany ciąg znaków j.kowalski. Polu nazwa obiektu $user2 został przypisany ciąg znaków a.nowak, czynność ta została jednak wykonana pośrednio przez wywołanie metody ustawNazwe. Po dokonaniu przypisań wartości pól obiektów zostały odczytane i wysłane na ekran za pomocą instrukcji echo. I znów w przypadku $user1 odczyt był bezpośredni, tj. przez odwołanie do pola nazwa, natomiast w przypadku $user2 — pośredni, czyli przez wywołanie metody pobierzNazwe, która zwraca wartość pola nazwa wybranego obiektu. Tym samym po uruchomieniu skryptu w przeglądarce zobaczymy taki widok jak na rysunku 5.2. Rysunek 5.2. Efekt działania skryptu operującego na obiektach typu Uzytkownik<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 281<br /> <br /> Konstruktory i destruktory Tworzenie konstruktorów Po utworzeniu obiektu jego pola są puste, nie zawierają żadnych wartości. Często nie jest to sytuacja pożądana i należy nadać im pewne wartości początkowe. Załóżmy na przykład, że w przypadku znanej nam już klasy Uzytkownik chcielibyśmy, aby utworzony obiekt tego typu był wypełniony wartościami domyślnymi. Pole nazwa powinno przyjąć wartość Gość, a pole id wartość 0. Oczywiście można po każdym utworzeniu obiektu przypisywać wartości tym polom, np.: $user1 = new Uzytkownik(); $user1->nazwa = "Gość"; $user1->id = 0;<br /> <br /> Można też do klasy Uzytkownik dopisać dodatkową metodę o nazwie init, initialize, inicjuj (lub podobnej) w postaci: public function inicjuj() { $this->nazwa = "Gość"; $this->id = 0; }<br /> <br /> i wywoływać ją po każdym utworzeniu obiektu. Widać jednak od razu, że żadna z tych metod nie jest wygodna. Przede wszystkim wymagają one, aby programista zawsze pamiętał o ich stosowaniu, a jak pokazuje praktyka, jest to zwykle zbyt optymistyczne założenie. Łatwo bowiem o zwykłe zapomnienie czy pomyłkę. Na szczęście obiektowe języki programowania udostępniają dużo wygodniejszy mechanizm konstruktorów. Konstruktory są to specjalne metody wykonywane podczas tworzenia obiektów danej klasy. Doskonale zatem nadają się do wykonywania czynności inicjalizacyjnych. Aby zdefiniować konstruktor, należy umieścić w klasie metodę o nazwie __construct, schematycznie: class nazwa_klasy { function __construct() { //treść konstruktora } //pozostałe składowe klasy }<br /> <br /> Ze względu na zachowanie kompatybilności z PHP4 dostępna jest również druga konstrukcja, w której konstruktor musi mieć nazwę zgodną z nazwą klasy (podobnie jak w klasycznych językach programowania), schematycznie: class nazwa_klasy { function nazwa_klasy() { //treść konstruktora<br /> <br /> 282<br /> <br /> PHP5. Praktyczny kurs } //pozostałe składowe klasy }<br /> <br /> Tej wersji nie należy jednak używać, chyba że istnieje konieczność zachowania zgodności z PHP4, co jest bardzo rzadko spotykaną sytuacją. W książce będzie używany wyłącznie pierwszy zaprezentowany schemat. Jeśli zatem chcemy, aby obiekty klasy Uzytkownik przyjmowały automatycznie domyślne wartości pól, tak jak zostało to wcześniej opisane, do klasy należałoby dodać konstruktor w postaci: function __construct() { $this->nazwa = "Gość"; $this->id = 0; }<br /> <br /> A więc jej pełny kod miałby postać widoczną na listingu 5.4. Zapiszmy go w pliku o nazwie Uzytkownik.php. Listing 5.4. Kod klasy Uzytkownik zawierającej konstruktor <?php class Uzytkownik { public $nazwa, $id; function __construct() { $this->nazwa = "Gość"; $this->id = 0; } public function ustawNazwe($wartosc) { $this->nazwa = $wartosc; } public function pobierzNazwe() { return $this->nazwa; } public function ustawId($wartosc) { $this->id = $wartosc; } public function pobierzId() { return $this->id; } } ?><br /> <br /> Aby się przekonać, że konstruktor faktycznie działa według opisanej zasady, wystarczy wykonać kod skryptu widocznego na listingu 5.5. Na jego początku jest dołączana zawartość pliku Uzytkownik.php zawierającego kod klasy Uzytkownik. Następnie tworzony jest nowy obiekt typu Uzytkownik i przypisywany zmiennej $user1. Ponie-<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 283<br /> <br /> waż klasa Uzytkownik zawiera obecnie konstruktor, podczas tworzenia obiektu został on wywołany. Przekonujemy się o tym, wyświetlając na ekranie wartości pól nazwa i id. Mimo że nie zostały wykonane jawne przypisania, pola zawierają wartości Gość i 0. To właśnie efekt działania konstruktora. Listing 5.5. Ilustracja działania konstruktora <?php include "Uzytkownik.php"; $user1 = new Uzytkownik(); echo $user1->nazwa; echo "<br />"; echo $user1->id; ?><br /> <br /> Parametry konstruktorów Konstruktory nie muszą być bezargumentowe, mogą również przyjmować argumenty, które zostaną użyte na przykład do zainicjowania pól obiektu. Argumenty przekazuje się dokładnie w taki sam sposób jak w przypadku zwykłych metod, czyli budowa takiego konstruktora jest następująca: class nazwa_klasy { __construct(argument1, argument2,..., argumentN) { //kod konstruktora } }<br /> <br /> Jeśli konstruktor przyjmuje argumenty, przy tworzeniu obiektu należy je oczywiście podać, czyli zamiast stosowanej do tej pory konstrukcji: $zmienna = new nazwa_klasy()<br /> <br /> trzeba zastosować wywołanie: $zmienna = new nazwa_klasy(argument1, argument2,..., argumentN)<br /> <br /> W przypadku używanej do tej pory przykładowej klasy Uzytkownik przydatny byłby np. konstruktor, który przyjmowałby dwa argumenty oznaczające nazwę i identyfikator użytkownika. Definicja, co z pewnością nie jest żadnym zaskoczeniem, wyglądałaby wtedy następująco: function __construct($nazwa, $id) { $this->nazwa = $nazwa; $this->id = $id; }<br /> <br /> Po umieszczeniu takiego konstruktora w klasie Uzytkownik będzie można wykonać kod skryptu widocznego na listingu 5.6.<br /> <br /> 284<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Listing 5.6. Wykorzystanie konstruktora dwuargumentowego <?php include "Uzytkownik.php"; $user1 = new Uzytkownik("j.kowalski", 15); echo $user1->nazwa; echo "<br />"; echo $user1->id; ?><br /> <br /> Destruktory Destruktory to przeciwieństwa konstruktorów. Są to metody wykonywane wtedy, gdy obiekt jest niszczony, usuwany z pamięci. Są przydatne, jeśli na przykład klasa używa zasobów systemowych, które muszą być zwolnione przed usunięciem obiektu. Co prawda w większości przypadków, gdy tworzymy stosunkowo nieskomplikowane projekty, destruktor nie będzie nam potrzebny, warto jednak wiedzieć, w jaki sposób jest budowany. Otóż, podobnie jak w przypadku konstruktorów, jest to specjalna funkcja o nazwie __destruct, którą należy umieścić w kodzie klasy. Schematycznie taka konstrukcja ma postać: class nazwa_klasy { function __destruct() { //treść destruktora } //pozostałe składowe klasy }<br /> <br /> Automatyczne ładowanie kodu klasy Definicje klas często przechowuje się w osobnych plikach o nazwach zgodnych z nazwą klasy, np. klasa Uzytkownik była przechowywana w pliku o nazwie Uzytkownik. php (listing 5.4). Aby użyć takiej definicji w skrypcie, konieczne jest dołączenie treści pliku za pomocą instrukcji include (lub podobnej). Miało to miejsce na przykład w skryptach z listingów 5.5 i 5.6. Jeśli jednak klas jest dużo, niezbędne staje się używanie wielu instrukcji include, co nie jest wygodne, łatwo też wtedy o pomyłkę. Ten problem można łatwo rozwiązać, stosując technikę automatycznego ładowania pliku z kodem klasy w momencie pierwszego odwołania do klasy. Używa się w tym celu funkcji __autoload. Można to zrobić tak, jak zostało to przedstawione na listingu 5.7. Listing 5.7. Użycie funkcji __autoload <?php function __autoload($nazwa_klasy){ include $nazwa_klasy . '.php'; } $user1 = new Uzytkownik("j.kowalski", 15);<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 285<br /> <br /> echo $user1->nazwa; echo "<br />"; echo $user1->id; ?><br /> <br /> Kod jest zbudowany na bazie tego z listingu 5.6 i współpracuje z klasą Uzytkownik zawierającą konstruktor przyjmujący dwa argumenty. Nie ma jednak instrukcji include wczytującej plik Uzytkownik.php. Jest za to funkcja __autoload. Całość działa w taki sposób, że w momencie wystąpienia pierwszej instrukcji odwołującej się do klasy Uzytkownik (w tym przypadku jest to instrukcja tworząca nowy obiekt), gdy nie ma definicji takiej klasy, a jest funkcja o nazwie __autoload (tak jest właśnie w tym przypadku), ta funkcja jest wywoływana, a nazwa klasy jest jej przekazywana w postaci argumentu. Skoro tak, we wnętrzu funkcji nazwa klasy jest zawarta w argumencie $nazwa_klasy. To pozwala użyć instrukcji include do załadowania brakującego pliku. Oczywiście przy tej technice warunek jest taki, że nazwa pliku z kodem klasy jest faktycznie zgodna z nazwą klasy. O tym, że do funkcji __autoload jest przekazywana nazwa klasy, łatwo się przekonać, wykonując kod przedstawiony na listingu 5.8. Listing 5.8. Wartość argumentu funkcji __autoload <?php function __autoload($nazwa_klasy){ echo $nazwa_klasy; } $obj = new ZwykłaKlasa(); ?><br /> <br /> W kodzie znajduje się instrukcja tworząca nowy obiekt klasy ZwykłaKlasa. Ponieważ definicji tej klasy nie ma w skrypcie, ale znajduje się w nim funkcja __autoload, ta funkcja jest wykonywana. W przekazanym jej argumencie znajduje się nazwa brakującej klasy. Przekonujemy się o tym, wyświetlając wartość argumentu za pomocą instrukcji echo — kod klasy nie jest jednak dołączany. Dlatego po wywołaniu takiego skryptu w przeglądarce ukaże się widok zaprezentowany na rysunku 5.3. W pierwszym wierszu pojawi się nazwa klasy — to efekt działania instrukcji echo. Drugi wiersz to komunikat o błędzie. Ponieważ w funkcji __autoload nie został załadowany kod klasy, aparat wykonawczy PHP nie mógł utworzyć obiektu klasy ZwykłaKlasa, a więc wykonywanie kodu zostało przerwane. Rysunek 5.3. Efekt działania skryptu z listingu 5.3<br /> <br /> 286<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Obiektowa lista odwiedzin Wśród przykładów z rozdziału 3. (lekcja 12.) był taki, który zajmował się zbieraniem danych dotyczących połączeń z naszą witryną. Zbierane były informacje o adresie IP, dacie i czasie odwiedzin oraz rodzaju przeglądarki. Spróbujmy zmodyfikować tamten przykład w taki sposób, aby skrypt działał, wykorzystując poznane do tej pory techniki obiektowe. Powstanie zatem klasa Stats (nazwę można zmienić na inną), w której zapisem i odczytem danych będą się zajmowały zdefiniowane w niej metody. Kod został zaprezentowany na listingu 5.9. Za zapis danych będzie odpowiedzialna metoda writeData, natomiast za odczyt — readData. Jak łatwo się domyślić, ich postać będzie bardzo podobna do funkcji prezentowanych w przykładzie z lekcji 12., dlatego też nie będą ponownie szczegółowo omawiane zasady ich działania. Skupimy się na różnicach oraz ogólnej strukturze klasy. Listing 5.9. Kod klasy Stats <?php class Stats { public $stat_file = ""; function __construct($stat_file) { $this->stat_file = $stat_file; } function writeData() { $file_str = ""; if(file_exists($this->stat_file)){ if(($file_str = file_get_contents($this->stat_file)) === false){ //Błąd przy próbie odczytu zawartości pliku return false; } } if(!$fd = fopen($this->stat_file, "w")){ //Błąd przy próbie otwarcia pliku return false; } $str = date("Y-m-d:G:i")." "; $str .= $_SERVER['REMOTE_ADDR']." "; if(isSet($_SERVER['HTTP_USER_AGENT'])){ $str .= $_SERVER['HTTP_USER_AGENT']; } $str .= "\n"; fwrite($fd, $str); fwrite($fd, $file_str); fclose($fd); return true; } function readData() { if(!$fd = fopen($this->stat_file, "r")){ //Błąd przy próbie otwarcia pliku return false; }<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> } ?><br /> <br /> }<br /> <br /> 287<br /> <br /> $result = "<ol>"; while (!feof($fd)){ if(($str = fgets($fd)) != ""){ $result .= "<li>$str</li>\n"; } } $result .= "</ol>"; return $result;<br /> <br /> Klasa Stats zawiera jedno pole o nazwie $stat_file, które przechowuje nazwę pliku z danymi. Zawartość tego pola jest ustawiana w kodzie konstruktora, który przyjmuje jako argument ciąg znaków określający nazwę tego pliku. Tym samym zarówno w funkcji writeData, jak i readData niezbędna była zmiana odwołań w funkcjach wykorzystujących tę nazwę, czyli: file_exists, file_get_contents i fopen. Zmianie uległ także sposób działania funkcji readData (w przykładzie z lekcji 12. miała ona nazwę printData). Jej zadaniem jest teraz nie wyświetlenie odczytanych danych, ale zwrócenie ich jako rezultatu działania metody. W związku z tym w funkcji pojawiła się dodatkowa zmienna o nazwie $result, w której są zapisywane kolejne odczytywane wiersze. Wartość tej zmiennej jest zwracana za pomocą instrukcji return. Stworzoną w ten sposób klasę Stats (zapiszmy ją w pliku o nazwie Stats.php) można użyć w skrypcie uaktualniającym i wyświetlającym listę odwiedzin — został on zaprezentowany na listingu 5.10. Listing 5.10. Wykorzystanie klasy Stats <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <p>Lista odwiedzin:</p> <div> <?php include "Stats.php"; $statystyka = new Stats("./stats.txt"); if(($str = $statystyka->readData()) === false){ echo "Lista nie jest w tej chwili dostępna.<br />"; } else{ echo $str; } $statystyka->writeData(); ?> </div> </body> </html><br /> <br /> 288<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Przedstawiony kod jest bardzo prosty. Rozpoczyna się od dołączenia treści pliku Stats. php, a następnie utworzenia obiektu klasy Stats i przypisania go zmiennej $statystyka. Jako argument konstruktora został wykorzystany ciąg znaków ./stats.txt, co oznacza, że plik z danymi ma nazwę stats.txt i znajduje się w katalogu bieżącym (tym samym co kod skryptu) serwera. Po utworzeniu obiektu jest wykonywana instrukcja warunkowa if. Wykorzystywany jest w niej złożony warunek: ($str = $statystyka->readData()) === false<br /> <br /> Oznacza to: przypisz zmiennej $str wynik działania metody readData wywołanej na rzecz obiektu $statystyka i porównaj wartość tej zmiennej z wartością false. Jeśli zatem $str jest równe false, oznacza to, że nie udało się odczytać danych i jest wtedy wyświetlany odpowiedni komunikat, natomiast gdy $str jest różne od false, wyświetlana jest wartość $str (czyli zawartość pliku Stats.txt). Na zakończenie jest natomiast wywoływana metoda writeData, która do pliku Stats.txt dopisuje wiersz opisujący aktualne odwołanie.<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 17.1. Napisz kod klasy Punkt, która przechowuje dane dotyczące położenia punktów na ekranie. Klasa powinna mieć dwa pola — x i y — oraz metody ustawiające i pobierające ich wartości. Ćwiczenie 17.2. Zmodyfikuj kod skryptu z sekcji „Obiektowa lista odwiedzin” w ten sposób, aby dane zapisywane przez metodę writeData były przekazywane jako argumenty tej metody. Ćwiczenie 17.3. Napisz obiektową wersję skryptu wyświetlającego licznik odwiedzin strony. Ćwiczenie 17.4. Napisz obiektową wersję skryptu wyświetlającego listę odnośników wraz z ich opisami (analogicznie jak w przykładzie z lekcji 12.). Lista odnośników oraz dane dotyczące pojedynczego odnośnika powinny być zrealizowane za pomocą osobnych klas.<br /> <br /> Lekcja 18. Więcej o programowaniu obiektowym Dziedziczenie Dziedziczenie to jeden z fundamentów programowania obiektowego. Umożliwia sprawne i łatwe wykorzystywanie napisanego już raz kodu przez budowanie hierarchii klas przejmujących swoje właściwości. Zobaczymy zatem, jak tworzy się klasy potomne<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 289<br /> <br /> oraz jakie podstawowe zależności występują między klasą bazową a potomną. W tym celu utworzymy hipotetyczną ogólną klasę Osoba, przyjmując, że jej zadaniem jest przechowywanie danych dotyczących osób, tj. imienia i nazwiska. Jej postać została zaprezentowana na listingu 5.11. Listing 5.11. Kod klasy Osoba <?php class Osoba { public $imie, $nazwisko; public function ustawImie($imie) { $this->imie = $imie; } public function ustawNazwisko($nazwisko) { $this->nazwisko = $nazwisko; } public function pobierzImie() { return $this->imie; } public function pobierzNazwisko() { return $this->nazwisko; } } ?><br /> <br /> Do przechowywania danych dotyczących imienia i nazwiska służą pola o nazwach $imie i $nazwisko, a ich wartości mogą być ustawiane i odczytywane zarówno bezpośrednio, jak i za pomocą wywołania dostępnych w klasie metod. Do odczytu służą metody pobierzImie i pobierzNazwisko, a do zapisu ustawImie i ustawNazwisko. Zastanówmy się teraz, co należałoby zrobić, gdyby w systemie oprócz danych osób trzeba było zapisywać dane dotyczące użytkowników, a każdy z nich posiadałby imię, nazwisko oraz identyfikator nadawany przez system. Pomysłem, który się od razu nasuwa, jest napisanie dodatkowej klasy, np. o nazwie Uzytkownik, w postaci: class Uzytkownik { public $imie, $nazwisko, $id; /* w tym miejscu metody klasy */ }<br /> <br /> do której należałoby dopisać pełny zestaw metod takich jak w klasie Osoba, czyli ustawImie, ustawNazwisko, pobierzImie i pobierzNazwisko, oraz dodatkowe metody obsługujące pole $id. Taka klasa nie będzie jednak prezentowana, gdyż byłoby to zwykłym marnotrawieniem miejsca. Zauważmy, że w takiej sytuacji należałoby w dużej części po prostu powtórzyć już raz napisany kod. Czym bowiem różniłaby się metoda ustawImie z klasy Osoba od metody ustawImie z klasy Uzytkownik? Niczym — byłyby identyczne. Dlatego klasę Uzytkownik należy potraktować jako rozszerzenie klasy Osoba.<br /> <br /> 290<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Rozszerzenie o dodatkowe pola i metody. Zamiast więc pisać całkiem od nowa kod klasy Uzytkownik, lepiej spowodować, aby przejęła ona wszystkie możliwości klasy Osoba, wprowadzając dodatkowo swoje własne. To właśnie jest dziedziczenie, które w PHP jest realizowane, podobnie jak w niektórych innych językach programowania, za pomocą słowa extends. Schematycznie taka konstrukcja ma następującą postać: class klasa_potomna extends klasa_bazowa { //kod klasy }<br /> <br /> Zapis taki oznacza, że klasa potomna dziedziczy z bazowej (np. klasa Uzytkownik z klasy Osoba). Zobaczmy, jak to będzie wyglądało w przypadku omawianych klas. Kod klasy Uzytkownik został przedstawiony na listingu 5.12. Listing 5.12. Kod klasy Uzytkownik <?php require_once("Osoba.php"); class Uzytkownik extends Osoba { public $id; public function ustawId($id) { $this->id = $id; } public function pobierzId() { return $this->id; } } ?><br /> <br /> Na początku kodu została umieszczona instrukcja wymuszająca wczytanie zawartości pliku z definicją klasy Osoba. Ta definicja jest niezbędna, ponieważ klasa Uzytkownik dziedziczy z klasy Osoba, co jest wyrażane przez słowo kluczowe extends. Użyta została instrukcja require_once, dzięki czemu jeśli w skrypcie korzystającym z kodu klasy Uzytkownik będzie już zawarta instrukcja wczytująca kod klasy Osoba, ponowne wczytanie nie nastąpi (z taką właśnie sytuacją będziemy mieli do czynienia w kolejnym skrypcie). Klasa Uzytkownik zawiera jedynie definicję pola $id oraz metod operujących na nim: ustawId — ustawiającej wartość oraz pobierzId — pobierającej wartość. Jednak dzięki dziedziczeniu z klasy Osoba każdy obiekt typu Uzytkownik będzie również zawierał wszystkie pola i wszystkie metody z klasy Osoba. Najlepiej się o tym przekonać, wykonując dowolne operacje na tych obiektach. Kod wykonujący takie instrukcje został przedstawiony na listingu 5.13.<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 291<br /> <br /> Listing 5.13. Użycie obiektów klas Osoba i Uzytkownik <?php include "Osoba.php"; include "Uzytkownik.php"; $osoba = new Osoba(); $osoba->ustawImie("Andrzej"); $osoba->ustawNazwisko("Nowak"); echo "Dane obiektu \$osoba\n"; echo $osoba->pobierzImie(), "\n"; echo $osoba->pobierzNazwisko(), "\n"; $uzytkownik = new Uzytkownik(); $uzytkownik->ustawImie("Jan"); $uzytkownik->ustawNazwisko("Kowalski"); $uzytkownik->ustawId("012"); echo echo echo echo ?><br /> <br /> "\nDane obiektu \$uzytkownik\n"; $uzytkownik->pobierzImie(), "\n"; $uzytkownik->pobierzNazwisko(), "\n"; $uzytkownik->pobierzId(), "\n";<br /> <br /> Kod rozpoczyna się od instrukcji include, które do treści skryptu dołączają treść pliku Osoba.php (zawierającego definicję klasy Osoba) oraz pliku Uzytkownik.php (zawierającego kod klasy Uzytkownik). Zostały umieszczone w skrypcie, ponieważ są w nim używane obie klasy. Dzięki temu kod jest spójny, choć warto zauważyć, że z formalnego punktu widzenia nie ma potrzeby dołączania pliku Osoba.php, gdyż jest on dołączany w kodzie klasy Uzytkownik.php. Następnie jest tworzony nowy obiekt typu Osoba i przypisywany zmiennej obiektowej $osoba. Dalej wywoływane są metody ustawImie i ustawNazwisko powodujące nadanie wartości polom imie i nazwisko. W kolejnym kroku dane są wyświetlane, przy czym wartości pól są pobierane za pomocą wywołań odpowiednich metod. W dalszej części skryptu tworzony jest nowy obiekt klasy Uzytkownik i przypisywany zmiennej $uzytkownik. Po wykonaniu tej czynności są wywoływane metody ustawImie, ustawNazwisko i ustawId powodujące nadanie polom tego obiektu konkretnych wartości. Następnie, podobnie jak w przypadku obiektu $osoba, wartości te są wyświetlane na ekranie za pomocą instrukcji echo, a do ich pobrania są wykorzystywane odpowiednie metody. Jeśli teraz uruchomimy powyższy kod w konsoli (jeśli chcemy zobaczyć efekt działania w przeglądarce, należy zamienić znaki końca linii \n na znaczniki <br />, tak aby efekt był czytelny), zobaczymy taki widok jak na rysunku 5.4. To najlepszy dowód, że obiekt klasy Uzytkownik posiada wszystkie pola i wszystkie metody z klasy Osoba, mimo że nie zostały one w nim jawnie zdefiniowane.<br /> <br /> 292<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Rysunek 5.4. Skrypt z listingu 5.13 uruchomiony na konsoli<br /> <br /> Przesłanianie składowych Wiadomo, że w trakcie dziedziczenia klasa potomna dziedziczy składowe z klasy bazowej. Co się jednak stanie, jeśli w klasie potomnej zostaną zdefiniowane pola i (lub) metody o takich danych nazwach jak w klasie bazowej? Innymi słowy, co by było, gdyby w klasie Uzytkownik z poprzedniej części lekcji umieścić na przykład metodę o nazwie pobierzImie, która przecież istnieje w klasie Osoba? Otóż w takiej sytuacji składowa z klasy bazowej zostanie przesłonięta przez tę z klasy potomnej. Aby jednak nie zaciemniać sedna problemu niepotrzebnym kodem wielu metod, zostanie to bliżej wyjaśnione na prostszym przykładzie zaprezentowanym na listingu 5.14. Listing 5.14. Ilustracja problemu przesłaniania metod <?php class A { public function f() { echo "Jestem funkcją f z klasy A."; } } class B extends A { public function f() { echo "Jestem funkcją f z klasy B."; } } $objA = new A(); $objB = new B(); $objA->f(); echo "\n"; $objB->f(); ?><br /> <br /> Mamy tu dwie klasy A i B, obie zawierają metodę o takiej samej nazwie — f. W kodzie tworzone są też dwa obiekty tych klas — $objA typu A i $objB typu B. Po utworzeniu<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 293<br /> <br /> obiektów wywoływana jest metoda f każdego z nich. Gdyby A i B były osobnymi, niepowiązanymi klasami, przedstawiona sytuacja nie stwarzałaby żadnego problemu — byłaby pewność, że w przypadku obiektu $objA zostanie wywołana metoda z klasy A, a w przypadku $objB — klasy B. Jednak klasa B dziedziczy z klasy A. Jak więc zachowa się przedstawiony kod? Tak jak jest to widoczne na rysunku 5.5. Rysunek 5.5. Ilustracja problemu przesłaniania metod<br /> <br /> Wydawać by się mogło, że powinien wystąpić konflikt nazw (z powodu dwukrotnego zadeklarowania metody f). Jednak próba wykonania kodu wykazuje, że PHP nie zgłasza żadnych błędów. Dlaczego więc konflikt nazw nie występuje? Otóż zasada jest następująca: jeśli w klasie bazowej i pochodnej występuje metoda o tej samej nazwie i argumentach, ta z klasy bazowej jest przesłaniana. Czyli w obiektach klasy bazowej będzie obowiązywała metoda z klasy bazowej, a w obiektach klasy pochodnej ta z klasy pochodnej. Tak więc wykonanie instrukcji $objA->f() spowodowało wywołanie metody f z klasy A, a instrukcji $objB->f() metody f z klasy B. W tym miejscu może pojawić się pytanie, czy jest w takim razie możliwe wywołanie w klasie pochodnej przesłoniętej metody z klasy bazowej? Jeśli pytanie to brzmi zbyt zawile, to (na przykładzie klas z listingu 5.14) chodzi o to, czy w klasie B można wywołać metodę f z klasy A? Odpowiedź brzmi — tak. W tym celu jest wykorzystywane odwołanie parent:: o ogólnej postaci: parent::nazwa_metody(argumenty);<br /> <br /> Zobrazowano to w kodzie widocznym na listingu 5.15. Efekt działania skryptu został zaprezentowany na rysunku 5.6. Listing 5.15. Dostęp do przesłoniętej składowej <?php class A { public function f() { echo "Jestem funkcją f z klasy A."; } } class B extends A { public function f() { parent::f(); echo "Jestem funkcją f z klasy B."; } }<br /> <br /> 294<br /> <br /> PHP5. Praktyczny kurs $objA = new A(); $objB = new B(); $objA->f(); echo "\n"; $objB->f(); ?><br /> <br /> Rysunek 5.6. Ilustracja dostępu do przesłoniętej metody<br /> <br /> Ogólna struktura przykładu jest taka sama jak na listingu 5.14. Mamy do czynienia z dwiema klasami A i B, a w każdej z nich z metodą f. Różnica jest taka, że w metodzie f z klasy B (dziedziczącej z A) została dodatkowo wywołana metoda f z klasy bazowej (A). W tym celu zostało użyte odwołanie: parent::f();<br /> <br /> Na rysunku 5.6 widać, że wywołanie zakończyło się sukcesem, tzn. w przypadku obiektu $objB po wykonaniu instrukcji $objB->f(); najpierw została wywołana metoda f z klasy A, a następnie instrukcja echo z metody f klasy B.<br /> <br /> Klasy i składowe finalne Wiemy już, że metody klasy bazowej mogą być przeciążane w klasach pochodnych. Taka sytuacja nie zawsze jest jednak pożądana, dlatego też PHP umożliwia deklarowanie metod jako finalne. Tak zadeklarowane składowe (za pomocą słowa kluczowego final) nie mogą być przeciążane. Schematycznie taka konstrukcja będzie miała następującą postać: class nazwa_klasy { final public function nazwa_metody { //kod metody } //definicje pozostałych składowych }<br /> <br /> O tym, że tak utworzonej metody nie można przeciążyć (redefiniować) w klasie pochodnej, można się przekonać, próbując wykonać kod widoczny na listingu 5.16. Listing 5.16. Próba przeciążenia metody finalnej <?php class Osoba { public $imie, $nazwisko; final public function wyswietl()<br /> <br /> Rozdział 5. ♦ Obiektowy PHP {<br /> <br /> }<br /> <br /> }<br /> <br /> 295<br /> <br /> echo "Imię: ", $this->imie, "\n"; echo "Nazwisko: ", $this->nazwisko, "\n";<br /> <br /> class Uzytkownik extends Osoba { public $id; public function wyswietl() { parent::wyswietl(); echo "Id: ", $this->id, "\n"; } } ?><br /> <br /> Widnieją na nim dwie klasy — Osoba i Uzytkownik. W klasie Osoba została zadeklarowana finalna metoda o nazwie wyswietl, której zadaniem jest wyświetlenie wartości pól tej klasy. Klasa Uzytkownik jest pochodną od Osoba i w związku z tym dziedziczy wszystkie jej składowe. Znajduje się w niej również ponowna deklaracja metody wyswietl, która w normalnych warunkach przesłoniłaby deklarację z klasy bazowej. Ponieważ jednak w klasie bazowej metoda wyswietl jest zadeklarowana jako finalna, próba uruchomienia kodu spowoduje wyświetlenie komunikatu o błędzie. Przykład takiego komunikatu został zaprezentowany na rysunku 5.7. Rysunek 5.7. Próba przeciążenia metody finalnej powoduje wystąpienie błędu<br /> <br /> Konstruktory i destruktory klas bazowych Przy dziedziczeniu klas należy zwrócić uwagę na zachowanie konstruktorów i destruktorów. Otóż te, które zostały zdefiniowane w klasach potomnych, zostaną oczywiście wykonane, nie będą natomiast wywoływane konstruktory i destruktory z klas bazowych. Z kolei jeśli w klasie potomnej nie ma zdefiniowanego konstruktora, wówczas zostanie wykonany konstruktor z klasy bazowej. To zagadnienie zilustrowano w przykładzie widocznym na listingu 5.17. Listing 5.17. Metody specjalne w klasach potomnych <?php class A { function __construct() { echo("Jestem konstruktorem z klasy A.\n"); }<br /> <br /> 296<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> }<br /> <br /> function __destruct() { echo("Jestem destruktorem z klasy A.\n"); }<br /> <br /> class B extends A { function __construct() { echo("Jestem konstruktorem z klasy B.\n"); } function __destruct() { echo("Jestem destruktorem z klasy B.\n"); } } class C extends A { } $objB = new B(); //$objC = new C(); ?><br /> <br /> Zostały w nim zdefiniowane trzy klasy — A, B i C, przy czym klasy B i C dziedziczą z A. Klasy A i B zawierają konstruktory i destruktory mające za zadanie wyświetlenie informacji o tym, z której klasy dana metoda pochodzi, natomiast klasa C jest ich pozbawiona. Na samym końcu tworzony jest obiekt klasy B, który zostanie zniszczony podczas kończenia pracy skryptu (instrukcja tworząca obiekt klasy C jest ujęta w komentarz i nie zostanie wykonana). Choć moglibyśmy się spodziewać, że skoro B dziedziczy z A, to przy tworzeniu obiektu zostanie wykonany zarówno konstruktor z klasy A, jak i z B, tak jednak nie jest. Na ekranie zobaczymy jedynie informacje wyświetlone przez metody klasy B. Prawdziwe jest zatem stwierdzenie, że jeśli w klasie potomnej jest zdefiniowany konstruktor, to tylko on zostanie wykonany (nie zostanie automatycznie wykonany konstruktor klasy bazowej). Ujmijmy teraz w komentarz instrukcję tworzącą obiekt klasy B oraz usuńmy komentarz z instrukcji tworzącej obiekt klasy C i ponownie uruchommy skrypt. Tym razem będzie inaczej. Okaże się, że przy tworzeniu obiektu $objC został wywołany konstruktor z klasy bazowej (klasy A), a przy jego niszczeniu — destruktor klasy bazowej. To ilustracja zasady, że jeśli w klasie potomnej (w tym przykładzie C) nie ma konstruktora, a w klasie bazowej jest — ten z klasy bazowej (w tym przykładzie A) zostanie automatycznie wykonany. Nic jednak nie stoi na przeszkodzie, aby w pierwszym z omawianych przypadków (klasy A i B) samodzielnie wywołać konstruktor i (lub) destruktor klasy bazowej. W praktyce często jest to potrzebne. W takiej sytuacji należy użyć składni ze słowem kluczowym parent, czyli dla konstruktora (podobnie jak miało to miejsce w przypadku przesłoniętych metod): parent::__construct();<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 297<br /> <br /> a dla destruktora: parent::__destruct();<br /> <br /> Tę technikę zobrazowano w kodzie widocznym na listingu 5.18. Listing 5.18. Wywołanie konstruktora i destruktora klasy bazowej <?php class A { //tutaj treść klasy A z listingu 5.17 } class B extends A { function __construct() { parent::__construct(); echo("Jestem konstruktorem z klasy B.\n"); } function __destruct() { parent::__destruct(); echo("Jestem destruktorem z klasy B.\n"); } } $objB = new B(); ?><br /> <br /> Klasa A pozostała w postaci przedstawionej na listingu 5.17, dlatego jej treść pominięto. W konstruktorze i destruktorze klasy B, która dziedziczy z A, zostały natomiast dopisane wywołania konstruktorów odziedziczonych z klasy A — zgodnie z podanym wyżej schematem. Po uruchomieniu kodu okaże się, że utworzenie obiektu klasy B spowodowało uruchomienie zarówno konstruktora z klasy B, jak i z klasy A. Podobnie przy niszczeniu obiektu zostały wykonane oba dostępne destruktory.<br /> <br /> Specyfikatory dostępu W dotychczasowych przykładach przed nazwami pól oraz części metod pojawiało się słowo public. Nie zostało to jednak dokładnie wyjaśnione. Czas przyjrzeć się bliżej tej kwestii. Otóż w PHP składowe klasy muszą mieć określony sposób dostępu, który definiuje się przez tzw. specyfikatory dostępu określane również modyfikatorami dostępu (oba terminy są poprawne, z ang. access modifiers). Wyróżniamy trzy takie modyfikatory:  public — dostęp publiczny,  protected — dostęp chroniony,  private — dostęp prywatny.<br /> <br /> 298<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Modyfikator musi wystąpić przed nazwą pola, przed nazwą metody — nie, jest ona wtedy traktowana tak, jakby znajdowało się przed nią słowo public (czyli metoda zadeklarowana bez specyfikatora dostępu jest metodą publiczną). Co jednak oznaczają te słowa kluczowe? Otóż:  Dostęp do składowych publicznych jest nieograniczony, co oznacza,<br /> <br /> że można się do nich dowolnie odwoływać.  Dostęp do składowych chronionych jest ograniczony do klasy, w której<br /> <br /> są one zdefiniowane, oraz do klas bazowych i pochodnych.  Dostęp do składowych prywatnych jest ograniczony tylko do klasy,<br /> <br /> w której są zdefiniowane. Najlepiej pokazać to na przykładzie widocznym na listingu 5.19. Nieprawidłowe odwołania, które spowodowałyby wystąpienie błędów, zostały zaprezentowane w formie komentarza. Listing 5.19. Dostęp do składowych <?php class A { public $wartosc_1 = 10; protected $wartosc_2 = 20; private $wartosc_3 = 30; public function wyswietl() { echo "wartosc_1 = ", $this->wartosc_1, "\n"; echo "wartosc_2 = ", $this->wartosc_2, "\n"; echo "wartosc_3 = ", $this->wartosc_3, "\n"; } } class B extends A { public function wyswietl() { echo "wartosc_1 = ", $this->wartosc_1, "\n"; echo "wartosc_2 = ", $this->wartosc_2, "\n"; //echo "wartosc_3 = ", $this->wartosc_3, "\n"; } } $objA = new A(); $objB = new B(); echo "Zawartość obiektu \$objA:\n"; echo $objA->wartosc_1, "\n"; //echo $objA->wartosc_2, "\n"; //echo $objA->wartosc_3, "\n"; $objA->wyswietl(); echo "\nZawartość obiektu \$objB:\n"; $objB->wyswietl(); ?><br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 299<br /> <br /> Klasa A zawiera trzy pola:  publiczne wartosc_1 o wartości 10,  chronione wartosc_2 o wartości 20,  prywatne wartosc_3 o wartości 30.<br /> <br /> oraz metodę wyswietl wyświetlającą ich wartości na ekranie. Klasa B dziedziczy z A, nie ma w niej zdefiniowanych żadnych dodatkowych pól, istnieje w niej jednak metoda wyswietl przesłaniająca metodę o tej samej nazwie z klasy A. W kodzie skryptu zostały utworzone dwa obiekty — $objA klasy A oraz $objB klasy B. Po utworzeniu obiektów wykonywana jest seria instrukcji obrazujących prawidłowe i nieprawidłowe odwołania. I tak instrukcja:  echo $objA->wartosc_1, "\n"; jest prawidłowa, gdyż pole wartosc_1<br /> <br /> jest publiczne i można się do niego swobodnie odwoływać.  echo $objA->wartosc_2, "\n"; jest nieprawidłowa, gdyż pole wartosc_2 jest chronione i można się do niego odwołać jedynie z wnętrza klasy A lub klasy pochodnej B.  echo $objA->wartosc_3, "\n"; jest nieprawidłowa, gdyż pole wartosc_3 jest prywatne i można się do niego odwołać jedynie z wnętrza klasy A.  $objA->wyswietl(); jest prawidłowa, gdyż metoda wyswietl klasy A<br /> <br /> jest publiczna, a ponieważ znajduje się wewnątrz klasy, ma pełny dostęp do wszystkich pól i może wyświetlić ich zawartość.  $objB->wyswietl(); jest prawidłowa, gdyż metoda wyswietl klasy B jest publiczna, jednak zawarta w niej instrukcja echo "wartosc_3 = ", $this->wartosc_3, "\n"; jest nieprawidłowa, gdyż próbuje się odwołać do prywatnej składowej z klasy A.<br /> <br /> Składowe statyczne Są to takie składowe, które istnieją nawet wtedy, gdy nie ma żadnego obiektu danej klasy. Są one deklarowane za pomocą słowa kluczowego static, które należy umieścić po specyfikatorze dostępu. Oznacza to, że w przypadku pól taka deklaracja będzie miała schematyczną postać: specyfikator_dostepu static $nazwa_pola;<br /> <br /> a w przypadku metod: specyfikator_dostepu static function nazwa_metody(argumenty);<br /> <br /> Aby dostać się do składowej statycznej, czyli zapisać lub odczytać wartość, bądź też wywołać metodę, należy użyć konstrukcji dla pól w postaci: nazwa_klasy::nazwa_pola<br /> <br /> oraz dla metod w postaci: nazwa_klasy::nazwa_metody(argumenty)<br /> <br /> 300<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Zobrazowano to w kodzie widocznym na listingu 5.20. Efekt jego działania został natomiast zaprezentowany na rysunku 5.8. Listing 5.20. Użycie składowych statycznych <?php class A { public static $liczba = 100; public static function f() { echo "Jestem statyczną funkcją f klasy A."; } } echo "Wartość statycznego pola \$liczba klasy A to: "; echo A::$liczba, ".\n"; A::$liczba = 200; echo "Wartość statycznego pola \$liczba klasy A po zmianie to: "; echo A::$liczba, ".\n"; echo "Wywołanie statycznej funkcji f klasy A:\n"; A::f(); ?><br /> <br /> Rysunek 5.8. Odwołania do składowych statycznych<br /> <br /> W klasie A zostały zdefiniowane dwie składowe statyczne — pole o nazwie $liczba oraz funkcja o nazwie f. Pierwotną wartością pola jest 100, natomiast zadaniem funkcji jest jedynie wyświetlenie informacji o jej wywołaniu. W kodzie skryptu najpierw jest wyświetlana początkowa wartość pola, a następnie jest ona zmieniana i ponownie wyprowadzana na ekran. Dzieje się tak mimo tego, że nie został utworzony żaden obiekt klasy A. W obu przypadkach stosowane jest bowiem odwołanie w postaci: A::$liczba. W analogiczny sposób jest też wywoływana metoda f — stosowane jest odwołanie A::f(). Gdy korzystamy ze składowych statycznych, należy dodatkowo zwrócić uwagę na dwie rzeczy. Pierwsza to sposób odwoływania się do tych składowych z wnętrza klasy. Jak pamiętamy, aby odwołać się do zwykłej składowej klasy, należało zastosować odwołanie $this będące synonimem obiektu bieżącego. W przypadku składowych statycznych tak być nie może, gdyż istnieją one niezależnie od istnienia obiektów danej klasy. Dlatego odwołanie przez obiekt bieżący wymaga użycia innej konstrukcji. Jest w tym celu wykorzystywane słowo self i operator ::. Schematycznie, dla pól: self::nazwa_statycznego_pola<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 301<br /> <br /> a dla metod: self::nazwa_statycznej_metody(argumenty)<br /> <br /> Nie wyklucza to jednak stosowania metody przedstawionej wyżej, czyli odwołań w postaci: nazwa_klasy::nazwa_składowej_statycznej<br /> <br /> Problem drugi to odwołania do składowych statycznych na zewnątrz klasy, w której są zdefiniowane, ale przez istniejący obiekt. W przypadku zwykłych składowych schemat był następujący (dla pól): $nazwa_obiektu->nazwa_pola<br /> <br /> lub (dla metod): $nazwa_obiektu->nazwa_metody(argumenty)<br /> <br /> Przy korzystaniu ze składowych statycznych w przypadku metod tego typu odwołania są dopuszczalne, choć niezalecane (jeśli w pliku konfiguracyjnym php.ini została włączona opcja E_STRICT dotycząca wyświetlania błędów, wówczas po użyciu takiej konstrukcji zostanie wygenerowana nota informacyjna), natomiast w przypadku pól jest to konstrukcja nieprawidłowa. Na listingu 5.21 został zaprezentowany przykład ilustrujący omawiane problemy. Listing 5.21. Odwołania do składowych statycznych <?php class A { public static $liczba = 100; public static function f() { echo "Wartość statycznego pola \$liczba to "; echo A::$liczba, ".\n"; } public function g() { self::$liczba = 200; self::f(); } } $objA = new A(); echo "Wartość statycznego pola \$liczba to {$objA->liczba}.\n"; $objA->f(); $objA->g(); ?><br /> <br /> W klasie A zostały zdeklarowane: statyczne pole $liczba, statyczna metoda f i zwykła metoda g. W metodzie f jest wyświetlana bieżąca wartość pola $liczba. Stosowane jest tu odwołanie znane z poprzedniego przykładu — A::$liczba. Jak widać, może ono być z powodzeniem stosowane wewnątrz klasy. Metoda g zawiera dwie instrukcje. Pierwsza z nich zmienia wartość pola $liczba na 200, druga wywołuje metodę f<br /> <br /> 302<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> (powodującą wyświetlenie aktualnego stanu pola na ekranie). W obu przypadkach stosowane jest odwołanie przez obiekt bieżący ze słowem kluczowym self. W kodzie skryptu jest tworzony obiekt klasy A — $objA. Następnie w instrukcji echo ma miejsce próba odczytania wartości pola $liczba przez odwołanie $objA->liczba (użyta została składnia z nawiasem klamrowym). Ponieważ w ten sposób nie można odwoływać się do pól statycznych, instrukcja ta nie zadziała prawidłowo i spowoduje wyświetlenie komunikatu informującego o tym (o ile konfiguracja PHP pozwala na wyświetlanie takich komunikatów). Właściwie zadziałają natomiast znajdujące się dalej prawidłowe wywołania funkcji f oraz g i ostatecznie po uruchomieniu skryptu na ekranie zobaczymy taki widok jak na rysunku 5.9.<br /> <br /> Rysunek 5.9. Efekt uruchomienia skryptu 5.21<br /> <br /> Trzeba jednak zauważyć, że choć wywołanie $objA->f(); jest dopuszczalne, nie jest ono formą zalecaną. Skoro bowiem metoda f jest statyczna, należy ją wywoływać tak jak składową statyczną, czyli z użyciem operatora ::. Zatem lepszym rozwiązaniem byłoby użycie konstrukcji: A::f();<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 18.1. Napisz kod klasy Punkt3D pochodnej od klasy Punkt powstałej w ćwiczeniu 17.1, która przechowuje dane dotyczące punktów w przestrzeni 3D. Dopisz metody pobierające i ustawiające współrzędną z. Ćwiczenie 18.2. Zmodyfikuj kod z listingu 5.3 w taki sposób, aby pola id i nazwa były chronione, a skrypt działał poprawnie. Ćwiczenie 18.3. Do klasy Punkt dopisz statyczną metodę nowyPunkt, której zadaniem będzie zwracanie nowego obiektu typu Punkt określającego punkt o współrzędnych (0,0). Ćwiczenie 18.4. Zmodyfikuj kod klasy Osoba z listingu 5.11 w taki sposób, aby dane były przechowywane w tablicy o dostępie chronionym (protected), która zawiera klucze imie i nazwisko. Wszystkie metody klasy muszą spełniać identyczne zadania jak w klasie pierwotnej. Ćwiczenie 18.5. Z klasy Osoba powstałej w ćwiczeniu 18.4 wyprowadź klasę Uzytkownik, która będzie spełniała takie same zadania jak klasa Uzytkownik z listingu 5.12.<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 303<br /> <br /> Lekcja 19. Wyjątki Wyjątki to konstrukcje programistyczne służące do obsługi sytuacji, jak sama nazwa wskazuje, wyjątkowych. Najczęściej wykorzystywane są do obsługi błędów, pozwalając na zmniejszenie liczby instrukcji warunkowych oraz pomijanie całych bloków kodu, dzięki czemu skrypty są bardziej przejrzyste i łatwiej nimi zarządzać. PHP również obsługuje wyjątki (począwszy od omawianej w niniejszej publikacji wersji 5.). Osoby znające klasyczne języki programowania, takie jak C++ czy Java, nie będą miały żadnych problemów z posługiwaniem się tymi konstrukcjami, gdyż ich składnia jest zapożyczona wprost z tego typu języków.<br /> <br /> Instrukcja throw Programista ma możliwość zgłoszenia wyjątku za pomocą instrukcji throw. Czynność tę określa się również jako „wyrzucanie” wyjątku (od ang. throw — rzucać). Zgłoszenie wyjątku to nic innego jak informacja dla aparatu wykonawczego PHP, że wystąpiła sytuacja nadzwyczajna, która wymaga specjalnej obsługi. Z reguły jest to informacja o błędzie. Zobaczmy zatem, jak zareaguje PHP na wykonanie instrukcji throw. Po uruchomieniu w konsoli (oczywiście można go również uruchomić w przeglądarce) skryptu: <?php throw new Exception(); ?><br /> <br /> ukaże się widok jak na rysunku 5.10. Rysunek 5.10. Wynik wykonania prostej instrukcji throw<br /> <br /> Opierając się na wcześniejszych informacjach z tego rozdziału, można się domyślić, że parametrem instrukcji throw jest obiekt klasy Exception utworzony za pomocą instrukcji new. Widać też, że wykonanie powyższego skryptu spowodowało wystąpienie błędu krytycznego (fatal error) i zakończenie działania kodu. Rzecz jasna, gdyby to był jedyny sposób wykorzystywania wyjątków, funkcjonalność tej techniki byłaby znikoma, jak jednak zostanie pokazane na kolejnych stronach, tak wygenerowany wyjątek można przechwycić i wykonać własny kod obsługi błędu. Najpierw jednak przyjrzyjmy się bliżej klasie Exception.<br /> <br /> 304<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Klasa Exception i pochodne Wyjątek to obiekt zgłoszony za pomocą instrukcji throw. Musi to być jednak obiekt klasy Exception lub dziedziczącej z niej (pochodnej od Exception). Jeśli spróbujemy użyć innej klasy, PHP zgłosi błąd widoczny na rysunku 5.11. Klasa Exception oferuje kilka przydatnych metod. Zacznijmy od konstruktora. W przykładzie z poprzedniej sekcji był on bezargumentowy. W rzeczywistości może przyjmować argumenty, z których pierwszy określa komunikat, a drugi kod błędu — te właściwości będą przechowywane przez obiekt wyjątku1. Schematyczne wywołanie ma zatem postać: Exception(["komunikat" [, kod_błędu]])<br /> <br /> Jeżeli zostanie pominięty argument kod_błędu, zastosowana będzie wartość 0, natomiast jeśli zostanie pominięty argument komunikat, zastosowana będzie wartość pusta null. Zarówno komunikat, jak i kod błędu mogą być dowolne, zależą jedynie od programisty (komunikat powinien być ciągiem znaków, a kod błędu — wartością całkowitą).<br /> <br /> Rysunek 5.11. Efekt zastosowania nieprawidłowego obiektu wyjątku<br /> <br /> Oprócz konstruktora do dyspozycji jest kilka metod, w tym:  getMessage — zwracająca komunikat powiązany z danym wyjątkiem.  getCode — zwracająca kod powiązany z danym wyjątkiem.  getFile — zwracająca nazwę pliku, w którym wystąpił dany wyjątek.  getLine — zwracająca numer linii kodu, w której wystąpił dany wyjątek.<br /> <br /> Wszystkie one są metodami finalnymi, co oznacza, że nie mogą być przesłaniane w klasach pochodnych. Przykład obrazujący wykorzystanie tych metod zostanie przedstawiony już na kolejnych stronach, na razie przekonajmy się, jakie klasy pochodne od Exception dostępne są standardowo. W PHP w wersji 5.0 jest dostępna jedynie klasa Exception. Dopiero w wersji 5.1 został dodany cały zestaw tych klas. Ta hierarchia została przedstawiona na rysunku 5.12. Widać wyraźnie, że bezpośrednio z Exception dziedziczą LogicException (reprezentująca logiczne błędy skryptu) oraz RuntimeException (dla błędów, które mogą powstać jedynie w trakcie wykonywania skryptu) i dopiero z tych dwóch klas dziedziczą kolejne opisujące bardziej szczegółowe wyjątki. Przykładowo, wyjątek typu InvalidArgumentException (nieprawidłowy argument) mógłby być generowany po wykryciu, że do funkcji została przekazana wartość typu string, podczas gdy oczekiwana była wartość całkowita, natomiast wyjątek typu RangeException w sytuacji, gdy nastąpiło przekazanie argumentu spoza dopuszczalnego zakresu. 1<br /> <br /> Dostępny jest także trzeci, również opcjonalny, argument, który może być używany przy kaskadowej obsłudze wyjątków.<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 305<br /> <br /> Rysunek 5.12. Pochodne klasy Exception<br /> <br /> Blok try...catch Zgłoszenie wyjątku to sygnalizacja wystąpienia błędu. Logika podpowiada, że powinna istnieć konstrukcja programistyczna umożliwiająca reakcję na taki błąd. Taka technika nazywa się przechwytywaniem wyjątków, a służy do tego instrukcja try…catch o następującej postaci: try{ //instrukcje mogące spowodować wyjątek } catch (typWyjątku obiektWyjątku){ //kod obsługi błędu }<br /> <br /> W nawiasie klamrowym występującym po słowie try umieszczamy instrukcje, które mogą spowodować zaistnienie wyjątku. W bloku występującym po catch umieszczamy kod, który ma zostać wykonany wtedy, gdy wyjątek wystąpi. W jaki sposób zatem do pierwszego przykładu z tej lekcji wprowadzić blok try…catch, aby po wygenerowaniu wyjątku nie występował błąd krytyczny? Odpowiedzią jest kod widoczny na listingu 5.22. Listing 5.22. Przechwycenie wyjątku <?php try{ throw new Exception(); } catch(Exception $e){ echo "Został wygenerowany wyjątek!"; } ?><br /> <br /> 306<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Jeśli go uruchomimy, na ekranie pojawi się napis Został wygenerowany wyjątek!, a więc udało nam się wykonać własny kod obsługi błędu. Działanie jest tu następujące: za pomocą instrukcji new tworzony jest nowy obiekt wyjątku klasy Exception, który jest zgłaszany za pomocą instrukcji throw. Wyjątek ten jest przechwytywany przez blok try i przekazywany do bloku catch. W bloku catch obiekt wyjątku (powstały po wykonaniu instrukcji new Exception()) jest dostępny przez argument $e. Skoro tak, spróbujmy wykorzystać opisane wcześniej (a dostępne w tym obiekcie) metody klasy Exception. Niech więc generowany wyjątek zawiera również komunikat oraz wymyślony przez nas kod błędu i niech te informacje będą wyświetlane na ekranie. Takie zadanie realizuje skrypt widoczny na listingu 5.23, a efekt jego działania został zaprezentowany na rysunku 5.13. Listing 5.23. Wyjątek z komunikatem i kodem <?php try{ throw new Exception("Testowy obiekt wyjątku", 123); } catch(Exception $e){ echo "Został wygenerowany wyjątek!\n"; echo "Treść komunikatu: ", $e->getMessage(), "\n"; echo "Kod błędu: ", $e->getCode(), "\n"; echo "Nazwa pliku: ", $e->getFile(), "\n"; echo "Numer linii: ", $e->getLine(), "\n"; } ?><br /> <br /> Rysunek 5.13. Odczytanie danych związanych z wyjątkiem<br /> <br /> Tym razem w konstruktorze wyjątku zostały przekazane dwa argumenty, czyli komunikat oraz kod. Zostały więc zapisane w obiekcie wyjątku. Po przechwyceniu wyjątku w bloku catch z obiektu wyjątku reprezentowanego przez zmienną $e odczytano dostępne informacje. Po wystąpieniu wyjątku na ekranie zostały więc wyświetlone: komunikat (pobrany za pomocą metody getMessage), kod błędu (pobrany za pomocą metody getCode), a także nazwa pliku (pobrana za pomocą metody getFile) oraz numer linii (pobrany za pomocą metody getLine), w których wystąpił błąd. W celu lepszego przećwiczenia sposobów obsługi błędów wykonajmy teraz bardziej konkretny przykład. Zadanie jest takie: trzeba napisać klasę o nazwie Kontener, której zadaniem będzie przechowywanie czterech wartości całkowitych (zapisanych w wewnętrznej tablicy). Odczyt tych wartości będzie możliwy za pomocą metody o nazwie getElement, której indeks żądanego elementu będzie przekazywany w postaci argu-<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 307<br /> <br /> mentu. Konieczne będzie zatem sygnalizowanie sytuacji, kiedy wartość przekazanego argumentu znajdzie się poza zakresem dopuszczalnych indeksów. Zobaczmy najpierw, jak będzie wyglądało wykonanie takiego zadania bez użycia wyjątków. Przykład działający w taki sposób został zaprezentowany na listingu 5.24. Listing 5.24. Wykorzystanie klasy kontener bez użycia wyjątków <?php class Kontener { protected $tab = array(100, 200, 300, 400); public function getElement($index) { if(!is_numeric($index)){ return false; } $index = (integer) $index; if($index < 0 || $index >= count($this->tab)){ return false; } else{ return $this->tab[$index]; } } } $kontener = new Kontener(); if($_SERVER['argc'] < 2){ exit("W wywołaniu należy podać wartość indeksu!"); } $index = $_SERVER['argv'][1]; $val = $kontener->getElement($index); if($val === false){ echo "Nieprawidłowy indeks!"; } else{ echo "Element o indeksie $index to $val."; } ?><br /> <br /> Klasa kontener zawiera chronione pole $tab będące w istocie czteroelementową tablicą zawierającą wartości całkowite 100, 200, 300 i 400. Publiczna metoda getElement ma za zadanie zwrócić wartość elementu o indeksie wskazanym przez argument $index. Działa ona w taki sposób, że jeśli wspomniany argument zawiera istniejącą wartość indeksu, wówczas metoda zwraca żądaną wartość, a w każdym innym przypadku zwraca false (indeks nienumeryczny lub indeks poza dopuszczalnym zakresem 0 – 3). Jeśli więc wynikiem działania getElement jest false, oznacza to wystąpienie błędu2. 2<br /> <br /> Zauważmy, że w taki właśnie sposób sygnalizuje wystąpienie błędu wiele funkcji dostępnych standardowo w PHP.<br /> <br /> 308<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Kod metody getElement zaczyna się od sprawdzenia, czy wartość argumentu $index może być interpretowana jako wartość numeryczna, co jest wykonywane za pomocą funkcji is_numeric. Jeśli nie jest to wartość numeryczna (np. przekazany został ciąg znaków abc), metoda zwraca wartość false i tym samym kończy swoje działanie. Jeśli jednak $index może być zinterpretowany jako wartość numeryczna, wartość ta jest konwertowana do typu integer. Po co ta konwersja? Załóżmy na przykład, że jako wartość indeksu został przekazany ciąg znaków 001. Funkcja is_numeric stwierdzi, że jest to wartość numeryczna, jednak w tablicy $tab nie ma klucza o nazwie 001. Dlatego dla prawidłowego działania kodu jest niezbędna konwersja do typu integer (konwersja przykładowego ciągu 001 do typu integer da w wyniku wartość całkowitą 1). Kolejny krok to sprawdzenie, czy wartość przekazana w argumencie nie przekracza dopuszczalnego zakresu indeksów. Ta czynność jest wykonywana za pomocą instrukcji warunkowej if. Wiadomo przecież, że indeks nie może być ani mniejszy od zera, ani większy niż całkowita liczba elementów tablicy pomniejszona o jeden (pamiętamy, że tablica jest numerowana od 0, czyli pierwsza wartość ma indeks 0). Jeśli zatem wartość argumentu $index zawiera się w wymienionym przedziale, to zwracana jest zawartość odpowiedniego klucza tablicy, a w przeciwnym razie — wartość false. W dalszej części skryptu tworzony jest i przypisywany zmiennej $kontener obiekt klasy Kontener. Skrypt ma być wywoływany w wierszu poleceń w taki sposób, aby można było jednocześnie przekazać mu wartość żądanego indeksu. W ten sposób łatwo będziemy mogli obserwować jego zachowanie w różnych sytuacjach. Oznacza to jednak, że trzeba odczytać przekazane przez użytkownika wartości. Odbywa się to za pomocą superglobalnej tablicy $_SERVER (por. opis w rozdziale 7.). Klucz argc tej tablicy zawiera całkowitą liczbę argumentów przekazanych w wierszu poleceń, natomiast klucz argv — tablicę zawierającą poszczególne argumenty. Chodzi jednak o argumenty przekazane nie skryptowi, ale aparatowi wykonawczemu PHP. Jeśli więc wydamy przykładowe polecenie: php index.php arg1 arg2<br /> <br /> oznacza to wywołanie aplikacji php i przekazanie jej argumentów index.php, arg1 i arg2. A zatem jest to polecenie wykonania przez aplikację php skryptu o nazwie index.php. Wewnątrz tego skryptu w tablicy $_SERVER pod kluczem argc będzie się znajdowała wartość 3 (jako że aplikacji php zostały przekazane trzy argumenty). Pod indeksem argv będzie się natomiast znajdowała trójelementowa tablica zawierająca kolejne argumenty. Pod indeksem 0 będzie ciąg znaków index.php, pod indeksem 1 — arg1, a pod 2 — arg2. Jeśli więc napiszemy: $index = $_SERVER['argv'][1];<br /> <br /> będzie to oznaczało: przypisz zmiennej $index wartość drugiego (czyli o indeksie 1) elementu tablicy $_SERVER['argv']. Powracając jednak do skryptu z listingu 5.24 — bada on, czy w wierszu poleceń został przekazany przynajmniej jeden argument, a zatem czy wartość zapisana w $_SERVER[ 'argc'] jest co najmniej równa 2 (zgodnie z podanymi wyżej wyjaśnieniami), a następnie przypisuje wartość argumentu (odczytaną z tablicy $_SERVER['argv']) zmiennej $index. Zmienna ta jest dalej wykorzystywana jako argument metody getElement<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 309<br /> <br /> obiektu $kontener. W zależności od wartości zwróconej przez tę metodę na ekranie wyświetla się albo poszukiwana wartość, albo komunikat o błędzie. Kilka przykładowych wywołań skryptu zostało przedstawionych na rysunku 5.14. Rysunek 5.14. Efekt przykładowych wywołań skryptu<br /> <br /> Skoro wiadomo już, jak tego typu przykład funkcjonowałby przed epoką wyjątków, zobaczmy, jak zmieni się przy ich wykorzystaniu. Odpowiedni kod został zaprezentowany na listingu 5.25. Ogólna struktura skryptu jest bardzo podobna do poprzedniej wersji, zupełnie inny jest jednak sposób sygnalizowania błędów. Tym razem nie będzie już sytuacji, gdy wartość zwracana przez metodę getElement raz jest prawidłowa, a innym razem sygnalizuje wystąpienie błędu3. Listing 5.25. Wykorzystanie klasy Kontener z użyciem wyjątków <?php class Kontener { protected $tab = array(100, 200, 300, 400); public function getElement($index) { if(!is_numeric($index)){ throw new InvalidArgumentException("Nieprawidłowy argument"); } $index = (integer) $index; if($index < 0 || $index >= count($this->tab)){ throw new InvalidArgumentException("Nieprawidłowy argument"); } else{ return $this->tab[$index]; } } } $kontener = new Kontener(); if($_SERVER['argc'] < 2){ exit("W wywołaniu należy podać wartość indeksu!"); } $index = $_SERVER['argv'][1]; 3<br /> <br /> Warto tu wyobrazić sobie taką sytuację, że tablica tab może zawierać wartości dowolnego typu (w tym również typu boolean). Jak wtedy bez użycia wyjątków sygnalizować wystąpienie błędu? Wymagałoby to stosowania dodatkowych, niezbyt wygodnych konstrukcji programistycznych.<br /> <br /> 310<br /> <br /> PHP5. Praktyczny kurs try{ $val = $kontener->getElement($index); } catch(InvalidArgumentException $e){ echo "Wystąpił błąd: ", $e->getMessage(); exit(); } echo "Element o indeksie $index to $val."; ?><br /> <br /> W przypadku stwierdzenia (w metodzie getElement), że argument $index nie jest wartością numeryczną bądź też że jego wartość przekracza dopuszczalny zakres indeksów, jest zgłaszany wyjątek typu InvalidArgumentException. Jednocześnie instrukcja wywołująca metodę getElement jest ujęta w blok try…catch, dzięki czemu wyjątek może zostać przechwycony. W bloku catch, w przypadku wystąpienia wyjątku, wyświetlany jest przenoszony przez niego komunikat, który jest pobierany za pomocą metody getMessage.<br /> <br /> Przechwytywanie wielu wyjątków W dotychczasowych przykładach w jednym bloku try…catch przechwytywany był tylko jeden wyjątek. Tak jednak być nie musi — ta instrukcja może przechwytywać wiele wyjątków. Dokładniej mówiąc, po jednym bloku try może wystąpić wiele bloków catch przechwytujących różne typy wyjątków. Taką sytuację schematycznie można przedstawić następująco: try{ //instrukcje mogące spowodować wyjątek } catch(KlasaWyjątku1 identyfikatorWyjątku1){ //obsługa wyjątku 1 } catch(KlasaWyjątku2 identyfikatorWyjątku2){ //obsługa wyjątku 2 } /* ... dalsze bloki catch ... */ catch(KlasaWyjątkuN identyfikatorWyjątkuN){ //obsługa wyjątku N }<br /> <br /> Po wygenerowaniu wyjątku sprawdzane jest, czy jego typem jest KlasaWyjatku1 — jeśli tak, wykonywane są instrukcje z pierwszego bloku catch, a blok try…catch jest opuszczany. Jeżeli jednak typem wyjątku nie jest KlasaWyjatku1, sprawdzane jest, czy jest to KlasaWyjątku2 itd. Wróćmy zatem do ostatniego przykładu z poprzedniej części lekcji (listing 5.25). W metodzie getElement były rozpoznawane dwie błędne sytuacje. Pierwsza miała miejsce wtedy, gdy przekazany argument nie reprezentował prawidłowej wartości liczbowej, druga — kiedy wartość argumentu była poza dopuszczalnym zakresem. W obu jednak<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 311<br /> <br /> przypadkach postępowanie było identyczne — zgłoszenie wyjątku InvalidArgumentException. Skoro jednak można zastosować wiele bloków catch, można ten przykład rozbudować w taki sposób, aby reakcja na dwie opisane sytuacje była odmienna, tak by użytkownik otrzymywał dokładniejszy komunikat o błędzie. Tak działający kod został przedstawiony na listingu 5.26. Listing 5.26. Przechwytywanie wielu wyjątków <?php class Kontener { protected $tab = array(100, 200, 300, 400); public function getElement($index) { if(!is_numeric($index)){ throw new InvalidArgumentException( "Argument nie jest wartością liczbową."); } $index = (integer) $index; if($index < 0 || $index >= count($this->tab)){ throw new OutOfRangeException("Indeks poza zakresem."); } else{ return $this->tab[$index]; } } } $kontener = new Kontener(); if($_SERVER['argc'] < 2){ exit("W wywołaniu należy podać wartość indeksu!"); } $index = $_SERVER['argv'][1]; try{ $val = $kontener->getElement($index); } catch(InvalidArgumentException $e){ echo "Wystąpił błąd: ", $e->getMessage(); exit(); } catch(OutOfRangeException $e){ echo "Wystąpił błąd: ", $e->getMessage(); exit(); } echo "Element o indeksie $index to $val."; ?><br /> <br /> Tym razem w przypadku gdy funkcja is_numeric zwróci wartość false, czyli argument $index nie będzie reprezentował prawidłowej wartości liczbowej, zostanie wygenerowany wyjątek typu InvalidArgumentException zawierający komunikat o treści<br /> <br /> 312<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> „Argument nie jest wartością liczbową”. Natomiast w sytuacji gdy argument $index będzie miał wartość liczbową, ale wykraczającą poza dopuszczalny zakres indeksów, zostanie wygenerowany wyjątek OutOfRangeException zawierający komunikat „Indeks poza zakresem”. W bloku try, zgodnie z podanymi wyżej zasadami, przechwytywane są oba typy wyjątków. Reakcja jest taka sama — jest wyświetlana treść komunikatu zawartego w obiekcie $e. Zauważmy jednak, że równie dobrze reakcje te mogłyby być zupełnie różne. Gdyby więc istniała taka potrzeba, można by inaczej reagować na każdą z tych sytuacji. Efekt działania kilku przykładowych wywołań powyższego skryptu został przedstawiony na rysunku 5.15. Rysunek 5.15. Różne reakcje na różne rodzaje wywołań skryptu<br /> <br /> Przy stosowaniu wielu bloków catch należy jednak pamiętać o hierarchii wyjątków, nie jest bowiem obojętne, w jakiej kolejności będą przechwytywane. Ogólna zasada jest taka, że kolejność nie ma znaczenia, o ile wszystkie wyjątki są na jednym poziomie hierarchii. Jeśli jednak przechwytujemy wyjątki z różnych poziomów, najpierw muszą to być wyjątki bardziej szczegółowe, czyli stojące niżej w hierarchii, a dopiero po nich bardziej ogólne, czyli z wyższego poziomu. Jeśli spojrzymy teraz ponownie na rysunek 5.12, zobaczymy wyraźnie, że najwyżej w hierarchii są wyjątki typu Exception, poniżej te wyprowadzone z klasy Exception: LogicException i RuntimeException, a jeszcze niżej wyprowadzone z tych dwóch ostatnich klas. Jeśli nie zachowamy właściwej kolejności, wyjątki bardziej szczegółowe nigdy nie zostaną obsłużone, a dokładniej mówiąc, zostaną obsłużone jako wyjątki wyższego rzędu. Zobrazowano to w przykładzie widocznym na listingu 5.27. Listing 5.27. Zła kolejność przechwytywania wyjątków <?php try{ throw new OutOfRangeException(); } catch(Exception $e){ echo "Został wykonany blok dla wyjątku Exception."; } catch(OutOfRangeException $e){ echo "Został wykonany blok dla wyjątku OutOfRangeException."; } ?><br /> <br /> Po jego uruchomieniu okaże się, że mimo wygenerowania wyjątku OutOfRangeException został wykonany blok przynależny wyjątkowi Exception. Stało się tak dlatego, że Exception jest wyjątkiem bardziej ogólnym od OutOfRangeException i zawsze będzie<br /> <br /> Rozdział 5. ♦ Obiektowy PHP<br /> <br /> 313<br /> <br /> obsługiwany wcześniej. Prawidłowa jest zatem kolejność odwrotna: najpierw wyjątek bardziej szczegółowy (leżący niżej w hierarchii) — OutOfRangeException, a dopiero później ten bardziej ogólny (leżący wyżej w hierarchii) — Exception.<br /> <br /> Własne wyjątki Jeśli dostępne standardowo predefiniowane typy wyjątków są niewystarczające, nic nie stoi na przeszkodzie, aby zdefiniować własne. Utworzenie własnego wyjątku polega na wyprowadzeniu nowej klasy od klasy Exception lub dowolnej klasy od niej pochodnej. Można na przykład utworzyć wyjątek, który miałby być generowany w przypadku, gdy argument jest mniejszy od zera. Zapewne nazwalibyśmy go: ArgumentMniejszyOd ZeraException. Najprostsza definicja takiej klasy to: class ArgumentMniejszyOdZeraException extends Exception { }<br /> <br /> Jak widać, nie musi ona zawierać żadnego dodatkowego kodu. Zakładając teraz, że w skrypcie ma się pojawić funkcja o nazwie dodatniArgument, która będzie generowała wyjątek ArgumentMniejszyOdZeraException w przypadku otrzymania argumentu o wartości mniejszej od zera, wykorzystanie takiej klasy wyglądałoby tak jak na listingu 5.28. Efekt wykonania przedstawionego kodu został natomiast zaprezentowany na rysunku 5.16. Listing 5.28. Użycie wyjątku ArgumentMniejszyOdZeraException <?php class ArgumentMniejszyOdZeraException extends Exception { } function dodatniArgument($arg) { if($arg < 0){ throw new ArgumentMniejszyOdZeraException( "Argument mniejszy od zera: $arg."); } } try{ dodatniArgument(-1); } catch(ArgumentMniejszyOdZeraException $e){ echo "Wystąpił błąd: ", $e->getMessage(); } ?><br /> <br /> Rysunek 5.16. Efekt użycia klasy ArgumentMniejszy OdZeraException<br /> <br /> 314<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 19.1. Do klasy Kontener z listingu 5.25 dodaj metodę setElement, która będzie pozwalała na dodawanie nowych elementów do tablicy $tab. Ćwiczenie 19.2. Zmodyfikuj kod ćwiczenia 19.1 w taki sposób, aby metoda setElement umożliwiała jedynie modyfikację istniejących elementów tablicy, a przy próbie dodania nowego elementu generowała odpowiedni wyjątek. Ćwiczenie 19.3. Zmodyfikuj kod ćwiczenia 19.1 w taki sposób, aby metoda setElement umożliwiała jedynie dodawanie nowych elementów do tablicy, a przy próbie modyfikacji istniejącego elementu generowała odpowiedni wyjątek. Ćwiczenie 19.4. Napisz skrypt ilustrujący możliwości klas powstałych w ćwiczeniach 19.2 i 19.3. Ćwiczenie 19.5. Napisz taką klasę Kontener, w której wartość pobieranego elementu będzie przekazywana za pomocą wyjątku.<br /> <br /> Rozdział 6.<br /> <br /> Grafika i obrazy Lekcja 20. Obsługa grafiki Biblioteka graficzna PHP umożliwia zarówno wykonywanie różnorodnych operacji na obrazach, jak i generowanie plików graficznych. Wraz z PHP jest w tym celu dostarczana standardowo biblioteka GD1 (dostępna również pod adresem http://www.libgd.org/ lub http://www. boutell.com/gd/). W przypadku systemu Windows uaktywnienie funkcji graficznych uzyskamy przez usunięcie komentarza (początkowego średnika) z wiersza: extension=php_gd2.dll<br /> <br /> znajdującego się w pliku php.ini (oczywiście o ile ten wiersz jest ujęty w komentarz — poprzedzony średnikiem). W przypadku Linuksa w pakietach dla poszczególnych dystrybucji biblioteka GD jest zwykle dołączana standardowo i nie trzeba wykonywać dodatkowych czynności. Aby włączyć obsługę biblioteki GD w przypadku samodzielnej kompilacji pakietów PHP, należy podczas konfiguracji podać dodatkową opcję: --with-gd<br /> <br /> jeśli chcemy korzystać z biblioteki dostarczonej wraz z PHP lub: --with-gd=nazwa_katalogu<br /> <br /> jeśli chcemy korzystać z zewnętrznej wersji biblioteki, np. pobranej spod podanego wyżej adresu. W tym przypadku parametr nazwa_katalogu powinien wskazywać katalog, w którym ta biblioteka została zainstalowana.<br /> <br /> 1<br /> <br /> Jako rozszerzenia dostępne są też inne biblioteki, np. ImageMagic, Gmagick, Cairo. Dokładne informacje o nich można znaleźć w dokumentacji PHP.<br /> <br /> 316<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> W celu przekonania się, czy dana wersja PHP ma włączoną obsługę biblioteki GD, można użyć funkcji o nazwie gd_info. Zwraca ona tablicę asocjacyjną zawierającą informacje o konfiguracji. Wystarczy zatem wywołać skrypt przedstawiony na listingu 6.1. Listing 6.1. Informacje o zainstalowanej bibliotece graficznej <?php $arr = gd_info(); foreach($arr as $key => $val){ echo "$key = $val\n"; } ?><br /> <br /> Przykładowy efekt działania kodu w konsoli systemu Windows został zaprezentowany na rysunku 6.1 (skrypt można też wywołać w przeglądarce, dodając jednak dla formatowania znacznik <br />). W sytuacji gdy wykonanie skryptu nie spowoduje wyświetlania informacji lub też pojawi się komunikat o nieznanej funkcji gd_info, będzie to oznaczać, że obsługa biblioteki GD nie została włączona. Rysunek 6.1. Informacje o wersji i opcjach biblioteki graficznej GD<br /> <br /> Jak stworzyć galerię obrazów? Zanim przejdziemy do procedur przetwarzających grafikę, spróbujmy zająć się bardzo popularnym tematem tworzenia galerii obrazów. W większości wypadków nie wymaga to wykorzystywania funkcji udostępnianych przez bibliotekę GD — wystarczą zdobyte do tej pory wiadomości dotyczące języka PHP, w tym współpracy z przeglądarką (lekcje z rozdziału 4.) oraz systemem plików (lekcje z rozdziału 3.). Stwórzmy więc kilka przykładowych galerii.<br /> <br /> Prosta galeria Najprostsza galeria wyświetla pojedyncze obrazy wraz z odnośnikami nawigacyjnymi, tak jak zostało to zaprezentowane na rysunku 6.2. Jej utworzenie nie powinno sprawić żadnego kłopotu. Pliki z obrazami zapiszemy w osobnym katalogu, np. o nazwie images. Skrypt oczywiście uwzględni automatycznie wszelkie zmiany zawartości tego katalogu, nie trzeba więc będzie troszczyć się o ręczną aktualizację danych. Aby jednak nie komplikować kodu skryptu, przyjęte zostanie założenie, że katalog nie może<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 317<br /> <br /> Rysunek 6.2. Przykładowy wygląd galerii<br /> <br /> zawierać innych plików niż pliki galerii ani podkatalogów. Będzie się w nim też musiał znajdować co najmniej jeden plik graficzny. Numer wyświetlanego obrazu będzie przekazywany do skryptu za pomocą metody GET w postaci parametru o nazwie imgid. Obrazy będą wyświetlane w kolejności alfabetycznej (według nazw plików), pierwszy z nich będzie miał identyfikator 0, drugi — 1 itd. Na każdej stronie galerii, tak jak jest to widoczne na rysunku 6.2, będą wyświetlane:  obraz (umieszczany na stronie za pomocą znacznika <img>),  nazwa pliku graficznego,  numer obrazu (numeracja będzie się rozpoczynać od 1),  całkowita liczba obrazów,  odnośniki do pierwszego, poprzedniego, następnego i ostatniego obrazu.<br /> <br /> Skrypt generujący tak określoną galerię został przedstawiony na listingu 6.2. Przyjrzyjmy się mu bliżej. Listing 6.2. Prosta galeria obrazów <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Galeria obrazów</title><br /> <br /> 318<br /> <br /> PHP5. Praktyczny kurs </head> <body> <?php $imgDir = "./images"; //odczytanie parametru if(isSet($_GET['imgid'])){ $imgId = $_GET['imgid']; } else{ $imgId = 0; } //odczytanie zawartości katalogu $dir = scandir($imgDir); array_shift($dir); array_shift($dir); $count = count($dir); //sprawdzenie poprawności parametru if($imgId < 0 || $imgId >= $count || !is_Numeric($imgId)){ $imgId = 0; } //ustalenie nazwy bieżącego obrazu oraz //identyfikatorów obrazów dla odnośników $imgName = $dir["$imgId"]; $first = 0; $last = $count - 1; if($imgId < $count - 1){ $next = $imgId + 1; } else{ $next = $count - 1; } if($imgId > 0){ $prev = $imgId - 1; } else{ $prev = 0; } ?> <div> <div id='obraz' style='text-align:center'> <?php echo "<img src=\"$imgDir/$imgName\" alt=\"$imgName\" />"; ?> </div> <div id='opis' style='text-align:center'> <?php $imgId++; echo "Obraz $imgName ($imgId z $count)"; ?> </div> <div id='nawigacja' style='text-align:center'><br /> <br /> Rozdział 6. ♦ Grafika i obrazy <?php echo "<a echo "<a echo "<a echo "<a ? rel="nofollow"> </div> </div> </body> </html><br /> <br /> 319<br /> <br /> href=\"galeria.php?imgid=$first\">Pierwszy</a> "; href=\"galeria.php?imgid=$prev\">Poprzedni</a> "; href=\"galeria.php?imgid=$next\">Następny</a> "; href=\"galeria.php?imgid=$last\">Ostatni</a> ";<br /> <br /> Kod rozpoczyna się od ustawienia zmiennej $imgDir wskazującej katalog, w którym będą umieszczane obrazy (musi to być katalog dostępny przez serwer WWW). W tym przypadku jest to podkatalog images katalogu, w którym będzie umieszczony skrypt galeria.php. Następnie za pomocą instrukcji warunkowej if sprawdzane jest, czy do skryptu został przekazany parametr imgid, czyli czy w tablicy $_GET jest klucz o nazwie imgid. Jeśli tak, jego wartość jest odczytywana, konwertowana za pomocą funkcji intval do typu integer (por. lekcja 4. z rozdziału 2.) i przypisywana zmiennej $imgId, w przeciwnym razie wartość zmiennej $imgId jest ustawiana na 0. Po wykonaniu tych wstępnych czynności za pomocą funkcji scandir odczytywana jest zawartość katalogu wskazywanego przez $imgDir i przypisywana zmiennej $dir. Jak wiadomo z lekcji 10. (rozdział 3.), wynikiem działania scandir jest tablica zawierająca wszystkie elementy wskazanego katalogu (dlatego też powinny się w nim znajdować wyłącznie pliki graficzne galerii) posortowane w kolejności alfabetycznej. Pierwsze dwa elementy tej tablicy to wskazanie do katalogu bieżącego (.) oraz nadrzędnego (..)2, dlatego też są one usuwane za pomocą dwóch wywołań funkcji array_shift (funkcja array_shift usuwa z tablicy pierwszą komórkę, czyli pierwszy indeks). Następnie za pomocą wywołania funkcji count pobierana jest i zapisywana w zmiennej $count całkowita liczba obrazów, a za pomocą instrukcji if następuje sprawdzenie poprawności parametru zapisanego w zmiennej $imgId. Nie można bowiem zakładać, że do skryptu została przekazana na pewno poprawna wartość. Dlatego też jest sprawdzane, czy wartość $imgId jest:  mniejsza od 0,  większa od maksymalnej możliwej wartości ($count - 1),<br /> <br /> Jeśli jeden z tych warunków jest prawdziwy (czyli kiedy zostanie stwierdzona nieprawidłowość przekazanych danych), zmiennej $imgId jest przypisywana wartość 0, co oznacza, że zostanie wyświetlony pierwszy obraz. Po ostatecznym ustaleniu identyfikatora wyświetlanego obrazu są ustawiane wartości zmiennych, które w dalszej części posłużą jako parametry dla znaczników HTML. Są to:  $imgName — nazwa pliku graficznego pobrana z tablicy $dir,  $first — identyfikator pierwszego obrazu (czyli 0), 2<br /> <br /> Wyjątkiem jest sytuacja, gdy parametrem przekazanym funkcji scandir jest nazwa katalogu głównego.<br /> <br /> 320<br /> <br /> PHP5. Praktyczny kurs  $last — identyfikator ostatniego obrazu, czyli liczba elementów tablicy $dir pomniejszona o 1 ($dir - 1),  $next — identyfikator następnego obrazu, czyli wartość aktualnego identyfikatora powiększona o 1 ($imgId + 1),  $prev — identyfikator poprzedniego obrazu, czyli wartość aktualnego identyfikatora pomniejszona o 1 ($imgId - 1).<br /> <br /> Należy przy tym zwrócić uwagę, że jeśli aktualny identyfikator ma wartość 0, to wartością $prev powinno być 0 (nie ma bowiem wcześniejszego obrazu) — i analogicznie jeśli aktualny identyfikator ma wartość równą identyfikatorowi ostatniego obrazu, to wartością $next powinien być właśnie on (nie ma bowiem następnego obrazu). Wszystkie zebrane w opisany sposób dane pozwalają na wygenerowanie znacznika <img> w postaci: <img src=\"$imgDir/$imgName\" alt=\"$imgName\" /><br /> <br /> np.: <img src="./images/obraz001.jpg" alt="obraz001.jpg" /><br /> <br /> oraz odnośników:  <a href="galeria.php?imgid=$first" rel="nofollow">Pierwszy</a> — do obrazu<br /> <br /> pierwszego,  <a href="galeria.php?imgid=$prev" rel="nofollow">Poprzedni</a> — do obrazu<br /> <br /> poprzedniego,  <a href="galeria.php?imgid=$next" rel="nofollow">Następny</a> — do obrazu następnego,  <a href="galeria.php?imgid=$last" rel="nofollow">Ostatni</a> — do obrazu ostatniego,  oraz pozostałych danych: nazwy pliku graficznego ($imgName), numeru aktualnego obrazu ($imgId + 1), całkowitej liczby obrazów ($count).<br /> <br /> Galeria z miniaturami obrazów Nieco bardziej złożonym przykładem jest galeria zawierająca miniatury obrazów (taka jak zaprezentowana na rysunku 6.3). U góry strony wyświetlana jest pewna liczba miniatur (zdefiniowana w kodzie skryptu). Kliknięcie każdej z nich powoduje wyświetlenie w dolnej części strony wybranego obrazu w pełnej rozdzielczości. Pod miniaturkami znajdują się z kolei odnośniki pozwalające na nawigację pomiędzy kolejnymi stronami miniatur. Spróbujmy napisać skrypt tworzący taką galerię. Zacznijmy od przygotowania obrazów. Pliki graficzne zawierające zdjęcia w pełnej rozdzielczości zapiszemy w podkatalogu o nazwie images, natomiast miniatury w podkatalogu thumbnails. Miniatury można przygotować w dowolnym programie graficznym. Oba podkatalogi zapiszemy w katalogu, w którym będzie znajdował się skrypt realizujący funkcje galerii. Skrypt nazwiemy galeria.php. Oczywiście wszystkie wymienione nazwy można zmieniać według własnych potrzeb, będzie to jednak wymagało uwzględnienia wprowadzonych zmian w kodzie. Należy zwrócić przy tym uwagę,<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 321<br /> <br /> Rysunek 6.3. Galeria zawierająca miniatury obrazów<br /> <br /> aby w podkatalogach przeznaczonych do umieszczania plików galerii znajdowały się jedynie pliki graficzne, ponieważ skrypt nie będzie sprawdzał typów plików (weryfikacja zostanie pominięta w celu uproszczenia kodu). Zastanówmy się teraz, jak ma wyglądać struktura strony zawierającej galerię. Może być ona zrealizowana na kilka sposobów. Najprościej jest użyć kilku warstw (które można dowolnie ostylować) albo też do formatowania użyć zwykłej tabeli (choć nie jest to obecnie sposób zalecany). Skorzystajmy zatem z trzech warstw. Górna będzie przechowywać obrazy miniatur, środkowa — odnośniki do kolejnych stron z miniaturami, a dolna — wybrany przez użytkownika obraz w pełnej rozdzielczości. Struktura ta będzie miała zatem schematyczną postać: <div id='miniatury' style='text-align:center'> <!-- lista miniatur --> </div> <div id='nawigacja' style='text-align:center'> <!-- odnośniki do kolejnych stron z miniaturami --> </div> <div id='obraz' style='text-align:center'> <!-- obraz w pełnej rozdzielczości--> </div><br /> <br /> Do skryptu będą przekazywane dwa argumenty:<br /> <br /> 322<br /> <br /> PHP5. Praktyczny kurs  pid — (od page id) określający numer strony z miniaturkami, która ma zostać<br /> <br /> wyświetlona w górnej części witryny.  iid — (od image id) określający numer obrazu, który ma zostać wyświetlony<br /> <br /> w dolnej części witryny. Miniatury powinny mieć takie same nazwy jak właściwe pliki z grafiką i być według nich ustawione w kolejności alfabetycznej. Ponieważ liczba obrazów w galerii nie będzie z góry ustalana (tak aby można było ją aktualizować jedynie przez zmianę zawartości katalogów z grafiką), niezbędne będzie obliczanie liczby stron z miniaturami, co będzie się odbywało według prostego wzoru: liczba stron = całkowita liczba miniatur / liczba miniatur na pojedynczej stronie<br /> <br /> Kod skryptu generującego galerię został przedstawiony na listingu 6.3. W celu zaoszczędzenia miejsca zostały w nim pominięte wstępne znaczniki HTML, które są takie same jak w poprzednim przykładzie. Listing 6.3. Skrypt generujący galerię z miniaturami obrazów <!-- początek kodu HTML jak w przykładzie z listingu 6.2 --> <body> <?php $imgDir = "./images"; $thumbDir = "./thumbnails"; $thOnPage = 5; if(isSet($_GET['iid']) && isSet($_GET['pid'])){ $iId = $_GET['iid']; $pId = $_GET['pid']; } else{ $iId = 0; $pId = 0; } $dir = scandir($thumbDir); array_shift($dir); array_shift($dir); $count = count($dir); $pages = ceil($count / $thOnPage); if($iId < 0 || $iId > $count || $pId < 0 || $pId > $pages){ $iId = 0; $pId = 0; } ?> <div id='miniatury' style='text-align:center'> <?php for($i = 0; $i < $thOnPage; $i++){ $imgNo = $pId * $thOnPage + $i; if($imgNo >= $count) break; $imgName = $dir[$imgNo];<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 323<br /> <br /> $imgTag = "<img src=\"$thumbDir/$imgName\" alt=\"$imgName\" />\n"; $aHead = "<a href=\"./galeria.php?pid=$pId&iid=$imgNo\" rel="nofollow">"; $aFoot = "</a>"; echo "$aHead $imgTag $aFoot\n";<br /> <br /> } ?> </div> <div id='nawigacja' style='text-align:center'> Idź do strony: <?php for($i = 0; $i < $pages; $i++){ echo "<a href=\"./galeria.php?pid=$i&iid=$iId\" rel="nofollow">$i</a> "; } ?> </div> <div id='obraz' style='text-align:center'> <?php $imgName = $dir[$iId]; echo "<img src=\"$imgDir/$imgName\" alt=\"$imgName\" />\n"; ?> </div> </body> </html><br /> <br /> Kod rozpoczyna się od ustawienia zmiennych, które zawierają: nazwę katalogu z obrazami ($imgDir), nazwę katalogu z miniaturami ($thumbDir) oraz liczbę miniatur wyświetlanych na pojedynczej stronie ($thOnPage). Dzięki temu wszelkie modyfikacje tych parametrów będą mogły być wykonywane w prosty sposób w jednym miejscu. Następnie ma miejsce sprawdzenie, czy do skryptu zostały przekazane parametry pid i iid. Jeśli tak, ich wartości za pomocą funkcji intval są konwertowane na liczby całkowite i przypisywane zmiennym $pid i $iid, jeśli nie — zmienne te otrzymują wartość 0. Oznacza to, że wywołanie skryptu bez podania parametrów spowoduje, iż zostaną wyświetlone strona miniatur oraz obraz, które będą miały indeks 0. Kolejne instrukcje to wczytanie i zapisanie w zmiennej $dir zawartości katalogu z miniaturami oraz usunięcie dwóch pierwszych komórek tej tablicy, czyli pozbycie się wskazań do katalogu bieżącego i nadrzędnego. Te czynności są wykonywane dokładnie w ten sam sposób jak w poprzednim przykładzie. Po wczytaniu danych następuje obliczenie całkowitej liczby plików (zmienna $count) oraz wynikającej z niej liczby stron z miniaturami (zmienna $pages). Ponieważ w tym drugim przypadku wynik może być liczbą z częścią ułamkową, jest on zaokrąglany do liczby całkowitej za pomocą funkcji ceil (zaokrąglenie w górę). Gdy znamy już zarówno całkowitą liczbę plików, jak i liczbę stron z miniaturami, a zatem również zakres wartości, jakie mogą przyjmować zmienne $iId i $pId, dokonujemy weryfikacji danych. Nie można bowiem zakładać, że dane przesłane do skryptu na pewno są poprawne. W przypadku stwierdzenia jakiejkolwiek nieprawidłowości (wartości poza dopuszczalnym zakresem) zmiennym $iId i $pId zostaną przypisane wartości 0, czyli skrypt zachowa się tak, jakby nie zostały mu przekazane żadne parametry. Po przeprowadzeniu wszystkich opisanych procedur można już przystąpić do wygenerowania górnego wiersza zawierającego obrazy miniatur. Proces ten odbywa się w pętli<br /> <br /> 324<br /> <br /> PHP5. Praktyczny kurs for, która ma tyle przebiegów, ile miniatur ma się znaleźć na stronie. Wewnątrz pętli najpierw jest obliczany indeks aktualnie przetwarzanej miniatury (zmienna $imgNo), który wynika ze wzoru: indeks obrazu = indeks wyświetlanej strony * liczba miniatur na stronie + $i<br /> <br /> Gdyby się okazało, że tak wyliczona wartość jest większa od całkowitej liczby obrazów lub jej równa, pętla zostanie przerwana. Oznacza to bowiem, że przetwarzana jest ostatnia strona z miniaturami, na której liczba miniatur może być mniejsza niż na pozostałych stronach. Po obliczeniu indeksu aktualnej miniatury z tablicy $dir jest odczytywana (i zapisywana w zmiennej $imgName) nazwa odpowiadającego jej pliku. Pozwala to na skonstruowanie znacznika <img> w postaci: <img src="$thumbDir/$imgName" alt="$imgName" /><br /> <br /> który jest przypisywany zmiennej $imgTag. Konstruowany jest również znacznik <a>, który spowoduje, że miniatura będzie jednocześnie odnośnikiem pozwalającym na wyświetlenie odpowiadającego jej obrazu w pełnej rozdzielczości. Znacznik ten przyjmuje postać: <a href="./galeria.php?pid=$pId&iid=$imgNo" rel="nofollow"> znacznik <img> </a><br /> <br /> W kodzie został on rozbity na dwie części — $aHead i $aFoot — tak aby w prosty sposób można było skonstruować zawartość wysyłaną do przeglądarki za pomocą instrukcji echo. Przyjmuje ona postać: echo "$aHead $imgTag $aFoot";<br /> <br /> Należy zwrócić uwagę na sposób zapisania znaku & w postaci &. Jest to niezbędne, aby zachować zgodność z obowiązującymi standardami HTML. Druga część strony (druga warstwa <div>) musi zawierać odnośniki do wszystkich stron z miniaturami. Jej konstrukcja nie jest skomplikowana. Odnośniki są generowane w pętli for, a każdy z nich ma postać: <a href="./galeria.php?pid=$i&iid=$iId" rel="nofollow">$i</a> <br /> <br /> Jak widać, zmienia się tu wartość parametru pid, natomiast wartością iid jest indeks aktualnie wyświetlanego obrazu. Dzięki temu obraz w pełnej rozdzielczości wyświetlany w dolnej komórce tabeli będzie się zmieniał tylko na wyraźne życzenie użytkownika przeglądającego galerię, gdy kliknie on wybraną miniaturę. Równie prosta jest konstrukcja ostatniego, dolnego wiersza witryny (trzeciej warstwy <div>). Powinien się w nim znaleźć jedynie znacznik <img> powodujący wyświetlenie<br /> <br /> wybranego przez użytkownika obrazu. Nazwa pliku z tym obrazem jest pobierana z tablicy $dir (jej indeks jest zapisany w zmiennej $iId) i przypisywana pomocniczej zmiennej $imgName. Następnie konstruowany jest znacznik <img> w postaci: <img src="$imgDir/$imgName" alt="$imgName" /><br /> <br /> który jest wysyłany do przeglądarki za pomocą instrukcji echo.<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 325<br /> <br /> Przetwarzanie grafiki Tworzenie obrazu W celu utworzenia nowego obrazu w pamięci należy wykorzystać funkcję imagecreate3 truecolor , której jako argumenty przekazuje się szerokość i wysokość obrazu. Schematyczne wywołanie ma zatem postać: imagecreatetruecolor(szerokość, wysokość)<br /> <br /> Funkcja zwraca identyfikator obrazu (wartość typu resource), który pozwala na dalsze operacje. Gdy obraz utworzony za pomocą imagecreatetruecolor nie będzie już potrzebny, powinien zostać usunięty z pamięci za pomocą wywołania imagedestroy. Funkcja imagedestroy zwraca wartość true, jeśli operacja się powiedzie, lub false w przeciwnym wypadku. Konstrukcja skryptu (dla przykładowego obrazu o rozmiarach 200×100 pikseli) powinna być więc następująca: <?php $wysokosc = 100; $szerokosc = 200; $img = imagecreatetruecolor($szerokosc, $wysokosc); //operacje na obrazie imagedestroy($img); ?><br /> <br /> W przypadku gdy chcemy wczytać obraz z pliku graficznego, należy użyć funkcji dedykowanej dla danego formatu graficznego4:  imagecreatefromgif — dla formatu GIF,  imagecreatefromjpeg — dla formatu JPEG,  imagecreatefrompng — dla formatu PNG.<br /> <br /> Każda z nich przyjmuje jako argument nazwę pliku graficznego (o ile konfiguracja środowiska na to pozwala, może być to też ciąg wskazujący URL obrazu). Wczytanie zawartości przykładowego pliku o nazwie obraz1.jpg, który znajduje się w katalogu /var/www/images, osiągniemy przez wykonanie instrukcji: $img = imagecreatefromjpeg("/var/www/images/obraz1.jpg");<br /> <br /> a gdy ten obraz znajduje się w katalogu c:\www\obrazy\, dzięki instrukcji: $img = imagecreatefromjpeg("c:\\www\\obrazy\\obraz1.jpg");<br /> <br /> lub: $img = imagecreatefromjpeg("c:/www/obrazy/obraz1.jpg");<br /> <br /> 3<br /> <br /> Można także użyć funkcji imagecreate, zaleca się jednak korzystanie z imagecreatetruecolor.<br /> <br /> 4<br /> <br /> Dostępne są także funkcje dla mniej popularnych formatów, np. gd2, bmp, xpm itp. Ich opis można znaleźć w dokumentacji PHP.<br /> <br /> 326<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Zapisywanie plików graficznych Obraz utworzony w pamięci (niezależnie od tego, jak ta czynność została wykonana) może być w prosty sposób zapisany do pliku lub wysłany do standardowego wyjścia (np. przeglądarki). W zależności od wybranego formatu należy użyć jednej z dedykowanych funkcji:  imagegif — dla formatu GIF,  imagejpeg — dla formatu JPEG,  imagepng — dla formatu PNG.<br /> <br /> Każda z nich przyjmuje dwa argumenty — pierwszy określa obraz, natomiast drugi nazwę pliku. Jeśli parametr określający nazwę pliku zostanie pominięty, obraz jest wysyłany do standardowego wyjścia. Aby na przykład zapisać na dysku plik typu JPEG o nazwie image.jpg utworzony z obrazu wskazywanego przez zmienną $img, zastosujemy konstrukcję: imagejpeg($img, "image.jpg");<br /> <br /> aby natomiast wysłać taki obraz do przeglądarki — konstrukcję5: imagejpeg($img);<br /> <br /> Funkcje imagejpg oraz imagepng mogą też przyjmować trzeci argument określający jakość pliku wynikowego. W przypadku imagejpg jest to wartość od 0 do 100, przy czym 0 oznacza największą kompresję i największą utratę jakości (ale najmniejszy rozmiar pliku wynikowego), natomiast 100 — najmniejszą kompresję i najmniejszą utratę jakości (ale największy rozmiar pliku wynikowego). W przypadku imagepng jest to wartość od 0 do 9, gdzie 0 oznacza brak kompresji, a 9 największą kompresję6. Jeżeli stosowany jest trzeci argument, a obraz powinien być wysłany do przeglądarki, jako nazwy pliku (drugi argument) należy użyć wartości null, np.: imagejpeg($img, null, 85);<br /> <br /> Kolory Wiele funkcji operujących na obrazie wymaga podania w postaci argumentu koloru, który ma być użyty (np. funkcja rysująca linie wymaga podania koloru linii). Aby jednak móc skorzystać z danego koloru, niezbędne jest wcześniejsze jego zaalokowanie, które odbywa się przez wywołanie funkcji imagecolorallocate. Jej wywołanie ma postać: imagecolorallocate($obraz, czerwony, zielony, niebieski)<br /> <br /> gdzie $obraz to identyfikator zwrócony przez jedną z funkcji tworzących obraz, natomiast pozostałe argumenty określają poszczególne składowe koloru w formacie RGB. Mogą być one podawane w postaci dziesiętnej lub szesnastkowej. Wybrane kolory 5<br /> <br /> W takim przypadku niezbędne byłoby również wcześniejsze wysłanie odpowiedniego nagłówka HTTP.<br /> <br /> 6<br /> <br /> Ten argument jest dostępny od PHP w wersji 5.1.2. Począwszy od wersji 5.1.3, jest też możliwe stosowanie czwartego argumentu określającego filtry, jakie mają być zastosowane do obrazu.<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 327<br /> <br /> i odpowiadające im składowe RGB zostały przedstawione w tabeli 6.1. Funkcja imagecolorallocate zwraca identyfikator koloru lub wartość false (w wersjach PHP poniżej 5.1.3 — –1), jeśli jej działanie nie zakończyło się powodzeniem. Przykładowo, uzyskanie indeksu koloru czerwonego dla obrazu wskazywanego przez zmienną $img będzie wymagało wywołania w postaci: $czerwony = imagecolorallocate($img, 255, 0, 0);<br /> <br /> lub: $czerwony = imagecolorallocate($img, 0xFF, 0, 0);<br /> <br /> Tabela 6.1. Wybrane kolory i odpowiadające im składowe RGB Kolor<br /> <br /> Składowa R<br /> <br /> Składowa G<br /> <br /> Składowa B<br /> <br /> Beżowy<br /> <br /> 245<br /> <br /> 245<br /> <br /> 220<br /> <br /> Biały<br /> <br /> 255<br /> <br /> 255<br /> <br /> 255<br /> <br /> Błękitny<br /> <br /> 0<br /> <br /> 191<br /> <br /> 255<br /> <br /> Brązowy<br /> <br /> 139<br /> <br /> 69<br /> <br /> 19<br /> <br /> 0<br /> <br /> 0<br /> <br /> 0<br /> <br /> Czerwony<br /> <br /> 255<br /> <br /> 0<br /> <br /> 0<br /> <br /> Ciemnoczerwony<br /> <br /> 192<br /> <br /> 0<br /> <br /> 0<br /> <br /> 0<br /> <br /> 0<br /> <br /> 139<br /> <br /> 169<br /> <br /> 169<br /> <br /> 169<br /> <br /> 0<br /> <br /> 100<br /> <br /> 0<br /> <br /> Fiolet<br /> <br /> 238<br /> <br /> 130<br /> <br /> 238<br /> <br /> Koralowy<br /> <br /> 255<br /> <br /> 127<br /> <br /> 80<br /> <br /> Niebieski<br /> <br /> 0<br /> <br /> 0<br /> <br /> 255<br /> <br /> Oliwkowy<br /> <br /> 128<br /> <br /> 128<br /> <br /> 0<br /> <br /> Purpurowy<br /> <br /> 128<br /> <br /> 0<br /> <br /> 128<br /> <br /> Srebrny<br /> <br /> 192<br /> <br /> 192<br /> <br /> 192<br /> <br /> 70<br /> <br /> 130<br /> <br /> 180<br /> <br /> 128<br /> <br /> 128<br /> <br /> 128<br /> <br /> Czarny<br /> <br /> Ciemnoniebieski Ciemnoszary Ciemnozielony<br /> <br /> Stalowoniebieski Szary<br /> <br /> 0<br /> <br /> 255<br /> <br /> 0<br /> <br /> Żółtozielony<br /> <br /> 192<br /> <br /> 255<br /> <br /> 62<br /> <br /> Żółty<br /> <br /> 255<br /> <br /> 255<br /> <br /> 0<br /> <br /> Zielony<br /> <br /> Jeśli chcemy wypełnić wybranym kolorem pewien obszar obrazu, można skorzystać z funkcji imagefill, której wywołanie ma postać: imagefill($obraz, wspx, wspy, kolor);<br /> <br /> gdzie $obraz określa obraz, wspx i wspy — współrzędną punktu, od którego rozpocznie się procedura wypełniania, a kolor — kolor wypełnienia. Aby na przykład w obrazie wskazywanym przez zmienną $img wypełnić kolorem niebieskim obszar rozpoczynający się od punktu o współrzędnych (15, 25), należy zastosować instrukcję:<br /> <br /> 328<br /> <br /> PHP5. Praktyczny kurs $niebieski = imagecolorallocate($img, 0, 0, 0xFF); imagefill($img, 15, 25, $niebieski);<br /> <br /> Informacje o obrazie Jeśli chcemy otrzymać informację o rozmiarach znajdującego się w pamięci obrazu, możemy skorzystać z funkcji imagesx (z ang. image size x) i imagesy (z ang. image size y). Pierwsza z nich zwraca szerokość, a druga wysokość obrazu. W obu przypadkach jako argument należy podać odnośnik do obrazu. Jeśli zatem utworzyliśmy lub wczytaliśmy z pliku obraz, który jest identyfikowany przez zmienną $img, to jego rozmiary możemy uzyskać za pomocą przykładowych wywołań: $szerokosc = imagesx($img); $wysokosc = imagesy($img);<br /> <br /> Równie przydatną funkcją jest getimagesize, która (nieco wbrew swojej nazwie) zwraca wiele przydatnych informacji, a nie tylko rozmiary obrazu. Jej wywołanie ma postać: getimagesize(nazwa_pliku[, $tablica]);<br /> <br /> gdzie nazwa_pliku określa nazwę pliku, z którego dane chcemy odczytać (może to być zarówno plik lokalny, jak i zdalny), a tablica — opcjonalną tablicę, w jakiej zostaną zapisane dodatkowe informacje (w obecnej wersji PHP zapisywane są w niej jedynie niektóre znaczniki APP z plików JPG). Wartością zwracaną przez getimagesize jest tablica o następującej zawartości:  indeks 0 — szerokość obrazu w pikselach,  indeks 1 — wysokość obrazu w pikselach,  indeks 2 — określenie typu pliku (dostępne wartości zostały<br /> <br /> zaprezentowane w tabeli 6.2),  indeks 3 — ciąg znaków zapisany w postaci height="wysokość" width="szerokość", który określa rozmiary obrazu,  klucz mime — ciąg znaków określający typ mime pliku.  klucz channels — liczba kanałów (3 dla RGB, 4 dla CMYK).  klucz bits — liczba bitów, na których zapisywany jest kolor (z czego<br /> <br /> bezpośrednio wynika maksymalna możliwa liczba kolorów w obrazie).<br /> <br /> Generowanie grafiki Na obrazie utworzonym lub wczytanym w sposób opisany w sekcji „Tworzenie obrazu” można za pomocą odpowiednich funkcji wykonywać różne operacje graficzne. Na kolejnych stronach omówione zostanie kilka z nich. Funkcje te pozwalają m.in. na rysowanie linii, łuków, prostokątów, wielokątów i elips.<br /> <br /> Rysowanie linii Do rysowania linii służy funkcja imageline, której wywołanie ma postać: imageline($obraz, xp, yp, xk, yk, kolor)<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 329<br /> <br /> Tabela 6.2. Typy plików rozpoznawane przez funkcję getimagesize Typ<br /> <br /> Wartość<br /> <br /> GIF<br /> <br /> 1<br /> <br /> JPEG<br /> <br /> 2<br /> <br /> PNG<br /> <br /> 3<br /> <br /> SWF<br /> <br /> 4<br /> <br /> PSD<br /> <br /> 5 6<br /> <br /> BMP 7<br /> <br /> 7<br /> <br /> TIFF_II<br /> <br /> TIFF_MM<br /> <br /> 8<br /> <br /> 8 9<br /> <br /> JPC JPEG_2000<br /> <br /> 9<br /> <br /> JP2<br /> <br /> 10<br /> <br /> JPX<br /> <br /> 11<br /> <br /> JB2<br /> <br /> 12<br /> <br /> SWC<br /> <br /> 13<br /> <br /> IFF<br /> <br /> 14<br /> <br /> WBMP<br /> <br /> 15<br /> <br /> XBM<br /> <br /> 16<br /> <br /> 9<br /> <br /> 17<br /> <br /> ICO<br /> <br /> gdzie:  $obraz — to określenie obrazu,  xp — współrzędna x początku linii,  yp — współrzędna y początku linii,  xk — współrzędna x końca linii,  yk — współrzędna y końca linii,  kolor — określenie koloru.<br /> <br /> Należy przy tym pamiętać, że współrzędne lewego górnego rogu to (0, 0). Przykładowo, aby utworzyć obraz o białym tle i o rozdzielczości 100×30 pikseli, który by zawierał dwie przekątne (pierwszą koloru zielonego, a drugą czerwonego), i zapisać go na dysku pod nazwą obraz1.jpg, należy wykonać kod widoczny na listingu 6.4.<br /> <br /> 7<br /> <br /> Kolejność bajtów zgodna z formatem Intela (z ang. intel byte order).<br /> <br /> 8<br /> <br /> Kolejność bajtów zgodna z formatem Motoroli (z ang. motorola byte order).<br /> <br /> 9<br /> <br /> Począwszy od PHP w wersji 5.3.0.<br /> <br /> 330<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Listing 6.4. Rysowanie przekątnych <?php $img = imagecreatetruecolor(100, 30); $bialy = imagecolorallocate($img, 255, 255, 255); $zielony = imagecolorallocate($img, 0, 255, 0); $czerwony = imagecolorallocate($img, 255, 0, 0); imagefill($img, 0, 0, $bialy); imageline($img, 0, 0, 99, 29, $czerwony); imageline($img, 0, 29, 99, 0, $zielony); imagejpeg($img, "obraz1.jpg"); imagedestroy($img); ?><br /> <br /> Obraz jest tworzony za pomocą funkcji imagecreatetruecolor. Ta funkcja zwraca zasób będący odwołaniem do obrazu (czy też identyfikatorem obrazu). A zatem w dalszej części skryptu obraz będzie reprezentowany przez zmienną $img. W uproszczeniu często mówi się po prostu o obrazie $img. Następnie za pomocą funkcji imagecolorallocate alokowane są trzy kolory: biały, zielony i czerwony. Wyniki działania funkcji (identyfikatory kolorów) są przypisywane zmiennym $bialy, $zielony i $czerwony. Obszar obrazu jest wypełniany kolorem białym dzięki funkcji imagefill, a przekątne są rysowane przez funkcję imageline. Na zakończenie obraz jest zapisywany do pliku o nazwie obraz1.jpg (odpowiada za to funkcja imagejpg) oraz usuwany z pamięci (odpowiada za to funkcja imagedestroy).<br /> <br /> Rysowanie prostokątów Do rysowania prostokątów służą funkcje imagerectangle i imagefilledrectangle, których wywołanie ma postać: imagerectangle($obraz, xp, yp, xk, yk, kolor) imagefilledrectangle($obraz, xp, yp, xk, yk, kolor)<br /> <br /> gdzie:  $obraz — to określenie obrazu,  xp — współrzędna x lewego górnego rogu,  yp — współrzędna y lewego górnego rogu,  xk — współrzędna x prawego dolnego rogu,  yk — współrzędna y prawego dolnego rogu,  kolor — określenie koloru.<br /> <br /> Pierwsza funkcja tworzy sam kontur prostokąta, a druga prostokąt wypełniony kolorem. Aby zatem utworzyć obraz o białym tle i o rozdzielczości 100×100 pikseli, który by zawierał cztery ułożone w szachownicę prostokąty w kolorach niebieskim i zielonym (w tym dwa wypełnione własnym kolorem i dwa wypełnione kolorem tła), oraz zapisać go na dysku pod nazwą obraz1.jpg, należy wykonać kod widoczny na listingu 6.5.<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 331<br /> <br /> Listing 6.5. Tworzenie prostokątów <?php $img = imagecreatetruecolor(100, 100); $bialy = imagecolorallocate($img, 255, 255, 255); $zielony = imagecolorallocate($img, 0, 255, 0); $niebieski = imagecolorallocate($img, 0, 0, 255); imagefill($img, 0, 0, $bialy); imagefilledrectangle($img, 10, 10, 50, 50, $niebieski); imagefilledrectangle($img, 50, 50, 90, 90, $niebieski); imagerectangle($img, 10, 50, 50, 90, $zielony); imagerectangle($img, 50, 10, 90, 50, $zielony); imagejpeg($img, "obraz1.jpg"); imagedestroy($img); ?><br /> <br /> Rysowanie wielokątów Do rysowania wielokątów służą funkcje imagepolygon i imagefilledpolygon, których wywołanie ma postać: imagepolygon($obraz, $punkty, ile, kolor) imagefilledpolygon($obraz, $punkty, ile, kolor)<br /> <br /> gdzie:  $obraz — to określenie obrazu,  $punkty — tablica zawierająca współrzędne kolejnych punktów,  ile — liczba wierzchołków,  kolor — określenie koloru.<br /> <br /> Tablica punkty musi być zbudowana w taki sposób, że klucze 0 i 1 zawierają współrzędne x i y pierwszego wierzchołka, klucze 2 i 3 — drugiego wierzchołka, 4 i 5 — trzeciego wierzchołka itd. Funkcja imagepolygon rysuje sam kontur wielokąta, natomiast imagefilledpolygon wielokąt wypełniony wskazanym kolorem. Aby na przykład uzyskać obraz o białym tle i o rozdzielczości 320×200 pikseli, który by zawierał sześciokąt wypełniony kolorem żółtym, należy wykorzystać kod widoczny na listingu 6.6. Listing 6.6. Tworzenie sześciokąta wypełnionego kolorem żółtym <?php $img = imagecreatetruecolor(320, 200); $bialy = imagecolorallocate($img, 255, 255, 255); $zolty = imagecolorallocate($img, 255, 255, 0); imagefill($img, 0, 0, $bialy); $tab = array(80, 100, 120, 20, 200, 20, 240, 100, 200, 180, 120, 180); imagefilledpolygon($img, $tab, 6, $zolty);<br /> <br /> 332<br /> <br /> PHP5. Praktyczny kurs imagejpeg($img, "obraz1.jpg"); imagedestroy($img); ?><br /> <br /> Rysowanie elips Do rysowania elips służą funkcje imageelipse i imagefilledelipse, których wywołanie ma postać: imageelipse($obraz, xc, yc, xw, xh, kolor) imagefilledelipse($obraz, xc, yc, xw, xh, kolor)<br /> <br /> gdzie:  $obraz — to określenie obrazu,  xc — współrzędna x środka elipsy,  yc — współrzędna y środka elipsy,  xw — szerokość elipsy (średnica pozioma),  xh — wysokość elipsy (średnica pionowa),  kolor — określenie koloru.<br /> <br /> Funkcja imageelipse rysuje sam kontur, natomiast imagefilledelipse elipsę wypełnioną wskazanym kolorem. Aby na przykład uzyskać obraz o białym tle i o rozdzielczości 320×200 pikseli, który by zawierał czarny okrąg oraz elipsę wypełnioną kolorem niebieskim, należy wykorzystać kod widoczny na listingu 6.7. Listing 6.7. Rysowanie elips <?php $img = imagecreatetruecolor(320, 200); $bialy = imagecolorallocate($img, 255, 255, 255); $czarny = imagecolorallocate($img, 0, 0, 0); $niebieski = imagecolorallocate($img, 0, 0, 255); imagefill($img, 0, 0, $bialy); imagefilledellipse($img, 100, 100, 100, 30, $niebieski); imageellipse($img, 220, 100, 80, 80, $czarny); imagejpeg($img, "obraz1.jpg"); imagedestroy($img); ?><br /> <br /> Rysowanie wycinków elips Do rysowania wycinków elips służą funkcje imagearc i imagefilledarc, których wywołanie ma postać: imagearc($obraz, xc, yc, xw, xh, k1, k2, kolor) imagefilledarc($obraz, xc, yc, xw, xh, k1, k2, kolor, styl)<br /> <br /> gdzie:<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 333<br /> <br />  $obraz — to określenie obrazu,  xc — współrzędna x środka elipsy,  yc — współrzędna y środka elipsy,  xw — szerokość elipsy (średnica pozioma),  xh — wysokość elipsy (średnica pionowa),  k1 — kąt (w stopniach) określający linię początkową,  k2 — kąt (w stopniach) określający linię końcową,  kolor — określenie koloru,  styl — styl wypełnienia.<br /> <br /> Pierwsza z nich rysuje sam łuk, druga wycinek elipsy zgodnie ze stylem przekazanym w argumencie styl. Argument ten składa się z następujących stałych, które można łączyć przez sumę bitową (operator |):  IMG_ARC_PIE — wycinek, którego końce są połączone łukiem, standardowo<br /> <br /> wypełniony zadanym kolorem.  IMG_ARC_CHORD — wycinek, którego końce połączone są linią prostą,<br /> <br /> standardowo wypełniony zadanym kolorem.  IMG_ARC_NOFILL — wycinek nie będzie wypełniany kolorem.  IMG_ARC_EDGED — w połączeniu z IMG_ARC_NOFILL powoduje, że zostanie<br /> <br /> wykreślony pełny kontur wycinka. Opcje IMG_ARC_PIE i IMG_ARC_CHORD wzajemnie się wykluczają, czyli nie mogą być użyte jednocześnie. Wygenerowanie obrazu widocznego na rysunku 6.4 osiągniemy zatem, stosując kod zaprezentowany na listingu 6.8. Rysunek 6.4. Wykorzystanie różnych opcji funkcji imagefilledarc<br /> <br /> Listing 6.8. Różne sposoby rysowania wycinków elips <?php $img = imagecreatetruecolor(400, 200); $bialy = imagecolorallocate($img, 255, 255, 255); $czerwony = imagecolorallocate($img, 255, 0, 0); $niebieski = imagecolorallocate($img, 0, 0, 255); imagefill($img, 0, 0, $bialy); imagearc($img, imagearc($img, imagearc($img, imagearc($img,<br /> <br /> 110, 100, 80, 80, 0, 90, $czerwony); 90, 100, 80, 80, 90, 180, $czerwony); 90, 90, 80, 80, 180, 270, $czerwony); 110, 90, 80, 80, 270, 360, $czerwony);<br /> <br /> 334<br /> <br /> PHP5. Praktyczny kurs imagefilledarc($img, imagefilledarc($img, imagefilledarc($img, imagefilledarc($img, IMG_ARC_EDGED);<br /> <br /> 310, 290, 290, 310,<br /> <br /> 100, 80, 80, 0, 90, $niebieski, IMG_ARC_PIE); 100, 80, 80, 90, 180, $niebieski, IMG_ARC_CHORD); 90, 80, 80, 180, 270, $niebieski, IMG_ARC_NOFILL); 90, 80, 80, 270, 360, $niebieski, IMG_ARC_NOFILL |<br /> <br /> imagejpeg($img, "obraz1.jpg"); imagedestroy($img); ?><br /> <br /> Przetwarzanie obrazów Nakładanie filtrów Wśród funkcji przetwarzających obrazy znajduje się imagefilter, która nakłada na nie jeden z dostępnych filtrów. Jej wywołanie ma postać: imagefilter($obraz, filtr[, arg1[, arg2[, arg3]]])<br /> <br /> Argument $obraz określa obraz poddawany zmianie, filtr — rodzaj filtra (dostępne wartości zostały podane w tabeli 6.3), natomiast arg1, arg2, arg3 i arg4 to parametry niezbędne do działania niektórych filtrów. Funkcja zwraca wartość true, jeśli jej działanie zakończyło się sukcesem, lub false w przeciwnym razie. Tabela 6.3. Filtry dostępne dla funkcji imagefilter Nazwa filtra<br /> <br /> Opis<br /> <br /> IMG_FILTER_NEGATE<br /> <br /> Inwersja kolorów.<br /> <br /> IMG_FILTER_GRAYSCALE<br /> <br /> Konwersja obrazu do odcieni szarości.<br /> <br /> IMG_FILTER_BRIGHTNESS<br /> <br /> Zmiana poziomu jasności obrazu. Do jego ustalenia należy wykorzystać argument arg1.<br /> <br /> IMG_FILTER_CONTRAST<br /> <br /> Zmiana kontrastu obrazu. Do ustalenia kontrastu należy wykorzystać argument arg1.<br /> <br /> IMG_FILTER_COLORIZE<br /> <br /> Działanie podobne do IMG_FILTER_GRAYSCALE z tą różnicą, że istnieje możliwość ustalenia koloru bazowego. Kolor ten należy podać w formacie RGB, gdzie R to wartość arg1, G — wartość arg2, B — wartość arg3, a kanał alfa (przezroczystość) — arg4 (dostępny od PHP 5.2.5).<br /> <br /> IMG_FILTER_EDGEDETECT<br /> <br /> Uwypuklenie krawędzi w obrazie.<br /> <br /> IMG_FILTER_EMBOSS<br /> <br /> Wytłoczenie obrazu.<br /> <br /> IMG_FILTER_GAUSSIAN_BLUR<br /> <br /> Rozmycie obrazu metodą Gaussa.<br /> <br /> IMG_FILTER_SELECTIVE_BLUR<br /> <br /> Rozmycie obrazu.<br /> <br /> IMG_FILTER_MEAN_REMOVAL<br /> <br /> Uwypuklenie krawędzi.<br /> <br /> IMG_FILTER_SMOOTH<br /> <br /> Wygładzenie (zmiękczenie, rozmycie) obrazu. Parametr arg1 pozwala na określenie poziomu intensywności efektu.<br /> <br /> IMG_FILTER_PIXELATE<br /> <br /> Pikselizacja obrazu. Argument arg1 określa rozmiar bloku, natomiast arg2 ustawiony na true (domyślnie false) włącza przetwarzanie zaawansowane (większe wygładzenie obrazu wynikowego).<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 335<br /> <br /> Można zatem napisać przykładowy skrypt, który podczas wywoływania w wierszu poleceń będzie otrzymywał nazwę pliku graficznego w formacie JPG oraz wartość całkowitą, a także wykona zmianę poziomu kontrastu tego pliku. Działający w ten sposób kod został zaprezentowany na listingu 6.9. Listing 6.9. Zmiana poziomu kontrastu <?php if($argc < 3){ exit("Wywołanie skryptu: php konwertuj.php nazwa_pliku poziom_kontrastu\n"); } if(!$img = imagecreatefromjpeg($argv[1])){ exit("Nie udało się wczytać pliku {$argv[1]}.\n"); } if(!is_numeric($argv[2])){ exit("Poziom kontrastu musi być liczbą całkowitą!\n"); } if(!imagefilter($img, IMG_FILTER_CONTRAST, $argv[2])){ exit("Nie udało się zmienić poziomu kontrastu w pliku {$argv[1]}."); } if(!imagejpeg($img, $argv[1])){ exit("Wystąpił błąd podczas zapisu pliku {$argv[1]}."); } echo "Operacja zmiany kontrastu zakończona sukcesem!"; imagedestroy($img); ?><br /> <br /> Skalowanie W celu przeskalowania obrazu do zadanych rozmiarów można użyć funkcji imagecopyresized lub imagecopyresampled. W rzeczywistości pobierają one określony parametrami wycinek z obrazu źródłowego i wstawiają go w miejsce obrazu docelowego (również określone parametrami). Jeśli wyznaczone obszary obrazu źródłowego i docelowego nie będą takie same, nastąpi odpowiednie przeskalowanie. Różnica pomiędzy imagecopyresized a imagecopyresampled jest taka, że druga z nich podczas skalowania dokonuje interpolacji pikseli, dzięki czemu uzyskuje się dokładniejszy efekt. Obie funkcje przyjmują identyczne zestawy argumentów, a ich wywołania mają postać: imagecopyresized($obraz_docelowy, $obraz_źródłowy, xd, yd, xs, ys, wd, hd, ws, hs); imagecopyresampled($obraz_docelowy, $obraz_źródłowy, xd, yd, xs, ys, wd, hd, ws, hs);<br /> <br /> gdzie:  $obraz_docelowy — określa obraz docelowy,  $obraz_źródłowy — określa obraz źródłowy,  xd — współrzędna x lewego górnego rogu kopiowanego obszaru w obrazie<br /> <br /> docelowym,<br /> <br /> 336<br /> <br /> PHP5. Praktyczny kurs  yd — współrzędna y lewego górnego rogu kopiowanego obszaru w obrazie<br /> <br /> docelowym,  xs — współrzędna x lewego górnego rogu kopiowanego obszaru w obrazie<br /> <br /> źródłowym,  ys — współrzędna y lewego górnego rogu kopiowanego obszaru w obrazie<br /> <br /> źródłowym,  wd — szerokość kopiowanego obszaru w obrazie docelowym,  hd — wysokość kopiowanego obszaru w obrazie docelowym,  ws — szerokość kopiowanego obszaru w obrazie źródłowym,  hs — wysokość kopiowanego obszaru w obrazie źródłowym.<br /> <br /> Jak by to wyglądało w praktyce? Załóżmy na przykład, że mamy plik o nazwie obraz. jpg zawierający obraz o rozdzielczości 800×600 pikseli. Chcielibyśmy powiększyć jego środkowy fragment o wielkości 160×120 pikseli do rozdzielczości 400×300 (chodzi zatem o wykonanie operacji przedstawionej schematycznie na rysunku 6.5) i tak przetworzoną część zapisać w pliku o nazwie obraz2.jpg.<br /> <br /> Rysunek 6.5. Schemat skalowania obrazu<br /> <br /> Kolejność wykonywanych czynności będzie zatem następująca: 1. Wczytanie obrazu z pliku obraz1.jpg za pomocą funkcji imagecreatefromjpeg. 2. Utworzenie nowego obrazu za pomocą funkcji imagecreatetruecolor. 3. Przeskalowanie wycinka obrazu oryginalnego za pomocą funkcji imagecopyresampled. 4. Zapisanie przeskalowanego obrazu do pliku obraz2.jpg za pomocą funkcji imagejpeg. 5. Usunięcie obrazów z pamięci za pomocą funkcji imagedestroy.<br /> <br /> Pozostaje jeszcze ustalenie argumentów funkcji imagecopyresampled. Nie jest to trudne. Ponieważ przeskalowany fragment będzie zajmował cały obszar obrazu docelowego, współrzędne lewego górnego wierzchołka to 0,0, a rozdzielczość to 400×300<br /> <br /> Rozdział 6. ♦ Grafika i obrazy<br /> <br /> 337<br /> <br /> pikseli. Długość i szerokość powiększanego fragmentu obrazu źródłowego też jest nam znana — to 160×120. Pozostaje więc ustalenie współrzędnych lewego górnego wierzchołka tego obszaru. Można to wyliczyć ze wzorów: x = (szerokość obrazu źródłowego - szerokość powiększanego wycinka) / 2 y = (wysokość obrazu źródłowego - wysokość powiększanego wycinka) / 2<br /> <br /> co w tym przypadku daje x = 320 i y = 240. Kod skryptu wykonującego przedstawione zadania został zaprezentowany na listingu 6.10. Listing 6.10. Skrypt skalujący środkową część obrazu do zadanej rozdzielczości <?php if(!$img_src = imagecreatefromjpeg("obraz1.jpg")) exit("Nie udało się wczytać pliku obraz1.jpg.\n"); if(!$img_dest = imagecreatetruecolor(400, 300)) exit("Nie udało się utworzyć nowego obrazu.\n"); if(!imagecopyresampled($img_dest, $img_src, 1, 1, 320, 240, 400, 300, 160, 120)) exit("Nie udała się operacja skalowania.\n"); if(!imagejpeg($img_dest, "obraz2.jpg")) exit("Wystąpił błąd podczas zapisu pliku obraz2.jpg.\n"); echo "Operacja skalowania zakończona sukcesem!\n"; imagedestroy($img_src); imagedestroy($img_dest); ?><br /> <br /> Obracanie Do obracania obrazów służy funkcja imagerotate, której wywołanie ma postać: imagerotate($obraz_źródłowy, kąt_obrotu, kolor_tła, ignoruj_przezroczyste);<br /> <br /> Obraca ona obraz wskazywany przez $obraz_źródłowy o kąt kąt_obrotu, wypełniając ewentualne powstałe przy tym puste obszary kolorem kolor_tła. Ustawienie argumentu ignoruj_przezroczyste na wartość inną niż 0 powoduje, że fragmenty z oznaczoną przezroczystością będą ignorowane (wartość domyślna to 0; argument wprowadzony w PHP 5.1.0). Funkcja zwraca przetworzony obraz. Aby zatem obrócić obraz wskazywany przez zmienną $img o 45 stopni (wypełniając puste obszary kolorem białym), a obraz wynikowy przypisać zmiennej $obraz, należałoby wykonać instrukcje: $bialy = $imagecolorallocate($img, 255, 255, 255); $obraz = imagerotate($img, 45, $bialy);<br /> <br /> Ćwiczenia do samodzielnego wykonania Ćwiczenie 20.1. Zmodyfikuj skrypt generujący galerię z listingu 6.2 w taki sposób, aby zachowywał się prawidłowo, gdy w katalogu przeznaczonym do przechowywania obrazów:<br /> <br /> 338<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> a) nie ma żadnego pliku, b) zapisane są pliki o rozszerzeniach innych niż jpg, gif, png, c) znajdują się podkatalogi. Ćwiczenie 20.2. Napisz taki skrypt realizujący galerię obrazów, żeby każdy obraz mógł zawierać podpis pobierany z pliku tekstowego o nazwie zgodnej z nazwą pliku z obrazem, ale o rozszerzeniu txt. Ćwiczenie 20.3. Napisz skrypt, który będzie wykonywał skalowanie obrazu z pliku graficznego typu JPG (lub innego) do zadanej rozdzielczości. Nazwa pliku oraz rozdzielczość powinny być podawane w postaci argumentu. Ćwiczenie 20.4. Napisz skrypt skalujący wszystkie obrazy typu JPG (lub innego) zapisane w danym katalogu o zadaną wartość procentową. Ćwiczenie 20.5. Napisz skrypt wykonujący konwersje pomiędzy różnymi formatami plików graficznych.<br /> <br /> Rozdział 7.<br /> <br /> Obsługa sieci Lekcja 21. Połączenia, poczta i FTP Tablica $_SERVER PHP udostępnia wiele informacji dotyczących aktualnie obsługiwanego połączenia oraz serwera, na którym jest uruchomione. Z niektórych z nich już korzystaliśmy. Odczytywane były na przykład: adres IP urządzenia, z którego nawiązane zostało połączenie, dane dotyczące przeglądarki, argumenty wiersza poleceń itp. Czas jednak usystematyzować te informacje. Wszystkie tego typu dane są zebrane w tablicy $_SERVER, której kolejne klucze zawierają różne informacje. Jest to tablica superglobalna, czyli dostępna w każdym miejscu skryptu. Jej standardowa zawartość została przedstawiona w tabeli 7.1. Trzeba jednak wspomnieć, że różne wersje PHP uruchamiane w różnych środowiskach systemowych mogą zawierać również dodatkowe wpisy. Przykładowy skrypt wyświetlający informacje zawarte w całej tablicy $_SERVER (nazwy kluczy wraz z odpowiadającymi im wartościami) jest widoczny na listingu 7.1, a efekt jego działania został zaprezentowany na rysunku 7.1. Tabela 7.1. Zawartość tablicy $_SERVER Klucz<br /> <br /> Znaczenie<br /> <br /> Przykładowa wartość<br /> <br /> PHP_SELF<br /> <br /> Ścieżka dostępu do bieżącego skryptu względem katalogu głównego serwera WWW.<br /> <br /> /index.php<br /> <br /> argv<br /> <br /> Tablica zawierająca argumenty przekazane z wiersza poleceń. Pierwszym argumentem jest nazwa pliku wykonywalnego PHP. W przypadku gdy skrypt został wywołany nie z wiersza poleceń, ale za pomocą metody GET, tablica zawiera część ciągu URL wywołującego skrypt, począwszy od znaku ?.<br /> <br /> Tablica<br /> <br /> 340<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Tabela 7.1. Zawartość tablicy $_SERVER — ciąg dalszy Klucz<br /> <br /> Znaczenie<br /> <br /> Przykładowa wartość<br /> <br /> argc<br /> <br /> Liczba argumentów zawartych w tablicy argv.<br /> <br /> Liczba całkowita<br /> <br /> GATEWAY_INTERFACE<br /> <br /> Numer wersji interfejsu CGI wykorzystywanego przez serwer.<br /> <br /> CGI/1.1<br /> <br /> SERVER_ADDR<br /> <br /> Adres IP serwera, na którym uruchomiono skrypt.<br /> <br /> SERVER_NAME<br /> <br /> Nazwa serwera, na którym pracuje PHP.<br /> <br /> www.mojadomena.com, localhost<br /> <br /> SERVER_SOFTWARE<br /> <br /> Ciąg znaków zawierający identyfikator serwera, który jest wysyłany w nagłówkach HTTP.<br /> <br /> Microsoft-IIS/5.0, Apache/2.0.54<br /> <br /> SERVER_PROTOCOL<br /> <br /> Nazwa i wersja protokołu użytego w odwołaniu do bieżącej strony.<br /> <br /> HTTP/1.0<br /> <br /> REQUEST_METHOD<br /> <br /> Nazwa metody użytej w zapytaniu.<br /> <br /> GET, HEAD, POST, PUT<br /> <br /> REQUEST_TIME<br /> <br /> Czas, w którym rozpoczęło się zapytanie (podany jako znacznik czasu Uniksa). Dostępny od PHP 5.1.0.<br /> <br /> Liczba całkowita<br /> <br /> QUERY_STRING<br /> <br /> Część ciągu URL wywołującego skrypt, począwszy od znaku ? (o ile taki występuje).<br /> <br /> pid=1&iid=10<br /> <br /> DOCUMENT_ROOT<br /> <br /> Katalog główny dla bieżącego skryptu.<br /> <br /> /var/www/html, c:\Inetpub\wwwroot\<br /> <br /> HTTP_ACCEPT<br /> <br /> Wartość nagłówka HTTP Accept:, o ile jest obecny.<br /> <br /> text/xml,application/xml, application/xhtml+xml<br /> <br /> HTTP_ACCEPT_CHARSET<br /> <br /> Wartość nagłówka HTTP Accept-Charset:, o ile jest obecny.<br /> <br /> iso-8859-1,*,utf-8, ISO-8859-2, utf-8;q=0.7,*;q=0.7<br /> <br /> HTTP_ACCEPT_ENCODING<br /> <br /> Wartość nagłówka HTTP Accept-Encoding:, o ile jest obecny.<br /> <br /> gzip, deflate<br /> <br /> HTTP_ACCEPT_LANGUAGE<br /> <br /> Wartość nagłówka HTTP Accept-Language:, o ile jest obecny.<br /> <br /> pl,en-us;q=0.7,en;q=0.3<br /> <br /> HTTP_CONNECTION<br /> <br /> Wartość nagłówka HTTP Connection:, o ile jest obecny.<br /> <br /> Keep-Alive<br /> <br /> HTTP_HOST<br /> <br /> Wartość nagłówka HTTP Host:, o ile jest obecny.<br /> <br /> www.mojadomena.com, localhost<br /> <br /> HTTP_REFERER<br /> <br /> Wartość nagłówka HTTP Referer:, o ile jest obecny. Adres URL strony, z której nastąpiło odwołanie do strony bieżącej.<br /> <br /> Adres URL<br /> <br /> HTTP_USER_AGENT<br /> <br /> Wartość nagłówka HTTP User-Agent:, o ile jest obecny. Określenie przeglądarki, która wysłała zapytanie.<br /> <br /> Mozilla/5.0 (Windows; U; Windows NT 5.0; pl; rv:1.8) Gecko/20051111 Firefox/1.5<br /> <br /> HTTPS<br /> <br /> Wartość niepusta, o ile skrypt został wywołany za pomocą protokołu HTTPS.<br /> <br /> -<br /> <br /> Rozdział 7. ♦ Obsługa sieci<br /> <br /> 341<br /> <br /> Tabela 7.1. Zawartość tablicy $_SERVER — ciąg dalszy Klucz<br /> <br /> Znaczenie<br /> <br /> Przykładowa wartość<br /> <br /> REMOTE_ADDR<br /> <br /> Adres IP, z którego nawiązano bieżące połączenie.<br /> <br /> 10.0.0.23<br /> <br /> REMOTE_HOST<br /> <br /> Nazwa domenowa komputera, z którego nawiązano bieżące połączenie. Istnienie pola zależy od konfiguracji serwera WWW.<br /> <br /> pc1.mojadomena.com<br /> <br /> REMOTE_PORT<br /> <br /> Port, z którego nawiązano bieżące połączenie.<br /> <br /> Liczba całkowita<br /> <br /> SCRIPT_FILENAME<br /> <br /> Bezwzględna ścieżka dostępu do bieżącego skryptu.<br /> <br /> /var/www/html/index.php, c:\Inetpub\www\index.php<br /> <br /> SERVER_ADMIN<br /> <br /> Wartość pola konfiguracyjnego SERVER_ADMIN serwera WWW (dla serwera Apache).<br /> <br /> root@localhost<br /> <br /> SERVER_PORT<br /> <br /> Port używany przez serwer WWW do komunikacji.<br /> <br /> 80<br /> <br /> SERVER_SIGNATURE<br /> <br /> Ciąg znaków opisujący wersję serwera oraz nazwę hosta wirtualnego, o ile taka opcja została włączona.<br /> <br /> Apache/2.0.54 (Fedora) Server at pc24. mojadomena.com Port 80<br /> <br /> PATH_TRANSLATED<br /> <br /> Ścieżka dostępu do aktualnego skryptu w systemie plików serwera.<br /> <br /> /var/www/html/index.php, c:\www\index.php<br /> <br /> SCRIPT_NAME<br /> <br /> Nazwa aktualnie wykonywanego skryptu.<br /> <br /> /index.php<br /> <br /> REQUEST_URI<br /> <br /> Identyfikator URI użyty w żądaniu dostępu do bieżącej strony.<br /> <br /> /index.php<br /> <br /> PHP_AUTH_DIGEST<br /> <br /> Zawartość nagłówka Authorization: w przypadku korzystania z serwera Apache i uwierzytelniania typu Digest HTTP Authentication.<br /> <br /> -<br /> <br /> PHP_AUTH_USER<br /> <br /> Nazwa użytkownika w przypadku uwierzytelniania HTTP.<br /> <br /> -<br /> <br /> PHP_AUTH_PW<br /> <br /> Hasło użytkownika w przypadku uwierzytelniania HTTP.<br /> <br /> -<br /> <br /> AUTH_TYPE<br /> <br /> Rodzaj uwierzytelniania HTTP.<br /> <br /> -<br /> <br /> PATH_INFO<br /> <br /> /dane/pliki Część ścieżki dostępu do skryptu znajdująca się w adresie URL za nazwą pliku ze skryptem, ale przed znakiem ?.<br /> <br /> ORG_PATH_INFO<br /> <br /> Oryginalna wartość PATH_INFO przed przetworzeniem przez PHP.<br /> <br /> Listing 7.1. Wyświetlenie zawartości tablicy $_SERVER <?php foreach($_SERVER as $key => $val){ echo "$key = $val<br />"; } ?><br /> <br /> /dane/pliki<br /> <br /> 342<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Rysunek 7.1. Przykładowa zawartość tablicy $_SERVER<br /> <br /> Adresy IP Znajomość adresu IP, z którego nadeszło połączenie z witryną, pozwala nie tylko na śledzenie ruchu na stronie i zapisywanie go w logu, tak jak to było prezentowane w przykładzie 3.25 z lekcji 12., ale również na przykład na kontrolę dostępu do strony. Możliwe są tu różne warianty, np. można zablokować połączenia z niektórych adresów lub też dopuszczać połączenia jedynie z wybranych adresów. Spróbujmy wykonać tego typu przykład. Powstanie skrypt, który pozwoli blokować wybrane adresy IP. W przypadku wykrycia zablokowanego adresu użytkownikowi zamiast treści witryny będzie wyświetlany komunikat o braku dostępu, np. taki, jaki jest widoczny na rysunku 7.2. Kod strony wyświetlającej taki komunikat będzie zapisywany w oddzielnym pliku o nazwie bannedip.html. Rysunek 7.2. Blokada wybranych adresów IP<br /> <br /> Sam skrypt, którego kod został zaprezentowany na listingu 7.2, ma bardzo prostą konstrukcję. Wszystkie zablokowane adresy należy umieścić w osobnym pliku o nazwie bannedip.txt (każdy adres w osobnym wierszu). Należy przy tym zwrócić uwagę, aby<br /> <br /> Rozdział 7. ♦ Obsługa sieci<br /> <br /> 343<br /> <br /> był on zapisany w lokalizacji niedostępnej z poziomu WWW, tak aby jego treść nie mogła być w prosty sposób poznana przez osoby postronne. Tak więc pierwszym zadaniem skryptu jest wczytanie zawartości pliku bannedip.txt, co jest wykonywane przez funkcję file. Listing 7.2. Kontrola dostępu do witryny ze względu na adres IP <?php if(!($ips_arr = file("/var/wwwdata/bannedip.txt", FILE_IGNORE_NEW_LINES))){ include "./banned.html"; exit(); } $ip = $_SERVER['REMOTE_ADDR']; if((array_search($ip, $ips_arr) !== false)){ include "./bannedip.html"; exit(); } ?> <!-- tutaj kod html strony --><br /> <br /> Jak wiadomo z rozdziału 4. (lekcja 11.), wynikiem działania file jest tablica zawierająca w następujących po sobie komórkach kolejne odczytane wiersze. Adres IP, z którego nadeszło połączenie, jest odczytywany z tablicy $_SERVER i zapisywany w zmiennej $ip. Zmienna ta jest następnie wykorzystywana jako pierwszy z argumentów funkcji array_search. Drugim argumentem jest tablica $ips_arr. Działanie tej funkcji będzie takie, że jeśli odnajdzie ona w tablicy $ips_arr wartość wskazywaną przez $ip, to zwróci nazwę klucza, pod którym ta wartość się znajduje, a w przeciwnym razie wartość false. Jeśli więc wynik działania array_search będzie różny od false, wczytana zostanie treść pliku bannedip.html, jeśli natomiast wartość ta będzie równa false, kod PHP zakończy działanie i wyświetlona zostanie właściwa treść strony. W równie prosty sposób możemy napisać skrypt, który będzie wczytywał różne wersje witryny w zależności od tego, z jakiego adresu IP nadeszło połączenie. Dane zapiszemy w trzech plikach: ips1.txt, ips2.txt i ips3.txt, a każdy z nich będzie przechowywał adresy przynależne do trzech różnych grup. Każda taka grupa będzie miała przypisaną swoją stronę startową: index1.php, index2.php i index3.php. W przypadku gdy adres, z którego nadeszło połączenie, nie będzie zapisany w żadnym z wymienionych plików, zostanie wczytana treść strony index0.php. Działający w opisany sposób skrypt został zaprezentowany na listingu 7.3. Listing 7.3. Różne wersje strony ze względu na adres IP <?php function check($arr, $ip) { if($arr){ if((array_search($ip, $arr) !== false)){ return true; }<br /> <br /> 344<br /> <br /> PHP5. Praktyczny kurs } return false; } $ips1 = file("/var/wwwdata/ips1.txt", FILE_IGNORE_NEW_LINES); $ips2 = file("/var/wwwdata/ips2.txt", FILE_IGNORE_NEW_LINES); $ips3 = file("/var/wwwdata/ips3.txt", FILE_IGNORE_NEW_LINES); $ip = $_SERVER['REMOTE_ADDR']; if(check($ips1, $ip)){ include "./index1.php"; } else if(check($ips2, $ip)){ include "./index2.php"; } else if(check($ips3, $ip)){ include "./index3.php"; } else{ include "./index0.php"; } ?><br /> <br /> Dane z plików są wczytywane za pomocą funkcji file i umieszczane w tablicach $ips1, $ips2 i $ips3, natomiast adres IP jest pobierany z tablicy $_SERVER i umieszczany w zmiennej $ip. Za sprawdzenie, czy adres zapisany w $ip znajduje się w którejś z tablic, odpowiada funkcja check. Zwraca ona wartość true, jeśli adres został znaleziony, lub false w przeciwnym razie. Dzięki temu za pomocą złożonej instrukcji warunkowej if else może zostać wczytany odpowiedni plik z właściwą treścią strony. Treść wybranego pliku jest dołączana za pomocą instrukcji include. Funkcja check przyjmuje dwa argumenty. Pierwszym z nich ($arr) jest tablica, która będzie przeszukiwana, drugim ($ip) — wartość poszukiwana (czyli adres IP). Ponieważ funkcja file w przypadku niepowodzenia zwraca wartość false, a więc istnieje możliwość, że wartością parametru $arr nie będzie prawidłowa tablica, dlatego w funkcji check najpierw jest wykonywana instrukcja if($arr), a dalsze czynności są wykonywane jedynie wtedy, gdy wynikiem jej działania jest true (czyli kiedy $arr jest różne od false). Sama weryfikacja danych jest wykonywana analogicznie do poprzedniego przykładu. Warto w tym miejscu zwrócić uwagę, że taki skrypt można nieco usprawnić. W zaprezentowanej wersji najpierw są bowiem wczytywane dane z wszystkich trzech plików zawierających adresy IP, a dopiero potem wykonywane jest badanie, czy poszukiwany adres znajduje się w którymś z plików. Jeśli zatem adres pobrany z tablicy $_SERVER występuje na przykład już w pierwszym pliku (ips1.txt), to treść pozostałych dwóch (ips2.txt i ips3.txt) była pobierana na próżno. Sposób modyfikacji przykładu pozostanie jednak ćwiczeniem do samodzielnego wykonania.<br /> <br /> Rozdział 7. ♦ Obsługa sieci<br /> <br /> 345<br /> <br /> Jak rozpoznać przeglądarkę? Jednym z problemów, z jakimi spotykają się webmasterzy, jest rozpoznanie typu przeglądarki internetowej, którą wykorzystuje osoba przeglądająca stronę. Jak to zrobić? Jak wiadomo z przykładu 3.25 z rozdziału 3., informacje tego typu można odnaleźć w tablicy $_SERVER pod indeksem 'HTTP_USER_AGENT'. Analizując zapisany tam ciąg znaków, z dużym prawdopodobieństwem można stwierdzić, z którym produktem ma się do czynienia. Ograniczmy się przy tym do rozpoznawania jedynie tych najpopularniejszych:  Chrome  Firefox  Internet Explorer  Opera<br /> <br /> Powstanie funkcja, która będzie zwracała ciąg znaków zawierający nazwę rozpoznanej przeglądarki lub też ciąg nieznana, jeśli rozpoznanie nie będzie możliwe. Rozpoznawanie będzie się odbywało za pomocą przeszukiwania ciągów znaków odczytanych z tablicy $_SERVER. Przyjmiemy przy tym następujące zasady:  Jeśli zostanie odnaleziony ciąg znaków opera, wówczas uznamy,<br /> <br /> że mamy do czynienia z przeglądarką Opera.  Jeśli zostanie odnaleziony ciąg znaków msie, wówczas uznamy,<br /> <br /> że mamy do czynienia z przeglądarką Internet Explorer.  Jeśli zostanie odnaleziony ciąg znaków firefox, wówczas uznamy,<br /> <br /> że mamy do czynienia z przeglądarką Mozilla Firefox.  Jeśli zostanie odnaleziony ciąg znaków chrome, wówczas uznamy,<br /> <br /> że mamy do czynienia z przeglądarką Google Chrome. Działająca w opisany sposób funkcja jest widoczna na listingu 7.4. Jej działanie rozpoczyna się od sprawdzenia, czy w tablicy $_SERVER istnieje klucz o nazwie HTTP_USER_ AGENT. Niektóre przeglądarki można bowiem skonfigurować w taki sposób, aby nie wysyłały ciągów identyfikacyjnych, a w takiej sytuacji nie będzie w tej tablicy wymienionego klucza. Jeśli klucza nie będzie, zwrócony zostanie ciąg nieznana oznaczający, że rozpoznanie się nie powiodło. Listing 7.4. Funkcja rozpoznająca typ przeglądarki <?php function getBrowserType() { if(!isSet($_SERVER['HTTP_USER_AGENT'])){ return("nieznana"); } $browser_info = strtolower($_SERVER['HTTP_USER_AGENT']); if(strpos($browser_info, "opera") !== false){ return("opera");<br /> <br /> 346<br /> <br /> PHP5. Praktyczny kurs } else if(strpos($browser_info, "msie") !== false){ return("msie"); } else if(strpos($browser_info, "firefox") !== false){ return("firefox"); } else if(strpos($browser_info, "chrome") !== false){ return("chrome"); } else{ return("nieznana"); } } echo getBrowserType(); ?><br /> <br /> Jeśli jednak klucz HTTP_USER_AGENT jest obecny, jego zawartość jest odczytywana i zapisywana w zmiennej $browser_info. Wcześniej (za pomocą funkcji strtolower) jest też dokonywana konwersja ciągu, tak aby wszystkie litery zostały zamienione na małe, co ułatwi dalsze operacje. Ciąg zapisany w $browser_info jest przeszukiwany za pomocą znanej z lekcji 8. funkcji strpos w złożonej instrukcji warunkowej if...else. Równie łatwo można uzyskać dane o rodzaju systemu operacyjnego wykorzystywanego przez danego użytkownika serwisu. Taka informacja jest również zawarta w ciągu znajdującym się w tablicy $_SERVER pod indeksem HTTP_USER_AGENT. Jeśli odnajdziemy w nim podciąg: windows, linux lub mac, będziemy mogli z dużym prawdopodobieństwem określić typ systemu operacyjnego jako Windows, Linux lub MacOS. Funkcja wykonująca takie zadanie będzie miała postać analogiczną do przedstawionej na listingu 7.4 getBrowserType i została zaprezentowana na listingu 7.5. Podobnie jednak jak w przypadku poprzedniego przykładu należy pamiętać, że wyniki działania takiej funkcji mogą być zafałszowane przez przeglądarki wysyłające nieprawdziwe dane identyfikacyjne. Listing 7.5. Funkcja rozpoznająca typ systemu operacyjnego <?php function getSystemType() { if(!isSet($_SERVER['HTTP_USER_AGENT'])){ return("nieznany"); } $browser_info = strtolower($_SERVER['HTTP_USER_AGENT']); if(strpos($browser_info, "windows") !== false){ return("windows"); } else if(strpos($browser_info, "linux") !== false){ return("linux"); } else if(strpos($browser_info, "mac") !== false){ return("macos");<br /> <br /> Rozdział 7. ♦ Obsługa sieci<br /> <br /> 347<br /> <br /> } else{ return("nieznany"); } } echo getSystemType(); ?><br /> <br /> Połączenie FTP PHP oferuje szereg funkcji pozwalających na pełną obsługę protokołu FTP. Nie ma potrzeby, aby je tutaj wszystkie omawiać, warto jednak omówić przykład pokazujący, jak za pomocą PHP pobrać plik z serwera FTP, a także jak wysłać taki plik. Pierwszą czynnością, którą należy wykonać, jest nawiązanie połączenia za pomocą funkcji ftp_ connect. Przyjmuje ona trzy argumenty, a jej schematyczne wywołanie ma postać: ftp_connect(host[, port[, timeout]])<br /> <br /> Parametr host określa nazwę lub adres IP serwera, z którym chcemy się połączyć, port to port, na którym pracuje usługa FTP, natomiast timeout określa czas (w sekundach), po jakim próba wykonywania operacji FTP ma zostać przerwana, o ile nie uzyska się odpowiedzi. Standardowo przyjmowane wartości dla domyślnych argumentów port i timeout to odpowiednio 21 i 90. Funkcja ftp_connect zwraca identyfikator połączenia (wartość typu resource), którym należy się posługiwać przy wykonywaniu dalszych operacji, lub też false, jeśli połączenia nie udało się nawiązać. Po nawiązaniu połączenia należy wykonać procedurę logowania. Służy do tego funkcja ftp_login o schematycznej postaci: ftp_login (ftpid, użytkownik, hasło)<br /> <br /> ftpid to identyfikator połączenia zwrócony przez funkcję ftp_connect, a użytkownik i hasło to ciągi znaków określające nazwę użytkownika oraz hasło. Logowanie należy<br /> <br /> wykonać nawet wówczas, jeśli łączymy się z serwerem FTP oferującym dostęp anonimowy. W takim wypadku jako nazwę użytkownika należy podać ciąg anonymous, a jako hasło — adres e-mail. Niektóre serwery akceptują także podanie zamiast hasła pustego ciągu znaków. Pobranie pliku z serwera osiągamy dzięki funkcji: ftp_fget(ftpid, plik_lokalny, plik_zdalny, tryb[, pozycja])<br /> <br /> gdzie:  ftpid — identyfikator połączenia.  plik_lokalny — nazwa pliku (na dysku lokalnym), w którym będą<br /> <br /> zapisywane odczytane dane.  plik_zdalny — nazwa pliku do pobrania (wraz ze ścieżką dostępu).<br /> <br /> 348<br /> <br /> PHP5. Praktyczny kurs  tryb — tryb transmisji. Może przyjmować wartość FTP_ASCII (dla transmisji tekstowej) lub FTP_BINARY (dla transmisji binarnej).  pozycja — opcjonalny parametr pozwalający na wznowienie zerwanej<br /> <br /> wcześniej transmisji. Określa pozycję w pliku, od której powinny być wysyłane dane. Po zakończeniu transmisji połączenie należy zamknąć za pomocą funkcji ftp_close, której wywołanie ma postać: ftp_close(ftpid)<br /> <br /> Przykładowy skrypt, który pobiera wskazany plik z wybranego serwera FTP, został przedstawiony na listingu 7.6. Dla uproszczenia wszystkie parametry połączenia zostały podane bezpośrednio w kodzie skryptu. Listing 7.6. Pobranie pliku z serwera FTP <?php $host = "ftp.mojserwer.com"; $user = "anonymous"; $pass = "moj@adres.email"; $plik_lokalny = "./plik.zip"; $plik_zdalny = "/plik.zip"; if(!$ftpid = ftp_connect($host)){ exit("Nie mogę nawiązać połączenia z serwerem ftp.\n"); } echo "Połączenie z serwerem $host zostało nawiązane...\n"; if(!ftp_login($ftpid, $user, $pass)){ ftp_close($ftpid); exit("Wystąpił błąd przy próbie zalogowania...\n"); } else{ echo "Logowanie zakończone sukcesem...\n"; } if(!ftp_get($ftpid, $plik_lokalny, $plik_zdalny, FTP_BINARY)){ exit("Błąd przy próbie pobrania pliku $plik_zdalny..."); } else{ echo "Plik $plik_zdalny został pobrany i zapisany jako $plik_lokalny.\n"; } if(!ftp_close($ftpid)){ echo "Błąd przy próbie zakończenia połączenia...\n"; } else{ echo "Połączenie zostało zakończone...\n"; } ?><br /> <br /> Rozdział 7. ♦ Obsługa sieci<br /> <br /> 349<br /> <br /> Kod rozpoczyna się od ustawienia zmiennych pomocniczych:  $host — przechowuje nazwę lub adres IP serwera FTP.  $user — przechowuje nazwę użytkownika.  $pass — przechowuje hasło użytkownika.  $plik_lokalny — przechowuje nazwę pliku lokalnego (wraz ze ścieżką<br /> <br /> dostępu), czyli pliku, który zostanie zapisany na dysku.  $plik_zdalny — przechowuje nazwę pliku zdalnego (wraz ze ścieżką<br /> <br /> dostępu), czyli pliku, który będzie pobierany z serwera. Następnie (za pomocą funkcji ftp_connect) ma miejsce próba połączenia z serwerem wskazanym przez wartość zmiennej $host. Jeśli ta próba zakończy się sukcesem, zmiennej $ftpid zostanie przypisany identyfikator połączenia, w przeciwnym wypadku otrzyma ona wartość false, a skrypt zakończy działanie, wyświetlając na ekranie konsoli stosowny komunikat. Jeśli połączenie udało się nawiązać, jest wywoływana wykonująca procedurę logowania funkcja ftp_login, której w postaci argumentów został przekazany identyfikator połączenia $ftpid oraz wartości zmiennych $user i $pass. Jeżeli wartością zwróconą przez ftp_login będzie true, oznacza to, że procedura zakończyła się sukcesem, jest więc wyświetlany komunikat z informacją o tym fakcie i rozpoczyna się wykonywanie dalszych instrukcji skryptu. Jeśli jednak zwróconą wartością jest false, oznacza to, że logowanie się nie udało, połączenie jest zatem zamykane za pomocą funkcji ftp_ close, a skrypt kończy działanie. Po prawidłowym zalogowaniu można przystąpić do pobrania pliku, co jest wykonywane za pomocą funkcji ftp_get. W tym przypadku pobierany jest plik o nazwie plik.zip znajdujący się w katalogu głównym serwera FTP — / i jest on zapisywany na dysku jako plik o tej samej nazwie w katalogu bieżącym — ./ (tym, z którego został uruchomiony skrypt). Jeśli wartością zwróconą przez ftp_get jest true, oznacza to, że pobranie zakończyło się sukcesem, jeśli natomiast wartością tą jest false, oznacza to, że wystąpił błąd (np. nie ma takiego pliku na serwerze FTP). W obu przypadkach jest wyświetlany odpowiedni komunikat. Na zakończenie połączenie z serwerem FTP jest zamykane za pomocą wywołania funkcji ftp_close.<br /> <br /> Wysyłanie poczty Z poziomu PHP można również wysyłać listy elektroniczne — służy do tego funkcja mail. Aby móc z niej skorzystać, należy wcześniej odpowiednio skonfigurować środowisko (konkretnie chodzi o ustawienie odpowiednich parametrów w pliku php.ini). W przypadku pracy w systemie Linux oraz niestandardowej lokalizacji programu Sendmail należy zmiennej sendmail_path przypisać ścieżkę do tego programu lub też innej aplikacji zajmującej się wysyłaniem poczty. Z reguły jednak domyślne ustawienia są właściwe i nie wymagają modyfikacji.<br /> <br /> 350<br /> <br /> PHP5. Praktyczny kurs<br /> <br /> Jeśli natomiast korzystamy ze środowiska Windows, należy przypisać odpowiednie wartości następującym zmiennym:  SMPT — określa nazwę lub adres IP serwera SMTP.  SMTP_PORT — określa port, na którym działa serwer SMTP.  SENDMAIL_FROM — określa, co będzie wpisane w polu FROM wysyłanego listu.<br /> <br /> Należy zatem skorzystać z usługi SMTP (serwera pocztowego) udostępnianego przez niektóre wersje systemu Windows (z reguły wersje Professional) lub też zainstalować inny produkt spełniający takie zadanie, np. PostCast Server (dostępny pod adresem http://www.postcastserver.com) lub Mercury Mail Transport System (dostępny pod adresem http://www.pmail.com). Serwer pocztowy działa standardowo na porcie nr 25. Wywołanie funkcji mail ma następującą postać: mail(do, temat, treść[, nagłówki[, parametry]])<br /> <br /> Parametry do, temat i treść określają odpowiednio: adres odbiorcy, temat listu oraz jego treść. Opcjonalny parametr nagłówki pozwala na dodanie do listu dodatkowych nagłówków SMTP. Argument parametry umożliwia przekazanie dodatkowych parametrów do programu pocztowego. Funkcja zwraca wartość true, jeśli wysłanie listu zakończyło się powodzeniem, lub false w przeciwnym razie. Jeśli więc na adres uzytkownik@nazwa.domeny chcielibyśmy wysłać list o temacie test i zawartości zapisanej w zmiennej $tresc, powinniśmy zastosować wywołanie: mail("uzytkownik@nazwa.domeny", "test", $tresc);<br /> <br /> Stosując tę technikę, można napisać skrypt, który na nasz adres e-mail będzie wysyłał na przykład opinie użytkowników o witrynie. Podobny skrypt był prezentowany w rozdziale 2., w lekcji 15. Wtedy opinie były zapisywane w pliku tekstowym. Formularz będzie podobny jak w tamtym przypadku, pojawi się w nim tylko dodatkowe pole o nazwie temat, w którym będzie można wpisywać temat listu. Kod HTML zostanie też oddzielony od kodu PHP. Tym razem kod formularza będzie miał zatem postać widoczną na listingu 7.7, który po wczytaniu do przeglądarki będzie wyglądał jak na rysunku 7.3. Dane będą natomiast wysyłane do skryptu o nazwie sendmail.php za pomocą metody POST. Temat listu będzie przekazywany w parametrze o nazwie temat, a treść — w parametrze tresc. Listing 7.7. Kod HTML formularza <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-2"> <title>Moja strona WWW</title> </head> <body> <div> <strong>Wyraź swoją opinię:</strong><br /> </div> <form method="post" action="http://localhost/sendmail.php"><br /> <br /> Rozdział 7. ♦ Obsługa sieci<br /> <br /> 351<br /> <br /> <div> Temat: <br /> <input type="text" size="40" name="temat" /> <br /> Treść wiadomości: <br /> <textarea rows="5" cols="20" name="tresc">