Zbiór gotowych rozwiązań i porad dla programistów Ruby
Omówienie możliwości języka Ruby
Zasady komunikacji z bazami danych
Tworzenie interfejsów graficznych dla aplikacji
Testowanie kodu źródłowego
Ruby, obiektowy język programowania, opracowany na początku lat 90. ubiegłego wieku w
Japonii, cieszy się zasłużoną i stale rosnącą popularnością. Dziś Ruby
jest poważną konkurencją dla Perla i podstawowym fundamentem
technologii Ruby on Rails -- doskonałego narzędzia do szybkiego
tworzenia aplikacji i witryn internetowych. Prosta składnia, duże
możliwości, zwarta konstrukcja, rozbudowana i niezwykle wygodna obsługa
wyjątków oraz przetwarzania plików tekstowych
sprawiają, że po ten język programowania sięga coraz więcej
osób piszących oprogramowanie.
Książka 'Ruby. Tao programowania w 400 przykładach' to podręcznik
dla tych programistów, którzy poszukują metod
rozwiązywania konkretnych zadań programistycznych za pomocą Ruby. Na
ponad 400 przykładach przedstawiono w niej przeróżne
zastosowania i możliwości tego języka. Czytając ją, poznasz elementy
języka Ruby i zasady programowania obiektowego, techniki przetwarzania
łańcuchów tekstowych z zastosowaniem wyrażeń regularnych
oraz sposoby wykonywania nawet najbardziej złożonych operacji
matematycznych. Znajdziesz tu także omówienie metod
komunikacji z bazami danych, budowania graficznych
interfejsów użytkownika, programowania wielowątkowego i
pisania skryptów administracyjnych. Dowiesz się też, jak
korzystać z frameworka Ruby on Rails.
Programowanie obiektowe w Ruby
Przetwarzanie danych tekstowych
Obliczenia matematyczne
Internacjonalizacja aplikacji
Operacje na złożonych strukturach danych
Dynamiczne elementy języka Ruby
Tworzenie interfejsów graficznych dla aplikacji
Aplikacje wielowątkowe
Pobieranie danych z baz
Dystrybucja aplikacji
Testowanie
Tworzenie aplikacji internetowych w technologii Ruby on Rails
Przyspiesz proces tworzenia witryn i aplikacji z Ruby!
Darmowy fragment publikacji:
Ruby. Tao programowania
w 400 przyk‡adach
Autor: Hal Fulton
T‡umaczenie: Miko‡aj Szczepaniak
ISBN: 978-83-246-0958-1
Tytu‡ orygina‡u: The Ruby Way, Second Edition:
Solutions and Techniques in Ruby Programming
Format: B5, stron: 912
oprawa twarda
Przyk‡ady na ftp: 54 kB
Zbi(cid:243)r gotowych rozwi„zaæ i porad dla programist(cid:243)w Ruby
(cid:149) Om(cid:243)wienie mo¿liwo(cid:156)ci jŒzyka Ruby
(cid:149) Zasady komunikacji z bazami danych
(cid:149) Tworzenie interfejs(cid:243)w graficznych dla aplikacji
(cid:149) Testowanie kodu (cid:159)r(cid:243)d‡owego
Ruby, obiektowy jŒzyk programowania, opracowany na pocz„tku lat 90. ubieg‡ego
wieku w Japonii, cieszy siŒ zas‡u¿on„ i stale rosn„c„ popularno(cid:156)ci„. Dzi(cid:156) Ruby jest
powa¿n„ konkurencj„ dla Perla i podstawowym fundamentem technologii Ruby on Rails
-- doskona‡ego narzŒdzia do szybkiego tworzenia aplikacji i witryn internetowych.
Prosta sk‡adnia, du¿e mo¿liwo(cid:156)ci, zwarta konstrukcja, rozbudowana i niezwykle
wygodna obs‡uga wyj„tk(cid:243)w oraz przetwarzania plik(cid:243)w tekstowych sprawiaj„,
¿e po ten jŒzyk programowania siŒga coraz wiŒcej os(cid:243)b pisz„cych oprogramowanie.
Ksi„¿ka (cid:132)Ruby. Tao programowania w 400 przyk‡adach(cid:148) to podrŒcznik dla tych
programist(cid:243)w, kt(cid:243)rzy poszukuj„ metod rozwi„zywania konkretnych zadaæ
programistycznych za pomoc„ Ruby. Na ponad 400 przyk‡adach przedstawiono w niej
przer(cid:243)¿ne zastosowania i mo¿liwo(cid:156)ci tego jŒzyka. Czytaj„c j„, poznasz elementy jŒzyka
Ruby i zasady programowania obiektowego, techniki przetwarzania ‡aæcuch(cid:243)w
tekstowych z zastosowaniem wyra¿eæ regularnych oraz sposoby wykonywania nawet
najbardziej z‡o¿onych operacji matematycznych. Znajdziesz tu tak¿e om(cid:243)wienie metod
komunikacji z bazami danych, budowania graficznych interfejs(cid:243)w u¿ytkownika,
programowania wielow„tkowego i pisania skrypt(cid:243)w administracyjnych. Dowiesz siŒ te¿,
jak korzysta(cid:230) z frameworka Ruby on Rails.
(cid:149) Programowanie obiektowe w Ruby
(cid:149) Przetwarzanie danych tekstowych
(cid:149) Obliczenia matematyczne
(cid:149) Internacjonalizacja aplikacji
(cid:149) Operacje na z‡o¿onych strukturach danych
(cid:149) Dynamiczne elementy jŒzyka Ruby
(cid:149) Tworzenie interfejs(cid:243)w graficznych dla aplikacji
(cid:149) Aplikacje wielow„tkowe
(cid:149) Pobieranie danych z baz
(cid:149) Dystrybucja aplikacji
(cid:149) Testowanie
Tworzenie aplikacji internetowych w technologii Ruby on Rails
Przyspiesz proces tworzenia witryn i aplikacji z 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
5
SPIS TREŚCI
ROZDZIAŁ 1.
Słowo wstępne ..................................................................................................21
Podziękowania ..................................................................................................25
O autorze ............................................................................................................29
Wprowadzenie ..................................................................................................31
Przegląd języka Ruby ......................................................................................47
1.1. Wprowadzenie do programowania obiektowego ...........................48
1.1.1.
Czym jest obiekt? ...................................................................49
1.1.2. Dziedziczenie ..........................................................................50
1.1.3.
Polimorfizm .............................................................................53
1.1.4.
Kilka dodatkowych pojęć .....................................................54
Podstawy składni i semantyki języka Ruby .....................................55
1.2.1.
Słowa kluczowe i identyfikatory .........................................57
1.2.2. Komentarze i dokumentacja osadzana
1.2.
1.3.
w kodzie źródłowym .............................................................58
1.2.3.
Stałe, zmienne i typy .............................................................58
1.2.4. Operatory i priorytety operatorów .....................................61
Program przykładowy ..........................................................62
1.2.5.
1.2.6.
Pętle i struktury sterujące .....................................................65
1.2.7. Wyjątki .....................................................................................70
Programowanie obiektowe w języku Ruby ......................................73
1.3.1. Obiekty ....................................................................................74
1.3.2.
Klasy wbudowane .................................................................74
1.3.3. Moduły i klasy mieszane ......................................................76
1.3.4.
Tworzenie klas ........................................................................77
1.3.5. Metody i atrybuty ..................................................................82
1.4. Aspekty dynamiczne języka programowania Ruby .......................84
Kodowanie w czasie wykonywania ....................................85
1.4.1.
Refleksja ...................................................................................86
1.4.2.
1.4.3.
Brakujące metody ..................................................................88
1.4.4. Odzyskiwanie pamięci ..........................................................89
6
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
ROZDZIAŁ 2.
1.5. Ćwiczenie intuicji: o czym warto pamiętać ......................................90
1.5.1. Wybrane reguły składniowe ................................................90
1.5.2.
Różne spojrzenia na programowanie .................................93
1.5.3. Wyrażenie case języka Ruby ................................................97
1.5.4.
Rubyizmy i idiomy ............................................................... 100
1.5.5. Orientacja na wyrażenia i inne zagadnienia ................... 106
Żargon języka Ruby ............................................................................ 108
1.6.
Konkluzja .............................................................................................. 112
1.7.
Praca z łańcuchami .........................................................................................113
2.1. Reprezentowanie typowych łańcuchów ......................................... 114
2.2. Reprezentowanie łańcuchów w notacjach alternatywnych ........ 115
2.3. Stosowanie dokumentu wbudowanego ......................................... 115
2.4. Określanie długości łańcuchów ........................................................ 118
2.5. Przetwarzanie po jednym wierszu w każdej iteracji .................... 118
2.6. Przetwarzanie po jednym bajcie w każdej iteracji ........................ 118
2.7. Stosowanie wyspecjalizowanych technik
porównywania łańcuchów ................................................................ 119
2.8. Dzielenie łańcuchów na tokeny ....................................................... 121
2.9.
Formatowanie łańcuchów ................................................................. 122
2.10. Stosowanie łańcuchów w roli obiektów wejścia-wyjścia ............. 123
2.11. Konwersja wielkich i małych liter .................................................... 123
2.12. Uzyskiwanie dostępu i przypisywanie podłańcuchów ................ 125
2.13. Zamiana łańcuchów ........................................................................... 127
2.14. Przeszukiwanie łańcuchów ............................................................... 128
2.15. Konwertowanie znaków na kody ASCII ......................................... 129
2.16. Konwersja jawna i niejawna ............................................................. 129
2.17. Dołączanie elementów do łańcuchów ............................................. 132
2.18. Usuwanie końcowych znaków nowego wiersza
i innych symboli specjalnych ............................................................ 133
2.19. Usuwanie znaków białych z początku i końca łańcucha ............. 134
2.20. Powielanie łańcuchów ........................................................................ 134
2.21. Osadzanie wyrażeń w ramach łańcuchów ..................................... 135
2.22. Opóźnianie przetwarzania łańcuchów ........................................... 135
2.23. Analiza składniowa danych oddzielonych przecinkami .............. 136
2.24. Konwertowanie łańcuchów na liczby (dziesiętne i inne) ............. 137
2.25. Kodowanie i dekodowanie tekstu szyfrowanego
za pomocą metody rot13 .................................................................... 139
2.26. Szyfrowanie łańcuchów ..................................................................... 140
2.27. Kompresja łańcuchów ........................................................................ 141
2.28. Wyznaczanie liczby wystąpień znaków w łańcuchach ................ 142
2.29. Odwracanie kolejności znaków w łańcuchu .................................. 142
2.30. Usuwanie powtarzających się znaków ............................................ 143
2.31. Usuwanie określonych znaków ........................................................ 143
2.32. Wyświetlanie znaków specjalnych .................................................. 143
SPIS TREŚCI
7
ROZDZIAŁ 3.
2.33. Generowanie kolejnych łańcuchów .................................................. 144
2.34. Wyznaczanie 32-bitowych sum CRC ............................................... 144
2.35. Wyznaczanie kodów MD5 dla łańcuchów ..................................... 145
2.36. Wyznaczanie odległości Levenshteina dzielącej dwa łańcuchy ...... 146
2.37. Kodowanie i dekodowanie łańcuchów w formacie base64 ......... 148
2.38. Kodowanie i dekodowanie łańcuchów
za pomocą narzędzi uuencode oraz uudecode .............................. 149
2.39. Rozszerzanie i kompresja znaków tabulacji ................................... 149
2.40. Opakowywanie wierszy tekstu ........................................................ 150
2.41. Konkluzja .............................................................................................. 151
Praca z wyrażeniami regularnymi ...............................................................153
3.1.
Składnia wyrażeń regularnych ......................................................... 154
3.2. Kompilowanie wyrażeń regularnych .............................................. 156
Stosowanie znaków specjalnych ...................................................... 157
3.3.
Stosowanie tzw. kotwic ...................................................................... 157
3.4.
3.5.
Stosowanie kwantyfikatorów ............................................................ 158
3.6.
Antycypacja dodatnia i ujemna ........................................................ 160
3.7. Uzyskiwanie dostępu do referencji wstecznych ............................ 161
Stosowanie klas znaków .................................................................... 165
3.8.
3.9.
Rozszerzone wyrażenia regularne ................................................... 166
3.10. Dopasowywanie znaku nowego wiersza do kropki ..................... 167
3.11. Stosowanie opcji osadzanych ............................................................ 168
3.12. Stosowanie podwyrażeń osadzanych ............................................. 169
3.13. Ruby i Oniguruma .............................................................................. 169
3.13.1. Testowanie dostępności mechanizmu Oniguruma ....... 170
3.13.2. Kompilacja silnika Oniguruma .......................................... 171
3.13.3. Przegląd wybranych nowości
zaimplementowanych w silniku Oniguruma ................. 172
3.13.4.
Dodatnia i ujemna antycypacja wsteczna ...................... 172
3.13.5. Więcej o kwantyfikatorach ................................................. 174
3.13.6. Dopasowania nazwane ....................................................... 174
3.13.7. Rekurencja w wyrażeniach regularnych ......................... 176
3.14. Kilka przykładowych wyrażeń regularnych .................................. 177
3.14.1. Dopasowywanie adresów IP .............................................. 177
3.14.2. Dopasowywanie par klucz-wartość .................................. 178
3.14.3. Dopasowywanie liczb rzymskich ...................................... 179
3.14.4. Dopasowywanie stałych numerycznych ......................... 179
3.14.5. Dopasowywanie łańcuchów zawierających datę
i godzinę ................................................................................ 180
3.14.6. Wykrywanie powtarzających się
wyrazów w tekście ............................................................... 181
3.14.7. Dopasowywanie słów pisanych wielkimi literami ......... 181
3.14.8. Dopasowywanie numerów wersji .................................... 182
3.14.9. Kilka dodatkowych wzorców ............................................ 182
3.15. Konkluzja .............................................................................................. 183
8
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
ROZDZIAŁ 4. Umiędzynaradawianie aplikacji Ruby .......................................................185
4.1. Wstęp teoretyczny i terminologia .................................................... 187
4.2. Kodowanie znaków we współczesnym świecie
(po rezygnacji ze standardu ASCII) ................................................. 191
Biblioteka jcode i zmienna globalna $KCODE ................ 192
4.2.1.
Ponowne spojrzenie na popularne operacje
4.2.2.
na łańcuchach i wyrażeniach regularnych ...................... 193
4.2.3. Wykrywanie schematów kodowania znaków ................ 198
4.2.4. Normalizacja łańcuchów Unicode .................................... 198
4.2.5.
Problemy związane z porządkowaniem łańcuchów ..... 200
4.2.6. Konwertowanie łańcuchów zakodowanych
4.3.
według różnych schematów .............................................. 204
Stosowanie katalogów komunikatów .............................................. 207
4.3.1. Wstęp teoretyczny i terminologia ..................................... 207
Pierwsze kroki w świecie katalogów komunikatów ...... 208
4.3.2.
Lokalizacja prostej aplikacji ................................................ 209
4.3.3.
4.3.4.
Informacje dodatkowe ........................................................ 214
4.4. Konkluzja .............................................................................................. 215
ROZDZIAŁ 5. Wykonywanie obliczeń numerycznych .....................................................217
5.1. Reprezentowanie liczb w języku Ruby ........................................... 218
5.2.
Podstawowe operacje na liczbach .................................................... 219
5.3. Zaokrąglanie liczb zmiennoprzecinkowych ................................... 220
Porównywanie liczb zmiennoprzecinkowych ............................... 222
5.4.
Formatowanie liczb przeznaczonych do wyświetlenia ................ 223
5.5.
5.6.
Formatowanie liczb z separatorami tysięcy .................................... 224
Praca z bardzo dużymi liczbami całkowitymi ................................ 225
5.7.
Stosowanie typu BigDecimal ............................................................ 225
5.8.
5.9.
Praca z liczbami wymiernymi ........................................................... 227
5.10. Operacje na macierzach ..................................................................... 228
5.11. Praca z liczbami zespolonymi ........................................................... 233
5.12. Stosowanie biblioteki mathn ............................................................. 234
5.13. Rozkład na czynniki pierwsze, największy wspólny dzielnik
i najmniejsza wspólna wielokrotność .............................................. 235
5.14. Praca z liczbami pierwszymi ............................................................. 236
5.15. Niejawna i bezpośrednia konwersja numeryczna ........................ 237
5.16. Koercja wartości numerycznych ...................................................... 238
5.17. Wykonywanie operacji bitowych na liczbach ................................ 240
5.18. Konwersje pomiędzy systemami liczbowymi ................................ 241
5.19. Wyznaczanie pierwiastków sześciennych, czwartego
stopnia, piątego stopnia itd. .............................................................. 242
5.20. Określanie porządku bajtów obowiązującego
w danej architekturze ......................................................................... 243
5.21. Numeryczna metoda wyznaczania całki oznaczonej ................... 244
5.22. Trygonometria w stopniach, radianach i gradach ......................... 245
SPIS TREŚCI
9
5.23. Bardziej zaawansowane funkcje trygonometryczne .................... 247
5.24. Wyznaczanie logarytmów o dowolnych podstawach .................. 247
5.25. Wyznaczanie wartości średniej, mediany
i mody zbioru danych ........................................................................ 248
5.26. Wariancja i odchylenie standardowe .............................................. 249
5.27. Wyznaczanie współczynnika korelacji ............................................ 250
5.28. Generowanie liczb losowych ............................................................. 251
5.29. Składowanie wyników funkcji w pamięci podręcznej
ROZDZIAŁ 6.
ROZDZIAŁ 7.
6.2.
za pomocą biblioteki memoize .......................................................... 252
5.30. Konkluzja ................................................................................................. 254
Symbole i przedziały .....................................................................................255
6.1.
Symbole ................................................................................................ 256
Symbole jako typy wyliczeniowe ...................................... 258
6.1.1.
Symbole jako metawartości ................................................ 258
6.1.2.
6.1.3.
Symbole, zmienne i metody ............................................... 259
6.1.4. Konwertowanie na symbole i z symboli .......................... 260
Przedziały ............................................................................................. 261
6.2.1.
Przedziały otwarte i domknięte ......................................... 262
6.2.2. Wyznaczanie punktów końcowych .................................. 262
6.2.3.
Iteracyjne przeszukiwanie przedziałów .......................... 263
6.2.4.
Sprawdzanie przynależności do przedziałów ................ 264
6.2.5. Konwertowanie przedziałów na tablice ........................... 264
6.2.6.
Przedziały odwrotne ........................................................... 265
6.2.7. Operator przerzutnikowy .................................................. 265
6.2.8.
Przedziały niestandardowe ................................................ 269
6.3. Konkluzja ................................................................................................... 272
Praca z datami i godzinami ...........................................................................273
7.1. Określanie bieżącej godziny .............................................................. 274
7.2.
Praca z określonymi datami i godzinami
(począwszy od punktu nazywanego epoką) .................................. 275
7.3. Określanie dnia tygodnia .................................................................. 276
7.4. Określanie daty Wielkanocy ............................................................. 277
7.5. Określanie daty n-tego dnia tygodnia w danym miesiącu .......... 277
7.6. Konwersja pomiędzy sekundami
a większymi jednostkami czasu ........................................................ 279
7.7. Konwersja daty i godziny do postaci i z postaci epoki ................. 280
7.8.
Praca z sekundami przestępnymi
— nie róbcie tego w domu! ................................................................ 280
7.9. Wyznaczanie numeru dnia w danym roku .................................... 281
7.10. Sprawdzanie poprawności daty i godziny ..................................... 281
7.11. Określanie numeru tygodnia w danym roku ................................ 283
7.12. Wykrywanie roku przestępnego ...................................................... 284
7.13. Określanie strefy czasowej ................................................................ 285
10
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
ROZDZIAŁ 8.
7.14. Praca z samymi godzinami i minutami ........................................... 285
7.15. Porównywanie wartości reprezentujących daty i godziny .......... 285
7.16. Dodawanie i odejmowanie przedziałów czasowych
do i od wartości reprezentujących daty i godziny ........................ 286
7.17. Wyznaczanie różnic dzielących dwie wartości
reprezentujące daty i godziny .......................................................... 287
7.18. Praca z określonymi datami i godzinami
(sprzed punktu nazywanego epoką) ............................................... 287
7.19. Wzajemna konwersja obiektów klasy Time, Date
oraz DateTime ...................................................................................... 288
7.20. Odczytywanie daty i godziny z łańcucha wejściowego ............... 289
7.21. Formatowanie i wyświetlanie daty i godziny ................................ 291
7.22. Konwersja stref czasowych ............................................................... 292
7.23. Określanie liczby dni danego miesiąca ........................................... 292
7.24. Dzielenie miesiąca na tygodnie ........................................................ 293
7.25. Konkluzja .............................................................................................. 294
Tablice, tablice mieszające i inne wyliczeniowe struktury danych .....295
Praca z tablicami .................................................................................. 296
8.1.
8.1.1.
Tworzenie i inicjalizacja tablic ........................................... 296
8.1.2. Uzyskiwanie dostępu i przypisywanie wartości
8.1.7.
elementom tablicy ................................................................ 297
8.1.3. Określanie rozmiaru tablicy ............................................... 299
Porównywanie tablic ........................................................... 299
8.1.4.
Sortowanie elementów tablicy ........................................... 301
8.1.5.
8.1.6.
Selekcja elementów tablicy
według określonych kryteriów .......................................... 304
Stosowanie wyspecjalizowanych
funkcji indeksujących .......................................................... 306
Implementacja macierzy rzadkich .................................... 308
8.1.8.
8.1.9.
Stosowanie tablic w roli zbiorów matematycznych ....... 309
8.1.10. Losowe porządkowanie elementów tablicy .................... 313
8.1.11. Stosowanie tablic wielowymiarowych ............................. 314
8.1.12.
Identyfikacja tych elementów jednej tablicy,
które nie występują w innej tablicy .................................. 315
8.1.13. Transformowanie i odwzorowywanie tablic ................... 315
8.1.14. Usuwanie wartości nil z tablicy ......................................... 316
8.1.15. Usuwanie określonych elementów tablicy ...................... 316
8.1.16. Konkatenacja i dołączanie tablic ........................................ 317
8.1.17. Stosowanie tablic w roli stosów i kolejek ......................... 318
8.1.18.
Iteracyjne przeszukiwanie tablic ....................................... 319
8.1.19. Wstawianie separatorów uwzględnianych
w łańcuchu wynikowym .................................................... 320
8.1.20. Odwracanie kolejności elementów tablicy ...................... 320
8.1.21. Usuwanie z tablicy powtarzających się elementów ....... 320
SPIS TREŚCI
11
8.1.22. Przeplatanie tablic ................................................................ 321
8.1.23. Zliczanie częstotliwości występowania
poszczególnych wartości w tablicy ................................... 321
8.1.24. Odwracanie kierunku relacji w tablicy
8.2.
przez tworzenie odpowiedniej tablicy mieszającej ........ 321
8.1.25. Zsynchronizowane sortowanie wielu tablic .................... 322
8.1.26. Określanie wartości domyślnej
dla nowych elementów tablicy .......................................... 323
Praca z tablicami mieszającymi ......................................................... 324
8.2.1.
Tworzenie nowych tablic mieszających ........................... 324
8.2.2. Określanie wartości domyślnej
dla tablicy mieszającej ......................................................... 325
8.2.3. Uzyskiwanie dostępu i dodawanie par
klucz-wartość ........................................................................ 326
8.2.4. Usuwanie par klucz-wartość .............................................. 327
8.2.5.
Iteracyjne przeszukiwanie tablicy mieszającej ................ 328
8.2.6. Odwracanie związków w tablicy mieszającej ................. 328
8.2.7. Wykrywanie kluczy i wartości w tablicy mieszającej ...... 329
8.2.8. Konwersja tablic mieszających na tablice ........................ 329
8.2.9. Wyodrębnianie par klucz-wartość
według określonych kryteriów .......................................... 330
8.2.10. Sortowanie tablicy mieszającej .......................................... 330
8.2.11. Scalanie dwóch tablic mieszających .................................. 331
8.2.12. Tworzenie tablic mieszających na podstawie tablic ....... 331
8.2.13. Wyznaczanie różnicy i iloczynu (części wspólnej)
kluczy zbioru tablic mieszających ..................................... 331
8.2.14. Stosowanie tablic mieszających w roli reprezentacji
8.2.15.
macierzy rzadkich ................................................................ 332
Implementacja tablic mieszających obsługujących
powtarzające się klucze ....................................................... 333
8.3. Ogólne omówienie typów wyliczeniowych ................................... 336
8.3.1. Metoda inject ........................................................................ 337
8.3.2.
Stosowanie kwalifikatorów ................................................ 338
8.3.3. Metoda partition .................................................................. 339
8.3.4.
Iteracyjne przeszukiwanie kolekcji
grupami elementów ............................................................ 340
8.3.5. Konwersja tablic na zbiory ................................................. 341
Stosowanie obiektów klasy Enumerator .......................... 341
8.3.6.
8.3.7.
Stosowanie obiektów klasy Generator ............................. 343
8.4. Konkluzja ................................................................................................... 344
Zaawansowane struktury danych ...............................................................347
Praca ze zbiorami ................................................................................ 348
9.1.
9.1.1.
Proste operacje na zbiorach ................................................ 348
9.1.2. Zaawansowane operacje na zbiorach ............................... 350
ROZDZIAŁ 9.
12
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
9.2.
9.3.
9.4.
Praca ze stosami i kolejkami .............................................................. 351
9.2.1.
Implementacja stosu wymuszającego
właściwy dostęp do danych ............................................... 353
9.2.2. Wykrywanie niezbilansowanych
9.2.3.
9.2.4.
znaków interpunkcyjnych w wyrażeniach ..................... 354
Stosy i rekurencja ................................................................. 355
Implementacja kolejki wymuszającej
właściwy dostęp do danych ............................................... 357
Praca z drzewami ................................................................................ 358
Implementacja drzewa binarnego .................................... 359
9.3.1.
Sortowanie danych z wykorzystaniem
9.3.2.
drzewa binarnego ................................................................ 361
Stosowanie drzewa binarnego
w roli tablicy wyszukiwania ............................................... 363
9.3.4. Konwersja drzewa na łańcuch lub tablicę ....................... 364
Praca z grafami .................................................................................... 365
9.4.1.
Implementacja grafu w formie macierzy sąsiedztwa ...... 366
9.4.2. Określanie, czy wszystkie węzły grafu
9.3.3.
są z nim połączone ............................................................... 368
9.4.3. Określanie, czy dany graf zawiera cykl Eulera ............... 370
9.4.4. Określanie, czy dany graf zawiera ścieżkę Eulera .......... 371
9.4.5. Narzędzia ułatwiające operacje na grafach
w języku Ruby ...................................................................... 371
9.5. Konkluzja .............................................................................................. 372
ROZDZIAŁ 10. Operacje wejścia-wyjścia i techniki składowania danych .....................373
10.1. Praca z plikami i katalogami .............................................................. 375
10.1.1. Otwieranie i zamykanie plików ........................................ 375
10.1.2. Aktualizacja pliku ................................................................. 377
10.1.3. Dopisywanie danych do istniejącego pliku ..................... 377
10.1.4. Swobodny dostęp do zawartości plików ......................... 377
10.1.5. Praca z plikami binarnymi .................................................. 378
10.1.6. Blokowanie dostępu do plików ......................................... 380
10.1.7. Wykonywanie prostych operacji wejścia-wyjścia .......... 381
10.1.8. Wykonywanie buforowanych
i niebuforowanych operacji wejścia-wyjścia ................... 382
10.1.9. Modyfikowanie uprawnień dostępu
i praw własności do plików ................................................ 383
10.1.10. Uzyskiwanie i ustawianie informacji o znacznikach
czasowych ............................................................................. 385
10.1.11. Weryfikacja istnienia i rozmiaru pliku ............................. 387
10.1.12. Weryfikacja specjalnych charakterystyk plików ............ 388
10.1.13. Praca z potokami .................................................................. 390
10.1.14. Wykonywanie specjalnych operacji wejścia-wyjścia ....... 392
10.1.15. Stosowanie nieblokujących operacji wejścia-wyjścia ....... 393
10.1.16. Stosowanie metody readpartial ......................................... 393
SPIS TREŚCI
13
10.1.17. Modyfikowanie ścieżek do plików ................................... 394
10.1.18. Stosowanie klasy Pathname ............................................... 395
10.1.19. Wykonywanie operacji na plikach
na poziomie poleceń ............................................................ 396
10.1.20. Przechwytywanie znaków z klawiatury .......................... 398
10.1.21. Odczytywanie i umieszczanie w pamięci
całych plików ........................................................................ 399
10.1.22. Iteracyjne przeszukiwanie pliku wejściowego
wiersz po wierszu ................................................................ 399
10.1.23. Iteracyjne przeszukiwanie pliku wejściowego
bajt po bajcie ......................................................................... 400
10.1.24. Traktowanie łańcuchów jak plików .................................. 400
10.1.25. Odczytywanie danych osadzonych
w kodzie źródłowym programu ........................................ 401
10.1.26. Odczytywanie kodu źródłowego programu ................... 401
10.1.27. Praca z plikami tymczasowymi ......................................... 402
10.1.28. Zmienianie i ustawianie katalogu bieżącego ................... 403
10.1.29. Zmiana bieżącego katalogu głównego ............................. 403
10.1.30. Iteracyjne przeszukiwanie listy plików
i podkatalogów ..................................................................... 404
10.1.31. Uzyskiwanie listy plików i podkatalogów ....................... 404
10.1.32. Tworzenie łańcucha katalogów ......................................... 404
10.1.33. Rekurencyjne usuwanie katalogów .................................. 405
10.1.34. Odnajdywanie plików i katalogów ................................... 405
10.2. Uzyskiwanie dostępu do danych na wyższym poziomie ............ 406
10.2.1. Proste utrwalanie obiektów ................................................ 406
10.2.2. Bardziej złożone utrwalanie obiektów ............................. 408
10.2.3. Sporządzanie „głębokiej kopii”
w ograniczonej formie ......................................................... 409
10.2.4. Udoskonalone utrwalanie obiektów
za pomocą biblioteki PStore ............................................... 409
10.2.5. Praca z danymi CSV ............................................................ 411
10.2.6. Utrwalanie danych z wykorzystaniem
formatu YAML ...................................................................... 413
10.2.7. Przezroczysta architektura utrwalania obiektów
za pomocą projektu Madeleine ......................................... 414
10.2.8. Stosowanie biblioteki DBM ................................................ 415
10.3. Stosowanie biblioteki KirbyBase ....................................................... 417
10.4. Nawiązywanie połączeń z zewnętrznymi bazami danych .......... 420
10.4.1. Korzystanie z interfejsu bazy danych SQLite ................. 421
10.4.2. Korzystanie z interfejsu bazy danych MySQL ................ 422
10.4.3. Korzystanie z interfejsu bazy danych PostgreSQL ........ 425
10.4.4. Korzystanie z interfejsu do protokołu LDAP .................. 429
10.4.5. Korzystanie z interfejsu bazy danych Oracle .................. 430
14
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
10.4.6. Stosowanie opakowania DBI ............................................. 432
10.4.7. Mechanizmy odwzorowań obiektowo-relacyjnych ....... 433
10.5. Konkluzja ................................................................................................. 435
ROZDZIAŁ 11. Programowanie obiektowe i dynamiczne elementy języka Ruby ........437
11.1. Programowanie obiektowe w codziennej pracy ............................ 438
11.1.1. Stosowanie wielu konstruktorów ...................................... 439
11.1.2. Tworzenie atrybutów egzemplarzy .................................. 440
11.1.3. Stosowanie bardziej złożonych konstruktorów .............. 441
11.1.4. Tworzenie atrybutów i metod na poziomie klas ............ 443
11.1.5. Dziedziczenie po nadklasie ................................................ 447
11.1.6. Testowanie klas obiektów ................................................... 449
11.1.7. Testowanie równości obiektów ......................................... 452
11.1.8. Kontrola dostępu do metod ............................................... 453
11.1.9. Kopiowanie obiektów ......................................................... 455
11.1.10. Stosowanie metody initialize_copy .................................. 457
11.1.11. Wyjaśnienie znaczenia metody allocate ........................... 458
11.1.12. Praca z modułami ................................................................ 459
11.1.13. Transformowanie i konwertowanie obiektów ................ 462
11.1.14. Tworzenie klas (struktur)
zawierających wyłącznie dane .......................................... 466
11.1.15. Zamrażanie obiektów .......................................................... 467
11.2. Techniki zaawansowane .................................................................... 469
11.2.1. Wysyłanie obiektom komunikatów
wyrażonych wprost ............................................................. 469
11.2.2. Specjalizacja pojedynczych obiektów .............................. 471
11.2.3. Zagnieżdżanie klas i modułów .......................................... 475
11.2.4. Tworzenie klas parametrycznych ..................................... 476
11.2.5. Stosowanie kontynuacji
w implementacji generatora ............................................... 479
11.2.6. Składowanie kodu w formie obiektów ............................. 481
11.2.7. Omówienie mechanizmu zawierania modułów ............ 483
11.2.8. Wykrywanie parametrów domyślnych ........................... 485
11.2.9. Delegowanie wywołań i przekazywanie ich dalej ......... 486
11.2.10. Automatyczne definiowanie metod odczytujących
i zapisujących na poziomie klasy ...................................... 488
11.2.11. Stosowanie zaawansowanych
technik programistycznych ................................................ 490
11.3. Praca z elementami dynamicznymi języka Ruby .......................... 493
11.3.1. Dynamiczne przetwarzanie kodu ..................................... 494
11.3.2. Stosowanie metody const_get ........................................... 495
11.3.3. Dynamiczne tworzenie egzemplarzy klasy
reprezentowanej przez nazwę ........................................... 496
11.3.4. Zwracanie i ustawianie zmiennych egzemplarzy .......... 497
11.3.5. Stosowanie wyrażenia define_method ............................ 498
SPIS TREŚCI
15
ROZDZIAŁ 12.
11.3.6. Stosowanie metody const_missing ................................... 502
11.3.7. Usuwanie definicji ............................................................... 503
11.3.8. Generowanie list zdefiniowanych konstrukcji ............... 505
11.3.9. Analiza stosu wywołań ....................................................... 507
11.3.10. Monitorowanie wykonywania programu ....................... 508
11.3.11. Przeszukiwanie przestrzeni obiektów .............................. 510
11.3.12. Obsługa wywołań nieistniejących metod ........................ 510
11.3.13. Śledzenie zmian w definicji klasy lub obiektu ................ 511
11.3.14. Definiowanie finalizatorów obiektów .............................. 515
11.4. Konkluzja ................................................................................................. 517
Interfejsy graficzne dla Ruby .......................................................................519
12.1. Ruby i Tk ............................................................................................... 520
12.1.1. Wprowadzenie ..................................................................... 521
12.1.2. Prosta aplikacja okienkowa ................................................ 522
12.1.3. Praca z przyciskami ............................................................. 524
12.1.4. Praca z polami tekstowymi ................................................. 528
12.1.5. Praca z pozostałymi rodzajami kontrolek ........................ 532
Informacje dodatkowe ........................................................ 536
12.1.6.
12.2. Ruby i GTK2 ......................................................................................... 537
12.2.1. Wprowadzenie ..................................................................... 537
12.2.2. Prosta aplikacja okienkowa ................................................ 538
12.2.3. Praca z przyciskami ............................................................. 540
12.2.4. Praca z polami tekstowymi ................................................. 542
12.2.5. Praca z pozostałymi rodzajami kontrolek ........................ 545
12.2.6.
Informacje dodatkowe ........................................................ 550
12.3. FXRuby (FOX) ...................................................................................... 553
12.3.1. Wprowadzenie ..................................................................... 553
12.3.2. Prosta aplikacja okienkowa ................................................ 555
12.3.3. Praca z przyciskami ............................................................. 556
12.3.4. Praca z polami tekstowymi ................................................. 558
12.3.5. Praca z pozostałymi rodzajami kontrolek ........................ 560
12.3.6.
Informacje dodatkowe ........................................................ 569
12.4. QtRuby .................................................................................................. 570
12.4.1. Wprowadzenie ..................................................................... 570
12.4.2. Prosta aplikacja okienkowa ................................................ 571
12.4.3. Praca z przyciskami ............................................................. 572
12.4.4. Praca z polami tekstowymi ................................................. 574
12.4.5. Praca z pozostałymi rodzajami kontrolek ........................ 576
Informacje dodatkowe ........................................................ 581
12.4.6.
12.5. Pozostałe zestawy narzędzi GUI ......................................................... 582
12.5.1. Ruby i środowisko X ............................................................ 582
12.5.2. Ruby i system wxWidgets ................................................... 583
12.5.3. Apollo (Ruby i Delphi) ........................................................ 583
12.5.4. Ruby i interfejs Windows API ............................................ 584
12.6. Konkluzja ................................................................................................. 584
16
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
ROZDZIAŁ 13. Wątki w języku Ruby ....................................................................................585
13.1. Tworzenie wątków i zarządzanie nimi ........................................... 586
13.1.1. Tworzenie wątków .............................................................. 587
13.1.2. Uzyskiwanie dostępu do zmiennych
lokalnych wątków ................................................................ 588
13.1.3. Sprawdzanie i modyfikowanie stanu wątku ................... 590
13.1.4. Oczekiwanie na wątek potomny
(i przechwytywanie zwracanej wartości) ........................ 593
13.1.5. Obsługa wyjątków ............................................................... 595
13.1.6. Stosowanie grup wątków ................................................... 596
13.2. Synchronizacja wątków ..................................................................... 597
13.2.1. Proste synchronizowanie wątków
z wykorzystaniem sekcji krytycznych .............................. 599
13.2.2. Synchronizacja dostępu do zasobów
(biblioteka mutex.rb) ............................................................ 600
13.2.3. Stosowanie predefiniowanych klas
kolejek synchronizowanych ............................................... 604
13.2.4. Stosowanie zmiennych warunkowych ............................ 605
13.2.5. Stosowanie pozostałych technik synchronizacji ............. 607
13.2.6. Stosowanie limitów czasowych dla operacji ................... 610
13.2.7. Oczekiwanie na zdarzenia ................................................. 611
13.2.8. Kontynuacja przetwarzania
w czasie wykonywania operacji wejścia-wyjścia ........... 612
Implementacja iteratorów równoległych ......................... 613
13.2.9.
13.2.10. Rekurencyjne, równoległe usuwanie
plików i katalogów ............................................................... 615
13.3. Konkluzja .............................................................................................. 616
ROZDZIAŁ 14. Tworzenie skryptów i administracja systemem .......................................617
14.1. Uruchamianie programów zewnętrznych ...................................... 618
14.1.1. Stosowanie metod system i exec ....................................... 618
14.1.2. Przechwytywanie danych wyjściowych
wykonywanego polecenia .................................................. 620
14.1.3. Operacje na procesach ........................................................ 621
14.1.4. Operacje na standardowym wejściu-wyjściu ................. 624
14.2. Opcje i argumenty wiersza poleceń ................................................. 624
14.2.1. Analiza składniowa opcji wiersza poleceń ...................... 625
14.2.2. Stała ARGF ............................................................................ 627
14.2.3. Stała ARGV ............................................................................ 628
14.3. Biblioteka Shell .................................................................................... 629
14.3.1. Przekierowywanie wejścia-wyjścia
za pomocą klasy Shell .......................................................... 629
Informacje dodatkowe o bibliotece shell.rb ..................... 631
14.3.2.
SPIS TREŚCI
17
14.4. Uzyskiwanie dostępu do zmiennych środowiskowych ............... 632
14.4.1. Odczytywanie i ustawianie wartości
zmiennych środowiskowych ............................................. 632
14.4.2. Składowanie zmiennych środowiskowych
14.4.3.
w formie tablic lub tablic mieszających ............................ 633
Importowanie zmiennych środowiskowych
do postaci zmiennych globalnych aplikacji ..................... 634
14.5. Wykonywanie skryptów w systemach Microsoft Windows ....... 635
14.5.1. Stosowanie biblioteki Win32API ........................................ 636
14.5.2. Stosowanie biblioteki Win32OLE ...................................... 637
14.5.3. Stosowanie interfejsu ActiveScriptRuby .......................... 640
14.6. Wygodny instalator dla systemu Windows .................................... 641
14.7. Biblioteki, które warto znać ............................................................... 643
14.8. Praca z plikami, katalogami i drzewami .......................................... 644
14.8.1. Kilka słów o filtrach tekstu ................................................. 644
14.8.2. Kopiowanie drzewa katalogów
(obejmującego dowiązania symetryczne) ........................ 645
14.8.3. Usuwanie plików według wieku i innych kryteriów ...... 647
14.8.4. Określanie ilości wolnej przestrzeni na dysku ................ 648
14.9. Rozmaite zadania realizowane za pomocą skryptów ................... 648
14.9.1. Programy języka Ruby w formie
pojedynczych plików .......................................................... 649
14.9.2. Kierowanie potoku do interpretera języka Ruby ........... 650
14.9.3. Uzyskiwanie i ustawianie kodów wyjścia ....................... 651
14.9.4. Sprawdzanie, czy dany program pracuje w trybie
interaktywnym ..................................................................... 652
14.9.5. Określanie bieżącej platformy
lub systemu operacyjnego .................................................. 652
14.9.6. Stosowanie modułu Etc ...................................................... 653
14.10. Konkluzja .............................................................................................. 654
ROZDZIAŁ 15. Ruby i formaty danych ..................................................................................655
15.1. Analiza składniowa danych w formacie XML
za pomocą biblioteki REXML ............................................................ 656
15.1.1. Analiza składniowa z wykorzystaniem
struktury drzewa .................................................................. 658
15.1.2. Analiza składniowa danych w formie strumienia .......... 659
15.1.3.
Język XPath i inne ................................................................ 660
15.2. Praca z formatami RSS i Atom .......................................................... 661
15.2.1. Biblioteka standardowa rss ................................................. 661
15.2.2. Biblioteka feedtools .............................................................. 664
15.3. Operowanie na obrazach za pośrednictwem
biblioteki RMagick ............................................................................... 666
15.3.1. Typowe operacje na obrazach ........................................... 667
15.3.2. Przekształcenia i efekty specjalne ..................................... 670
15.3.3.
Interfejs API umożliwiający rysowanie ............................ 672
18
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
15.4. Tworzenie dokumentów PDF
za pomocą biblioteki PDF::Writer .................................................... 677
15.4.1. Podstawowe pojęcia i techniki ........................................... 677
15.4.2. Dokument przykładowy ..................................................... 679
15.5. Konkluzja .............................................................................................. 687
ROZDZIAŁ 16. Testowanie i diagnozowanie oprogramowania ........................................689
16.1. Testowanie aplikacji za pomocą biblioteki Test::Unit ................... 690
16.2. Narzędzia ZenTest .............................................................................. 695
16.3. Stosowanie debugera języka Ruby .................................................. 698
16.4. Stosowanie narzędzia irb w roli debugera programów
napisanych w Ruby ............................................................................ 701
16.5. Ocena pokrycia kodu testami ........................................................... 703
16.6. Ocena wydajności ............................................................................... 704
16.7. Stosowanie techniki pretty-printing dla obiektów ........................ 709
16.8. Konkluzja .............................................................................................. 711
ROZDZIAŁ 17. Pakowanie i dystrybucja kodu źródłowego ..............................................713
17.1. Stosowanie narzędzia RDoc .............................................................. 714
17.1.1. Stosowanie znaczników formatujących ........................... 715
17.1.2. Bardziej zaawansowane techniki formatowania ............ 719
Instalacja i pakowanie ........................................................................ 720
17.2.1. Biblioteka setup.rb ............................................................... 720
17.2.2. System RubyGems ............................................................... 723
17.3. Projekty RubyForge i RAA ................................................................. 724
17.4. Konkluzja .............................................................................................. 727
ROZDZIAŁ 18. Programowanie rozwiązań sieciowych ......................................................729
18.1. Serwery sieciowe ................................................................................. 731
18.1.1. Prosty serwer — która godzina? ........................................ 732
18.1.2.
Implementacja serwera wielowątkowego ....................... 734
18.1.3. Studium przypadku: serwer szachowy pracujący
17.2.
w trybie równorzędnym ..................................................... 734
18.2. Aplikacje klienckie .............................................................................. 743
18.2.1. Uzyskiwanie za pośrednictwem internetu
prawdziwych liczb losowych ............................................. 744
18.2.2. Nawiązywanie połączeń
z oficjalnym serwerem czasu ............................................. 747
18.2.3. Komunikacja z serwerem POP .......................................... 748
18.2.4. Wysyłanie wiadomości poczty elektronicznej
za pośrednictwem protokołu SMTP ................................. 750
18.2.5. Komunikacja z serwerem IMAP ........................................ 753
18.2.6. Kodowanie i dekodowanie załączników ......................... 756
18.2.7. Studium przypadku: brama łącząca listę dyskusyjną
z grupą dyskusyjną .............................................................. 758
SPIS TREŚCI
19
18.2.8. Uzyskiwanie strony internetowej
na podstawie adresu URL .................................................. 763
18.2.9. Stosowanie biblioteki Open-URI ....................................... 764
18.3. Konkluzja .............................................................................................. 765
ROZDZIAŁ 19. Ruby i aplikacje internetowe .......................................................................767
19.1. Programowanie w języku Ruby aplikacji CGI ............................... 767
19.1.1. Wprowadzenie do biblioteki cgi.rb ................................... 769
19.1.2. Wyświetlanie i przetwarzanie formularzy ....................... 771
19.1.3. Praca ze znacznikami kontekstu klienta .......................... 772
19.1.4. Praca z sesjami użytkownika ............................................. 773
19.2. Stosowanie technologii FastCGI ....................................................... 774
19.3. Framework Ruby on Rails ................................................................. 776
19.3.1. Podstawowe zasady i techniki programowania ............. 777
19.3.2. Testowanie i diagnozowanie aplikacji budowanych
na bazie frameworku Rails ................................................. 779
19.3.3. Rozszerzenia zbioru klas podstawowych ........................ 780
19.3.4. Narzędzia i biblioteki pokrewne ....................................... 781
19.4. Wytwarzanie aplikacji internetowych z wykorzystaniem
zestawu narzędzi Nitro ...................................................................... 782
19.4.1. Tworzenie prostych aplikacji na bazie
zestawu narzędzi Nitro ....................................................... 783
19.4.2. Zestaw narzędzi Nitro i wzorzec projektowy MVC ...... 785
19.4.3. Nitro i mechanizm Og ......................................................... 790
19.4.4. Realizacja typowych zadań budowy aplikacji
19.4.5.
internetowych z wykorzystaniem
zestawu narzędzi Nitro ....................................................... 791
Informacje dodatkowe ........................................................ 795
19.5. Wprowadzenie do frameworku Wee .............................................. 797
19.5.1. Prosty przykład .................................................................... 798
19.5.2. Wiązanie stanu z adresami URL ........................................ 799
19.6. Wytwarzanie aplikacji internetowych z wykorzystaniem
frameworku IOWA ............................................................................. 801
19.6.1. Podstawowe cechy frameworku IOWA ........................... 801
19.6.2. Stosowanie szablonów w aplikacjach budowanych
na bazie frameworku IOWA .............................................. 804
19.6.3. Transfer sterowania pomiędzy komponentami ............. 805
19.7. Ruby i serwery WWW ........................................................................ 807
19.7.1. Stosowanie modułu mod_ruby ......................................... 808
19.7.2. Stosowanie narzędzia erb ................................................... 809
19.7.3. Stosowanie serwera WEBrick ............................................. 812
19.7.4. Stosowanie serwera Mongrel ............................................. 814
19.8. Konkluzja .............................................................................................. 817
20
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
ROZDZIAŁ 20.
Implementacja aplikacji rozproszonych w Ruby .....................................819
20.1. Wprowadzenie do biblioteki drb ...................................................... 820
20.2. Studium przypadku: symulacja systemu publikacji
aktualnych notowań papierów wartościowych ............................. 823
20.3. Biblioteka Rinda: przestrzeń krotek języka Ruby .......................... 827
20.4. Wyszukiwanie usług za pomocą mechanizmów
rozproszonych języka Ruby .............................................................. 832
20.5. Konkluzja .............................................................................................. 833
ROZDZIAŁ 21. Narzędzia wytwarzania oprogramowania w Ruby .................................835
21.1. Stosowanie systemu RubyGems ....................................................... 836
21.2. Narzędzie rake ..................................................................................... 838
21.3. Stosowanie narzędzia irb ................................................................... 843
21.4. Narzędzie ri .......................................................................................... 848
21.5. Edytory kodu ....................................................................................... 849
21.6. Zintegrowane środowiska wytwarzania ......................................... 851
21.7. Konkluzja .............................................................................................. 852
ROZDZIAŁ 22. Społeczność programistów języka Ruby ...................................................855
22.1. Zasoby internetowe ............................................................................ 855
22.2. Grupy i listy dyskusyjne .................................................................... 856
22.3. Blogi i czasopisma internetowe ........................................................ 857
22.4. Dokumenty RCR ................................................................................. 857
22.5. Kanały IRC ........................................................................................... 858
22.6. Konferencje poświęcone programowaniu w Ruby ....................... 859
22.7. Lokalne grupy programistów Ruby ................................................. 860
22.8. Konkluzja .............................................................................................. 860
Skorowidz ........................................................................................................861
ROZDZIAŁ 9.
Zaawansowane
struktury danych
Graficzne odwzorowanie danych pobieranych z banków wszystkich komputerów świata.
Niewyobrażalna złożoność… Linie światła sięgającego nieprzestrzeni umysłu, roje i kon-
stelacje danych. Jak światła miasta, milknące w oddali.
— William Gibson
Istnieją oczywiście bardziej złożone i interesujące struktury danych niż tablice, tablice
mieszające i pokrewne. Część spośród struktur danych, którymi zajmiemy się w niniej-
szym rozdziale, jest pośrednio lub bezpośrednio obsługiwana w języku Ruby; pozostałe
będziemy musieli w większym lub mniejszym stopniu implementować samodzielnie.
Na szczęście okazuje się, że język programowania Ruby znacznie upraszcza proces
konstruowania niestandardowych struktur danych.
Jak się za chwilę okaże, zbiór matematyczny może być reprezentowany w formie tablic.
Najnowsza wersja języka Ruby dodatkowo oferuje swoim programistom klasę Set,
która doskonale sprawdza się w tej roli.
Stosy i kolejki należą do najbardziej popularnych struktur danych w świecie kompute-
rów. Czytelnicy zainteresowani praktycznymi zastosowaniami tych struktur danych
znajdą kilka przykładów w niniejszym rozdziale. Bardziej szczegółowe omówienie
zagadnień związanych ze stosami i kolejkami można znaleźć w niezliczonych pod-
ręcznikach przeznaczonych dla studentów pierwszego roku informatyki.
348
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
Drzewa są szczególnie przydatne w procesach sortowania, przeszukiwania i zwy-
kłego reprezentowania danych hierarchicznych. W tym rozdziale skoncentrujemy
się przede wszystkim na drzewach binarnych, ale zajmiemy się też innymi struktu-
rami tego typu.
Bardziej ogólną formą drzewa jest graf (ang. graph). Graf jest po prostu kolekcją węzłów
połączonych łukami, które mogą mieć przypisane wagi i kierunki. Grafy okazują się
szczególnie przydatne w takich obszarach badań jak sieci komputerowe czy inży-
nieria wiedzy.
Ponieważ jednak najprostszym zagadnieniem są zbiory, właśnie nimi zajmiemy się
w pierwszej kolejności.
9.1. PRACA ZE ZBIORAMI
W poprzednim rozdziale mieliśmy okazję się przekonać, jak pewne metody klasy
Array umożliwiają nam stosowanie jej obiektów w roli możliwej do przyjęcia repre-
zentacji zbiorów. Nieco większe możliwości i wygodę w tym obszarze oferuje klasa
Set, która ukrywa przed programistą część szczegółów implementacyjnych.
Aby mieć dostęp do rozwiązań zaimplementowany w klasie Set, wystarczy użyć pro-
stego wyrażenia require:
require set
W ten sposób dodatkowo rozbudowujemy moduł Enumerable o metodę to_set, która
umożliwia konwersję na zbiór dowolnych obiektów reprezentujących wyliczeniowe
struktury danych.
Tworzenie nowych zbiorów jest bardzo proste. Okazuje się, że w przypadku zbiorów
metoda [] działa dokładnie tak samo jak w przypadku tablic mieszających. Metoda new
może otrzymywać na wejściu opcjonalny obiekt wyliczeniowy i opcjonalny blok kodu.
Jeśli zdecydujemy się na użycie bloku, przekazany kod zostanie wykorzystany w roli
swoistego preprocesora przetwarzającego daną listę (podobnie jak operacja map):
s1 = Set[3,4,5] # czyli {3,4,5} w notacji matematycznej
arr = [3,4,5]
s2 = Set.new(arr) # jw.
s3 = Set.new(arr) {|x| x.to_s } # zbiór łańcuchów (nie liczb)
9.1.1. PROSTE OPERACJE NA ZBIORACH
Do wyznaczania sumy zbiorów służy metoda union (dla metody union zdefiniowano
dwa aliasy: | oraz +):
x = Set[1,2,3]
y = Set[3,4,5]
Rozdział 9. • ZAAWANSOWANE STRUKTURY DANYCH 349
a = x.union(y) # Set[1,2,3,4,5]
b = x | y # jw.
c = x + y # jw.
Iloczyn (część wspólną) dwóch zbiorów możemy wyznaczać za pomocą metody
intersetion (lub jej aliasu ):
x = Set[1,2,3]
y = Set[3,4,5]
a = x.intersection(y) # Set[3]
b = x y # jw.
Dwuargumentowy operator – reprezentuje operację różnicy zbiorów (o czym wspomi-
naliśmy już przy okazji omawiania tablic w punkcie 8.1.9 zatytułowanym „Stosowanie
tablic w roli zbiorów matematycznych”):
diff = Set[1,2,3] - Set[3,4,5] # Set[1,2]
Podobnie jak w przypadku tablic, przynależność do zbioru możemy sprawdzać za
pomocą metod member? i include?. Warto pamiętać, że kolejność operandów jest
odwrotna niż ta, którą znamy z lekcji matematyki:
Set[1,2,3].include?(2) # true
Set[1,2,3].include?(4) # false
Set[1,2,3].member?(4) # false
Za pomocą metody empty? możemy (podobnie jak w przypadku tabel) sprawdzić, czy
mamy do czynienia ze zbiorem pustym. Metoda clear usuwa wszystkie elementy
zbioru niezależnie od jego bieżącej zawartości:
s = Set[1,2,3,4,5,6]
s.empty? # false
s.clear
s.empty? # true
Klasa Set oferuje też możliwość określania relacji łączących dwa zbiory — za pomocą
odpowiednich metod możemy sprawdzać, czy zbiór reprezentowany przez obiekt
docelowy jest podzbiorem innego zbioru, czy jest jego podzbiorem właściwym lub czy
jest jego nadzbiorem:
x = Set[3,4,5]
y = Set[3,4]
x.subset?(y) # false
y.subset?(x) # true
y.proper_subset?(x) # true
x.subset?(x) # true
x.proper_subset?(x) # false
x.superset?(y) # true
350
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
Metoda add (alias ) dodaje pojedynczy element do wskazanego zbioru i zwraca
zmodyfikowany zbiór; metoda add? zwraca wartość nil, jeśli wskazany zbiór zawiera
już dany element. Za pomocą metody merge możemy jednocześnie dodawać wiele
elementów. Wszystkie wymienione metody mogą oczywiście modyfikować obiekt
docelowy (reprezentujący zbiór). Metoda replace działa na zbiorach dokładnie tak jak
w przypadku łańcuchów i tablic.
I wreszcie operator == służy do weryfikacji równości dwóch zbiorów:
Set[3,4,5] == Set[5,4,3] # true
9.1.2. ZAAWANSOWANE OPERACJE NA ZBIORACH
Oczywiście mamy też możliw
Pobierz darmowy fragment (pdf)
