Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00228 005811 13604964 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
PHP. Obiekty, wzorce, narzędzia. Wydanie V - ebook/pdf
PHP. Obiekty, wzorce, narzędzia. Wydanie V - ebook/pdf
Autor: Liczba stron: 536
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-3554-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> php - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).
Czytaj online.
Komentuj

Jeszcze kilka lat temu programowanie zorientowane obiektowo w PHP wydawało się dość karkołomnym zagadnieniem. Upowszechnienie licznych frameworków sprawiło jednak, że coraz większa liczba programistów tworzy aplikacje WWW, pisząc kod obiektowy w PHP. Frameworki są chętnie stosowane, gdyż wydaje się, że dzięki nim nie trzeba już poświęcać czasu na rozgryzanie szczegółów działania kodu. Niestety, bardzo często okazuje się, że bez zrozumienia zasad działania frameworków i bez umiejętności oceny jakości zastosowanych w nich rozwiązań projektant nie jest w stanie napisać poprawnie funkcjonującej aplikacji.

Trzymasz w ręku książkę przeznaczoną dla programistów, którzy chcą dogłębnie zrozumieć mechanizmy programowania obiektowego w języku PHP i dzięki temu tworzyć, testować oraz publikować efektywny kod. Dużo uwagi poświęcono tu wzorcom projektowym i ich stosowaniu. Opisano zalety wzorców i przedstawiono sporo klasycznych już rozwiązań. Nie zabrakło również omówienia narzędzi oraz metod postępowania, dzięki którym doskonały kod staje się udanym projektem. To wszystko sprawia, że niniejsza książka jest nieodzownym podręcznikiem dla każdego projektanta, który chce tworzyć niezawodne, eleganckie i efektywne aplikacje.

Najważniejsze zagadnienia:

Twój klucz do sukcesu: eleganckie wzorce projektowe i najlepsze praktyki programistyczne!

Matt Zandstra — jest programistą WWW, konsultantem technicznym i autorem książek. Jakiś czas temu był starszym programistą w Yahoo!, a obecnie jest niezależnym konsultantem. Napisał kilka bardzo dobrze przyjętych książek o programowaniu w PHP. Specjalizuje się w rozwijaniu oprogramowania dla biznesu, zwłaszcza w PHP, Perlu i Javie, zarządzaniu treścią i programowaniu zorientowanym obiektowo. Chętnie udziela konsultacji dotyczących stosowania najlepszych praktyk programistycznych. Wraz z żoną Louise i dwójką dzieci mieszka w Liverpoolu.

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

Darmowy fragment publikacji:

Tytuł oryginału: PHP Objects, Patterns, and Practice, 5th Edition Tłumaczenie: Piotr Cieślak Projekt okładki: Studio Gravite / Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki ISBN: 978-83-283-3553-0 Original edition copyright © 2016 by Matt Zandstra. All rights reserved. Polish edition copyright © 2017 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. Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą 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/phpob5.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/phpob5 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ści O autorze ...............................................................................................................15 O recenzencie technicznym ....................................................................................17 Podziękowania ......................................................................................................19 Wprowadzenie ......................................................................................................21 Rozdział 2. Część I. Obiekty ..............................................................................23 PHP — projektowanie i zarządzanie ......................................................................25 Rozdział 1. 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 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 Poleć książkęKup książkę SPIS TREŚCI Rozdział 4. 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 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 6 Poleć książkęKup książkę SPIS TREŚCI 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. Obiekty a 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 7 Poleć książkęKup książkę SPIS TREŚCI 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 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ł 9. 8 Poleć książkęKup książkę SPIS TREŚCI 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 9 Poleć książkęKup książkę SPIS TREŚCI 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 10 Poleć książkęKup książkę SPIS TREŚCI 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 11 Poleć książkęKup książkę SPIS TREŚCI 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 12 Poleć książkęKup książkę SPIS TREŚCI 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 Bibliografia ..........................................................................................................499 Książki ................................................................................................................................................. 499 Publikacje ............................................................................................................................................ 500 Witryny WWW ................................................................................................................................. 500 Prosty analizator leksykalny ................................................................................503 Skaner .................................................................................................................................................. 503 Analizator leksykalny ........................................................................................................................ 510 Skorowidz ............................................................................................................523 Dodatek A Dodatek B 13 Poleć książkęKup książkę SPIS TREŚCI 14 Poleć książkęKup książkę R O Z D Z I A Ł 3    Obiektowy elementarz Obiekty i klasy są sercem tej książki, a od momentu wprowadzenia PHP5 nieco ponad dekadę temu stanowią również serce języka PHP. Niniejszy rozdział ma przygotować niezbędny grunt dla pogłębionego omówienia obiektów i projektowania obiektowego w kontekście mechanizmów języka PHP. Ci, którym programowanie obiektowe w tym języku jest całkiem obce, powinni przeczytać ten rozdział bardzo uważnie. Omawiam w nim następujące zagadnienia:  Klasy i obiekty — deklarowanie klas i tworzenie ich egzemplarzy (obiektów).  Konstruktory — automatyzację konfiguracji obiektów.  Typy elementarne i klasy — jakie znaczenie ma typ w PHP.  Dziedziczenie — gdzie się przydaje i jak je stosować.  Widoczność — udostępnianie interfejsów klas i zabezpieczanie metod i składowych obiektów przed ingerencją. Klasy i obiekty Pierwszą przeszkodą na drodze do zrozumienia programowania obiektowego jest dziwaczność i niezwykłość relacji pomiędzy klasą a jej obiektami. Dla wielu osób właśnie pojęcie tej relacji stanowi pierwsze olśnienie, wywołuje pierwszą ekscytację programowaniem obiektowym. Nie skąpmy więc energii na poznawanie podstaw. Pierwsza klasa Klasy są często opisywane w odniesieniu do obiektów. To bardzo ciekawe, ponieważ obiekty są z kolei niejednokrotnie opisywane przez pryzmat klas. Ta zależność bardzo spowalnia pierwsze postępy adeptów programowania obiektowego. Ponieważ to klasy definiują obiekty, zaczniemy od definicji klasy. Krótko mówiąc, klasa to swego rodzaju szablon wykorzystywany do generowania jednego lub większej liczby obiektów. Deklaracja klasy zawiera słowo kluczowe class i dowolnie wybraną nazwę klasy. Nazwa klasy może być dowolną kombinacją cyfr i liter, nie może się jednak od cyfry zaczynać. Kod skojarzony z klasą musi być ograniczony nawiasami klamrowymi. Spróbujmy na podstawie tych informacji skonstruować klasę: // listing 03.01 class ShopProduct { // ciało klasy } Poleć książkęKup książkę PHP. OBIEKTY, WZORCE, NARZĘDZIA Zdefiniowana właśnie klasa ShopPoduct jest prawidłową klasą, choć jej przydatność jest na razie znikoma. Mimo to osiągnęliśmy coś bardzo znaczącego, bo zdefiniowaliśmy typ. Utworzyliśmy więc kategorię danych, którą możemy wykorzystywać w skryptach. Znaczenie tego faktu stanie się niebawem jaśniejsze. Pierwszy obiekt (lub dwa) Skoro klasa jest szablonem generowania obiektów, obiekt stanowią dane, które zostały zaaranżowane zgodnie z szablonem definiowanym w klasie. Obiekt zwie się egzemplarzem klasy bądź jej konkretyzacją. Klasa definiuje jego typ. Wykorzystamy teraz klasę ShopProduct jako formę do generowania obiektów typu ShopProduct. Pomoże nam w tym operator new. Operator new jest zazwyczaj stosowany w połączeniu z nazwą klasy, jak tutaj: // listing 03.02 $product1 = new ShopProduct(); $product2 = new ShopProduct(); Operator new, jeśli zostanie wywoływany z nazwą klasy w roli swojego jedynego operandu, zwraca egzemplarz tejże klasy. W naszym przykładzie generuje obiekt klasy ShopProduct. Klasę ShopProduct wykorzystaliśmy do wygenerowania dwóch obiektów typu ShopProduct. Choć funkcjonalnie $product1 i $product2 są identyczne (tzn. puste), stanowią obiekty rozłączne, a ich wspólnym mianownikiem jest jedynie wspólna klasa, na podstawie której zostały wygenerowane. Istnienie klas i obiektów można sprowadzić do następującej analogii: klasa to jakby maszyna tłocząca gumowe kaczki. Obiektami zaś są owe gumowe kaczki produkowane przy użyciu maszyny. Ich „typ” jest wyznaczany formą, w której są odciskane. Wszystkie wypluwane z maszyny kaczki wyglądają więc identycznie, ale są niezależnymi od siebie obiektami materialnymi. Innymi słowy, są różnymi egzemplarzami pewnego przedmiotu. Aby rozróżnić poszczególne kaczki, można by im zresztą podczas wytłaczania nadawać numery seryjne. Każdy obiekt tworzony w języku PHP również posiada odrębną tożsamość, jednak unikatową jedynie w okresie życia danego obiektu (PHP ponownie wykorzystuje nieużywane już identyfikatory obiektów w obrębie tego samego procesu). Można się o tym przekonać, wydrukowując obiekty $product1 i $product2: // listing 03.03 var_dump($product1); var_dump($product2); Wykonanie powyższego kodu spowoduje wypisanie na wyjściu: object(popp\r03\zestaw01\ShopProduct)#235 (0) { } object(popp\r03\zestaw01\ShopProduct)#234 (0) { }  Uwaga W bardzo starych wersjach PHP (do wersji 5.1 włącznie) można było wyświetlić zawartość obiektu wprost. Taka operacja powoduje zrzutowanie obiektu na ciąg znaków zawierający identyfikator obiektu. Od PHP 5.2 język został pozbawiony tej automagicznej konwersji, więc traktowanie obiektu jako ciągu znaków jest błędem, chyba że w klasie obiektu jest zdefiniowana metoda __toString(). Metodami zajmiemy się w dalszej części tego rozdziału, a o metodzie __toString() będzie mowa w rozdziale 4. Przekazanie obiektu do wywołania var_dump() pozwala wypisać ciekawe dane o obiekcie, z identyfikatorem obiektu na czele (po symbolu kratki). Aby klasę ShopProduct uczynić ciekawszą, możemy uzupełnić ją o obsługę specjalnych pól danych, zwanych składowymi bądź właściwościami (ang. properties). 38 Poleć książkęKup książkę ROZDZIAŁ 3.  OBIEKTOWY ELEMENTARZ Definiowanie składowych klasy Klasy mogą definiować specjalne zmienne zwane właściwościami bądź składowymi. Składowa przechowuje dane, które różnią się pomiędzy egzemplarzami danej klasy. W przypadku obiektów klasy ShopProduct (niech będzie to asortyment księgarski, choć ogólnie chodzi o dowolne artykuły) możemy na przykład zażyczyć sobie obecności pól ceny (price) i tytułu (title). Składowa klasy przypomina zwykłą zmienną, z tym że przy deklarowaniu składowej jej nazwę trzeba poprzedzić słowem kluczowym określającym widoczność. Może być nim public, protected albo private. Wybór słowa kluczowego widoczności określa zasięg, w którym możliwe będzie realizowanie odwołań do składowych.  Uwaga Zasięg to inaczej kontekst (klasy czy funkcji), w ramach którego zmienna posiada znaczenie (to samo dotyczy metod, o których więcej w dalszej części rozdziału). Zmienna zdefiniowana wewnątrz funkcji istnieje jedynie lokalnie, a zmienna definiowana poza funkcją istnieje globalnie. Należy przyjąć, że nie istnieje możliwość odwoływania się do danych definiowanych w zasięgu, który jest bardziej lokalny niż bieżący. Po zdefiniowaniu zmiennej wewnątrz funkcji nie można się do niej później odwołać spoza tejże funkcji. Obiekty są w tym względzie bardziej przenikalne — niektóre z ich zmiennych mogą być niekiedy dostępne z innych kontekstów. Ową dostępność reguluje się słowami public, protected i private. Do kwestii widoczności i regulujących ją słów kluczowych wrócimy później. Na razie spróbujemy po prostu zadeklarować kilka składowych klasy za pomocą słowa kluczowego public: // listing 03.04 class ShopProduct { public $title = bez tytułu ; public $producerMainName = nazwisko ; public $producerFirstName = imię ; public $price = 0; } Jak widać, uzupełniliśmy klasę o cztery składowe, przypisując do każdej z nich wartość domyślną. Wszelkie obiekty konkretyzowane na bazie takiej klasy będą teraz zawierać owe dane domyślne. Słowo kluczowe public poprzedzające deklarację każdej składowej umożliwia odwoływanie się do niej spoza kontekstu obiektu. Do składowych definiowanych w obrębie klasy, a konkretyzowanych w obiektach możemy się odwoływać za pośrednictwem ciągu znaków „- ” (operatora obiektów) w połączeniu ze zmienną w postaci obiektu oraz nazwą składowej: // listing 03.05 $product1 = new ShopProduct(); print $product1- title; bez tytułu Ponieważ składowe zostały zdefiniowane jako publiczne (public), możemy odczytywać ich wartości i je do nich przypisywać, zmieniając domyślne stany obiektów definiowane w klasie: // listing 03.06 $product1 = new ShopProduct(); $product2 = new ShopProduct(); $product1- title = Moja Antonia ; $product2- title = Paragraf 22 ; Deklarując i ustawiając w klasie ShopProduct składową $title, wymuszamy podaną początkową wartość tej składowej we wszystkich nowo tworzonych obiektach klasy. Oznacza to, że kod użytkujący klasę może bazować na domniemaniu obecności tej składowej w każdym z obiektów klasy. Nie może już jednak domniemywać wartości składowych, gdyż te — jak wyżej — mogą się w poszczególnych obiektach różnić między sobą. 39 Poleć książkęKup książkę PHP. OBIEKTY, WZORCE, NARZĘDZIA  Uwaga Kod wykorzystujący klasę, funkcję bądź metodę nazwiemy kodem klienckim wobec tej klasy, metody czy funkcji, albo po prostu klientem klasy (metody, funkcji). Termin „klient” będzie się więc w tej książce pojawiał stosunkowo często. Zresztą PHP nie zmusza nas do deklarowania wszystkich składowych w klasie. Obiekty można uzupełniać składowymi dynamicznie, jak tutaj: // listing 03.07 $product1- arbitraryAddition = nowość ; Taka metoda uzupełniania obiekt
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

PHP. Obiekty, wzorce, narzędzia. Wydanie V
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
ebook/pdf
71,20 zł
Idź do sklepu »

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ą: