• 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

Osoby które kupowały "Ruby. Tao programowania w 400 przykładach", wybierały także:

• Ruby on Rails. Ćwiczenia 18,75 zÅ‚, (3,00 zÅ‚ -84%)
• Ruby. Kurs video. Poziom pierwszy. Podstawy jÄ™zyka i praktyczne przykÅ‚ady 79,00 zÅ‚, (23,70 zÅ‚ -70%)
• Programowanie w Ruby. Poziom drugi. Kurs video. Zaawansowane techniki 69,00 zÅ‚, (27,60 zÅ‚ -60%)
• Ruby on Rails (RoR). Kurs video. Programowanie aplikacji internetowych 99,00 zÅ‚, (44,55 zÅ‚ -55%)
• Ruby on Rails. Kurs video. Wdrażanie (deployment) na wÅ‚asne serwery i chmurÄ™ 59,00 zÅ‚, (26,55 zÅ‚ -55%)

Spis treści

Ruby. Tao programowania w 400 przykładach -- spis treści

Słowo wstępne (21)

Podziękowania (25)

O autorze (29)

Wprowadzenie (31)

Rozdział 1. 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)
• 1.2. 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 w kodzie źródÅ‚owym (58)
  • 1.2.3. StaÅ‚e, zmienne i typy (58)
  • 1.2.4. Operatory i priorytety operatorów (61)
  • 1.2.5. Program przykÅ‚adowy (62)
  • 1.2.6. PÄ™tle i struktury sterujÄ…ce (65)
  • 1.2.7. WyjÄ…tki (70)
• 1.3. 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)
  
  • 1.4.1. Kodowanie w czasie wykonywania (85)
  • 1.4.2. Refleksja (86)
  • 1.4.3. BrakujÄ…ce metody (88)
  • 1.4.4. Odzyskiwanie pamiÄ™ci (89)
• 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)
• 1.6. Å»argon jÄ™zyka Ruby (108)
  
• 1.7. Konkluzja (112)

Rozdział 2. 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)
  
• 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)

Rozdział 3. Praca z wyrażeniami regularnymi (153)

• 3.1. SkÅ‚adnia wyrażeÅ„ regularnych (154)
  
• 3.2. Kompilowanie wyrażeÅ„ regularnych (156)
  
• 3.3. Stosowanie znaków specjalnych (157)
  
• 3.4. Stosowanie tzw. kotwic (157)
  
• 3.5. Stosowanie kwantyfikatorów (158)
  
• 3.6. Antycypacja dodatnia i ujemna (160)
  
• 3.7. Uzyskiwanie dostÄ™pu do referencji wstecznych (161)
  
• 3.8. Stosowanie klas znaków (165)
  
• 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)

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)
  
  • 4.2.1. Biblioteka jcode i zmienna globalna $KCODE (192)
  • 4.2.2. Ponowne spojrzenie na popularne operacje 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 wedÅ‚ug różnych schematów (204)
• 4.3. Stosowanie katalogów komunikatów (207)
  
  • 4.3.1. WstÄ™p teoretyczny i terminologia (207)
  • 4.3.2. Pierwsze kroki w Å›wiecie katalogów komunikatów (208)
  • 4.3.3. Lokalizacja prostej aplikacji (209)
  • 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)
  
• 5.4. Porównywanie liczb zmiennoprzecinkowych (222)
  
• 5.5. Formatowanie liczb przeznaczonych do wyÅ›wietlenia (223)
  
• 5.6. Formatowanie liczb z separatorami tysiÄ™cy (224)
  
• 5.7. Praca z bardzo dużymi liczbami caÅ‚kowitymi (225)
  
• 5.8. Stosowanie typu BigDecimal (225)
  
• 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)
  
• 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 za pomocÄ… biblioteki memoize (252)
  
• 5.30. Konkluzja (254)

Rozdział 6. Symbole i przedziały (255)

• 6.1. Symbole (256)
  
  • 6.1.1. Symbole jako typy wyliczeniowe (258)
  • 6.1.2. Symbole jako metawartoÅ›ci (258)
  • 6.1.3. Symbole, zmienne i metody (259)
  • 6.1.4. Konwertowanie na symbole i z symboli (260)
• 6.2. 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)

Rozdział 7. 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)
  
• 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)

Rozdział 8. Tablice, tablice mieszające i inne wyliczeniowe struktury danych (295)

• 8.1. Praca z tablicami (296)
  
  • 8.1.1. Tworzenie i inicjalizacja tablic (296)
  • 8.1.2. Uzyskiwanie dostÄ™pu i przypisywanie wartoÅ›ci elementom tablicy (297)
  • 8.1.3. OkreÅ›lanie rozmiaru tablicy (299)
  • 8.1.4. Porównywanie tablic (299)
  • 8.1.5. Sortowanie elementów tablicy (301)
  • 8.1.6. Selekcja elementów tablicy wedÅ‚ug okreÅ›lonych kryteriów (304)
  • 8.1.7. Stosowanie wyspecjalizowanych funkcji indeksujÄ…cych (306)
  • 8.1.8. Implementacja macierzy rzadkich (308)
  • 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)
  • 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 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)
• 8.2. 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 macierzy rzadkich (332)
  • 8.2.15. 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)
  • 8.3.6. Stosowanie obiektów klasy Enumerator (341)
  • 8.3.7. Stosowanie obiektów klasy Generator (343)
• 8.4. Konkluzja (344)

Rozdział 9. Zaawansowane struktury danych (347)

• 9.1. Praca ze zbiorami (348)
  
  • 9.1.1. Proste operacje na zbiorach (348)
  • 9.1.2. Zaawansowane operacje na zbiorach (350)
• 9.2. 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 znaków interpunkcyjnych w wyrażeniach (354)
  • 9.2.3. Stosy i rekurencja (355)
  • 9.2.4. Implementacja kolejki wymuszajÄ…cej wÅ‚aÅ›ciwy dostÄ™p do danych (357)
• 9.3. Praca z drzewami (358)
  
  • 9.3.1. Implementacja drzewa binarnego (359)
  • 9.3.2. Sortowanie danych z wykorzystaniem drzewa binarnego (361)
  • 9.3.3. Stosowanie drzewa binarnego w roli tablicy wyszukiwania (363)
  • 9.3.4. Konwersja drzewa na Å‚aÅ„cuch lub tablicÄ™ (364)
• 9.4. 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 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)
  • 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)
  • 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)
  • 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)

Rozdział 12. 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)
  • 12.1.6. Informacje dodatkowe (536)
• 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)
  • 12.4.6. Informacje dodatkowe (581)
• 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)

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)
  • 13.2.9. Implementacja iteratorów równolegÅ‚ych (613)
  • 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)
  • 14.3.2. Informacje dodatkowe o bibliotece shell.rb (631)
• 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 w formie tablic lub tablic mieszajÄ…cych (633)
  • 14.4.3. 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)
• 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)
• 17.2. 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 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)
  • 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 internetowych z wykorzystaniem zestawu narzÄ™dzi Nitro (791)
  • 19.4.5. 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)

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)