Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00073 006625 13598419 na godz. na dobę w sumie
PHP. Obiekty, wzorce, narzędzia. Wydanie IV - ebook/pdf
PHP. Obiekty, wzorce, narzędzia. Wydanie IV - ebook/pdf
Autor: Liczba stron: 488
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-9181-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> php - programowanie
Porównaj ceny (książka, ebook, audiobook).

Twój przewodnik po obiektowym PHP!

Język PHP przebył długą drogę od swoich początków do obecnego poziomu rozwoju. Dziś jest pełnoprawnym, obiektowym językiem programowania, wciąż zdobywającym większe zaufanie i używanym w coraz większych projektach. Jeżeli znasz ten język od dawna, lecz nie jesteś przekonany, że nadaje się on do zaawansowanych zastosowań, albo dopiero zaczynasz karierę i potrzebujesz szybkiego wprowadzenia w świat obiektów czy wzorców projektowych w języku PHP, to jest właśnie książka dla Ciebie!

Sięgnij po nią i przekonaj się na własnej skórze, że PHP to dojrzały język, który nie ustępuje konkurentom. W trakcie lektury poznasz podstawowe zagadnienia związane z programowaniem obiektowym, a następnie przejdziesz do nauki zaawansowanej obsługi obiektów w języku PHP. Kolejne rozdziały zostały poświęcone między innymi wzorcom projektowym, dobrym i złym praktykom, zastosowaniu PEAR i Pyrus oraz sposobom automatycznego generowania dokumentacji i tworzenia kodu wysokiej jakości dzięki testom automatycznym. Książka ta jest doskonałą lekturą dla każdego programisty PHP chcącego podnieść swoje kwalifikacje.

Dzięki tej książce:

Poznaj zaawansowane możliwości języka PHP!

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

Darmowy fragment publikacji:

Tytuł oryginału: PHP Objects, Patterns, and Practice, Fourth Edition Tłumaczenie: Przemysław Szeremiota ISBN: 978-83-246-9178-4 Original edition copyright © 2013 by Matt Zandstra All rights reserved. Polish edition copyright © 2014 by HELION SA. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/phpob4.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/phpob4 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:258)ci Rozdzia(cid:239) 1. O autorze ...............................................................................................................13 O recenzencie technicznym ....................................................................................15 Podzi(cid:218)kowania ......................................................................................................17 Wprowadzenie ......................................................................................................19 PHP — projektowanie i zarz(cid:200)dzanie ......................................................................21 Problem ................................................................................................................................................. 21 PHP a inne języki programowania .................................................................................................... 22 O książce ............................................................................................................................................... 24 Obiekty ........................................................................................................................................... 24 Wzorce ............................................................................................................................................ 24 Narzędzia ....................................................................................................................................... 25 Nowości w czwartym wydaniu ................................................................................................... 26 Podsumowanie ..................................................................................................................................... 26 Rozdzia(cid:239) 2. Obiekty ..................................................................................................................27 Nieoczekiwany sukces obiektów w PHP .......................................................................................... 27 PHP/FI — u zarania języka ......................................................................................................... 27 PHP3 — składniowy lukier ......................................................................................................... 27 Cicha rewolucja — PHP4 ............................................................................................................ 28 PHP5 — nieuchronne zmiany .................................................................................................... 29 Debata obiektowa — za czy przeciw? ............................................................................................... 30 Podsumowanie ..................................................................................................................................... 30 Rozdzia(cid:239) 3. Obiektowy elementarz ..........................................................................................31 Klasy i obiekty ...................................................................................................................................... 31 Pierwsza klasa ................................................................................................................................ 31 Pierwszy obiekt (lub dwa) ........................................................................................................... 32 Definiowanie składowych klasy ......................................................................................................... 33 Metody .................................................................................................................................................. 35 Metoda konstrukcji obiektu ........................................................................................................ 36 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Rozdzia(cid:239) 4. Typy argumentów metod ................................................................................................................... 37 Typy elementarne ......................................................................................................................... 38 Typy obiektowe ............................................................................................................................. 40 Dziedziczenie ........................................................................................................................................ 42 Problemy związane z dziedziczeniem ........................................................................................ 42 Stosowanie dziedziczenia ............................................................................................................. 46 Zarządzanie dostępem do klasy — słowa public, private i protected ................................... 50 Podsumowanie ..................................................................................................................................... 54 Zaawansowana obs(cid:239)uga obiektów ........................................................................55 Metody i składowe statyczne .............................................................................................................. 55 Składowe stałe ...................................................................................................................................... 58 Klasy abstrakcyjne ............................................................................................................................... 59 Interfejsy ................................................................................................................................................ 61 Cechy typowe ....................................................................................................................................... 62 Zadanie dla cech typowych ......................................................................................................... 62 Definiowanie i stosowanie cechy typowej ................................................................................. 63 Stosowanie wielu cech typowych ................................................................................................ 64 Łączenie cech z interfejsami ........................................................................................................ 64 Unikanie kolizji nazw metod za pomocą słowa insteadof ...................................................... 65 Aliasy metod cech typowych ....................................................................................................... 67 Cechy typowe z metodami statycznymi .................................................................................... 68 Dostęp do składowych klasy włączającej ................................................................................... 68 Definiowanie metody abstrakcyjnej cechy typowej ................................................................. 69 Zmiana dostępności metod cech typowych .............................................................................. 70 Późne wiązanie statyczne: słowo static ............................................................................................. 71 Obsługa błędów .................................................................................................................................... 73 Wyjątki ........................................................................................................................................... 75 Klasy i metody finalne ......................................................................................................................... 80 Przechwytywanie chybionych wywołań ........................................................................................... 81 Definiowanie destruktorów ................................................................................................................ 86 Wykonywanie kopii obiektów ........................................................................................................... 87 Reprezentacja obiektu w ciągach znaków ........................................................................................ 90 Wywołania zwrotne, funkcje anonimowe i domknięcia ................................................................ 91 Podsumowanie ..................................................................................................................................... 94 Rozdzia(cid:239) 5. Narz(cid:218)dzia obiektowe .............................................................................................95 PHP a pakiety ....................................................................................................................................... 95 Pakiety i przestrzenie nazw w PHP ............................................................................................ 95 Automatyczne wczytywanie kodu ............................................................................................ 103 Klasy i funkcje pomocnicze .............................................................................................................. 105 Szukanie klasy .............................................................................................................................. 106 Badanie obiektów i klas .............................................................................................................. 107 Pozyskiwanie ciągu pełnej nazwy klasy ................................................................................... 108 Badanie metod ............................................................................................................................. 108 Badanie składowych ................................................................................................................... 110 Badanie relacji dziedziczenia ..................................................................................................... 110 Badanie wywołań metod ............................................................................................................ 110 6 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Interfejs retrospekcji — Reflection API .......................................................................................... 112 Zaczynamy ................................................................................................................................... 112 Pora zakasać rękawy ................................................................................................................... 112 Badanie klasy ............................................................................................................................... 114 Badanie metod ............................................................................................................................. 116 Badanie argumentów metod ..................................................................................................... 117 Korzystanie z retrospekcji ......................................................................................................... 118 Podsumowanie ................................................................................................................................... 121 Rozdzia(cid:239) 6. Obiekty a projektowanie obiektowe ...................................................................123 Czym jest projektowanie? ................................................................................................................. 123 Programowanie obiektowe i proceduralne .................................................................................... 124 Odpowiedzialność ...................................................................................................................... 127 Spójność ....................................................................................................................................... 127 Sprzęganie .................................................................................................................................... 127 Ortogonalność ............................................................................................................................. 128 Zasięg klas ........................................................................................................................................... 128 Polimorfizm ........................................................................................................................................ 129 Hermetyzacja ...................................................................................................................................... 131 Nieważne jak ....................................................................................................................................... 132 Cztery drogowskazy .......................................................................................................................... 132 Zwielokrotnianie kodu ............................................................................................................... 133 Przemądrzałe klasy ..................................................................................................................... 133 Złota rączka ................................................................................................................................. 133 Za dużo warunków ..................................................................................................................... 133 Język UML .......................................................................................................................................... 133 Diagramy klas .............................................................................................................................. 134 Diagramy sekwencji ................................................................................................................... 139 Podsumowanie ................................................................................................................................... 141 Rozdzia(cid:239) 7. Czym s(cid:200) wzorce projektowe? Do czego si(cid:218) przydaj(cid:200)? .........................................143 Czym są wzorce projektowe? ........................................................................................................... 143 Wzorzec projektowy .......................................................................................................................... 145 Nazwa ........................................................................................................................................... 145 Problem ........................................................................................................................................ 146 Rozwiązanie ................................................................................................................................. 146 Konsekwencje .............................................................................................................................. 146 Format wzorca według Bandy Czworga ......................................................................................... 146 Po co nam wzorce projektowe? ....................................................................................................... 147 Wzorzec projektowy definiuje problem .................................................................................. 147 Wzorzec projektowy definiuje rozwiązanie ............................................................................ 147 Wzorce projektowe są niezależne od języka programowania .............................................. 147 Wzorce definiują słownictwo .................................................................................................... 148 Wzorce są wypróbowane ........................................................................................................... 148 Wzorce mają współpracować .................................................................................................... 149 Wzorce promują prawidła projektowe .................................................................................... 149 Wzorce są stosowane w popularnych frameworkach ........................................................... 149 Wzorce projektowe a PHP ............................................................................................................... 149 Podsumowanie ................................................................................................................................... 150 7 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Rozdzia(cid:239) 8. Wybrane prawid(cid:239)a wzorców ................................................................................151 Olśnienie wzorcami ........................................................................................................................... 151 Kompozycja i dziedziczenie ............................................................................................................. 152 Problem ........................................................................................................................................ 152 Zastosowanie kompozycji .......................................................................................................... 155 Rozprzęganie ...................................................................................................................................... 157 Problem ........................................................................................................................................ 157 Osłabianie sprzężenia ................................................................................................................. 158 Kod ma używać interfejsów, nie implementacji ............................................................................ 160 Zmienne koncepcje ........................................................................................................................... 161 Nadmiar wzorców ............................................................................................................................. 161 Wzorce ................................................................................................................................................ 161 Wzorce generowania obiektów ................................................................................................. 162 Wzorce organizacji obiektów i klas .......................................................................................... 162 Wzorce zadaniowe ...................................................................................................................... 162 Wzorce korporacyjne ................................................................................................................. 162 Wzorce baz danych ..................................................................................................................... 162 Podsumowanie ................................................................................................................................... 162 Rozdzia(cid:239) 9. Generowanie obiektów .......................................................................................163 Generowanie obiektów — problemy i rozwiązania ...................................................................... 163 Wzorzec Singleton ............................................................................................................................. 167 Problem ........................................................................................................................................ 167 Implementacja ............................................................................................................................. 168 Konsekwencje .............................................................................................................................. 169 Wzorzec Factory Method ................................................................................................................. 170 Problem ........................................................................................................................................ 170 Implementacja ............................................................................................................................. 172 Konsekwencje .............................................................................................................................. 174 Wzorzec Abstract Factory ................................................................................................................ 174 Problem ........................................................................................................................................ 174 Implementacja ............................................................................................................................. 175 Konsekwencje .............................................................................................................................. 177 Prototyp ............................................................................................................................................... 178 Problem ........................................................................................................................................ 178 Implementacja ............................................................................................................................. 179 Ależ to oszustwo! ............................................................................................................................... 181 Podsumowanie ................................................................................................................................... 182 Rozdzia(cid:239) 10. Wzorce elastycznego programowania obiektowego ...........................................183 Strukturalizacja klas pod kątem elastyczności obiektów ............................................................. 183 Wzorzec Composite .......................................................................................................................... 183 Problem ........................................................................................................................................ 184 Implementacja ............................................................................................................................. 186 Konsekwencje .............................................................................................................................. 189 Composite — podsumowanie ................................................................................................... 191 Wzorzec Decorator ............................................................................................................................ 192 Problem ........................................................................................................................................ 192 Implementacja ............................................................................................................................. 194 Konsekwencje .............................................................................................................................. 197 8 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Wzorzec Facade ................................................................................................................................. 197 Problem ........................................................................................................................................ 197 Implementacja ............................................................................................................................. 199 Konsekwencje .............................................................................................................................. 199 Podsumowanie ................................................................................................................................... 200 Rozdzia(cid:239) 11. Reprezentacja i realizacja zada(cid:241) ..........................................................................201 Wzorzec Interpreter .......................................................................................................................... 201 Problem ........................................................................................................................................ 201 Implementacja ............................................................................................................................. 202 Ciemne strony wzorca Interpreter ........................................................................................... 209 Wzorzec Strategy ............................................................................................................................... 209 Problem ........................................................................................................................................ 209 Implementacja ............................................................................................................................. 211 Wzorzec Observer ............................................................................................................................. 214 Implementacja ............................................................................................................................. 215 Wzorzec Visitor ................................................................................................................................. 220 Problem ........................................................................................................................................ 220 Implementacja ............................................................................................................................. 221 Wady wzorca Visitor .................................................................................................................. 225 Wzorzec Command ........................................................................................................................... 226 Problem ........................................................................................................................................ 226 Implementacja ............................................................................................................................. 226 Podsumowanie ................................................................................................................................... 230 Rozdzia(cid:239) 12. Wzorce korporacyjne ...........................................................................................231 Przegląd architektury ........................................................................................................................ 231 Wzorce .......................................................................................................................................... 232 Aplikacje i warstwy ..................................................................................................................... 232 Małe oszustwo na samym początku ................................................................................................ 235 Wzorzec Registry ........................................................................................................................ 235 Implementacja ............................................................................................................................. 236 Warstwa prezentacji .......................................................................................................................... 244 Wzorzec Front Controller ......................................................................................................... 244 Wzorzec Application Controller .............................................................................................. 253 Wzorzec Page Controller ........................................................................................................... 264 Wzorce Template View i View Helper .................................................................................... 268 Warstwa logiki biznesowej ............................................................................................................... 270 Wzorzec Transaction Script ...................................................................................................... 270 Wzorzec Domain Model ............................................................................................................ 274 Podsumowanie ................................................................................................................................... 277 Rozdzia(cid:239) 13. Wzorce bazodanowe ...........................................................................................279 Warstwa danych ................................................................................................................................. 279 Wzorzec Data Mapper ...................................................................................................................... 280 Problem ........................................................................................................................................ 280 Implementacja ............................................................................................................................. 280 Wzorzec Identity Map ...................................................................................................................... 293 Problem ........................................................................................................................................ 293 Implementacja ............................................................................................................................. 294 Konsekwencje .............................................................................................................................. 296 9 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Wzorzec Unit of Work ...................................................................................................................... 297 Problem ........................................................................................................................................ 297 Implementacja ............................................................................................................................. 297 Konsekwencje .............................................................................................................................. 301 Wzorzec Lazy Load ............................................................................................................................ 301 Problem ........................................................................................................................................ 301 Implementacja ............................................................................................................................. 302 Konsekwencje .............................................................................................................................. 303 Wzorzec Domain Object Factory .................................................................................................... 303 Problem ........................................................................................................................................ 303 Implementacja ............................................................................................................................. 304 Konsekwencje .............................................................................................................................. 305 Wzorzec Identity Object ................................................................................................................... 306 Problem ........................................................................................................................................ 306 Implementacja ............................................................................................................................. 307 Konsekwencje .............................................................................................................................. 311 Wzorce Selection Factory i Update Factory .................................................................................. 312 Problem ........................................................................................................................................ 312 Implementacja ............................................................................................................................. 312 Konsekwencje .............................................................................................................................. 315 Co zostało z wzorca Data Mapper? ................................................................................................. 316 Podsumowanie ................................................................................................................................... 318 Rozdzia(cid:239) 14. Dobre (i z(cid:239)e) praktyki ...........................................................................................319 Nie tylko kod ...................................................................................................................................... 319 Pukanie do otwartych drzwi ............................................................................................................ 320 Jak to zgrać? ........................................................................................................................................ 321 Uskrzydlanie kodu ............................................................................................................................. 322 Dokumentacja .................................................................................................................................... 323 Testowanie .......................................................................................................................................... 324 Ciągła integracja ................................................................................................................................. 325 Podsumowanie ................................................................................................................................... 325 Rozdzia(cid:239) 15. PEAR i Pyrus ........................................................................................................327 Czym jest PEAR? ............................................................................................................................... 327 Pyrus .................................................................................................................................................... 328 Instalowanie pakietu ......................................................................................................................... 329 Kanały PEAR ............................................................................................................................... 331 Korzystanie z pakietu z PEAR ......................................................................................................... 333 Obsługa błędów w pakietach PEAR ......................................................................................... 334 Tworzenie własnych pakietów PEAR ............................................................................................. 337 Plik package.xml ......................................................................................................................... 337 Składniki pakietu ........................................................................................................................ 338 Element contents ........................................................................................................................ 339 Zależności ..................................................................................................................................... 342 Dookreślanie instalacji — phprelease ...................................................................................... 343 Przygotowanie pakietu do dystrybucji .................................................................................... 344 Konfigurowanie własnego kanału PEAR ................................................................................ 345 Podsumowanie ................................................................................................................................... 348 10 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Rozdzia(cid:239) 16. Generowanie dokumentacji — phpDocumentor .................................................349 Po co nam dokumentacja? ................................................................................................................ 349 Instalacja ............................................................................................................................................. 350 Generowanie dokumentacji ............................................................................................................. 350 Komentarze DocBlock ...................................................................................................................... 352 Dokumentowanie klas ...................................................................................................................... 354 Dokumentowanie plików ................................................................................................................. 354 Dokumentowanie składowych ......................................................................................................... 355 Dokumentowanie metod .................................................................................................................. 357 Namespace support ........................................................................................................................... 357 Tworzenie odnośników w dokumentacji ....................................................................................... 359 Podsumowanie ................................................................................................................................... 361 Rozdzia(cid:239) 17. Zarz(cid:200)dzanie wersjami projektu z systemem Git ...................................................363 Po co mi kontrola wersji? ................................................................................................................. 363 Skąd wziąć klienta Git? ..................................................................................................................... 364 Konfigurowanie serwera Git ............................................................................................................ 365 Tworzenie repozytorium zdalnego .......................................................................................... 365 Rozpoczynamy projekt ..................................................................................................................... 367 Klonowanie repozytorium ......................................................................................................... 369 Wprowadzanie i zatwierdzanie zmian ............................................................................................ 370 Dodawanie i usuwanie plików i katalogów .................................................................................... 373 Dodawanie pliku ......................................................................................................................... 373 Usuwanie pliku ........................................................................................................................... 374 Dodawanie katalogu ................................................................................................................... 374 Usuwanie katalogów ................................................................................................................... 374 Etykietowanie wersji .......................................................................................................................... 375 Rozgałęzianie projektu ...................................................................................................................... 375 Podsumowanie ................................................................................................................................... 379 Rozdzia(cid:239) 18. Testy jednostkowe z PHPUnit ..............................................................................381 Testy funkcjonalne i testy jednostkowe .......................................................................................... 381 Testowanie ręczne ............................................................................................................................. 382 PHPUnit .............................................................................................................................................. 384 Tworzenie przypadku testowego .............................................................................................. 384 Metody asercji ............................................................................................................................. 385 Testowanie wyjątków ................................................................................................................. 386 Uruchamianie zestawów testów ............................................................................................... 387 Ograniczenia ................................................................................................................................ 388 Atrapy i imitacje .......................................................................................................................... 389 Dobry test to oblany test ............................................................................................................ 392 Testy dla aplikacji WWW ................................................................................................................. 394 Przygotowanie aplikacji WWW do testów ............................................................................. 395 Proste testy aplikacji WWW ..................................................................................................... 396 Selenium ....................................................................................................................................... 398 Słowo ostrzeżenia ............................................................................................................................... 402 Podsumowanie ................................................................................................................................... 404 11 Kup książkęPoleć książkę SPIS TRE(cid:165)CI Rozdzia(cid:239) 19. Automatyzacja instalacji z Phing .........................................................................405 Czym jest Phing? ................................................................................................................................ 406 Pobieranie i instalacja pakietu Phing .............................................................................................. 406 Montowanie dokumentu kompilacji .............................................................................................. 407 Różnicowanie zadań kompilacji ............................................................................................... 408 Właściwości ................................................................................................................................. 410 Typy .............................................................................................................................................. 416 Operacje ....................................................................................................................................... 420 Podsumowanie ................................................................................................................................... 424 Rozdzia(cid:239) 20. Ci(cid:200)g(cid:239)a integracja kodu .........................................................................................425 Czym jest ciągła integracja? .............................................................................................................. 425 Przygotowanie projektu do ciągłej integracji ......................................................................... 427 Jenkins ................................................................................................................................................. 436 Instalowanie Jenkinsa ................................................................................................................. 436 Instalowanie rozszerzeń Jenkinsa ............................................................................................. 438 Konfigurowanie klucza publicznego serwera Git .................................................................. 439 Instalowanie projektu ................................................................................................................. 439 Pierwsza kompilacja ................................................................................................................... 441 Konfigurowanie raportów ......................................................................................................... 441 Automatyzacja kompilacji ......................................................................................................... 444 Podsumowanie ................................................................................................................................... 446 Rozdzia(cid:239) 21. Obiekty, wzorce, narz(cid:218)dzia ..................................................................................447 Obiekty ................................................................................................................................................ 447 Wybór ........................................................................................................................................... 448 Hermetyzacja i delegowanie ...................................................................................................... 448 Osłabianie sprzężenia ................................................................................................................. 448 Zdatność do wielokrotnego stosowania kodu ........................................................................ 449 Estetyka ........................................................................................................................................ 449 Wzorce ................................................................................................................................................ 450 Co dają nam wzorce? .................................................................................................................. 450 Wzorce a zasady projektowe ..................................................................................................... 451 Narzędzia ............................................................................................................................................ 452 Testowanie ................................................................................................................................... 453 Dokumentacja ............................................................................................................................. 453 Zarządzanie wersjami ................................................................................................................. 453 Automatyczna kompilacja (instalacja) .................................................................................... 454 System integracji ciągłej ............................................................................................................. 454 Co pominęliśmy? ........................................................................................................................ 454 Podsumowanie ................................................................................................................................... 455 Bibliografia ..........................................................................................................457 Książki ................................................................................................................................................. 457 Publikacje ............................................................................................................................................ 458 Witryny WWW ................................................................................................................................. 458 Prosty analizator leksykalny ................................................................................461 Skaner .................................................................................................................................................. 461 Analizator leksykalny ........................................................................................................................ 468 Skorowidz ............................................................................................................481 Dodatek A Dodatek B 12 Kup książkęPoleć książkę R O Z D Z I A (cid:146) 5 (cid:132) (cid:132) (cid:132) Narz(cid:218)dzia obiektowe Poprzednie rozdziały zaznajamiały Czytelnika z programowaniem obiektowym, przybliżając mu podstawowe konstrukcje obiektowe, takie jak klasy i metody. Udogodnienia obiektowe nie kończą się na tych konstrukcjach i mechanizmach — sam język udostępnia też mechanizmy pomocnicze, ułatwiające pracę z obiektami. Niniejszy rozdział poświęcony będzie prezentacji niektórych z tych narzędzi oraz technikom wykorzystywanym do organizowania, testowania i korzystania z klas i obiektów. W rozdziale omawiam: (cid:120) Pakiety — czyli organizowanie kodu w kategorie logiczne. (cid:120) Przestrzenie nazw — od wersji 5.3 można osadzać elementy kodu w odrębnych przestrzeniach nazw. (cid:120) Włączanie kodu — z naciskiem na ustanowienie centralnie dostępnej lokalizacji kodu bibliotecznego. (cid:120) Funkcje pomocnicze względem klas i obiektów — służące do testowania obiektów, klas, składowych i metod. (cid:120) Interfejs Reflection API — bezprecedensowy zestaw wbudowanych klas pozwalających na retrospekcję: realizację dynamicznych odwołań do informacji o klasach. PHP a pakiety Pakiet to zbiór powiązanych ze sobą klas. Pakiety służą do wyodrębniania i rozdzielania poszczególnych części systemu. W niektórych językach programowania obsługa pakietów (modułów) jest sformalizowana — jak w Javie, gdzie pakiety dysponują własnymi przestrzeniami nazw. W PHP koncepcja pakietu jest cokolwiek obca, ale od wersji 5.3 wprowadzono przestrzenie nazw, o których napiszę więcej w następnym podrozdziale. Skoro i tak przez jakiś czas będziemy musieli pracować również ze starym kodem, nie może tu zabraknąć klasycznego sposobu organizowania klasy w struktury pakietopodobne. Pakiety i przestrzenie nazw w PHP PHP nie posiada mechanizmów obsługi pakietów jako takich, ale programiści od zawsze radzili sobie z kategoryzacją kodu poprzez odrębne konwencje nazewnicze i separację kodu w systemie plików. Niebawem zajmiemy się zalecanymi technikami organizowania kodu na bazie katalogów i plików, na początek jednak weźmiemy na warsztat konwencje nazewnicze oraz nowy mechanizm przestrzeni nazw. Aż do powstania wersji 5.3 programiści byli zmuszeni do dobierania nazw plików w kontekście globalnym. Innymi słowy, jeśli klasa nosiła miano ShoppingBasket, była pod tą nazwą dostępna w całym systemie. Prowadziło to do dwóch problemów. Przede wszystkim wprowadzało niemałe ryzyko kolizji nazw. Niby jest Kup książkęPoleć książkę PHP. OBIEKTY, WZORCE, NARZ(cid:125)DZIA to mało prawdopodobne, bo wystarczy zapamiętać wszystkie nazwy klas, prawda? Kłopot w tym, że każdy z programistów używa mnóstwa kodu bibliotecznego, zewnętrznego. To oczywiście pożądane, ale w kontekście kolizji nazw bardzo ryzykowne. Co jeśli nasz projekt robi tak: // plik my.php require_once useful/Outputter1.php class Outputter { // wypisywanie danych } A plik włączany do projektu robi tak: // plik useful/Outputter1.php class Outputter { // ... } Chyba już wiemy, prawda? Oto co się stanie: PHP Fatal error: Cannot redeclare class Outputter in ...Outputter1.php on line 2 Oczywiście, istniało konwencjonalne obejście tego problemu. Należało poprzedzać nazwy klas nazwami pakietów, co gwarantowało (w pewnym stopniu) unikatowość nazw klas: // plik my.php require_once useful/Outputter2.php ; class my_Outputter { // wypisywanie danych } // plik useful/Outputter2.php class useful_Outputter { // ... } Sęk w tym, że w miarę rozbudowywania projektów nazwy klas wydłużały się niemiłosiernie. Nie jest to może bardzo problematyczne, ale zmniejsza czytelność kodu i utrudnia zapamiętanie nazw klas przez programistów, a także przyczynia się do utraty wielu roboczogodzin potrzebnych na poprawianie pomyłek w coraz to dłuższych nazwach. Jeszcze przez lata będziemy skazani na tę konwencję, bo każdy z nas korzysta z jakichś starszych bibliotek. Z tego względu do zagadnienia klasycznego sposobu zarządzania pakietami wrócimy jeszcze w dalszej części rozdziału. Ratunek — przestrzenie nazw W PHP 5.3 pojawiła się obsługa przestrzeni nazw. Zasadniczo przestrzeń nazw to pojemnik, w którym można umieszczać klasy, funkcje i zmienne. W obrębie przestrzeni nazw można się do tych elementów odwoływać bez kwalifikowania odwołań. Z zewnątrz należy albo zaimportować przestrzeń nazw, albo odwoływać się do jej elementów za pomocą nazw kwalifikowanych. Skomplikowane? Przykład powinien rozjaśnić problem. Oto przykład kolidujących klas przepisany na przestrzenie nazw: namespace my; require_once useful/Outputter3.php ; class Outputter { // wypisywanie danych } 96 Kup książkęPoleć książkę ROZDZIA(cid:146) 5. (cid:132) NARZ(cid:125)DZIA OBIEKTOWE // plik useful/Outputter3.php namespace useful; class Outputter { // } Zauważmy słowo kluczowe namespace. Łatwo się domyślić, że ustanawia ono nową przestrzeń nazw. Użytkownicy tego mechanizmu powinni pamiętać, że deklaracja przestrzeni nazw musi być pierwszą instrukcją pliku. Powyżej utworzyliśmy dwie przestrzenie nazw: my oraz useful. Typowo jednak przestrzenie nazw tworzą głębszą hierarchię. Na samym szczycie definiuje się zazwyczaj przestrzeń z nazwą projektu albo organizacji. Następnie kwalifikuje się tę nazwę nazwą pakietu — PHP pozwala na deklarowanie zagnieżdżonych przestrzeni nazw. Poziomy w hierarchii przestrzeni nazw oddziela się znakami lewego ukośnika. namespace com\getinstance\util; class Debug { static function helloWorld() { print hello from Debug\n ; } } Gdybyśmy udostępniali repozytorium z kodem, w naturalny sposób moglibyśmy użyć członów nazwy domeny jako początkowych członów przestrzeni nazw. Sztuczkę tę stosują programiści Javy w nazwach pakietów: odwracają nazwy domen organizacji czy projektów, od członu najbardziej ogólnego do członu najbardziej szczegółowego. A po zidentyfikowaniu repozytorium można zacząć definiować pojedyncze pakiety — w tym przypadku pakiet util. Jak wywołać metodę klasy z takiego pakietu? Zależy, skąd ta metoda ma być wywołana. Jeśli wywołanie odbywa się w obrębie przestrzeni nazw, w której metoda jest zadeklarowana, można ją wywołać wprost: Debug::helloWorld(); Takie wywołanie nazwiemy niekwalifikowanym. W przestrzeni nazw com\getinstance\util nazwy klas i metod są dostępne bez żadnych członów poprzedzających. Ale spoza przestrzeni nazw należy używać nazwy klasy (metody) kwalifikowanej nazwą przestrzeni nazw: com\getinstance\util\Debug::helloWorld(); Jaki będzie więc efekt wykonania poniższego kodu? namespace main; com\getinstance\util\Debug::helloWorld(); Pytanie było podchwytliwe. Oczywiście pojawi się błąd: PHP Fatal error: Class main\com\getinstance\util\Debug not found in … A to dlatego, że użyliśmy względnej przestrzeni nazw. PHP przy rozwiązywaniu nazw szuka przestrzeni nazw com\getinstance\util w obrębie przestrzeni nazw main i rzecz jasna — nie znajduje jej. Tak samo, jak można stosować bezwzględne ścieżki plików i URL-e, tak samo można konstruować bezwzględne nazwy przestrzeni nazw. Błąd poprzedniego programu można więc naprawić tak: namespace main; \com\getinstance\util\Debug::helloWorld(); Znak lewego ukośnika na początku identyfikatora przestrzeni nazw mówi, że poszukiwanie przestrzeni nazw należy zacząć od samego szczytu hierarchii, a nie od bieżącej przestrzeni nazw. Ale czy przestrzenie nazw nie miały przypadkiem oszczędzić programistom długich nazw? Deklaracja klasy Debug jest co prawda krótsza, ale jej wywołania wcale się nie skróciły — są równie rozwlekłe jak w klasycznym modelu „pakietów” bez przestrzeni nazw. Do wyeliminowania tej rozwlekłości przewidziano osobne słowo kluczowe języka PHP: use. Pozwala ono na aliasowanie nazw innych przestrzeni nazw w bieżącej przestrzeni nazw. Oto przykład: 97 Kup książkęPoleć książkę PHP. OBIEKTY, WZORCE, NARZ(cid:125)DZIA namespace main; use com\getinstance\util; util\Debug::helloWorld(); Przestrzeń nazw com\getinstance\util została tu skrócona do krótkiej nazwy util. Zauważmy, że nie rozpoczęto jej od znaku ukośnika: argument dla słowa kluczowego use jest rozpatrywany w globalnej, a nie w bieżącej przestrzeni nazw. Dalej, jeśli w ogóle chcemy się pozbyć kwalifikacji nazw, możemy zaimportować klasę Debug do bieżącej przestrzeni nazw: namespace main; use com\getinstance\util\Debug; Debug::helloWorld(); A co się stanie, jeśli w bieżącej przestrzeni nazw (main) znajduje się już deklaracja klasy Debug? Łatwo zgadnąć. Oto stosowny kod i efekt jego wykonania: namespace main; use com\getinstance\util\Debug; class Debug { static function helloWorld() { print hello from main\Debug ; } } Debug::helloWorld(); PHP Fatal error: Cannot declare class main\Debug because the name is already in use in … Zatoczyliśmy więc koło, wracając ponownie do kolizji nazw klas, nieprawdaż? Na szczęście nasz problem ma rozwiązanie w postaci jawnych aliasów dla używanych nazw: namespace main; use com\getinstance\util\Debug as uDebug; class Debug { static function helloWorld() { print hello from main\Debug ; } } uDebug::helloWorld(); Użycie słowa as w klauzuli use pozwala na zmianę aliasu nazwy Debug na uDebug. Kiedy programista pisze kod w jakiejś przestrzeni nazw i zamierza odwołać się do klasy z globalnej (nienazwanej) przestrzeni nazw, może po prostu poprzedzić nazwę klasy pojedynczym znakiem ukośnika. Oto deklaracja metody w globalnej przestrzeni nazw: // plik global.php: bez przestrzeni nazw class Lister { public static function helloWorld() { print ahoj z modu(cid:239)u g(cid:239)ównego\n ; } } 98 Kup książkęPoleć książkę ROZDZIA(cid:146) 5. (cid:132) NARZ(cid:125)DZIA OBIEKTOWE A oto kod zamknięty w przestrzeni nazw, odwołujący się do owej metody: namespace com\getinstance\util; require_once global.php ; class Lister { public static function helloWorld() { print ahoj z modu(cid:239)u .__NAMESPACE__. \n ; } } Lister::helloWorld(); // odwołanie lokalne \Lister::helloWorld(); // odwołanie globalne Kod z przestrzeni nazw deklaruje własną wersję klasy Lister. Odwołanie z nazwą niekwalifikowaną to odwołanie do wersji lokalnej; odwołanie z nazwą kwalifikowaną pojedynczym znakiem ukośnika to odwołanie do klasy z globalnej przestrzeni nazw. Oto efekt wykonania poprzedniego fragmentu kodu. ahoj z modu(cid:239)u com\getinstance\util ahoj z modu(cid:239)u g(cid:239)ównego Warto go pokazać, bo przy okazji ilustruje działanie stałej __NAMESPACE__. Otóż przechowuje ona nazwę bieżącej przestrzeni nazw i bardzo przydaje się w diagnostyce błędów. W pojedynczym pliku można deklarować więcej niż jedną przestrzeń nazw — składnia pozostaje bez zmian. Można też stosować składnię alternatywną, z użyciem nawiasów klamrowych ujmujących ciało deklaracji przestrzeni nazw. namespace com\getinstance\util { class Debug { static function helloWorld() { print ahoj, tu Debug\n ; } } } namespace main { \com\getinstance\util\Debug::helloWorld(); } Jeśli zachodzi konieczność użycia wielu przestrzeni nazw w pojedynczym pliku, składnia z nawiasami klamrowymi jest wręcz zalecana. Ogólnie jednak zaleca się, aby przestrzenie nazw były definiowane w osobnych plikach. Unikatową cechą składni z nawiasami klamrowymi jest możliwość przełączenia się do globalnej przestrzeni nazw wewnątrz pliku. Wcześniej do pozyskania kodu z globalnej przestrzeni nazw użyliśmy dyrektywy require_once. Mogliśmy jednak użyć alternatywnej składni przestrzeni nazw i zamknąć wszystko w jednym pliku. namespace { class Lister { //... } } namespace com\getinstance\util { class Lister { //... } Lister::helloWorld(); // odwołanie lokalne \Lister::helloWorld(); // odwołanie globalne } 99 Kup książkęPoleć książkę PHP. OBIEKTY, WZORCE, NARZ(cid:125)DZIA Do globalnej przestrzeni nazw weszliśmy, otwierając blok przestrzeni nazw bez określenia nazwy. (cid:132) Uwaga Nie mo(cid:285)na miesza(c
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

PHP. Obiekty, wzorce, narzędzia. Wydanie IV
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ą: