Ruby. Programowanie

Ruby. Programowanie Autor: David Flanagan, Yukihiro Matsumoto T³umaczenie: £ukasz Piwko ISBN: 978-83-246-1767-8 Tytu³ orygina³u: The Ruby Programming Language Format: 168x237, stron: 408 Poznaj mo¿liwoœci Ruby! Zaprojektowany i stworzony w 1995 roku jêzyk Ruby dziêki swym unikalnym mo¿liwoœciom zdobywa sobie coraz wiêksze uznanie programistów na ca³ym œwiecie. Jak uda³o mu siê wkupiæ w ³aski tego nieufnego œrodowiska? Przyczyni³a siê do tego miêdzy innymi prosta sk³adnia z wbudowanymi w ni¹ wyra¿eniami regularnymi, automatyczne oczyszczanie pamiêci i przeci¹¿anie operatorów. Dodatkowo ogromna i chêtna do pomocy spo³ecznoœæ sprawia, ¿e to rozwi¹zanie staje siê jeszcze bardziej atrakcyjne. Uwaga! Jednym z autorów tej ksi¹¿ki jest sam Yukihiro Matsumoto – twórca jêzyka Ruby! Ksi¹¿ka stanowi kompletny zbiór informacji na temat jêzyka Ruby. Jeœli naprawdê chcesz zrozumieæ ten jêzyk, oto obowi¹zkowa pozycja do przeczytania! W trakcie lektury zapoznasz siê z bogatym API, pozwalaj¹cym na przetwarzanie tekstu; zrozumiesz techniki zwi¹zane z wykonywaniem dzia³añ na liczbach, implementacj¹ kolekcji, operacjami wejœcia-wyjœcia oraz prac¹ wspó³bie¿n¹ i operacjami sieciowymi. Ponadto znajdziesz tu elementy dostêpne powszechnie w jêzykach programowania, takie jak instrukcje warunkowe, pêtle czy te¿ operatory logiczne. Dziêki ksi¹¿ce „Ruby. Programowanie” wykorzystanie metod i obiektów klasy Proc oraz stosowanie platformy Ruby nie bêdzie stanowi³o dla Ciebie najmniejszego problemu! • Wprowadzenie do jêzyka Ruby • Sposoby uruchamiania programów napisanych w Ruby • Dostêpne typy danych • Zastosowanie wyra¿eñ i operatorów • Sterowanie przep³ywem • Wykorzystanie iteratorów oraz enumeratorów • Obs³uga wyj¹tków • Zastosowanie wspó³bie¿noœci • U¿ycie domkniêæ • Cykl ¿ycia obiektów • Refleksje oraz metaprogramowanie • Liczby w Ruby Wydawnictwo Helion • U¿ywanie wyra¿eñ regularnych ul. Koœciuszki 1c • Kolekcje 44-100 Gliwice • Operacje na dacie i godzinie tel. 032 230 98 63 • Tablice jedno- oraz wielowymiarowe e-mail: helion@helion.pl • Obs³uga plików oraz katalogów • Programowanie sieciowe • Obs³uga œrodowiska Ruby • Gwarancja bezpieczeñstwa Wykorzystaj elastycznoœæ i mo¿liwoœci jêzyka Ruby!

Spis tre ci Wstýp ........................................................................................................................................ 7 1. Wprowadzenie .............................................................................................................11 1.1. Krótki kurs jözyka Ruby 12 1.2. Wypróbuj jözyk Ruby 20 1.3. Ksiñ ka — informacje 24 1.4. Program rozwiñzujñcy sudoku 25 2. Struktura i uruchamianie programów Ruby ............................................................... 31 2.1. Struktura leksykalna 32 2.2. Struktura syntaktyczna 39 2.3. Struktura plików 40 2.4. Kodowanie znaków 41 2.5. Wykonywanie programu 43 3. Typy danych i obiekty ..................................................................................................45 3.1. Liczby 46 3.2. Tekst 50 3.3. Tablice 66 3.4. Tablice asocjacyjne 68 3.5. Zakresy 70 3.6. Symbole 72 3.7. Säowa kluczowe true, false i nil 73 3.8. Obiekty 73 4. Wyra enia i operatory .................................................................................................85 4.1. Literaäy i literaäy säów kluczowych 86 4.2. Odwoäania do zmiennych 87 4.3. Odwoäania do staäych 88 3

4.4. Wywoäania metod 89 4.5. Przypisania 91 4.6. Operatory 99 5. Instrukcje i przep yw sterowania ..............................................................................115 5.1. Instrukcje warunkowe 116 5.2. Pötle 124 5.3. Iteratory i obiekty przeliczalne 126 5.4. Bloki 136 5.5. Kontrola przepäywu sterowania 141 5.6. Wyjñtki i ich obsäuga 148 5.7. Instrukcje BEGIN i END 158 5.8. Wñtki, wäókna i kontynuacje 159 6. Metody, obiekty klasy Proc, lambdy i domkniýcia ................................................... 165 6.1. Definiowanie prostych metod 167 6.2. Nazwy metod 170 6.3. Nawiasy w metodach 172 6.4. Argumenty metod 174 6.5. Obiekty proc i lambda 181 6.6. Domkniöcia 188 6.7. Obiekty klasy Method 191 6.8. Programowanie funkcyjne 192 7. Klasy i modu y ............................................................................................................ 201 7.1. Definiowanie prostej klasy 202 7.2. Widoczno è metod — publiczne, chronione i prywatne 218 7.3. Tworzenie podklas i dziedziczenie 220 7.4. Tworzenie i inicjacja obiektów 227 7.5. Moduäy 232 7.6. Funkcje load i require 236 7.7. Metody singletonowe i klasa eigenclass 240 7.8. Wyszukiwanie metod 242 7.9. Wyszukiwanie staäych 244 8. Refleksja i metaprogramowanie ..............................................................................247 8.1. Typy, klasy i moduäy 248 8.2. Wykonywanie äaþcuchów i bloków 250 8.3. Zmienne i staäe 252 8.4. Metody 254 8.5. Metody zwrotne 258 8.6. ledzenie 259 4 _ Spis tre ci

8.7. Moduäy ObjectSpace i GC 261 8.8. Niestandardowe struktury sterujñce 262 8.9. Brakujñce metody i staäe 264 8.10. Dynamiczne tworzenie metod 267 8.11. Tworzenie äaþcuchów aliasów 269 8.12. Jözyki do wyspecjalizowanych zastosowaþ 274 9. Platforma Ruby .......................................................................................................... 279 9.1. ãaþcuchy 280 9.2. Wyra enia regularne 285 9.3. Liczby i matematyka 295 9.4. Data i godzina 299 9.5. Kolekcje 300 9.6. Pliki i katalogi 320 9.7. Wej cie i wyj cie 325 9.8. Programowanie sieciowe 335 9.9. Wñtki i wspóäbie no è 340 10. rodowisko Ruby .......................................................................................................355 10.1. Uruchamianie interpretera Ruby 356 10.2. rodowisko najwy szego poziomu 360 10.3. Praktyczne skróty do ekstrakcji i raportowania 368 10.4. Wywoäywanie systemu operacyjnego 370 10.5. Bezpieczeþstwo 374 Skorowidz ............................................................................................................................ 379 Spis tre ci _ 5

ROZDZIA 2. Struktura i uruchamianie programów Ruby 31

Niniejszy rozdziaä opisuje strukturö programów w jözyku Ruby. Na poczñtku opisano strukturö leksykalnñ, w tym tokeny i znaki, z których skäada siö program. Dalej znajduje siö opis struktury syntaktycznej programu Ruby z wyja nieniem sposobów pisania wyra eþ, instrukcji ste- rujñcych, metod, klas itd. jako sekwencji tokenów. Na koþcu zamieszczony jest opis plików zawierajñcych kod Ruby z obja nieniem sposobów dzielenia programów w tym jözyku na kilka plików oraz wykonywania pliku z kodem Ruby przez interpreter Ruby. 2.1. Struktura leksykalna Interpreter Ruby analizuje program jako sekwencjö tokenów. Nale ñ do nich: komentarze, literaäy, znaki interpunkcyjne, identyfikatory i säowa kluczowe. Niniejszy rozdziaä wprowadza wymienione typy tokenów oraz zawiera wa ne informacje na temat znaków, z których siö one skäadajñ, w tym rozdzielajñcych biaäych znaków. 2.1.1. Komentarze Komentarze zaczynajñ siö od znaku # i majñ zasiög do koþca wiersza. Interpreter Ruby ignoruje znaki # i wszystko, co znajduje siö za nimi w tym samym wierszu (nie ignoruje znaku nowego wiersza, który jest biaäym znakiem mogñcym oznaczaè zakoþczenie instrukcji). Je li # znajduje siö wewnñtrz äaþcucha lub wyra enia regularnego (zobacz rozdziaä 3.), to stanowi jego czö è i nie wprowadza komentarza. # Ten caáy wiersz jest komentarzem. x = "#To jest a cuch." # A to jest komentarz. y = /#To jest wyra enie regularne./ # Tu jest jeszcze jeden komentarz. Komentarze zajmujñce wiele wierszy sñ tworzone przez wstawienie znaku # na poczñtku ka dego z nich. # # Niniejsza klasa reprezentuje liczb typu Complex. # Mimo nazwy (záo ona) nie jest ona wcale skomplikowana. # Nale y zauwa yè, e w jözyku Ruby nie ma komentarzy w stylu C /* */. Nie ma sposobu na wstawienie komentarza w rodku wiersza kodu. 2.1.1.1. Dokumenty osadzone W jözyku Ruby dostöpny jest jeszcze inny sposób wstawiania komentarzy wielowierszo- wych. Sñ to tak zwane dokumenty osadzone (ang. embedded document). Pierwszy wiersz takiego komentarza zaczyna siö od ciñgu znaków =begin, a ostatni od ciñgu =end. Tekst znaj- dujñcy siö pomiödzy =begin a =end jest ignorowany. Nale y tylko pamiötaè, e miödzy tekstem a ciñgami =begin i =end musi byè przynajmniej jedna spacja. Dokumenty osadzone sñ wygodnym sposobem na tworzenie däugich komentarzy bez wstawiania na poczñtku ka dego wiersza znaku #. =begin Kto musi naprawiü poni szy kod! Kod znajduj cy si w tym miejscu jest w komentarzu. =end 32 _ Rozdzia 2. Struktura i uruchamianie programów Ruby

Warto zauwa yè, e dokumenty osadzone dziaäajñ tylko wówczas, gdy wiersze zaczynajñ siö od znaku =. # =begin Ten wiersz byá komentarzem, a teraz sam jest w komentarzu! Kod znajdujîcy si w tym miejscu nie jest w komentarzu. # =end Jak sama nazwa wskazuje, dokumenty osadzone mogñ säu yè do wstawiania w programie Ruby däugich bloków dokumentacji lub kodu ródäowego w innym jözyku (na przykäad HTML lub SQL). Sñ one czösto przeznaczone do u ytku przez ró nego rodzaju narzödzia przetwarzania koþcowego, które sñ uruchamiane na rzecz kodu Ruby. Po ciñgu =begin z re- guäy umieszczany jest identyfikator okre lajñcy, dla jakiego narzödzia przeznaczony jest dany komentarz. 2.1.1.2. Komentarze dokumentacyjne W programach Ruby mo na osadzaè dokumentacjö API w specjalnych, przeznaczonych do tego celu komentarzach poprzedzajñcych definicje metod, klas i moduäów. Do przeglñdania tej dokumentacji säu y omówione w rozdziale 1.2.4 narzödzie o nazwie ri. Narzödzie rdoc pobiera komentarze dokumentacyjne z kodu ródäowego Ruby i konwertuje je na format HTML lub przygotowuje do wy wietlenia przez narzödzie ri. Opis narzödzia rdoc wykracza poza te- matykö tej ksiñ ki. Szczegóäowe informacje na jego temat znajdujñ siö w pliku lib/rdoc/README w kodzie ródäowym Ruby. Komentarz dokumentacyjny musi znajdowaè siö bezpo rednio przed moduäem, klasñ lub metodñ, które API dokumentuje. Z reguäy zajmuje kilka wierszy zaczynajñcych siö od znaku #, ale mo e te mieè formö dokumentu osadzonego rozpoczynajñcego siö ciñgiem =begin rdoc (je li säowo rdoc zostanie pominiöte, narzödzie rdoc nie zauwa y tego komentarza). Poni szy komentarz demonstruje najwa niejsze elementy formatujñce gramatyki oznaczania komentarzy dokumentacyjnych w jözyku Ruby. Szczegóäowy opis tej gramatyki znajduje siö w wymienionym wcze niej pliku README: # # Gramatyka oznaczania komentarzy rdoc jest prosta jak w wiki. # # Akapity oddziela si pustym wierszem. # # = Nagáówki. # # Nagáówki zaczynaj si od znaku równo ci. # # == Podnagáówki. # Powy szy wiersz tworzy podnagáówek. # === Podpodnagáówek. # I tak dalej. # # = Przykáady. # # Wci te wiersze s wy wietlane dosáownie pismem o staáej szeroko ci znaków. # Nale y uwa aü, aby nie wci ü nagáówków lub list. # # = Listy i rodzaje pisma. # # Elementy listy zaczynaj si od znaku * lub -. Rodzaj pisma okre la si za pomoc interpunkcji lub kodu HTML: # * _italic_ lub <i>kursywa</i> # * *bold* lub <b>pogrubienie</b> # * +code+ lub <tt>pismo o staáej szeroko ci znaków</tt> # 2.1. Struktura leksykalna _ 33

# 1. Listy numerowane zaczynaj si od liczb. # 99. Mo na u ywaü dowolnych liczb; nie musz byü kolejne. # 1. Nie ma sposobu na zagnie d anie list. # # Terminy list opisowych s umieszczane w nawiasach kwadratowych: # [element 1] Opis elementu 1. # [element 2] Opis elementu 2. # 2.1.2. Litera y Literaäy to warto ci, które znajdujñ siö bezpo rednio w kodzie ródäowym Ruby. Zaliczajñ siö do nich liczby, äaþcuchy tekstowe i wyra enia regularne (inne literaäy, takie jak warto ci tablic jednowymiarowych i asocjacyjnych, nie sñ pojedynczymi tokenami, a bardziej zäo onymi wyra eniami). Skäadnia literaäów liczbowych i äaþcuchowych w jözyku Ruby jest skomplikowana, a zostaäa szczegóäowo opisana w rozdziale 3. Na razie wystarczy tylko krótki przy- käad demonstrujñcy, jak wyglñdajñ literaäy w jözyku Ruby: 1 # Literaá caákowitoliczbowy. 1.0 # Literaá liczby zmiennoprzecinkowej. 'one' # Literaá áa cuchowy. "two" # Inny literaá áa cuchowy. /trzy/ # Literaá wyra enia regularnego. 2.1.3. Znaki interpunkcyjne Znaki interpunkcyjne speäniajñ w jözyku Ruby ró ne zadania. Ich postaè ma wiökszo è ope- ratorów w tym jözyku, na przykäad operator dodawania to +, mno enia *, a logiczne LUB to ||. Peäna lista operatorów w jözyku Ruby znajduje siö w rozdziale 4.6. Znaki specjalne säu ñ tak e do oddzielania äaþcuchów, wyra eþ regularnych, literaäów tablic jednowymiarowych i asocjacyjnych oraz grupowania wyra eþ, argumentów metod oraz indeksów tablic. W skäadni jözyka Ruby znaki interpunkcyjne majñ tak e wiele innych zastosowaþ, o których bödzie jeszcze mowa. 2.1.4. Identyfikatory Identyfikator to inaczej nazwa. W jözyku Ruby wykorzystuje siö go do nazywania zmiennych, metod, klas itd. Mo e skäadaè siö z liter, liczb i znaków podkre lenia, ale nie mo e za- czynaè siö od liczby. Nie mo e zawieraè znaków: biaäych, niedrukowalnych oraz interpunkcyjnych z wyjñtkiem wymienionych tutaj. Identyfikatory zaczynajñce siö od wielkiej litery A-Z oznaczajñ staäe. Je li warto è takiego identyfikatora zostanie zmieniona w programie, interpreter zgäosi ostrze enie (ale nie bäñd). Nazwy klas i moduäów muszñ zaczynaè siö od wielkiej litery. Poni ej znajduje siö kilka przykäadowych identyfikatorów: i x2 old_value _internal # Identyfikatory mog zaczynaü si od znaku podkre lenia. PI # Staáa. Zgodnie z konwencjñ identyfikatory skäadajñce siö z kilku säów niebödñcych staäymi pisane sñ ze znakiem podkre lenia w_taki_sposób, podczas gdy identyfikatory staäych, które skäa- dajñ siö z kilku wyrazów, pisze siö WTakiSposób lub W_TAKI_SPOSÓB. 34 _ Rozdzia 2. Struktura i uruchamianie programów Ruby

2.1.4.1. Rozró nianie wielkich i ma ych liter Wielko è liter w jözyku Ruby ma znaczenie. Maäa litera i wielka litera to nie to samo. Na przykäad säowo kluczowe end jest czym innym ni säowo kluczowe END. 2.1.4.2. Znaki Unicode w identyfikatorach Reguäy jözyka Ruby dotyczñce tworzenia identyfikatorów sñ zdefiniowane w kategoriach znaków ASCII, które sñ zabronione. Ogólnie mówiñc, wszystkie znaki spoza zestawu ASCII mogñ byè u ywane w identyfikatorach, wliczajñc te wyglñdajñce na znaki interpunkcyjne. Na przykäad w pliku UTF-8 poni szy kod Ruby jest poprawny: def ×(x,y) # Nazw tej metody jest znak mno enia Unicode. x*y # Metoda ta mno y podane argumenty. end Podobnie japoþski programista mo e w swoim programie zakodowanym w systemie SJIS lub EUC u ywaè w identyfikatorach znaków Kanji. Wiöcej informacji na temat pisania progra- mów kodowanych w innych systemach ni ASCII znajduje siö w podrozdziale 2.4.1. Specjalne reguäy dotyczñce tworzenia identyfikatorów sñ oparte na znakach ASCII i nie dotyczñ znaków spoza tego zestawu. Na przykäad identyfikator nie mo e zaczynaè siö od cyfry z zestawu ASCII, ale mo e zaczynaè siö od cyfry z alfabetu innego ni typu Latin. Podobnie, aby byè staäñ, musi zaczynaè siö od wielkiej litery z zestawu ASCII. Na przykäad identyfikator Å nie jest staäñ. Dwa identyfikatory sñ takie same tylko wówczas, gdy sñ reprezentowane przez taki sam ciñg bajtów. Niektóre zestawy znaków, na przykäad Unicode, posiadajñ wiöcej ni jeden punkt kodowy do reprezentacji tego samego znaku. W jözyku Ruby nie ma adnej normalizacji Unicode, a wiöc ró ne punkty kodowe sñ uznawane za ró ne znaki, nawet je li majñ iden- tyczne znaczenie lub sñ reprezentowane przez taki sam glif czcionki. 2.1.4.3. Znaki interpunkcyjne w identyfikatorach Znaki interpunkcyjne mogñ wystöpowaè na poczñtku i koþcu identyfikatorów. Ich znaczenie jest nastöpujñce: $ Znak ten przed nazwñ zmiennej oznacza, e jest ona globalna. Podñ ajñc za przy- käadem Perla, w jözyku Ruby istnieje grupa zmiennych globalnych, które w nazwach zawierajñ inne znaki interpunkcyjne, takie jak $_ i $-K. Lista tych specjalnych zmiennych znajduje siö w rozdziale 10. @ Na poczñtku zmiennych obiektowych znajduje siö symbol @. Zmienne klasowe majñ przedrostek zäo ony z dwóch takich znaków. Zmienne obiektowe i klasowe zostaäy opisane w rozdziale 7. ? Bardzo pomocnñ konwencjñ jest umieszczanie na koþcu nazw metod zwracajñcych warto ci logiczne znaku ?. ! Nazwy metod koþczñce siö znakiem wykrzyknika wskazujñ, e nale y ostro nie ich u ywaè. Konwencja ta jest z reguäy stosowana do wyró nienia metod mutacyjnych modyfikujñcych obiekty bezpo rednio w porównaniu z metodami, które zwracajñ zmodyfikowanñ kopiö obiektu. = Metody posiadajñce nazwy koþczñce siö znakiem równo ci mo na wywoäywaè poprzez wstawienie ich nazw bez znaku równo ci po lewej stronie operatora przypisania (wiöcej na ten temat mo na przeczytaè w podrozdziaäach 4.5.3 i 7.1.5). 2.1. Struktura leksykalna _ 35

Poni ej znajduje siö kilka identyfikatorów z przedrostkami lub przyrostkami: $files # Zmienna globalna. @data # Zmienna obiektowa. @@counter # Zmienna klasowa. empty? # Metoda zwracaj ca warto ü logiczn , czyli predykat. sort! # Wersja metody sort modyfikuj ca obiekty bezpo rednio. timeout= # Metoda wywoáywana przez przypisanie. Niektóre operatory jözyka Ruby sñ zaimplementowane jako metody, dziöki czemu mo na je przedefiniowywaè w ró nych klasach zgodnie z potrzebñ. Dlatego te istnieje mo liwo è u ywania niektórych operatorów jako nazw metod. W tym kontek cie znaki interpunkcyjne lub znaki operatorów sñ traktowane jako identyfikatory, a nie operatory. Wiöcej informacji na temat operatorów w jözyku Ruby znajduje siö w podrozdziale 4.6. 2.1.5. S owa kluczowe Poni sze säowa kluczowe majñ w jözyku Ruby specjalnñ funkcjö i tak te sñ traktowane przez analizator skäadni Ruby: __LINE__ case ensure not then __ENCODING__ class false or true __FILE__ def for redo undef BEGIN defined? if rescue unless END do in retry until alias else module return when and elsif next self while begin end nil super yield break Poza powy szymi säowami istniejñ jeszcze trzy tokeny przypominajñce säowa kluczowe. Sñ one specjalnie traktowane przez analizator skäadni tylko wówczas, gdy znajdujñ siö na poczñtku wiersza. =begin =end __END__ Jak wiadomo, tokeny =begin i =end na poczñtku wiersza oznaczajñ poczñtek i koniec komentarza wielowierszowego. Token _END_ oznacza koniec programu (i poczñtek sekcji danych), je li znajduje siö sam w wierszu (ani przed nim, ani za nim nie mo e byè adnych biaäych znaków). W wiökszo ci jözyków säowa kluczowe byäyby tak zwanymi säowami zarezerwowanymi i nigdy nie mo na by byäo u ywaè ich jako identyfikatorów. Analizator skäadni Ruby jest bardzo elastyczny. Nie zgäasza adnych bäödów, je li które z tych säów zostanie opatrzone przedrost- kiem @, @@ czy $ i u yte jako identyfikator zmiennej obiektowej, klasowej lub globalnej. Po- nadto säów kluczowych mo na u ywaè jako nazw metod, z tym, e metoda musi zawsze byè wywoäywana jawnie poprzez obiekt. Nale y jednak pamiötaè, e u ycie tych säów jako iden- tyfikatorów spowoduje zaciemnienie kodu ródäowego. Najlepiej jest traktowaè je jako säowa zarezerwowane. Wiele wa nych wäasno ci jözyka Ruby jest zaimplementowanych jako metody klas Kernel, Module, Class i Object. Dlatego te dobrze jest poni sze säowa równie traktowaè jako zarezerwowane: # To s metody, które wygl daj na instrukcje lub sáowa kluczowe. at_exit catch private require attr include proc throw attr_accessor lambda protected attr_reader load public attr_writer loop raise 36 _ Rozdzia 2. Struktura i uruchamianie programów Ruby

# To s cz sto u ywane funkcje globalne. Array chomp! gsub! select Float chop iterator? sleep Integer chop! load split String eval open sprintf URI exec p srand abort exit print sub autoload exit! printf sub! autoload? fail putc syscall binding fork puts system block_given? format rand test callcc getc readline trap caller gets readlines warn chomp gsub scan # To s cz sto u ywane metody obiektowe. allocate freeze kind_of? superclass clone frozen? method taint display hash methods tainted? dup id new to_a enum_for inherited nil? to_enum eql? inspect object_id to_s equal? instance_of? respond_to? untaint extend is_a? send 2.1.6. Bia e znaki Spacje, tabulatory i znaki nowego wiersza nie sñ same w sobie tokenami, ale säu ñ do ich oddzielania, gdy te w przeciwnym razie zlaäyby siö w jeden. Poza tñ podstawowñ funkcjñ roz- dzielajñcñ wiökszo è biaäych znaków jest ignorowana przez interpreter Ruby. Sñ one stosowane gäównie do formatowania programów, aby äatwiej siö je czytaäo. Jednak nie wszystkie biaäe znaki sñ ignorowane. Niektóre sñ wymagane, a niektóre nawet zabronione. Gramatyka jözyka Ruby jest ekspresywna, ale i skomplikowana. Istnieje kilka przypadków, w których wstawienie lub usuniöcie biaäego znaku mo e spowodowaè zmianö dziaäania programu. Mimo i sytu- acje takie nie sñ czöste, nale y o nich wiedzieè. 2.1.6.1. Znaki nowego wiersza jako znaki ko czéce instrukcje Najczöstsze zastosowanie biaäych znaków ma zwiñzek ze znakami nowego wiersza, które säu ñ jako znaki koþczñce instrukcje. W jözykach takich jak Java i C ka da instrukcja musi byè za- koþczona rednikiem. W jözyku Ruby tak e mo na koþczyè instrukcje tym znakiem, ale jest to wymagane tylko wówczas, gdy w jednym wierszu znajduje siö wiöcej ni jedna instrukcja. Zgodnie z konwencjñ we wszystkich innych tego typu sytuacjach rednik nie jest u ywany. Przy braku redników interpreter Ruby musi zgadnñè na wäasnñ rökö, gdzie koþczy siö dana instrukcja. Je li kod w wierszu stanowi peänñ pod wzglödem syntaktycznym instrukcjö, znakiem jñ koþczñcym jest znak nowego wiersza. Gdy instrukcja nie jest kompletna, Ruby kon- tynuuje jej analizö w kolejnym wierszu (w Ruby 1.9 jest jeden wyjñtek od tej reguäy, który zostaä opisany dalej w tym podrozdziale). Je eli wszystkie instrukcje mieszczñ siö w pojedynczym wierszu, nie ma problemu. Jednak w przypadku gdy instrukcja zajmuje wiöcej ni jeden wiersz, nale y tak jñ podzieliè, aby interpreter nie wziñä jej pierwszej czö ci za kompletnñ instrukcjö. W takiej sytuacji w grö wcho- dzi biaäy znak. Program mo e dziaäaè na ró ne sposoby w zale no ci od tego, gdzie siö on znajduje. Na przykäad poni sza procedura dodaje x do y i sumö zapisuje w zmiennej total: 2.1. Struktura leksykalna _ 37

total = x + # Wyra enie niekompletne — analiza jest kontynuowana. y Natomiast poni szy kod przypisuje zmiennñ x do total, a nastöpnie oblicza warto è y i nic z niñ nie robi: total = x # To jest kompletne wyra enie. + y # Bezu yteczne, ale kompletne wyra enie. Kolejnym przykäadem sñ instrukcje return i break, po których opcjonalnie mo e znajdowaè siö wyra enie okre lajñce warto è zwrotnñ. Znak nowego wiersza pomiödzy säowem kluczo- wym a wyra eniem spowoduje zakoþczenie instrukcji przed tym ostatnim. Znak nowego wiersza mo na wstawiè bez obawy, e instrukcja zostanie zakoþczona zbyt wcze nie, po ka dym operatorze, kropce lub przecinku w wywoäaniu metody oraz literale dowolnego rodzaju tablicy. Mo na go tak e zastñpiè lewym uko nikiem, co zapobiega automatycznemu zakoþczeniu instrukcji przez Ruby: var total = first_long_variable_name + second_long_variable_name + third_long_variable_name # Powy ej nie ma adnego znaku ko cz cego instrukcj . Reguäy dotyczñce koþczenia instrukcji sñ nieco inne w Ruby 1.9. Je li pierwszym znakiem nie- bödñcym spacjñ w wierszu jest kropka, wiersz ten jest traktowany jako kontynuacja poprzed- niego, a wiöc znajdujñcy siö wcze niej znak nowego wiersza nie koþczy instrukcji. Wiersze zaczy- najñce siö od kropek sñ przydatne w przypadku däugich äaþcuchów metod, czasami nazywanych päynnymi API (ang. fluent API); ka da wywoäana w nich metoda zwraca obiekt, na rzecz którego mogñ byè wywoäane dodatkowe metody. Na przykäad: animals = Array.new .push("pies") # Nie dziaáa w Ruby 1.8. .push("krowa") .push("kot") .sort 2.1.6.2. Spacje a wywo ywanie metod W niektórych sytuacjach gramatyka Ruby dopuszcza pominiöcie nawiasów w wywoäaniach metod, które dziöki temu mogñ byè u ywane tak, jakby byäy instrukcjami; w znacznym stopniu wpäywa to na elegancjö kodu. Niestety, mo liwo è ta powoduje zale no è od biaäych znaków. Przykäadowo poni sze dwa wiersze kodu ró niñ siö tylko jednñ spacjñ: f(3+2)+1 f (3+2)+1 W pierwszym wierszu do funkcji f zostaje przekazana warto è 5, a do zwróconego wyniku zostaje dodana jedynka. Poniewa w drugim wierszu po nazwie funkcji znajduje siö spacja, Ruby zakäada, e nawias w wywoäaniu tej funkcji zostaä pominiöty. Nawias znajdujñcy siö dalej jest traktowany jako sposób oddzielenia wyra enia, a argumentem funkcji jest caäe wyra enie (3+2)+1. Je li wäñczone sñ ostrze enia (za pomocñ opcji -w), Ruby zgäasza ostrze enie zawsze, gdy napotyka taki niejednoznaczny kod. Rozwiñzanie tego problemu jest proste: x Nigdy nie nale y umieszczaè spacji miödzy nazwñ metody a otwierajñcym nawiasem. x Je eli pierwszy argument metody zaczyna siö od nawiasu otwierajñcego, wywoäanie metody zawsze powinno byè otoczone nawiasami. Na przykäad f((3+2)+1). 38 _ Rozdzia 2. Struktura i uruchamianie programów Ruby

x Zawsze uruchamiaj interpreter z opcjñ -w, dziöki czemu bödzie on zgäaszaä ostrze enia zawsze, gdy zapomnisz o powy szych reguäach! 2.2. Struktura syntaktyczna Do tej pory zostaäy omówione tokeny i znaki, z których siö one skäadajñ. Teraz krótko zaj- miemy siö tym, jak tokeny leksykalne äñczñ siö w wiöksze struktury syntaktyczne programu Ruby. Niniejszy podrozdziaä opisuje skäadniö programów Ruby od najprostszych wyra eþ po najwiöksze moduäy. W efekcie jest on mapñ prowadzñcñ do kolejnych rozdziaäów. Podstawowñ jednostkñ syntaktycznñ w jözyku Ruby jest wyra enie (ang. expression). Inter- preter Ruby oblicza wyra enia, zwracajñc ich warto ci. Najprostsze wyra enia to wyra enia pierwotne (ang. primary expression), które bezpo rednio reprezentujñ warto ci. Nale ñ do nich opisywane wcze niej literaäy äaþcuchowe i liczbowe. Inne tego typu wyra enia to niektóre säowa kluczowe, jak true, false, nil i self. Odwoäania do zmiennych równie sñ wyra e- niami pierwotnymi. Ich warto ciñ jest warto è zmiennej. Bardziej skomplikowane warto ci mogñ byè zapisane jako wyra enia zäo one: [1,2,3] # Literaá tablicowy. {1=>"one", 2=>"two"} # Literaá tablicy asocjacyjnej. 1..3 # Literaá zakresowy. Operatory säu ñ do wykonywania obliczeþ na warto ciach, a wyra enia zäo one zbudowane sñ z prostszych podwyra eþ rozdzielonych operatorami: 1 # Wyra enie pierwotne. x # Inne wyra enie pierwotne. x = 1 # Wyra enie przypisania. x = x + 1 # Wyra enie z dwoma operatorami. Tematowi operatorów i wyra eþ, w tym zmiennych i wyra eþ przypisania, po wiöcony jest rozdziaä 4. Wyra enia w poäñczeniu ze säowami kluczowymi tworzñ instrukcje, jak na przykäad instrukcja if, która warunkowo wykonuje kod, lub instrukcja while wykonujñca kod wielokrotnie: if x < 10 then # Je li to wyra enie ma warto ü true, x = x + 1 # nale y wykonaü t instrukcj . end # Oznacza koniec instrukcji warunkowej. while x < 10 do # Dopóki wyra enie to ma warto ü true... print x # nale y wykonywaü t instrukcj . x = x + 1 # Nast pnie nale y wykonaü t instrukcj . end # Oznacza koniec p tli. W jözyku Ruby instrukcje te sñ z technicznego punktu widzenia wyra eniami, ale nadal istnieje przydatne rozró nienie pomiödzy wyra eniami na wpäywajñce na przepäyw sterowania w programie i na te, które tego nie robiñ. Instrukcje sterujñce zostaäy opisane w rozdziale 5. We wszystkich nieprymitywnych programach wyra enia i instrukcje grupowane sñ w para- metryzowane jednostki, dziöki czemu mogñ byè wielokrotnie wywoäywane przy u yciu ró nych danych wej ciowych. Jednostki te sñ nazywane funkcjami, procedurami lub podprocedurami. Poniewa jözyk Ruby jest zorientowany obiektowo, jednostki te to metody. Metody i zwiñzane z nimi struktury nazywane proc i lambda sñ tematem rozdziaäu 6. Zestawy metod zaprojektowane, aby wzajemnie oddziaäywaäy miödzy sobñ, mo na äñczyè w klasy, a grupy wzajemnie powiñzanych klas i metod, które sñ od nich niezale ne, tworzñ moduäy. Klasy i moduäy sñ tematem rozdziaäu 7. 2.2. Struktura syntaktyczna _ 39

2.2.1. Struktura bloku Programy Ruby majñ strukturö blokowñ. Moduäy, klasy i definicje metod, a tak e wiökszo è instrukcji zawiera bloki zagnie d onego kodu. Sñ one oznaczane säowami kluczowymi lub specjalnymi znakami i zgodnie z konwencjñ powinny byè wciöte na gäöboko è dwóch spacji wzglödem swoich ograniczników. W programach w jözyku Ruby mogñ wystöpowaè dwa rodzaje bloków. Jeden z nich jest formalnie nazywany blokiem. Jest to fragment kodu zwiñzany z metodñ iteracyjnñ lub do niej przekazywany: 3.times { print "Ruby! " } W powy szym przykäadzie klamry wraz ze znajdujñcym siö miödzy nimi kodem stanowiñ blok zwiñzany z wywoäaniem metody iteracyjnej 3.times. Formalne bloki tego typu mogñ byè oznaczane klamrami lub säowami kluczowymi do i end: 1.upto(10) do |x| print x end Ograniczniki do i end sñ z reguäy u ywane w przypadkach, gdy blok zajmuje wiöcej ni jeden wiersz kodu. Zwróè uwagö na wciöcie wielko ci dwóch spacji kodu w bloku. Bloki zostaäy opisane w podrozdziale 5.4. Aby uniknñè mylenia prawdziwych bloków, drugi ich rodzaj mo na nazwaè ciaäem (w praktyce jednak termin „blok” jest u ywany w obu przypadkach). Ciaäo jest listñ instrukcji, które skäadajñ siö na ciaäo definicji klasy, metody, pötli while lub czegokolwiek innego. Nigdy nie jest oznaczane klamrami — w tym przypadku ogranicznikami sñ säowa kluczowe. Szczegóäy dotyczñce skäadni ciaä instrukcji, metod oraz klas i moduäów znajdujñ siö odpowiednio w rozdziaäach 5., 6. i 7. Ciaäa i bloki mo na zagnie d aè jedne w drugich. Programy jözyka Ruby zazwyczaj zawie- rajñ kilka poziomów zagnie d onego kodu, czytelnego dziöki wciöciom. Poni ej znajduje siö schematyczny przykäad: module Stats # Moduá. class Dataset # Klasa w module. def initialize(filename) # Metoda w klasie. IO.foreach(filename) do |line| # Blok w metodzie. if line[0,1] == "#" # Instrukcja if w bloku. next # Prosta instrukcja w instrukcji if. end # Koniec ciaáa instrukcji if. end # Koniec bloku. end # Koniec ciaáa metody. end # Koniec ciaáa klasy. end # Koniec ciaáa moduáu. 2.3. Struktura plików Zasad dotyczñcych struktury kodu jözyka Ruby w pliku jest kilka. Dotyczñ one przygoto- wywania programów do u ytku i nie dotyczñ bezpo rednio samego jözyka. Po pierwsze, je li w programie Ruby zawarty jest komentarz shebang (#!) informujñcy systemy operacyjne typu Unix, jak go uruchomiè, musi on znajdowaè siö w pierwszej linijce. 40 _ Rozdzia 2. Struktura i uruchamianie programów Ruby

Po drugie, w sytuacji gdy w programie Ruby znajduje siö komentarz okre lajñcy kodowanie znaków (opisane w podrozdziale 2.4.1), musi on znajdowaè siö w pierwszej linijce lub w drugiej, je li w pierwszej jest komentarz shebang. Po trzecie, je eli plik zawiera linijkö, w której znajduje siö tylko token _END_ bez adnych biaäych znaków przed nim i za nim, interpreter koþczy przetwarzanie w tym miejscu. W dalszej czö ci pliku mogñ znajdowaè siö dowolne dane, które program mo e odczytywaè za pomocñ staäej DATA obiektu IO (wiöcej informacji na temat tej staäej globalnej mo na znale è w podrozdziale 9.7 i rozdziale 10.). Program Ruby nie musi mie ciè siö w jednym pliku. Na przykäad wiele programów äaduje kod Ruby z dodatkowych plików bibliotecznych. Do äadowania kodu z innych plików säu y metoda require. Szuka ona okre lonych moduäów na cie ce wyszukiwania i uniemo liwia zaäadowanie danego moduäu wiöcej ni jeden raz. Szczegóäy na ten temat znajdujñ siö w podrozdziale 7.6. Poni szy kod ilustruje ka dy z wymienionych punktów struktury pliku z programem Ruby: #!/usr/bin/ruby -w Komentarz shebang. # -*- coding: utf-8 -*- Komentarz okre laj cy kodowanie. require 'socket' Zaáadowanie biblioteki sieciowej. ... Kod programu. __END__ Koniec programu. ... Dane programu. 2.4. Kodowanie znaków Na najni szym poziomie program w jözyku Ruby jest ciñgiem znaków. Reguäy leksykalne tego jözyka zostaäy zdefiniowane przy u yciu znaków z zestawu ASCII. Na przykäad komentarze zaczynajñ siö od znaku # (kod ASCII 35), a dozwolone biaäe znaki to: tabulator po- ziomy (ASCII 9), znak nowego wiersza (10), tabulator pionowy (11), wysuw strony (12), powrót karetki (13) i spacja (32).Wszystkie säowa kluczowe jözyka Ruby zostaäy zapisane znakami ASCII; tak e wszystkie operatory i inne znaki interpunkcyjne pochodzñ z tego zestawu. Domy lnie interpreter Ruby przyjmuje, e kod ródäowy Ruby jest zakodowany w systemie ASCII. Nie jest to jednak wymóg. Interpreter mo e przetwarzaè tak e pliki zakodowane w innych systemach zawierajñcych wszystkie znaki dostöpne w ASCII. Aby mógä on zinterpretowaè bajty pliku ródäowego jako znaki, musi wiedzieè, jakiego kodowania u yè. Kodowanie mogñ okre laè pliki Ruby lub mo na poinformowaè o tym interpreter. Wyja nienie, jak to zrobiè, znajduje siö nieco dalej. Interpreter Ruby jest bardzo elastyczny, je li chodzi o znaki wystöpujñce w programach. Nie- które znaki ASCII majñ specjalne znaczenie i nie mogñ byè stosowane w identyfikatorach. Poza tym program Ruby mo e zawieraè wszelkie znaki dozwolone przez kodowanie. Napi- sali my wcze niej, e identyfikatory mogñ zawieraè znaki spoza zestawu ASCII. To samo dotyczy komentarzy, literaäów äaþcuchowych i wyra eþ regularnych — mogñ zawieraè dowolne znaki inne ni znak ograniczajñcy oznaczajñcy koniec komentarza lub literaäu. W plikach ASCII äaþcuchy mogñ zawieraè dowolne bajty, tak e te, które reprezentujñ niedrukowalne znaki kontrolne (takie u ycie surowych bajtów nie jest jednak zalecane; w literaäach w jözyku Ruby mo na stosowaè symbole zastöpcze, dziöki czemu dowolne znaki mo na wstawiè przy 2.4. Kodowanie znaków _ 41

u yciu kodów liczbowych). Je li plik jest zakodowany w systemie UTF-8, komentarze, äaþcu- chy i wyra enia regularne mogñ zawieraè dowolne znaki Unicode. Je li plik jest zakodowany w jednym z japoþskich systemów — SJIS lub EUC — äaþcuchy mogñ zawieraè znaki Kanji. 2.4.1. Okre lanie kodowania programu Domy lnie interpreter Ruby przyjmuje, e programy sñ kodowane w systemie ASCII. W Ruby 1.8 kodowanie mo na zmieniè za pomocñ opcji wiersza poleceþ -K. Aby uruchomiè program Ruby zawierajñcy znaki Unicode w UTF-8, nale y uruchomiè interpreter przy u yciu opcji -Ku. Programy zawierajñce japoþskie znaki w kodowaniu EUC-JP lub SJIS mo na uruchomiè, wy- korzystujñc opcjö -Ke i -Ks. Ruby 1.9 równie obsäuguje opcjö -K, ale nie jest ona ju preferowanym sposobem okre lania kodowania pliku z programem. Zamiast zmuszaè u ytkownika skryptu do okre lenia kodowania w trakcie uruchamiania Ruby, twórca skryptu mo e je okre liè za pomocñ specjalnego komentarza znajdujñcego siö na poczñtku pliku1. Na przykäad: # coding: utf-8 Komentarz musi skäadaè siö wyäñcznie ze znaków ASCII i zawieraè säowo coding z dwu- kropkiem lub znakiem równo ci, po którym znajduje siö nazwa wybranego kodowania (nie mo e ona zawieraè spacji ani znaków interpunkcyjnych z wyjñtkiem my lnika i znaku podkre lenia). Biaäe znaki mogñ znajdowaè siö po obu stronach dwukropka lub znaku równo ci, a przed äaþcuchem coding mo e znajdowaè siö dowolny przedrostek, jak en. W caäym tym komentarzu, wäñcznie ze säowem coding i nazwñ kodowania, nie sñ rozró niane wielkie i maäe litery, a wiöc mo e on byè pisany zarówno maäymi, jak i wielkimi literami. Komentarze kodowania zazwyczaj zawierajñ tak e informacjö o kodowaniu dla edytora tek- stowego. U ytkownicy edytora Emacs mogliby napisaè: # -*- coding: utf-8 -*- A u ytkownicy programu vi: # vi: set fileencoding=utf-8 : Tego typu komentarz kodowania zazwyczaj mo e znajdowaè siö tylko w pierwszej linijce pliku. Wyjñtkiem jest sytuacja, gdy pierwsza linijka jest zajöta przez komentarz shebang (który umo liwia wykonanie skryptu w systemach uniksowych). Wówczas kodowanie mo e znaj- dowaè siö w drugiej linijce. #!/usr/bin/ruby -w # coding: utf-8 W nazwach kodowania nie sñ rozró niane wielkie i maäe litery, a wiöc nazwy mo na pisaè w dowolny sposób, tak e mieszajñc maäe litery z wielkimi. Ruby 1.9 obsäuguje nastöpujñce kodowania ródäa: ASCII-8BIT (inna nazwa to BINARY), US-ASCII (7-bit ASCII), kodowania europej- skie ISO-8859-1 do ISO-8859-15, Unicode UTF-8 oraz japoþskie SHIFT_JIS (inaczej SJIS) i EUC-JP. Konkretne kompilacje lub dystrybucje Ruby mogñ obsäugiwaè tak e dodatkowe kodowania. Pliki zakodowane w systemie UTF-8 identyfikujñ swoje kodowanie, je li ich trzy pierwsze bajty to 0xEF 0xBB 0xBF. Bajty te nazywane sñ BOM (Byte Order Mark — znacznik kolejno ci bajtów) i nie sñ obowiñzkowe w plikach UTF-8 (niektóre programy dziaäajñce w systemie Windows dodajñ te bajty przy zapisywaniu plików Unicode). 1 W tej kwestii Ruby wykorzystuje konwencjö z jözyka Python; zobacz http://www.python.org/dev/peps/pep-0263/. 42 _ Rozdzia 2. Struktura i uruchamianie programów Ruby

W Ruby 1.9 säowo kluczowe __ENCODING__ (na poczñtku i koþcu znajdujñ siö dwa znaki podkre lenia) ewaluuje do kodowania ródäa aktualnie wykonywanego kodu. Powstaäa w wyniku tego warto è jest obiektem klasy Encoding (wiöcej na temat klasy Encoding znajduje siö w podrozdziale 3.2.6.2). 2.4.2. Kodowanie ród a i domy lne kodowanie zewnýtrzne W Ruby 1.9 wa na jest ró nica pomiödzy kodowaniem ródäa pliku Ruby a domy lnym kodowaniem zewnötrznym procesu Ruby. Kodowanie ródäa jest tym, co zostaäo opisane wcze- niej — informuje interpreter, jak odczytywaè znaki w skrypcie. Jest ono zazwyczaj ustawiane za pomocñ komentarzy kodowania. Program Ruby mo e skäadaè siö z wiöcej ni jednego pliku, a ka dy z nich mo e mieè inne kodowanie ródäa. Kodowanie ródäa pliku wpäywa na kodowanie literaäów äaþcuchowych w tym pliku. Wiöcej informacji na temat kodowania äaþ- cuchów znajduje siö w podrozdziale 3.2.6. Domy lne kodowanie zewnötrzne to co innego — jest ono u ywane przez Ruby podczas odczytu z plików i strumieni. Obejmuje caäy proces Ruby i nie mo e zmieniaè siö od pliku do pliku. W typowych warunkach jest ustawiane na podstawie lokalizacji, na którñ ustawiony jest komputer. Mo na to jednak zmieniè, u ywajñc odpowiednich opcji wiersza poleceþ, o czym za chwilö. Domy lne kodowanie zewnötrzne nie wpäywa na kodowanie literaäów äaþcuchowych, ale ma du e znaczenie dla operacji wej cia i wyj cia; wiöcej informacji na ten temat znajduje siö w podrozdziale 9.7.2. Wcze niej podana zostaäa opcja -K jako sposób na okre lenie kodowania ródäa. W rzeczywi- sto ci ustawia ona domy lne kodowanie zewnötrzne procesu i stosuje je jako domy lne kodowanie ródäa. W Ruby 1.9 opcja -K jest dostöpna ze wzglödu na zgodno è z Ruby 1.8, ale nie jest ju zale- canym sposobem ustawiania kodowania zewnötrznego. Dwie nowe opcje -E i --encoding pozwalajñ na okre lenie kodowania za pomocñ jego peänej nazwy zamiast jednoliterowego skrótu. Na przykäad: ruby -E utf-8 # Nazwa kodowania po opcji -E. ruby -Eutf-8 # Spacja jest opcjonalna. ruby --encoding utf-8 # Nazwa kodowania po opcji --encoding ze spacj . ruby --encoding=utf-8 # Po opcji --encoding mo na wstawiü znak równo ci. Wszystkie szczegóäy na ten temat znajdujñ siö w podrozdziale 10.1. Domy lne kodowanie zewnötrzne mo na sprawdziè, wykorzystujñc klasowñ metodö Encoding. ´default_external. Zwraca ona obiekt typu Encoding. Aby sprawdziè nazwö (jako äaþcuch) kodowania znaków pochodzñcego od lokalizacji, nale y u yè metody Encoding.locale_ ´charmap; zawsze bazuje ona na ustawieniach dotyczñcych lokalizacji i ignoruje opcje wiersza poleceþ zmieniajñce domy lne kodowanie zewnötrzne. 2.5. Wykonywanie programu Ruby to jözyk skryptowy. Oznacza to, e programy Ruby sñ listami lub skryptami poleceþ do wykonania. Domy lnie polecenia sñ wykonywane sekwencyjnie w takiej kolejno ci, w jakiej zo- staäy napisane. Instrukcje sterujñce (opisane w rozdziale 5.) zmieniajñ tö domy lnñ kolejno è, po- zwalajñc na warunkowe wykonywanie niektórych instrukcji lub wielokrotne ich powtarzanie. 2.5. Wykonywanie programu _ 43

Programi ci przyzwyczajeni do tradycyjnych statycznych jözyków kompilowanych, jak C lub Java, mogñ byè nieco zbici z tropu. W Ruby nie ma specjalnej metody main, od której zaczyna siö wykonywanie. Interpreter Ruby otrzymuje skrypt instrukcji do wykonania i zaczyna je wy- konywaè od pierwszego do ostatniego wiersza. Ostatnie zdanie nie jest jednak do koþca prawdziwe, poniewa interpreter najpierw przeszu- kuje plik w celu znalezienia instrukcji BEGIN, których kod wykonuje najpierw. Nastöpnie wraca do pierwszego wiersza i zaczyna wykonywanie sekwencyjne. Wiöcej na temat instrukcji BEGIN znajduje siö w podrozdziale 5.7. Inna ró nica pomiödzy jözykiem Ruby a jözykami kompilowanymi dotyczy definicji modu- äów, klas i metod. W jözykach kompilowanych sñ to struktury syntaktyczne przetwarzane przez kompilator. W Ruby sñ to instrukcje jak wszystkie inne. Kiedy interpreter Ruby napotka definicjö klasy, wykonuje jñ, powodujñc powstanie nowej klasy. Podobnie kiedy napotka definicjö metody, wykonuje jñ, powodujñc powstanie nowej metody. W dalszej czö ci programu interpreter najprawdopodobniej znajdzie wyra enie wywoäujñce tö metodö, które spowoduje wykonanie instrukcji zawartych w ciele tej metody. Interpreter Ruby wywoäywany jest w wierszu poleceþ poprzez podanie mu skryptu do wykonania. Bardzo proste jednowierszowe skrypty wpisuje siö czasami bezpo rednio w wierszu poleceþ. Czö ciej jednak podaje siö nazwö pliku zawierajñcego skrypt. Interpreter Ruby od- czytuje plik i wykonuje znajdujñcy siö w nim skrypt. Najpierw wykonuje bloki BEGIN. Pó niej przechodzi do pierwszego wiersza pliku i dziaäa, dopóki nie wystñpi jedna z poni szych sytuacji: x Interpreter wykona polecenie, które spowoduje zakoþczenie programu. x Dojdzie do koþca pliku. x Dojdzie do wiersza oznaczajñcego logiczny koniec pliku za pomocñ tokenu _END_. Przed zakoþczeniem dziaäania interpreter Ruby zazwyczaj (je li nie zostaäa wywoäana metoda exit!) wykonuje ciaäa wszystkich znalezionych instrukcji END oraz pozostaäy kod zamkniöcia zarejestrowany za pomocñ funkcji at_exit. 44 _ Rozdzia 2. Struktura i uruchamianie programów Ruby

Ruby. Programowanie

0 comments

Notes on slide 1

Favorites, Groups & Events