[20:02] <@mulander>: Dobra zaczynamy ;) witam wszystkich, na drugim wykladzie Perl'a
[20:02] <@mulander>: Dzisiaj w planie mamy dokonczenie tematu zmiennych skalarnych z poprzedniego wykladu, oraz przerobienie list i tablic ( o ile nam sie to uda na jednym wykladzie ;P )
[20:03] <@mulander>: zmiany nicka nagradzam kopniakiem, nagminne zmienianie banem na czas wykladu.
[20:04] <@mulander>: Wracamy do zmiennych skalarnych, na ostatnim wykladzie zabraklo nam czasu wspomniec o automatycznej konwersji pomiedzy liczbami a ciagami.
[20:05] <@mulander>: Proces ten interpreter perla wykonuje automatycznie kiedy kontekst wymaga liczby lub ciagu a podana zostala wartosc przeciwna do oczekiwanej ;)
[20:05] <@mulander>: najlepiej widac to przy operatorach logicznych liczb i ciagow jednak o tym juz mowilismy na ostatnim wykladzie
[20:06] <@mulander>: jednak warto lepiej sie przyjzec temu jakie efekty daje taka automatyczna konwersja by interpreter nie zaskoczyl nas swoimi wytworami ;) ( chociaz robi to w dobrej wierze :> )
[20:06] <@mulander>: zaczniemy od najprosztszej konwersji dla interpretera czyli liczby na ciag.
[20:06] <@mulander>: zalozmy sobie iz w naszym skrypcie znajduje sie zmienna $a = 5;
[20:07] <@mulander>: jezeli teraz uzyjemy jej przy operatorach logicznych ciagu ( eq lt gt ne le ge ) zostanie ona skonwertowana na ciag "5"
[20:08] <@mulander>: taki sam efekt uzyskamy jezeli poddamy dana zmienna interpolacji czyli dodamy taka linijke do kodu $ciag = "jakis ciag $a";
[20:08] <@mulander>: Jednak nawet przy tej najprosztszej konwersji musimy uwazac na 2 rzeczy.
[20:09] <@mulander>: perl kazda liczbe ktora zaczyna sie od 0 traktuje jako liczbe octalna a kazda liczbe zaczynajaca sie od 0x jako heksadecymalna
[20:10] <@mulander>: takze jezeli przypadkiem dodacie 0 na poczatku swojej liczby to nie dziwcie sie ze przy konwersji zostanie ona zamieniona na swoj odpowiednik decymalny.
[20:10] <@mulander>: troche bardziej zamotana jest konwersja ciagu na liczbe.
[20:11] <@mulander>: sprawa jest w miare prosta kiedy nasza liczba znajduje sie na poczatku ciagu np. $ciag = "123to jest liczba"
[20:11] <@mulander>: interpreter zamieni ten ciag na liczbe 123
[20:11] <@mulander>: jezeli konwersji zostanie poddany ciag ktory nie zawiera zadnej liczby np. $ciag = "mulander" otrzymamy liczbowa reprezentacje w postaci 0
[20:12] <@mulander>: perl jednak nie zawsze radzi sobie w tak fajny sposob.
[20:12] <@mulander>: jezeli nasza liczba znajduje sie w srodku, na koncu itd ciagu znakow
[20:12] <@mulander>: rowniez otrzymamy wartosc 0 np. ciag $ciag = "Mul6ander" zwroci wartosc 0
[20:13] <@mulander>: jednak moga wystapic problemy z konwersja nawet wtedy kiedy nasza liczba znajduje sie na poczatku ciagu
[20:13] <@mulander>: o ile poprzedza ja 0 albo 0x
[20:14] <@mulander>: poniewaz perl nie radzi sobie z konwertowaniem liczby octalnej i hexadecymalnej z ciagu na liczbe
[20:14] <@mulander>: takze ciag znakow "0xffblablabla" zostanie zamieniony na 0
[20:14] <@mulander>: tak samo ciag "0777 blech" zwroci wartosc 0
[20:14] <@mulander>: ciag znakow zawierajacy sama liczbe powinien byc przekonwertowany bez wiekszych problemow
[20:15] <@mulander>: jednak liczby oktalne i hexadecymalne rowniez nie zostana w nim przekonwertowane.
[20:15] <@mulander>: teraz drobny przyklad do konwersji liczb
[20:15] <@mulander>: http://wyklady.vexillium.org/convert.pl
[20:16] <@mulander>: w jednym komencie walnalem gafe i napisalem otrzymalismy zwykla liczbe zamiast oktalnej ( ma byc hexadecymalnej :P )
[20:16] <@mulander>: jakies pytania ?
[20:16] rfl: o co chodzi?
[20:16] r00uter: tak
[20:16] r00uter: mam pytanie
[20:16] r00uter: ale przeklne
[20:16] <@mulander>: rfl : o automatyczna konwersje liczb na ciagi i spowrotem
[20:16] r00uter: ki chuj nie moge odpalac skryptow perla na linuxie mandrake 9.2
[20:16] r00uter: ?
[20:17] <@mulander>: masz zainstalowany interpreter ?
[20:17] r00uter: tak
[20:17] <@mulander>: plik ma prawa wykonywalne ?
[20:17] r00uter: uuuu
[20:17] <@mulander>: probowales wywolywac przez interpreter ?
[20:17] <@mulander>: jakie bledy zwraca ?
[20:17] r00uter: chmokd...
[20:17] <@mulander>: chmod +x skrypt.pl
[20:17] <@mulander>: ./skrypt.pl
[20:17] r00uter: no
[20:17] r00uter: i to jest moj klopot
[20:17] r00uter: ;]
[20:17] r00uter: jzu oki
[20:17] r00uter: wim
[20:17] abanon: mulander: ja cie podziwiam normalnie :D
[20:18] r00uter: lizus
[20:18] r00uter: :P
[20:18] <@mulander>: jeszcze jakies pytania odnosnie tego tematu ?
[20:18] r00uter: ile uczyles sie perla ?
[20:18] <@mulander>: 3/4 miesiac sie ucze ;)
[20:18] r00uter: ja mam male zastrzezenie
[20:18] <@mulander>: slucham
[20:18] Pepi: Perl 6 poradzi sobie z ta automatyczna konwersja?
[20:18] r00uter: ja jestem tu 1 raz i doszedlem (samodzielnie) do zmienych asoncjacyjnych
[20:19] r00uter: wiec nie wiele kumam
[20:19] Pepi: czy tez bedzie wzracal np dla pep9i zero?
[20:19] arux: zaprosil bym tu RCL'a to moglibyscie podyskutowac na temat programowania
[20:19] <@mulander>: r00uter mysmy jeszcze do hashy nie doszli
[20:19] <@mulander>: btw tablic asocjacyjnych nie zmiennych.
[20:19] r00uter: a co maja hashe do zmiennych asoncjacyjnych
[20:19] r00uter: to sa zmienne z oparametrami
[20:20] r00uter: przecie
[20:20] <@mulander>: hash = tablica asocjacyjna.
[20:20] r00uter: uuuu
[20:20] r00uter: to sie skompromisowalem
[20:20] r00uter: ;]
[20:20] <@mulander>: :)
[20:20] rfl: chyba skompromitowales?
[20:21] r00uter: rfl: tak w skrocie
[20:21] r00uter: ;]
[20:21] > mulander idzie po fajeczke i zaraz continue.
[20:21] r00uter: a co oznacza parametr +x
[20:21] r00uter: przy chodzie
[20:21] r00uter: *chmodzie
[20:21] arux: r00uter dzieki za zaproszenie tu ale jak wiesz to nie dlamnie- baner bedzie jutro tylko te wymiary znajde
[20:21] arux: peace
[20:21] <@mulander>: nadaje prawa wykonywalne dla pliku
[20:21] r00uter: przeciez dalem ci wymiary
[20:21] <@mulander>: mozemy kontynuowac ?
[20:22] r00uter: chwila
[20:22] abanon: mulander: czekaj zapalmy spokojnie
[20:22] r00uter: momencik
[20:22] abanon: ;]
[20:22] arux: spoko gdzies mam histroie to znajde
[20:22] <@mulander>: sprawy nie zwiazane z kursem zalatwiajcie poza kanalem.
[20:22] r00uter: no
[20:22] <@mulander>: potem ludziom zle sie loga czyta.
[20:22] r00uter: ok
[20:22] r00uter: sorka
[20:22] arux: milo bylo poslychac czegos o czym niemam pojecia
[20:22] <@mulander>: thx
[20:22] arux: kiedy indziej
[20:22] r00uter: ale loga mozna modyfikowac ;]
[20:22] r00uter: oka ja gotowy
[20:23] <@mulander>: lecimy dalej, konwesje mamy za soba mysle ze tu nic wiecej nie trzeba dodawac. Poprostu starajcie sie rzadko z niej korzystac ;)
[20:23] <@mulander>: zadawaj
[20:23] r00uter: oki
[20:23] r00uter: co oznacza
[20:23] r00uter: my $string1 = "mulander";
[20:23] r00uter: my
[20:23] r00uter: przed zmienna
[20:23] r00uter: ?
[20:23] r00uter: juz mis ie pozapominialo
[20:23] <@mulander>: my deklaruje zakres nazw dla zmiennych.
[20:23] r00uter: :-/
[20:23] r00uter: a
[20:24] r00uter: oki
[20:24] <@mulander>: czyli jest to zmienna lokalna dla danego bloku kodu
[20:24] <@mulander>: w tym wypadku main::
[20:24] r00uter: oka zaczynaj
[20:24] <@mulander>: skoro konwersja za nami wrocimy jeszcze na sekunde do operatorow.
[20:25] <@mulander>: programisci Perla sa leniwi wiec skorzystali z wielu skrotow jakie oferuje jezyk C ;)
[20:25] <@mulander>: miedzy innymi ze skroconych wersji operatorow.
[20:25] <@mulander>: i tak zamiast pisac $a = $a + 5; by dodac do wartosci $a liczby 5
[20:26] <@mulander>: wystarczy tak jak w jezyku C napisac $a += 5;
[20:26] <@mulander>: taki skrot dziala praktycznie dla wszystkich oepratorow
[20:27] <@mulander>: mozna ja uzywac w stosunku do +=,-=,*=,**=,/=,%=,.= i tak dalej.
[20:27] <@mulander>: krotkie objasnienie do .=
[20:27] <@mulander>: . to konkantenacja stringow ( czyli laczenie ciagow bylo na ostatnim wykladzie )
[20:27] <@mulander>: dzieki temu skrotowi zamiast pisac $a = $a . "cos dalej"
[20:27] <@mulander>: r00uter pop dotyczy tablic nie zmiennych skalarnych
[20:28] <@mulander>: i ma zupelnie inne dzialanie niz operatory ktore wymienilem.
[20:28] <@mulander>: do tego dojdziemy moze dzisiaj ;)
[20:28] <@mulander>: wracajac do tematu
[20:28] <@mulander>: dzieki temu skrotowi zamiast pisac $a = $a . "cos dalej"
[20:28] <@mulander>: mozemy napisac $a .= "cos dalej"
[20:28] <@mulander>: przyklad uzycia skrotow znajdziecie tutaj
[20:29] <@mulander>: http://wyklady.vexillium.org/short.pl
[20:29] <@mulander>: pytania ?
[20:29] KamiI: chyba nie :)
[20:29] abanon: ;]
[20:29] <@mulander>: zapomnialem wspomniec
[20:29] <@mulander>: mozemy zrobic cos takiego $a = $b = $c = $d = 5
[20:30] Annihilator: w srode wracam pozno!!!!!!!
[20:30] <@mulander>: teraz $a $b $c $d wszystkie maja wartosc 5.
[20:30] Annihilator: o cholera, nie to okn
[20:30] Annihilator: sorry wam
[20:30] Annihilator: ;-]
[20:30] Annihilator: o
[20:30] <@mulander>: spox jest -m :P
[20:30] abanon: ;]
[20:30] [1]r00uter: kurde
[20:30] [1]r00uter: [20:33] *** Disconnected
[20:31] <@mulander>: brak pytan /
[20:31] <@mulander>: ?
[20:31] dreston: brak:)
[20:31] <@mulander>: lecimy dalej ?
[20:31] KamiI: tak
[20:32] <@mulander>: Programisci Perla sa bardziej leniwi niz sie wam wydaje :P wiec skorzystali z jeszcze jednego skrotu perla.
[20:32] <@mulander>: stwierdzili ze nie lubia pisac $a +=1; wiec pozyczyli od C operatory post i pre inkrementacji/dekrementacji
[20:32] <@mulander>: i dzieki temu zamiast pisac $a += 1; moga napisac ++$a;
[20:33] <@mulander>: mamy do dyspozycji 2 operatory inkrementacji i 2 dekrementacji
[20:34] <@mulander>: operatory dekrementacji to --$zmienna; $zmienna--;
[20:34] <@mulander>: inkrementacji ++$zmienna; $zmienna++;
[20:34] <@mulander>: czym sie roznia poszczegolne zapisy ?
[20:34] <@mulander>: otoz pre dekrementacja/inkrementacja najpierw podnosi wartosc przechowywana przez zmienna a dopiero potem zwraca nowa wartosc do tego co jest po lewej
[20:35] <@mulander>: np. $a = 5; print ++$a; wydrukuje 6
[20:35] <@mulander>: operator $zmienna++ najpierw zwroci aktualna wartosc dopiero potem ja podniesie
[20:35] <@mulander>: czyli $a = 5; print $a++; wydrukuje 5
[20:35] <@mulander>: to samo sie tyczy pre i post dekrementacji
[20:35] <@mulander>: przyklad dzialania: http://wyklady.vexillium.org/inc.pl
[20:36] <@mulander>: przyjzyjcie sie przykladowi
[20:36] <@mulander>: ja skocze na 5 minut do sklepu po fajki i odpowiem na ewentualne pytania :P
[20:36] KamiI: nie pal tyle :P
[20:36] <@mulander>: przypomnijcie mi tez ze mam wam jedna rzecz odnosnie post inkremetnacji powiedziec :P
[20:36] defc0n: yo
[20:36] [2]r00uter: l0l
[20:36] KamiI: czesc defc0n
[20:36] defc0n: wyklad jest czy nie?
[20:36] NaurAFK: jest
[20:36] NaurAFK: ale przerwa na papierosa
[20:37] defc0n: yhym
[20:37] defc0n: ;]
[20:37] defc0n: duzo mnie minelo?
[20:37] Nauredhel: duzo
[20:37] [2]r00uter: a mnie kurwa caly czas rozlaczalo
[20:37] defc0n: :/
[20:37] r00uter: i jak polaczyl;o
[20:37] r00uter: to przerwa
[20:37] r00uter: :D
[20:37] abanon: to i ja se zapale ;p
[20:37] Nauredhel: ;]
[20:37] defc0n: i tak perl mnie nie interesuje
[20:37] defc0n: wiec
[20:37] defc0n: tylko z ciekawosci
[20:37] defc0n: poslucha,
[20:37] r00uter: to po co tu siedzisz
[20:38] r00uter: ;[
[20:38] defc0n: r00uter zebys sie pytal
[20:38] r00uter: :-/
[20:39] abanon: elemelka ktos chce
[20:39] abanon: LMa sie znaczy
[20:39] abanon: lajta ;p
[20:39] r00uter: mnie
[20:39] r00uter: mam viceroy'e lajty :p
[20:39] abanon: masz
[20:39] r00uter: za 4.35
[20:39] abanon: ostatnio davidofy palilem
[20:39] r00uter: oo
[20:39] abanon: i malborro 100;s
[20:39] r00uter: ja raz sobie kupilem
[20:39] abanon: 100's*
[20:39] r00uter: nie 2 razy
[20:40] r00uter: czerwo i blue
[20:40] r00uter: ;]
[20:40] r00uter: ale czerwo jak zapalilem to pol i bylem najarany
[20:40] r00uter: a teraz to ....
[20:40] r00uter: :-(
[20:40] r00uter: smutna historia
[20:40] r00uter: ale za to jaka zyciowa !
[20:40] r00uter: ;]
[20:40] abanon: sety czerwone sa chujowe
[20:41] abanon: za duze i mocne
[20:41] r00uter: tylko ze ja lajtem juz sie nie napale
[20:41] abanon: a davidofy sa bez smaku dla mnie
[20:41] <@mulander>: jestem
[20:41] abanon: wole Lm
[20:41] abanon: 2 malborro
[20:41] r00uter: mulander nie przeszkadzaj
[20:41] abanon: mulander: to zaczynaj ;p
[20:41] r00uter: :P
[20:41] abanon: ;]
[20:41] r00uter: malboro = przereklamowane
[20:41] abanon: no...
[20:41] r00uter: i to ostro
[20:41] r00uter: a davidofy
[20:41] abanon: tez takie bez smaku
[20:41] <@mulander>: jakies pytania odnosnie inkrementacji i dekrementacji ?
[20:41] r00uter: mieszanka no. 7
[20:41] abanon: w lmach cos sie czuje
[20:42] r00uter: oka ciiii
[20:42] abanon: ok
[20:42] r00uter: niech gada
[20:42] r00uter: szybciej skonczyu
[20:42] r00uter: :P
[20:42] <@mulander>: pytania odnosnie inkrementacji i dekrementacji ?
[20:42] r00uter: nie
[20:42] <@mulander>: to lecimy dalej
[20:43] <@mulander>: jak juz jestesmy przy zmiennych skalarnych i czesto wspominamy o ciagach powiedzmy sobie troche o dwoch bardzo fajnych operatorach chop i chomp
[20:43] <@mulander>: ktore wlasnie maja za zadanie pracowac na ciagach znakow.
[20:43] <@mulander>: na pierwszy ogien pojdzie chop.
[20:43] <@mulander>: chop bierze ciag znakow jaki mu damy i doslownie odrabuje od niego ostatni znak.
[20:44] <@mulander>: nastepnie ten ostatni znak zwraca do tego co jest po jego lewej stronie ;)
[20:44] <@mulander>: czyli jezeli mamy zmienna $a = "chop"; i wykonamy $b = chop $a; to w zmiennej $b znajdziemy 'p' a $a bedzie przechowywac teraz "cho"
[20:45] <@mulander>: chop usuwa rowniez znaki nowej lini, np. $input = "tekst wpisany przez uzytkownika\n"; chop $input; da nam teraz $input eq "tekst wpisany przez uzytkownika"
[20:45] <@mulander>: czyli chop usunie znak nowej lini.
[20:46] <@mulander>: niema jednak zadnych przeciwskazan by za pomoca chop usunac po kolei wszystkie znaki z ciagu.
[20:46] <@mulander>: r00uter sekundka dwa slowa podam przyklad i beda pytania.
[20:46] <@mulander>: dawniej uzywany chop do pozbywania sie znaku nowej lini z linijki pobranej z pliku lub tekstu pobranego ze STDIN ( przewaznie klawiatury ) teraz sie juz tego praktycznie nie stosuje chomp sie sprawdza lepiej ale o tym za chwile.
[20:47] <@mulander>: przyklad do chop
[20:47] <@mulander>: http://wyklady.vexillium.org/chop.pl
[20:47] <@mulander>: pytania ?
[20:47] pytanie: wiec
[20:47] r00uter: do czego przydaje sie funkcja chop
[20:47] r00uter: :[
[20:47] Pepi: czy te wszystkie linki beda dostepne po wykladzie?
[20:47] r00uter: przeciez
[20:48] r00uter: jak ktos beedzie chcial
[20:48] <@mulander>: Pepi mysle ze tak.
[20:48] r00uter: odjac jakas ;iterke
[20:48] r00uter: to
[20:48] r00uter: print .........
[20:48] <@mulander>: jak nie wtym miejscu to bedzie zaznaczone na stronie wykladow gdzie.
[20:48] Pepi: spoko no to elegancko
[20:48] <@mulander>: r00uter do wszystkiego mozna znalezc zastosowanie.
[20:48] r00uter: no ale to jest niemal nieprzydatne
[20:48] r00uter: chyba ze dla zabawy
[20:48] r00uter: :-/
[20:48] <@mulander>: nie przydatne do odcinania znaku nowej lini z input.
[20:49] r00uter: oka ja lece na chwile zjesc
[20:49] <@mulander>: aha jeszcze wroce na sekunde do autoinkrementacji
[20:49] <@mulander>: nie przypomnieiliscie ze mialem wam cos powiedziec :P
[20:49] r00uter: ;]
[20:50] r00uter: bo zupa byla za slona
[20:50] <@mulander>: jak zrobicie $a++; w void context czyli kiedy nic nie czeka na wartosc zwracana przed inkrementacja
[20:50] <@mulander>: wtedy interpreter automagicznie i po cichu podczas kompilacji zamieni wasze $a++ na ++$a ;)
[20:50] r00uter: ;]
[20:50] <@mulander>: taka przyjemna optymalizacja kodu, poniewaz dziala to szybciej a i tak nic nie czeka na zwracana wartosc.
[20:51] Pepi: ja mu dam po cichu :P
[20:51] Adas0212: :P
[20:51] <@mulander>: perl jest leniwy
[20:51] <@mulander>: poco ma zwracac wartosc jezeli nic jej nie sprawdza/pobiera ? :P
[20:51] r00uter: l0l
[20:51] r00uter: fakt
[20:51] Pepi: no w sumie masz racje :D
[20:51] r00uter: a robic to nima komu
[20:52] <@mulander>: moge przejsc do chomp ?
[20:52] r00uter: jak mi zupa wystygnie
[20:52] r00uter: ;]
[20:52] Pepi: tak
[20:52] r00uter: dawaj
[20:52] <@mulander>: chomp dziala bardzo podobnie do chop, rowniez odrabuja znak z ciagu.
[20:52] <@mulander>: jednak jest pewna istotna roznica.
[20:53] <@mulander>: chomp odrabuje znak nowej lini z konca ciagu wtedy i tylko wtedy kiedy taki znak istnieje.
[20:53] <@mulander>: a wartosc jaka zwraca to ilosc w ten sposob odrabanych znakow nowej linii ;)
[20:54] <@mulander>: czyli jezeli zrobimy $a = "tekst\n"; chomp $a or die "no new line"; to $a bedzie zawieralo "tekst" i komunikat bledu nie zostanie zwrocony
[20:55] <@mulander>: jezeli jednak zrobimy $a = "tekst"; chomp $a or die "no new line"; to dostaniemy komunikat "no new line" a $a dalej bedzie zawieralo "tekst"
[20:55] <@mulander>: mozecie to sprawdzic takim jedno linijkowcem

[20:55] <@mulander>: perl -e 'chomp ($a = "tekst") or die "no newline;" [20:55] <@mulander>: perl -e 'chomp ($a = "tekst\n") or die "no newline;"

[20:56] <@mulander>: w pierwszym zwroci blad w drugim nie.
[20:56] <@mulander>: podaje tez pelny przyklad
[20:56] <@mulander>: http://wyklady.vexillium.org/chomp.pl
[20:56] <@mulander>: pytania ?
[20:56] r00uter: czysty
[20:56] Pepi: brak wszystko jasne
[20:57] defc0n: niom
[20:57] <@mulander>: Tym samym uwazam temat zmiennych skalarnych za zakonczony
[20:57] <@mulander>: nastepny obszerniejszy temat to beda listy i tablice o ktorych za jakies 10/20 minut moze szybciej
[20:58] <@mulander>: a w miedzy czasie powiemy sobie bardzo krotko
[20:58] <@mulander>: o pobieraniu i drukowaniu danych od uzytkownika
[20:58] <@mulander>: jakies pytania ?
[20:58] rfl: o co chodzi?
[20:58] glos: moge prosic o przerwe 2 minutowa
[20:58] glos: ?
[20:58] <@mulander>: czy ktos jeszcze chce przerwe ?
[20:58] r00uter: zlituj sie
[20:58] <@mulander>: rfl w czym oco chodzi ?
[20:58] <@mulander>: rfl sprecyzuj pytanie prosze.
[20:58] r00uter: musze kupe
[20:59] r00uter: :P
[20:59] <@mulander>: hehe lec poczekamy ;)
[20:59] r00uter: dzieki
[20:59] KamiI: lol ;D
[20:59] Nauredhel: ale speed bedzie kupa
[20:59] defc0n: :D:D
[21:00] Nome: narq all!
[21:00] <@mulander>: narazie.
[21:00] KamiI: nara
[21:00] SlashBeast: lol no nie moge :p
[21:00] SlashBeast: kupe :p
[21:00] KamiI: ;)
[21:00] <@mulander>: hehe :)
[21:00] defc0n: az zasmierdzialo
[21:00] defc0n: i SB przywialo
[21:00] defc0n: :D
[21:00] rfl: lol
[21:00] SlashBeast: bywa
[21:01] SlashBeast: ja tu tylko sesje zasadze
[21:01] SlashBeast: porobie za sztuczny tlok
[21:01] SlashBeast: :D
[21:01] <@mulander>: :)
[21:01] defc0n: hehe
[21:01] SlashBeast: Moge poprowadzic wyklad o Wyzszosci metalu nad hiphopem :p
[21:01] SlashBeast: co Wy na to :D ?
[21:01] <@mulander>: jestem za :D
[21:01] r00uter: print "Juz skonczylem";
[21:01] r00uter: :D
[21:02] <@mulander>: lecimy dalej ?
[21:02] r00uter: panowie
[21:02] r00uter: Punk
[21:02] r00uter: ;]
[21:02] r00uter: oka lecimy
[21:02] r00uter: :D
[21:02] defc0n: :D
[21:02] SlashBeast: ne schocmy z tematu
[21:02] <@mulander>: jak juz mowilem przerobimy pobieranie danych i wypisywanie ich na ekran
[21:02] <@mulander>: w perlu mamy dwa czesto stosowane sposoby na pobranie danych z klawiatury od uzytkownika.
[21:03] <@mulander>: pierwszy to uzycie ( STDIN to filehandle ktory standardowo jest ustawiony na klawiature )
[21:03] <@mulander>: oraz konstrukcje <> ( ktorej raczej nie polecam do pobierania danych bo jezeli ktos wrzuci nam nazwe pliku jako argument przy uruchomieniu programu to bedziemy czytac z pliku zamiast z klawiatury wiecej o <> i jego wariacjach na wykladzie jemu poswieconemu )
[21:04] <@mulander>: skoro mamy omowic sprawe w skrocie to zajmiemy sie teraz .
[21:04] <@mulander>: aby pobrac dane z klawiatury do jakiejs zmiennej wystarczy napisac $zmienna = ;
[21:05] <@mulander>: zostanie wczytana caly ciag znakow wprowadzony przez uzytkownika az do momentu pojawienia sie znaku nowej lini ( czyli wcisniecia entera przez usera )
[21:05] <@mulander>: jednak nalezy tutaj uwazac poniewaz znak nowej lini rowniez bedzie zawarty we wczytanym ciagu
[21:05] <@mulander>: takze jezeli napiszemy sobie teraz uproszczona wersje hello
[21:05] <@mulander>: #!/usr/bin/perl
[21:05] <@mulander>: use warnings;
[21:05] <@mulander>: use strict;
[21:05] <@mulander>: print "Jak masz na imie?";
[21:06] <@mulander>: my $imie = ;
[21:06] <@mulander>: print "Witaj $imie, milo ciebie poznac.\n";
[21:06] <@mulander>: to po odpaleniu tego programu mozemy sie zdziwic widzac taki output:
[21:06] <@mulander>: Jak masz na imie? Mulander
[21:06] <@mulander>: Witaj Mulander
[21:06] <@mulander>: , milo ciebie poznac
[21:07] <@mulander>: ta jeszcze kropka na koncu ;)
[21:07] <@mulander>: w kazdym razie jezeli chcemy uniknac takiego problemu
[21:07] <@mulander>: wystarczy ze dodamy pod linijke my $imie = ;
[21:07] <@mulander>: nastepujaca linijke: chomp $imie;
[21:08] <@mulander>: teraz znak nowej lini zostanie usuniety.
[21:08] <@mulander>: jednak jak juz mowilem programiscie perla sa baaaardzo leniwi :P
[21:08] <@mulander>: wiec i jest sposob na skrocenie tego zapisu :P
[21:08] <@mulander>: zamiast pisac
[21:08] <@mulander>: my $tekst = ;
[21:08] <@mulander>: chomp $tekst;
[21:08] <@mulander>: baaaardzo czesto pisze sie:
[21:08] <@mulander>: chomp (my $tekst = );
[21:08] <@mulander>: i dziala to w ten sam sposob ;)
[21:08] <@mulander>: pytania ?
[21:08] rfl: o co chodzi?
[21:09] <@mulander>: o pobieranie tekstu wpisanego z klawiatury.
[21:09] r00uter: oka
[21:09] rfl: aa...ok
[21:09] r00uter: ale moment
[21:09] kiero: mulander: troche sie spoznilem i nie wiem co robi funkcja chomp
[21:09] r00uter: jak to jest skrot
[21:09] r00uter: skoro wychodzi na jedno a
[21:09] rfl: usuwa spacje ze zmiennej
[21:09] r00uter: e nasz skrot ma wiecej znakow
[21:09] r00uter: :P
[21:09] <@mulander>: kiero: chomp usuwa znak nowej linii z konca ciagu znakow wtedy i tylko wtedy jezeli ten znak nowej lini istnieje.
[21:09] rfl: aaa zle powiedzialem
[21:09] r00uter: gdzie logika
[21:09] r00uter: ?
[21:10] <@mulander>: gdzie skrot ? zajmuje jedna linijke, tylko raz wywolujemy zmienna nie musimy dwa razy pisac $tekst ;)
[21:10] r00uter: yhy
[21:10] r00uter: czyli przy uzyciu funkcji chomp (my $tekst = ); mizemy stworzyc prosty karqlator ?
[21:10] <@mulander>: jeszcze jakies pytania co do ?
[21:10] r00uter: :-)
[21:11] <@mulander>: zalezy co rozumiesz poprzez prosty kalkulator :P
[21:11] r00uter: ;]
[21:11] <@mulander>: mozna zrobic kalkulator z parsowaniem skladni jako program w perlu zajmujacy 3 krotkie linijki :P
[21:11] <@mulander>: ale ten sposob nie polecam bez poprawnego sprawdzania input :P
[21:11] <@mulander>: wystarczy uzyc:
[21:12] <@mulander>: chomp (my $wyrazenie = );
[21:12] kiero: aa jeszcze jedno
[21:12] <@mulander>: eval { "print $wyrazenie;" } :P
[21:12] kiero: co to jest to my przed kazda zmienna?
[21:12] r00uter: kiero chwila kolejka....
[21:12] r00uter: juz bylo to pytanie
[21:12] <@mulander>: kiero my sie pojawia tylko raz w momencie kiedy zmienna sie pojawia pierwszy raz.
[21:12] <@mulander>: i deklaruje zmienna jako lokalna
[21:12] <@mulander>: w wiekszosci naszych przypadkow jako lokalna dla zakresu nazw main::
[21:13] <@mulander>: aha przy okazji uzywanie my jest szybsze niz nie deklarowanie zmiennej jako my ;)
[21:13] kiero: mulander: ale trzeba napisac 'my' za kazdym razem jak tworze inna zmienna tak?
[21:13] <@mulander>: zmienne zadeklarowane dzialjaa szybciej.
[21:13] <@mulander>: kiero tak.
[21:13] <@mulander>: ale tylko 1 raz jak sie pojawia.
[21:13] <@mulander>: jezeli mielibysmy jzu zmienna $tekst
[21:13] <@mulander>: to mozemy napisac
[21:13] <@mulander>: chomp ($tekst = );
[21:14] kiero: kapiszi ;]
[21:14] r00uter: a
[21:14] Karql: kto ma cos d Karqlatora
[21:14] Karql: ?
[21:14] Karql: :D
[21:14] r00uter: zapomnial bym
[21:14] r00uter: ;]
[21:14] r00uter: mulander
[21:14] <@mulander>: tak ?
[21:14] r00uter: ty masz winde
[21:14] r00uter: ?
[21:14] r00uter: ;]
[21:14] <@mulander>: w tym momencie tak ;)
[21:14] r00uter: glpie pytanie
[21:14] <@mulander>: w debianku kernelik padl :>
[21:14] r00uter: ale istotne
[21:14] r00uter: yhy]
[21:15] r00uter: a jest mozliwosc pisania w perlu na windzie
[21:15] r00uter: bo ja robowalem
[21:15] <@mulander>: tak.
[21:15] r00uter: ale zaden interpreter nie latal
[21:15] <@mulander>: a myslisz ze co teraz robie ? :)
[21:15] r00uter: jaki masz interpretere
[21:15] r00uter: ?
[21:15] kiero: ActivePerl pewnie
[21:15] <@mulander>: pozatym to co napiszesz na windowsie bedzie w 90% dzialac na linuksie i vice versa.
[21:15] <@mulander>: ActivePerl
[21:15] r00uter: ja tez mialem
[21:15] r00uter: i nie lataly mi skrypty
[21:16] <@mulander>: poprawnie sie zainstalowal ?
[21:16] r00uter: no chyba tak
[21:16] <@mulander>: btw odpalales skrypty przez interpreter ?
[21:16] Karql: r00uter: na pierwszej lekcji miales
[21:16] <@mulander>: sprawdzales jak sie zainstalowal w cmd.exe ?
[21:16] r00uter: przynajmniej zamenial pliki txt na pl
[21:16] <@mulander>: wpisujac perl -V ?
[21:16] kiero: r00uter: wlasnie jak odpalales skrypty?
[21:16] r00uter: mulander nie
[21:17] r00uter: kiero skrypty wogle sie nie odpalaly
[21:17] <@mulander>: zainstaluj active perla
[21:17] r00uter: ani przez interpreter
[21:17] <@mulander>: wlacz cmd.exe
[21:17] <@mulander>: wpisz: perl -V
[21:17] <@mulander>: jak wyskoczy cos innego niz blad
[21:17] <@mulander>: to wpisz perl -e "print 'dziala?';"
[21:17] r00uter: nazwa 'perl' nie jest..........
[21:18] <@mulander>: jaka wersja windowsa ?
[21:18] r00uter: xp
[21:18] r00uter: domowy
[21:18] Karql: to wpisz bez perl
[21:18] <@mulander>: zaraz ci dam linka
[21:18] r00uter: zaraz sobie znajde
[21:18] r00uter: ;]
[21:18] Karql: tez dzialalo mi pod konsola w szkole jak instalowalem
[21:19] <@mulander>: http://downloads.activestate.com/ActivePerl/Windows/5.8/ActivePerl-5.8.7.813-MSWin32-x86-148120.msi
[21:19] r00uter: ActivePerl 5.8.0 build 804
[21:19] r00uter: mam cos takiego
[21:19] <@mulander>: dla tych wszystkich co nie maja.
[21:19] Pepi: a ja perla mam w shellu :D
[21:19] r00uter: dzieki
[21:19] r00uter: cfaniakk
[21:19] r00uter: ja tez mam shella
[21:19] <@mulander>: moge kontynuowac ?
[21:19] r00uter: ale nie powiem gdzie
[21:19] Pepi: :PP
[21:19] r00uter: bo mnie wysmiejecie
[21:19] r00uter: :P
[21:19] r00uter: oka
[21:19] Pepi: tak
[21:19] r00uter: dawaj
[21:20] <@mulander>: dobra po dlugiej przerwie ;)
[21:20] <@mulander>: przechodzimy do drukowania na ekranie, uprzedzam ze tez w bardzo uproszczonej formie bo poswiecimy sobie pewnie z 1/2 wyklady pozniej na funkcje print/printf/write ;)
[21:21] <@mulander>: powiedzmy sobie troche o print.
[21:21] <@mulander>: print to operator perla ( nie funkcja ;P )
[21:21] <@mulander>: i przyjmuje liste argumentow ( o tym jak dojdziemy dzisiaj do list ;P )
[21:22] <@mulander>: zwracana wartosc pozwala stwierdzic czy drukowanie sie powiodlo tego sie praktycznie nie sprawdza ;)
[21:22] <@mulander>: bo rzadko kiedy nie udaje sie drukowac na ekranie ;P
[21:22] <@mulander>: powiedzmy sobie o jeszcze jednej rzeczy, mozemy uzywac nawiasow lub ich nie uzywac ;) jak w wiekszosci wbudowanych funkcji/operatorow perla ( mozemy tez tak zrobic by nasze subrutyny tez nawiasow nie wymagaly ;) ale to sie rzadko stosuje )
[21:22] <@mulander>: wiec uzycie
[21:23] <@mulander>: print ("wydrukuj jakis tekst\n");
[21:23] <@mulander>: oraz
[21:23] <@mulander>: print "wydrukuj jakis tekst\n";
[21:23] <@mulander>: oba sa poprawne i oba zadzialaja dobrze.
[21:23] <@mulander>: to ktorego sposobu bedziecie uzywac zalezy tylko od was i od tego co jest dla was wygodniejsze
[21:24] <@mulander>: tak ?
[21:24] r00uter: a co jesli nie doda sie na koncu \n
[21:24] r00uter: ?
[21:24] <@mulander>: nie zostanie wydrukowany znak nowej lini.
[21:24] r00uter: to wszystko
[21:24] r00uter: kontunluj
[21:24] KamiI: skoro ludzie piszacy w perlu sa tak leniwi to po co pisac w nawiasach? :D
[21:25] <@mulander>: mozemy uzywac dowolnych cudzyslowi w print np.:
[21:25] <@mulander>: print "tekst";
[21:25] <@mulander>: print 'tekst';
[21:25] <@mulander>: print qq/tekst/;
[21:25] <@mulander>: print qw/tekst/;
[21:25] <@mulander>: print<[21:25] <@mulander>: tekst
[21:25] <@mulander>: EOF
[21:25] <@mulander>: i tak dalej.
[21:25] <@mulander>: tyle jezeli chodzi o samego printa
[21:26] <@mulander>: printf podarujemy sobie teraz poniewaz nie jest to glowny temat dzisiaj, dla zainteresowanych dziala praktycznie identicznie jak printf z C.
[21:26] <@mulander>: pytania ?
[21:26] button: jedno
[21:26] Karql: mulander
[21:26] button: jaka jest różnica między " i '
[21:26] Karql: nie wiem czemu to mi nigdy nie dziala
[21:26] Karql: print<[21:26] Karql: tekst
[21:26] <@mulander>: "" podlega interpolacji, '' nie.
[21:26] r00uter: wszystko rozumiem do momentu print<[21:26] Karql: EOF
[21:26] <@mulander>: Karql kilka uwag co do <[21:27] <@mulander>: jak zamykasz here-document bo tak to sie nazywa.
[21:27] Karql: can;t find string terminator "EOF"
[21:27] <@mulander>: to znacznik EOF na koncu
[21:27] <@mulander>: musi byc pierwszym znakiem w lini
[21:27] <@mulander>: czyli nie moze go poprzedzac spacja
[21:27] <@mulander>: oraz nic wiecej nie moze znajdowac sie w tej samej lini po znaczniku EOF
[21:28] Karql: to tak mam
[21:28] Karql: #!/usr/bin/perl
[21:28] Karql: use warnings;
[21:28] Karql: use strict;
[21:28] Karql: print<[21:28] Karql: tekst
[21:28] Karql: EOF
[21:28] Karql: taki kod mam
[21:28] Karql: i w zmiennej mi dziala z eofem a w pirnt nie i nei wiem dlaczego
[21:28] r00uter: a juz rozumiem
[21:29] <@mulander>: u mnie dziala.
[21:29] <@mulander>: zaraz wrzuce ci example na serwer w8
[21:29] Karql: to moze przez edytor
[21:29] Karql: ?
[21:29] KamiI: u mnie tez dziala
[21:29] Karql: bo kopiowalem gotowe przyklady z stron i tez byl blad:D
[21:29] Karql: i sie wlasnie dziwilem
[21:29] <@mulander>: sciagniesz sobie z serwera zaraz umieszcze.
[21:29] <@mulander>: btw jaka werje perla masz ?
[21:30] Karql: tego najnowszego activ
[21:30] <@mulander>: http://wyklady.vexillium.org/karql.pl
[21:30] Karql: ale to bedzie przez edytor pewnie bo na shella wrzucalem i to samo
[21:30] <@mulander>: to zapis strone jako karql.pl
[21:30] Karql: no jak skopiowalem to co mi dales to tez ten blad:D
[21:31] <@mulander>: a jak zapisales ?
[21:31] <@mulander>: zapisz strone jako karql.pl
[21:31] Karql: no to dziala
[21:32] <@mulander>: i powinno dzialac, moze twoj edytor dodaje jakies bzdury po znaczniku EOF
[21:32] <@mulander>: np. spacje albo inna pierdole
[21:32] Karql: dziwne no ale kij pewnie tak sie dzieje
[21:32] Karql: bo tak jak mowie dziwilem sie czemu mi nie dziala to googlowalem za jakimis przykladmi i kopiowalem i lipa:D
[21:32] <@mulander>: po i przed EOF nie moze byc nawet spacji
[21:32] Karql: hehe
[21:32] Karql: ale dziwne bo jak zmienna definiowalem to dzialalo z eof
[21:33] Karql: dobra jedziemy dalej:D
[21:33] r00uter: moment
[21:33] r00uter: instaluje perla
[21:33] <@mulander>: r00uter
[21:33] <@mulander>: ?
[21:33] <@mulander>: a...
[21:33] dreston: heh
[21:33] r00uter: tzn interpreter
[21:33] r00uter: juz koncowka
[21:33] <@mulander>: dobrze napisales: perl to interpreter Perl to jezyk :P
[21:34] r00uter: pojebalo mis ie
[21:34] r00uter: zacielo mi sie
[21:34] r00uter: :P
[21:34] <@mulander>: btw skoro i tak czekamy to jezeli ktos ma negatywne uwagi lub sugestie co do sposobu prowadzenia wykladu niech wali teraz.
[21:34] r00uter: lub niech zamilczy na wieki
[21:34] r00uter: :D
[21:34] Szejker: ja mam jedno zastrzezenie
[21:34] KamiI: moim zdaniem wszystko jest ok :)
[21:34] Szejker: te wyklady powinny byc na zywo ;p
[21:35] <@mulander>: hehe :)
[21:35] defc0n: no to nie sa?
[21:35] defc0n: :D
[21:35] <@mulander>: kup mi kamerke :>
[21:35] Szejker: nie w tym sensie ;p
[21:35] <@mulander>: i kazdemu kto tu siedzi
[21:35] Szejker: no to by byl niezly pomysl
[21:35] <@mulander>: zrobimy video wyklad :P
[21:35] Szejker: zeby wlasnie via kamerke
[21:35] Szejker: chociaz niektorych moglaby przerazic uroda wykladowcy ;pppppp
[21:35] Pepi: wylac sie, wysrac sie , najejsc sie, napic sie przed wykladem a nie robic przerwy to samo tyczy sie zakupow ale nie mam pretesji do prowadzacego
[21:35] button: a o czym zaraz bedzie i wogle o czym jeszcze dzi¶ bedzie ten wykład ?
[21:35] <@mulander>: listy oraz tablice.
[21:35] r00uter: teraz
[21:36] <@mulander>: czyli glowny temat.
[21:36] r00uter: cmd --- perl -v
[21:36] r00uter: dziala
[21:36] <@mulander>: dzisiejszego wykladu :)
[21:36] <@mulander>: mozemy kontynuowac czy jeszcze jakies pytania ?
[21:36] r00uter: tak
[21:36] r00uter: cd interpretera
[21:36] Pepi: kontynuacja
[21:37] r00uter: oka juz nie ma
[21:37] r00uter: ;]
[21:37] <@mulander>: Skoro mamy za soba zmienne skalarne, pobieranie danych i drukowanie ( w duzym skrocie ale mamy :P ) to przechodzimy do list i tablic.
[21:37] <@mulander>: zmienne skalarne to podstawowy typ zmiennych w perlu, ze zmiennych skalarnych zbudowane sa inne typy danych jakimi bedziemy operowac.
[21:37] <@mulander>: ale najpierw powiemy sobie troche o listach.
[21:38] <@mulander>: lista to nic innego jak uporzadkowane dane skalarne.
[21:38] <@mulander>: wczesniej powiedzialem ze print jako argument pobiera liste.
[21:38] <@mulander>: teraz kazdy to sobie moze latwo sprwadzic.
[21:39] <@mulander>: wpisujac perl -e "print "a",'b',"\n",2+2,'222',2*2,"\n";
[21:39] <@mulander>: jak widzicie podalismy do funkcji print liste skladajaca sie z 7 elementow.
[21:39] <@mulander>: gdzie ? :)
[21:39] blad: chwila
[21:39] <@mulander>: a fakt ;)
[21:40] <@mulander>: to mialbyc jedno linijkowiec
[21:40] <@mulander>: juz poprawiam
[21:40] <@mulander>: wpisujac perl -e "print qq/a/,'b',qq/\n/,2+2,'222',2*2,qq/\n/;"
[21:40] <@mulander>: sprobojcie teraz
[21:41] Karql: dziala
[21:41] <@mulander>: kazdemu dziala ?
[21:41] KamiI: tak :)
[21:41] defc0n: dziala
[21:41] blad: a jaki mialo dac efekt
[21:41] blad: bo cos wyszlo
[21:41] <@mulander>: wydrukowac tekst na ekranie.
[21:41] blad: a wczesniej no comma allowed ofter filehandle at -e line 1
[21:41] Karql: ab
[21:41] Karql: 42224
[21:41] <@mulander>: a b
[21:41] blad: ale jaki
[21:41] blad: a
[21:41] blad: tak
[21:41] Karql: taki mial byc efekt
[21:41] blad: dziala
[21:41] <@mulander>: 42224
[21:42] <@mulander>: teraz objasniam co sie dzieje.
[21:42] <@mulander>: podalismy liste argumentow zamiast jednego ciagu znakow
[21:42] <@mulander>: oczywiscie mogli bysmy te nawiasy polaczyc za pomoca .
[21:42] <@mulander>: ale podawanie listy jest bardzo wygodne
[21:42] <@mulander>: a dla tych ktorzy lubia takie rzeczy ( np. ja lubie :P ) podam ciekawostke
[21:43] <@mulander>: print "$_\n"; dziala okolo 1.5% wolniej od print $_ . "\n"; i okolo 21% wolniej od print $_,"\n"; :)
[21:43] <@mulander>: ale tutaj uzylem printa by tylko udowodnic iz nie klamalem wczesniej mowiac iz przyjmuje liste :)
[21:43] <@mulander>: teraz przejdzmy do ciekawszych zastosowan list
[21:44] <@mulander>: ale najpierw co zauwazylismy, elementy listy sa oddzielone przecinkami.
[21:44] <@mulander>: w takim razie mozemy to w bardzo fajny sposob uzywac.
[21:44] <@mulander>: np. zalozmy ze chcemy zadeklarowac 3 zmienne i kazdej przypisac kolejno wartosci 1 2 i 3
[21:44] <@mulander>: mozemy napisac to tak:
[21:44] <@mulander>: my $a = 1;
[21:44] <@mulander>: my $b = 2;
[21:44] <@mulander>: my $c = 3;
[21:44] <@mulander>: ale mozemy tez skorzystac z list i zrobic to w jednej linijce :D
[21:45] <@mulander>: ( ale ci programisci perla sa leniwi co ? :P )
[21:45] <@mulander>: my ($a,$b,$c) = (1,2,3);
[21:45] <@mulander>: pytanka czy narazie jasne ?
[21:45] Karql: nie
[21:45] r00uter: hmm
[21:45] <@mulander>: po lewej mamy liste
[21:45] Karql: hehe ty i ta twoja optymalizacja:D
[21:45] <@mulander>: wymusilismy ja przez nawiasy
[21:45] Karql: masz bzika na punkcie tych procentow i milisekund:D
[21:45] <@mulander>: po prawej tez mamy liste
[21:45] <@mulander>: wiadomo kazdy element odpowaida temu z drugiej strony
[21:46] <@mulander>: Karql i cpu uzywanego przez skrypt :P
[21:46] Karql: no
[21:46] r00uter: palic
[21:46] r00uter: mi sie chce
[21:46] r00uter: :-(
[21:46] r00uter: i nie mam gdzie ...
[21:46] <@mulander>: jakies pytania czy lecimy dalej ?
[21:46] r00uter: o kotrej sie konczy ?
[21:47] <@mulander>: zalezy ile wytrzymacie ;P
[21:47] r00uter: a
[21:47] r00uter: spokko
[21:47] Karql: mulander: cos nam wolno idzie prawie 2h a dopiero 700 lini:D
[21:47] <@mulander>: hehe :P
[21:47] <@mulander>: dobra lece dalej trzeba nadrobic ;P
[21:47] Karql: dobra jedziemy dalej
[21:47] <@mulander>: listy nam daja jeszcze jedna genialna wrecz pomoc :)
[21:48] <@mulander>: wyobrazcie sobie ze macie zmienna $a = 5 i zmienna $b = 10 i checie je zamienic wartosciami
[21:48] <@mulander>: normlanie musieli byscie napisac cos takiego
[21:48] <@mulander>: r00uter poczekaj chwile
[21:48] <@mulander>: my $a = 5;
[21:48] <@mulander>: my $b = 10;
[21:48] <@mulander>: my $c = $a;
[21:48] <@mulander>: $a = $b;
[21:48] <@mulander>: $b = $a;
[21:49] <@mulander>: tfu
[21:49] <@mulander>: $b = $c
[21:49] <@mulander>: zamiast $b = $a ;)
[21:49] <@mulander>: musielismy uzyc $c jako tymczasowego schowka dla wartosci $a by moc ja potem zapisac do $b
[21:49] <@mulander>: ale leniwi programisci perla znalezli na to sposob
[21:49] <@mulander>: i to taki ze calosc miesci sie w 2 linijkach a nie w 5ciu :P
[21:50] <@mulander>: my ($a,$b) = (5,10);
[21:50] <@mulander>: ($a,$b) = ($b,$a);
[21:50] <@mulander>: prwada ze duzo prostsze i bardziej przejzyste ? :D
[21:50] Karql: nie ma pytan:D
[21:50] defc0n: :D
[21:50] r00uter: fakt
[21:50] rfl: o co chodzi?
[21:50] r00uter: bo mi sie cos pomylilo
[21:50] <@mulander>: i jest bardziej wydajne bo nie musimy pracowac na 3 zmiennych :P wiec zaoszczedzamy pamiec :>>>
[21:50] Pepi: proste jak krzywy drut ktory dal sie wyprostowac :D
[21:51] Pepi: hehe
[21:51] <@mulander>: rfl o zamiane wartosci dwoch miennych
[21:51] rfl: aa..ok
[21:51] Karql: mulander: jedziemy dalej bo dzisiaj tablice musimy zrobic nie odpuscimy ci:D
[21:51] <@mulander>: lecimy dalej :D
[21:52] <@mulander>: a teraz zrobmy sobie jeszcze jedna sztuczke dla leniwych programistow :P
[21:52] <@mulander>: wyobrazmy sobie ze mamy zmienne od $a do $f
[21:52] <@mulander>: i kazdej chcemy przypisac liczby od 1 do 6
[21:52] <@mulander>: my ($a,$b,$c,$d,$e,$f) = ( 1,2,3,4,5,6);
[21:53] <@mulander>: moze to nie jest duzo pisania ale mozna to jeszcze bardzeij skrocic
[21:53] <@mulander>: :P
[21:53] <@mulander>: my ($a,$b,$c,$d,$e,$f) = ( 1 .. 6 );
[21:53] <@mulander>: albo mozemy przypisac odpowiednie literki
[21:53] <@mulander>: my ($a,$b,$c,$d,$e,$f) = ( a .. f );
[21:53] <@mulander>: albo duze literki
[21:53] <@mulander>: my ($a,$b,$c,$d,$e,$f) = ( A .. F );
[21:53] <@mulander>: jednym slowem operator dwoch kropek zwany operatorem zasiegu.
[21:54] <@mulander>: generuje liste elementow od podanej wartosci do wartosci podanej po operatorze :)
[21:54] <@mulander>: czasem sie to bardzo przydaje :)
[21:54] <@mulander>: ale oczywiscie w troche innym kontekscie niz przypisywanie cyferek czy liter pod zmienne ;)
[21:54] <@mulander>: jak ktos nigdy nie pamieta alfabetu to zawsze moze zrobic

[21:55] <@mulander>: perl -e "print a .. z;"

[21:55] <@mulander>: :)
[21:55] pytanie: no
[21:55] <@mulander>: aha jeszcze wzmianka w stecz to raczej nie dziala ;)
[21:55] pytanie: a bedzie jakas praca domowa ?
[21:55] pytanie: dziala
[21:55] <@mulander>: beda zadanka :)
[21:55] defc0n: rany
[21:55] Pepi: zajebiste to z tymi " .. "
[21:55] r00uter: no
[21:55] r00uter: mulander
[21:55] r00uter: perl -e "print a .. z;"
[21:55] r00uter: to dziala
[21:56] <@mulander>: a zobaczcie cos takiego :P
[21:56] rfl: a co jak dam (A..x) ?
[21:56] <@mulander>: perl -e "print aa .. zz;"
[21:56] Karql: ide shella powiesicLD
[21:56] defc0n: ;]
[21:56] <@mulander>: wydrukuje alfabet duzych liter
[21:56] r00uter: l0l
[21:56] Karql: perl -e "print 1 .. 1000000;"
[21:56] r00uter: ciekawy wynik
[21:56] Karql: ahaha wpisalem to to wyglada jak matrix:D
[21:57] r00uter: haha
[21:57] Karql: fajnie kod zawala:D
[21:57] <@mulander>: ctrl+c by przerwac dzialanie programu to tak na marginesie :P
[21:57] r00uter: faktycznie
[21:57] Karql: mulander: i know
[21:57] Karql: :D
[21:57] <@mulander>: jeszcze jedno powiem o ..
[21:57] <@mulander>: raczej nie robcie tak jak karql bo to bardzo pamiecio zerne :P
[21:57] r00uter: oka mode i mow
[21:57] <@mulander>: poniewaz program musi wygenerowac liste 1000000 elementow
[21:57] <@mulander>: jeszcze jedna wzmianka w perlu mozna oddzielac liczby _
[21:58] <@mulander>: czyli 1000000 mozemy zapisac jako 1_000_000
[21:58] <@mulander>: a perl to potraktuje jako 1000000 a nam bedzie latwiej czytac ;)
[21:58] r00uter: zaraz
[21:58] Karql: a w tym zasiegu mozna jakos spacje zrobi
[21:58] r00uter: mulander
[21:58] r00uter: pepi zadal ciekawe pytanie
[21:58] Karql: zeby bylo aa ab ac
[21:58] r00uter: sorka
[21:58] r00uter: rfl
[21:58] r00uter: [22:01] a co jak dam (A..x) ?
[21:58] r00uter: zignoruje
[21:58] r00uter: duza litere
[21:58] r00uter: ?
[21:58] KamiI: sprawdz :>
[21:58] Karql: juz mulander powiedzial
[21:59] r00uter: czy skonwertuje
[21:59] Karql: ze wygeneruje alfabet z duzych liter
[21:59] r00uter: a jak by na odwrot
[21:59] r00uter: to maly
[21:59] r00uter: ?
[21:59] <@mulander>: to wygeneruje alfabet malych
[21:59] r00uter: yhy
[21:59] Karql: mulander Karql: a w tym zasiegu mozna jakos spacje zrobi
[21:59] Karql: zeby bylo aa ab ac
[21:59] Karql: etc
[22:00] <@mulander>: Karql mysle ze nie zabardzo ;)
[22:00] <@mulander>: ale szczerze nigdy nie szperalem za tym.
[22:00] Karql: tez tak mysle ale sie chcialem dopytac:D
[22:00] r00uter: mulander wykladasz za tydzien ?
[22:00] <@mulander>: r00uter tak.
[22:00] r00uter: o tej samej porze ?
[22:00] Karql: to lxu:D
[22:00] <@mulander>: chyba ze nie bedzie chetnych do sluchania :)
[22:00] abanon: mulander: ty juz 2h nawijasz
[22:00] abanon: ;]
[22:00] <@mulander>: r00uter tak o tej samej.
[22:00] Karql: dobra dalej bo jeszcze godzina na tablice:D
[22:00] r00uter: bo ja juz chce czy nie to musze leciec
[22:00] <@mulander>: abanon ostatnio 3h ale zasneli :P
[22:00] abanon: ;]
[22:00] ekim: nie wszyscy
[22:00] r00uter: ale za tydzien napewno wpadne
[22:00] ekim: ;)
[22:01] abanon: mulander: 3h gorzej niz w szkole ;p
[22:01] r00uter: podoba mi sie
[22:01] <@mulander>: ekim :P
[22:01] r00uter: :D
[22:01] <@mulander>: r00uter thx
[22:01] r00uter: dozynki po szkole :P
[22:01] Adas0212: hehe
[22:01] r00uter: mulander podoba mis ie bo
[22:01] r00uter: jak czytam kurs
[22:01] Pepi: chetni sa do sluchania :D
[22:01] r00uter: i cezgos nie kapuje to kurs mi nie wytlumaczy
[22:01] r00uter: :D
[22:01] <@mulander>: :P
[22:01] maxbog: mam pytanko: wyklad sie skonczyl czy jeszcze bedzie?
[22:01] r00uter: zarabisty pomysl
[22:01] Karql: ale google ci wytlumaczy:D
[22:01] r00uter: ;]
[22:01] <@mulander>: maxbog jeszcze traw
[22:01] Karql: maxbog: bedzie jeszcze dlugo:D
[22:02] <@mulander>: trwa :P
[22:02] r00uter: oka nie przeszkadzam
[22:02] maxbog: ok
[22:02] Karql: dobra koniec off i jedziemy:D
[22:02] r00uter: edukujcie soe
[22:02] r00uter: pa
[22:02] <@mulander>: r00uter narazie ;)
[22:02] <@mulander>: dobra lecimy
[22:02] <@mulander>: wyobrazmy sobie ze chcemy przypisac kilka ciagow do zmiennych
[22:02] <@mulander>: np.
[22:03] <@mulander>: my ($nick1,$nick2,$nick3,$nick4) = ("Mulander","Karql","r00uter","Pepi");
[22:03] <@mulander>: oczywiscie to jest w pelni poprawne
[22:03] <@mulander>: ale jak juz mowilem programisci perla sa baaaaaardzo leniwi :P
[22:03] <@mulander>: i nie lubia gimnastykowac palcow i wpisywac co chwile te wszystkie " i ,
[22:03] <@mulander>: wiec wymyslili qw(); :P
[22:03] <@mulander>: i teraz mozemy zrobic to tak
[22:04] <@mulander>: my ($nick,$nick2,$nick3,$nick4) = qw( Mulander Karql r00uter Pepi );
[22:04] <@mulander>: prwada ze wygodniej ? :P
[22:04] <@mulander>: oczywiscie mozemy to zapisac dla nas bardziej czytelnie
[22:04] <@mulander>: my ($nick,$nick2,$nick3,$nick4) = qw(
[22:04] <@mulander>: Mulander
[22:04] <@mulander>: Karql
[22:04] <@mulander>: r00uter
[22:04] <@mulander>: Pepi
[22:04] <@mulander>: );
[22:04] <@mulander>: i bedzie to dzialac tak samo a nam wygodniej czytac :P
[22:05] <@mulander>: ale to tylko taka wstawka ;) poeksperymentujcie sami z qw();
[22:05] <@mulander>: uprzedzam miedzy qw a (); nie moze byc spacji
[22:05] <@mulander>: czyli zawsze qw( nigdy qw (
[22:05] <@mulander>: tyle o listach przejdziemy zaraz do tablic ale najpierw pytanka
[22:05] Karql: wszystko jasne
[22:06] Karql: hahaah ten perl jest jeszcze bardziej leniwy niz php:D
[22:06] <@mulander>: zadnych pytan ?
[22:06] Karql: zadnych pytan dobry nauczyciel:D
[22:06] <@mulander>: Karql duzo bardziej leniwy :P
[22:06] Karql: podlizuej sie zebym sie z rodzicami nie musial zglosci:D
[22:06] <@mulander>: ale to dobrze :>
[22:06] Pepi: wszystko jasne
[22:06] <@mulander>: dobra to przechodzimy do glownego tematu dzisiaj i zarazem najbardziej obszernego, do tablic.
[22:06] ekim: dobra jadziem dalej
[22:07] <@mulander>: Co to jest tablica ? ktos ma jakis pomysl ? :D
[22:07] <@mulander>: walcie swoje propozycje na priv ( oczywiscie mowie o tablicy w perlu )
[22:07] <@mulander>: albo dam voica :P
[22:07] <@mulander>: co to tablica ?
[22:07] Karql: no to ze do jednej zmiennej kilka wartosci mozna przypiscac:D
[22:07] <@mulander>: ujdzie :P
[22:07] <@mulander>: teraz moja definicja :P
[22:07] Karql: i pozniej sie do nich odwolywac poprzez $zmienna[1] etc
[22:08] <@mulander>: Karql nie wyrpzedzaj faktow :P
[22:08] <@mulander>: Tablica to poprostu zmienna ktora przechowuje liste :D czyli uporzadkowane dane skalarne.
[22:08] <@mulander>: pamietacie ze zmienne skalarne w perlu oznaczalismy znaczkiem $
[22:08] <@mulander>: do oznaczenia tablic sluzy nam @
[22:09] <@mulander>: i tak wiedzac co to lista mozemy zadeklarowac tablice naszych ksywek ktore mielismy poprzednio
[22:09] <@mulander>: my @nick = qw( Mulander Karql r00uter Pepi );
[22:10] <@mulander>: czyli @nick przechowuje teraz 4 wartosci skalarne mozmey sie pokusic powiedziec ze @nick sklada sie z czterech zmiennych skalarnych
[22:10] <@mulander>: kazdy element naszej tablicy @nick ma swoj unikatowy numerek.
[22:10] <@mulander>: i kazdy element jest liczony od 0 w gore
[22:10] <@mulander>: my zapisalismy 4 ksywki wiec mamy numerki 0,1,2,3,4
[22:10] <@mulander>: 0 to Mulnader 1 Karql i tak dalej.
[22:11] <@mulander>: teraz powiedzmy ze chcemy wypisac pierwszy element naszej tablicy czyli moja ksywke.
[22:11] <@mulander>: odwolujemy sie od JEDNEGO elementu tablicy wiec nie uzywamy znaczka @ ( bo on odpowaida przynajmniej dwom elemnetom tablicy )
[22:11] <@mulander>: a zamiast @ stosujemy $
[22:11] <@mulander>: zeby wydrukowac moja ksywke wpiszemy wiec
[22:12] <@mulander>: print $nick[0];
[22:12] <@mulander>: i na ekranie powinno nam sie wyswietlic Mulander ( o ile macie taka tablice w skrypcie :P )
[22:12] <@mulander>: w nawiasach kwadratowych po $nick podany jest tak zwany index elementu czyli jego numerek
[22:12] <@mulander>: nalezy pamietac ze miedzy $nazwatablicy a [index] niema spacji
[22:12] <@mulander>: wiec zawsze piszemy $nazwa[index] a nigdy $nazwa [index]
[22:13] <@mulander>: wszystko jasne jak narazie ?
[22:13] Karql: ta
[22:13] KamiI: brak pytan :)
[22:13] Karql: ale jedno pytanie:D
[22:13] <@mulander>: :P
[22:13] Karql: da sie jakos sprawdzic ile jest elementow w tablicy
[22:13] <@mulander>: jakie ?
[22:13] <@mulander>: Karql tak.
[22:13] Karql: tak jak np w php bylo count()?
[22:14] <@mulander>: sproboj takiego jedno linijkowca
[22:14] <@mulander>: perl -e "@tab = qw ( a b c ); print scalar @tab;"
[22:14] <@mulander>: tablica w kontekscie skalarnym ZAWSZE zwraca liczbe elementow
[22:14] <@mulander>: kontekst skalarny wymusilismy poprzez zastosowanie 'scalar'
[22:14] Karql: no juz kumam
[22:15] <@mulander>: jezeli bysmytego nie uzyli program wydrukowal by
[22:15] <@mulander>: abc
[22:15] Karql: mozna tez my $zmienna = scalar @tab
[22:15] <@mulander>: inna ciekawostka jezeli poddamy tablice interpolacji
[22:15] <@mulander>: (Karql tak mozna )
[22:15] <@mulander>: czyli zrobimy print "@tab";
[22:15] <@mulander>: to wydruk bedzie nastepujacy:
[22:15] <@mulander>: a b c
[22:15] <@mulander>: czyli elementy zostana oddzielone spacja
[22:16] Karql: jak dalem tak to nie zostaly perl -e "@tab = qw ( a b c ); print @tab;"
[22:16] <@mulander>: to czym maja byc oddzielone mozna zdefiniowac zmieniajac specjalna zmienna w perlu ale o tym szerzej przy zmiennych specjalnych :P
[22:16] <@mulander>: Karql powinienes dostac klapsa :P
[22:16] <@mulander>: mowilem miedzy qw a (); nie moze byc spacji
[22:16] <@mulander>: lol :P
[22:16] <@mulander>: sorry to ja dalem spacje :>
[22:16] Karql: no ty dales:D
[22:16] <@mulander>: ale gafa hehehe
[22:16] <@mulander>: Karql ma racje ma byc perl -e "@tab = qw( a b c ); print @tab;"
[22:17] maxbog: ale mi to poprzednie zadzialalo :)
[22:17] <@mulander>: przechodzimy dalej
[22:17] Karql: perl -e "@tab = qw(a b c); print @tab;" ale jak dam tak to tez mi bez spacji wydrukuje:D
[22:17] <@mulander>: a zrob print "@tab";
[22:17] <@mulander>: to bedziesz mial spacje.
[22:18] <@mulander>: dobra lecimy
[22:18] <@mulander>: wielksoci tablicy nie trzeba deklarowac tak jak to jest w C
[22:18] <@mulander>: programisci perla sa leniwi wiec postarali sie by interpreter automagicznie powiekszal i zmniejszal tablice w miare potrzeby :P
[22:19] <@mulander>: czyli jak zrobimy
[22:19] <@mulander>: $tablica[100] = "Mulander";
[22:19] <@mulander>: to bedizemy mieli tablice powiekszona do 100 elemntow
[22:19] <@mulander>: a wszystkie elementy do elementu 99 ( czyli Mulander" ) beda zawieraly wartosc undef, czyli nie zdefiniowana ale pamiec dla nich bedzie zarezerwowana.
[22:19] <@mulander>: ( brr ale to niszczy wydajnosc takie cos wiec nie przesadzajcie :P )
[22:20] <@mulander>: aby uzyskac wielkosc tablicy mozemy zrobic scalar @tablica tak jak mowilem wczesniej
[22:20] <@mulander>: jezeli jednak chcemy numerek ostatniego elementu
[22:20] <@mulander>: mozemy napisac
[22:20] <@mulander>: $#tablica
[22:20] <@mulander>: co w wypadku $#tablica w ktorej mamy 100 elementow zwroci nam 99
[22:22] <@mulander>: pytania ?
[22:22] maxbog: czym sie rozni $#tablica od scalar @tablica - 1?
[22:22] Karql: niczym:D
[22:23] <@mulander>: tym ze mniej piszesz :P i mniej obliczen dla interpretera :P
[22:23] maxbog: mhm
[22:23] Karql: to jak chce cos dodac do konca tablicy to zrobie $tab[++$#tab]=?
[22:23] maxbog: ale wy leniwi jestescie :)
[22:23] maxbog: (mowie o programistach perla)
[22:23] <@mulander>: Karql mozesz ale zaraz dojdziemy do push poczekaj troche :P
[22:24] <@mulander>: btw maxbog wolalbys pisac print $tablica[scalar @tablica-1] czy $tablica[$#tablica]; ? :P
[22:24] Karql: hahah to tak jak Annihilator tlumaczyl roznice miedzy echo a print
[22:24] Karql: ze jak ma czas to pisze print a jak nie ma to echo:D
[22:24] maxbog: to po co wymyslac scalar @tablica jak mozna napisac ++$#tablica?
[22:24] <@mulander>: ? :)
[22:24] maxbog: :)
[22:25] Karql: mulander: bo jest jeden znak roznicy:D
[22:25] <@mulander>: bo czasem chcesz znac tylko ilosc elementow a nie odrazu ja powiekszac ?
[22:25] <@mulander>: btw ++$#tablica to nie to co chcesz zrobic :)
[22:25] <@mulander>: $#tablica zwraca tylko numer ostatniego elementu.
[22:26] Karql: mam pytanie:D
[22:26] Karql: robimy dzisiaj hashe:D
[22:26] Karql: hehehe
[22:26] Pepi: czy to $tablica[100] = "Mulander" ; moze posluzyc do zalania buforu ?
[22:26] Pepi: jako przyklad dalem twoj przyklad
[22:26] <@mulander>: pytaj gynvaela ;)
[22:26] <@mulander>: ale mysle ze perl takie rzeczy sprawdza wewnetrznie.
[22:26] Gynvael: zalania ?
[22:26] Gynvael: tzn overflow ?
[22:27] Gynvael: ee perl na to nie pozwoli;>
[22:27] Pepi: szkoda
[22:27] Gynvael: w C nie ma kontroli bo nie ma jak jej zrobic ;> w perlu jest jak ja zrobic ;>
[22:27] Gynvael: i jest zrobiona ;>
[22:27] <@mulander>: :D
[22:28] Karql: dobra fly:D
[22:28] Pepi: a juz myslalem ze sie da :d
[22:28] <@mulander>: lecimy dalej :)
[22:28] <@mulander>: teraz sie pobawimy w cos takiego co sie nazywa slice :P
[22:28] <@mulander>: niech kazdy zrobi sobie taki jedno linijkowiec
[22:29] <@mulander>: print -e "@tab = qw( a b c ); print @tab[0,2];
[22:29] <@mulander>: o ile wszystko poszlo ladnie powinno wam wydrukowac:
[22:29] <@mulander>: ac
[22:29] <@mulander>: czyli 0 i 2 element tablicy.
[22:30] <@mulander>: slice sluzy poprostu do pobrania wiecej niz jednego elementu tablicy
[22:30] <@mulander>: nalezy tutaj zwrocic uwage ze juz nie stosujemy znaczka $ by odwolac sie do jednego elementu
[22:30] <@mulander>: bierzemy wiecej niz 1 wiec stosujemy @
[22:30] <@mulander>: tutaj swoja sile pokazuje operator zasiegu ( .. )
[22:30] <@mulander>: bo mozemy zrobic
[22:30] <@mulander>: print @tablica[11 .. 22];
[22:30] <@mulander>: i to nam wydrukuje wszystkie elementy od 11 do 22 :)
[22:31] <@mulander>: dosyc wygodne prawda :P programisci perla sa leniwi i niechce im sie pisac
[22:31] <@mulander>: $tablica[11],$tablica[12],$tablica[13] itd :P
[22:31] <@mulander>: narazie jasne ?
[22:31] Karql: ta
[22:31] <@mulander>: slice jest przydatny w roznych sytuacjach
[22:31] <@mulander>: zalozmy ze mamy tablice @osoba
[22:32] <@mulander>: gdzie w 0 mamy jej numer
[22:32] <@mulander>: w 3 ksywke
[22:32] <@mulander>: w 4 email
[22:32] <@mulander>: a pozostale elementy nas nie interesuja
[22:32] <@mulander>: wiec mozemy zrobic cos takiego
[22:32] <@mulander>: my ($nr,$nick,$mail) = @osoba[0,3,4];
[22:32] <@mulander>: prawda ze wygodniejsze od pisania:
[22:33] <@mulander>: my ($nr,$nick,$mail) = ($osoba[0],$osoba[3],$osoba[4]);
[22:33] <@mulander>: ? :P
[22:33] Pepi: no wygodniejsze jest to
[22:33] <@mulander>: slice stosuje sie dosyc czesto.
[22:33] <@mulander>: ale jezeli jest to jasne to przejdziemy do roznych funkcji operujacych na tablicach.
[22:34] Karql: a pytanko
[22:34] <@mulander>: ( czasami stosuje slowo funkcja i operator na przemian :P )
[22:34] <@mulander>: Karql tak ?
[22:34] Karql: zalozmy ze mamy tablice i chcemy wypisac
[22:34] Karql: kazdy element w nowej lini
[22:34] Karql: to mozna to jakos inaczej niz tak
[22:34] Karql: foreach(@tablica){
[22:34] Karql: print $_,"\n";
[22:34] Karql: }
[22:34] <@mulander>: Karql nawet krocej :P
[22:34] Karql: bez petli
[22:34] <@mulander>: bo perl programisci sa bardzo leniwi :P
[22:35] <@mulander>: print $_,"\n" for @tablica;
[22:35] <@mulander>: a bez petli
[22:35] <@mulander>: to moglbys zmienic specjalna zmienna ktora decyduje o tym jak maja byc oddzielane elementy tablicy przy interpolacji
[22:35] <@mulander>: i w tedy po ustawieniu tej zmiennej jak zrobisz
[22:35] <@mulander>: print "@tablica" to otrzymasz kazdy element w nowej lini.
[22:35] Karql: no rozumiem
[22:35] Karql: a jeszcze tutaj
[22:36] <@mulander>: zreszta mozesz zrobic jeszcze inaczej
[22:36] <@mulander>: i tez bardzo prosto
[22:36] Karql: a nic:D
[22:36] <@mulander>: juz podaje jedno linijkowca
[22:36] maxbog: w perlu jest 100 sposobow na zrobiebie jednej banalnej rzeczy
[22:36] maxbog: kazdy krotszy od poprzedniego :D
[22:36] Karql: mulander: a powiesz o tej zmiennej przy interpolacji?

[22:36] <@mulander>: perl -e "@tab = qw(a b c); print qq/\n/, @tab; [22:37] <@mulander>: perl -e "@tab = qw(a b c); print qq/\n/, @tab;"

[22:37] <@mulander>: odpal to u siebie
[22:37] <@mulander>: tfu
[22:37] <@mulander>: jeszcze jedna rzecz
[22:37] <@mulander>: perl -e "@tab = qw(a b c); print join qq/\n/, @tab;"
[22:37] <@mulander>: teraz odpal to u siebie :P
[22:37] Karql: wyswietlilo mi abc:D
[22:38] <@mulander>: to musiales o czym zapomniec ;)
[22:38] Karql: zrobilo mi nowa linie a pozniej abc
[22:38] Karql: nie linie po abc
[22:38] Karql: :D
[22:38] Karql: karql@zombie:~$ perl -e "@tab = qw(a b c); print qq/\n/, @tab;"
[22:38] Karql: abc

[22:38] <@mulander>: perl -e "@tab = qw(a b c); print (join (qq/\n/, @tab));"

[22:38] KamiI: jeszcze join :)
[22:38] <@mulander>: sproboj tak
[22:38] Karql: teraz dziala
[22:39] Karql: moglo by dawac jeszcze po ostatnim elemencie ale nei bede meczyl:D
[22:39] Karql: to by bylo print (join (@tab,qq/\n/));?
[22:40] <@mulander>: sproboj
[22:40] <@mulander>: dobra wracamy do tematu
[22:41] <@mulander>: jak powiedzielismy tablica przechowuje liste o uporzadkowanej kolejnosci
[22:41] <@mulander>: zalozmy ze mamy tablice @tab = qw( a .. z );
[22:41] <@mulander>: jezeli zrobimy print @tab;
[22:41] <@mulander>: otrzymamy alfabet od a do z
[22:41] <@mulander>: a teraz powiedzcie mi co sie stanie jezeli napiszemy zamiast tego print reverse @tab;
[22:42] Karql: odwroci tablice
[22:42] Karql: :D
[22:42] <@mulander>: dokladnie.
[22:42] <@mulander>: i zwroci odwrocona tablice do tego co jest po lewej
[22:42] Karql: a cos takiego jak sort tez jest
[22:42] <@mulander>: czyli mozna zrobic
[22:42] Karql: ?
[22:42] <@mulander>: Karql dojde do tego.
[22:42] <@mulander>: czyli jak zrobimy @odwrocona = reverse @zwykla;
[22:43] <@mulander>: to @odwrocona bedzie zawierala to co @zwykla tylko w odwrotnej kolejnosci :)
[22:43] <@mulander>: zaczeliscie pytac o sort
[22:43] <@mulander>: wiec zanim przejde do pop,push,shift,unshift to omowimy sobie sort.
[22:43] <@mulander>: sort jako argument przyjmuje tablice
[22:44] <@mulander>: i zwraca ja posortowana do tego co jest po lewej.
[22:44] <@mulander>: standardowo sort do sortuje alfanumerycznie
[22:44] <@mulander>: tfu :P
[22:44] <@mulander>: wedlug wartosci ascii danego znaku :P
[22:44] <@mulander>: mozna w uproszczesniu powiedziec ze alfabetycznie.
[22:44] <@mulander>: czyli @posortowana = sort @imiona;
[22:45] <@mulander>: to @posortowana bedzie zawierala imiona posortowane alfabetycznie
[22:45] <@mulander>: jezeli jednak chcemy cos posortowac numerycznie, np. tablice zawierajaca liczby
[22:45] <@mulander>: to musimy uzyc operatora statku kosmicznego :D <=>
[22:45] <@mulander>: w nastepujacy sposob
[22:45] <@mulander>: @sorted = sort { $a <=> $b } @numerki;
[22:46] <@mulander>: to nam posortuje numerki od najwiekszego do najmniejszego
[22:46] <@mulander>: jezeli chcemy efekt odwrotny uzywamy
[22:46] <@mulander>: @sorted = sort { $b <=> $a } @numerki;
[22:47] <@mulander>: aby sortowac 'alfabetycznie' stosuje sie @sorted = sort { $a cmp $b } @nazwiska;
[22:47] <@mulander>: i to jest standardowe ustawienie sort
[22:48] <@mulander>: pytania ? :P
[22:48] <@mulander>: uwagi? :P
[22:48] Karql: mulander: @sorted = sort { $a <=> $b } @numerki;
[22:48] Karql: [22:45] Vee opuścił(a) pokój/kanał
[22:48] Karql: [22:46] <@mulander>: to nam posortuje numerki od najwiekszego do najmniejszego
[22:48] Karql: tutaj mialo byc od najmniejszego do najwiekszego:D
[22:48] <@mulander>: pogubilem sie ;)
[22:48] KamiI: ;]
[22:48] <@mulander>: po 3h pisania juz jest nieciekawie :P
[22:48] Karql: rozumiem ale tylko pisze:D
[22:48] Karql: ktos musi stac na strazy:D
[22:49] Karql: wykladu
[22:49] Karql: a jak sie poprawia nauczyciela to znaczy ze sie uwaza:D
[22:49] Karql: i powinienem dostac plusika do dziennika:D
[22:49] <@mulander>: # sort numerically ascending
[22:49] <@mulander>: @articles = sort {$a <=> $b} @files;
[22:49] <@mulander>: # sort numerically descending
[22:49] <@mulander>: @articles = sort {$b <=> $a} @files;
[22:49] <@mulander>: tak jest w perldocu takze napewno teraz sie nie pomylilem :P
[22:49] ekim: lizus;p
[22:49] Karql: no asc rosnaco dec malejaco
[22:50] <@mulander>: wiem ;)
[22:50] Karql: dobra next:D
[22:50] Pepi: no next
[22:50] <@mulander>: teraz musze wymusic na was pewien sposob myslenia :P
[22:50] <@mulander>: wyobrazcie sobie tablice
[22:50] <@mulander>: jako zbior zmiennych skalarnych
[22:50] <@mulander>: teraz kazda taka zmienna skalarna wyobrazcie sobie jako kartke papieru
[22:51] <@mulander>: czyli @stos to jest stos kartek papieru.
[22:51] <@mulander>: co jest ciekawego w takim stosie ?
[22:51] <@mulander>: mozemy na stos kartek klasc nowa kartke
[22:51] <@mulander>: i zdejmowac kartke z takiego stosu.
[22:51] <@mulander>: i w brew pozorom to jest bardzo przydatne :)
[22:51] <@mulander>: i jeszcze czesciej stosowane
[22:52] <@mulander>: mozemy zrobic cos takiego
[22:52] <@mulander>: my @nick = push "Mulander";
[22:52] <@mulander>: tfu!
[22:52] <@mulander>: ale blad :P
[22:52] <@mulander>: push @nick, "Mulander";
[22:52] <@mulander>: push @nick, "Karql";
[22:52] <@mulander>: push @nick, "Pepi";
[22:52] <@mulander>: teraz nasza tablica @nick wyglada tak
[22:52] <@mulander>: $nick[0] = "Mulander";
[22:53] <@mulander>: $nick[1] = "Karql";
[22:53] <@mulander>: $nick[2] = "Pepi";
[22:53] <@mulander>: jezeli teraz zrobimy
[22:53] <@mulander>: pop @nick;
[22:53] <@mulander>: to nasza tablica ma wartosci 0 = Mulander oraz 1 = Karql, Pepi jest calkowicie usuniety
[22:53] <@mulander>: i tablica jest zmniejszona wiec pepi nie zajmuje nam juz pamieci :P
[22:53] <@mulander>: ( zaraz sie pozbedziemy Karqla :P )
[22:54] <@mulander>: ale co robi ciekawego pop ? :P
[22:54] <@mulander>: zwraca to co usuwa w lewo.
[22:54] <@mulander>: wiec mozemy to sobie jakos zapisac.
[22:54] <@mulander>: albo np. wydrukowac
[22:54] <@mulander>: zapismy to sobie
[22:54] <@mulander>: my $smietnik = pop @nick;
[22:54] <@mulander>: teraz istnieje tylko jeden element w @nick o indeksie 0 i jest to "Mulander"
[22:55] <@mulander>: a zmienna $smietnik zawiera "Karql";
[22:55] <@mulander>: pytania ?
[22:55] KamiI: niet
[22:55] Karql: jak usuwalismy pepiego
[22:55] Afro_PL: nope
[22:55] Pepi: brak
[22:55] TwojaStara: nil
[22:55] ekim: mozna usunac cos ze srodka tablicy?
[22:55] Afro_PL: pop @nick
[22:55] Afro_PL: usuwanie z konca
[22:55] <@mulander>: ekim mozna z poczatku lub konca ;)
[22:55] <@mulander>: o usuwaniu z poczatku za chwile.
[22:56] Karql: to wystarczy pop @nick czy cos jeszcze
[22:56] TwojaStara: Nawiasem mówi±c, mowa o Perlu?
[22:56] <@mulander>: Karql wystarczy pop @nick;
[22:56] TwojaStara: Tym języku programowania, tym następcy BrainFucka?
[22:56] <@mulander>: TwojaStara tak o Perlu.
[22:56] <@mulander>: :P
[22:56] Afro_PL: :D
[22:56] <@mulander>: brainfuck fajny :D
[22:56] <@mulander>: dobra wracamy do tematu :P
[22:56] Karql: ze smietnikiem bylo chamskei no ale jedzmy dalej:D
[22:57] <@mulander>: umiemy juz usuwac z konca stosu i dodawac na koniec stosu.
[22:57] <@mulander>: teraz sie dowiemy ze mozemy to samo robic z poczatkiem
[22:57] <@mulander>: za pomoca shift i unshift;
[22:58] <@mulander>: jezlei mamy tablice @vodka = qw( setka piedziesiatka koniec );
[22:58] <@mulander>: to mozemy ladnie zrobic
[22:59] <@mulander>: hmm ostatni msg jaki doszedl ? :
[22:59] <@mulander>: :P
[22:59] KamiI: jak w nowym orleanie :D
[22:59] Karql: to mozemy ladnie zrobic
[22:59] TwojaStara: 22:53 <@mulander> to mozemy ladnie zrobic
[22:59] <@mulander>: heeh :P
[22:59] <@mulander>: n oto wracamy do tematu
[23:00] <@mulander>: $mulander = shift @vodka;
[23:00] <@mulander>: $karql = shift @vodka;
[23:00] <@mulander>: $pepi = shift @vodka;
[23:00] <@mulander>: mulander bedzie mial "setka" karql "piedziesiatka" a pepi "koniec" :P
[23:00] <@mulander>: oczywiscie tablica odpowiednio sie zmniejsza :P
[23:00] <@mulander>: mozemy tez ladnie dodac cos na poczatek naszej listy
[23:00] <@mulander>: wrocmy do jej pierwowzoru
[23:01] <@mulander>: czyli @vodka = qw( setka piedziesiatka koniec );
[23:01] <@mulander>: dodajmy jeszcze poczatek
[23:01] <@mulander>: unshift @vodka, "poczatek";
[23:01] <@mulander>: teraz nasz stos wyglad atak 0 = poczatek, 1 = setka, 2 = piedziesiatka, 3 = koniec
[23:01] <@mulander>: pytania ?
[23:01] abanon: mulander: co ty robisz
[23:02] Afro_PL: eee..
[23:02] abanon: bota irc??
[23:02] Afro_PL: :D
[23:02] <@mulander>: abanon ?
[23:02] abanon: co za program teraz tworzysz
[23:02] abanon: tzn te przyklady
[23:02] <@mulander>: :P
[23:02] abanon: bo mni enei bylo troche
[23:02] <@mulander>: chcialem bys sie obudzil :P
[23:02] <@mulander>: wiedzialem ze alkohol podziala :P
[23:02] abanon: ;]
[23:02] Pepi: czemu ja nie dostalem vodki ?:P brak q
[23:02] abanon: kurwa mam chec na piwo
[23:02] Afro_PL: dziwne, zazwyczaj alkochol przymula :D
[23:03] Afro_PL: a ja na loooda :D
[23:03] abanon: ale nikt nie chce isc ;p
[23:03] Afro_PL: i zaraz jednego wezme
[23:03] abanon: a ci co by poslzi gdzies sa
[23:04] Karql: sczli shift ucina a unshift dodaje
[23:04] Karql: ?
[23:04] <@mulander>: tak shift zabiera pierwszy element
[23:04] <@mulander>: a unshift dodaje pierwszy element
[23:04] Pepi: no jak widac :d
[23:04] Karql: myslaem ze bedzie na odwort:D
[23:04] KamiI: ja tez :D
[23:04] <@mulander>: to wynika chyba z leniwstwa :P
[23:04] ekim: ja tez;)
[23:04] <@mulander>: bo znacznie czesciej sie uzywa shift :P
[23:04] Karql: a shift na polskie co znaczy
[23:04] <@mulander>: a programisci perla sa leniwi i nie lubia duzo pisac :P
[23:05] KamiI: i gina na zawal serca z powodu braku jakiegokolwiek ruchu ;P
[23:05] <@mulander>: btw push-shift moze byc nawet 100 razy szybszy niz unshift-pop ;)
[23:06] Pepi: ile bedzie wyklad jeszcze trwal ?
[23:06] <@mulander>: mysle ze do 20 minut wyrobimy
[23:06] Pepi: spox
[23:06] KamiI: kiedy beda zadanka?
[23:06] <@mulander>: albo po wykladzie napisze albo rano
[23:06] <@mulander>: ale nastawiajcie sie raczej na jutro rano.
[23:06] Pepi: lepiej rano
[23:06] Karql: a o ktorej bo chce pierwszy zeby mi pula nie uciekla:D
[23:06] <@mulander>: to umieszcze rano
[23:07] <@mulander>: by kazdy mial rowne szanse.
[23:07] abanon: mulander: juz ponad 3h ;p
[23:07] KamiI: tzn umiesc po poludniu bo rano to tez nie rowne szansze :P
[23:07] <@mulander>: Karql jak sie zbudze :P
[23:07] Karql: to jutro nie ide spac po zastrzyku:D
[23:07] Karql: dobra to lecmy dalej
[23:08] <@mulander>: pojawilo sie w jednym z jedno linijkowcow ktore uzywalismy takie cudo jak join
[23:08] <@mulander>: wiedzcie ze oprocz join istnieje rowniez split
[23:08] <@mulander>: ale zaczniemy od join
[23:08] <@mulander>: zalozmy ze mamy tablice @liczby;
[23:09] <@mulander>: teraz chcemy te liczby wszystkie zapisac do zmiennej $liczby
[23:09] <@mulander>: ( uwaga wazna sprawa ! $liczby to oddzielna zmienna niz @liczby !!! )
[23:09] <@mulander>: ale chcemy by byly do niej zapisane wszystkie liczby w taki sposob 1::2::3::4::5
[23:10] <@mulander>: czyli kazda liczba oddzielona dwu kropkiem
[23:10] <@mulander>: nic prosztszego robimy
[23:10] <@mulander>: $liczby = join "::", @liczby;
[23:10] <@mulander>: i juz mamy nasze liczby zamienione na jedna zmienna skalarna do tego oddzielone dwoma myslnikami.
[23:10] <@mulander>: zalozmy teraz ze spowrotem chcemy z $liczby czyli naszych liczb oddzielonych srednikami zrobic tablice liczb
[23:11] <@mulander>: to jest tez proste zrobimy @liczby = split /::/, $liczby;
[23:11] <@mulander>: to // jest wyrazenie regularne i o tym powiem szerzej przy wyrazeniach regularnych
[23:11] <@mulander>: ale jako ciekawostke
[23:11] <@mulander>: zrobmy sobie maly przyklad
[23:12] <@mulander>: zalozmy ze w zmiennej $dlugi_tekst mamy tekst jaki wpisal jakis uzytkownik
[23:12] <@mulander>: chcemy z tego zrobic tablice
[23:12] <@mulander>: to zrobimy:
[23:12] <@mulander>: @tablica_slow = split / /, $dlugi_tekst;
[23:12] <@mulander>: teraz nasz $dlugi_tekst zostanie podzielony przy kazdej spacji jaka jest w tekscie.
[23:12] <@mulander>: czyli jezeli $dlugi_tekst to "dobiegamy do konca"
[23:13] <@mulander>: do elementy @tablica_slow to kolejno: 0=dobiegamy,1=do,2=konca
[23:13] <@mulander>: pytania ?
[23:13] Karql: ta
[23:13] Karql: jest w perlu cos takiego jak chunk_split() w php
[23:13] <@mulander>: co robi chunk_split() ?
[23:14] Karql: do okreslonej zmiennej co okreslona liczbe znakow daje okreslony ciag
[23:14] Karql: zeby np $dlugi_tekst podzielic co znak do zmiennej
[23:14] Karql: zeby kazdy znak to byl jeden element tablicy
[23:14] <@mulander>: mozna wystarczy wyrazenie regularne zmienic ;)
[23:14] Karql: czyli nie trzeba tak jak w php dodawac co znak jakis znak zeby pozniej rozbic przez ten znak?:D
[23:15] <@mulander>: wiesz jezeli chcesz oddzielic by kazdy znak byl oddzielnym elementem to zrob
[23:15] <@mulander>: @tablica_znakow = split //, $dlugi_tekst; :)
[23:16] Karql: aha kumam
[23:16] Karql: spox
[23:16] <@mulander>: programisci perla sa leniwi nie mamy oddzielnych funkcji do tego co mozna zrobic ta sama :P
[23:16] <@mulander>: ale jak dokladnie obslugiwac // powiemy przy wyrazeniach regularnych
[23:16] <@mulander>: a to jest baaaaaaaaardzo obszerny temat.
[23:16] Pepi: hehe
[23:16] Karql: no wyrazenia regulanre sa obszerne mozna ksiazki pisac:D
[23:16] <@mulander>: jest ksiazka
[23:16] <@mulander>: Mastering Regular Expressions with Perl
[23:17] <@mulander>: okolo 600 stron o ile dobrze pamietam
[23:17] Afro_PL: O_O
[23:17] <@mulander>: o samych wyrazeniach regularnych :P
[23:17] <@mulander>: dobra teraz ostatnia rzecz jaka dzisiaj zrobimy
[23:17] <@mulander>: i tablice mamy za soba
[23:17] <@mulander>: to juz w sumie tylko formalnosc.
[23:17] <@mulander>: powiedzialem wam jak pobrac linijke tekstu od uzytkownika
[23:18] <@mulander>: teraz dowiecie sie jak pobierac wiecej naraz :P
[23:18] <@mulander>: chom(my @linijki = );
[23:18] <@mulander>: chomp(my @linijki = );
[23:18] <@mulander>: to drugie :P
[23:18] <@mulander>: i teraz jak to podziala
[23:18] <@mulander>: uzytkownik wpisze tekst
[23:18] <@mulander>: i nacisnie enter
[23:18] <@mulander>: i tak moze w nieskonczonosc :P
[23:19] <@mulander>: dopuki nie nacisnie ctrl + d lub ctrl + z ( zalezy od systemu operacyjnego na jakim pracuje :P )
[23:19] <@mulander>: i wszystko co wpisal bedzie ladnie wpisane do zmiennej @linijki
[23:19] <@mulander>: kazdy element @linijki
[23:19] <@mulander>: to bedzie jedna linijka wprowadzonego tekstu
[23:19] <@mulander>: uzywajac chomp usunelismy odrazu wszystkie znaki nowej linii jakie wprowadzil
[23:19] <@mulander>: nalezy wspomniec ze jak macie duzo linijek w jakiejs innej zmiennej
[23:20] <@mulander>: np. czesc pliku w @plik
[23:20] <@mulander>: i chcecie usunac szybko wszystkie znaki nowej lini
[23:20] <@mulander>: mozecie zrobic chomp @plik;
[23:20] <@mulander>: i z kazdego elementu zostanie usuniety znak nowej lini jezeli istnieje.
[23:20] <@mulander>: pytania ?
[23:20] Karql: http://helion.pl/ksiazki/wyrare.htm ta ksiazka?
[23:20] Afro_PL: ee...
[23:20] Karql: ta jest bez tego with perl
[23:20] Afro_PL: a nie ctrl-c? :
[23:20] Afro_PL: :P
[23:20] <@mulander>: Afro_PL jak dasz ctrl+c to przerwiesz program
[23:21] <@mulander>: jak dasz ctrl+d lub ctrl+z to to co wpisales bedzie zapisane do zmiennej i program poleci dalej.
[23:21] Afro_PL: aaaaa
[23:21] <@mulander>: mogac pracowac na tym co wprowadzil uzytkownik.
[23:21] Afro_PL: ok - sry
[23:21] <@mulander>: Jezeli niema wiecej pytan to z mojej strony dzisiejszy kurs sie konczy w tym momencie
[23:21] <@mulander>: dziekuje tym co nie zasneli :P
[23:21] Karql: zrobmy dzisiaj jeszcze hashe:D
[23:21] Afro_PL: dzieeeekuuuujeeeemyyyy
[23:21] <@mulander>: tym co zasneli tez dziekuje poprawili mi statystyke usypiacza :P
[23:21] Afro_PL: :D
[23:22] ekim: hehe
[23:22] Pepi: spoko dzieks za pouczajacy wyklad
[23:22] <@mulander>: robil ktos loga ? :P
[23:22] Karql: ja
[23:22] Karql: jak zwykle:D
[23:22] Afro_PL: ja ;]
[23:22] <@mulander>: wyslij do gynvaela na maila :P
[23:22] Afro_PL: mi sie robi automatycznie ;]
[23:22] Karql: mulander: wyslac ci
[23:22] Karql: ok juz wysle
[23:22] KamiI: nastepny wyklad za tydzien?
[23:22] Karql: !uptime
[23:22] logger: Karql: System UpTime: 5 dni, 12 godz. , 0 min. , i 35 sek.
[23:22] logger: Karql: Bot UpTime: 0 dni, 3 godz. , 45 min. , i 53 sek.
[23:22] Afro_PL: taaaak
[23:22] Afro_PL: :D
[23:22] Karql: :D
[23:22] <@mulander>: tak, chyba ze chcecie wczesniej.
[23:22] Karql: a da sie wczesneij to chcemy:D