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:

• poznasz podstawowe zagadnienia związane z programowaniem obiektowym
• nauczysz się operować na obiektach w PHP
• poznasz przydatne wzorce projektowe
• unikniesz typowych problemów
• przygotujesz testy jednostkowe

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

Osoby które kupowały "PHP. Obiekty, wzorce, narzędzia. Wydanie IV", wybierały także:

• PHP 8 Programming Tips, Tricks and Best Practices 157,37 zł, (29,90 zł -81%)
• Domain-Driven Design in PHP 135,91 zł, (29,90 zł -78%)
• PHP Microservices 135,91 zł, (29,90 zł -78%)
• Drupal 8 Module Development. Second edition 124,58 zł, (29,90 zł -76%)
• Mastering The Faster Web with PHP, MySQL, and JavaScript 124,58 zł, (29,90 zł -76%)

Spis treści

PHP. Obiekty, wzorce, narzędzia. Wydanie IV -- spis treści

O autorze (13)

O recenzencie technicznym (15)

Podziękowania (17)

Wprowadzenie (19)

Rozdział 1. PHP - projektowanie i zarzą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ł 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ł 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)
• 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)

Rozdział 4. Zaawansowana obsł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ł 5. Narzę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)
• 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ł 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ł 7. Czym są wzorce projektowe? Do czego się przydają? (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)

Rozdział 8. Wybrane prawidł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ł 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ł 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)
• Wzorzec Facade (197)
  • Problem (197)
  • Implementacja (199)
  • Konsekwencje (199)
• Podsumowanie (200)

Rozdział 11. Reprezentacja i realizacja zadań (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ł 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ł 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)
• 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ł 14. Dobre (i zł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ł 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)

Rozdział 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ł 17. Zarzą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ł 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)

Rozdział 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ł 20. Ciągł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ł 21. Obiekty, wzorce, narzę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)

Dodatek A. Bibliografia (457)

• Książki (457)
• Publikacje (458)
• Witryny WWW (458)

Dodatek B. Prosty analizator leksykalny (461)

• Skaner (461)
• Analizator leksykalny (468)

Skorowidz (481)