Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00123 008875 11061555 na godz. na dobę w sumie
Ruby. Programowanie - książka
Ruby. Programowanie - książka
Autor: , Liczba stron: 408
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1767-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> ruby - programowanie
Porównaj ceny (książka, ebook, audiobook).

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!

Wykorzystaj elastyczność i możliwości języka Ruby!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

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(cid:156)ci Ruby! Zaprojektowany i stworzony w 1995 roku jŒzyk Ruby dziŒki swym unikalnym mo¿liwo(cid:156)ciom zdobywa sobie coraz wiŒksze uznanie programist(cid:243)w na ca‡ym (cid:156)wiecie. Jak uda‡o mu siŒ wkupi(cid:230) w ‡aski tego nieufnego (cid:156)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(cid:243)w. Dodatkowo ogromna i chŒtna do pomocy spo‡eczno(cid:156)(cid:230) sprawia, ¿e to rozwi„zanie staje siŒ jeszcze bardziej atrakcyjne. Uwaga! Jednym z autor(cid:243)w tej ksi„¿ki jest sam Yukihiro Matsumoto (cid:150) tw(cid:243)rca jŒzyka Ruby! Ksi„¿ka stanowi kompletny zbi(cid:243)r informacji na temat jŒzyka Ruby. Je(cid:156)li naprawdŒ chcesz zrozumie(cid:230) 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(cid:156)cia-wyj(cid:156)cia oraz prac„ wsp(cid:243)‡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 (cid:132)Ruby. Programowanie(cid:148) wykorzystanie metod i obiekt(cid:243)w klasy Proc oraz stosowanie platformy Ruby nie bŒdzie stanowi‡o dla Ciebie najmniejszego problemu! (cid:149) Wprowadzenie do jŒzyka Ruby (cid:149) Sposoby uruchamiania program(cid:243)w napisanych w Ruby (cid:149) DostŒpne typy danych (cid:149) Zastosowanie wyra¿eæ i operator(cid:243)w (cid:149) Sterowanie przep‡ywem (cid:149) Wykorzystanie iterator(cid:243)w oraz enumerator(cid:243)w (cid:149) Obs‡uga wyj„tk(cid:243)w (cid:149) Zastosowanie wsp(cid:243)‡bie¿no(cid:156)ci (cid:149) U¿ycie domkniŒ(cid:230) (cid:149) Cykl ¿ycia obiekt(cid:243)w (cid:149) Refleksje oraz metaprogramowanie (cid:149) Liczby w Ruby (cid:149) U¿ywanie wyra¿eæ regularnych (cid:149) Kolekcje (cid:149) Operacje na dacie i godzinie (cid:149) Tablice jedno- oraz wielowymiarowe (cid:149) Obs‡uga plik(cid:243)w oraz katalog(cid:243)w (cid:149) Programowanie sieciowe (cid:149) Obs‡uga (cid:156)rodowiska Ruby (cid:149) Gwarancja bezpieczeæstwa Wykorzystaj elastyczno(cid:156)(cid:230) i mo¿liwo(cid:156)ci jŒzyka Ruby! Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treļci Wstýp ........................................................................................................................................7 1. Wprowadzenie .............................................................................................................11 12 20 24 25 1.1. Krótki kurs jözyka Ruby 1.2. Wypróbuj jözyk Ruby 1.3. KsiñĔka — informacje 1.4. Program rozwiñzujñcy sudoku 2. Struktura i uruchamianie programów Ruby ............................................................... 31 32 39 40 41 43 2.1. Struktura leksykalna 2.2. Struktura syntaktyczna 2.3. Struktura plików 2.4. Kodowanie znaków 2.5. Wykonywanie programu 3. Typy danych i obiekty ..................................................................................................45 46 50 66 68 70 72 73 73 3.1. Liczby 3.2. Tekst 3.3. Tablice 3.4. Tablice asocjacyjne 3.5. Zakresy 3.6. Symbole 3.7. Säowa kluczowe true, false i nil 3.8. Obiekty 4. WyraŜenia i operatory .................................................................................................85 86 87 88 4.1. Literaäy i literaäy säów kluczowych 4.2. Odwoäania do zmiennych 4.3. Odwoäania do staäych 3 4.4. Wywoäania metod 4.5. Przypisania 4.6. Operatory 89 91 99 5. Instrukcje i przepĥyw sterowania ..............................................................................115 5.1. Instrukcje warunkowe 116 124 5.2. Pötle 126 5.3. Iteratory i obiekty przeliczalne 5.4. Bloki 136 141 5.5. Kontrola przepäywu sterowania 148 5.6. Wyjñtki i ich obsäuga 158 5.7. Instrukcje BEGIN i END 5.8. Wñtki, wäókna i kontynuacje 159 6. Metody, obiekty klasy Proc, lambdy i domkniýcia ................................................... 165 167 170 172 174 181 188 191 192 6.1. Definiowanie prostych metod 6.2. Nazwy metod 6.3. Nawiasy w metodach 6.4. Argumenty metod 6.5. Obiekty proc i lambda 6.6. Domkniöcia 6.7. Obiekty klasy Method 6.8. Programowanie funkcyjne 7. Klasy i moduĥy ............................................................................................................ 201 202 218 220 227 232 236 240 242 244 7.1. Definiowanie prostej klasy 7.2. WidocznoĈè metod — publiczne, chronione i prywatne 7.3. Tworzenie podklas i dziedziczenie 7.4. Tworzenie i inicjacja obiektów 7.5. Moduäy 7.6. Funkcje load i require 7.7. Metody singletonowe i klasa eigenclass 7.8. Wyszukiwanie metod 7.9. Wyszukiwanie staäych 8. Refleksja i metaprogramowanie ..............................................................................247 248 250 252 254 258 259 8.1. Typy, klasy i moduäy 8.2. Wykonywanie äaþcuchów i bloków 8.3. Zmienne i staäe 8.4. Metody 8.5. Metody zwrotne 8.6. ćledzenie 4 _ Spis treļci 8.7. Moduäy ObjectSpace i GC 8.8. Niestandardowe struktury sterujñce 8.9. Brakujñce metody i staäe 8.10. Dynamiczne tworzenie metod 8.11. Tworzenie äaþcuchów aliasów 8.12. Jözyki do wyspecjalizowanych zastosowaþ 261 262 264 267 269 274 9. Platforma Ruby ..........................................................................................................279 280 285 295 299 300 320 325 335 340 9.1. ãaþcuchy 9.2. WyraĔenia regularne 9.3. Liczby i matematyka 9.4. Data i godzina 9.5. Kolekcje 9.6. Pliki i katalogi 9.7. WejĈcie i wyjĈcie 9.8. Programowanie sieciowe 9.9. Wñtki i wspóäbieĔnoĈè 10. Ļrodowisko Ruby .......................................................................................................355 356 360 368 370 374 10.1. Uruchamianie interpretera Ruby 10.2. ćrodowisko najwyĔszego poziomu 10.3. Praktyczne skróty do ekstrakcji i raportowania 10.4. Wywoäywanie systemu operacyjnego 10.5. Bezpieczeþstwo 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 struktu- ry 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 igno- ruje 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 ta- kiego 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 wsta- wiania 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 ta- blic 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 skompli- kowana, 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 asocjacyj- nych 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 zmien- nych, 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 interpunk- cyjnych 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è po- przez wstawienie ich nazw bez znaku równoĈci po lewej stronie operatora przypisa- nia (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 komenta- rza 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 ela- styczny. 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 zare- zerwowane: # 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 od- dzielania, 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ö, zna- kiem 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 in- terpreter 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 in- strukcji 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 wy- raĔ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 instruk- cja 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 ist- nieje 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 kla- sy, 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 ro- dzaje 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 ozna- czane 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 pod- rozdziale 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 podroz- dziale 7.6. PoniĔszy kod ilustruje kaĔdy z wymienionych punktów struktury pliku z programem Ruby: #!/usr/bin/ruby -w # -*- coding: utf-8 -*- require socket ... __END__ ... Komentarz shebang. Komentarz okreĞlający kodowanie. Zaáadowanie biblioteki sieciowej. Kod programu. 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 ko- mentarze 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è do- wolne 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 kodo- wania 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 pod- kreĈ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 kodo- wania Ē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 pod- kreĈlenia) ewaluuje do kodowania Ēródäa aktualnie wykonywanego kodu. Powstaäa w wyni- ku 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 kodo- waniem 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 ustawia- ne 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 ko- dowanie Ē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 instruk- cji 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 napo- tka 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 progra- mu interpreter najprawdopodobniej znajdzie wyraĔenie wywoäujñce tö metodö, które spo- woduje wykonanie instrukcji zawartych w ciele tej metody. Interpreter Ruby wywoäywany jest w wierszu poleceþ poprzez podanie mu skryptu do wy- konania. 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
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Ruby. Programowanie
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: