Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00056 009752 11018348 na godz. na dobę w sumie
PHP5. Tajniki programowania - książka
PHP5. Tajniki programowania - książka
Autor: , , Liczba stron: 728
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-856-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> php - programowanie
Porównaj ceny (książka, ebook, audiobook).

Odkryj potęgę najnowszej wersji języka PHP

PHP w ciągu ostatnich lat stał się jednym z najpopularniejszych języków programowania wykorzystywanych do tworzenia aplikacji internetowych. Swój sukces zawdzięcza prostocie i ogromnym możliwościom, pozwalającym na pisanie rozbudowanych aplikacji, znacznie przekraczających funkcjonalnością 'zwykłe' portale i dynamiczne strony WWW. Najnowsza wersja języka PHP, oznaczona numerem 5, to w pełni obiektowy język programowania umożliwiający realizację złożonych projektów. Posiada mechanizmy obsługi plików XML i protokołu SOAP oraz poprawione i rozbudowane funkcje do komunikacji z bazami danych.

'PHP5. Tajniki programowania' to napisany przez współtwórcę języka PHP5 oraz dwóch doskonałych programistów przewodnik opisujący ogromne możliwości tej platformy. Autorzy przedstawiają sposoby wykorzystania PHP5 w projektach informatycznych o dowolnej skali złożoności. Omawiają model obiektowy PHP5, wzorce projektowe, metody korzystania z plików XML i technologii SOAP oraz techniki współpracy z bazami danych. W książce znajdziesz także szczegółowe omówienie biblioteki PEAR, obsługi wyjątków oraz metod optymalizowania wydajności aplikacji.

Jeśli tworzysz aplikacje WWW, pakiety lub rozszerzenia PHP, w tej książce znajdziesz odpowiedzi na wszystkie pytania.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl PHP5. Tajniki programowania Autorzy: Andi Gutmans, Stig Saether Bakken, Derick Rethans T³umaczenie: Daniel Kaczmarek (przedmowa, rozdz. 1, 8–11), Rados³aw Meryk (rozdz. 12–16, dod. A–C), Anna Zawadzka (rozdz. 2–7) ISBN: 83-7361-856-2 Tytu³ orygina³u: PHP 5 Power Programming Format: B5, stron: 728 Odkryj potêgê najnowszej wersji jêzyka PHP • Zaawansowane techniki programowania w PHP5 • Wzorce projektowe i stosowanie technologii XML i SOAP • Sposoby poprawy wydajnoġci aplikacji • Wspó³praca z bazami danych PHP w ci¹gu ostatnich lat sta³ siê jednym z najpopularniejszych jêzyków programowania wykorzystywanych do tworzenia aplikacji internetowych. Swój sukces zawdziêcza prostocie i ogromnym mo¿liwoġciom, pozwalaj¹cym na pisanie rozbudowanych aplikacji, znacznie przekraczaj¹cych funkcjonalnoġci¹ „zwyk³e” portale i dynamiczne strony WWW. Najnowsza wersja jêzyka PHP, oznaczona numerem 5, to w pe³ni obiektowy jêzyk programowania umo¿liwiaj¹cy realizacjê z³o¿onych projektów. Posiada mechanizmy obs³ugi plików XML i protoko³u SOAP oraz poprawione i rozbudowane funkcje do komunikacji z bazami danych. „PHP5. Tajniki programowania” to napisany przez wspó³twórcê jêzyka PHP5 oraz dwóch doskona³ych programistów przewodnik opisuj¹cy ogromne mo¿liwoġci tej platformy. Autorzy przedstawiaj¹ sposoby wykorzystania PHP5 w projektach informatycznych o dowolnej skali z³o¿onoġci. Omawiaj¹ model obiektowy PHP5, wzorce projektowe, metody korzystania z plików XML i technologii SOAP oraz techniki wspó³pracy z bazami danych. W ksi¹¿ce znajdziesz tak¿e szczegó³owe omówienie biblioteki PEAR, obs³ugi wyj¹tków oraz metod optymalizowania wydajnoġci aplikacji. • Nowe mo¿liwoġci PHP5 • Podstawy PHP5 i programowania zorientowanego obiektowo • Stosowanie wzorców projektowych • Techniki tworzenia aplikacji WWW • Komunikacja z bazami danych, wspó³praca z MySQL i SQLite • Obs³uga b³êdów i wyj¹tków • Przetwarzanie plików XML • Instalowanie biblioteki PEAR • Pakiety PEAR • Tworzenie komponentów PEAR • Przenoszenie kodu z PHP4 do wersji PHP5 • Projektowanie wydajnych aplikacji Jeġli tworzysz aplikacje WWW, pakiety lub rozszerzenia PHP, w tej ksi¹¿ce znajdziesz odpowiedzi na wszystkie pytania. Spis treści Słowo wstępne ...................................................n............................ 15 Przedmowa ...................................................n.................................. 17 Rozdział 1. Co nowego w PHP5? ...................................................n................... 25 1.1. Wprowadzenie ...................................................d.................................................. 25 1.2. Własności języka ...................................................d.............................................. 25 1.2.1. Nowy model zorientowany obiektowo ...................................................d 25 1.2.2. Nowe mechanizmy zorientowane obiektowo ......................................... 27 1.2.3. Pozostałe nowe mechanizmy języka ...................................................d... 31 1.3. Ogólne zmiany w PHP ...................................................d...................................... 32 1.3.1. XML i usługi sieciowe ...................................................d........................ 32 1.4. Pozostałe nowe mechanizmy PHP5 ...................................................d.................. 36 1.4.1. Nowy menedżer pamięci ...................................................d..................... 36 1.4.2. Wycofana obsługa Windows 95 ...................................................d.......... 36 1.5. Podsumowanie ...................................................d.................................................. 36 Rozdział 2. Podstawy języka PHP5 ...................................................n................. 37 2.1. Wprowadzenie ...................................................d.................................................. 37 2.2. Osadzanie w HTML .................................................d............................................ 38 2.3. Komentarze ...................................................d...................................................d.... 38 2.4. Zmienne ...................................................d...................................................d......... 39 2.4.1. Pośrednie referencje do zmiennych ...................................................d..... 40 2.4.2. Zarządzanie zmiennymi ...................................................d...................... 40 2.4.3. Superglobale ..................................................d......................................... 42 2.5. Podstawowe typy danych ...................................................d.................................. 43 2.5.1. Liczby całkowite ...................................................d................................. 43 2.5.2. Liczby zmiennopozycyjne ...................................................d................... 43 2.5.3. Łańcuchy ...................................................d............................................. 44 2.5.4. Typ logiczny (boolowski) ...................................................d................... 46 2.5.5. Null ...................................................d...................................................d.. 47 2.5.6. Identyfikator zasobów (resource) ...................................................d........ 48 2.5.7. Tablice ..................................................d.................................................. 48 2.5.8. Stałe ...................................................d...................................................d. 54 2.6. Operatory ...................................................d...................................................d....... 55 2.6.1. Operatory binarne ..................................................d................................. 56 2.6.2. Operatory przypisania ...................................................d......................... 56 2.6.3. Operatory porównania ...................................................d......................... 57 2.6.4. Operatory logiczne ...................................................d.............................. 58 2.6.5. Operatory bitowe ...................................................d................................. 59 6 PHP5. Tajniki programowania 2.6.6. Operatory jednoargumentowe ...................................................d............. 59 2.6.7. Operatory negacji ...................................................d................................ 59 2.6.8. Operatory inkrementacji i dekrementacji ............................................... 60 2.6.9. Operatory rzutowania ...................................................d.......................... 61 2.6.10. Operator kontroli błędów ...................................................d.................... 61 2.6.11. Jedyny operator trójargumentowy (tzw. ternariusz) ............................... 62 2.7. Struktury kontrolne ...................................................d........................................... 62 2.7.1. Warunkowe struktury kontrolne ...................................................d.......... 62 2.7.2. Struktury kontrolne w postaci pętli ...................................................d..... 65 2.7.3. Struktury kontrolne dołączania kodu ...................................................d... 68 2.8. Funkcje ...................................................d...................................................d.......... 70 2.8.1. Funkcje definiowane przez użytkownika ............................................... 71 2.8.2. Zasięg funkcji ...................................................d...................................... 71 2.8.3. Zwracanie wartości przez wartość ...................................................d....... 72 2.8.4. Zwracanie wartości przez referencję ...................................................d... 73 2.8.5. Definiowanie parametrów funkcji ...................................................d....... 73 2.8.6. Zmienne statyczne ...................................................d............................... 75 2.9. Podsumowanie ...................................................d.................................................. 75 Rozdział 3. Język obiektowy ...................................................n.......................... 77 3.1. Wprowadzenie ...................................................d.................................................. 77 3.2. Obiekty ...................................................d...................................................d.......... 78 3.3. Deklarowanie klasy ..................................................d............................................ 79 3.4. Słowo kluczowe new i konstruktory ...................................................d................. 79 3.5. Destruktory ...................................................d...................................................d.... 80 3.6. Odwoływanie się do metod i właściwości przy użyciu zmiennej $this ................ 81 3.6.1. Właściwości public, protected i private .................................................. 81 3.6.2. Metody public, protected i private ...................................................d....... 83 3.6.3. Właściwości statyczne ...................................................d......................... 84 3.6.4. Metody statyczne ...................................................d................................ 86 3.7. Stałe klasy ...................................................d...................................................d...... 86 3.8. Klonowanie obiektów ...................................................d....................................... 87 3.9. Polimorfizm ...................................................d...................................................d... 89 3.10. parent:: i self:: ...................................................d...................................................d 91 3.11. Operator instanceof ...................................................d........................................... 92 3.12. Metody i klasy abstrakcyjne ...................................................d............................. 93 3.13. Interfejsy ...................................................d...................................................d........94 3.14. Dziedziczenie interfejsów ...................................................d................................. 96 3.15. Metody final ...................................................d...................................................d.. 96 3.16. Klasy final ...................................................d...................................................d...... 97 3.17. Metoda __toString() ...................................................d.......................................... 97 3.18. Obsługa wyjątków ...................................................d............................................ 98 3.19. __autoload() ...................................................d...................................................d. 101 3.20. Wskazania typu klasy w parametrach funkcji ...................................................d. 103 3.21. Podsumowanie ...................................................d................................................ 104 Rozdział 4. Zaawansowane programowanie obiektowe i wzorce projektowe ...... 105 4.1. Wprowadzenie ...................................................d................................................ 105 4.2. Możliwości przeciążania ...................................................d................................. 105 4.2.1. Przeciążanie właściwości i metod ...................................................d..... 106 4.2.2. Przeciążanie składni dostępu do tablic ................................................. 108 4.3. Iteratory ...................................................d...................................................d....... 109 4.4. Wzorce projektowe ...................................................d......................................... 113 4.4.1. Wzorzec strategii ...................................................d............................... 114 4.4.2. Wzorzec Singleton ...................................................d............................ 116 Spis treści 7 4.4.3. Wzorzec fabryki ...................................................d................................ 117 4.4.4. Wzorzec obserwatora ...................................................d........................ 120 4.5. Refleksja (ang. reflection) ...................................................d............................... 122 4.5.1. Wprowadzenie ..................................................d.................................... 122 4.5.2. Interfejs Reflector ...................................................d.............................. 123 4.5.3. Przykłady użycia refleksji ...................................................d................. 125 4.5.4. Implementowanie wzorca delegata przy użyciu refleksji ..................... 126 4.6. Podsumowanie ...................................................d................................................ 128 Rozdział 5. Jak napisać aplikację sieci WWW z PHP ........................................ 129 5.1. Wprowadzenie ...................................................d................................................ 129 5.2. Osadzanie w kodzie HTML ...................................................d............................ 130 5.3. Dane wprowadzane przez użytkownika ...................................................d.......... 132 5.4. Zabezpieczanie danych wprowadzanych przez użytkownika .............................. 134 5.4.1. Pospolite błędy ...................................................d.................................. 135 5.5. Techniki zabezpieczania skryptów ...................................................d................. 137 5.5.1. Sprawdzanie danych wejściowych ...................................................d.... 137 5.5.2. Weryfikacja HMAC ...................................................d.......................... 139 5.5.3. PEAR::Crypt_HMAC ...................................................d....................... 140 5.5.4. Program filtrujący ...................................................d............................. 143 5.5.5. Praca z hasłami ...................................................d.................................. 144 5.5.6. Obsługa błędów ...................................................d................................. 145 5.6. Cookies ...................................................d...................................................d........ 146 5.7. Sesje ...................................................d...................................................d............. 149 5.8. Wgrywanie plików (ang. upload) ...................................................d................... 153 5.8.1. Obsługiwanie przychodzącego wgrywanego pliku .............................. 153 5.9. Architektura ...................................................d...................................................d. 158 5.9.1. Jeden skrypt obsługuje wszystko ...................................................d....... 158 5.9.2. Jeden skrypt na funkcję ...................................................d..................... 159 5.9.3. Oddzielanie logiki od układu ...................................................d............ 159 5.10. Podsumowanie ...................................................d................................................ 161 Rozdział 6. Bazy danych z PHP5 ...................................................n.................. 163 6.1. Wprowadzenie ...................................................d................................................ 163 6.2. MySQL ...................................................d...................................................d........ 164 6.2.1. Mocne i słabe strony MySQL .................................................d.............. 164 6.2.2. Interfejs PHP ...................................................d..................................... 165 6.2.3. Przykładowe dane ...................................................d............................. 166 6.2.4. Połączenia ...................................................d......................................... 166 6.2.5. Zapytania buforowane i niebuforowane ............................................... 168 6.2.6. Zapytania ...................................................d........................................... 168 6.2.7. Zapytania z wieloma instrukcjami ...................................................d..... 169 6.2.8. Tryby pobierania ...................................................d............................... 170 6.2.9. Zapytania preinterpretowane ...................................................d............. 170 6.2.10. Obsługa BLOB ...................................................d.................................. 173 6.3. SQLite ..................................................d...................................................d........... 174 6.3.1. Mocne i słabe strony SQLite ...................................................d............. 174 6.3.2. Najlepsze obszary zastosowania ...................................................d........ 176 6.3.3. Interfejs PHP ...................................................d..................................... 176 6.4. PEAR DB ...................................................d...................................................d.... 191 6.4.1. Uzyskiwanie PEAR BD ...................................................d.................... 191 6.4.2. Wady i zalety abstrakcji baz danych ...................................................d. 191 6.4.3. Które funkcje są abstrahowane ...................................................d.......... 192 6.4.4. Połączenia z bazą danych ...................................................d.................. 193 8 PHP5. Tajniki programowania 6.4.5. Wykonywanie zapytań ...................................................d...................... 195 6.4.6. Pobieranie wyników ...................................................d.......................... 198 6.4.7. Sekwencje ...................................................d......................................... 200 6.4.8. Funkcje związane z przenośnością ...................................................d.... 201 6.4.9. Błędy abstrakcyjne ...................................................d............................ 203 6.4.10. Metody złożone ...................................................d................................. 205 6.5. Podsumowanie ...................................................d................................................ 207 Rozdział 7. Obsługa błędów ...................................................n......................... 209 7.1. Wprowadzenie ...................................................d................................................ 209 7.2. Rodzaje błędów ...................................................d.............................................. 210 7.2.1. Błędy programistyczne ...................................................d...................... 210 7.2.2. Niezdefiniowane symbole ...................................................d................. 213 7.2.3. Błędy dotyczące przenośności ...................................................d........... 215 7.2.4. Błędy wykonania ...................................................d............................... 219 7.2.5. Błędy PHP ...................................................d......................................... 219 7.3. Błędy PEAR ...................................................d...................................................d 225 7.3.1. Klasa PEAR_Error ...................................................d............................ 228 7.3.2. Obsługa błędów PEAR ...................................................d...................... 231 7.3.3. Tryby błędów PEAR ...................................................d......................... 232 7.3.4. Łagodna obsługa błędów ...................................................d................... 233 7.4. Wyjątki ...................................................d...................................................d........ 235 7.4.1. Co to są wyjątki ...................................................d................................. 235 7.4.2. try, catch i throw ...................................................d............................... 236 7.5. Podsumowanie ...................................................d................................................ 238 Rozdział 8. XML i PHP5 ...................................................n............................... 239 8.1. Wprowadzenie ...................................................d................................................ 239 8.2. Słownictwo ...................................................d...................................................d.. 240 8.3. Parsowanie XML-a ...................................................d......................................... 242 8.3.1. SAX ...................................................d.................................................. 242 8.3.2. DOM ...................................................d................................................. 246 8.4. SimpleXML ...................................................d...................................................d. 250 8.4.1. Tworzenie obiektu SimpleXML ...................................................d........ 251 8.4.2. Przeglądanie obiektów SimpleXML ...................................................d. 251 8.4.3. Zapisywanie obiektów SimpleXML ...................................................d.. 253 8.5. PEAR ...................................................d...................................................d........... 253 8.5.1. XML_Tree ...................................................d........................................ 253 8.5.2. XML_RSS ...................................................d......................................... 254 8.6. Przekształcanie XML-a ...................................................d................................... 257 8.6.1. XSLT ...................................................d................................................. 257 8.7. Komunikacja za pośrednictwem XML ...................................................d........... 261 8.7.1. XML-RPC ...................................................d......................................... 262 8.7.2. SOAP ...................................................d................................................ 269 8.8. Podsumowanie ...................................................d................................................ 275 Rozdział 9. Najważniejsze rozszerzenia ...................................................n......... 277 9.1. Wprowadzenie ...................................................d................................................ 277 9.2. Pliki i strumienie ...................................................d............................................. 278 9.2.1. Dostęp do plików ...................................................d.............................. 278 9.2.2. Dane wejściowe i wyjściowe z programu ............................................ 280 9.2.3. Strumienie wejścia/wyjścia ...................................................d............... 283 9.2.4. Strumienie kompresji ...................................................d........................ 284 9.2.5. Strumienie użytkownika ...................................................d.................... 286 9.2.6. Strumienie URL ...................................................d................................ 288 Spis treści 9 9.2.7. Blokowanie ...................................................d....................................... 292 9.2.8. Zmiana nazwy i usuwanie plików ...................................................d..... 293 9.2.9. Pliki tymczasowe ...................................................d.............................. 294 9.3. Wyrażenia regularne ...................................................d....................................... 295 9.3.1. Składnia ..................................................d.............................................. 295 9.3.2. Funkcje ...................................................d.............................................. 308 9.4. Obsługa dat ...................................................d...................................................d.. 315 9.4.1. Odczytywanie daty i godziny ...................................................d............ 315 9.4.2. Formatowanie daty i godziny ...................................................d............ 318 9.4.3. Parsowanie dat w różnych formatach ...................................................d 326 9.5. Operacje na grafice przy użyciu GD ...................................................d............... 326 9.5.1. Przypadek 1: formularz odporny na działanie robotów ........................ 328 9.5.2. Przypadek 2: wykres słupkowy ...................................................d......... 333 9.5.3. Rozszerzenie Exif ...................................................d.............................. 338 9.6. Wielobajtowe ciągi i zestawy znaków ...................................................d............ 340 9.6.1. Konwersje zestawów znaków ..................................................d............. 341 9.6.2. Dodatkowe funkcje obsługujące zestawy znaków wielobajtowych ..... 346 9.6.3. Ustawienia międzynarodowe ..................................................d.............. 350 9.7. Podsumowanie ...................................................d................................................ 353 Rozdział 10. Stosowanie PEAR ...................................................n...................... 355 10.1. Wprowadzenie ...................................................d................................................ 355 10.2. Pojęcia związane z PEAR ...................................................d............................... 356 10.2.1. Pakiety ...................................................d.............................................. 356 10.2.2. Wersje ...................................................d............................................... 357 10.2.3. Numery wersji ...................................................d................................... 358 10.3. Pobieranie repozytorium PEAR ...................................................d...................... 360 10.3.1. Instalowanie dystrybucji PHP PEAR dla systemów UNIX/Linux ....... 360 10.3.2. Windows ...................................................d........................................... 361 10.3.3. go-pear.org ...................................................d........................................ 362 10.4. Instalowanie pakietów ...................................................d.................................... 365 10.4.1. Polecenie pear ...................................................d................................... 366 10.5. Parametry konfiguracyjne ...................................................d............................... 369 10.6. Polecenia PEAR ..................................................d............................................... 376 10.6.1. Polecenie pear install ...................................................d........................ 376 10.6.2. Polecenie pear list ...................................................d............................. 380 10.6.3. Polecenie pear info ...................................................d............................ 381 10.6.4. Polecenie pear list-all ...................................................d........................ 382 10.6.5. Polecenie pear list-upgrades ...................................................d.............. 382 10.6.6. Polecenie pear upgrade ...................................................d..................... 383 10.6.7. Polecenie pear upgrade-all ...................................................d................ 384 10.6.8. Polecenie pear uninstall ..................................................d...................... 385 10.6.9. Polecenie pear search ...................................................d........................ 385 10.6.10. Polecenie pear remote-list ...................................................d................. 386 10.6.11. Polecenie pear remote-info ...................................................d............... 387 10.6.12. Polecenie pear download ...................................................d.................. 387 10.6.13. Polecenie pear config-get ...................................................d.................. 388 10.6.14. Polecenie pear config-set ...................................................d.................. 388 10.6.15. Polecenie pear config-show ...................................................d.............. 388 10.6.16. Skróty ...................................................d................................................ 389 10.7. Interfejsy instalatora ...................................................d....................................... 390 10.7.1. Instalator CLI (Command Line Interface) ............................................ 390 10.7.2. Instalator Gtk ...................................................d.................................... 390 10.8. Podsumowanie ...................................................d................................................ 393 10 PHP5. Tajniki programowania Rozdział 11. Najważniejsze pakiety PEAR ...................................................n...... 395 11.1. Wprowadzenie ...................................................d................................................ 395 11.2. Zapytania do bazy danych ...................................................d.............................. 395 11.3. Systemy szablonów ...................................................d........................................ 395 11.3.1. Pojęcia związane z szablonami ...................................................d......... 396 11.3.2. Szablon HTML_Template_IT ...................................................d........... 396 11.3.3. Szablon HTML_Template_Flexy ...................................................d...... 399 11.4. Uwierzytelnianie ...................................................d............................................. 404 11.4.1. Informacje ogólne ...................................................d............................. 404 11.4.2. Przykład: Auth i plik z hasłami ...................................................d......... 405 11.4.3. Przykład: Auth i baza danych z danymi o użytkowniku ...................... 406 11.4.4. Bezpieczeństwo pracy z pakietem Auth ............................................... 408 11.4.5. Skalowalność Auth ...................................................d........................... 410 11.4.6. Podsumowanie informacji o Auth ...................................................d..... 411 11.5. Obsługa formularzy ...................................................d........................................ 411 11.5.1. Pakiet HTML_QuickForm ...................................................d................ 411 11.5.2. Przykład: formularz logowania ...................................................d......... 412 11.5.3. Pobieranie danych ...................................................d............................. 412 11.6. Buforowanie ...................................................d...................................................d 412 11.6.1. Pakiet Cache_Lite ...................................................d............................. 413 11.7. Podsumowanie ...................................................d................................................ 414 Rozdział 12. Tworzenie komponentów PEAR ...................................................n.. 415 12.1. Wprowadzenie ...................................................d................................................ 415 12.2. Standardy PEAR ...................................................d............................................. 415 12.2.1. Nazewnictwo symboli ...................................................d....................... 416 12.2.2. Wcięcia ...................................................d............................................. 418 12.3. Numery wersji ...................................................d................................................ 420 12.4. Środowisko wiersza polecenia ...................................................d........................ 421 12.5. Podstawy ...................................................d...................................................d...... 422 12.5.1. Kiedy i w jaki sposób można dołączać pliki ........................................ 422 12.5.2. Obsługa błędów ..................................................d.................................. 423 12.6. Tworzenie pakietów ...................................................d........................................ 423 12.6.1. Przykład PEAR: HelloWorld ...................................................d............ 424 12.6.2. Tworzenie archiwum tarball ...................................................d.............. 426 12.6.3. Weryfikacja ...................................................d....................................... 427 12.6.4. Testy regresji ...................................................d..................................... 428 12.7. Format pliku package.xml ...................................................d.............................. 428 12.7.1. Informacje o pakiecie ...................................................d........................ 429 12.7.2. Informacje o wersji ...................................................d........................... 431 12.8. Zależności ...................................................d...................................................d.... 436 12.8.1. Element deps ...................................................d................................ 436 12.8.2. Element dep ...................................................d.................................. 436 12.8.3. Typy zależności ..................................................d.................................. 437 12.8.4. Dlaczego należy unikać zależności ...................................................d... 438 12.8.5. Zależności opcjonalne ...................................................d....................... 439 12.8.6. Przykłady ...................................................d.......................................... 439 12.9. Zastępowanie ciągów znaków ...................................................d........................ 440 12.9.1. Element replace ...................................................d............................ 440 12.9.2. Przykłady ...................................................d.......................................... 440 12.10. Włączanie kodu w języku C ...................................................d........................... 441 12.10.1. Element configureoptions ...................................................d............. 441 12.10.2. Element configureoption ...................................................d.............. 441 Spis treści 11 12.11. Publikowanie pakietów ..................................................d.................................... 442 12.12. Proces publikowania pakietów PEAR ...................................................d............ 442 12.13. Przygotowanie pakietu ...................................................d................................... 444 12.13.1. Analiza kodu źródłowego ...................................................d................. 444 12.13.2. Generowanie sum kontrolnych MD5 ...................................................d 444 12.13.3. Aktualizacja pliku package.xml ...................................................d........ 444 12.13.4. Tworzenie archiwum tarball ...................................................d............. 445 12.14. Przesyłanie kodu ...................................................d............................................. 445 12.14.1. Przesyłanie wydania ...................................................d.......................... 445 12.14.2. Koniec ...................................................d............................................... 446 12.15. Podsumowanie ...................................................d................................................ 446 Rozdział 13. Migracja ...................................................n................................... 447 13.1. Wprowadzenie ...................................................d................................................ 447 13.2. Model obiektowy ...................................................d............................................ 447 13.3. Przekazywanie obiektów do funkcji ...................................................d............... 448 13.4. Tryb zgodności ...................................................d............................................... 449 13.4.1. Konwersja obiektów ...................................................d........................... 449 13.4.2. Porównywanie obiektów ...................................................d..................... 450 13.5. Inne zmiany ...................................................d...................................................d. 451 13.5.1. Przypisywanie wartości do zmiennej $this ............................................ 451 13.5.2. get_class ...................................................d.............................................. 454 13.6. E_STRICT ...................................................d...................................................d... 454 13.6.1. „Automagiczne” tworzenie obiektów ...................................................d. 454 13.6.2. var i public ...................................................d.......................................... 455 13.6.3. Konstruktory ...................................................d....................................... 455 13.6.4. Metody dziedziczone ...................................................d.......................... 456 13.6.5. Definiowanie klas przed ich wykorzystaniem ........................................ 456 13.7. Inne problemy zgodności ...................................................d................................ 456 13.7.1. Interfejs wiersza polecenia ...................................................d.................. 457 13.7.2. Komentarze ...................................................d......................................... 457 13.7.3. MySQL ...................................................d............................................... 458 13.8. Zmiany w funkcjach ...................................................d....................................... 458 13.8.1. array_merge() ...................................................d...................................... 459 13.8.2. strrpos() i strripos() ...................................................d............................. 459 13.9. Podsumowanie ...................................................d................................................ 460 Rozdział 14. Wydajność ...................................................n................................ 461 14.1. Wprowadzenie ...................................................d................................................ 461 14.2. Projektowanie wydajnych aplikacji ...................................................d................ 462 14.2.1. Wskazówka 1: uwaga na stany ..................................................d............. 462 14.2.2. Wskazówka 2: buforowanie ...................................................d................ 463 14.2.3. Wskazówka 3: nie należy przesadzać z projektowaniem ....................... 469 14.3. Testy szybkości ...................................................d............................................... 470 14.3.1. Zastosowanie programu ApacheBench .................................................. 470 14.3.2. Zastosowanie programu Siege ...................................................d............ 471 14.3.3. Testowanie a rzeczywisty ruch ...................................................d........... 472 14.4. Tworzenie profilu aplikacji za pomocą programu Profiler z pakietu Zend Studio .....472 14.5. Tworzenie profili za pomocą APD ...................................................d................. 473 14.5.1. Instalacja debugera APD ...................................................d..................... 474 14.5.2. Analiza danych ..................................................d..................................... 475 14.6. Tworzenie profili za pomocą programu Xdebug ............................................... 478 14.6.1. Instalacja programu Xdebug ...................................................d............... 478 14.6.2. Śledzenie wykonywania skryptu ...................................................d......... 479 14.6.3. Zastosowanie programu KCachegrind ...................................................d 481 12 PHP5. Tajniki programowania 14.7. Zastosowanie APC (Advanced PHP Cache) ...................................................d... 483 14.8. Zastosowanie ZPS (Zend Performance Suite) ...................................................d 484 14.8.1. Automatyczna optymalizacja ...................................................d.............. 484 14.8.2. Buforowanie skompilowanego kodu ...................................................d... 485 14.8.3. Buforowanie dynamicznych stron ...................................................d....... 486 14.8.4. Kompresja stron ...................................................d.................................. 489 14.9. Optymalizacja kodu ...................................................d........................................ 490 14.9.1. Mikrotesty szybkości ...................................................d.......................... 491 14.9.2. Przepisywanie kodu w PHP na język C ................................................. 493 14.9.3. Kod obiektowy a proceduralny ...................................................d........... 493 14.10. Podsumowanie ...................................................d................................................ 495 Rozdział 15. Wstęp do pisania rozszerzeń PHP .................................................. 497 15.1. Wprowadzenie ...................................................d................................................ 497 15.2. Szybki start ...................................................d...................................................d.. 498 15.2.1. Zarządzanie pamięcią ...................................................d.......................... 503 15.2.2. Zwracanie wartości z funkcji PHP ...................................................d...... 504 15.2.3. Dokończenie funkcji self_concat() ...................................................d...... 504 15.2.4. Podsumowanie przykładu ...................................................d................... 506 15.2.5. Tworzenie interfejsu dla bibliotek zewnętrznych ................................... 506 15.2.6. Zmienne globalne ..................................................d................................. 515 15.2.7. Wprowadzanie własnych dyrektyw INI ................................................. 515 15.2.8. Makra TSRM (Thread-Safe Resource Manager) ................................... 517 15.3. Podsumowanie ...................................................d................................................ 518 Rozdział 16. Tworzenie skryptów powłoki w PHP .............................................. 521 16.1. Wprowadzenie ...................................................d................................................ 521 16.2. Wykorzystanie PHP do pisania skryptów powłoki działających w wierszu polecenia ...................................................d................... 521 16.2.1. Różnice pomiędzy wersjami CLI i CGI ................................................. 522 16.2.2. Środowisko wykonywania skryptów powłoki ........................................ 524 16.2.3. Przetwarzanie opcji wiersza polecenia ...................................................d 526 16.2.4. Dobre praktyki ...................................................d.................................... 529 16.2.5. Zarządzanie procesami ...................................................d........................ 530 16.2.6. Przykłady ...................................................d............................................ 533 16.3. Podsumowanie ...................................................d................................................ 539 Dodatek A Zestawienie pakietów repozytoriów PEAR i PECL ........................... 541 A.1. Uwierzytelnianie ...................................................d.............................................. 541 A.2. Testy szybkości ...................................................d................................................ 545 A.3. Buforowanie ...................................................d...................................................d. 545 A.4. Konfiguracja ...................................................d...................................................d. 546 A.5. Obsługa konsoli ...................................................d............................................... 547 A.6. Bazy danych ...................................................d...................................................d.. 549 A.7. Godziny i daty ...................................................d.................................................. 560 A.8. Szyfrowanie ...................................................d...................................................d.. 562 A.9. Formaty plików ...................................................d................................................ 564 A.10. System plików ...................................................d................................................. 568 A.11. Elementy obsługi Gtk ...................................................d...................................... 570 A.12. HTML ...................................................d...................................................d........... 571 A.13. HTTP ...................................................d...................................................d............ 585 A.14. Pliki graficzne ...................................................d.................................................. 588 A.15. Obsługa ustawień międzynarodowych ..................................................d.............. 592 A.16. Rejestrowanie ...................................................d.................................................. 594 A.17. Poczta ...................................................d...................................................d........... 595 Spis treści 13 A.18. Operacje matematyczne ...................................................d................................... 598 A.19. Obsługa sieci ...................................................d...................................................d 602 A.20. Liczby ...................................................d...................................................d........... 616 A.21. Płatności ...................................................d...................................................d....... 617 A.22. PEAR ...................................................d...................................................d............ 619 A.23. PHP ...................................................d...................................................d.............. 621 A.24. Przetwarzanie danych ...................................................d...................................... 629 A.25. Obliczenia naukowe ...................................................d........................................ 629 A.26. Strumienie ...................................................d...................................................d.... 630 A.27. Struktury ...................................................d...................................................d....... 632 A.28. System ...................................................d...................................................d.......... 634 A.29. Przetwarzanie tekstu ...................................................d........................................ 635 A.30. Narzędzia ...................................................d...................................................d...... 637 A.31. Serwisy internetowe ...................................................d........................................ 640 A.32. XML ...................................................d...................................................d............. 642 Dodatek B Format pakietu phpDocumentor ...................................................n. 653 B.1. Wprowadzenie ...................................................d................................................. 653 B.2. Tworzenie dokumentacji za pomocą komentarzy ............................................... 654 B.3. Znaczniki ...................................................d...................................................d...... 655 B.4. Tabela znaczników ...................................................d........................................... 670 B.5. Korzystanie z narzędzia phpDocumentor ...................................................d......... 670 Dodatek C Zend Studio — szybki start ...................................................n........ 679 C.1. Wersja 3.5.x ...................................................d...................................................d.. 679 C.2. O podręczniku Zend Studio Client — szybki start .............................................. 679 C.3. O firmie Zend ...................................................d...................................................d 680 C.4. Zend Studio Client: przegląd ..................................................d............................. 680 C.5. Edycja plików ...................................................d.................................................. 683 C.6. Projekty ...................................................d...................................................d......... 684 C.7. Korzystanie z debugera ...................................................d.................................... 685 C.8. Konfiguracja pakietu Zend Studio Server w celu debugowania i tworzenia profili .....688 C.9. Korzystanie z programu Profiler ...................................................d...................... 688 C.10. Obsługa produktu ..................................................d.............................................. 690 C.11. Najważniejsze własności ...................................................d................................. 691 Skorowidz ...................................................n.................................. 693 Rozdział 3. Język obiektowy „Wzniosłe myśli wymagają wzniosłego języka.” — Arystofanes 3.1. Wprowadzenie Obsługa programowania obiektowego została wprowadzona w PHP3. Choć nadawała się do pracy, była niezwykle uproszczona. Niewiele zmieniło się pod tym względem wraz z wydaniem wersji PHP4, gdyż w nowej wersji główny nacisk położono na zgodność z poprzednimi. To ogólne zapotrzebowanie na ulepszoną obsługę obiekto- wą spowodowało, że w PHP5 ponownie zaprojektowano cały model obiektowy, do- dając znaczną liczbę mechanizmów, a także zmieniając zachowanie podstawowego „obiektu”. Początkujący użytkownicy PHP dzięki lekturze tego rozdziału będą mogli zapoznać się z modelem obiektowym. Jednak zawarte tu informacje będą także użyteczne dla osób zaznajomionych już z PHP4, ponieważ wraz z wprowadzeniem wersji PHP5 uległo zmianie prawie wszystko, co ma związek z programowaniem obiektowym. Dzięki lekturze tego rozdziału czytelnik będzie mógł poznać:      podstawy modelu obiektowego, sposób tworzenia i cykl życia obiektu oraz metody jego sterowania, trzy główne słowa kluczowe ograniczania dostępu (RWDNKE, RTQVGEVGF i RTKXCVG), korzyści płynące z używania dziedziczności klas, wskazówki prowadzące do udanej obsługi wyjątków. 78 PHP5. Tajniki programowania 3.2. Obiekty Programowanie obiektowe różni się od funkcjonalnego głównie tym, że dane i kod występują w nim jako jedna całość, znana pod nazwą obiektu. Aplikacje obiektowe zazwyczaj są podzielone na pewną liczbę obiektów, które ze sobą współdziałają. Każdy obiekt zwykle reprezentuje jeden wyodrębniony, niezależny od innych pro- blem, i ma pewną liczbę właściwości i metod. Właściwości są danymi obiektu, co za- sadniczo oznacza zmienne, które należą do obiektu. Metody — dla osób przywykłych do pracy w środowiskach funkcjonalnych — są funkcjami, które obsługuje obiekt, zaś funkcjonalność, która według przeznaczenia ma być dostępna dla innych obiektów i wykorzystywana do interakcji z nimi, jest nazywana interfejsem obiektu. Rysunek 3.1 przedstawia klasę. Klasa jest czymś w rodzaju szablonu dla obiektu i opisuje metody i właściwości, które będzie miał obiekt danego typu. W tym przykła- dzie klasa reprezentuje osobę. Dla każdej osoby w aplikacji można stworzyć oddzielny egzemplarz tej klasy, reprezentujący informacje o tej osobie. Jeśli na przykład dwie osoby w naszej aplikacji noszą imiona Jan i Julia, można utworzyć dwa oddzielne egzem- plarze tej klasy i dla obu wywołać metodę UGV0COG , która pozwoli zainicjować zmienną PCOG, zawierającą imię danej osoby. Metody i składowe, których mogą używać inne oddziałujące obiekty, tworzą kontrakt klasy. W tym przykładzie kontraktami osoby ze światem zewnętrznym są dwie metody UGV i IGV, UGV0COG i IGV0COG . Rysunek 3.1. Schemat klasy Person Przedstawiony tu przykładowy kod PHP definiuje klasę, tworzy jej dwa egzemplarze, definiuje nazwę każdego egzemplarza, po czym wyświetla nazwy: ENCUU2GTUQP] RTKXCVGPCOG HWPEVKQPUGV0COG PCOG ] VJKU PCOGPCOG _ HWPEVKQPIGV0COG ] TGVWTPVJKU PCOG _ Rozdział 3. ♦ Język obiektowy 79 _ LWNKCPGY2GTUQP  LWNKC UGV0COG ,WNKC  LCPPGY2GTUQP  LCP UGV0COG ,CP  RTKPVLWNKC IGV0COG  P RTKPVLCP IGV0COG  P 3.3. Deklarowanie klasy Wnioskując z prezentowanego przed chwilą przykładu można stwierdzić, że zdefi- niowanie klasy (szablonu obiektu) nie jest niczym trudnym. Wystarczy użyć słowa kluczowego ENCUU, nadać klasie nazwę, po czym wymienić wszystkie metody i wła- ściwości, które powinien mieć egzemplarz tej klasy: ENCUU/[ NCUU] // Lista metod  // Lista właściwości  _ Jak widać, na początku definicji właściwości PCOG użyte zostało słowo kluczowe RTKXCVG. Zostanie ono omówione szczegółowo w dalszej części książki; w tym przy- padku oznacza ono, że do PCOG mogą mieć dostęp tylko metody z tej klasy. Zmusza to każdego, kto chciałby pobrać lub ustawić tę właściwość, do posłużenia się meto- dami IGV0COG i UGV0COG , które reprezentują interfejs klasy przeznaczony do użyt- ku przez inne obiekty lub kod źródłowy. 3.4. Słowo kluczowe new i konstruktory Egzemplarze klas są tworzone przy użyciu słowa kluczowego PGY. W poprzednim przykładzie nowy egzemplarz klasy 2GTUQP został utworzony przy pomocy instrukcji LWNKCPGY2GTUQP . Podczas wywołania PGY zostaje przydzielony nowy obiekt, z własnymi kopiami właściwości zdefiniowanymi we wskazanej klasie, po czym przywołany zostaje konstruktor obiektu, jeśli tylko został zdefiniowany. Konstruktor to metoda o nazwie AAEQPUVTWEV , która jest automatycznie przywoływana przez słowo kluczowe PGY po utworzeniu obiektu. Zazwyczaj służy do automatycznego wy- konywania różnych inicjalizacji, takich jak inicjalizacja właściwości. Konstruktory mogą również pobierać argumenty; w takim przypadku w momencie napisania in- strukcji PGY trzeba również przekazać konstruktorowi parametry funkcji, umieszczając je między nawiasami. 80 PHP5. Tajniki programowania W PHP4, podobnie jak w C++, zamiast używać metody AAEQPUVTWEV  jako nazwy konstruktora, definiowało się metodę, nadając jej taką samą nazwę jak ta, którą posia- dała klasa. W PHP5 możliwość ta wciąż istnieje, jednak dla nowych aplikacji należy używać nowej, zunifikowanej konwencji nazywania konstruktorów. Nasz poprzedni przykład można napisać w inny sposób, tak by w wierszu PGY kod przekazywał imiona osób: ENCUU2GTUQP] HWPEVKQPAAEQPUVTWEV PCOG ] VJKU PCOGPCOG _ HWPEVKQPIGV0COG ] TGVWTPVJKU PCOG _ RTKXCVGPCOG _ LWNKCPGY2GTUQP ,WNKC  P LCPPGY2GTUQP ,CP  P RTKPVLWNKC IGV0COG  RTKPVLCP IGV0COG  Wynik zwrócony przez ten kod będzie identyczny z tym z poprzedniego przykładu. Ponieważ konstruktor nie może zwracać wartości, najczęstszą praktyką zgłaszania błędu ze środka konstruktora jest rzucenie wyjątku. 3.5. Destruktory Destruktory to odwrotność konstruktorów. Wywoływane są one w momencie usu- wania obiektu (na przykład gdy do danego obiektu nie ma już referencji). Ponieważ PHP pilnuje, by po każdym żądaniu wszystkie zasoby zostały zwolnione, destruktory mają ograniczone znaczenie. Mimo to wciąż mogą być przydatne do wykonywania określonych czynności, takich jak opróżnianie zasobu lub informacji o rejestracji w momencie usuwania obiektu. Destruktor może być wywołany w dwóch sytuacjach: podczas wykonywania skryptu, kiedy niszczone są wszystkie odwołania do obiektu, lub w momencie osiągnięcia końca skryptu i zakończenia wykonywania przez PHP żądania. Druga sytuacja jest dość niedogodna, ponieważ jest się uzależnionym od pewnych obiektów, których destruktory mogły już zostać wywołane, wskutek czego obiekty te nie są już dostępne. Stąd też destruktorów należy używać ostrożnie i nie uzależniać ich od innych obiektów. Rozdział 3. ♦ Język obiektowy 81 Definiowanie destruktora polega na dodaniu do klasy metody AAFGUVTWEV : ENCUU/[ NCUU] HWPEVKQPAAFGUVTWEV ] RTKPV0KUEQP[LGUVQDKGMVV[RW/[ NCUU P _ _ QDLPGY/[ NCUU  QDL07.. W rezultacie skrypt wyświetli: 0KUEQP[LGUVQDKGMVV[RW/[ NCUU W tym przykładzie dojście do instrukcji QDL07.. powoduje usunięcie jedynego uchwytu do obiektu, w następstwie czego zostaje wywołany destruktor, a sam obiekt ulega zniszczeniu. Destruktor zostałby wywołany także bez ostatniego wiersza kodu, tym razem jednak podczas kończenia wykonywania żądania. PHP nie gwarantuje dokładnego czasu wywołania destruktora. Może to być kilka instrukcji po wykonaniu ostatniego odwołania do obiektu. Z tego właśnie względu należy uważać, by nie pisać aplikacji w sposób, który mógłby doprowadzić do kło- potów. 3.6. Odwoływanie się do metod i właściwości przy użyciu zmiennej $this Podczas wykonywania metody obiektu definiowana jest automatycznie specjalna zmienna o nazwie VJKU, która jest odwołaniem do samego obiektu. Używając tej zmien- nej i notacji  można odwoływać się do metod i właściwości tego obiektu. Na przy- kład można uzyskać dostęp do właściwości PCOG przy użyciu instrukcji VJKU PCOG (należy zauważyć, że przed nazwą właściwości nie używa się znaku ). Metody obiektu można udostępnić w ten sam sposób: na przykład z wnętrza jednej z metod klasy osoby (2GTUQP) można wywołać funkcję IGV0COG , wpisując instrukcję VJKU IGV0COG . 3.6.1. Właściwości public, protected i private W programowaniu obiektowym kluczowym paradygmatem jest hermetyzacja i kon- trola dostępu do właściwości obiektu (nazywanych także zmiennymi składowymi). W najpopularniejszych językach obiektowych można spotkać trzy główne słowa klu- czowe kontroli dostępu: RWDNKE, RTQVGEVGF i RTKXCVG. 82 PHP5. Tajniki programowania Definiując składową klasy w definicji klasy, programista musi przed zadeklarowa- niem samej składowej umieścić jedno z tych trzech słów. Osoby zaznajomione z mo- delem obiektowym PHP3 lub 4 wiedzą, że w tamtych wersjach wszystkie składowe klasy były definiowane ze słowem kluczowym XCT. W PHP5 jego odpowiednikiem jest słowo kluczowe RWDNKE, choć etykieta XCT została zachowana w celu zapewnienia kompatybilności ze starszymi wersjami programu. Składnia ta jest jednak przestarzała, dlatego namawiamy do przekształcenia swych skryptów i dostosowania ich do nowych wymogów: ENCUU/[ NCUU] RWDNKERWDNKE/GODGT5MđCFQYCRWDNKEPC RTQVGEVGFRTQVGEVGF/GODGT5MđCFQYCEJTQPKQPC RTKXCVGRTKXCVG/GODGT5MđCFQYCRT[YCVPC HWPEVKQPO[/GVJQF ] // ... _ _ QDLPGY/[ NCUU  Ten przykład będzie jeszcze rozbudowywany, w celu zademonstrowania użycia tych modyfikatorów dostępu. Najpierw jednak podajmy definicję każdego z modyfikatorów dostępu:    RWDNKE. Dostęp do składowych publicznych można uzyskać spoza obiektu przy użyciu kodu QDL RWDNKE/GODGT oraz z wnętrza metody O[/GVJQF przy użyciu specjalnej zmiennej VJKU (na przykład VJKU RWDNKE/GODGT). Jeśli składową publiczną odziedziczy inna klasa, zastosowanie mają te same zasady, co oznacza, że dostęp do niej można uzyskać tak z obiektów spoza klasy pochodnej, jak i z wnętrza metod do niej należących. RTQVGEVGF. Dostęp do składowych chronionych można uzyskać tylko z wnętrza metody obiektu — na przykład VJKU RTQVGEVGF/GODGT. Jeśli inna klasa odziedziczy składową chronioną, zastosowanie mają te same zasady, można zatem do niej sięgnąć z wnętrza metody pochodnego obiektu poprzez specjalną zmienną VJKU. RTKXCVG. Składowe prywatne są podobne do składowych chronionych, ponieważ dostęp do nich jest możliwy tylko z wnętrza metody obiektu. Nie są natomiast dostępne z metod obiektów pochodnych. Ponieważ właściwości prywatne nie są widoczne z klas pochodnych, dwie pokrewne ze sobą klasy mogą deklarować te same właściwości prywatne. Każda klasa będzie „widzieć” tylko własną prywatną kopię, która nie jest powiązana z innymi. Zazwyczaj w przypadku składowych, które mają być dostępne spoza obiektu, należy używać słowa RWDNKE, zaś dla tych, które są — według logiki obiektu — wewnętrzne, słowa RTKXCVG. Z kolei słowa RTQVGEVGF należy używać do tych s
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

PHP5. Tajniki programowania
Autor:
, ,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: