[20:00:52] <@Annihilator> Cisza!
[20:00:56] <@Annihilator> Teraz ja mówię!
[20:01:08] <@Annihilator> Czas zacząć masowe pranie mózgu.
[20:01:14] <@Annihilator> A Waszym góru dziś będę ja.
[20:01:25] <@Annihilator> Przygotujcie się, że ja krótkie piłki, a potem pauki.
[20:01:46] <@Annihilator> Przy okazji mam dwie informacje od Góru Gynvaela, którego zmogła choroba gardła od Was.
[20:01:56] <@Annihilator> [19:42:10] GynAway: w niedziele o 18 bash w przykladach by keidii
[20:01:56] <@Annihilator> [19:42:38] GynAway: i we wtorek o 21 wstep do algorytmow poprowadzi G0blin
[20:02:10] <@Annihilator> Dobra, nie bedzie polskich znakow.
[20:02:34] <@Annihilator> Przypominam dla teMpych, ze niedziela 18 - bash, wtorek 21 - algorytmy
[20:02:41] <@Annihilator> A dzisiaj PHP
[20:02:45] <@Annihilator> Nie mylic z BHP
[20:02:58] <@Annihilator> Tamten drugi to jezyk biurokracji.
[20:03:12] <@Annihilator> Ok, tylko poukladam swoje notatki
[20:03:32] <@Annihilator> I mozemy rozpoczac powoli
[20:03:47] <@Annihilator> Wiec sluchajcie, krotka pilka: dzis bedzie wyklad o PHP
[20:04:06] <@Annihilator> Nie rozmawiac gdy ja mowie, nawet nickami.
[20:04:07] <@Annihilator> !!!
[20:04:38] <@Annihilator> PHP nalezy do takich rodzajow jezyka wysokiego poziomu, ktore zwa sie Server-Side
[20:04:50] <@Annihilator> Na czym to polega, to wyjasnie na prostym przykladzie
[20:05:07] <@Annihilator> Otoz, jak wiadomo, PHP najczesciej stosuje sie
[20:05:14] <@Annihilator> Przy budowie dynamicznych stron WWW
[20:05:25] <@Annihilator> Ale niekoniecznie dynamicznych w sensie, ze tam cos fruwa
[20:05:32] <@Annihilator> Albo jakies statki-szlaczki lataja
[20:05:41] <@Annihilator> Dynamiczne tutaj oznacza bynajmniej cos innego
[20:06:14] <@Annihilator> I istnieja dwa jezyki tworzenia stron - Client-Side (np: JavaScript) i Server-Side (PHP)
[20:06:19] <@Annihilator> Takie przyklady tylko
[20:06:25] <@Annihilator> Czym sie rozni jedno od drugiego?
[20:06:30] <@Annihilator> Odpowiedz jest prosta
[20:06:38] <@Annihilator> Client-side dzialaja na waszym komputerze
[20:06:42] <@Annihilator> I mozecie je wylaczyc
[20:06:59] <@Annihilator> Jak wylaczycie JaveScript to nie otrzymacie pytania ,,Czy jestes gupi''
[20:07:03] <@Annihilator> W postaci monitu
[20:07:20] <@Annihilator> Natomiast jezykow Server-Side nie wylaczycie bo dzialaja po stronie serwera
[20:07:31] <@Annihilator> Co wiecej - Wasza przegladarka nawet tego jezyka nie widzi
[20:07:41] <@Annihilator> Wchodzicie na formularz, przegladarka go wysyla na serwer
[20:08:04] <@Annihilator> Na serwerze parser PHP go obrabia i kaze serwerowi WWW wyslac wersje w HTMLu do Waszej przegladarki
[20:08:28] <@Annihilator> Po prostu na server-side nie macie wplywu i dobrze
[20:08:42] <@Annihilator> Dlatego skala zastosowan takich jezykow jest wieksza niz client-side
[20:08:47] <@Annihilator> Ale do rzeczy
[20:08:55] <@Annihilator> Zajmiemy sie dzisiaj najpopularniejszym z nich - PHP
[20:09:04] <@Annihilator> Zanim zaczne chrzanic o jego skladni
[20:09:11] <@Annihilator> Musze powiedziec Wam mniej wiecej co i jak
[20:09:18] <@Annihilator> Otoz strona domowa PHP to www.php.net
[20:09:56] <@Annihilator> Stamtad mozna sciagnac odpowiednie oprogramowanie, czyli zrodla PHP. Te zrodla po sciagnieciu nalezy skompilowac na swojej maszynie (Unix/Linux) lub zainstalowac (Windows)
[20:10:26] <@Annihilator> I po zainstalowaniu nalezy dokonac odpowiedniego wpisu w serwerze HTTP (najczesciej to bedzie apache), aby on kumal z czym to jest
[20:10:38] <@Annihilator> Jesli nie dokonamy wpisu to jak ktos wejdzie na nasza strone
[20:10:49] <@Annihilator> To zamiast wykonania kodu PHP otrzyma on kod zrodlowy
[20:10:57] <@Annihilator> I bedzie wiedzial jak Wam sie wlamac na strone
[20:11:19] <@Annihilator> Prawidlowo dziajalacy serwer WWW z obsluga PHP nie pozwala na przegladanie zrodel plikow php
[20:11:31] <@Annihilator> Tylko wykonuje instrukcje, ktore on ma w nich zawarte.
[20:11:56] <@Annihilator> I my takze, musimy powiedziec serwerowi WWW, jakie rozszerzenie, musza miec nasze pliki PHP
[20:12:00] <@Annihilator> A moga byc rozne
[20:12:05] <@Annihilator> Nie tylko php3, php czy phtml
[20:12:15] <@Annihilator> To rownie dobrze moze byc *.dupa
[20:12:27] <@Annihilator> Np: jan.kowalski.com/ksiega.dupa
[20:12:31] <@Annihilator> Itp.
[20:12:38] <@Annihilator> Bardziej sprytni haxorzy
[20:12:49] <@Annihilator> Daja rozszerzenie php np: html
[20:13:00] <@Annihilator> Wtedy taki slabszy haxor wchodzi na strone, a tam ksiega.html
[20:13:07] <@Annihilator> I stwierdza, ze nie moze shaxorzyć htmla
[20:13:17] <@Annihilator> I idzie dalej, aż znajdzie gdzies ksiega.php
[20:13:31] <@Annihilator> A inny haxor nie da sie tak podejsc i bedzie haxorzyl, aż coś upoluje.
[20:13:45] <@Annihilator> Tutaj juz trzeba odpowiednia konfiguracje PHP miec, aby nam szkod nie narobil.
[20:13:54] <@Annihilator> Ale nie bojta sie, takich geniuszy jest malo.
[20:14:00] <@Annihilator> Ok.
[20:14:11] <@Annihilator> Wiemy juz, ze PHP to jezyk dzialajacy po stronie serwera.
[20:14:19] <@Annihilator> Wiemy tez, ze mozna mu przypisac rozne rozszerzenie.
[20:14:29] <@Annihilator> Ale zalozmy sytuacje, ze przypisalismy mu rozszerzenie *.php
[20:14:48] <@Annihilator> Od teraz nasz serwer HTTP bedzie odwolania do plikow *.php puszczal przez parser PHP
[20:15:11] <@Annihilator> W ten o to sposob, gdy jakis pseudo-haxor napisze: http://jan.kowalski.com/ksiega.php
[20:15:33] <@Annihilator> To otrzyma od parsera PHP juz odpowiedz w postaci wykonania kodu z tegoz pliku
[20:15:52] <@Annihilator> Jak bedzie blad w pliku *.php
[20:15:55] <@Annihilator> To tez bedzie odpowiedz
[20:16:03] <@Annihilator> Ale bardzo brzydka, dlatego nie robcie bledow.
[20:16:22] <@Annihilator> Powiem jeszcze o paru podstawach
[20:16:38] <@Annihilator> Prawie zawsze w oprogramowaniu PHP, glowny plik konfiguracyjny ma nazwe: php.ini
[20:16:45] <@Annihilator> Nawet na systemach Uniksowych.
[20:16:53] <@Annihilator> Tam jest cala konfiguracja i tam sie mozna bawic.
[20:16:59] <@Annihilator> Wspomne tylko o najwazniejszych rzeczach
[20:17:31] <@Annihilator> Jest taka dyrektywa w pliku konfiguracyjnym
[20:17:39] <@Annihilator> Ktora zwie sie: error_reporting
[20:17:44] <@Annihilator> Domyslnie jest tak:
[20:17:50] <@Annihilator> error_reporting = E_ALL & ~E_NOTICE
[20:18:12] <@Annihilator> Co oznacza, ze parser bedzie informowal o warningach i errorach, ale NOTICE juz nie bedzie wyswietlal.
[20:18:26] <@Annihilator> I teraz - jesli piszecie sobie cos, zawsze miejcie ustawione to tak:
[20:18:30] <@Annihilator> error_reporting = E_ALL
[20:18:36] <@Annihilator> Zeby mowil o wszystkim co go boli
[20:18:42] <@Annihilator> Nawet o tym, ze zla pogoda dzisiaj
[20:18:51] <@Annihilator> Bo te wszystkie komunikaty NOTICE to sa tez bledy
[20:18:58] <@Annihilator> Tylko takie mniej grozne, ale dokuczliwe
[20:19:10] <@Annihilator> Moga spowodowac, ze tam pozniej cos nie zadziala jak nalezy, zmienna sie zgubi, etc
[20:19:30] <@Annihilator> Takze pamietajcie, gdy piszecie cos: error_reporting = E_ALL
[20:19:34] <@Annihilator> Natomiast
[20:19:45] <@Annihilator> Gdy macie wlasny serwer, bron Boze produkcyjny
[20:19:52] <@Annihilator> To musicie zrobic co innego
[20:20:07] <@Annihilator> Jest w php.ini inna wazna dyrektywa, domyslnie wyglada tak:
[20:20:09] <@Annihilator> display_errors = On
[20:20:23] <@Annihilator> Co oznacza, ze parser PHP bedzie informowal o bledach w skryptach PHP
[20:20:31] <@Annihilator> Czyli jak Wasz klient napisze dupiata ksiege gosci
[20:20:34] <@Annihilator> I jakis blad zrobi
[20:20:46] <@Annihilator> To on o tym bledzie poinformuje i nie wykona kodu ksiegi.
[20:20:59] <@Annihilator> Na serwerach produkcyjnych powinniscie miec: display_errors = Off
[20:21:04] <@Annihilator> Off
[20:21:08] <@Annihilator> Ale nie ten do komarów :p
[20:21:36] <@Annihilator> Po prostu nie moze na waznym serwerze parser pokazywac co jest zle, bo to niezbezpieczne. Haxory nie spia.
[20:21:49] <@Annihilator> Serwer produkcyjny to taki, na ktorym ludziom zakladacie konta
[20:21:55] <@Annihilator> Np jak ktos zaklada konta WWW za kase
[20:21:59] <@Annihilator> To serwer produkcyjny
[20:22:02] <@Annihilator> Taki przyklad
[20:22:11] <@Annihilator> Ale na amatorskich serwerach tez to polecam
[20:22:21] <@Annihilator> Bo informowanie o bledach jest niebezpieczne
[20:22:35] <@Annihilator> Ktos kto sie dobrze na tym zna (ja?) moze wiele z tego bledu wywnioskowac
[20:22:42] <@Annihilator> I shaxorowac za duzo na serwerze
[20:22:50] <@Annihilator> W skrajnych przypadkach rozwalic serwer
[20:22:55] <@Annihilator> I kasa przestanie byc
[20:22:59] <@Annihilator> Klienci odejda
[20:23:06] <@Annihilator> A wlasciciel serwera popelni samobojstwo
[20:23:10] <@Annihilator> Wiec lepiej nie ryzykowac
[20:23:37] <@Annihilator> Tak wiec konkludujac: jak tworzycie sobie skrypty na domowych komputerze, to odpowiednia konfiguracja php.ini:
[20:23:42] <@Annihilator> error_reporting = E_ALL
[20:23:46] <@Annihilator> display_errors = On
[20:24:02] <@Annihilator> Natomiast, gdy dla serwera:
[20:24:12] <@Annihilator> error_reporting = E_ALL & ~E_NOTICE
[20:24:14] <@Annihilator> display_errors = Off
[20:24:26] <@Annihilator> To mowie Wam po to, byscie mnie w przyszlosci do sadu nie podali
[20:24:35] <@Annihilator> Gdy Wam jakis gimnazjalista spieprzy ksiege gosci
[20:24:37] <@Annihilator> Albo baze danych
[20:24:43] <@Annihilator> O bezpieczenstwie trzeba wspominac
[20:24:50] <@Annihilator> A w PHP to sprawa wazna.
[20:24:54] <@Annihilator> Bo to nie przelewki.
[20:24:59] <@Annihilator> Tutaj krotka pilka i masz problem.
[20:25:04] <@Annihilator> Ok. Idzmy dalej.
[20:25:20] <@Annihilator> Przejdzmy do zagadnienia w jaki sposob wlaczac kod PHP do strony.
[20:25:32] <@Annihilator> Zalozmy, ze mamy juz poprawnie skonfigurowany serwer HTTP z obsluga PHP
[20:25:50] <@Annihilator> Karql, register_global jest domyslnie na OFF, wiec nie trzeba mysle o tym mowic.
[20:26:08] <@Annihilator> Wspomne tylko, aby nie zmieniac na ON, chyba, ze ktos planuje dzien pozniej samobojstwo przy uzyciu telefonu.
[20:26:25] <@Annihilator> Ok.
[20:26:34] <@Annihilator> Mamy serwer, czas napisac jakis kod w PHP.
[20:26:49] <@Annihilator> I tak, aby parser PHP wkroczyul do akcji to musimy go zachecic.
[20:27:03] <@Annihilator> Niestety to nie jest tesciowa, ktora na komende sie stawi, my musimy sie do niego dostosowac.
[20:27:16] <@Annihilator> Musimy wiec miec plik o rozszerzeniu *.php
[20:27:26] <@Annihilator> Zakladam oczywiscie, ze tak skonfigurowalismy serwer HTTP
[20:27:41] <@Annihilator> Ze pliki z rozszerzeniem *.php przesyla on przez parser PHP
[20:28:02] <@Annihilator> Zalozmy, ze mamy jakas prosta strone, z kodem HTML
[20:28:06] <@Annihilator> Juz taka wystawiam
[20:29:37] <@Annihilator> Ok, nasza testowa strona: http://irc7.pl/~mateusz/php/cv.html
[20:29:41] <@Annihilator> Taka dziwna nazwa na początek
[20:30:03] <@Annihilator> Zobaczmy do kodu
[20:30:10] <@Annihilator> Mamy tam najzwyklejszy kod HTML
[20:30:16] <@Annihilator> XHTML znaczy sie.
[20:30:24] <@Annihilator> Czyli jezyk tworzenia stron WWW
[20:30:36] <@Annihilator> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
[20:30:36] <@Annihilator> <html>
[20:30:36] <@Annihilator> <head>
[20:30:36] <@Annihilator> <title>Strona testowa</title>
[20:30:36] <@Annihilator> <meta http-equiv="Content-type" content="application/xhtml+xml;charset=iso-8859-2" />
[20:30:36] <@Annihilator> <link rel="stylesheet" href="styl.css" type="text/css" />
[20:30:36] <@Annihilator> </head>
[20:30:36] <@Annihilator> <body>
[20:30:36] <@Annihilator> <p>I co sie gapisz, he?</p>
[20:30:36] <@Annihilator> </body>
[20:30:36] <@Annihilator> </html>
[20:30:47] <@Annihilator> W kazdym miejscu tego kodu mozna umiejscowic PHP
[20:30:59] <@Annihilator> I teraz, sa trzy popularne sposoby umieszczania kodu php
[20:31:06] <@Annihilator> Pierwszy: <? kod ?>
[20:31:11] <@Annihilator> Drugi: <?php kod ?>
[20:31:23] <@Annihilator> Trzeci: <script language="php"></script>
[20:31:33] <@Annihilator> Ten ostatni jest lamerski i mozna z JavaScript pomylic.
[20:31:38] <@Annihilator> Wiec wystrzegajcie sie go.
[20:31:54] <@Annihilator> Pierwszy podany przezemnie tez jest lamerski i coraz rzadziej stosowany
[20:32:00] <@Annihilator> Bo moze kolidowac z XMLem
[20:32:09] <@Annihilator> Więc stosujcie tylko <?php kod ?>
[20:32:15] <@Annihilator> Bo tak powinno byc
[20:32:25] <@Annihilator> Mozna zmusic parser php, aby <? ?> odrzucal
[20:32:34] <@Annihilator> Wystarczy znowu zagladnac w php.ini
[20:32:37] <@Annihilator> I poszukać:
[20:32:57] <@Annihilator> short_open_tag = Off
[20:33:19] <@Annihilator> Jeśli jest na Off, parser PHP nie będzie parsował kodu, który jest zagnieżdzony sposobem <? ?>
[20:33:35] <@Annihilator> Piszemy więc w <?php i ?>
[20:33:42] <@Annihilator> Więc co teraz zrobimy? Co? No co?
[20:33:55] <@Annihilator> Czas na krotka przerwe, REKLAMĘ i takie tam.
[20:34:16] <@Annihilator> goGOgoGO, a mam Cie w dowodzie?
[20:34:17] <@Annihilator> ;p
[20:34:18] < Nome> Czas na reklame? YEAH!
[20:34:20] < goGOgoGO> Czym rozni sie echo od print ? :P
[20:34:21] < DoZer> hmtl jest jezykiem xhtml jest standardem jezyka przynajmniej tak mi sie wydaje ;p
[20:34:27] < Vengeance> ja moge odpowiedziec :]
[20:34:29] < fgfd> aha
[20:34:33] < Rein> annihilator: a bedzie cos o gdlibrary?
[20:34:35] < fgfd> kiedy dojdziemy do echo
[20:34:36] <@Annihilator> goGOgoGO, później sprawdzę
[20:34:40] <@Annihilator> Rein, w podstawach??
[20:34:40] <@Annihilator> ;p
[20:34:40] < Vengeance> echo wyswietla... print tez wyswietla
[20:34:43] < Vengeance> z tymze
[20:34:44] < fgfd> za godzine:P
[20:34:48] < Rein> annihilator: tak myslalem :P
[20:34:49] < Chochlik> print sprawdza jescze czy sie dobrze wyswietlilo to co trzeba bodajze
[20:34:51] < Vengeance> print dodatkowo zwraca wynik czy sie to powiodlo
[20:34:53] < Karql> pirnt jest funkcja
[20:34:53] < Nome> echo "Wlasnie czym to sie rozni?";
[20:34:56] < Vengeance> i zwraca true or false
[20:35:01] < Vengeance> echo nie zwraca nic
[20:35:08] < Vengeance> pozatym print jest o literke dluzsze w pisaniu
[20:35:10] < fgfd> vengeance
[20:35:10] < crook> http://www.faqts.com/knowledge_base/view.phtml/aid/1/fid/40 <-
[20:35:15] < fgfd> a ty tez bedziesz jakis wyklad
[20:35:15] < Vengeance> jest wolniejsze w uzywaniu
[20:35:15] <@Annihilator> Nie zagłębiałem się w te różnice, jak nie mam czasu to piszę echo, a jak mam czas to piszę print.
[20:35:17] < fgfd> robil
[20:35:17] < Vengeance> i ogolnie jest fuj :d
[20:35:19] < fgfd> moze kiedys
[20:35:27] < Vengeance> moze kiedys... ale poki co nie ;]
[20:35:28] < fgfd> w koncu masz strefe PHP
[20:35:32] < Karql> jak beda skrytpy a ktos nie ma serwa
[20:35:36] < Karql> to niech napisze do mnie na priv
[20:35:41] <@Annihilator> Przerwa potrwa 5 minut.
[20:35:45] < Karql> bo zalozylem konto z php do wykladow to sobie bedzie mogl potestowac
[20:35:50] <@Annihilator> Za ten czas schlodze klawiature.
[20:36:10] * mulander podaje gasnice Annihilator'owi
[20:36:14] < defc0n> Annihilator cieklym azotem
[20:36:14] < defc0n> ;]
[20:36:15] < Rein> karql: jak ktos sobie nawet serwa nie umie zrobic, po co uczy sie php? :D
[20:36:20] < Vengeance> pozatym przez echo
[20:36:23] < Vengeance> mozna laczyc stringi
[20:36:26] < Karql> ale moze nie ma na kompie postawionego:D
[20:36:26] < Vengeance> uzywajac przecinka ;]
[20:36:35] < Vengeance> nic to nie daje
[20:36:36] < Rein> karql: to niech sobie postawi :]
[20:36:37] < goGOgoGO> A przez print nie?
[20:36:37] < Karql> i teraz nie zdarzy to dlatego:D
[20:36:38] < Astarot> Venge juz starczy ;)
[20:36:38] < Vengeance> ale fajnie wyglada :D
[20:36:43] < Vengeance> ok :D
[20:36:46] < Rein> karql: :D
[20:36:49] < Vengeance> mozna by zrobic acly wyklad
[20:36:50] < Vengeance> na temat
[20:36:53] < Vengeance> echo / print
[20:36:55] < Vengeance> :D
[20:36:57] < Vengeance> rotfl
[20:36:59] < Rein> vengeance: :D
[20:37:07] < fgfd> vengeance
[20:37:10] < fgfd> pisales na haxite
[20:37:12] < fgfd> ze zrobisz arta
[20:37:16] < Rein> vengeance: powinni dodac printf :P
[20:37:18] < fgfd> zakladales nawet topic i co??
[20:37:35] < Vengeance> fgfd: i art jest :D ale nie opublikowany... i troche zmienil zalozenia ;]
[20:37:43] < Vengeance> dluga historia
[20:37:47] < fgfd> no daj go juz
[20:37:50] < fgfd> jest chyba o xss
[20:37:52] < fgfd> tak??
[20:37:58] < Vengeance> napisalem o XSS ale o podstawach w sumie
[20:38:01] < Vengeance> jeszcze troche trzeba dam dodac...
[20:38:04] < fgfd> dodaj go tera
[20:38:07] < fgfd> co ja bede robil
[20:38:11] < Vengeance> nie ;]
[20:38:14] < Vengeance> ale najpierw to ukaze sie w pewnym magazynie...
[20:38:17] < goGOgoGO> Dobrze, ze o XSS !
[20:38:18] < Vengeance> a dopiero potem na haxite moze
[20:38:21] < Vengeance> jak bedzie tego wart
[20:38:32] < fgfd> a moze na lewo bys dal do niego adres;)
[20:38:45] < Astarot> Annihilator: jak juz se schlodzisz klawiature napiszesz w punktach co dzisiaj jeszcze bedzie wykladane?
[20:38:50] < Astarot> :)
[20:39:05] <@Annihilator> Astarot, najpierw zglosza sie rodzice, bo widze ze paru nie uwaza na wykladzie
[20:39:11] <@Annihilator> I soie gada na innych kanalach
[20:39:13] < Rein> lol :D
[20:39:18] <@Annihilator> To jest lekcewazacy stosunek do nauczyciela
[20:39:21] < Rein> nie wolno gadac na lekcji :P
[20:39:21] <@Annihilator> I przedmiotu
[20:39:22] <@Annihilator> ;p
[20:39:42] < Astarot> my naprawde sie staramy
[20:39:52] < Astarot> nie zasnac ;P [joke]
[20:39:52] < Rein> mow za siebie :D
[20:39:56] < Dale> ale ja uwazam ;p
[20:40:18] <@Annihilator> Ok. Spokoj.
[20:40:23] <@Annihilator> To znowu ja, Wasz idol.
[20:40:35] <@Annihilator> Chcialem pozdrowic dziadka oraz zareklamowac Avon.
[20:40:40] <@Annihilator> Ok. To tyle.
[20:40:54] <@Annihilator> Przypominam, ze jestescie na wykladzie o podstawach PHP
[20:41:11] <@Annihilator> Prosze przestac guc zumy i przechodzimy dalej
[20:41:19] <@Annihilator> Mam do tego mala informacje dla studentow.
[20:41:31] <@Annihilator> Jesli ktos nie ma na czym testowac to odsylam do strony: www.krasnal.tk
[20:41:38] <@Annihilator> Tam jest tzw: krasnal serw
[20:41:45] <@Annihilator> Zawiera w sobie apache+php+mysql
[20:41:50] <@Annihilator> Latwe do zainstalowania pod windows
[20:41:54] <@Annihilator> I mozna od razu pisac
[20:42:10] <@Annihilator> Bo potrzebna jest praktyka
[20:42:16] <@Annihilator> Sluchajcie - teoria nic nie da
[20:42:25] <@Annihilator> Jak wy nie zobaczycie ze, echo dupa wyswietli 'dupa'
[20:42:29] <@Annihilator> To nie uwierzycie
[20:42:36] <@Annihilator> Ja juz 13 lat pierdziele sie z systemem edukacji
[20:42:41] <@Annihilator> I oni mi tylko teoretyzuja
[20:42:47] <@Annihilator> Wiec jak ktos nie ma serwer www+php
[20:42:51] <@Annihilator> To sciagac krasnala
[20:42:54] <@Annihilator> Czy innego skrzata
[20:42:57] <@Annihilator> Zainstalowac
[20:43:02] <@Annihilator> I brac sie do roboty
[20:43:28] <@Annihilator> Przypominam o stronie testowej: http://irc7.pl/~mateusz/php/cv.html
[20:43:39] <@Annihilator> Tam mam prosta strone z kodem XHTML czy HTML jak kto woli
[20:43:59] <@Annihilator> Taka strona nie obchodzi nic a nic parsera php
[20:44:06] <@Annihilator> Wiec czas jej zmienic rozszerzenie
[20:44:15] <@Annihilator> I tak: http://irc7.pl/~mateusz/php/cv.php
[20:44:33] <@Annihilator> Teraz parser PHP zacznie obchodzi, tyle, ze tam narazie nie ma zadnego kodu PHP i nic nowego nie zobaczycie
[20:44:54] <@Annihilator> Czas zaczac cos robic.
[20:45:00] <@Annihilator> Zaczniemy oczywiscie od Hello World
[20:45:04] <@Annihilator> Bo jakze inaczej
[20:45:19] <@Annihilator> A zaraz, ja jestem abstynent, czyli sie wyrozniam, to zaczniemy od: Czesc
[20:45:25] <@Annihilator> Hello World jest juz nudne, wiecie
[20:45:31] <@Annihilator> jeszcze ktos to pomyli z C i asm
[20:45:31] <@Annihilator> ;p
[20:45:46] <@Annihilator> <p>I co sie gapisz, he?</p>
[20:45:50] <@Annihilator> Usune ta czesc kodu
[20:45:56] <@Annihilator> i wpisze tam:
[20:45:58] <@Annihilator> <?php
[20:46:04] <@Annihilator> echo "Czesc";
[20:46:05] <@Annihilator> ?>
[20:46:33] <@Annihilator> Tak powinen wygladac kod po przerobce:
[20:46:34] <@Annihilator> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
[20:46:34] <@Annihilator> <html>
[20:46:34] <@Annihilator> <head>
[20:46:34] <@Annihilator> <title>Strona testowa</title>
[20:46:34] <@Annihilator> <meta http-equiv="Content-type" content="application/xhtml+xml;charset=iso-8859-2" />
[20:46:34] <@Annihilator> <link rel="stylesheet" href="styl.css" type="text/css" />
[20:46:34] <@Annihilator> </head>
[20:46:34] <@Annihilator> <body>
[20:46:34] <@Annihilator> <?php
[20:46:34] <@Annihilator> echo "Czesc";
[20:46:34] <@Annihilator> ?>
[20:46:34] <@Annihilator> </body>
[20:46:34] <@Annihilator> </html>
[20:46:51] <@Annihilator> PojedynczeCudzyslowia, nie ucz ojca dzieci robic, jak beda pojedyczne to beda, narazie sa podwojne
[20:46:54] <@Annihilator> :p
[20:47:06] <@Annihilator> Zaraz bede mowil kiedy pojedyncze, a kiedy podwojne.
[20:47:27] <@Annihilator> Odswiezcie sobie: http://irc7.pl/~mateusz/php/cv.php
[20:47:36] <@Annihilator> I tam zobaczycie teraz slowo Czesc
[20:48:16] <@Annihilator> Kurde, cos serwer nawala
[20:48:18] <@Annihilator> Niech to liczo
[20:48:20] <@Annihilator> Licho
[20:49:10] <@Annihilator> Macie zastepczy URL, gdyby co: http://eurocom.olkusz.pl/~mateusz/cv.php
[20:49:20] <@Annihilator> Ale jak dziala to ok
[20:49:25] <@Annihilator> Zajezdzacie serwer, studenci.
[20:49:31] <@Annihilator> Na to nawet PHP nie poradzi.
[20:49:31] <@Annihilator> ;p
[20:49:42] <@Annihilator> Ok, Dobra, do rzeczy.
[20:49:46] <@Annihilator> Mamy tekst czesc.
[20:49:52] <@Annihilator> Chcielismy, by go wyswietlilo.
[20:50:07] <@Annihilator> Jesli ktos teraz pomysli sobie: no co za idiota, nie lepiej w HTMLU taki tekst wyswietlic?
[20:50:09] <@Annihilator> To ma racje
[20:50:14] <@Annihilator> PHP nie jest od walenia w bambus
[20:50:25] <@Annihilator> Wiec taki przyklad to tylko przyklad, i ja sie od niego odcinam.
[20:50:35] <@Annihilator> Teraz slowo o zmiennych.
[20:50:46] <@Annihilator> Zmienne w jezyku PHP zaczynaja sie od znaku $
[20:50:56] <@Annihilator> Czyli: $ciocia, $wujek, $dupa_salata
[20:51:17] <@Annihilator> To sa zmienne, zmienne nie moga miec takiej skladni: $51015_zaraz_sie_zacznie
[20:51:18] <@Annihilator> ;p
[20:51:30] <@Annihilator> Cyfry won z poczatku, przynajmniej za mlodu u mnie tak bylo
[20:51:52] <@Annihilator> Zmienne to nic innego jak... zmienne
[20:51:57] <@Annihilator> Jakby to Wam wytlumaczyc
[20:52:11] <@Annihilator> Po prostu: zalozmy, ze mamy tekst: Czesc, tu dupa
[20:52:22] <@Annihilator> I mamy go czesto w dokumencie uzyc
[20:52:42] <@Annihilator> To zamiast ciagle to pisac, to tworzymy zmienna: $dupa="Czesc, tu dupa";
[20:52:54] <@Annihilator> I pozniej tylko: echo $dupa;
[20:52:57] <@Annihilator> I mamy nasz tekst.
[20:53:04] <@Annihilator> Zwracam uwage na sredniki, sa wazne
[20:53:12] <@Annihilator> Inaczej Parse Error i zegnaj hollywod
[20:53:20] <@Annihilator> Choc nie zawsze, ale o tym na innych wykladach
[20:53:34] <@Annihilator> My jestesmy przy podstawach i sredniki nas poki co obchodza
[20:53:56] <@Annihilator> Pamietajcie wiec, ze zmienne w PHP zaczynaja sie od znaku dolara
[20:54:05] <@Annihilator> Podalem przyklad jak wyswietlic tekst
[20:54:27] <@Annihilator> Ale nic nie stoi na przeszkodzie, by zrobic taki myk: $dupa = print "Czesc, tu dupa";
[20:54:39] <@Annihilator> Wtedy gdzies tam w dokumencie wystarczy tylko umiescic: $dupa
[20:54:41] <@Annihilator> I mamy tekst
[20:54:48] <@Annihilator> I teraz slowo o operatorach.
[20:54:55] <@Annihilator> Podobnie jak w c = oznacza przypisanie
[20:55:07] <@Annihilator> czyli: $ciocia="Krysia";
[20:55:19] <@Annihilator> Oznacza: zmiennej $ciocia, przypisujemy tekst: Krysia
[20:55:29] <@Annihilator> Mozna inaczej: $ciocia=$wujek
[20:55:44] <@Annihilator> Oznacza: zmiennej ciocia, przypisujemy wartosc zmiennej $wujek.
[20:55:55] <@Annihilator> Proste i logiczne
[20:56:14] <@Annihilator> Jesli bedzie == to bedzie to oznaczalo rownosc
[20:56:34] <@Annihilator> Jak napisze ktos: $ciocia==$wujek to oznacz: zmienna ciocia jest rowna zmiennej wujek
[20:56:40] <@Annihilator> Ma to zastosowanie przy porownywaniu
[20:56:45] <@Annihilator> Np:
[20:56:57] <@Annihilator> $skladnik1 = "11";
[20:57:09] <@Annihilator> $skladnik2 = "11";
[20:57:33] <@Annihilator> I: if($skladnik1==$skladnik2) { koniec_swiata } etc
[20:57:41] <@Annihilator> Ale nie o porownaniach teraz mowimy
[20:57:54] <@Annihilator> Czas zaczac zmienne stosowac w naszym wykladzie
[20:58:02] <@Annihilator> Zapewne niektorzy juz zdarzyli krasnala zainstalowac
[20:58:07] <@Annihilator> A jak nie to kij im w oko
[20:58:13] <@Annihilator> Wiec czas sie pobawic zmiennymi
[20:58:22] <@Annihilator> I tymi cudzyslowami
[20:58:44] <@Annihilator> Od teraz bedziemy cwiczyc na czystym PHP
[20:58:52] <@Annihilator> Nie bedziemy zagniezdzac w dokumencie HTML
[20:59:01] <@Annihilator> Do tego dojdziemy - gdy to bedzie potrzebne
[20:59:15] <@Annihilator> Jak stworzymy plik o rozszerzeniu costam.php
[20:59:23] <@Annihilator> To mozemy od razu pisac kod: <?php kod ?>
[20:59:31] <@Annihilator> Przypominam, ze <?php to znacznik otwierajacy
[20:59:36] <@Annihilator> A ?> to zamykajacy
[20:59:40] <@Annihilator> Nie pomylcie kolejnosci
[20:59:59] <@Annihilator> A ja już pichce dla Was przyklad
[21:00:46] <@Annihilator> http://irc7.pl/~mateusz/php/plik.php - tu macie
[21:00:57] <@Annihilator> Tym razem zawartosc tego pliku, to tylko:
[21:01:06] <@Annihilator> <?php
[21:01:06] <@Annihilator> echo "Czesc";
[21:01:06] <@Annihilator> ?>
[21:01:16] <@Annihilator> Jak wejdziecie na strone to zobaczycie slowo Czesc
[21:01:30] <@Annihilator> Ale my to juz widzielismy, wiec czas na zabawe z czyms innym
[21:03:00] <@Annihilator> Znowu zatkaliscie serwer
[21:03:10] <@Annihilator> Niech Was demony scisna, same problemy ze studentami
[21:04:19] <@Annihilator> Ok
[21:04:22] <@Annihilator> Mam inny serwer
[21:04:27] <@Annihilator> Przechodzimy dalej:
[21:04:29] <@Annihilator> Oto nowy kod:
[21:04:33] <@Annihilator> <?php
[21:04:33] <@Annihilator> $lat="pietnascie";
[21:04:34] <@Annihilator> echo "Podwojny cudzyslow: Szejker ma $lat lat";
[21:04:34] <@Annihilator> echo "<br/><br/>";
[21:04:34] <@Annihilator> echo 'Zmienna w pojedynczym: Szejker ma $lat lat';
[21:04:34] <@Annihilator> ?>
[21:04:54] <@Annihilator> Wpiszcie go i odpalcie, tutaj efekt: http://eurocom.olkusz.pl/~mateusz/plik.php
[21:05:10] <@Annihilator> Zajmiemy sie tutaj zagadnieniem tych cudzyslowi
[21:05:39] <@Annihilator> upted, to szukaj: php triad
[21:05:45] <@Annihilator> Krasnala spieprzyli, a to numer
[21:05:45] <@Annihilator> ;p
[21:05:56] <@Annihilator> Ok, wrocmy do wykladu
[21:06:05] <@Annihilator> Mamy tutaj jedna zmienna: $lat="pietnascie";
[21:06:27] <@Annihilator> W podwojny cudzyslow jak ja wsadzimy i wyswietlimy (nie musze chyba mowic, ze echo sluzy do wyswietlania)
[21:06:36] <@Annihilator> TO otrzymamy: Szejker ma pietnascie lat
[21:06:48] <@Annihilator> Czyli za zmienna, w cudzyslowiu podwojnym zostala podstawiona wartosc
[21:07:00] <@Annihilator> Inaczej jest z pojedynczym - tam mamy: Szejker ma $lat lat
[21:07:10] <@Annihilator> Co oznacza, że zmienna nie została przeparsowana
[21:07:26] <@Annihilator> Tak mniej więcej wygląda różnica pomiędzy podwójnym, a pojedynczym cudzysłowem
[21:07:33] <@Annihilator> Identycznie w przypadku polecenia print
[21:07:47] <@Annihilator> Jakie stad wnioski?
[21:07:59] <@Annihilator> Gdy nie masz zmiennych - uzywaj pojedynczych cudzyslowi
[21:08:04] <@Annihilator> A nie zadne fujj
[21:08:13] <@Annihilator> Jak ktos tam brzydko nicka zmienil, za to sie rodzice stawia
[21:08:14] <@Annihilator> ;p
[21:08:28] <@Annihilator> Ale dobra, czas nas goni, a pare przykladow trzeba zrobic
[21:08:50] <@Annihilator> Apropo tego nieszczesnego krasnala, to na priv Nekrataal mi dal taki link: http://www.wampserver.com/en/index.php
[21:12:27] <@Annihilator> Momencik
[21:12:32] <@Annihilator> Przyklad uploaduje
[21:12:33] <@Annihilator> :)
[21:13:11] <@Annihilator> Ok, mam
[21:13:19] <@Annihilator> http://eurocom.olkusz.pl/~mateusz/plik.php
[21:13:22] <@Annihilator> Tutaj efekt
[21:13:24] <@Annihilator> A tutaj kod:
[21:13:28] <@Annihilator> <?php
[21:13:29] <@Annihilator> $a="2";
[21:13:29] <@Annihilator> $b="3";
[21:13:29] <@Annihilator> $c=$a+$b;
[21:13:29] <@Annihilator> $d=$a-$b;
[21:13:29] <@Annihilator> $e="<br/>";
[21:13:29] <@Annihilator> echo "Zmienna a: $a";
[21:13:29] <@Annihilator> echo $e;
[21:13:29] <@Annihilator> echo "Zmienna b: $b";
[21:13:29] <@Annihilator> echo $e;
[21:13:29] <@Annihilator> echo "Zmienna c: $c";
[21:13:29] <@Annihilator> echo $e;
[21:13:29] <@Annihilator> echo "Zmienna d: $d";
[21:13:29] <@Annihilator> ?>
[21:13:48] <@Annihilator> Pokazalem w jaki prosty sposob, mozna operowac na zmiennych
[21:13:58] <@Annihilator> Mozna je dodawac, odejmowac, itp
[21:14:07] <@Annihilator> Przypisywac od razu wyniki itd
[21:14:26] <@Annihilator> $c=$a+$b;
[21:14:46] <@Annihilator> Tutaj widzicie proste przypisanie: przypis zmiennej c, sumę zmiennych: a i b
[21:14:58] <@Annihilator> Mozna inne dziwne sztuki robic, laczyc wiele zmiennych i przypisywac
[21:15:06] <@Annihilator> Ale to jest tylko maly przykladzik
[21:15:24] <@Annihilator> Skoro znamy juz zmienne, to moze sprobojmy porownywac
[21:16:09] <@Annihilator> Taki przykladzik:
[21:16:12] <@Annihilator> $a="2";
[21:16:12] <@Annihilator> $b="3";
[21:16:12] <@Annihilator> if ($a==$b)
[21:16:12] <@Annihilator> { echo 'Sa rowne';
[21:16:12] <@Annihilator> }
[21:16:12] <@Annihilator> else
[21:16:12] <@Annihilator> { echo 'Nie sa rowne';
[21:16:12] <@Annihilator> }
[21:16:36] <@Annihilator> Tutaj prosta petla:
[21:16:49] <@Annihilator> if ($a==$b) oznacz: jesli zmienna a, jest rowna zmiennej b, to:
[21:16:53] <@Annihilator> echo 'Sa rowne';
[21:16:59] <@Annihilator> w przeciwnym wypadku (else)
[21:17:05] <@Annihilator> echo 'Nie sa rowne';
[21:17:14] <@Annihilator> Jesli komus napisze ze sa rowne to zmiencie PHP lepiej
[21:17:16] <@Annihilator> Albo kompa
[21:17:17] <@Annihilator> ;-)
[21:17:36] <@Annihilator> Ok, to byly proste podstawy
[21:17:41] <@Annihilator> Mysle ze poki co
[21:17:51] <@Annihilator> Mozna to na tym etapie zakonczyc i rozpoczac zadawanie pytan