Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. [phone]

e-mail: [e-mail]

Ruby. Leksykon
kieszonkowy

Autor: Michael Fitzgerald
ISBN: 978-83-246-1384-7
Tytu³ orygina³u:

Ruby Pocket Reference

Format: B6, stron: 192

Podrêczny zestaw informacji niezbêdnych w pracy programisty

Ruby to obiektowy jêzyk programowania, opracowany w 1995 roku w Japonii. Dziêki
swojej prostej sk³adni, zwartej konstrukcji i sporym mo¿liwoœciom b³yskawicznie zyska³
ogromne grono zwolenników. Pojawienie siê mechanizmu Ruby on Rails, niesamowicie
usprawniaj¹cego tworzenie aplikacji i witryn internetowych zgodnych z nurtem Web
2.0, dodatkowo zwiêkszy³o popularnoœæ jêzyka Ruby. W oparciu o ten jêzyk powsta³o
wiele znanych serwisów WWW, odwiedzanych ka¿dego dnia przez tysi¹ce goœci.

„

Ruby. Leksykon kieszonkowy

”

to zestawienie niezbêdnych informacji o tym jêzyku,

przydatne podczas codziennej pracy programisty. Znajdziesz w nim informacje
o s³owach kluczowych, operatorach, zmiennych i sta³ych. Przeczytasz tak¿e
o formatowaniu tekstu, wyra¿eniach regularnych, operacjach na plikach
i programowaniu obiektowym. Dowiesz siê ponadto, jak korzystaæ z interaktywnego
Ruby i RDoc.

•

Uruchamianie interpretera Ruby

•

S³owa kluczowe

•

Zmienne

•

Instrukcje warunkowe

•

Programowanie obiektowe

•

Modu³y

•

Operacje na plikach

•

Obs³uga wyj¹tków

•

Metody klas Array, Hash, Object, Kernel i String

•

Wyszukiwanie i usuwanie b³êdów

Usprawnij i przyspiesz swoj¹ pracê,

korzystaj¹c z leksykonów kieszonkowych

3

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

Staäe

20

Równolegäe przypisanie zmiennych

21

Symbole ........................................................................................ 21

Wbudowane zmienne .................................................................22

Pseudozmienne ........................................................................... 25

4

_ Spis tre

ļci

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

Moduäy oraz mixiny

54

Spis tre

ļci _

5

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 wäasnoĈè 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

6

_ Spis tre

ļci

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

Przedzia

ĥy _ 27

Przedzia

ĥy

Ruby obsäuguje przedziaäy dziöki wykorzystaniu operatorów

..

(przedziaä domkniöty) oraz

...

(lewostronnie domkniöty, prawo-

stronnie otwarty). Na przykäad przedziaä

1..12

zawiera liczby

1

,

2

,

3

,

4

,

5

,

6

,

7

,

8

,

9

,

10

,

11

,

12

(z

12

wäñ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è przedziaä na przykäad do utworzenia tablicy
cyfr:

(1..9).to_a # => [1, 2, 3, 4, 5, 6, 7, 8, 9]

Przedziaä 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 daäo 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 säów kluczowych

def

oraz

end

:

def hello
puts "Witaj

Łwiecie!"

end

hello # => Witaj

Ğwiecie!

28

_ Ruby. Leksykon kieszonkowy

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 wywoäaþ w jözyku Ruby nawiasy
sñ opcjonalne. JeĈli pominie siö nawiasy przy wywoäywaniu 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ñ säowa kluczowego

return

:

def hello
return "Witaj

Łwiecie!"

end

Metody

_ 29

Konwencje nazewnictwa metod

Ruby posiada konwencje dotyczñce ostatniego znaku w nazwie
metody — sñ one czösto spotykane w tym jözyku, jednak nie sñ
wymuszane. JeĈli nazwa metody koþczy siö znakiem zapytania (

?

),

jak w

eql?

, oznacza to, Ĕe metoda zwraca wartoĈè typu Boolean —

true

bñdĒ

false

. Na przykäad:

x = 1.0
y = 1.0
x.eql? y # =>

true

JeĈli nazwa metody koþczy siö wykrzyknikiem (

!

), jak

delete!

,

oznacza to, Ĕe metoda jest destruktywna, czyli wprowadza zmiany
na miejscu do samego obiektu, a nie jego kopii — zmienia wiöc orygi-
nalny obiekt. RóĔnicö widaè na przykäadzie metod

delete

oraz

delete!

obiektu

String

:

der_mensch = "Matz!" # => "Matz!"
der_mensch.delete( "!" ) # => "Matz"
puts der_mensch # => Matz!
der_mensch.delete!( "!" ) # => "Matz"
puts der_mensch # => Matz

JeĈli nazwa metody koþczy siö znakiem równoĈci (

=

), jak w

family_

name=

, oznacza to, Ĕe metoda jest typu setter, czyli wykonuje przy-

pisanie bñdĒ ustawia zmiennñ, takñ jak zmienna instancji w klasie:

class Name
def family_name=( family )
@family_name = family
end
def given_name=( given )
@given_name = given
end
end

n = Name.new
n.family_name= "Matsumoto" # => "Matsumoto"
n.given_name= "Yukihiro" # => "Yukihiro"
p n # => <Name:0x1d441c

@family_name="Matsumoto", given_name="Yukihiro"

>

30

_ Ruby. Leksykon kieszonkowy

Argumenty domy

ļlne

Zaprezentowana wczeĈniej metoda

repeat

zawieraäa 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-
woäa 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 wywoäaè 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] )

Metody

_

31

MoĔna równieĔ wykorzystaè argumenty ustalone w poäñ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 säowo kluczowe

alias

, które säuĔ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 przykäad 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 wywoäywany w poäñczeniu
z metodñ, co zostanie zaraz zaprezentowane. Tak naprawdö bloki

32

_ Ruby. Leksykon kieszonkowy

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óädzieli 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 dziaäanie uzaleĔnione jest od po-

wiñzanej z nimi metody (na przykäad

each

).

PoniĔej znajduje siö przykäad wywoäania 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 przykäad jedynie instrukcjö

yield

:

Czytaj dalej...

Metody

_ 33

def gimme
yield
end

ēeby dowiedzieè siö, co robi

yield

, naleĔy wywoäaè

gimme

i zoba-

czyè, co siö stanie:

gimme
LocalJumpError: no block given
from (irb):11:in 'gimme'
from (irb):13
from :0

Otrzymuje siö bäñd, poniewaĔ zadanie instrukcji

yield

polega na

wykonaniu bloku kodu powiñzanego z metodñ. Tego wäaĈnie bra-
kowaäo w wywoäaniu metody

gimme

. MoĔna uniknñè tego bäö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 zawieraäa

ona dwie instrukcje

yield

, a nastöpnie wywoäaè jñ z blokiem:

def gimme
if block_given?
yield
yield
else
puts "Nie zawieram bloku!"
end