[20:02:11] <@damianmyst> witam.
[20:02:15] <@damianmyst> jam jest damianmyst
[20:02:23] <@damianmyst> bede prowadzil wyklad z OOP w PHP
[20:02:34] <@damianmyst> ostatni wyklad byl z teorii...
[20:02:40] <@damianmyst> dzisiaj bardziej teoretycznie
[20:02:50] <@damianmyst> zajmiemy sie parserami szablonów.
[20:03:05] <@damianmyst> Parsery szablonów sa to
[20:03:21] <@damianmyst> narzedzia, ktora pozwalaja calkowicie oddzielic kod php od kodu html
[20:03:36] <@damianmyst> przez co nasze projekty staja sie o wiele bardziej przejrzyste,
[20:03:42] <@damianmyst> latwiej sie je przebudowuje
[20:03:59] <@damianmyst> robiac projekty z szablonami nasza praca jest wydajniejsza
[20:04:06] <@damianmyst> pracujac z grafikiem nie kolidujemy sobie
[20:04:16] <@damianmyst> gdyz grafik zajmuje sie szablonem a my k0dem
[20:04:28] <@damianmyst> jednak nie ma nic za darmo...
[20:04:37] <@damianmyst> parsery szablonów żrą troche zasobów...
[20:04:42] <@damianmyst> ale jest i na to sposób :)
[20:04:46] <@damianmyst> ok
[20:05:02] <@damianmyst> na potrzeby wykladu napisalem prosty parser, ktory krok po kroku bede omawial
[20:05:18] <@damianmyst> nasz parser pozwala, na wyswietlanie szablonów, ich cacheowanie, przekazywanie zmiennych
[20:05:23] <@damianmyst> tyle wystarczy na niezle dziela
[20:05:30] <@damianmyst> pytania?
[20:05:45] <prawn> nie
[20:05:55] <@damianmyst> ok'ej
[20:05:59] <@damianmyst> to dalej
[20:06:24] <@damianmyst> podam wam teraz
[20:06:43] <@damianmyst> adres do zrodel oraz przykladu klasy do obslugi szablonow ktora w 1 godzine dla potrzeb wykladu napisalem
[20:06:48] <@damianmyst> Źródła:
[20:06:48] <@damianmyst> http://damianmyst.info/wyklad/phps.php?file=index1.php5
[20:06:48] <@damianmyst> http://damianmyst.info/wyklad/phps.php?file=class1.php5
[20:06:48] <@damianmyst> http://damianmyst.info/wyklad/phps.php?file=compiler1.php5
[20:06:48] <@damianmyst> http://damianmyst.info/wyklad/phps.php?file=tpl_testowy.tpl
[20:06:54] <@damianmyst> Działanie:
[20:06:54] <@damianmyst> http://damianmyst.info/wyklad/index1.php5
[20:07:10] <@damianmyst> zapoznajcie sie z źródlami i za ~3 minuty, zaczne omawiac kazdy z plików :)
[20:08:14] <@damianmyst> jak pewnie zauwarzyliscie ( :> ), przy kazdym wg. mnie wazniejszym kawalku kodu dalem komentarz z cyferka
[20:08:21] <@damianmyst> sa to hmm...odnosniki,
[20:08:28] <@damianmyst> bede sie do nich odnosil przy omawianiu kodu :)
[20:08:47] <crook> Po co w klasie Compiler konstruktor?
[20:08:58] <@damianmyst> bo bedzie ( chyba )
[20:09:00] <@damianmyst> drugi wyklad
[20:09:10] <@damianmyst> i zajmiemy sie o wiele wiekszymi mozliwosciami
[20:09:10] <@damianmyst> :)
[20:09:10] <crook> A.
[20:09:29] <@damianmyst> OOP jest rozszezalne...ale warto myslec przyszlosciowo
[20:10:28] <@damianmyst> jak tam czytanie? :>
[20:10:57] <prawn> duzo tego Oo
[20:11:07] <prawn> wole teorie :d
[20:11:11] <@damianmyst> zauwarzcie jak plik index1.php5 jest czysciutki
[20:11:18] <@damianmyst> prawn, bedzie dobrze ;p
[20:11:35] <@damianmyst> mozemy dowolnie rozbudowywac layot strony, a kod php i tak bedzie czysty...
[20:11:53] <@damianmyst> piszacz jeszcze w OO, nie winnismy sie pogubic w naszym projekcie
[20:12:18] <@damianmyst> dobra, nie bede ustawial +m, bedziemy prowadzic jak cos zywa dyskusje
[20:12:41] <@damianmyst> ok, zaczniemy od omiewnia pliku
[20:12:46] <@damianmyst> index1.php5
[20:12:56] <@damianmyst> jak widac... uzywamy w nim naszej klasy
[20:13:00] <@damianmyst> do obslugi szablonów
[20:13:15] <@damianmyst> 3 linie kodu moga zastapic np 500 lini htmla
[20:13:26] <@damianmyst> fajnie nie? takie rzeczy niby tylko w erze...
[20:13:35] <@damianmyst> no ale ok.
[20:13:47] <@damianmyst> w pliczku index1.php5 mamy komentarze...juz o tym mówilem
[20:13:54] <@damianmyst> na początku plik jest już jeden taki
[20:13:57] <@damianmyst> #1.
[20:14:09] <@damianmyst> omówie teraz linie kodu pod #1
[20:14:21] <@damianmyst> Instrukcja include() służy do wczytania i wykonania kodu z określonego pliku w trakcie wykonywania skryptu.
[20:14:35] <@damianmyst> kolejny, komentarz...
[20:14:38] <@damianmyst> #2.
[20:14:48] <@damianmyst> Jest to tablica w której ustawiamy konfiguracje systemu szablonów.
[20:14:54] <@damianmyst> name - to nazwa katalogu ze stylem
[20:14:59] <@damianmyst> cat - sciezka od pliku wykonywalnego do katalogu ze stylem
[20:15:02] <@damianmyst> ex - rozszezenie jakie beda mialy pliku szablonów ( moze byc html ale ja mam jakies przyzwyczajenie do tpl )
[20:15:06] <@damianmyst> cache - wartosc boolenowska... czy szablony maja byc cacheowane czy nie. Wspomnę, że cacheowanie szablonów jest zalecane gdyż,
[20:15:06] <@damianmyst> przyspiesza to o wiele proces uzywania szablonów. Bez cacheu ów szablon musi zostac jeszcze spreparowany do użytku.
[20:15:06] <@damianmyst> cache_dir - katalog, w ktorym bedzie sie tworzyl cache dla szablonów
[20:15:30] <@damianmyst> hm...wspomne odrazu na wstepie....
[20:15:44] <@damianmyst> mozna spytac po co w tak prostym systemie szablonów cacheowanie
[20:15:47] <@damianmyst> szablonów?
[20:16:03] <@damianmyst> no jak mowilem juz crook'owi bedziemy to rozszerzac
[20:16:07] <@damianmyst> wiec dojda nowe mozliwosci
[20:16:15] <@damianmyst> bloki, tagi, inkludwanie w szablonach
[20:16:21] <@damianmyst> i takie tam
[20:16:37] <@damianmyst> wszystkie te bajery zwiekszaja czas preparowania szablonu do wygenerowania
[20:17:03] <@damianmyst> jednak po co za kazdym robic to samo, jak mozna to wykonac jeden raz...i potem sie do tego odwolywac?
[20:17:20] <@damianmyst> z ratunkkiem przychodzi cacheowanie.
[20:17:32] <@damianmyst> programisci "webowi" ostatnio zalubowali sie w cache'owaniu
[20:17:41] <@damianmyst> a to zapytań do bazy danych
[20:17:46] <@damianmyst> a to szablonów
[20:17:49] <@damianmyst> a to jeszcze innych rzeczy
[20:18:03] <@damianmyst> wszystko sie jednak sprowadza do jednego... optymalizacji
[20:18:28] <@damianmyst> piszac w OOP, latwo o optymalizacje... :)
[20:20:12] <@damianmyst> #4.
[20:20:29] <@damianmyst> $template -> file('blok1', 'tpl_testowy');
[20:20:50] <@damianmyst> Metoda klasy, która przygotowuje odpowiedni plik szablonu do sparsowania.
[20:21:20] <@damianmyst> czyli
[20:21:25] <@damianmyst> pobrania zawartosci pliku
[20:21:33] <@damianmyst> tzn, pliku szablonu
[20:21:42] <@damianmyst> ewentualne pobranie danych na temat cache'u
[20:21:56] <@damianmyst> ów metoda ma 2 argumenty
[20:22:06] <@damianmyst> pierwszy to tzn handler
[20:22:24] <@damianmyst> dzieki handlerowi mozemy parsowac wiele szablonow naraz
[20:22:36] <@damianmyst> np. w pliku gora.php, index.php, dol.php
[20:22:50] <@damianmyst> dla kazdego inny szablon...ale wszystkie includowane np przez index.php
[20:24:03] <@damianmyst> drugi argumenty metody wskazuje na nazwe pliku z szablonem. Nie podajemy rozszezenia tylko sama nazwe. Rozszezenie ustawiamy w konfigruacji szablonu
[20:24:22] <@damianmyst> kolejny komentarz...kolejna metoda
[20:24:23] <@damianmyst> #5
[20:24:38] <@damianmyst> Ta metod, zamienia zmienne w szablonach na oczekiwane zmienne. Czyli np. mając w szablonie {HEHE} i w kodzie php 'HEHE' => 'test'
[20:24:38] <@damianmyst> w przegladarce wyswietli nam sie "Test" a nie {HEHE}. Jest to kluczowy element szablonów.
[20:25:06] <@damianmyst> w kodach zrodlowych ktore wam dalem widac
[20:25:19] <@damianmyst> ze {HIHI} w szablonie zamieniane jest na
[20:25:23] <@damianmyst> Wyklad z OOP w PHP by damianmyst
[20:25:24] <@damianmyst> :)
[20:25:46] <@damianmyst> kolejny komentarz... nr.6
[20:25:52] <@damianmyst> Tablica z odpowiednikami zmiennych.
[20:26:00] <@damianmyst> co to jest tablica, chyba kazdy wie... :>
[20:26:24] <@damianmyst> kolejny punkt
[20:26:27] <@damianmyst> #7
[20:26:32] <@damianmyst> "Wkleja" w/w tablice do szablonu
[20:26:32] <@damianmyst> Ma to samo zostasowanie co metoda z punktu #5 tyle, ze wiecej zmiennych za jednym zamachem przekazujemy
[20:26:58] <@damianmyst> jest to o wiele wygodniejsze...bo duzo danych za jednym razem przekazemy
[20:27:45] <@damianmyst> kolejny punkt
[20:28:05] <@damianmyst> punkt #8
[20:28:18] <@damianmyst> Najwazniejszy element. Po wywolaniu tej metody spreparowany odpowiednio szablon sie juz wyswietla.
[20:30:06] <@damianmyst> $template -> display('blok1');
[20:30:19] <@damianmyst> metoda ta
[20:30:29] <@damianmyst> wywietla juz spreparowany specjalnie szablon
[20:30:43] <@damianmyst> w/w metoda ma 1 argument
[20:30:46] <@damianmyst> jest to handler....
[20:31:00] <@damianmyst> juz o nim wspominalem przy omawianiu metody do szykowania pliku...
[20:31:09] <@damianmyst> patrz pkt.4
[20:31:39] <@damianmyst> oznacza to...ze przy wywolaniu metody display, zostanie wyswietlony szablon ktory wczytalismy wczesniej...
[20:32:06] <@damianmyst> i tylko ten... :)
[20:32:16] <@damianmyst> kolejny komentarz
[20:32:18] <@damianmyst> #9
[20:32:25] <@damianmyst> Niszczenie instancji klasy. Nie jest ona nam juz potrzebne, nigdzie jej juz nie uzywamy wiec niepotrzebnie tylko zajmuje
[20:32:25] <@damianmyst> pamiec...wywalamy.
[20:33:01] <@damianmyst> wiec plik index.php5 mamy juz pobieznei omowiony...
[20:34:15] <@damianmyst> przechodzimy do serduszka naszych szablonow
[20:34:32] <@damianmyst> czyli do klasy obslugujaca szablony
[20:34:37] <@damianmyst> otwieramy wiec plik
[20:34:41] <@damianmyst> class1.php5
[20:35:09] <@damianmyst> tak jak w poprzednium pliku...poznazlaczalem odnosniki znakiem komentarza
[20:35:10] <@damianmyst> #
[20:35:16] <@damianmyst> punkt 1.
[20:35:24] <@damianmyst> final class Template
[20:35:33] <@damianmyst> definiujemy klasę. Nazywamy ją Template. Dajemy jej typ "final" co oznacza, ze jest ona koncowa klasa i ze nie mozna juz jej
[20:35:33] <@damianmyst> dziedziczyc.
[20:35:58] <@damianmyst> mam nadzieje ze o dziedziczeniu pamietamy z wczesniejszego wykladu :>
[20:36:12] <@damianmyst> punkt 2 vel #2
[20:36:24] <@damianmyst> aha...jezeli jednak sa pytania co do pkt1 pytac ;D
[20:36:44] <@damianmyst> rozumiem ze nie ma. Dalej
[20:36:48] <@damianmyst> #2.
[20:37:07] <@damianmyst> jest to zbiór wlasciwosci klasy, ktore posluza nam w dalszym procesie zabawy z szablonami. Wszystkim nadalem typ "public", przez
[20:37:07] <@damianmyst> co sa dostepne wszedzie.
[20:37:28] <@damianmyst> zarowno w klasie jak i poza nia
[20:37:44] <@damianmyst> pkt3 aka #3
[20:37:53] <@damianmyst> konstruktor klasy
[20:38:06] <@damianmyst> Czyli metoda, która wykonuje sie przy inicjowaniu instancji klasy ( patrz plik index1.php5 pkt #3 )
[20:38:42] <@damianmyst> w argumencie metody, przekazujemy konfiguracje szablonów. male pierdolki...ale zawsze :)
[20:39:05] <@damianmyst> argument funkcji jest przekazywany referencyjnie
[20:39:24] <@damianmyst> potem nam juz zmienna $_config nie jest potrzebna...wiec ustawiamy jej tablica na pustą
[20:39:32] <@damianmyst> zawsze mniej pamieci zajmuje
[20:39:42] <@damianmyst> punkt 4.
[20:39:57] <@damianmyst> destruktor klasy. Jest to metoda, która wykonuje sie podczas niszczenia instancji. Tzn, mozna ów metode wywolac
[20:40:03] <@damianmyst> przez celowe zniszczenie instancji klasy ( patrz plik index1.php5 pkt #9 ) lub tez gdy preproces przeleci caly skrypt
[20:40:13] <@damianmyst> i natknie sie na koniec...sam automatycznie wywola destruktor klasy.
[20:40:50] <@damianmyst> pytania?
[20:41:25] <kesay> ja mam jedno, nie powinno byc: inicjalizacja, zamiast inicjacja ? ;)
[20:41:38] <@damianmyst> kesay, hmm
[20:41:50] <@damianmyst> ze strony polonistycznej wlasciwie ma to samo znaczenie
[20:42:03] <@damianmyst> inicjujesz cos...
[20:42:05] <@damianmyst> jakis proces
[20:42:06] <kesay> nie do konca, ale to temat na inny wyklad ;)
[20:42:13] <@damianmyst> hehe... ;)
[20:42:27] <kesay> dobra, kontynuuj
[20:42:32] <@damianmyst> ok'ej
[20:42:44] <@damianmyst> #5
[20:42:56] <@damianmyst> metoda która już wcześniej omawialem. Dokladnie plik index1.php5 pkt #4. Chcialem zwrócić tu uwagę, ze nadalem jej typ
[20:43:07] <@damianmyst> "public", przez to metoda jest dostępna w klasie, poza nia, i gdyby nasza klasa nie byla finalna rowniez jako metod
[20:43:17] <@damianmyst> dziedziczona.
[20:43:44] <@damianmyst> punkt #6
[20:43:49] <@damianmyst> funkcja is_array();
[20:43:54] <@damianmyst> W php nie mamy takie kontrol nad tym jak np w c++. "Przechodzenie" między typami jest bardzo wygodne... aczkolwiek
[20:44:04] <@damianmyst> by skontrolowac dany typ musimy uzyc funkcji.
[20:44:10] <@damianmyst> Czyli, jezeli $handle_array jest tablica, funkcja zwrócić boolenowski true, w innym wypadku zwróci false.
[20:44:22] <@damianmyst> W php mamy jeszcze funkcje, która sprawdza czy zmienna jest:
[20:44:27] <@damianmyst> boolenowską wartością - is_bool;
[20:44:27] <@damianmyst> liczba zmiennoprzecinkową - is_float;
[20:44:27] <@damianmyst> liczba calkowitą - is_int;
[20:44:27] <@damianmyst> obiektem - is_object;
[20:44:27] <@damianmyst> i jeszcze pare, które warto poznac ale na, ktore nie warto tracic czasu podczas wykladu ;p
[20:45:01] <@damianmyst> jasne? :>
[20:45:25] <@damianmyst> #7
[20:45:37] <@damianmyst> Metoda file_check. Jest ona narzędziem metody "file". Używamy jej by sprawdzić czy plik szablonu istnieje w cache'u
[20:45:50] <@damianmyst> jesli nie to pobiera zawartośc pliku szablonu itp. Jej typ okreslony zostal na private, czyli dostepna jest tylko
[20:45:57] <@damianmyst> dla klasy. No bo pocóz nam coś takiego poza klasa?
[20:46:24] <@damianmyst> :)
[20:46:32] <@damianmyst> #8
[20:46:50] <@damianmyst> funkcja file_get_contents();
[20:46:57] <@damianmyst> bardzo przydatna funkcja, która wrzuca nam zawartość podanego w argumencie pliku w zmienna.
[20:47:17] <@damianmyst> funkcja ta jest również tlumiona przez operator "@", gdyz gdy zadany plik w argumencie nie istnieje, funkcja
[20:47:25] <@damianmyst> generuje blad... nieczytelny dla zwyklego uzytkownika...my wolimy czytelny blad :)
[20:47:34] <@damianmyst> Operatora "@" mozemy uzywac w wielu przypadkach. Mozna go uzywac do funkcji, niektórych operatorów oraz zmiennych
[20:48:13] <@damianmyst> #9
[20:48:24] <@damianmyst> Nasz "ludzki" bląd. Korzystam tu z funkcji sprintf, która jest printf'owym odpowiednikiem z C++. Parsuje ona nam odpowiednio
[20:48:34] <@damianmyst> string.
[20:48:39] <@damianmyst> Kolejna funkcja ( nie wiem czy wlasciwie mozna nazwac to funkcja...jednak umownie przyjmijmy taka nazwe ), jest exit. Ów
[20:48:48] <@damianmyst> funkcja, zakańcza dzialanie przetwarzania skrytpu. Poprostu zabija i wyswietla podany przez nas komunikat.
[20:49:15] <crook> Czemu niby nie jest funkcja?
[20:49:28] <@damianmyst> crook, duzo jest na ten temat dyskusji
[20:49:33] <@damianmyst> podobnie jak z echo
[20:49:41] <@damianmyst> manual i dokumentacja mowia ze nia sa funkcjami
[20:50:02] <crook> "The exit() function terminates execution of the script. It prints status just before exiting."
[20:50:11] <@damianmyst> exit
[20:50:11] <@damianmyst> (PHP 3, PHP 4 )
[20:50:11] <@damianmyst> exit -- Output a message and terminate the current script
[20:50:11] <@damianmyst> Description
[20:50:11] <@damianmyst> void exit ( [string status])
[20:50:11] <@damianmyst> void exit ( int status)
[20:50:11] <@damianmyst> Notatka: This is not a real function, but a language construct.
[20:50:52] <@damianmyst> hyhy :)
[20:51:00] <crook> Zastanowie sie nad tym.
[20:51:11] <@damianmyst> to jest temat do duzej dyskusji
[20:51:17] <@damianmyst> ale nie czas na to... ;)
[20:51:28] <kesay> to dla komporomisu powiedzmy, ze istnieje exit, jako funkcja i jako instrukcja ;)
[20:51:36] <kesay> jedzmy dalej
[20:51:39] <@damianmyst> okej ;)
[20:51:59] <@damianmyst> no więc
[20:52:14] <@damianmyst> #10
[20:52:25] <@damianmyst> W tym wypadku, nie potrzebujemy instancji klasy Compile bo:
[20:52:32] <@damianmyst> a) zadne obiekty nei sa w niej uzywane.
[20:52:38] <@damianmyst> b) tylko jednej metody z tej klasy nam potrzeb
[20:52:48] <@damianmyst> Więc szkoda preprocesora na meczenie sie z instancja klasy...odwolamy sie bezposredni do metody
[20:53:45] <@damianmyst> serducho omowilismy
[20:53:56] <@damianmyst> bardzo malo tej klasy a juz na tak duzo pozwala...
[20:54:06] <@damianmyst> zaledwie 100 lini kodu
[20:54:22] <@damianmyst> a ile korzysci...
[20:54:37] <@damianmyst> teraz
[20:54:46] <@damianmyst> przejdziemy do serca serducha ;D
[20:55:01] <@damianmyst> czyli klasa, ktora
[20:55:12] <@damianmyst> przygotuje nam odpowiednio szablon do wyswietlenia
[20:55:23] <@damianmyst> otwieramy zatem plik
[20:55:26] <@damianmyst> compier1.php5
[20:55:46] <@damianmyst> #1.
[20:56:00] <@damianmyst> definiujemy klasę Compiler, która nam posluży do spreparowania odpowiedniego kodu do wyświetlenia.
[20:56:10] <@damianmyst> Nie potrzebujemy zadnego typu dla tej klasy
[20:56:19] <@damianmyst> #2.
[20:56:23] <@damianmyst> konstruktor klasy. Nieuzywany, jest bo jest ;D
[20:56:34] <@damianmyst> jak crook pytal ;)
[20:56:35] <phoenix__> (przyszlosciowo):P
[20:56:40] <@damianmyst> wlasnie ;p
[20:56:55] <@damianmyst> punkt kolejny
[20:56:58] <@damianmyst> #3
[20:57:04] <crook> O, bo zobaczylem tam statyczne odwolanie jedno.
[20:57:07] <crook> Tzn. w tej klasie.
[20:57:13] <@damianmyst> self?
[20:57:15] <crook> I w przyszlosci co z Nim bedzie?
[20:57:16] <crook> Tak.
[20:57:29] <@damianmyst> zobaczysz ;)
[20:57:35] <crook> No, OK.
[20:57:59] <@damianmyst> #3
[20:58:00] <@damianmyst> metoda o typie "private". Sluzy do zapisu cache'u do pliku.
[20:58:15] <@damianmyst> #4
[20:58:26] <@damianmyst> funkcja file_exists();
[20:58:30] <@damianmyst> sprawdza czy podany katalog czy plik w argumencie funkcji istnieje.
[20:58:44] <@damianmyst> #5
[20:58:49] <@damianmyst> funkcja explode
[21:05:38] <@damianmyst> Rozbija string, wg. wzorca na tablice
[20:59:34] <@damianmyst> #6
[20:59:39] <@damianmyst> funkcja, która tworzy katalogi
[20:59:49] <@damianmyst> jak widac php to 95% funkcje
[20:59:56] <@damianmyst> ;f
[21:00:04] <@damianmyst> #7
[21:00:06] <phoenix__> nie prawda bo 89
[21:00:17] <@damianmyst> statystyki klamia!
[21:00:18] <@damianmyst> ;p
[21:00:26] <phoenix__> :]
[21:00:28] <@damianmyst> #7
[21:00:29] <@damianmyst> 3 poniższe linie sluza juz do samego zapisu pliku.
[21:01:14] <@damianmyst> #8
[21:01:27] <@damianmyst> publiczna funkcja. sluzy nam do preparowania kodu szablonu do wyswietlenia.
[21:01:45] <@damianmyst> #9
[21:01:49] <@damianmyst> Przypisujemy referencyjnie do zmiennej wartośc obiektu.
[21:02:11] <@damianmyst> #10
[21:02:16] <@damianmyst> Wyrażeniem regularnym "wyciągamy" wszystkie "zmienne" w szablonie. Zmienne sa zawsze w klamrach "{" i "}"
[21:02:32] <@damianmyst> tu zaznacze, ze warto przeczytac logi z wykladu Karql'a :)
[21:02:57] <@damianmyst> nasza
[21:03:01] <@damianmyst> nasze*
[21:03:12] <@damianmyst> wyrazenie regularne za pomoca funkcji preg_match_all
[21:03:18] <@damianmyst> stworzy nam tablice...
[21:03:31] <@damianmyst> ta tablica bedzie miala tyle elementów ile zmiennych w szablonie
[21:03:35] <@damianmyst> czyli w naszym przypadku 2
[21:03:36] <@damianmyst> bo
[21:03:45] <@damianmyst> mamy
[21:03:47] <@damianmyst> {HIHI}
[21:03:48] <@damianmyst> oraz
[21:03:50] <@damianmyst> {TEST}
[21:04:06] <@damianmyst> #11
[21:04:14] <@damianmyst> Wykonujemy pętle tyle razy ile jest Zmiennych w szablonie i zastępujemy ją odpowiednim obiektem.
[21:04:31] <@damianmyst> tu warto sie przyjzec...
[21:04:42] <@damianmyst> moglem wsadzic bezposrednio wartosc zmiennej
[21:04:49] <@damianmyst> ale to by sie mijalo z zalozeniem cacheowania...
[21:05:01] <@damianmyst> wiec zakladaj
[21:05:10] <@damianmyst> ze plik szablonu wyglada tak:
[21:05:17] <@damianmyst> http://damianmyst.info/wyklad/phps.php?file=tpl_testowy.tpl
[21:05:33] <@damianmyst> plik cache'u bedzie wygladac tak:
[21:05:35] <phoenix__> po co tam destruktoor?
[21:05:38] <@damianmyst> [21:05:38] <@damianmyst> echo "Temat Wykladu :: <b>" . $this -> vars[ "HIHI" ] . "</b><br />";
[21:05:38] <@damianmyst> echo "Co robimy :: <b><u>" . $this -> vars[ "TEST" ] . "</u></b>";
[21:05:38] <@damianmyst> ?>
[21:05:54] <@damianmyst> nie mowielm?
[21:06:09] <phoenix__> powiedz jeszcze raz ;]
[21:06:28] <@damianmyst> destruktor klasy. Jest to metoda, która wykonuje sie podczas niszczenia instancji. Tzn, mozna ów metode wywolac
[21:06:28] <@damianmyst> przez celowe zniszczenie instancji klasy ( patrz plik index1.php5 pkt #9 ) lub tez gdy preproces przeleci caly skrypt
[21:06:28] <@damianmyst> i natknie sie na koniec...sam automatycznie wywola destruktor klasy.
[21:06:37] <phoenix__> wiem co to
[21:06:46] <phoenix__> ale po co ?
[21:06:47] <@damianmyst> a destruktor jest po to zeby zobrazowac
[21:06:53] <phoenix__> dla szpmanu?:P
[21:06:54] <@damianmyst> jak sie uzywa destruktora
[21:07:01] <@damianmyst> nam sluzy jako stopka ]:->
[21:07:09] <@damianmyst> mhm ;)
[21:07:12] <@damianmyst> dokladnie ;p
[21:07:41] <@damianmyst> #12
[21:07:46] <@damianmyst> Funkcja eval();
[21:07:54] <@damianmyst> Wykonuje kod php zawarty w argumencie
[21:08:01] <@damianmyst> np
[21:08:01] <@damianmyst> eval("echo 'Damian';");
[21:08:06] <@damianmyst> wyswietli nam w przegladarce napis "Damian"
[21:08:16] <@damianmyst> fajna rzecz ta funkcja, trust me :)
[21:08:28] <@damianmyst> #13
[21:08:44] <@damianmyst> Odwolujemy sie to statycznej metody klasy...
[21:08:55] <@damianmyst> ale nawet gdyby nie byla ona statyczna
[21:09:03] <@damianmyst> to i tak nie mogl sie do nie odwal np tak:
[21:09:13] <@damianmyst> $this -> write_cache($echo, $handle);
[21:09:18] <@damianmyst> poniewaz klasa nie ma instancji kalsy
[21:09:30] <@damianmyst> wiec... skazani jestesmy na:
[21:09:36] <@damianmyst> compiler::write_cache($echo, $handle);
[21:09:37] <@damianmyst> :)
[21:09:52] <@damianmyst> tadam
[21:09:52] <@damianmyst> !
[21:09:54] <@damianmyst> koniec :)
[21:10:04] <@damianmyst> to by bylo na tyle.
[21:10:29] <@damianmyst> cala klase omuwilismy. Źrodla mozna dowolnie uzywac
[21:10:31] <@damianmyst> modyfikowac
[21:10:34] <@damianmyst> rozpowszechniac
[21:10:37] <@damianmyst> sprzedawac
[21:10:40] <@damianmyst> handlowac nimi
[21:10:41] <@damianmyst> itd
[21:10:44] <@damianmyst> ;p
[21:10:53] <@damianmyst> omowilismy*
[21:10:54] <@damianmyst> sory :)
[21:11:08] <@damianmyst> praca do domciu
[21:11:35] <@damianmyst> sprobowac
[21:11:49] <@damianmyst> zainicjowac instancje klasy compiler w klasie Template
[21:12:02] <@damianmyst> zebysmy mogli sie odwolywac przez $this w klasie compiler
[21:12:05] <@damianmyst> dziękuje :)