Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
01283 012084 11047007 na godz. na dobę w sumie
Ruby. Tao programowania w 400 przykładach - książka
Ruby. Tao programowania w 400 przykładach - książka
Autor: Liczba stron: 912
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-0958-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> ruby - programowanie
Porównaj ceny (książka, ebook, audiobook).

Zbiór gotowych rozwiązań i porad dla programistów Ruby

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.

Przyspiesz proces tworzenia witryn i aplikacji z Ruby!

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

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)

Gdzie kupić całą publikację:

Ruby. Tao programowania w 400 przykładach
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ą: