PHP OBIEKTY WZORCE NARZĘDZIA

89.00

Na stanie

SPIS TREŚCI

O autorze (15)

O recenzencie technicznym (17)

Podziękowania (19)

Wprowadzenie (21)

CZĘŚĆ I. OBIEKTY (23)

Rozdział 1. PHP – projektowanie i zarządzanie (25)

  • Problem (25)
  • PHP a inne języki programowania (26)
  • O książce (28)
    • Obiekty (28)
    • Wzorce (28)
    • Narzędzia (29)
    • Nowości w piątym wydaniu (30)
  • Podsumowanie (30)

Rozdział 2. PHP i obiekty (31)

  • Nieoczekiwany sukces obiektów w PHP (31)
    • PHP/FI – u zarania języka (31)
    • PHP3 – składniowy lukier (31)
    • Cicha rewolucja – PHP4 (32)
    • PHP5 – nieuchronne zmiany (33)
    • PHP7 – doganianie reszty świata (34)
  • Debata obiektowa – za czy przeciw? (34)
  • Podsumowanie (35)

Rozdział 3. Obiektowy elementarz (37)

  • Klasy i obiekty (37)
    • Pierwsza klasa (37)
    • Pierwszy obiekt (lub dwa) (38)
  • Definiowanie składowych klasy (39)
  • Metody (41)
    • Metoda konstrukcji obiektu (42)
  • Typy argumentów metod (43)
    • Typy elementarne (44)
    • Typy obiektowe (47)
  • Dziedziczenie (50)
    • Problemy związane z dziedziczeniem (51)
    • Stosowanie dziedziczenia (55)
    • Zarządzanie dostępem do klasy – słowa public, private i protected (60)
  • Podsumowanie (64)

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

  • Metody i składowe statyczne (65)
  • Składowe stałe (68)
  • Klasy abstrakcyjne (69)
  • Interfejsy (71)
  • Cechy typowe (73)
    • Zadanie dla cech typowych (73)
    • Definiowanie i stosowanie cechy typowej (74)
    • Stosowanie wielu cech typowych (75)
    • Łączenie cech z interfejsami (75)
    • Unikanie kolizji nazw metod za pomocą słowa insteadof (76)
    • Aliasy metod cech typowych (77)
    • Cechy typowe z metodami statycznymi (78)
    • Dostęp do składowych klasy włączającej (79)
    • Definiowanie metody abstrakcyjnej cechy typowej (79)
    • Zmiana dostępności metod cech typowych (80)
  • Późne wiązanie statyczne: słowo static (81)
  • Obsługa błędów (84)
    • Wyjątki (85)
  • Klasy i metody finalne (92)
  • Klasa do obsługi błędów wewnętrznych (93)
  • Przechwytywanie chybionych wywołań (94)
  • Definiowanie destruktorów (99)
  • Wykonywanie kopii obiektów (100)
  • Reprezentacja obiektu w ciągach znaków (103)
  • Wywołania zwrotne, funkcje anonimowe i domknięcia (104)
  • Klasy anonimowe (108)
  • Podsumowanie (109)

Rozdział 5. Narzędzia obiektowe (111)

  • PHP a pakiety (111)
    • Pakiety i przestrzenie nazw w PHP (111)
    • Automatyczne wczytywanie kodu (119)
  • Klasy i funkcje pomocnicze (122)
    • Szukanie klasy (123)
    • Badanie obiektów i klas (124)
    • Pozyskiwanie ciągu pełnej nazwy klasy (125)
    • Badanie metod (126)
    • Badanie składowych (127)
    • Badanie relacji dziedziczenia (127)
    • Badanie wywołań metod (128)
  • Interfejs retrospekcji – Reflection API (129)
    • Zaczynamy (129)
    • Pora zakasać rękawy (130)
    • Badanie klasy (132)
    • Badanie metod (133)
    • Badanie argumentów metod (135)
    • Korzystanie z retrospekcji (136)
  • Podsumowanie (139)

Rozdział 6. Obiektya projektowanie obiektowe (141)

  • Czym jest projektowanie? (141)
  • Programowanie obiektowe i proceduralne (142)
    • Odpowiedzialność (145)
    • Spójność (146)
    • Sprzęganie (146)
    • Ortogonalność (146)
  • Zasięg klas (147)
  • Polimorfizm (148)
  • Hermetyzacja (149)
  • Nieważne jak (150)
  • Cztery drogowskazy (151)
    • Zwielokrotnianie kodu (151)
    • Przemądrzałe klasy (151)
    • Złota rączka (151)
    • Za dużo warunków (151)
  • Język UML (152)
    • Diagramy klas (152)
    • Diagramy sekwencji (157)
  • Podsumowanie (159)

CZĘŚĆ II. WZORCE (161)

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

  • Czym są wzorce projektowe? (163)
  • Wzorzec projektowy (165)
    • Nazwa (165)
    • Problem (166)
    • Rozwiązanie (166)
    • Konsekwencje (166)
  • Format wzorca według Bandy Czworga (166)
  • Po co nam wzorce projektowe? (167)
    • Wzorzec projektowy definiuje problem (167)
    • Wzorzec projektowy definiuje rozwiązanie (167)
    • Wzorce projektowe są niezależne od języka programowania (167)
    • Wzorce definiują słownictwo (168)
    • Wzorce są wypróbowane (168)
    • Wzorce mają współpracować (169)
    • Wzorce promują prawidła projektowe (169)
    • Wzorce są stosowane w popularnych frameworkach (169)
  • Wzorce projektowe a PHP (169)
  • Podsumowanie (169)

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

  • Olśnienie wzorcami (171)
  • Kompozycja i dziedziczenie (172)
    • Problem (172)
    • Zastosowanie kompozycji (175)
  • Rozprzęganie (177)
    • Problem (178)
    • Osłabianie sprzężenia (179)
  • Kod ma używać interfejsów, nie implementacji (180)
  • Zmienne koncepcje (181)
  • Nadmiar wzorców (182)
  • Wzorce (182)
    • Wzorce generowania obiektów (183)
    • Wzorce organizacji obiektów i klas (183)
    • Wzorce zadaniowe (183)
    • Wzorce korporacyjne (183)
    • Wzorce baz danych (183)
  • Podsumowanie (183)

Rozdział 9. Generowanie obiektów (185)

  • Generowanie obiektów – problemy i rozwiązania (185)
  • Wzorzec Singleton (189)
    • Problem (189)
    • Implementacja (190)
    • Konsekwencje (192)
  • Wzorzec Factory Method (192)
    • Problem (192)
    • Implementacja (195)
    • Konsekwencje (196)
  • Wzorzec Abstract Factory (197)
    • Problem (197)
    • Implementacja (198)
    • Konsekwencje (200)
  • Prototyp (201)
    • Problem (202)
    • Implementacja (202)
  • Naginanie rzeczywistości – wzorzec Service Locator (205)
  • Doskonała izolacja – wstrzykiwanie zależności (206)
    • Problem (207)
    • Implementacja (207)
    • Konsekwencje (210)
  • Podsumowanie (210)

Rozdział 10. Wzorce elastycznego programowania obiektowego (211)

  • Strukturalizacja klas pod kątem elastyczności obiektów (211)
  • Wzorzec Composite (211)
    • Problem (212)
    • Implementacja (214)
    • Konsekwencje (217)
    • Composite – podsumowanie (220)
  • Wzorzec Decorator (220)
    • Problem (221)
    • Implementacja (223)
    • Konsekwencje (226)
  • Wzorzec Facade (226)
    • Problem (227)
    • Implementacja (228)
    • Konsekwencje (229)
  • Podsumowanie (229)

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

  • Wzorzec Interpreter (231)
    • Problem (231)
    • Implementacja (232)
    • Ciemne strony wzorca Interpreter (239)
  • Wzorzec Strategy (240)
    • Problem (240)
    • Implementacja (241)
  • Wzorzec Observer (244)
    • Implementacja (246)
  • Wzorzec Visitor (252)
    • Problem (252)
    • Implementacja (253)
    • Wady wzorca Visitor (258)
  • Wzorzec Command (258)
    • Problem (258)
    • Implementacja (259)
  • Wzorzec Null Object (262)
    • Problem (263)
    • Implementacja (265)
  • Podsumowanie (266)

Rozdział 12. Wzorce korporacyjne (267)

  • Przegląd architektury (267)
    • Wzorce (268)
    • Aplikacje i warstwy (268)
  • Małe oszustwo na samym początku (270)
    • Wzorzec Registry (271)
    • Implementacja (272)
  • Warstwa prezentacji (275)
    • Wzorzec Front Controller (276)
    • Wzorzec Application Controller (285)
    • Zarządzanie danymi w komponentach (290)
    • Wzorzec Page Controller (296)
    • Wzorce Template View i View Helper (300)
  • Warstwa logiki biznesowej (302)
    • Wzorzec Transaction Script (303)
    • Wzorzec Domain Model (306)
  • Podsumowanie (309)

Rozdział 13. Wzorce bazodanowe (311)

  • Warstwa danych (311)
  • Wzorzec Data Mapper (312)
    • Problem (312)
    • Implementacja (312)
  • Wzorzec Identity Map (325)
    • Problem (325)
    • Implementacja (325)
    • Konsekwencje (328)
  • Wzorzec Unit of Work (328)
    • Problem (328)
    • Implementacja (329)
    • Konsekwencje (332)
  • Wzorzec Lazy Load (332)
    • Problem (332)
    • Implementacja (333)
    • Konsekwencje (334)
  • Wzorzec Domain Object Factory (334)
    • Problem (335)
    • Implementacja (335)
    • Konsekwencje (336)
  • Wzorzec Identity Object (337)
    • Problem (338)
    • Implementacja (338)
    • Konsekwencje (343)
  • Wzorce Selection Factory i Update Factory (343)
    • Problem (343)
    • Implementacja (344)
    • Konsekwencje (347)
  • Co zostało z wzorca Data Mapper? (347)
  • Podsumowanie (349)

CZĘŚĆ III. NARZĘDZIA (351)

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

  • Nie tylko kod (353)
  • Pukanie do otwartych drzwi (354)
  • Jak to zgrać? (355)
  • Uskrzydlanie kodu (356)
  • Standardy (357)
  • Vagrant (358)
  • Testowanie (358)
  • Ciągła integracja (359)
  • Podsumowanie (359)

Rozdział 15. Standardy PHP (361)

  • Po co te standardy? (361)
  • Jakie są standardowe rekomendacje PHP? (362)
    • Dlaczego akurat PSR? (362)
    • Rekomendacje PSR – dla kogo? (363)
  • Kodowanie z klasą (363)
    • Podstawowy standard kodowania PSR-1 (364)
    • Rekomendacja stylu kodowania PSR-2 (366)
    • Sprawdzanie i poprawianie kodu (368)
  • PSR-4 – automatyczne ładowanie (370)
    • Zasady, które są dla nas ważne (370)
  • Podsumowanie (373)

Rozdział 16. Używanie i tworzenie komponentów PHP za pomocą Composera (375)

  • Czym jest Composer? (375)
  • Instalowanie Composera (376)
  • Instalowanie (zbioru) pakietów (376)
    • Instalowanie pakietu z poziomu wiersza poleceń (377)
    • Wersje (377)
    • Element require-dev (378)
  • Composer i automatyczne ładowanie kodu (379)
  • Tworzenie własnego pakietu (380)
    • Dodawanie informacji o pakiecie (380)
    • Pakiety systemowe (380)
  • Dystrybucja za pośrednictwem repozytorium Packagist (381)
  • Odrobina prywatności (384)
  • Podsumowanie (385)

Rozdział 17. Zarządzanie wersjami projektuz systemem Git (387)

  • Po co mi kontrola wersji? (387)
  • Skąd wziąć klienta Git? (388)
  • Obsługa repozytorium Git online (389)
  • Konfigurowanie serwera Git (391)
    • Tworzenie repozytorium zdalnego (391)
  • Rozpoczynamy projekt (393)
    • Klonowanie repozytorium (395)
  • Wprowadzanie i zatwierdzanie zmian (396)
  • Dodawanie i usuwanie plików i katalogów (399)
    • Dodawanie pliku (399)
    • Usuwanie pliku (399)
    • Dodawanie katalogu (400)
    • Usuwanie katalogów (400)
  • Etykietowanie wersji (400)
  • Rozgałęzianie projektu (401)
  • Podsumowanie (407)

Rozdział 18. Testy jednostkowe z PHPUnit (409)

  • Testy funkcjonalne i testy jednostkowe (409)
  • Testowanie ręczne (410)
  • PHPUnit (412)
    • Tworzenie przypadku testowego (412)
    • Metody asercji (414)
    • Testowanie wyjątków (415)
    • Uruchamianie zestawów testów (416)
    • Ograniczenia (417)
    • Atrapy i imitacje (419)
    • Dobry test to oblany test (421)
  • Testy dla aplikacji WWW (423)
    • Przygotowanie aplikacji WWW do testów (424)
    • Proste testy aplikacji WWW (426)
    • Selenium (427)
  • Słowo ostrzeżenia (432)
  • Podsumowanie (434)

Rozdział 19. Automatyzacja instalacji z Phingiem (435)

  • Czym jest Phing? (436)
  • Pobieranie i instalacja pakietu Phing (436)
  • Montowanie dokumentu kompilacji (437)
    • Różnicowanie zadań kompilacji (438)
    • Właściwości (440)
    • Typy (446)
    • Operacje (450)
  • Podsumowanie (454)

Rozdział 20. Vagrant (455)

  • Problem (455)
  • Odrobina przygotowań (456)
    • Wybór i instalacja środowiska Vagrant (456)
  • Montowanie lokalnych katalogóww maszynie wirtualnej Vagranta (458)
  • Zaopatrywanie maszyny wirtualnej (459)
    • Konfigurowanie serwera WWW (460)
    • Konfigurowanie MySQL (461)
    • Konfigurowanie nazwy hosta (462)
  • Kilka słów na koniec (463)
  • Podsumowanie (464)

Rozdział 21. Ciągła integracja kodu (465)

  • Czym jest ciągła integracja? (465)
    • Przygotowanie projektu do ciągłej integracji (467)
    • Instalowanie Jenkinsa (475)
    • Instalowanie rozszerzeń Jenkinsa (475)
    • Konfigurowanie klucza publicznego serwera Git (477)
    • Instalowanie projektu (478)
    • Pierwsza kompilacja (479)
    • Konfigurowanie raportów (482)
    • Automatyzacja kompilacji (484)
  • Podsumowanie (486)

Rozdział 22. Obiekty, wzorce, narzędzia (487)

  • Obiekty (487)
    • Wybór (488)
    • Hermetyzacja i delegowanie (488)
    • Osłabianie sprzężenia (488)
    • Zdatność do wielokrotnego stosowania kodu (489)
    • Estetyka (489)
  • Wzorce (490)
    • Co dają nam wzorce? (490)
    • Wzorce a zasady projektowe (491)
  • Narzędzia (492)
    • Testowanie (493)
    • Standardy (493)
    • Zarządzanie wersjami (493)
    • Automatyczna kompilacja (instalacja) (494)
    • System integracji ciągłej (494)
    • Co pominęliśmy? (494)
  • Podsumowanie (495)

DODATKI (497)

Dodatek A. Bibliografia (499)

  • Książki (499)
  • Publikacje (500)
  • Witryny WWW (500)

Dodatek B. Prosty analizator leksykalny (503)

  • Skaner (503)
  • Analizator leksykalny (510)

Skorowidz (523)

Autor

ISBN

978-83-283-3553-0

Liczba stron

Rok wydania

Wydawca

Opinie

Na razie nie ma opinii o produkcie.

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