Spis tre ci
Uruchomienie Ruby ...................................................................... 8
Uruchomienie interpretera Ruby 9
Wykorzystywanie #! w Uniksie oraz Linuksie 11
Skojarzenie rozszerzenia pliku w systemie Windows 11
Zarezerwowane s owa kluczowe .............................................. 13
Operatory ..................................................................................... 16
Komentarze .................................................................................. 17
Liczby ............................................................................................ 17
Zmienne ........................................................................................ 19
Zmienne lokalne 19
Zmienne instancji 19
Zmienne klasy 20
Zmienne globalne 20
Stale 20
Równolegle przypisanie zmiennych 21
Symbole ........................................................................................ 21
Wbudowane zmienne .................................................................22
Pseudozmienne ........................................................................... 25
3
 Sta e globalne ............................................................................. 26
Przedzia y .....................................................................................27
Metody .........................................................................................27
Nawiasy 28
Zwracanie warto ci 28
Konwencje nazewnictwa metod 29
Argumenty domy lne 30
Zmienna liczba argumentów 30
Aliasy metod 31
Bloki 31
Procedury 34
Instrukcje warunkowe ................................................................ 35
Instrukcja if 35
Instrukcja unless 38
Instrukcja while 38
Instrukcja until 40
Instrukcja case 41
P tla for 42
Operator trójargumentowy 43
Wykonywanie kodu przed programem b d po programie 43
Klasy ............................................................................................ 44
Zmienne instancji 45
Akcesory 47
Zmienne klasy 49
Metody klasy 49
Singletony 50
Dziedziczenie 51
Publiczna, prywatna czy chroniona 52
Moduly oraz mixiny 54
4 | Spis tre ci
 Pliki .............................................................................................. 56
Tworzenie nowego pliku 57
Otwieranie istniej cego pliku 58
ARGV oraz ARGF 58
Zmiana nazwy pliku oraz jego usuni cie 59
Badanie plików 59
Tryby oraz wlasno plików 60
Klasa IO ........................................................................................ 62
Obs uga wyj tków ..................................................................... 64
Klauzule rescue oraz ensure 65
Metoda raise 65
Metody catch oraz throw 66
Klasa Object ................................................................................ 66
Metody instancji klasy Object 67
Modu Kernel ...............................................................................73
Klasa String ................................................................................. 85
Podstawianie wyra e 85
a cuchy znaków z ogranicznikami 86
Dokumenty miejscowe 86
Znaki ucieczki 87
Kodowanie znaków 88
Wyra enia regularne 89
Metody klasy String 95
Klasa Array ................................................................................. 110
Tworzenie tablic 111
Metody klasy Array 113
Metody instancji klasy Array 114
Spis tre ci | 5
 Klasa Hash .................................................................................. 125
Tworzenie tablic asocjacyjnych 125
Metody klasy Hash 127
Metody instancji Hash 127
Dyrektywy s u ce do formatowania czasu ............................ 132
Ruby interaktywny (irb) ............................................................ 133
Debuger j zyka Ruby ................................................................ 137
Dokumentacja Ruby ..................................................................140
Opcje RDoc .................................................................................142
RubyGems .................................................................................. 147
Rake ............................................................................................ 152
Istniej ce zasoby dla j zyka Ruby ............................................155
S owniczek .................................................................................156
Skorowidz .................................................................................. 177
6 | Spis tre ci
Przedzia y
Ruby obsluguje przedzialy dzi ki wykorzystaniu operatorów ..
(przedzial domkni ty) oraz ... (lewostronnie domkni ty, prawo-
stronnie otwarty). Na przyklad przedzial 1..12 zawiera liczby
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 (z 12 wl cznie). W przedziale
1...12 warto ko cowa 12 zostaje jednak wykluczona, czyli
w praktyce znajduj si w nim liczby 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11.
Metoda === sprawdza, czy warto mie ci si w przedziale:
(1..25) === 14 # => true, w przedziale
(1..25) === 26 # => false, poza przedzia em
(1..25) === 25 # => false, poza przedzia em (wykorzystano operator ...)
Mo na wykorzysta przedzial na przyklad do utworzenia tablicy
cyfr:
(1..9).to_a # => [1, 2, 3, 4, 5, 6, 7, 8, 9]
Przedzial mo na równie utworzy w nast puj cy sposób:
digits = Range.new(1, 9)
digits.to_a # => [1, 2, 3, 4, 5, 6, 7, 8, 9]
Metody
Metody umo liwiaj grupowanie instrukcji oraz wyra e progra-
mistycznych w jednym miejscu, by dalo si je wykorzystywa
w sposób wygodny i w miar potrzeby  równie powtarzalny.
Wi kszo operatorów z j zyka Ruby jest tak e metodami. Poni ej
znajduje si prosta definicja metody o nazwie hello utworzonej
z wykorzystaniem slów kluczowych def oraz end:
def hello
puts "Witaj wiecie!"
end
hello # => Witaj wiecie!
Przedzia y | 27
Definicj metody mo na usun za pomoc undef:
undef hello # usuwa definicj metody o nazwie hello
hello # teraz nale y spróbować wywo ać t metod
NameError: undefined local variable or method 'hello' for
main:Object
from (irb):11
from :0
Metody mog przyjmowa argumenty. Zaprezentowana ni ej me-
toda repeat przyjmuje dwa argumenty, word oraz times:
def repeat( word, times )
puts word * times
end
repeat("Witaj! ", 3) # => Witaj! Witaj! Witaj!
repeat "Do widzenia! ", 4 # => Do widzenia! Do widzenia! Do widzenia!
Do widzenia!
Nawiasy
W wi kszo ci definicji metod oraz wywola w j zyku Ruby nawiasy
s opcjonalne. Je li pominie si nawiasy przy wywolywaniu metody
przyjmuj cej argumenty, w zale no ci od typów argumentów
mo na otrzyma ostrze enia.
Zwracanie warto ci
Metody zwracaj warto ci. W innych j zykach programowania
warto ci zwraca si w sposób jawny za pomoc instrukcji return.
W j zyku Ruby warto ostatniego obliczonego wyra enia zwra-
cana jest bez wzgl du na fakt u ycia jawnej instrukcji return. Jest to
cecha charakterystyczna Ruby. Mo na równie zdefiniowa zwra-
can warto za pomoc slowa kluczowego return:
def hello
return "Witaj wiecie!"
end
28 | Ruby. Leksykon kieszonkowy
Argumenty domy lne
Zaprezentowana wcze niej metoda repeat zawierala dwa argu-
menty. Argumentom tym mo na nada warto ci domy lne poprzez
u ycie znaku równo ci, po którym nast puje warto . Kiedy wy-
wola si metod bez argumentów, automatycznie wykorzystane
zostan warto ci domy lne. Nale y zdefiniowa metod repeat
ponownie, dodaj c do niej warto ci domy lne  Witaj! dla word
oraz 3 dla times. Nale y wywola t metod najpierw bez argu-
mentów, a nast pnie z nimi:
def repeat( word="Witaj!", times=3 )
puts word * times
end
repeat # => Witaj! Witaj! Witaj!
repeat( "Do widzenia! ", 5 ) # => Do widzenia! Do widzenia! Do widzenia!
Do widzenia! Do widzenia!
Zmienna liczba argumentów
Poniewa Ruby pozwala na przekazywanie do metody zmiennej
liczby argumentów dzi ki poprzedzeniu argumentu znakiem *,
autor programu ma w tym zakresie du elastyczno :
def num_args( *args )
length = args.size
label = length == 1 ? " argument" : " argumentów"
num = length.to_s + label + " ( " + args.inspect + " )"
num
end
puts num_args # => 0 argumentów ( [] )
puts num_args(1) # => 1 argument ( [1] )
puts num_args( 100, "witaj", 2.5, "trzy", 99009 ) # => 5 argumentów
( [100, "witaj", 2.5, "trzy", 99009] )
30 | Ruby. Leksykon kieszonkowy
Mo na równie wykorzysta argumenty ustalone w pol czeniu
z argumentami zmieniaj cymi si :
def two_plus( one, two, *args )
length = args.size
label = length == 1? " argument zmieniaj cy si " : "
argumentów zmieniaj cych si "
num = length.to_s + label + " ( " + args.inspect + " )"
num
end
puts two_plus( 1, 2 ) # => 0 argumentów zmieniaj cych si ( [] )
puts two_plus( 1000, 3.5, 14.3 ) # => 1 argument zmieniaj cy si ( [14.3] )
puts two_plus( 100, 2.5, "trzy", 70, 14.3, "witaj", 99009)
# => 5 argumentów zmieniaj cych si (["trzy", 70, 14.3, "witaj", 99009])
Aliasy metod
J zyk Ruby posiada slowo kluczowe alias, które slu y do two-
rzenia aliasów metod. Alias oznacza, e mo na utworzy kopi
metody z now nazw , cho obie metody odnosi si b d do tego
samego obiektu. Poni szy przyklad ilustruje sposób tworzenia
aliasu dla metody greet:
def greet
puts "Witaj, kochanie!"
end
alias baby greet # utworzenie aliasu baby dla metody greet
greet # wywo anie metody
Witaj, kochanie!
baby # wywo anie aliasu
Witaj, kochanie!
Bloki
Blok (ang. block) w Ruby jest czym wi cej ni tylko blokiem kodu
b d grup instrukcji. Jest on zawsze wywolywany w pol czeniu
z metod , co zostanie zaraz zaprezentowane. Tak naprawd bloki
Metody | 31
s domkni ciami (ang. closure), czasami okre lanymi mianem funk-
cji bezimiennych (ang. nameless function). S jak metoda znajduj ca
si wewn trz innej metody, która wspóldzieli zmienne lub odnosi
si do zmiennych z metody zewn trznej. W j zyku Ruby domkni -
cie lub blok umieszczone s w nawiasach klamrowych ({}) lub
te pomi dzy do oraz end, a ich dzialanie uzale nione jest od po-
wi zanej z nimi metody (na przyklad each).
Poni ej znajduje si przyklad wywolania bloku metody each
obiektu Array:
pacific = [ "Waszyngton", "Oregon", "Kalifornia" ]
pacific.each do |element|
puts element
end
Nazwa znajduj ca si pomi dzy znakami | (czyli |element|) mo e
by dowolna. Blok wykorzystuje j jako zmienn lokaln przecho-
wuj c ka dy z elementów tablicy, a pó niej u ywa jej, aby zrobi
co z tym elementem. Mo na zast pi do oraz end nawiasami klam-
rowymi, jak si to cz sto robi. Same nawiasy klamrowe maj tak
naprawd wy szy priorytet od konstrukcji z do oraz end:
pacific.each ( |e| puts e )
Je li u yje si nazwy zmiennej, która ju istnieje w zakresie nad-
rz dnym, blok przypisuje zmiennej ka d kolejn warto , co mo e
nie by zgodne z zamierzeniami autora. Nie generuje zmiennej
lokalnej dla bloku o tej nazwie, jak mo na by tego oczekiwa . W ten
sposób otrzyma si nast puj ce zachowanie:
j = 7
(1..4).to_a.each { | j | } # j jest teraz równe 4
Instrukcja yield
Instrukcja yield wykonuje blok powi zany z metod . Metoda
gimme zawiera na przyklad jedynie instrukcj yield:
32 | Ruby. Leksykon kieszonkowy
def gimme
yield
end
eby dowiedzie si , co robi yield, nale y wywola gimme i zoba-
czy , co si stanie:
gimme
LocalJumpError: no block given
from (irb):11:in 'gimme'
from (irb):13
from :0
Otrzymuje si bl d, poniewa zadanie instrukcji yield polega na
wykonaniu bloku kodu powi zanego z metod . Tego wla nie bra-
kowalo w wywolaniu metody gimme. Mo na unikn tego bl du
dzi ki skorzystaniu z metody block_given? (z Kernel). Nale y
ponownie zdefiniowa gimme z instrukcj if:
def gimme
if block_given?
yield
else
puts "Nie zawieram bloku!"
end
end
Teraz mo na ponownie wypróbowa metod gimme z blokiem oraz
bez niego:
gimme { print "Powiedz wszystkim 'cze '." } # => Powiedz
wszystkim 'cze ć'.
gimme # => Nie zawieram bloku!
Teraz nale y ponownie zdefiniowa metod gimme, by zawierala
ona dwie instrukcje yield, a nast pnie wywola j z blokiem:
def gimme
if block_given?
yield
yield
else
puts "Nie zawieram bloku!"
end
Metody | 33
Czytaj dalej...