PHP OBIEKTY WZORCE NARZĘDZIA

79.00

Na stanie

SPIS TREŚCI

O autorze (11)

O recenzencie technicznym (13)

Podziękowania (15)

Przedmowa do trzeciego wydania (17)

Część I: 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 trzecim wydaniu (26)
  • Podsumowanie (26)

Część II: Obiekty (27)

Rozdział 2. PHP a obiekty (29)

  • Nieoczekiwany sukces obiektów w PHP (29)
    • PHP/FI – u zarania języka (29)
    • PHP3 – składniowy lukier (30)
    • Cicha rewolucja – PHP4 (30)
    • PHP5 – nieuchronne zmiany (31)
  • W przyszłości (32)
  • Debata obiektowa – za czy przeciw? (32)
  • Podsumowanie (32)

Rozdział 3. Obiektowy elementarz (33)

  • Klasy i obiekty (33)
    • Pierwsza klasa (33)
    • Pierwszy obiekt (lub dwa) (34)
  • Definiowanie składowych klasy (35)
  • Metody (37)
    • Metoda konstrukcji obiektu (38)
  • Typy argumentów metod (39)
    • Typy elementarne (40)
    • Typy obiektowe (42)
  • Dziedziczenie (44)
    • Problemy związane z dziedziczeniem (44)
    • Stosowanie dziedziczenia (48)
    • Zarządzanie dostępem do klasy – słowa public, private i protected (52)
  • Podsumowanie (56)

Rozdział 4. Zaawansowana obsługa obiektów (57)

  • Metody i składowe statyczne (57)
  • Składowe stałe (60)
  • Klasy abstrakcyjne (61)
  • Interfejsy (62)
  • Późne wiązanie statyczne: słowo static (64)
  • Obsługa błędów (66)
    • Wyjątki (68)
  • Klasy i metody finalne (72)
  • Przechwytywanie chybionych wywołań (73)
  • Definiowanie destruktorów (77)
  • Wykonywanie kopii obiektów (78)
  • Reprezentacja obiektu w ciągach znaków (80)
  • Wywołania zwrotne, funkcje anonimowe i domknięcia (81)
  • Podsumowanie (85)

Rozdział 5. Narzędzia obiektowe (87)

  • PHP a pakiety (87)
    • Pakiety i przestrzenie nazw w PHP (87)
    • Ratunek – przestrzenie nazw (88)
    • Symulowanie systemu pakietów na bazie systemu plików (92)
    • Nazwy a la PEAR (93)
    • Ścieżki przeszukiwania (93)
    • Automatyczne wczytywanie kodu (95)
  • Klasy i funkcje pomocnicze (96)
    • Szukanie klasy (97)
    • Badanie obiektów i klas (98)
    • Badanie metod (99)
    • Badanie składowych (100)
    • Badanie relacji dziedziczenia (100)
    • Badanie wywołań metod (101)
  • Interfejs retrospekcji – Reflection API (102)
    • Zaczynamy (102)
    • Pora zakasać rękawy (103)
    • Badanie klasy (104)
    • Badanie metod (106)
    • Badanie argumentów metod (107)
    • Korzystanie z retrospekcji (108)
  • Podsumowanie (111)

Rozdział 6. Obiekty a projektowanie obiektowe (113)

  • Czym jest projektowanie? (113)
  • Programowanie obiektowe i proceduralne (114)
    • Odpowiedzialność (117)
    • Spójność (117)
    • Sprzęganie (118)
    • Ortogonalność (118)
  • Zasięg klas (118)
  • Polimorfizm (119)
  • Hermetyzacja (121)
  • Nieważne jak (122)
  • Cztery drogowskazy (122)
    • Zwielokrotnianie kodu (123)
    • Przemądrzałe klasy (123)
    • Złota rączka (123)
    • Za dużo warunków (123)
  • Język UML (123)
    • Diagramy klas (124)
    • Diagramy sekwencji (129)
  • Podsumowanie (131)

Część III: Wzorce (133)

Rozdział 7. Czym są wzorce projektowe? Do czego się przydają? (135)

  • Czym są wzorce projektowe? (135)
  • Wzorzec projektowy (137)
    • Nazwa (137)
    • Problem (138)
    • Rozwiązanie (138)
    • Konsekwencje (138)
  • Format wzorca według Bandy Czworga (138)
  • Po co nam wzorce projektowe? (139)
    • Wzorzec projektowy definiuje problem (139)
    • Wzorzec projektowy definiuje rozwiązanie (139)
    • Wzorce projektowe są niezależne od języka programowania (139)
    • Wzorce definiują słownictwo (140)
    • Wzorce są wypróbowane (140)
    • Wzorce mają współpracować (141)
    • Wzorce promują prawidła projektowe (141)
  • Wzorce projektowe a PHP (141)
  • Podsumowanie (141)

Rozdział 8. Wybrane prawidła wzorców (143)

  • Olśnienie wzorcami (143)
  • Kompozycja i dziedziczenie (144)
    • Problem (144)
    • Zastosowanie kompozycji (147)
  • Rozprzęganie (149)
    • Problem (149)
    • Osłabianie sprzężenia (150)
  • Kod ma używać interfejsów, nie implementacji (151)
  • Zmienne koncepcje (153)
  • Nadmiar wzorców (153)
  • Wzorce (154)
    • Wzorce generowania obiektów (154)
    • Wzorce organizacji obiektów i klas (154)
    • Wzorce zadaniowe (154)
    • Wzorce korporacyjne (154)
    • Wzorce baz danych (154)
  • Podsumowanie (154)

Rozdział 9. Generowanie obiektów (157)

  • Generowanie obiektów – problemy i rozwiązania (157)
  • Wzorzec Singleton (161)
    • Problem (161)
    • Implementacja (162)
    • Konsekwencje (163)
  • Wzorzec Factory Method (164)
    • Problem (164)
    • Implementacja (166)
    • Konsekwencje (167)
  • Wzorzec Abstract Factory (168)
    • Problem (168)
    • Implementacja (169)
    • Konsekwencje (171)
    • Prototyp (172)
    • Problem (173)
    • Implementacja (173)
  • Ależ to oszustwo! (175)
  • Podsumowanie (177)

Rozdział 10. Wzorce elastycznego programowania obiektowego (179)

  • Strukturalizacja klas pod kątem elastyczności obiektów (179)
  • Wzorzec Composite (179)
    • Problem (180)
    • Implementacja (182)
    • Konsekwencje (185)
    • Composite – podsumowanie (188)
  • Wzorzec Decorator (188)
    • Problem (188)
    • Implementacja (190)
    • Konsekwencje (193)
  • Wzorzec Facade (193)
    • Problem (193)
    • Implementacja (195)
    • Konsekwencje (195)
  • Podsumowanie (196)

Rozdział 11. Reprezentacja i realizacja zadań (197)

  • Wzorzec Interpreter (197)
    • Problem (197)
    • Implementacja (198)
    • Ciemne strony wzorca Interpreter (204)
  • Wzorzec Strategy (205)
    • Problem (205)
    • Implementacja (206)
  • Wzorzec Observer (210)
    • Implementacja (211)
  • Wzorzec Visitor (216)
    • Problem (216)
    • Implementacja (217)
    • Wady wzorca Visitor (221)
  • Wzorzec Command (222)
    • Problem (222)
    • Implementacja (222)
  • Podsumowanie (225)

Rozdział 12. Wzorce korporacyjne (227)

  • Przegląd architektury (227)
    • Wzorce (228)
    • Aplikacje i warstwy (228)
  • Małe oszustwo na samym początku (231)
    • Wzorzec Registry (231)
    • Implementacja (232)
  • Warstwa prezentacji (240)
    • Wzorzec Front Controller (240)
    • Wzorzec Application Controller (249)
    • Wzorzec Page Controller (259)
    • Wzorce Template View i Helper View (263)
  • Warstwa logiki biznesowej (266)
    • Wzorzec Transaction Script (266)
    • Wzorzec Domain Model (270)
  • Podsumowanie (273)

Rozdział 13. Wzorce bazodanowe (275)

  • Warstwa danych (275)
  • Wzorzec Data Mapper (276)
    • Problem (276)
    • Implementacja (276)
  • Wzorzec Identity Map (288)
    • Problem (288)
    • Implementacja (288)
    • Konsekwencje (291)
  • Wzorzec Unit of Work (291)
    • Problem (291)
    • Implementacja (291)
    • Konsekwencje (295)
  • Wzorzec Lazy Load (295)
    • Problem (295)
    • Implementacja (296)
    • Konsekwencje (297)
  • Wzorzec Domain Object Factory (297)
    • Problem (298)
    • Implementacja (298)
    • Konsekwencje (299)
  • Wzorzec Identity Object (300)
    • Problem (300)
    • Implementacja (301)
    • Konsekwencje (305)
  • Wzorce Selection Factory i Update Factory (306)
    • Problem (306)
    • Implementacja (306)
    • Konsekwencje (309)
  • Co zostało z wzorca Data Mapper? (309)
  • Podsumowanie (311)

Część IV: Narzędzia (313)

Rozdział 14. Dobre (i złe) praktyki (315)

  • Nie tylko kod (315)
  • Pukanie do otwartych drzwi (316)
  • Jak to zgrać? (317)
  • Uskrzydlanie kodu (318)
  • Dokumentacja (319)
  • Testowanie (320)
  • Ciągła integracja (320)
  • Podsumowanie (321)

Rozdział 15. PEAR i Pyrus (323)

  • Czym jest PEAR? (323)
  • Pyrus (324)
  • Instalowanie pakietu (325)
    • Kanały PEAR (327)
  • Korzystanie z pakietu z PEAR (328)
    • Obsługa błędów w pakietach PEAR (330)
  • Tworzenie własnych pakietów PEAR (333)
    • Plik package.xml (333)
    • Składniki pakietu (333)
    • Element contents (335)
    • Zależności (337)
    • Dookreślanie instalacji – phprelease (339)
    • Przygotowanie pakietu do dystrybucji (340)
    • Konfigurowanie własnego kanału PEAR (340)
  • Podsumowanie (344)

Rozdział 16. Generowanie dokumentacji – phpDocumentor (345)

  • Po co nam dokumentacja? (345)
  • Instalacja (346)
  • Generowanie dokumentacji (347)
  • Komentarze DocBlock (348)
  • Dokumentowanie klas (349)
  • Dokumentowanie plików (351)
  • Dokumentowanie składowych (351)
  • Dokumentowanie metod (352)
  • Tworzenie odnośników w dokumentacji (354)
  • Podsumowanie (356)

Rozdział 17. Zarządzanie wersjami projektu z Subversion (357)

  • Po co mi kontrola wersji? (357)
  • Skąd wziąć Subversion? (358)
  • Konfigurowanie repozytorium Subversion (359)
    • Tworzenie repozytorium (359)
    • Dostęp do repozytorium Subversion (360)
  • Rozpoczynamy projekt (361)
  • Aktualizacja i zatwierdzanie zmian (363)
  • Dodawanie i usuwanie plików i katalogów (367)
    • Dodawanie pliku (367)
    • Usuwanie pliku (367)
    • Dodawanie katalogu (367)
    • Usuwanie katalogów (368)
  • Etykietowanie i eksportowanie wydania (368)
    • Etykietowanie projektu (368)
    • Eksportowanie projektu (369)
  • Rozgałęzianie projektu (369)
  • Podsumowanie (373)

Rozdział 18. Testy jednostkowe z PHPUnit (375)

  • Testy funkcjonalne i testy jednostkowe (375)
  • Testowanie ręczne (376)
  • PHPUnit (378)
    • Tworzenie przypadku testowego (378)
    • Metody asercji (379)
    • Testowanie wyjątków (380)
    • Uruchamianie zestawów testów (381)
    • Ograniczenia (382)
    • Atrapy i imitacje (383)
    • Dobry test to oblany test (386)
  • Testy dla aplikacji WWW (389)
    • Przygotowanie aplikacji WWW do testów (389)
    • Proste testy aplikacji WWW (391)
    • Selenium (393)
  • Słowo ostrzeżenia (397)
  • Podsumowanie (398)

Rozdział 19. Automatyzacja instalacji z Phing (401)

  • Czym jest Phing? (402)
  • Pobieranie i instalacja pakietu Phing (402)
  • Montowanie dokumentu kompilacji (403)
    • Różnicowanie zadań kompilacji (404)
    • Właściwości (406)
    • Typy (410)
    • Operacje (414)
  • Podsumowanie (418)

Rozdział 20. Ciągła integracja kodu (419)

  • Czym jest ciągła integracja? (419)
    • Przygotowanie projektu do ciągłej integracji (421)
  • CruiseControl i phpUnderControl (427)
    • Instalowanie CruiseControl (427)
    • Instalowanie phpUnderControl (428)
    • Instalowanie projektu do integracji ciągłej (430)
  • Podsumowanie (439)

Część V: Konkluzje (441)

Rozdział 21. Obiekty, wzorce, narzędzia (443)

  • Obiekty (443)
    • Wybór (444)
    • Hermetyzacja i delegowanie (444)
    • Osłabianie sprzężenia (444)
    • Zdatność do wielokrotnego stosowania kodu (445)
    • Estetyka (445)
  • Wzorce (446)
    • Co dają nam wzorce? (446)
    • Wzorce a zasady projektowe (447)
  • Narzędzia (448)
    • Testowanie (449)
    • Dokumentacja (449)
    • Zarządzanie wersjami (449)
    • Automatyczna kompilacja (instalacja) (450)
    • System integracji ciągłej (450)
    • Co pominęliśmy? (450)
  • Podsumowanie (451)

Część VI: Dodatki (453)

Dodatek A: Bibliografia (455)

  • Książki (455)
  • Publikacje (456)
  • Witryny WWW (456)

Dodatek B: Prosty analizator leksykalny (459)

  • Skaner (459)
  • Analizator leksykalny (466)

Skorowidz (477)

Autor

ISBN

978-83-246-3026-4

Liczba stron

Rok wydania

Wydawca

Opinie

Na razie nie ma opinii o produkcie.

Napisz pierwszą opinię o „PHP OBIEKTY WZORCE NARZĘDZIA”