20:01 <@nooga> Tak wiec witam wszystkich zebranych i dziekuje za tak liczne przybycie :)
20:02 <@nooga> dzisiaj bede mowil o jesyku skryprowym zwanym Ruby
20:02 <@nooga> jest on wszechstronny
20:02 <@nooga> porownywalny do perla lub pythona
20:02 <@nooga> co ciekawe w japonii jest bardziej popularny od pythona ;p
20:03 <@nooga> mysle, ze na pozcatek trzeba pokazac wam kilka przykladow, ktore rozjasnia nieco wasze pojecie o jego skladni
20:03 <@nooga> i tak np. w ruby mozna napisac
20:03 <@nooga> 5.times {|i| print "To #{i} raz!\n"}
20:03 <@nooga> co znaczy
20:03 <@nooga> 5 razy: napisz costam
20:04 <@nooga> print "Fuj!" unless ["lasagne", "banan", "wodka"].include? gets.chomp
20:04 <@nooga> bleee, jesli to nei banan, wodka lub lasagne
20:04 <@nooga> s = "wagon slimak konewka"
20:04 <@nooga> s["slimak"] = "widelec" #=> "wagon widelec konewka"
20:04 <@nooga> zamienilismy kawalek stringa
20:05 <@nooga> a to tylko zajawka
20:05 <@nooga> w wykladzie posatram sie wyjasnic
20:05 <@nooga> m/w podstawowe sprawy takie jak arytmetyka, stringi, tablice, podprogramy czy iteracje i warunki
20:05 <@nooga> zabawy nam nei zabraknie ;p
20:06 <@nooga> teraz prosilbym was o zalatwienei sobie ruby (ci co nei maja)
20:06 <@nooga> windows: http://rubyforge.org/frs/download.php/9417/ruby184-16_rc1.exe
20:06 <@nooga> linux: ftp://ftp.ruby-lang.org/pub/ruby/ruby-1.8.4.tar.gz
20:06 <@nooga> hm
20:06 < Gynvael> kurcze fajne te przyklady
20:06 < Gynvael> widze ze elastyczna skladnie ma
20:06 < Regedit> ale nas wystraszyles
20:06 < Regedit> tymi przykladami
20:06 < KosiarZ> Ladne, bez watpienia ladne
20:06 <@nooga> phhh
20:06 <@nooga> wolno pisze
20:07 <@nooga> az wypiekow dstalem
20:07 < KosiarZ> gets.chomp to sdin?
20:07 < Regedit> spoko wyluzuj, to dopiero poczatek :)
20:07 < Regedit> panie profesorze :D
20:07 <@nooga> dojdziemy ;p
20:07 < jaro3000> ladne :-)
20:07 < Gynvael> albo odejmuje
20:07 < Gynvael> ;>
20:07 <@nooga> zabiera \n
20:07 <@nooga> dzis omowie tyle ile zdaze
20:07 < jaro3000> w vimie jest chyba wbudowany interpreter rubego.
20:07 <@nooga> jak bedzie glod wiedzy to zrobie kontynuacje
20:07 < moghar> re
20:08 < jaro3000> ale nie wiem jak sie zalacza
20:08 < DJ_cool_> Te kurwa
20:08 < DJ_cool_> Oddaj opa.
20:08 < moghar> Gynvael, znasz moze scheme ?
20:08 <@nooga> wyec jak tam? zainteresowani maja interpretery?
20:08 < DJ_cool_> Argh.
20:08 < KosiarZ> juz, jeno skompiluje, nooga
20:08 < DJ_cool_> Na moich jako¶ nie zdejmowali¶ta.
20:08 < Gynvael> moghar: ni
20:08 < Gynvael> nooga: tak
20:08 < DJ_cool_> ...
20:08 < DJ_cool_> n/c kurwa.
20:08 < moghar> Gynvael: a lispa ? ;]
20:08 < DJ_cool_> Aw.
20:08 <@nooga> ["paczka", "gramofon", "cysterna"].reverse.each {|rzecz| print "Tam jest #{rzecz}!\n"}
20:08 < Gynvael> moghar: tez nie
20:09 < moghar> ok
20:09 < prop|code> biedny DJ_cool_ lizaka mu zabrali ;d
20:09 < KosiarZ> wspolczuje temu co bedzie sprzatal w tym logu ;q
20:09 < jaro3000> moghar: lisp rox :-)
20:09 < jaro3000> nie nooga ?
20:09 < Regedit> dajcie no +m bo to wyklad ma byc a nie jakis burdel :)
20:10 < Gynvael> no ktos by mogl ;>
20:10 < moghar> jaro3000: ;]
20:10 <@nooga> +m dam ;p
20:10 <@nooga> za glosno bylo
20:10 <@nooga> tak wiec, jesli macie juz ruby
20:10 <@nooga> radze odpalic irb
20:10 <@nooga> wpisujemy poprostu irb w konsoli
20:11 <@nooga> powinien pojawic sie taki znak zachety
20:11 <@nooga> jestesmy teraz w interaktywnym interpreterze ruby
20:11 <@nooga> wychodzi sie wpisujac: exit
20:11 <@nooga> wiec tak
20:12 <@nooga> znak => x oznacza, ze x zostal zwrocony
20:12 <@nooga> to tak na przyszlosc
20:12 <@nooga> po wpisaniu linni nie trzeba srednika
20:12 <@nooga> ruby zlewa sredniki na koncu linii
20:13 <@nooga> sa one potrzebne jesli chcemy rozdzielac instrukcje w 1 linii
20:13 <@nooga> wiec moze od poczatku
20:13 <@nooga> komentarze w ruby nastepuja po znaczku #
20:13 <@nooga> jak w perlu czy pythonie
20:13 <@nooga> i teraz wazna rzecz
20:13 <@nooga> ruby jest scisle obiektowe
20:14 <@nooga> ale nie wymusza stylu obiektowego na programiscie
20:14 <@nooga> wszystko w ruby jest obiektem, nawet stale
20:14 <@nooga> z kolei f-cje to tak naprawde metody
20:14 <@nooga> no dobra
20:14 <@nooga> ale moznaby zapytac, do czego nalezy metoda np. print
20:15 <@nooga> otoz
20:15 <@nooga> ona nalezy do modulu, ktory jest wszechobecny w ruby, to taki root
20:15 <@nooga> nazywa sie Kernel
20:15 <@nooga> jesli
20:15 <@nooga> przed nazwa metody nie podamy obiektu
20:16 <@nooga> ruby domyslnie przypisze ja kernelowi
20:16 <@nooga> takze
20:16 <@nooga> irb(main):008:0> print "a"
20:16 <@nooga> a=> nil
20:16 <@nooga> irb(main):009:0> Kernel::print "A"
20:16 <@nooga> A=> nil
20:16 <@nooga> jak widzicie efekt ten sam
20:16 <@nooga> wypisuje sie na ekranie
20:16 <@nooga> identyfikatory w Ruby ro ciekawa sprawa
20:17 <@nooga> nie potrzeba zadnych tzw pieczeci jak w perlu np
20:17 <@nooga> piszemy poprostu: a, b, c, nocnik
20:17 <@nooga> przemycony_wafelek
20:17 <@nooga> wiec kalsycznie
20:17 <@nooga> jak np. w C
20:17 <@nooga> ciekawie robi sie gdy wchodza stale
20:17 <@nooga> ruby jest case sensitive
20:18 <@nooga> wiec stale odroznia sie za pomoca pierwszej duzej litery
20:18 <@nooga> np Konewka
20:18 <@nooga> jest stala, po przypisanu jej wartosci juz nic nei zmienimy
20:18 <@nooga> ale mojaKonewka to zmienna
20:18 <@nooga> dodatkowo
20:19 <@nooga> nalezaloby wspomniec, ze znak $ przed nazwa obiektu znaczy ze jest on globalny
20:19 <@nooga> $chochlik bedzie globalny
20:19 <@nooga> ruby wyroznia tez jeden b. fajny typ stalych
20:19 <@nooga> sa to symbole
20:19 <@nooga> zaczynaja sie od znaku :
20:20 <@nooga> jest to uzyteczne, o czym wkrotce opowiem
20:20 <@nooga> symbole dzialaja tak, ze wszedzie :a == :a tak samo jak 1 == 1
20:20 <@nooga> pytania?
20:20 < spaxio> co musze miec aby zaczac kodzic w rubby ;]
20:20 <@nooga> windows: http://rubyforge.org/frs/download.php/9417/ruby184-16_rc1.exe
20:20 <@nooga> linux: ftp://ftp.ruby-lang.org/pub/ruby/ruby-1.8.4.tar.gz
20:20 < jaro3000> phoenix__: pusty obiekt.
20:20 <@nooga> juz mowie
20:20 < jaro3000> phoenix__: zwracany przez funkcje.
20:20 < jaro3000> zgadlem ?
20:20 <@nooga> wlasnie mialem do tego dojsc
20:21 <@nooga> ejszcze jakeis pytania?
20:21 <@nooga> nie? jedziemy dalej 0.0
20:21 <@nooga> nil to obiekt pusty
20:21 <@nooga> jest to tak naprawde typ, symbolizuje go slowo kluczowe
20:22 <@nooga> tak samo sprawa sie ma z true i false
20:22 <@nooga> sa one unikalne
20:22 <@nooga> i ciekawostka: tylko false jest false
20:22 <@nooga> czyli np. 0 neijest traktowane jako false
20:22 <@nooga> mimo, iz ruby jest okreslane jako niescisle typowane
20:23 <@nooga> to trzeba czasem konwertowac typy
20:23 <@nooga> w ruby nie ma jak w perlu czy js, ze mozna dodawac bez problemu stringi i inty
20:24 <@nooga> sluza do tego metody to_i (zwraca inta), to_s (zwraca stringa) i kilka innych o ktorych dowiemy sie zaraz
20:24 <@nooga> przejde teraz do liczb i arytmetyki
20:24 <@nooga> tutaj klasycznie
20:24 <@nooga> prawie
20:24 <@nooga> liczby mozna zapisywac normalnie: 132432, 38732.333, 0.6666, 4e2
20:25 <@nooga> ale mozna tez tak: 100_333_666
20:25 <@nooga> _ ejst dozwolony, zeby sobie podzielic duze liczby
20:25 <@nooga> rozdzielic*
20:25 <@nooga> do dzielenia mamy /
20:25 <@nooga> a jesli chodzi o duze liczby, to ruby samo poznaje czy liczba wykracza poza zakres swojego inta i czyni ja typu Bignum
20:26 <@nooga> czyli ma obsluge wielkich liczb w komplecie i koder sie nei martwi
20:26 <@nooga> z operatorami arytmetycznymi mamy normalnie
20:26 <@nooga> czyli + - * / %
20:26 <@nooga> fajne, jest np. **
20:26 <@nooga> to jest potega
20:26 <@nooga> n**2 to n do drugiej
20:27 <@nooga> za to dzielenie calkowite ejst metoda
20:27 <@nooga> np. 666.div 600
20:27 <@nooga> mozna sobie poprobowac
20:27 <@nooga> ach, i tu kwestia, ze nie trzeba kniecznie brac argumentow w ( )
20:28 <@nooga> czasem trzeba, zeby ruby sie polapalo
20:28 <@nooga> ale czasem nie jest to konieczne
20:28 <@nooga> i etraz dramatyczna sprawa
20:28 <@nooga> oklamalem mowiac, ze
20:28 <@nooga> [20:27] <nooga> za to dzielenie calkowite ejst metoda
20:28 <@nooga> tak naprawde wszystkie operatory sa metodami!!!!!!
20:28 <@nooga> tak!
20:28 <@nooga> wklepcie sobie
20:29 <@nooga> 4 + 10 a potem 4.+ 10
20:29 <@nooga> i zobaczycie
20:29 < jaro3000> cieszy, ze operatory sa metodami, o to chcialem zapytac.
20:29 <@nooga> pytania?
20:29 < jaro3000> jeszcze jedno
20:29 < jaro3000> czy nil == false ?
20:29 <@nooga> nie
20:29 < jaro3000> ok.
20:29 <@nooga> nil to nil
20:29 <@nooga> poprostu nic
20:29 < Dzon> ej
20:29 <@nooga> jak pustka w szklanecce
20:29 <@nooga> wiecej pytan?
20:29 < Dzon> nie wiem czy bylo, jestem w sumie od niedawna
20:29 < KosiarZ> well
20:30 < Dzon> ale jakie zastosowania ma ten ruby? ;P
20:30 <@nooga> takei jak perl czy python
20:30 <@nooga> jadym dalej
20:30 < Dzon> aha
20:30 <@nooga> fajne sa w ruby zakresy
20:30 <@nooga> o czym przekonamy sie przy okazji iteracji
20:30 <@nooga> mozna sobie zrobic np 0..10
20:30 <@nooga> albo n..n+y
20:31 <@nooga> n..(n+y) :)
20:31 <@nooga> i tak matematycznie mozna powiedziec, ze 1..10 znaczy <1,10> a 1...10 to (1,10)
20:31 <@nooga> dobra
20:31 <@nooga> teraz stringi
20:32 <@nooga> jestem sklonny powiedziec, ze do stringow ruby ma tyle zabawek co perl
20:32 <@nooga> stringa mozna zrobic klasycznie "hello world"
20:32 <@nooga> lub miedzy ''
20:33 <@nooga> lub jak chcemy to %q(ehllo world)
20:33 <@nooga> albo w ostatecznosci <20:33 <@nooga> wiadomo, ze "" rozni sie od ''
20:34 <@nooga> otoz, miedzy " mozna stosowac sekwencje ucieczki
20:34 <@nooga> orac konstrukcje #{...}
20:34 <@nooga> perl np rozpoznaje czy w stringu jest jakas zmienna
20:34 <@nooga> bo ma $
20:34 <@nooga> a ruby nie
20:35 <@nooga> za to w #{} mozna sobie wsadzic dowolny kod, i to co on zwraca zostanei podstawione do tego string
20:35 <@nooga> a
20:35 <@nooga> zobaczcie sobie w irb
20:35 <@nooga> a = 100; print "blah #{a*5} blah"
20:36 <@nooga> i teraz
20:36 <@nooga> powstaje pytanie
20:36 <@nooga> dlaczego nie "blah "+(a*5)+" blah"
20:36 <@nooga> a wpiszcie
20:37 <@nooga> TypeError: can't convert Fixnum into String
20:37 <@nooga> no wlasnie
20:37 <@nooga> trzeba nam skonwetrowac typ recznie
20:37 <@nooga> "blah "+(a*5).to_s+" blah"
20:37 <@nooga> zalatwi sprawe
20:37 <@nooga> teraz widac, ze faktycznie wszystko jest b. obiektowe
20:38 <@nooga> bo do wyrazenia sobie aplikujemy metode typu ktorego ono jest
20:38 <@nooga> i tak np. mamy zabawki do stringow
20:38 <@nooga> nie w kalsycznym stylu
20:38 <@nooga> ze nbp. reverse "costam" zwroci "matsoc"
20:39 <@nooga> tylko wlasnie "costam".reverse
20:39 <@nooga> taki jest styl ruby
20:39 <@nooga> mozna b. fajnei to laczyc
20:39 <@nooga> np shaszujemy stringa
20:39 <@nooga> ale odwroconego
20:39 <@nooga> "moje tajne dane".reverse.crypt "hash"
20:40 <@nooga> czyli ("moje tajne dane".reverse) zwraca stringa
20:40 <@nooga> "enad enjat ejom"
20:40 <@nooga> a potem go haszujemy wewn. f-cja hashujaca
20:40 <@nooga> stringi mozna tez mnozyc
20:41 <@nooga> "blah"*5
20:41 <@nooga> domyslamy sie efektu
20:41 <@nooga> do interakcji (IO) sluza nam metody gets, print, p
20:41 <@nooga> mozna tez puts
20:41 <@nooga> ale to jest synonim print
20:42 <@nooga> no i tak
20:42 <@nooga> gets zwraca stringa wpis. przez usera
20:42 <@nooga> a string ma metode .chomp
20:42 <@nooga> ktora scina biale znaki
20:42 <@nooga> wiec ogolnei stosujemy gets.chomp
20:42 <@nooga> chcemy miec inta od lusera? piszemy gets.to_i
20:42 <@nooga> to_i i tak oleje te biale znaki wiec nie problem
20:43 <@nooga> stringi laczymy klasycznie, "a"+"b"
20:43 <@nooga> mozna tez operatorem <<
20:43 <@nooga> r = "poczatek"
20:43 <@nooga> r << costam
20:43 <@nooga> albo r+=costam
20:43 <@nooga> ciekawe: jest += ale nie ma ++ -- itd.
20:44 <@nooga> ruby ma wbudowane regexpy
20:44 <@nooga> posixowe
20:44 <@nooga> czyli klasycznie
20:44 <@nooga> i tu fajna kwestia do wyjasnienia
20:45 <@nooga> zrobmy: s = "wagon slimak konewka"
20:45 <@nooga> i zobaczcie
20:45 <@nooga> s.sub("slimak","tata")
20:45 <@nooga> co zwraca/
20:46 <@nooga> no zgadza sie
20:46 <@nooga> slimak stal sie tata
20:46 <@nooga> a wpiszcie
20:46 <@nooga> s
20:46 <@nooga> zmienilo sie cos?
20:46 <@nooga> nie, slimak na swoim miejscu
20:46 <@nooga> a teraz inaczej:
20:46 <@nooga> s.sub!("slimak","tata")
20:47 <@nooga> i wpiszcie: s
20:47 <@nooga> zmodyfikowalo stringa
20:47 <@nooga> i tu taka kwestia
20:47 <@nooga> jesli nazwa metody konczy sie znakiem !
20:48 <@nooga> to znaczy, ze modyfikuje ona obiekt do ktorego nalezy
20:48 <@nooga> a nazwa sub od substitute, zastap
20:48 <@nooga> mamy tez gsub i gsub! dla globalnej zamiany w calym striongu
20:48 <@nooga> ach, stringi moga byc wielolinijkowe
20:49 <@nooga> pytania :(?
20:49 < KosiarZ> tak
20:49 < KosiarZ> odnosnie "1"
20:49 < KosiarZ> tfu
20:49 < KosiarZ> "!"
20:49 <@nooga> mhm?
20:49 < KosiarZ> to do kazdej metody?
20:49 <@nooga> nie
20:49 <@nooga> wlasnie
20:49 <@nooga> nie powiedzialem wam
20:49 < KosiarZ> bo a=5; a.+! 10 nie dziala
20:50 <@nooga> ruby jest tak zbudowane, ze w irb mozna swietnie 'sciagac'
20:50 <@nooga> wpiszcie sobie 5.class
20:50 < KosiarZ> ...dzieki, tak myslalem
20:50 < illusion> nooga: zauwazylem [;
20:50 <@nooga> zwroci wam nazwe klasy do ktorej nalezy 5
20:50 < illusion> szkoda tlyko ze nie ma ++ i --
20:50 <@nooga> a wpiszcie 5.methods.sort
20:50 < KosiarZ> widze ze nie lubisz moich pytan, nooga ?
20:51 <@nooga> wywali wam liste metod dostepnych dla obiektu
20:51 <@nooga> KosiarZ: zrob co mowie to zobaczysz
20:51 <@nooga> ups
20:51 <@nooga> nie ma wiecej pytan?
20:51 < damianmyst> ne
20:51 <@nooga> ok
20:52 <@nooga> jeszze dopowiem
20:52 <@nooga> do przykladu na poczatku
20:52 <@nooga> s = "wagon slimak konewka"
20:52 <@nooga> s["slimak"] = "widelec" #=> "wagon widelec konewka"
20:52 <@nooga> tutaj poprostu wykorzystalismy operator []=
20:52 <@nooga> ktory tak naprawde jest synonimem sub
20:52 <@nooga> dla stringow
20:53 <@nooga> oczywiscie w gsub mozna fajnei korzystac z regexpow ktore tradycyjnie piszemy miedzy //
20:53 <@nooga> czyli costam.gsub(/c[ab]y/,"xxx")
20:53 <@nooga> w ruby nie ma konstrukcji s///
20:54 <@nooga> tablice
20:54 <@nooga> tablice w ruby (sa jeszcze hashe ale to inna bajka)
20:54 <@nooga> piszemy miedzy []
20:54 <@nooga> czyli ['a','b',1,2,3,:nos,:oko,x*y]
20:55 <@nooga> mozzna ladnie zagniezdzac [[a],[b,c]]
20:55 <@nooga> lub w szybki sposob %w( kon krowa kaczka )
20:55 <@nooga> zobaczcie, zwraca tablice
20:56 <@nooga> czesto uzywane metody tablic to np. sort, size, pop, push
20:56 <@nooga> a o tych lepszych za chwile sie dowiemy :D
20:56 <@nooga> np. tablica.include? z sprawdza czy z jest w tablicy
20:57 <@nooga> i tu kolejne wyjasnienei
20:57 <@nooga> niektore metody maja na koncu ?
20:57 <@nooga> to czesc rubowego stylu
20:57 <@nooga> zeby upodobnic np. warunek do pytania
20:57 <@nooga> fajna sprawa z tablicami wchodzi dopiero przy iteracjach, ale o tym za chwile
20:58 <@nooga> zeby dobrze wyjasnic iteracje, potrzebna bedzie nam wiedza o blokach
20:58 <@nooga> i tu uklon w strone ronych grup koderow
20:58 <@nooga> mozna je zapisywac za pomoca Cepowych klamerek:
20:58 <@nooga> { yadda; yadda; }
20:58 <@nooga> albo do ... end
20:59 <@nooga> niby nic
20:59 <@nooga> klasyka
20:59 <@nooga> ale w ruby bloki maja fajna rzecz
20:59 <@nooga> mozna do nich 'wpuscic' zmienne
20:59 <@nooga> np
20:59 <@nooga> do |x|
20:59 <@nooga> x.costam
20:59 <@nooga> end
21:00 <@nooga> miedzy | | podajemy nazwy argumentow ktoro otrzymuje blok
21:00 <@nooga> swietnie sie to przydaje, jest to bajer ktory odroznia ten jezyk
21:00 <@nooga> mozna oczywiscie podac wiecej zmiennych |x,y,z|
21:01 <@nooga> ja sobie wyobrazam, ze one sa w sliskiej rurze i wpadaja w kod na dole :)
21:01 <@nooga> blok zwraca ostatnie wyrazenie ktore zawiera
21:01 <@nooga> np.
21:01 <@nooga> {
21:01 <@nooga> 1
21:01 <@nooga> 2
21:01 <@nooga> 3
21:01 <@nooga> }
21:01 <@nooga> zwroci 3
21:02 <@nooga> o ile gdzies wczesniej nei wystapi return
21:02 <@nooga> zeby wykorzystac blok trzeba sobie napisac metode ktora przyjmie go jako argument
21:02 <@nooga> i wywolujemy go yieldem
21:02 <@nooga> ale to za chwile -.-
21:02 <@nooga> teraz chcialem mowic o najwiekrzym bajerze ruby
21:03 <@nooga> czyli iterachjach
21:03 <@nooga> korzystaja one z tego, ze bloki biora argumenty
21:03 <@nooga> pytania?
21:03 < illusion> niet? :>
21:03 <@nooga> nikt mnie nie slucha buuu
21:03 <@nooga> no jak nie to nie
21:03 <@nooga> jadym
21:04 <@nooga> najprostsza a zarazem calkeim fajna metoda iteracji jest
21:04 <@nooga> n.times do ... end
21:04 <@nooga> wykona ... n razy
21:04 <@nooga> znaczy wywola blok n razy
21:04 <@nooga> oczywiscie times to metoda
21:05 <@nooga> wiec mozna ((c*p-v)/2).round.times do ...
21:05 <@nooga> dlaczego nie
21:05 <@nooga> mozna tez n.times do |i| ... end
21:06 <@nooga> i wtedy metoda times wstrzykuje uaktualniony licznik do bloku, ktory tam nosi nazwe i
21:06 <@nooga> to fajne
21:06 <@nooga> mozna b. szybko zrobic cos kilka razy
21:06 <@nooga> bez pisania for(int i=.... heh
21:06 <@nooga> no i wlasnie for
21:07 <@nooga> w ruby for jest bardziej jak w pythonie niz w C
21:07 <@nooga> konstrukcja jest taka
21:07 <@nooga> for licznik in obiekt .... end
21:07 <@nooga> obiekt to moze byc np. zakres
21:08 <@nooga> albo tablica
21:08 <@nooga> czyli for i in 1..10 wykona 10 razy nadajac po kolei zmiennej i liczby od 1..10
21:09 <@nooga> albo for val in ['a','b','c'] przejdzie ta tablice nadajac wartosci kolejnych komorek zmiennej val
21:09 <@nooga> a to nie jedyny sposob
21:09 <@nooga> w takim przypadku lepiej skorzystac z metody dostarczanej przez klase Array
21:09 <@nooga> metode o nazwie each
21:10 <@nooga> ['a','b','c'].each {|literka| print literka}
21:10 <@nooga> ["paczka", "gramofon", "cysterna"].reverse.each {|rzecz| print "Tam jest #{rzecz}!\n"}
21:10 <@nooga> oczywiscie w blokach mozna wykonywac duzo instrukcji
21:11 <@nooga> mozna tez zmapowac tablice
21:11 <@nooga> to b. fajen jesli chcemy amsowo modyfikowac komorki
21:11 <@nooga> [1,2,445,6,88,0,33].map! {|value| value-1}
21:12 <@nooga> odejmie od wszystkich komorek 1
21:12 <@nooga> istnieja tez kalsyczne petle
21:12 <@nooga> while i until
21:12 <@nooga> while warunek
21:12 <@nooga> kod
21:12 <@nooga> end
21:12 <@nooga> no i musi byc end
21:13 <@nooga> nie moze byc pojedynczej instrukcji po
21:13 <@nooga> tak samo bedzie z ifem, forem itd
21:13 <@nooga> ale tworcy ruby pomysleli o tym
21:13 <@nooga> i mamy szyk przestawny
21:13 <@nooga> rob_cod while warunek
21:13 <@nooga> cos*
21:13 <@nooga> until dziala jak zaprzeczenie while
21:14 <@nooga> czyli costam while not warunek jest tozsame z costam until warunek
21:14 <@nooga> najbardziej przyziemna petla to loop
21:14 <@nooga> dziala tak
21:14 <@nooga> loop { ... }
21:14 <@nooga> wykonuje blok zupelnie jak while true
21:14 <@nooga> proste?
21:15 <@nooga> istnieja tez instrukcje sluzace do kontroli petli
21:15 <@nooga> break i next
21:15 <@nooga> break wychodzi z petli
21:15 <@nooga> a next zmusza do wykonania natychmaist nastepnej iteracji
21:15 <@nooga> ich uzywanie jest ebzpodstawne bez warunkow
21:16 <@nooga> zaraz o nich powiem jesli chcecie
21:16 <@nooga> pytania?
21:16 < MMP> Ja mam jedno
21:16 <@nooga> ?
21:16 <@nooga> prosze
21:16 < MMP> Czy moglbys w pliku txt dać przykład takiego kodu?
21:16 <@nooga> t.j?
21:16 <@nooga> jakiego dokladnie? :>
21:17 < MMP> Nie gra roli, chodziby prosta iteracja tablicy i zwrocenie wartosci
21:17 < MMP> w iru te kody nieciekawie wygladaja :-)
21:18 <@nooga> to po wykladzie
21:18 < jaro3000> sum=0; tablica.each { |i| sum+=i; } sum;
21:18 < jaro3000> ?
21:18 <@nooga> chyab, ze juz chcecie koniec
21:18 < jaro3000> sum=0; tablica.each { |i| sum+=i; }; sum;
21:18 <@nooga> no
21:18 < jaro3000> nooga: nieee, kontynuuj
21:18 <@nooga> jaro3000 dobrze
21:18 <@nooga> teraz instrukcje warunkowe
21:18 <@nooga> mamy if
21:18 <@nooga> np.
21:19 <@nooga> if 6==8
21:19 <@nooga> print "chyba glupis"
21:19 <@nooga> end
21:19 <@nooga> no i unless
21:19 <@nooga> unless znaczy dokladnie: if not
21:20 <@nooga> unless 6==8
21:20 <@nooga> print "no razcej"
21:20 <@nooga> end
21:20 <@nooga> i nie moze byc pojedynczej instrukcji
21:20 <@nooga> ale mamy szyk pzrestawny
21:20 <@nooga> ktory czyni ruby przyjemnym
21:20 <@nooga> print "no raczej" unless 6==8
21:21 <@nooga> tak samo z ifem
21:22 <@nooga> istnieje tez else
21:22 <@nooga> i elseif
21:22 <@nooga> sory
21:22 <@nooga> elsif
21:22 <@nooga> np.:
20:02 <@nooga> if x == :a
21:22 <@nooga> costam
21:22 <@nooga> elsif x == :b
21:22 <@nooga> cosinnego
21:22 <@nooga> else
21:22 <@nooga> wogole_inne
21:22 <@nooga> end
21:23 <@nooga> ale bezsasadne jest takie pisanie skoro mamy powazna instrukcje case
21:23 <@nooga> juz pokazuje
21:24 <@nooga> print "ile masz lat? "
21:24 <@nooga> case gets.to_i
21:24 <@nooga> when 0
21:24 <@nooga> print "kitujesz!"
21:24 <@nooga> when 1..10
21:24 <@nooga> print "bachor z ciebie"
21:24 <@nooga> when 10..20
21:24 <@nooga> print "i tak bachor z ciebie"
21:24 <@nooga> when 20..40
21:24 <@nooga> print "idz na piwo"
21:24 <@nooga> when 40..60
21:24 <@nooga> print "zbuduj dom"
21:24 <@nooga> when 80..100
21:24 <@nooga> print "umrzyj!"
21:24 <@nooga> else
21:24 <@nooga> print "niemozliwe :p"
21:24 <@nooga> end
21:24 <@nooga> program pobierze liczbe
21:24 <@nooga> i sprawdzi
21:24 <@nooga> w ktorym z zakresow sie znajdzie
21:25 <@nooga> i odpowienio zareagije
21:25 <@nooga> po when <wartosc> potrzebna jest nowa linia albo slowo then
21:25 <@nooga> nie trzeba zadnych breakow
21:26 <@nooga> za to mozna napisac: when 1..5,7,10..55
21:26 <@nooga> mozna tez uzywac regexpu
21:26 <@nooga> zakres
21:26 <@nooga> a..b to od a do b
21:26 <@nooga> czyli:
21:26 <@nooga> case mojstring
21:27 <@nooga> when /costam/ then reakcja
21:27 <@nooga> else
21:27 <@nooga> nie_pasuje
21:27 <@nooga> end
21:28 <@nooga> else jest jak default w C
21:28 <@nooga> i tu mozna robic fajne majstersztyki z case
21:28 <@nooga> np
21:28 <@nooga> po co pisac
21:28 <@nooga> case zmienna
21:28 <@nooga> when 1 then print "jeden"
21:29 <@nooga> when 2 then print "dwa"
21:29 <@nooga> end
21:29 <@nooga> skoro ruby jest zorientowane na wyrazenia
21:29 <@nooga> czyli nie wszystko musi byc instrukcja
21:29 <@nooga> a powiem inaczej
21:29 <@nooga> w ruby tak naprawde wszystko jest wyrazeniem
21:29 <@nooga> czyli mozeby
21:29 <@nooga> wynik = (case zmienna
21:30 <@nooga> when 1 then "jeden"
21:30 <@nooga> when 2 then "dwa"
21:30 <@nooga> end
21:30 <@nooga> print wynik
21:30 <@nooga> albo od razu: print (casae...
21:30 <@nooga> case*
21:31 <@nooga> wiele obiektow posiada fajne metody do ich testowania
21:31 <@nooga> to sa np. include?
21:31 <@nooga> is_a
21:31 <@nooga> is_a?
21:31 <@nooga> nil?
21:31 <@nooga> respond_to?
21:31 <@nooga> tak wiec intuicyjnie
21:32 <@nooga> include? sprawdza, czy np. tablica lub strig\ng zawiera element lub podstring
21:32 <@nooga> is_a? sprawdza czy obiekt jest danego typu
21:32 <@nooga> np. print "to ejst tablica" if testowany.is_a? Array
21:32 <@nooga> nazwy typow sa z duzej litery
21:32 <@nooga> albo :array
21:33 <@nooga> to oznacza to samo
21:33 <@nooga> nil? sprawdza czy obiekt jest pusty
21:33 <@nooga> przydaje sie, jesli cos nam sie wykrzaczy i czegos nei zwroci
21:33 <@nooga> mozeby wtedy bubezpieczyc program
21:33 <@nooga> cos.nil? dziala jak cos == nil
21:34 <@nooga> respond_to? sprawdza czy obiekt posiada metode
21:34 <@nooga> przydaje sie gdy przetwarzamy obiekty
21:34 <@nooga> roznych typow a o podobnych wlasciwosciach
21:34 <@nooga> pytania?
21:35 < Damon> witam :)
21:35 <@nooga> tak myslalem
21:35 <@nooga> czesc
21:35 <@nooga> przejdzmy teraz do definiowania metod
21:35 <@nooga> robimy to za pomoca defa
21:36 <@nooga> def nazwa(argumenty)
21:36 <@nooga> cialo
21:36 <@nooga> end
21:36 <@nooga> z argumentami sa rozne zabawy
21:36 <@nooga> np. gdy definiujemy domyslne wartosci def moja(a, b=7)
21:37 <@nooga> albo reszte
21:37 <@nooga> def moja(a,*b)
21:37 <@nooga> wtedy do a wleci pierwszy argument a do b wpada tablica z pozostalymi
21:38 <@nooga> to tak ogolnie
21:38 <@nooga> w ruby wszytsko jest obiektem
21:38 <@nooga> wiec metody tez nimi sa
21:38 <@nooga> zeby to zobrazowac
21:38 <@nooga> pokaze to tak
21:40 <@nooga> moja = lambda{print "huhu"}
21:40 <@nooga> to zadziala jak
21:40 <@nooga> def moja
21:40 <@nooga> print "huhu"
21:40 <@nooga> end
21:40 <@nooga> a sprawdzmy typ: moja.class
21:40 <@nooga> i co wyszlo? Proc?
21:41 <@nooga> nie zapominajmy o blokach
21:41 <@nooga> mozemy sobie napisac swoje iteratory
21:41 <@nooga> beda one zwyklymi metodami
21:41 <@nooga> wiec tak np:
21:41 <@nooga> def myloop
21:42 <@nooga> yield while true
21:42 <@nooga> end
21:42 <@nooga> i cobaczmy co nam zrobi: myloop { print "hello" }
21:42 <@nooga> yield wywoluje blok stojacy za wywolaniem, metody
21:43 <@nooga> yield 4
21:43 <@nooga> przekaze liczbe 4 do bloku
21:43 <@nooga> bedzie ja mozna zlapac {|i| ....
21:43 <@nooga> klaruje sie?
21:43 <@nooga> i jak?
21:43 <@nooga> pytania -.-?
21:43 < jaro3000> co to : przed nazwa obiektu, np. if x == :a
21:44 < illusion> hym, daj troche czasu na zajarzenie :P
21:44 < jaro3000> to tylko nazwa, czy ma jakies znaczenie ?
21:44 <@nooga> to oznacza symbol
21:44 <@nooga> tzn symbol to jest taki rodzaj stalej
21:44 <@nooga> zamiast np. enum w C
21:44 < illusion> od czego jest lambda?
21:44 < jaro3000> aha
21:44 <@nooga> :a == :a wszedzie i zawsze
21:44 <@nooga> tak samo jak 1 == 1
21:44 < jaro3000> lapie.
21:45 <@nooga> illusion: lambda to uklon w strone userow jezykow f-cyjnych
21:45 <@nooga> zwraca f-cje
21:45 < illusion> aha
21:45 <@nooga> to ejst f-cja wyzszego rzedu
21:45 <@nooga> patrz lisp, haskell czy co tam chcesz
21:45 <@nooga> ruby ejst czesciowo f-cyjne
21:45 < Gynvael> mhm
21:45 <@nooga> synonimem lambda w ruby ejst proc
21:45 <@nooga> ale to to samo
21:46 <@nooga> mam jeszcze klasy i wyjatki przygotowane
21:46 <@nooga> chcecie?
21:46 < Gynvael> ta
21:46 < Gynvael> daj daj
21:46 <@nooga> no dobra :-)
21:46 <@nooga> tak wiec klasy
21:47 <@nooga> klasy raczej klasycznie
21:47 <@nooga> class Nazwa
21:47 <@nooga> # tu definicje metod
21:47 <@nooga> end
21:47 <@nooga> mozemy uzywac obszarow: public, private, protected
21:47 <@nooga> konstruktor piszemy tak:
21:48 <@nooga> def initialize
21:48 <@nooga> end
21:48 <@nooga> moze on przyjac dowolne argumenty
21:48 <@nooga> nazwa klasy musi byc z wiekiej litery
21:48 <@nooga> to ejst stala!
21:48 <@nooga> no i kalsa w ruby... paradoksalnie... jest obiektem
21:49 <@nooga> ruby ma mocno rozbudowane OOP ale ja tu nie powiem o wszystkim
21:49 <@nooga> potraktujemy to po macoszemu :>
21:49 <@nooga> dziedziczenie robimy tak
21:49 <@nooga> class MojInt < Integer
21:49 <@nooga> i wsio
21:49 <@nooga> MojInt dziedziczy z Integer
21:50 <@nooga> uwaga
21:50 <@nooga> w ruby obeikty nie maja pol!
21:50 <@nooga> ale maja cos innego
21:50 <@nooga> w srodku klas stosujemy nazwy zaczynajace sie od @
21:50 <@nooga> @zmienna_klasowa
21:51 <@nooga> i one istnieja dla nas tylko wewnatrz klas
21:51 <@nooga> mozna je zainicjowac w konstruktorze
21:51 <@nooga> i modyfikowac
21:51 <@nooga> zeby dobrac sie do nich z zewnatrz
21:52 <@nooga> np. przez mojobiekt.wartosc czy mojobiekt.wartosc = cos
21:52 <@nooga> musimy
21:52 <@nooga> napisac 2 metody
21:52 <@nooga> def wartosc
21:52 <@nooga> @wartosc
21:52 <@nooga> edn
21:52 <@nooga> end
21:52 <@nooga> def wartosc=(x)
21:52 <@nooga> @wartosc = x
21:52 <@nooga> end
21:52 <@nooga> cholernie niewygodne, nie?
21:53 <@nooga> ale ruby temu zaradzi
21:53 <@nooga> wewnatrz klasy ejst miejsce nei tylko dla metod
21:53 <@nooga> zoabczmy:
21:53 <@nooga> class Moja
21:53 <@nooga> attr_reader :costam
21:54 <@nooga> attr_writer :costam
21:54 <@nooga> utworza nam odrazu metody czytajace i przypisujace wartosc @costam
21:54 <@nooga> taki szablon
21:55 <@nooga> w kalsach moga byc tez zmienne statyczne
21:55 <@nooga> zaczynaja sie od @@
21:55 <@nooga> np
21:55 <@nooga> mamy w klasie Glupek zmienna @@jestem_glupi = true
21:56 <@nooga> i wtedy kazda instancja kalsy Glupek bedzie miala dostep do tej wlasnie wartosci
21:56 <@nooga> czyli jesli jeden z glupkow stwierdzi, ze ejst madry
21:56 <@nooga> i przypisze @@jestem_glupi = false
21:56 <@nooga> wtedy wszystkei glupki stana sie nieglupie ;p
21:57 <@nooga> no i overloading z tych ciekawszych rzeczy
21:57 <@nooga> mozna sobie bezproblemowo dopisac lub nadpisac metode z dowolnej klasy
21:57 <@nooga> nawet jednej z tych systemowych
21:57 <@nooga> piszemy sobie
21:57 <@nooga> class Integer
21:58 <@nooga> def to_mys # na wzor to_s
21:58 <@nooga> "<<"+self+to_s+">>"
21:58 <@nooga> end
21:58 <@nooga> end
21:58 <@nooga> i mozemy juz wywolac 5.to_mys
21:58 <@nooga> i co sie stanie?
21:58 <@nooga> zwroci nam stringa "<<5>>"
21:59 <@nooga> klawo ;p?
21:59 <@nooga> pytania?
21:59 < Gynvael> a mozna przeciazyc to_s ?
21:59 < Gynvael> cofam
21:59 <@nooga> mozna
21:59 < Gynvael> nie trzeba ;p
21:59 <@nooga> mmozna tez przeciazac operator
21:59 <@nooga> y
21:59 < Gynvael> o, jak ? ;>
21:59 <@nooga> w klasie
21:59 <@nooga> def +(b)
22:00 <@nooga> self+b+2
22:00 <@nooga> end
22:00 < Gynvael> a jak poznac czym jest b ?
22:00 <@nooga> b.class
22:00 < Gynvael> czy b to string, int czy obiekt /
22:00 < Gynvael> aha
22:00 <@nooga> albo
22:00 <@nooga> def +(b)
22:00 <@nooga> self+b+2 if b.is_a? Integer
22:00 <@nooga> end
22:00 < Gynvael> fajne
22:01 <@nooga> na tym zakonczymy
22:01 <@nooga> linki dla zainteresowanych
22:01 <@nooga>http://www.rubycentral.com/book/index.html
22:01 <@nooga>http://poignantguide.net/ruby/
22:01 <@nooga>http://www.ruby-lang.org/en/
22:01 <@nooga> dziekuje za wysluchanie