plik

Wydawnictwo Helion
ul. Kociuszki 1c
44-100 Gliwice
tel. 032 230 98 63

e-mail: helion@helion.pl

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¿liwociom 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 goci.

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

Spis tre

ļci

Uruchomienie Ruby ...................................................................... 8

Uruchomienie interpretera Ruby

Wykorzystywanie #! w Uniksie oraz Linuksie

Skojarzenie rozszerzenia pliku w systemie Windows

Zarezerwowane s

ĥowa kluczowe ..............................................13

Operatory ..................................................................................... 16

Komentarze .................................................................................. 17

Liczby ............................................................................................ 17

Zmienne ........................................................................................ 19

Zmienne lokalne

Zmienne instancji

Zmienne klasy

Zmienne globalne

Staäe

Równolegäe przypisanie zmiennych

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

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

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

_ Spis tre

ļci

Sta

ĥe globalne ............................................................................. 26

Przedzia

ĥy .....................................................................................27

Metody .........................................................................................27

Nawiasy

Zwracanie wartoĈci

Konwencje nazewnictwa metod

Argumenty domyĈlne

Zmienna liczba argumentów

Aliasy metod

Bloki

Procedury

Instrukcje warunkowe ................................................................ 35

Instrukcja if

Instrukcja unless

Instrukcja while

Instrukcja until

Instrukcja case

Pötla for

Operator trójargumentowy

Wykonywanie kodu przed programem bñdĒ po programie

Klasy ............................................................................................ 44

Zmienne instancji

Akcesory

Zmienne klasy

Metody klasy

Singletony

Dziedziczenie

Publiczna, prywatna czy chroniona

Moduäy oraz mixiny

Spis tre

ļci _

Pliki .............................................................................................. 56

Tworzenie nowego pliku

Otwieranie istniejñcego pliku

ARGV oraz ARGF

Zmiana nazwy pliku oraz jego usuniöcie

Badanie plików

Tryby oraz wäasnoĈè plików

Klasa IO ........................................................................................ 62

Obs

ĥuga wyjétków ..................................................................... 64

Klauzule rescue oraz ensure

Metoda raise

Metody catch oraz throw

Klasa Object ................................................................................ 66

Metody instancji klasy Object

Modu

ĥ Kernel ...............................................................................73

Klasa String ................................................................................. 85

Podstawianie wyraĔeþ

ãaþcuchy znaków z ogranicznikami

Dokumenty miejscowe

Znaki ucieczki

Kodowanie znaków

WyraĔenia regularne

Metody klasy String

Klasa Array ................................................................................. 110

Tworzenie tablic

111

Metody klasy Array

113

Metody instancji klasy Array

114

_ 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

ĥ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

wäñcznie). W przedziale

1...12

wartoĈè koþcowa

zostaje jednak wykluczona, czyli

w praktyce znajdujñ siö w nim liczby

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!

_ 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"

_ 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

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

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

_ 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

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è

oraz

end

nawiasami klam-

rowymi, jak siö to czösto robi. Same nawiasy klamrowe majñ tak
naprawdö wyĔszy priorytet od konstrukcji z

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?

Kernel

). NaleĔy

ponownie zdefiniowaè

gimme

z instrukcjñ

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