Ruby. Tao programowania w 400 przykładach

Autor: Hal Fulton

Szczegóły książki w Helionie
Tytuł oryginału: The Ruby Way, Second Edition: Solutions and Techniques in Ruby Programming
ISBN: 978-83-246-0958-1
Cena: 117 zł
Zniżka: 10%
Cena ze zniżką: 105.3 zł
Oprawa: twarda
Format: B5
Data wydania: 2007.12.13
Liczba stron: 912
Przykładowy rozdział: ftp://ftp.helion.pl/online/swruby/swruby-9.pdf
Kategoria: Ruby on Rails

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

  • Omówienie możliwości języka Ruby 
  • Zasady komunikacji z bazami danych
  • Tworzenie interfejsów graficznych dla aplikacji
  • Testowanie kodu źródłowego

Ruby, obiektowy język programowania, opracowany na początku lat 90. ubiegłego wieku w Japonii, cieszy się zasłużoną i stale rosnącą popularnością. Dziś Ruby jest poważną konkurencją dla Perla i podstawowym fundamentem technologii Ruby on Rails -- doskonałego narzędzia do szybkiego tworzenia aplikacji i witryn internetowych. Prosta składnia, duże możliwości, zwarta konstrukcja, rozbudowana i niezwykle wygodna obsługa wyjątków oraz przetwarzania plików tekstowych sprawiają, że po ten język programowania sięga coraz więcej osób piszących oprogramowanie.

Książka "Ruby. Tao programowania w 400 przykładach" to podręcznik dla tych programistów, którzy poszukują metod rozwiązywania konkretnych zadań programistycznych za pomocą Ruby. Na ponad 400 przykładach przedstawiono w niej przeróżne zastosowania i możliwości tego języka. Czytając ją, poznasz elementy języka Ruby i zasady programowania obiektowego, techniki przetwarzania łańcuchów tekstowych z zastosowaniem wyrażeń regularnych oraz sposoby wykonywania nawet najbardziej złożonych operacji matematycznych. Znajdziesz tu także omówienie metod komunikacji z bazami danych, budowania graficznych interfejsów użytkownika, programowania wielowątkowego i pisania skryptów administracyjnych. Dowiesz się też, jak korzystać z frameworka Ruby on Rails.

  • Programowanie obiektowe w Ruby
  • Przetwarzanie danych tekstowych
  • Obliczenia matematyczne
  • Internacjonalizacja aplikacji
  • Operacje na złożonych strukturach danych  
  • Dynamiczne elementy języka Ruby
  • Tworzenie interfejsów graficznych dla aplikacji
  • Aplikacje wielowątkowe
  • Pobieranie danych z baz
  • Dystrybucja aplikacji
  • Testowanie 
  • Tworzenie aplikacji internetowych w technologii Ruby on Rails

Przyspiesz proces tworzenia witryn i aplikacji z Ruby!

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)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań