47 |
48 |
49 |
--------------------------------------------------------------------------------
/_posts/01-01-01-Getting-Started.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Pierwsze kroki
3 | ---
4 |
5 | # Pierwsze kroki {#getting_started_title}
6 |
7 |
--------------------------------------------------------------------------------
/_posts/01-02-01-Use-the-Current-Stable-Version.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Korzystaj z ostatniej stabilnej wersji
3 | isChild: true
4 | ---
5 |
6 | ## Korzystaj z ostatniej stabilnej wersji {#use_the_current_stable_version_title}
7 |
8 | Jeżeli dopiero rozpoczynasz swoją przygodę z PHP, upewnij się, że korzystasz z ostatniej stabilnej wersji (obecnie
9 | [PHP 7.1][php-release]). PHP jest silnie rozwijane i twórcy tego języka wciąż dodają do niego
10 | [nowe, przydatne funkcje](#language_highlights). Mimo tego, że konwencja nadawania kolejnych numerów wersji języka
11 | może sugerować, że zmiany są niewielkie, w rzeczywistości różnice między kolejnymi wersjami są _znaczące_. Na stronach
12 | [php.net][php-docs] dostępna jest obszerna, przetłumaczona na wiele języków dokumentacja zawierająca opis możliwości
13 | języka PHP, jak również spis wszystkich dostępnych funkcji i sposobów ich wywołania.
14 |
15 | W środowiskach produkcyjnych najbardziej rozpowszechnionymi wersjami PHP są obecnie te z zakresu 5.x.
16 | Ostatnią wersją 5.x jest 5.6. Jest to nadal dobra opcja, ale jeśli jesteś odpowiedzialny za jakiś projekt PHP,
17 | to powinieneś jak najszybciej uaktualnić go do najnowszej stabilnej wersji, bo PHP 5.6
18 | [nie będzie otrzymywało poprawek bezpieczeństwa po roku 2018][php-support]. Aktualizacja nie jest skomplikowana,
19 | ale należy uwzględnić kilka zmian, które [nie są kompatybilne wstecznie][php-backwards-compatibility].
20 | Informacje o dostępności funkcji i funkcjonalności w poszczególnych wersjach PHP dostępne są w [podręczniku PHP][php-docs].
21 |
22 | [php-release]: http://www.php.net/downloads.php
23 | [php-docs]: http://www.php.net/manual/pl/
24 | [php-support]: http://php.net/supported-versions.php
25 | [php-backwards-compatibility]: http://php.net/manual/en/migration70.incompatible.php
26 |
--------------------------------------------------------------------------------
/_posts/01-03-01-Built-in-Web-Server.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Wbudowany serwer WWW
3 | isChild: true
4 | ---
5 |
6 | ## Wbudowany serwer WWW {#builtin_web_server_title}
7 |
8 | PHP 5.4 (oraz nowsze) posiadają własny, wbudowany w dystrybucję serwer WWW, więc jeżeli korzystasz z wersji
9 | PHP 5.4 lub nowszej, możesz łatwo rozpocząć naukę programownaia bez instalacji standardowego serwera
10 | HTTP, takiego jak Apache. Aby uruchomić serwer, wykonaj następujące polecenie w głównym katalogu
11 | swojego projektu:
12 |
13 | > php -S localhost:8000
14 |
15 | * [Dowiedz się więcej na temat wbudowanego serwera WWW] [cli-server]
16 |
17 | [cli-server]: http://www.php.net/manual/pl/features.commandline.webserver.php
18 |
--------------------------------------------------------------------------------
/_posts/01-04-01-Mac-Setup.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Instalacja na Maku
3 | isChild: true
4 | ---
5 |
6 | ## Instalacja na Maku {#mac_setup_title}
7 |
8 | W systemie macOS PHP jest zainstalowane domyślnie, lecz nigdy nie jest to najświeższa wersja.
9 | +Wersja "Mavericks" posiada PHP 5.4.17, "Yosemite" - 5.5.9, "El Capitan" - 5.5.29 a "Sierra" 5.6.24.
10 |
11 | Jest możliwość aktualizacji preinstalowanej wersji PHP do najnowszej - można to zrobić poprzez
12 | [odpowiednie pakiety][mac-package-managers]. Zalecamy instalację [php-osx by Liip][php-osx-downloads].
13 |
14 | Możesz także [skompilować PHP samodzielnie][mac-compile], ale wcześniej upewnij się, że masz zainstalowany Xcode lub
15 | ["Command Line Tools for Xcode"][apple-developer], które możesz ściągnąć ze strony Mac Developer Center firmy Apple.
16 |
17 | Istnieje również możliwość instalacji pakietu "all-in-one", który zawiera PHP, serwer Apache oraz bazę MySQL wraz z
18 | graficznym interfejsem do zarządzania całym pakietem. Jeżeli interesuje Cię ta opcja, zainteresuj się projektem
19 | [MAMP][mamp-downloads].
20 |
21 | [mac-package-managers]: http://www.php.net/manual/pl/install.macosx.packages.php
22 | [mac-compile]: http://www.php.net/manual/pl/install.macosx.compile.php
23 | [xcode-gcc-substitution]: https://github.com/kennethreitz/osx-gcc-installer
24 | [apple-developer]: https://developer.apple.com/downloads
25 | [mamp-downloads]: http://www.mamp.info/en/downloads/index.html
26 | [php-osx-downloads]: http://php-osx.liip.ch/
27 |
--------------------------------------------------------------------------------
/_posts/01-05-01-Windows-Setup.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Instalacja w systemie Windows
3 | isChild: true
4 | ---
5 |
6 | ## Instalacja w systemie Windows {#windows_setup_title}
7 |
8 | PHP w systemie Windows można zainstalować na kilka sposobów. Pierwszym z nich jest instalacja
9 | [binariów][php-downloads]. Do wersji 5.3.0 można było korzystać z instalatora .msi, obecnie ten sposób instalacji
10 | nie jest już wspierany.
11 |
12 | Do nauki i lokalnego rozwijania aplikacji opartych o PHP najlepiej użyć serwera WWW wbudowanego w dystrybucję.
13 | Używając go, nie musisz się martwić o jego konfigurację. Jeżeli potrzebujesz czegoś więcej, możesz użyć jednego z
14 | pakietów "all-in-one", który sprawnie zainstaluje dedykowany serwer WWW, PHP oraz bazę danych MysQL. Najbardziej
15 | znanymi rozwiązaniami tego typu są [Web Platform Installer][wpi], [Zend Server CE][zsce], [XAMPP][xampp] oraz
16 | [WAMP][wamp]. Używając ich, pamiętaj o tym, że takie środowisko może różnić się od produkcyjnego, działającego np. na
17 | Linuksie.
18 |
19 | Jeżeli chcesz stworzyć środowisko produkcyjne w systemie Windows, najlepszym rozwiązaniem jest użycie serwera IIS7,
20 | który uznawany jest obecnie za najszybszy i najbardziej stabilny serwer WWW dla Windows. Aby skonfigurować PHP na
21 | serwerze IIS7 możesz użyć pluginu [phpmanager][phpmanager]. Przydatne informacje możesz znaleźć na stronie
22 | [http://php.iis.net][php-iis].
23 |
24 | Pamiętaj o tym, że rozwijanie aplikacji w systemie znacznie różniącym się od docelowego może prowadzić do problemów
25 | podczas instalacji aplikacji na serwerze produkcyjnym. Jeżeli tworzysz aplikację pod Windowsem, a uruchamiasz ją pod
26 | Linuksem, rozważ możliwość użycia maszyny wirtualnej. W tym celu zainteresuj się projektami [Vagrant][vagrant], a także
27 | [Puppet][puppet] lub [Chef][chef].
28 |
29 | [php-downloads]: http://windows.php.net
30 | [phpmanager]: http://phpmanager.codeplex.com/
31 | [wpi]: http://www.microsoft.com/web/downloads/platform.aspx
32 | [zsce]: http://www.zend.com/en/products/zend_server
33 | [xampp]: https://www.apachefriends.org/
34 | [wamp]: http://www.wampserver.com/en/
35 | [php-iis]: http://php.iis.net/
36 | [vagrant]: http://vagrantup.com/
37 | [puppet]: http://www.puppetlabs.com/
38 | [chef]: https://www.chef.io/
39 |
--------------------------------------------------------------------------------
/_posts/02-01-01-Code-Style-Guide.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Jak formatować kod
3 | ---
4 |
5 | # Jak formatować kod {#code_style_guide_title}
6 |
7 | Społeczność zgromadzona wokół języka PHP jest relatywnie duża i zróżnicowana, dzięki czemu powstało wiele bibliotek,
8 | frameworków i komponentów. Typową praktyką stosowaną przez programistów PHP jest wybór kilku takich składników i
9 | stworzenie na bazie tego własnego projektu. Stąd istotną sprawą jest to, aby te biblioteki stosowały wspólne konwencje
10 | i styl kodowania.
11 |
12 | Aby wyjść temu problemowi naprzeciw, [Framework Interop Group][fig] (znane także jako 'PHP Standards Group')
13 | wypracowało serię rekomendacji dotyczących stylu kodowania znanych jako [PSR-0][psr0], [PSR-1][psr1],
14 | [PSR-2][psr2] oraz [PSR-4][psr4]. Są one zbiorem konwencji i dobrych praktyk, których powinny trzymać się
15 | programiści tworząc swoje projekty. Już teraz konwencje te stosują m.in. takie projekty jak Drupal,
16 | Zend Framework, CakePHP, phpBB, AWS SDK, FuelPHP, czy Lithium. Oczywiście stosowanie tych zaleceń nie jest
17 | obowiązkowe, równie dobrze możesz tworzyć kod używając swojego własnego stylu.
18 |
19 | Decydując się na używanie PSR, ułatwiasz potencjalnym programistom, którzy będę z Tobą współpracować, zrozumienie
20 | Twojego kodu. Struktura dokumentów PSR jest zorganizowana w ten sposób, że stosowanie PSR-1 wymusza stosowanie PSR-0,
21 | ale nie PSR-2, itd.
22 |
23 | * [Dowiedz się więcej o PSR-0][psr0]
24 | * [Dowiedz się więcej o PSR-1][psr1]
25 | * [Dowiedz się więcej o PSR-2][psr2]
26 | * [Dowiedz się więcej o PSR-4][psr4]
27 |
28 | Aby sprawdzić czy Twój kod spełnia założenia PSR, możesz użyć projektu [PHP_CodeSniffer][phpcs] z użyciem rozszerzenia
29 | [phpcs-psr][phpcs-psr] lub wtyczek do edytorów tekstowych sprawdzających poprawność stylu w locie,
30 | np.: wtyczka [sublime-phpcs][sublime-phpcs] dla edytora Sublime Text.
31 | Aby automatycznie poprawić styl kodu możesz użyć jednego z narzędzi:
32 |
33 | * [PHP Coding Standards Fixer][phpcsfixer]
34 | * [PHP Code Beautifier and Fixer][phpcbf]
35 |
36 | PHP_CodeSniffer użyty w linii poleceń
37 |
38 | phpcs -sw --standard=PSR2 file.php
39 |
40 | wyświetli listę błędów (odstępstw od standardu) wraz z informacją o sposobie usunięcia błędu.
41 | Pakiet PHP_CodeSniffer zawiera drugie polecenie - `phpcbf` - pozwalające automatycznie naprawić wykryte błędy:
42 |
43 | phpcbf -w --standard=PSR2 file.php
44 |
45 | PHP Coding Standards Fixer domyślnie naprawia błędy automatycznie, a z odpowiednimi parametrami
46 | (`--dry-run` i `--diff`) wyświetla podsumowanie proponowanych zmian nie zmieniając plików.
47 |
48 | Kod powinien być pisany z wykorzystaniem angielskiego nazewnictwa. Komentarze powinny być pisane w języku
49 | zrozumiałym dla aktualnych oraz potencjalnych programistów.
50 |
51 | [fig]: http://www.php-fig.org/
52 | [psr0]: http://www.php-fig.org/psr/psr-0/
53 | [psr1]: http://www.php-fig.org/psr/psr-1/
54 | [psr2]: http://www.php-fig.org/psr/psr-2/
55 | [psr4]: http://www.php-fig.org/psr/psr-4/
56 | [phpcs]: http://pear.php.net/package/PHP_CodeSniffer/
57 | [sublime-phpcs]: https://github.com/benmatselby/sublime-phpcs
58 | [phpcs-psr]: https://github.com/klaussilveira/phpcs-psr
59 | [phpcsfixer]: http://cs.sensiolabs.org/
60 | [phpcbf]: https://github.com/squizlabs/PHP_CodeSniffer/wiki/Fixing-Errors-Automatically
61 |
--------------------------------------------------------------------------------
/_posts/03-01-01-Language-Highlights.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Rzut okiem na język
3 | ---
4 |
5 | # Rzut okiem na język {#language_highlights_title}
6 |
--------------------------------------------------------------------------------
/_posts/03-02-01-Programming-Paradigms.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Paradygmaty programowania w PHP
3 | isChild: true
4 | ---
5 |
6 | ## Paradygmaty programowania w PHP {#programming_paradigms_title}
7 |
8 | PHP jest językiem, w którym możesz programować na wiele sposobów. Przez ostatnie lata mocno rozwinął swoje możliwości.
9 | W wersji 5.0 (2004) dodano zupełnie nowy model programowania obiektowego, w 5.3 (2009) wprowadzono m.in. [anonimowe
10 | funkcje][anonymous-functions] i [przestrzenie nazw][namespaces], a w 5.4 (2012) - [traity][traits].
11 |
12 | ### Programowanie obiektowe
13 |
14 | PHP posiada rozbudowany model programowania obiektowego, który obsługuje m.in klasy, klasy abstrakcyjne, interfejsy,
15 | dziedziczenie, konstruktory, klonowanie, czy wyjątki.
16 |
17 | * [Czytaj dalej na temat programowania obiektowego][oop]
18 | * [Dowiedz się więcej na temat traitów][traits]
19 |
20 | ### Programowanie funkcyjne
21 |
22 | PHP od wersji 5.3 wspiera możliwość przypisania funkcji do zmiennej - są to tzw. funkcje anonimowe lub closure'y.
23 | Zarówno funkcje wbudowane, jak i te stworzone przez programistę, mogą być dzięki temu wywołane w sposób dynamiczny,
24 | przekazane jako argumenty wywołania innych funkcji lub nawet przez nie zwracane.
25 |
26 | Funkcje mogą także wywoływać same siebie, czyli działać rekurencyjnie.
27 |
28 | W PHP 5.4 dodano możliwość przypisania closure'a do zakresu obiektu w taki sposób, że mogą one być stosowane zamiennie
29 | z funkcjami anonimowymi praktycznie w każdej sytuacji.
30 |
31 | * Dowiedz sie więcej o [programowaniu funkcyjnym w PHP](/pages/Functional-Programming.html)
32 | * [Artykuł o funkcjach anonimowych][anonymous-functions]
33 | * [Artykuł o klasach typu closure][closure-class]
34 | * [Więcej szczegółów znajdziesz w Closures RFC][closures-rfc]
35 | * [Artykuł o Callables][callables]
36 | * [Artykuł o dynamicznym wywoływaniu funkcji przy użyciu `call_user_func_array`][call-user-func-array]
37 |
38 | ### Metaprogramowanie
39 |
40 | PHP wspiera metaprogramowanie udostępniając mechanizmy takie jak Reflection API i magiczne metody - m.in. `__get()`,
41 | `__set()`, `__call()`, `__callStatic()`, `__clone()`, `__toString()` i `__invoke()`, które umożliwiają programiście
42 | wywołanie danego kodu podczas konkretnych zdarzeń w cyklu życia obiektu.
43 |
44 | * [Artykuł o Reflection API][reflection]
45 | * [Artykuł o magicznych metodach][magic-methods]
46 |
47 | [namespaces]: http://php.net/manual/pl/language.namespaces.php
48 | [overloading]: http://uk.php.net/manual/pl/language.oop5.overloading.php
49 | [oop]: http://www.php.net/manual/pl/language.oop5.php
50 | [anonymous-functions]: http://www.php.net/manual/pl/functions.anonymous.php
51 | [closure-class]: http://php.net/manual/pl/class.closure.php
52 | [callables]: http://php.net/manual/pl/language.types.callable.php
53 | [magic-methods]: http://php.net/manual/pl/language.oop5.magic.php
54 | [reflection]: http://www.php.net/manual/pl/intro.reflection.php
55 | [traits]: http://www.php.net/traits
56 | [call-user-func-array]: http://php.net/manual/pl/function.call-user-func-array.php
57 | [closures-rfc]: https://wiki.php.net/rfc/closures
58 |
--------------------------------------------------------------------------------
/_posts/03-03-01-Namespaces.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Przestrzenie nazw
3 | isChild: true
4 | ---
5 |
6 | ## Przestrzenie nazw {#namespaces_title}
7 |
8 | Jak wspomniano wcześniej, społeczność PHP jest tworzona przez niezliczoną ilość programistów. Powoduje to, że może
9 | zdarzyć się sytuacja, w której dwie różne biblioteki użyją klasy o takiej samej nazwie. W takim przypadku pojawi się
10 | problem.
11 |
12 | Naprzeciw temu problemowi wychodzą _przestrzenie nazw_, których działanie można porównać z funkcją katalogów w systemie
13 | plików. Tak samo jak dwa pliki o tej samej nazwie mogą istnieć w dwóch różnych katalogach, klasy o takich samych
14 | nazwach mogą istnieć w różnych przestrzeniach nazw.
15 |
16 | Z tego powodu istotne jest, aby Twój kod był przypisany do własnej przestrzeni nazw. Dzięki temu jego elementy (klasy,
17 | funkcje, czy stałe) nie będą kolidowały z klasami bibliotek, których używasz. Traktuje o tym dokument [PSR-0][psr0].
18 |
19 | W grudniu 2013 roku PHP-FIG przygotowało kolejny standard: [PSR-4][psr4], który pewnego dnia zastąpi standard [PSR-0][psr0].
20 |
21 | * [Więcej informacji o przestrzeniach nazw][namespaces]
22 |
23 | [namespaces]: http://php.net/manual/pl/language.namespaces.php
24 | [psr0]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md
25 | [psr4]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md
26 |
--------------------------------------------------------------------------------
/_posts/03-04-01-Standard-PHP-Library.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Biblioteka standardowa (SPL)
3 | isChild: true
4 | ---
5 |
6 | ## Biblioteka standardowa (SPL) {#standard_php_library_title}
7 |
8 | Biblioteka standardowa (SPL, Standard PHP Library) jest zbiorem klas i interfejsów, które zapewniają dostępność
9 | typowych struktur danych (stos, kolejka, kopiec, itp) oraz iteratorów zdolnych do trawersowania po nich. W SPL
10 | znajdziesz też funkcje i mechanizmy umożliwiające automatyczne ładowanie klas oraz klasy pomocnicze, przydatne przy
11 | tworzeniu rozwiązań opartych o wzorce projektowe, np. `SplObserer`, `SplSubject`).
12 |
13 | * [Artykuł o SPL][spl]
14 |
15 | [spl]: http://php.net/manual/pl/book.spl.php
16 |
--------------------------------------------------------------------------------
/_posts/03-05-01-Command-Line-Interface.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Interfejs CLI
3 | isChild: true
4 | ---
5 |
6 | ## Interfejs CLI (Command Line Interface) {#command_line_interface}
7 |
8 | PHP znajduje zastosowanie głównie przy tworzeniu aplikacji webowych, ale może być również użyteczny jako język
9 | skryptowy, uruchamiany z poziomu konsoli. Dzięki temu można łatwo automatyzować typowe zadania, jak testowanie
10 | jednostkowe, proces deploymentu, czy administrację aplikacją.
11 |
12 | Skrypty uruchamiane z poziomu konsoli mają dostęp do całego kodu Twojej aplikacji i mogą go uruchamiać w ten sam
13 | sposób jak w przypadku wywołania z poziomu serwera WWW. Pamiętaj, aby nie umieszczać skryptów przeznaczonych do
14 | uruchomienia pod konsolą w publicznej części Twojego projektu.
15 |
16 | Spróbuj uruchomić następujące polecenie z poziomu linii poleceń:
17 |
18 | {% highlight bash %}
19 | > php -i
20 | {% endhighlight %}
21 |
22 | Twoim oczom powinna ukazać się pełna konfiguracja PHP, zbliżona do tej, którą zwraca funkcja [`phpinfo`][phpinfo].
23 |
24 | Inną ciekawą opcją jest `-a` - umożliwia ona uruchomienie interaktywnej konsoli PHP, podobnej do tej z Ruby'ego, czy
25 | Pythona.
26 |
27 | Aby zapoznać się z pełną listą opcji interfejsu konsolowego, zajrzyj na [tę stronę][cli-options].
28 |
29 | Jeżeli argumentem wywołania polecenia `php` będzie plik z kodem źródłowym, zostanie on uruchomiony. Uruchamiając skrypt
30 | z poziomu konsoli otrzymujesz dostęp do dwóch zmiennych - `$argc` i `$argv`. Pierwsza z nich jest liczbą naturalną,
31 | reprezentującą ilość przekazanych argumentów wywołania, a druga tablicą z ich wartościami. Ponadto istnieje możliwość
32 | zwrócenia kodu wyjścia, aby poinformować powłokę, czy skrypt wykonał się poprawnie. Więcej informacji na temat kodów
33 | wyjścia znajdziesz [tutaj][exit-codes].
34 |
35 | Poniżej znajdziesz kod skryptu drukującego napis "Witaj, $imie" z możliwością podania imienia przez linię poleceń. Plik
36 | z przykładu nazywa się `hello.php`.
37 |
38 | {% highlight php %}
39 | php hello.php
52 | Usage: php hello.php [imię]
53 | > php hello.php Marek
54 | Witaj, Marek!
55 | {% endhighlight %}
56 |
57 |
58 | * [Jak uruchamiać skrypty PHP z linii poleceń][php-cli]
59 | * [Jak skonfigurować PHP w systemie windows, aby móc uruchamiać skrypty z linii poleceń][php-cli-windows]
60 |
61 | [phpinfo]: http://php.net/manual/pl/function.phpinfo.php
62 | [cli-options]: http://www.php.net/manual/pl/features.commandline.options.php
63 | [argc]: http://php.net/manual/pl/reserved.variables.argc.php
64 | [argv]: http://php.net/manual/pl/reserved.variables.argv.php
65 | [php-cli]: http://php.net/manual/pl/features.commandline.php
66 | [php-cli-windows]: http://www.php.net/manual/pl/install.windows.commandline.php
67 | [exit-codes]: http://www.gsp.com/cgi-bin/man.cgi?section=3&topic=sysexits
--------------------------------------------------------------------------------
/_posts/03-06-01-XDebug.md:
--------------------------------------------------------------------------------
1 | ---
2 | isChild: true
3 | ---
4 |
5 | ## XDebug {#xdebug_title}
6 |
7 | Jednym z najbardziej użytecznych narzędzi podczas programowania jest debugger. Debugger pozwala na śledzenie
8 | wykonywania kodu i monitorowanie zawartości stosu. W PHP dostępny jest debugger o nazwie XDebug. Można go używać z
9 | poziomu IDE do śledzenia wykonywania kodu, a także wykorzystywać do profilowania aplikacji za pomocą KCacheGrind, czy
10 | tworzenia raportów pokrycia kodu testami w PHPUnit.
11 |
12 | Debugger przydaje się tam, gdzie ręczny debug za pomocą funkcji print_r/var_dump nie daje rady.
13 |
14 | [Instalacja XDebuga][xdebug-install] może okazać się dość skomplikowana. Najważniejszą funkcjonalnością jest zdalne
15 | debuggowanie ("Remote Debugging") - przydaje się, gdy tworzysz kod lokalnie, a testujesz go na wirtualnej maszynie, bądź
16 | na zdalnym serwerze.
17 |
18 | Aby skorzystać z tej funkcji, należy zmodyfikować konfigurację vhosta w poniższy sposób:
19 |
20 | php_value xdebug.remote_host "?.?.?.?"
21 | php_value xdebug.remote_port "9000"
22 |
23 | Wartości dyrektyw `remote_host` i `remote_port` powinny wskazywać na adres IP lokalnego komputera i port na którym
24 | nasłuchuje IDE. Po załadowaniu adresu z dodatkowym parametrem `XDEBUG_SESSION_START` o wartości `1`
25 | (np. http://your-website.example.com/index.php?XDEBUG_SESSION_START=1), IDE przechwyci bieżący stan wykonywanego
26 | skryptu umożliwiając kontrolę jego wykonywania. To bardzo ułatwia debuggowanie aplikacji.
27 |
28 | * [Czytaj dalej o XDebug][xdebug-docs]
29 |
30 | [xdebug-docs]: http://xdebug.org/docs/
31 | [xdebug-install]: http://xdebug.org/docs/install
32 |
--------------------------------------------------------------------------------
/_posts/04-01-01-Dependency-Management.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Zarządzanie zależnościami
3 | ---
4 |
5 | # Zarządzanie zależnościami {#dependency_management_title}
6 |
7 | PHP posiada tysiące bibliotek, frameworków i komponentów. Tworząc swój projekt wybierzesz prawdopodobnie kilka z nich
8 | - będą to jego zależności. Przez wiele lat PHP nie posiadał sprawnie działającego sposobu na zarządzanie zależnościami.
9 | Nawet jeżeli udało Ci się zestawić razem potrzebne Ci biblioteki, musiałeś ręcznie zadbać o ich dołączenie do projektu.
10 | Nigdy więcej.
11 |
12 | PHP dysponuje dwoma niezależnymi systemami pakietów. Są nimi Composer i PEAR. Zastanawiasz się pewnie który wybrać.
13 | Otóż wszystko zależy od tego w jaki sposób chcesz go użyć.
14 |
15 | * Jeżeli potrzebujesz stworzyć zależności dla konkretnego projektu - użyj **Composera**.
16 | * Jeżeli potrzebujesz zarządzać zależnościami dla całej instalacji PHP - użyj **PEARa**.
17 |
18 | Innymi słowy, pakiety Composera będą dostępne jedynie w projekcie, dla którego je przygotujesz, podczas gdy biblioteki
19 | PEARa będą dostępne dla wszystkich aplikacji w obrębie instalacji PHP. Mimo, że PEAR wydaje się być łatwiejszym
20 | podejściem, istnieje wiele przesłanek, aby zarządzać swoimi zależnościami per projekt, czyli używając Composera.
21 |
--------------------------------------------------------------------------------
/_posts/04-02-01-Composer-and-Packagist.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Composer i Packagist
3 | isChild: true
4 | ---
5 |
6 | ## Composer i Packagist {#composer_and_packagist_title}
7 |
8 | Composer jest **genialnym** systemem wspomagającym zarządzanie zależnościami aplikacji w PHP. Wystarczy jeżeli
9 | wylistujesz swoje zależności w pliku `composer.json`, a narzędzie to, przy użyciu kilku prostych poleceń, automagicznie
10 | ściągnie odpowiednie wersje bibliotek i ich zależności oraz odpowiednio skonfiguruje autoloadera.
11 |
12 | Za pomocą Composera można zainstalować wiele znanych bibliotek. Ich listę znajdziesz na stronie projektu [Packagist][1]
13 | - oficjalnego repozytorium bibliotek kompatybilnych z tym systemem.
14 |
15 | ### Instalacja Composera
16 |
17 | Composera możesz zainstalować lokalnie (w katalogu Twojego projektu) lub globalnie (np. w /usr/local/bin). Aby móc użyć
18 | tego narzędzia, wejdź do jego katalogu swojego projektu i wydaj polecenie:
19 |
20 | curl -s https://getcomposer.org/installer | php
21 |
22 | Polecenie to ściągnie do bieżącego katalogu plik `composer.phar`, który będziesz mógł uruchomić za pomocą PHP, aby
23 | zarządzać zależnościami. Pamiętaj, że przekierowanie zawartości strony bezpośrednio do interpretera PHP może nie być
24 | bezpieczne - przed wykonaniem tego polecenia zapoznaj się z kodem znajdującym się pod adresem
25 | http://getcomposer.org/installer.
26 |
27 | Aby zainstalować Composera dla wszystkich użytkowników, wystarczy jeżeli przeniesiesz ściągnięty plik `composer.phar`
28 | do współdzielonego katalogu, np. `/usr/local/bin`, zmieniając jego nazwę na `composer`
29 | (`sudo mv composer.phar /usr/local/bin/composer`).
30 |
31 | ### Ręczna instalacja Composera
32 |
33 | Ręczna instalacja Composera jest bardziej skomplikowanym procesem, gdyż sam musisz sprawdzić swój system, aby
34 | upewnić się, że spełnia on wymagania stawiane przez tę aplikację. Instalacja automatyczna sprawdza:
35 | - czy używasz odpowiedniej wersji PHP,
36 | - czy rozszerzenie phar jest zainstalowane,
37 | - czy uprawnienia do katalogów są odpowiednie,
38 | - czy nie zostały zainstalowane problematyczne rozszerzenia PHP,
39 | - oraz czy plik `php.ini` zawiera odpowiednie ustawienia.
40 |
41 | Aby pobrać Composera ręcznie, wykonaj następujące polecenia:
42 |
43 | curl -s https://getcomposer.org/composer.phar -o $HOME/local/bin/composer
44 | chmod +x $HOME/local/bin/composer
45 |
46 | Ścieżka `$HOME/local/bin` (lub dowolna inna którą wybierzesz) powinna znajdować się w zmiennej środowiskowej $PATH,
47 | dzięki czemu będziesz miał możliwość skorzystania z polecenia `composer` zamiast `php composer.phar`.
48 |
49 | ### Jak definiować i instalować zależności
50 |
51 | Najpierw stwórz plik `composer.json` w katalogu głównym swojego projektu i umieść w nim odpowiednie wpisy. Poniższy
52 | przykład demonstruje jak przy użyciu Composera zainstalować projekt [Twig][2]. W pliku `composer.json` umieść poniższą
53 | zawartość:
54 |
55 | {
56 | "require": {
57 | "twig/twig": "1.8.*"
58 | }
59 | }
60 |
61 | A następnie, będąc w tym samym katalogu, uruchom poniższe polecenie:
62 |
63 | php composer.phar install
64 |
65 | Efektem działania będzie ściągnięcie odpowiedniej wersji projektu Twig do katalogu `vendors/` oraz odpowiednie
66 | skonfigurowanie autoloadera. Aby z niego skorzystać, musisz dołączyć plik `vendor/autoload.php` do swojego skryptu:
67 |
68 | {% highlight php %}
69 | upload->get_error()`, abyś sprawdził sobie co poszło nie tak. Problemem jest to, że musisz o tym wiedzieć lub
17 | szukać rozwiązania w dokumentacji, zamiast otrzymać jasny komunikat w postaci wyjątku.
18 |
19 | Innym problemem jest fakt, że zwykle w przypadku błędu aplikacje wyświetlają komunikat błędu na stronie i kończą
20 | wykonywanie skryptu przez `exit`, przez co developerzy tracą możliwość dynamicznego obsłużenia takiego przypadku.
21 | Naprzeciw temu wychodzą wyjątki, które informują dewelopera o problemie i pozwalają mu podjąć odpowiednie kroki.
22 | Przykład:
23 |
24 | {% highlight php %}
25 | subject('Mój temat');
28 | $email->body('Jak się masz?');
29 | $email->to('guy@example.com', 'Ktoś');
30 |
31 | try
32 | {
33 | $email->send();
34 | }
35 | catch(Fuel\Email\ValidationFailedException $e)
36 | {
37 | // Walidacja danych wejściowych nie powiodła się
38 | }
39 | catch(Fuel\Email\SendingFailedException $e)
40 | {
41 | // Aplikacja nie była w stanie wysłać maila
42 | }
43 | {% endhighlight %}
44 |
45 | ### Wyjątki w SPL
46 |
47 | Wyjątek sam w sobie nie ma żadnego konkretnego znaczenia i najprostszym sposobem na zmianę tego stanu rzeczy jest
48 | nadanie mu nazwy:
49 |
50 | {% highlight php %}
51 | format('Y-m-d') . "\n";
23 | {% endhighlight %}
24 |
25 | Operacje arytmetyczne na obiekcie `DateTime` najłatwiej wykonuje się za pomocą klasy `DateInterval`. `DateTime` posiada
26 | metody `add()` i `sub()`, które przyjmują obiekt klasy `DateInterval` jako argument - dzięki temu możesz zapomnieć o
27 | problemach związanych ze strefami czasowymi oraz istnieniem czasu letniego i zimowego. Przykładowo, aby obliczyć
28 | interwał czasu między dwiema datami, możesz użyć metody `diff()`. Zwraca ona obiekt `DateInterval`, który bez zbędnych
29 | obliczeń zamienisz na zrozumiały dla użytkownika ciąg znaków.
30 |
31 | {% highlight php %}
32 | add(new \DateInterval('P1M6D'));
36 |
37 | $diff = $end->diff($start);
38 | echo "Różnica: " . $diff->format('%m miesiąc, %d dni (razem: %a dni)') . "\n";
39 | // Różnica: 1 miesiąc, 6 dni (razem: 37 dni)
40 | {% endhighlight %}
41 |
42 | Stosując obiekty `DateTime` możesz używać zwykłych operatorów porównania:
43 | {% highlight php %}
44 | format('m/d/Y') . " ";
63 | }
64 | {% endhighlight %}
65 |
66 | * [Strona w manualu na temat `DateTime`][datetime]
67 | * [dostępne opcje formatowania dat w PHP][dateformat]
68 |
69 | [datetime]: http://www.php.net/manual/book.datetime.php
70 | [dateformat]: http://www.php.net/manual/function.date.php
71 |
--------------------------------------------------------------------------------
/_posts/05-03-01-Design-Patterns.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Wzorce projektowe
3 | isChild: true
4 | ---
5 |
6 | ## Wzorce projektowe {#design_patterns_title}
7 |
8 | Wzorce projektowe bywają bardzo pomocne podczas tworzenia aplikacji. Dzięki ich użyciu, prościej jest zarządzać swoim
9 | kodem, a innym deweloperom - zrozumieć jak działają jego wewnętrzne mechanizmy.
10 |
11 | Wiele popularnych frameworków PHP implementuje wzorce projektowe. Jeżeli używasz któregoś z nich w swojej aplikacji,
12 | do Ciebie należy jedynie podążanie za nimi w kodzie swojej aplikacji. Jeżeli budujesz coś własnego od zera, będziesz
13 | musiał znaleźć i dopasować wzorce, które odpowiadają strukturze Twojej aplikacji.
14 |
15 | * Więcej na temat [wzorców projektowych](/pages/Design-Patterns.html)
16 |
--------------------------------------------------------------------------------
/_posts/06-01-01-Databases.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Bazy danych
3 | ---
4 |
5 | # Bazy danych {#databases_title}
6 |
7 | Tworząc aplikacje webowe, wielokrotnie staniesz przed koniecznością przechowania pewnych informacji. Służą do tego
8 | bazy danych. PHP wspiera wiele różnych silników baz danych. Zalecanym sposobem komunikacji z bazami danych _do wersji
9 | 5.1_ były natywne sterowniki, takie jak [mysql][mysql], [mysqli][mysqli], [pgsql][pgsql], itd.
10 |
11 | Sterowniki te sprawują się dobrze, o ile łączysz się z tylko jednym rodzajem bazy danych, np. MySQL, czy MSSQL, gdyż
12 | każdy z nich posiada inne API, a nauka każdego z nich szybko może się okazać bezsensownym nakładem czasu. Dodatkowo,
13 | sterownik mysql nie jest już aktywnie rozwijany i od wersji PHP 5.4.0 ma status "Long term deprecation", co oznacza, że
14 | wkrótce może zostać usunięty z PHP. Jeżeli obecnie używasz w swojej aplikacji funkcji `mysql_connect()`, czy
15 | `mysql_query()`, zapewne wkróce staniesz przed problemem przepisania tej części. Aby tego uniknąć, zaleca się
16 | stosowanie obiektowych rozszerzeń, takich jak mysqli lub PDO.
17 |
18 | * [Jak wybrać API do MySQL](http://php.net/manual/en/mysqlinfo.api.choosing.php)
19 |
20 | ## PDO
21 |
22 | PDO jest bazodanową warstwą abstrakcji dostępną od PHP 5.1.0, która dostarcza obiektowy interfejs do komunikacji z
23 | wieloma silnikami baz danych. PDO nie tłumaczy Twoich zapytań SQL ani nie emuluje brakujących funkcjonalności; jest
24 | natomiast biblioteką umożliwiającą łączenie się do wszystkich obsługiwanych przez siebie baz danych przez jedno wspólne
25 | API, co jest doskonałym rozwiązaniem dla aplikacji w których osoba instalująca ją decyduje o typie silnika.
26 |
27 | Co ważne, PDO pozwala na przekazywanie parametrów do zapytania SQL bezpośrednio z żądania ($_GET, $_POST). Nie musisz
28 | martwić się już o ataki SQL injection, gdyż biblioteka w odpowiedni sposób zabezpieczy ich wartości, aby nie były
29 | niebezpieczne. Dzieje się to dzięki tzw. "prepared statements" (`PDO::prepare()`) i wstrzykiwaniu parametrów przy
30 | użyciu metody `bindParam()`.
31 |
32 | Spójrzmy na typowy przykład. Twój skrypt otrzymuje numeryczne ID w parametrze GET. To ID uzywane jest później w
33 | zapytaniu SQL, aby wyciągnąć z bazy informacje na temat konkretnego rekordu. Poniżej przedstawiony jest kod, który
34 | nie korzysta z "prepared statements":
35 |
36 | {% highlight php %}
37 | query("SELECT name FROM users WHERE id = " . $_GET['id']); // <-- NIE!
40 | {% endhighlight %}
41 |
42 | Cóż, ten kod jest tragiczny. Parametr `id` wstrzykiwany jest do zapytania SQL prosto z żądania (`$_GET['id']`), co
43 | umożliwia wykonanie ataktu SQL injection, a w efekcie wykonanie dowolnego zapytania SQL na Twojej bazie danych. Aby
44 | tego uniknąć, powinieneś zabezpieczyć wartość tego parametru. Dzięki `bindParam()`, operacja zabezpieczenia wykona się
45 | automatycznie:
46 |
47 | {% highlight php %}
48 | prepare('SELECT name FROM users WHERE id = :id');
51 | $stmt->bindParam(':id', $_GET['id'], PDO::PARAM_INT); //<-- Automatyczne zabezpieczenie wartości parametru
52 | $stmt->execute();
53 | {% endhighlight %}
54 |
55 | To jest poprawny kod. PDO przy użyciu metody `bindParam()` zabezpiecza w odpowiedni wartość parametru uniemożliwiając
56 | wykonanie ataku SQL injection.
57 |
58 | * [Więcej informacji o PDO][1]
59 |
60 | ## Warstwy abstrakcji
61 |
62 | Sporo frameworków posiada własną warstwę abstrakcji bazy danych. Niektóre z nich bazują na PDO, inne nie. Często
63 | emulują funkcjonalności niedostępne w danym silniku poprzez opakowywanie zapytań w metody. Jest to oczywiście
64 | pewien narzut czasowy, ale jeżeli Twoja aplikacja ma działać jednocześnie np. na MySQL, PostgreSQL i SQLite, czasem
65 | przejrzystość kodu jest ważniejsza niż niewielki narzut.
66 |
67 | Niektóre z tych warstw zostały napisane z uwzględnieniem standardu przestrzeni nazw `PSR-0`, dzięki czemu mogą być
68 | użyte w dowolnej aplikacji napisanej w PHP.
69 |
70 | * [Doctrine2 DBAL][2]
71 | * [ZF2 Db][4]
72 | * [ZF1 Db][3]
73 |
74 | [1]: http://www.php.net/manual/pl/book.pdo.php
75 | [2]: http://www.doctrine-project.org/projects/dbal.html
76 | [3]: http://framework.zend.com/manual/en/zend.db.html
77 | [4]: http://packages.zendframework.com/docs/latest/manual/en/index.html#zend-db
78 |
79 | [mysql]: http://pl.php.net/mysql
80 | [mysqli]: http://pl.php.net/mysqli
81 | [pgsql]: http://pl.php.net/pgsql
82 |
--------------------------------------------------------------------------------
/_posts/07-01-01-Security.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Bezpieczeństwo
3 | ---
4 |
5 | # Bezpieczeństwo {#security_title}
6 |
--------------------------------------------------------------------------------
/_posts/07-02-01-Web-Application-Security.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Bezpieczeństwo aplikacji webowych
3 | isChild: true
4 | ---
5 |
6 | ## Bezpieczeństwo aplikacji webowych {#web_application_security_title}
7 |
8 | Są na świecie dranie, którzy chcieliby wykorzystać Twoją aplikację do niecnych celów. Jako deweloper, powinieneś być
9 | świadomy zagrożeń, które czyhają z ich strony i w odpowiedni sposób zabezpieczyć swoją aplikację, aby ich uniknąć. Na
10 | szczęście dobrzy ludzie z projektu [The Open Web Application Security Project][1] (OWASP) przygotowali obszerną listę
11 | potencjalnych zagrożeń wynikających z dostępności Twojej aplikacji w Internecie wraz z informacjami o sposobach
12 | zabezpieczenia przez nimi. Jest to lektura obowiązkowa dla każdego dewelopera PHP chcącego pisać bezpieczne aplikacje
13 | webowe.
14 |
15 | * [Przeczytaj "OWASP Security Guide"][2]
16 |
17 | [1]: https://www.owasp.org/
18 | [2]: https://www.owasp.org/index.php/Guide_Table_of_Contents
19 |
--------------------------------------------------------------------------------
/_posts/07-03-01-Password-Hashing-with-Bcrypt.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Kodowanie haseł za pomocą Bcrypt
3 | isChild: true
4 | ---
5 |
6 | ## Kodowanie haseł za pomocą Bcrypt {#password_hashing_with_bcrypt_title}
7 |
8 | Każdy programista napisze pewnego dnia aplikację, w której jedną z funkcjonalności będzie możliwość zalogowania się
9 | użytkownika. W takiej aplikacji, dane autoryzacyjne (login i hasło) zwykle przechowywane są w bazie danych, aby za ich
10 | pomocą zautentykować użytkownika. W takim przypadku bardzo istotną kwestią jest odpowiednie zakodowanie (zahashowanie)
11 | zapisanych haseł, aby uniknąć sytuacji, w której po ataku hackerskim na bazę danych, konta Twoich użytkowników
12 | pozostaną dostępne włamywaczom.
13 |
14 | Na szczęście w PHP wbudowany jest prosty, acz skuteczny mechanizm hashowania dowolnych danych - Bcrypt. Po zastosowaniu
15 | go, otrzymujemy skrót, na podstawie którego nie ma możliwości odgadnięcia pierwotnej postaci zakodowanego ciągu znaków.
16 |
17 | w PHP dostępnych jest kilka bibliotek bazujących ba Bcyrpt, których móżesz użyć w swojej aplikacji.
18 |
19 | * [Artykuł "How to Safely Store a Password" na stronie Coda Hale][3]
20 | * [Strona projektu PHPass][4]
21 |
22 | [3]: http://codahale.com/how-to-safely-store-a-password/
23 | [4]: http://www.openwall.com/phpass/
24 |
--------------------------------------------------------------------------------
/_posts/07-04-01-Data-Filtering.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Filtrowanie danych
3 | isChild: true
4 | ---
5 |
6 | ## Filtrowanie danych {#data_filtering_title}
7 |
8 | Nigdy, przenigdy nie ufaj zewnętrznym danym wprowadzonym do Twojego kodu. Zawsze waliduj i zabezpieczaj je przed
9 | użyciem. Możesz użyć do tego funkcji `filter_var()` i `filter_input()`, które pomagają w tych czynnościach - potrafią
10 | przykładowo w prosty sposób sprawdzić poprawność składniową wprowadzonego przez użytkownika adresu e-mail.
11 |
12 | Zewnętrzne dane mogą znaleźć się wszędzie: głównym ich źródłem są tablice `$_GET` i `$_POST` zawierające parametry
13 | żądania. Niektóre wartości w tablicy `$_SERVER` pochodzą wprost z nagłówków, które wysyła użytkownik, czy
14 | `fopen('php://input', 'r')` - ciało żądania HTTP. Pamiętaj, że zewnętrzne dane to nie tylko dane z formularzy
15 | wysłanych przez użytkownika. Pliki, które ściągasz, dane sesji, ciasteczka, czy nawet dane z zewnętrznych
16 | webservice'ów powinny być traktowane jako dane, którym nie można ufać.
17 |
18 | Z uwagi na to, że zewnętrzne dane mogą być przechowywane w bazach danych, należy pamiętać o tym, żeby przy ich odczycie
19 | również zadbać o ich zabezpieczenie. Za każdym razem, gdy próbujesz użyć takich danych zadaj sobie pytanie, czy są one
20 | odpowiednio zabezpieczone i czy można im ufać.
21 |
22 | Sposób zabezpieczania zewnętrznych danych zależy od sposobu ich użycia. Przykładowo gdy chcesz użyć danych pochodzących
23 | od użytkownika w HTML'u, musisz zadbać o usunięcie bądź zamianę znaczników sterujących, takich jak '<', '>' na
24 | odpowiednie encje HTML, gdyż w przeciwnym razie odpowiednio spreparowany ciąg znaków może uruchomić skrypt JS, co może
25 | być bardzo opłakane w skutkach - może przykładowo pomóc w przejęciu sesji użytkownika. Taki rodzaj ataku to XSS
26 | (Cross-Site Scripting).
27 |
28 | Innym przykładem jest przekazywanie danych od użytkownika jako fragment lub całość komendy do wykonania z poziomu linii
29 | poleceń. Nieodpowiednie zabezpieczenie takich danych przed użyciem w ten sposób może doprowadzić do wykonania
30 | niepożądanego polecenia, co może być poważnym zagrożeniem bezpieczeństwa aplikacji i/lub systemu na którym ona działa.
31 | Aby bezpiecznie przekazać takie dane do wiersza poleceń, zabezpiecz je za pomocą funkcji `escapeshellarg()`.
32 |
33 | Niebezpieczeństwo może czyhać również tam, gdzie za pomocą danych z zewnątrz ustalasz ścieżkę w systemie plików.
34 | Atakujący może wykorzystać to poprzez odpowiednią zmianę przekazanych wartości. Twoja aplikacja wczyta wtedy inny plik
35 | niż powinna, co może spowodować wyciek prywatnych danych lub pomóc w przeprowadzeniu innego ataku. Aby zabezpieczyć się
36 | przed tym, usuwaj "/", ".." i tzw. "[null bytes][6]" ze zmiennych przy użyciu których ustalasz ścieżkę pliku do
37 | wczytania.
38 |
39 | * [Dowiedz się więcej na temat filtrowania danych][1]
40 | * [Dowiedz się więcej na temat funkcji `filter_var()`][4]
41 | * [Dowiedz się więcej na temat funkcji `filter_input()`][5]
42 | * [Dowiedz się więcej na temat "null bytes"][6]
43 |
44 | ### Zabezpieczanie danych z zewnątrz (escaping)
45 |
46 | Dane pochodzące z zewnątrz mogą posiadać niebezpieczne znaki. Aby bezpiecznie się nimi posługiwać w aplikacji (np. aby
47 | bezpiecznie skorzystać z danych wejściowych w HTML'u bądź zapytaniu SQL), należy się ich pozbyć. Proces ten nazywany
48 | jest escapingiem.
49 |
50 | W przypadku zapytań SQL najlepszym sposobem na automatyczne zabezpieczenie się przez niebezpiecznymi znakami jest
51 | użycie PDO, które zrobi to za Ciebie. Jeżeli chodzi o HTML, częstym wyzwaniem jest konieczność dopuszczenia kilku
52 | wybranych tagów, aby umożliwić użytkownikowi proste formatowanie wpisanego tekstu. W takim przypadku jednym z wyjść
53 | jest użycie formatowania Markdown lub BBCode, bądź bibliotek takich jak [HTML Purifier][html-purifier].
54 |
55 | [Lista filtrów escape'ujących][2]
56 |
57 | ### Walidacja
58 |
59 | Dzięki walidacji możesz upewnić się, że wprowadzone przez użytkownika dane są tym, czego się spodziewasz. Dobrym
60 | przykładem jest walidacja danych takich jak adres e-mail, numer telefonu, czy wiek, wprowadzonych w formularzu
61 | rejestracji.
62 |
63 | [Lista filtrów walidujących][3]
64 |
65 | [1]: http://www.php.net/manual/pl/book.filter.php
66 | [2]: http://www.php.net/manual/pl/filter.filters.sanitize.php
67 | [3]: http://www.php.net/manual/pl/filter.filters.validate.php
68 | [4]: http://php.net/manual/pl/function.filter-var.php
69 | [5]: http://www.php.net/manual/pl/function.filter-input.php
70 | [6]: http://php.net/manual/pl/security.filesystem.nullbytes.php
71 | [html-purifier]: http://htmlpurifier.org/
72 |
--------------------------------------------------------------------------------
/_posts/07-05-01-Configuration-Files.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Pliki konfiguracyjne
3 | isChild: true
4 | ---
5 |
6 | ## Pliki konfiguracyjne {#configuration_files_title}
7 |
8 | Jeżeli Twoja aplikacja używa zewnętrznych plików konfiguracyjnych, pamiętaj, że nie powinny być one dostępne dla
9 | zewnętrznego świata. Zalecane jest użycie jednego z poniższych sposobów ich zabezpieczenia:
10 |
11 | - Trzymaj pliki konfiguracyjne poza DocumentRoot'em, dzięki czemu nie będą dostępne przez serwer WWW.
12 | - Jeżeli musisz przechowywać je w DocumentRoot'cie, zmień ich rozszerzenie na `.php`. W tym przypadku, nawet jeżeli
13 | skrypt zostanie wywołany bezpośrednio, jego zawartość nie będzie zwrócona do przeglądarki w oryginalnej formie.
14 | - Zawartość plików konfiguracyjnych powinna zostać odpowiednio zabezpieczona - albo poprzez ich szyfrowanie, albo przy
15 | użyciu zabezpieczeń oferowanych przez system plików (zmiana właściciela i/lub praw dostepu).
16 |
--------------------------------------------------------------------------------
/_posts/07-06-01-Register-Globals.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: register_globals
3 | isChild: true
4 | ---
5 |
6 | ## register_globals {#register_globals_title}
7 |
8 | UWAGA:
9 | Od wersji PHP 5.4.0 dyrektywa `register_globals` została usunięta i nie ma możliwości korzystania niej. Jej dostępność
10 | w wersjach >= 5.4.0 ogranicza się do wyświetlenia odpowiedniego komunikatu w przypadku omyłkowego użycia.
11 |
12 | W poprzednich wersjach PHP, po włączeniu dyrektywy `register_globals`, zmienne pochodzące od użytkownika (m.in.
13 | `$_POST`, `$_GET` i `$_REQUEST`) były "spłaszczane" do zwykłych zmiennych dostępnych w globalnej zakresie widoczności.
14 | To w łatwy sposób mogło prowadzić do problemów bezpieczeństwa, gdyż aplikacja nie była w stanie stwierdzić skąd
15 | pochodzą wartości poszczególnych zmiennych.
16 |
17 | Przykładowo, po włączeniu `register_globals`, zmienna `$_GET['foo']` byłaby dostępna jako $foo, co może nadpisać inną
18 | zmienną $foo i powodować problemy.
19 |
20 | Podsumowując, jeżeli używasz PHP < 5.4.0 __upewnij się__, że dyrektywa `register_globals` ma wartość __off__.
21 |
22 | * [Artykuł na ten temat w manualu](http://www.php.net/manual/pl/security.globals.php)
--------------------------------------------------------------------------------
/_posts/07-07-01-Error-Reporting.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Raportowanie błędów
3 | isChild: true
4 | ---
5 |
6 | ## Raportowanie błędów {#error_reporting_title}
7 |
8 | Wyświetlanie błędów jest pomocne przy szukaniu problematycznych miejsc w Twojej aplikacji, ale ma jeden poważny minus:
9 | eksponuje systemowe, być może kluczowe z punktu widzenia bezpieczeństwa, informacje całemu światu. Pamiętaj o tym, że
10 | środowisko produkcyjne (live) powinno być skonfigurowane pod tym względem inaczej niż deweloperskie.
11 |
12 | ### Środowisko deweloperskie
13 |
14 | W środowisku deweloperskim lub testowym wyświetlanie komunikatów błędów może być
15 | przydatne podczas śledzenia problemów z aplikacją. W tym środowisku powinieneś skonfigurować raportowanie błędów w ten
16 | sposób:
17 |
18 | - display_errors: On
19 | - error_reporting: -1
20 | - log_errors: On
21 |
22 | Za [php.net](http://pl1.php.net/manual/pl/function.error-reporting.php):
23 |
24 | > Passing in the value -1 will show every possible error, even when new levels and constants are added in future PHP versions. The E_ALL constant also behaves this way as of PHP 5.4.
25 |
26 | Poziom raportowania `E_STRICT` jest dostępny od wersji 5.3.0 nie będąc częścią poziomu `E_ALL`. W wersji 5.4.0
27 | zmieniono to zachowanie i `E_STRICT` jest częścią `E_ALL`. Co oznacza to dla programisty? To, że jeżeli potrzebuje
28 | wyświetlać wszystkie możliwe błędy w 5.3.0, należy użyć wartości `-1` lub `E_ALL | E_STRICT`.
29 |
30 | Podsumowując:
31 |
32 | * dla PHP < 5.3 - `-1` lub `E_ALL`
33 | * dla PHP = 5.3 - `-1` lub `E_ALL | E_STRICT`
34 | * dla PHP > 5.3 - `-1` lub `E_ALL`
35 |
36 | ### Środowisko produkcyjne
37 |
38 | W środowisku produkcyjnym wszystkie błędy powinny być ukryte i logowane do zewnętrznego pliku. W tym
39 | środowisku powinieneś skonfigurować raportowanie błędów w ten sposób:
40 |
41 | - display_errors: Off
42 | - error_reporting: E_ALL
43 | - log_errors: On
44 |
45 | Aby uzyskać więcej informacji na temat funkcji kontrolujących sposób raportowania błędów, zajrzyj do manuala:
46 |
47 | * [Error_reporting](http://www.php.net/manual/pl/errorfunc.configuration.php#ini.error-reporting)
48 | * [Display_errors](http://www.php.net/manual/pl/errorfunc.configuration.php#ini.display-errors)
49 | * [Log_errors](http://www.php.net/manual/pl/errorfunc.configuration.php#ini.log-errors)
--------------------------------------------------------------------------------
/_posts/08-01-01-Testing.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Testowanie
3 | ---
4 |
5 | # Testowanie {#testing_title}
6 |
7 | Pisanie testów automatycznych do dobra praktyka zwiększająca prawdopodobieństwo, że Twoja aplikacja będzie dobrze
8 | zbudowana. Uruchamiając testy automatyczne podczas kodowania upewniasz się, że zmiany, które wprowadzasz nie psują
9 | innych rejonów aplikacji. Korzystaj z nich, jeżeli możesz.
10 |
11 | Istnieje kilka sposobów automatycznego testowania kodu aplikacji napisanych w PHP. Każdy z nich ma na celu zredukowanie
12 | nakładu na ręczne testowanie, co oczywiście przekłada się na mniejsze zespoły testowe, a w efekcie do ograniczenia
13 | kosztów projektu.
--------------------------------------------------------------------------------
/_posts/08-02-01-Test-Driven-Development.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Test-Driven Development
3 | isChild: true
4 | ---
5 |
6 | ## Test-Driven Development {#test_driven_development_title}
7 |
8 | Cytując [Wikipedię](http://pl.wikipedia.org/wiki/Test-driven_development):
9 |
10 | > Test-driven development (TDD) jest techniką tworzenia oprogramowania, która polega na wielokrotnym powtarzaniu kilku kroków: najpierw programista pisze automatyczny test sprawdzający dodawaną funkcjonalność. Test w tym momencie nie powinien się udać. Później następuje implementacja funkcjonalności. W tym momencie wcześniej napisany test powinien się udać. W ostatnim kroku, programista dokonuje refaktoryzacji napisanego kodu, żeby spełniał on oczekiwane standardy. Technika została stworzona przez Kenta Becka. Można jej też używać do poprawiania istniejącego kodu.
11 |
12 | Istnieje kilka sposób testowania aplikacji, których możesz użyć podczas rozwijania swojej aplikacji.
13 |
14 | ### Testy jednostkowe
15 |
16 | Testy jednostkowe są techniką, która umożliwia sprawdzenie, czy funkcje, klasy i metody działają tak jak powinny -
17 | przez cały cykl ich życia. Sprawdzanie ich wewnętrznej logiki odbywa się poprzez ich wywoływanie z różnymi parametrami
18 | wejściowymi i badaniu ich odpowiedzi za pomocą odpowiednich asercji. Jeszcze dokładniejsze wyniki testów oraz bardziej
19 | kompletne pokrycie kodu testami można uzyskać dzięki wstrzykiwaniu zależności oraz korzystaniu z "mocków".
20 |
21 | Kiedy tworzysz klasę lub funkcję, powinieneś napisać test jednostkowy pokrywający i testujący zachowanie, które powinna
22 | posiadać. Najprostszym przykładem jest stworzenie testu, który sprawdzi, czy dla poprawnych danych wejściowych
23 | funkcja/metoda działa prawidłowo, a dla złych - odpowiednio to obsługuje. Dzięki temu wykonując kolejne zmiany i
24 | refaktoryzacje masz pewność, że kod wciąż działa tak jak powinien.
25 |
26 | Testy jednostkowe znajdują zastosowanie również w open-source - dzięki nim możesz w łatwy sposób pokazać, że dana
27 | funkcjonalność nie działa prawidłowo, a następnie po wprowadzeniu poprawki sprawdzić, że ona faktycznie działa. Jeżeli
28 | prowadzisz projekt, w którym korzystasz z tzw. "pull requests", zdecydowanie powinieneś wymagać wykonania odpowiednich
29 | testów jednostkowych.
30 |
31 | [PHPUnit](http://phpunit.de) jest najbardziej znanym frameworkiem, dzięki którym łatwo rozpoczniesz korzystanie z
32 | testów jednostkowych. Są również alternatywy:
33 |
34 | * [SimpleTest](http://simpletest.org)
35 | * [Enhance PHP](http://www.enhance-php.com/)
36 | * [PUnit](http://punit.smf.me.uk/)
37 |
38 | ### Testy integracyjne
39 |
40 | Cytując [Wikipedię](http://en.wikipedia.org/wiki/Integration_testing) (polskie tłumaczenie):
41 |
42 | > Testowanie integracyjne, zwane także Integracją i Testowaniem (ang. Integration and Testing, "I&T") jest fazą produkcji oprogramowania polegającą na automatycznym testowaniu odpowiednich grup modułów jako całość. Testy integracyjne wykonuje się zwykle po wykonaniu odpowiednich testów jednostkowych, a przed testami funkcjonalnymi. Testowanie integracyjne odbywa się na modułach, które zostały przetestowane jednostkowo. Moduły grupuje się w większe zbiory, na których stosuje się odpowiednie testy ujęte w planie testu integracyjnego i dostarcza się zintegrowany produkt, gotowy do testowania funkcjonalnego.
43 |
44 | Proces wykonywania testów integracyjnych rządzi się zasadami podobnymi do testowania jednostkowego, więc do ich
45 | wykonywania możesz używać tych samych narzędzi.
46 |
47 | ### Testy funkcjonalne
48 |
49 | Czasami znane również jako testy akceptacyjne. W odróżnieniu od testów jednostkowych, zamiast konkretnych fragmentów
50 | kodu, testują one pełną aplikację. Takie testy zwykle korzystają z rzeczywistych danych i symulują zachowanie
51 | prawdziwych użytkowników.
52 |
53 | #### Narzędzia do testów funkcjonalnych
54 |
55 | * [Selenium](http://seleniumhq.com)
56 | * [Mink](http://mink.behat.org)
57 | * [Codeception](http://codeception.com) framework do testowania zawierający narzędzia do testów akceptacyjnych
58 |
--------------------------------------------------------------------------------
/_posts/08-03-01-Behavior-Driven-Development.md:
--------------------------------------------------------------------------------
1 | ---
2 | isChild: true
3 | ---
4 |
5 | ## Behavior Driven Development {#behavior_driven_development_title}
6 |
7 | Istnieją dwa rodzaje BDD (Behavior-Driven Development): SpecBDD i StoryBDD. Pierwszy z nich charakteryzuje się
8 | technicznym podejściem, gdzie istotny jest kod i jego zachowanie, podczas gdy drugi reprezentuje podejście biznesowe,
9 | gdzie najważniejszą kwestią jest to jak produkt będzie funkcjonował z perspektywy klienta. W PHP dostępne są frameworki
10 | wspierające oba te typy.
11 |
12 | W StoryBDD piszesz zrozumiałe dla człowieka historyjki, które opisują zachowanie Twojej aplikacji. Są one później
13 | uruchamiane jako testy aplikacji. Frameworkiem, który wspiera taki typ testowania jest [Behat](http://behat.org/),
14 | inspirowany projektem [Cucumber](http://cukes.info/) dla Ruby'ego. Do opisywania historyjek w Behat używa się języka
15 | Gherkin DSL (Gherkin Domain Specific Language).
16 |
17 | W SpecBDD piszesz natomiast specyfikacje opisujące w jaki sposób powinien zachowywać się Twój kod. Zamiast testować
18 | funkcję, czy metodę, opisujesz jak powinna się zachowywać. Ten typ BDD wspierany jest przez framework PHPSpec, który
19 | z kolei inspirowany jest projektem [RSpec project](http://rspec.info/), także dla Ruby'ego.
20 |
21 | ### Linki
22 |
23 | * [Behat](http://behat.org/)
24 | * [PHPSpec](http://www.phpspec.net/)
25 | * [Codeception](http://www.codeception.com) framework do testowania aplikacji korzystający z zasad BDD
26 |
--------------------------------------------------------------------------------
/_posts/08-04-01-Complementary-Testing-Tools.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Dodatkowe narzędzia
3 | isChild: true
4 | ---
5 |
6 | ## Dodatkowe narzędzia {#complementary_testing_tools_title}
7 |
8 | Oprócz frameworków wspomagających testowanie istnieje również wiele innych narzędzi i bibliotek przydatnych podczas
9 | testowania aplikacji.
10 |
11 | ### Linki
12 |
13 | * [Selenium](http://seleniumhq.org/) narzędzie do automatyzacji testów w przeglądarkach, które może być zintegrowany z [PHPUnit](http://www.phpunit.de/manual/3.1/en/selenium.html)
14 | * [Mockery](https://github.com/padraic/mockery) framework typu Mock Object, który może być zintegrowany z [PHPUnit](http://phpunit.de/) lub [PHPSpec](http://www.phpspec.net/)
15 |
--------------------------------------------------------------------------------
/_posts/09-01-01-Servers-and-Deployment.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Serwery i deployment
3 | ---
4 |
5 | # Serwery i deployment {#servers_and_deployment_title}
6 |
7 | Aplikacje napisane w PHP mogą być deployowane na serwery produkcyjne na wiele różnych sposobów.
8 |
--------------------------------------------------------------------------------
/_posts/09-02-01-Platform-as-a-Service.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Chmura
3 | isChild: true
4 | ---
5 |
6 | ## Chmura {#platform_as_a_service_title}
7 |
8 | Chmura, czyli PaaS (skrót od Platform as a Service), dostarcza pełną architekturę, której wymaga Twoja aplikacja PHP,
9 | aby być dostępna w Sieci. Oznacza to, że za pomocą kilku kliknięć jesteś w stanie uruchomić takie środowisko, a nawet
10 | zainstalować odpowiednie frameworki, czy biblioteki.
11 |
12 | Ostatnimi czasy, głównie ze względu na łatwość skalowania aplikacji, rozwiązania oparte o chmurę zdobywają coraz
13 | większą popularność. [Listę dostawców](#paas_providers) rozwiązań PaaS znajdziesz w rozdziale [linki](#resources_title);
14 |
--------------------------------------------------------------------------------
/_posts/09-03-01-Virtual-or-Dedicated-Servers.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Serwery wirtualne lub dedykowane
3 | isChild: true
4 | ---
5 |
6 | ## Serwery wirtualne lub dedykowane {#virtual_or_dedicated_servers_title}
7 |
8 | Jeżeli potrafisz administrować serwerem bądź planujesz naukę w tym kierunku, zainteresuj się serwerami wirtualnymi.
9 | Dzięki nim masz możliwość skonfigurowania każdego detalu swojego środowiska produkcyjnego.
10 |
11 | ### nginx i PHP-FPM
12 |
13 | PHP potrafi dobrze współdziałać z serwerem [nginx](http://nginx.org) przy użyciu wbudowanego managera procesów FastCGI
14 | (FPM). Nginx jest lekkim i szybkim serwerem WWW, który zużywa znacznie mniej zasobów maszyny niż Apache, przez co
15 | potrafi obsłużyć więcej jednoczesnych procesów.
16 |
17 | * [Czytaj dalej o serwerze nginx](http://nginx.org)
18 | * [Czytaj dalej o PHP-FPM](http://php.net/manual/en/install.fpm.php)
19 | * [Jak bezpiecznie skonfigurować PHP i nginx](https://nealpoole.com/blog/2011/04/setting-up-php-fastcgi-and-nginx-dont-trust-the-tutorials-check-your-configuration/)
20 |
21 | ### Apache i PHP
22 |
23 | PHP i Apache mają za sobą długą historię. Serwer ten cechuje się łatwą, a zarazem dość obszerną konfiguracją, a także
24 | posiada wiele [modułów](http://httpd.apache.org/docs/2.4/mod/) rozszerzających jego możliwości. Na serwerach
25 | hostingowych jest często wybierany jako platforma pod popularne aplikacje open-source (np. Wordpress), czy aplikacje
26 | bazujące na frameworkach. Apache jednakowoż podczas pracy zużywa więcej zasobów serwera, przez co nie może obsłużyć tak
27 | wielu jednoczesnych połączeń, jak jego konkurent, nginx.
28 |
29 | Istnieje kilka możliwości zainstalowania PHP na serwerze Apache. Najczęstszym wyborem jest
30 | [prefork MPM](http://httpd.apache.org/docs/2.4/mod/prefork.html) (od Multi-Processing Modules) i moduł mod_php5. Jest
31 | to najszybszy sposób, który wymaga relatywnie niewielkiego nakładu pracy administracyjnej i jest najlepszym podejściem
32 | dla osób, które wolą ten czas przeznaczyć na kodowanie. Minusem jest fakt, że mod_php5 zużywa więcej zasobów, co może
33 | wpłynąć na szybkość działania.
34 |
35 | Jeżeli chcesz wycisnąć z Apache'a nieco więcej szybkości oraz stabilności działania, możesz użyć tego samego systemu
36 | FPM, który współdziała z serwerem nginx i uruchomić mpm_worker (http://httpd.apache.org/docs/2.4/mod/worker.html)
37 | lub [mpm_event](http://httpd.apache.org/docs/2.4/mod/event.html) z mod_fastcgi lub mod_fcgid. Aplikacje uruchomione w
38 | takiej konfiguracji będą działać szybciej, ale jej instalacja będzie wymagała większego nakładu pracy.
39 |
40 | * [Czytaj o serwerze Apache](http://httpd.apache.org/)
41 | * [Czytaj o Multi-Processing Modules](http://httpd.apache.org/docs/2.4/mod/mpm_common.html)
42 | * [Czytaj o mod_fastcgi](http://www.fastcgi.com/mod_fastcgi/docs/mod_fastcgi.html)
43 | * [Czytaj o mod_fcgid](http://httpd.apache.org/mod_fcgid/)
44 |
--------------------------------------------------------------------------------
/_posts/09-04-01-Shared-Servers.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Serwery hostingowe
3 | isChild: true
4 | ---
5 |
6 | ## Serwery hostingowe {#shared_servers_title}
7 |
8 | PHP dzięki swojej popularności jest szeroko wspierany na serwerach hostingowych na całym świecie. Mówiąc szczerze,
9 | trudno w dzisiejszych czasach znaleźć ofertę bez wsparcia dla tego języka. Liczbę ofert godnych zainteresowania
10 | zmniejszy na pewno ważne kryterium - numer zainstalowanej wersji interpretera; ważne, aby była to jedna z ostatnich
11 | wersji.
12 |
13 | Serwery hostingowe to rozwiązania współdzielone, co oznacza, że na jednej fizycznej maszynie może działać wiele
14 | aplikacji. Plusem takiego podejścia jest fakt, że hosting jest relatywnie tani. Minusem jest brak niezależności:
15 | zasoby serwera mogą być zajęte przez innych użytkowników, unieruchamiając bądź ograniczając dostęp do Twojej aplikacji.
16 | Inną istotną sprawą jest fakt, że inne aplikacje zainstalowane na tym samym serwerze mogą posiadać luki bezpieczeństwa,
17 | które pozwolą atakującemu uzyskać dostęp do maszyny i wykonać atak na wszystkich, nawet bezpiecznych aplikacjach.
18 | Jeżeli Twój budżet na to pozwala, powinieneś unikać serwerów hostingowych.
19 |
--------------------------------------------------------------------------------
/_posts/10-01-01-Caching.md:
--------------------------------------------------------------------------------
1 | # Caching {#caching_title}
2 |
3 | PHP sam w sobie całkiem dobrze radzi sobie z wydajnością, lecz jeżeli wykonujesz operacje kosztowne czasowo (np.
4 | komunikujesz się ze zdalnymi serwerami, czy ładujesz do pamięci duże pliki), może okazać się, że te miejsca negatywnie
5 | wpływają na wydajność Twojej aplikacji. Na szczęście istnieje kilka narzędzi, które pozwalają na pozbycie się takich
6 | wąskich gardeł, lub ograniczają ilość czasu potrzebnego na ich wykonanie.
7 |
--------------------------------------------------------------------------------
/_posts/10-02-01-Bytecode-Cache.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Kod bajtowy
3 | isChild: true
4 | ---
5 |
6 | ## Kod bajtowy {#bytecode_cache_title}
7 |
8 | Kiedy wykonujemy program napisany w PHP, jego kod źródłowy jest najpierw kompilowany do postaci kodu bajtowego, a
9 | następnie uruchamiany. Jeżeli między kolejnymi uruchomieniami plik z kodem nie zostaje zmodyfikowany, wynikowy kod
10 | bajtowy jest taki sam za każdym razem. Oznacza to, że kolejne jego kompilacje nie są potrzebne i powodują jedynie
11 | niepotrzebnym obciążenie procesora.
12 |
13 | Istnieją narzędzia za pomocą których możemy ograniczyć ilość kompilacji zapamiętując wynikowy kod bajtowy, aby kolejne
14 | żądania jego wykonania odbywały się znacznie szybciej. Narzędzia te potrafią drastycznie przyspieszyć działanie
15 | aplikacji, a do tego są bardzo proste w konfiguracji.
16 |
17 | Najbardziej znanymi narzędziami tego typu są:
18 |
19 | * [APC](http://php.net/manual/pl/book.apc.php)
20 | * [XCache](http://xcache.lighttpd.net/)
21 | * [Zend Optimizer+](http://www.zend.com/products/server/) (część pakietu Zend Server)
22 | * [WinCache](http://www.iis.net/download/wincacheforphp) (rozszerzenie MS Windows Server)
23 |
--------------------------------------------------------------------------------
/_posts/10-03-01-Object-Caching.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Caching obiektów
3 | isChild: true
4 | ---
5 |
6 | ## Caching obiektów {#object_caching_title}
7 |
8 | Aby przyspieszyć działanie konkretnych funkcjonalności Twojej aplikacji, warto zastanowić się gdzie w kodzie następuje
9 | odwołanie do źródeł danych, których pobranie jest czasochłonne, a częstość zmian jest niska. W takich sytuacjach warto
10 | rozważyć możliwość użycia cachingu tychże danych. Caching polega na zapamiętaniu rezultatu działania określonego
11 | fragmentu kodu w taki sposób, aby później można było wielokrotnie odwołać się do niego, zamiast ponownie wykonywać
12 | czasochłonną operację. Dzięki odpowiedniemu użyciu cache'a programista może w łatwy sposób zwiększyć szybkość działania
13 | aplikacji, a także zminimalizować obciążenie serwera.
14 |
15 | Większość narzędzi, o których pisałem w poprzednim paragrafie, ma funkcję cachingu obiektów. APC, XCache, czy WinCache
16 | oferują proste API do zapamiętywania wyników działania określonego kodu w ich wewnętrznej pamięci.
17 |
18 | Najbardziej znanymi narzędziami do cache'owania danych w PHP jest APC i memcached. Oba oferują proste API i są łatwe w
19 | instalacji i użyciu. Istotną różnicą między nimi jest fakt, że APC, zgodnie ze swoją architekturą, znajduje się na tym
20 | samym serwerze, co kod, który jest uruchamiany, a memcached jest narzędziem sieciowym, które umożliwia dostęp z wielu
21 | różnych maszyn, co powoduje, że jest nieznacznie wolniejszy niż APC.
22 |
23 | Wybór jest dosyć prosty: jeżeli zależy Ci na skalowaniu aplikacji, wybierz zorientowany na to memcached. Jeżeli Twoja
24 | aplikacja będzie działać na jednym serwerze, użyj APC.
25 |
26 | Przykładowy kod wykorzystujący APC:
27 |
28 | {% highlight php %}
29 |
17 | {% endfor %}
18 | {{ backtotop|markdownify }}
19 |
--------------------------------------------------------------------------------
/pages/Design-Patterns.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: Design Patterns
4 | ---
5 |
6 | # Design Patterns
7 |
8 | There are numerous ways to structure the code and project for you web application, and you can put as much or as little
9 | thought as you like into architecting. But it is usually a good idea to follow to common patterns because it will make
10 | your code easier to manage and easier for others to understand.
11 |
12 | * [Architectural pattern on Wikipedia](https://en.wikipedia.org/wiki/Architectural_pattern)
13 | * [Software design pattern on Wikipedia](https://en.wikipedia.org/wiki/Software_design_pattern)
14 |
15 | ## Factory
16 |
17 | One of the most commonly used design patterns is the factory pattern. In this pattern, a class simply creates
18 | the object you want to use. Consider the following example of the factory pattern:
19 |
20 | {% highlight php %}
21 | vehicle_make = $make;
30 | $this->vehicle_model = $model;
31 | }
32 |
33 | public function get_make_and_model()
34 | {
35 | return $this->vehicle_make . ' ' . $this->vehicle_model;
36 | }
37 | }
38 |
39 | class AutomobileFactory
40 | {
41 | public static function create($make, $model)
42 | {
43 | return new Automobile($make, $model);
44 | }
45 | }
46 |
47 | // have the factory create the Automobile object
48 | $veyron = AutomobileFactory::create('Bugatti', 'Veyron');
49 |
50 | print_r($veyron->get_make_and_model()); // outputs "Bugatti Veyron"
51 | {% endhighlight %}
52 |
53 | This code uses a factory to create the Automobile object. There are two possible benefits to building your code this
54 | way, the first is that if you need to change, rename, or replace the Automobile class later on you can do so and you
55 | will only have to modify the code in the factory, instead of every place in your project that uses the Automobile
56 | class. The second possible benefit is that if creating the object is a complicated job you can do all of the work in
57 | the factory, instead of repeating it every time you want to create a new instance.
58 |
59 | Using the factory pattern isn't always necessary (or wise). The example code used here is so simple that a factory
60 | would simply be adding unneeded complexity. However if you are making a fairly large or complex project you may save
61 | yourself a lot of trouble down the road by using factories.
62 |
63 | * [Factory pattern on Wikipedia](https://en.wikipedia.org/wiki/Factory_pattern)
64 |
65 | ## Front Controller
66 |
67 | The front controller pattern is where you have a single entrance point for you web application (e.g. index.php) that
68 | handles all of the requests. This code is responsible for loading all of the dependencies, processing the request and
69 | sending the response to the browser. The front controller pattern can be beneficial because it encourages modular code
70 | and gives you a central place to hook in code that should be run for every request (such as input sanitization).
71 |
72 | * [Front Controller pattern on Wikipedia](https://en.wikipedia.org/wiki/Front_Controller_pattern)
73 |
74 | ## Model-View-Controller
75 |
76 | The model-view-controller (MVC) pattern and its relatives HMVC and MVVM let you break up code into logical objects that
77 | serve very specific purposes. Models serve as a data access layer where data it fetched and returned in formats usable
78 | throughout your application. Controllers handle the request, process the data returned from models and load views to
79 | send in the response. And views are display templates (markup, xml, etc) that are sent in the response to the web
80 | browser.
81 |
82 | MVC is the most common architectural pattern used in the popular [PHP frameworks](https://github.com/codeguy/php-the-right-way/wiki/Frameworks).
83 |
84 | Learn more about MVC and its relatives:
85 |
86 | * [MVC](https://en.wikipedia.org/wiki/Model%E2%80%93View%E2%80%93Controller)
87 | * [HMVC](https://en.wikipedia.org/wiki/Hierarchical_model%E2%80%93view%E2%80%93controller)
88 | * [MVVM](https://en.wikipedia.org/wiki/Model_View_ViewModel)
89 |
--------------------------------------------------------------------------------
/pages/Functional-Programming.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: Functional Programming in PHP
4 | ---
5 |
6 | # Functional Programming in PHP
7 |
8 | PHP supports first-class function, meaning that a function can be assigned to a variable. Both user defined and built-in
9 | functions can be referenced by a variable and invoked dynamically. Functions can be passed as arguments to other
10 | functions (feature called Higher-order functions) and function can return other functions.
11 |
12 | Recursion, a feature that allows a function to call itself is supported by the language, but most of the PHP code focus
13 | on iteration.
14 |
15 | New anonymous functions (with support for closures) are present since PHP 5.3 (2009).
16 |
17 | PHP 5.4 added the ability to bind closures to an object's scope and also improved support for callables such that they
18 | can be used interchangeably with anonymous functions in almost all cases.
19 |
20 | The most common usage of higher-order functions is when implementing a strategy pattern. Built-in `array_filter`
21 | function asks both for the input array (data) and a function (a strategy or a callback) used as a filter function on
22 | each array item.
23 |
24 | {% highlight php %}
25 | $min
55 | *
56 | * Returns a single filter out of a family of "greater than n" filters
57 | */
58 | function criteria_greater_than($min)
59 | {
60 | return function($item) use ($min) {
61 | return $item > $min;
62 | };
63 | }
64 |
65 | $input = array(1, 2, 3, 4, 5, 6);
66 |
67 | // Use array_filter on a input with a selected filter function
68 | $output = array_filter($input, criteria_greater_than(3));
69 |
70 | print_r($output); // items > 3
71 | {% endhighlight %}
72 |
73 | Each filter function in the family accepts only elements greater than some minimum value. Single filter returned by
74 | `criteria_greater_than` is a closure whith `$min` argument closed by the value in the scope (given as an argument when
75 | `criteria_greater_than` is called).
76 |
77 | Early binding is used by default for importing `$min` variable into the created function. For true closures with late
78 | binding one should use a reference when importing. Imagine a templating or input validation libraries, where closure is
79 | defined to capture variables in scope and access them later when the anonymous function is evaluated.
80 |
81 | * [Read about Anonymous functions][anonymous-functions]
82 | * [More details in the Closures RFC][closures-rfc]
83 | * [Read about dynamically invoking functions with `call_user_func_array`][call-user-func-array]
84 |
85 | [anonymous-functions]: http://www.php.net/manual/en/functions.anonymous.php
86 | [call-user-func-array]: http://php.net/manual/en/function.call-user-func-array.php
87 | [closures-rfc]: https://wiki.php.net/rfc/closures
88 |
--------------------------------------------------------------------------------
/pages/example.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: Przykładowa strona
4 | ---
5 |
6 | # Tytuł strony
7 |
8 | Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
9 | tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
10 | quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
11 | consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
12 | cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
13 | proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
14 |
15 | Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
16 | tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
17 | quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
18 | consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
19 | cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
20 | proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
21 |
22 | Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
23 | tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
24 | quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
25 | consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
26 | cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
27 | proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
28 |
--------------------------------------------------------------------------------
/scripts/setup.js:
--------------------------------------------------------------------------------
1 | (function ($) {
2 | // Load contributors
3 | var $contributors = $('#contributors');
4 | if ( $contributors.length ) {
5 | var fail = function () {
6 | $contributors.html('