Jest to właściwy moment dla języka Ruby! Zapewnia on takie możliwości jak język Java lub C++, a ponadto oferuje funkcje dynamiczne, które umożliwiają tworzonemu kodowi reagowanie w odpowiedni sposób na zmiany w środowisku wykonawczym. Ponieważ język Ruby wyróżnia elegancja, tworzenie aplikacji, narzędzi programistycznych oraz skryptów administracyjnych jest łatwiejsze i bardziej zrozumiałe. Wraz z długo oczekiwaną wersją 2., aktywną społecznością programistów oraz niezliczonymi bibliotekami i narzędziami, język Ruby podąża własną drogą rozwoju.

Poznaj kluczowe pojęcia związane z językiem Ruby. W kolejnych rozdziałach znajdziesz istotne informacje na temat składni, dostępnych elementów oraz typowych konstrukcji. Ponadto zobaczysz, jak korzystać z obiektów, metod i zmiennych, oraz nauczysz się budować właściwą strukturę Twojego projektu. Po opanowaniu podstaw będziesz swobodnie tworzył proste programy oraz przejdziesz do zaawansowanych tematów związanych z technikami przepływu sterowania, wbudowanymi elementami, kolekcjami oraz wyrażeniami regularnymi. Ta książka jest doskonałym podręcznikiem dla wszystkich osób chcących nauczyć się języka Ruby i wykorzystać jego potencjał w kolejnych projektach.

Dzięki tej książce:

• poznasz składnię języka Ruby
• zrozumiesz filozofię stojącą za tym językiem
• opanujesz techniki programowania obiektowego
• wykorzystasz potencjał języka Ruby

Poznaj i wykorzystaj jego możliwości języka Ruby!

Osoby które kupowały "Ruby. Przewodnik programisty. Wydanie II", wybierały także:

• Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
• Programowanie w języku Ruby. Mikrousługi i konteneryzacja 57,74 zł, (17,90 zł -69%)
• Ruby on Rails. Od podstaw 49,00 zł, (26,95 zł -45%)
• Programowanie w języku Ruby. Mikrousługi i konteneryzacja 57,95 zł, (32,45 zł -44%)
• Rails. Sztuka programowania 57,95 zł, (32,45 zł -44%)

Spis treści

Ruby. Przewodnik programisty. Wydanie II -- spis treści

Przedmowa (17)

Przedmowa do pierwszego wydania (19)

Podziękowania (21)

O książce (23)

CZĘŚĆ I. FUNDAMENTY JĘZYKA RUBY (29)

Rozdział 1. Wprowadzenie do nauki języka Ruby (31)

• 1.1.Ogólne wprowadzenie do języka Ruby (32)
  • 1.1.1. Niezbędna składnia języka Ruby (33)
  • 1.1.2. Różnorodność identyfikatorów języka Ruby (35)
  • 1.1.3. Wywołania metod, komunikaty i obiekty języka Ruby (37)
  • 1.1.4. Tworzenie i zapisywanie prostego programu (39)
  • 1.1.5. Kierowanie programu do interpretera języka Ruby (40)
  • 1.1.6. Operacje wejścia-wyjścia związane z plikami i danymi wprowadzanymi przy użyciu klawiatury (42)
• 1.2. Anatomia instalacji języka Ruby (45)
  • 1.2.1. Podkatalog standardowych bibliotek języka Ruby (46)
  • 1.2.2. Katalog rozszerzeń języka C (RbConfig::CONFIG[archdir]) (46)
  • 1.2.3. Katalogi site_ruby (RbConfig::CONFIG[sitedir]) i vendor_ruby (RbConfig::CONFIG[vendordir]) (47)
  • 1.2.4. Katalog gems (47)
• 1.3. Rozszerzenia i biblioteki programistyczne języka Ruby (48)
  • 1.3.1. Ładowanie plików i rozszerzeń zewnętrznych (48)
  • 1.3.2. Ładowanie pliku określonego w domyślnej ścieżce ładowania (49)
  • 1.3.3. Żądanie składnika (50)
  • 1.3.4. Polecenie require_relative (52)
• 1.4. Standardowe narzędzia i aplikacje języka Ruby (52)
  • 1.4.1. Opcje wiersza poleceń interpretera (53)
  • 1.4.2. Omówienie interaktywnego interpretera języka Ruby irb (57)
  • 1.4.3. Narzędzia ri i Rdoc (59)
  • 1.4.4. Narzędzie do zarządzania zadaniami rake (60)
  • 1.4.5. Instalowanie pakietów za pomocą polecenia gem (62)
• 1.5. Podsumowanie (64)

Rozdział 2. Obiekty, metody i zmienne lokalne (65)

• 2.1. Komunikowanie się z obiektami (66)
  • 2.1.1. Język Ruby i obiektowość (66)
  • 2.1.2. Tworzenie obiektu ogólnego (67)
  • 2.1.3. Metody pobierające argumenty (69)
  • 2.1.4. Wartość zwracana metody (70)
• 2.2. Tworzenie obiektu: działanie biletu (71)
  • 2.2.1. Obiekt biletu - przede wszystkim działanie (71)
  • 2.2.2. Odpytywanie obiektu biletu (72)
  • 2.2.3. Skracanie kodu obiektu biletu za pomocą interpolacji łańcuchów (73)
  • 2.2.4. Dostępność biletu: wyrażanie stanu boolowskiego w metodzie (74)
• 2.3. Wbudowane zachowania obiektu (76)
  • 2.3.1. Unikatowe identyfikowanie obiektów za pomocą metody object_id (77)
  • 2.3.2. Uzyskiwanie możliwości obiektu za pomocą metody respond_to? (78)
  • 2.3.3. Wysyłanie komunikatów do obiektów za pomocą metody send (79)
• 2.4. Dokładna analiza argumentów metody (80)
  • 2.4.1. Argumenty wymagane i opcjonalne (80)
  • 2.4.2. Wartości domyślne argumentów (81)
  • 2.4.3. Kolejność parametrów i argumentów (82)
  • 2.4.4. Działania niedozwolone w przypadku list argumentów (85)
• 2.5. Zmienne lokalne i przypisywanie do zmiennych (85)
  • 2.5.1. Zmienne, obiekty i odwołania (87)
  • 2.5.2. Odwołania w przypisaniu do zmiennej i ponowne przypisanie (89)
  • 2.5.3. Odwołania i argumenty metody (91)
  • 2.5.4. Zmienne lokalne i przypominające je elementy (92)
• 2.6. Podsumowanie (93)

Rozdział 3. Organizowanie obiektów za pomocą klas (95)

• 3.1. Klasy i instancje (96)
  • 3.1.1. Metody instancji (97)
  • 3.1.2. Przesłanianie metod (97)
  • 3.1.3. Ponowne otwieranie klas (98)
• 3.2. Zmienne instancji i stan obiektu (100)
  • 3.2.1. Inicjowanie obiektu ze stanem (102)
• 3.3. Metody ustawiające (103)
  • 3.3.1. Znak równości (=) w nazwach metod (104)
  • 3.3.2. "Lukier" składniowy dla metod przypominających przypisania (105)
  • 3.3.3. Pełnia możliwości metod ustawiających (106)
• 3.4. Atrybuty i rodzina metod attr_* (108)
  • 3.4.1. Automatyzowanie tworzenia atrybutów (108)
  • 3.4.2. Podsumowanie metod attr_* (111)
• 3.5. Dziedziczenie i hierarchia klas języka Ruby (111)
  • 3.5.1. Pojedyncze dziedziczenie: po jednym dla klienta (113)
  • 3.5.2. Przodkowie obiektów i nie do końca brakujące łącze: klasa Object (113)
  • 3.5.3. Starszy brat El Viejo: BasicObject (114)
• 3.6. Klasy jako obiekty i odbiorcy komunikatów (115)
  • 3.6.1. Tworzenie obiektów klasy (115)
  • 3.6.2. Wywoływanie metod przez obiekty klasy (116)
  • 3.6.3. Metoda pojedynczego obiektu (117)
  • 3.6.4. Kiedy i dlaczego należy tworzyć metodę klasy? (119)
  • 3.6.5. Porównanie metod klasy z metodami instancji (120)
• 3.7. Szczegóły dotyczące stałych (120)
  • 3.7.1. Podstawowe zastosowanie stałych (121)
  • 3.7.2. Porównanie ponownego przypisania z modyfikowaniem stałych (123)
• 3.8. "Natura" i "wychowanie" w przypadku obiektów języka Ruby (124)
• 3.9. Podsumowanie (126)

Rozdział 4. Moduły i organizacja programu (127)

• 4.1. Podstawowe informacje dotyczące tworzenia i używania modułów (128)
  • 4.1.1. Moduł hermetyzujący "podobieństwo do stosu" (129)
  • 4.1.2. Dodawanie modułu do klasy (131)
  • 4.1.3. Bardziej zaawansowane użycie modułów (133)
• 4.2. Moduły, klasy i wyszukiwanie metody (135)
  • 4.2.1. Demonstracja podstaw wyszukiwania metod (135)
  • 4.2.2. Definiowanie tej samej metody więcej niż raz (138)
  • 4.2.3. Sposób działania instrukcji prepend (141)
  • 4.2.4. Podsumowanie reguł wyszukiwania metod (142)
  • 4.2.5. Nawigacja w obrębie ścieżki wyszukiwania metod za pomocą słowa kluczowego super (143)
• 4.3. Metoda method_missing (145)
  • 4.3.1. Łączenie metody method_missing ze słowem kluczowym super (146)
• 4.4. Projekt i nadawanie nazw w przypadku klas i modułów (150)
  • 4.4.1. Dodawanie modułów do klas i/lub dziedziczenie (151)
  • 4.4.2. Zagnieżdżanie modułów i klas (153)
• 4.5. Podsumowanie (154)

Rozdział 5. Obiekt domyślny (self), zasięg i widoczność (155)

• 5.1. Obiekt self, czyli obiekt bieżący/domyślny (156)
  • 5.1.1. Co zostaje obiektem self i w jakim miejscu? (157)
  • 5.1.2. Obiekt self najwyższego poziomu (158)
  • 5.1.3. Obiekt self w definicjach klas, modułów i metod (159)
  • 5.1.4. Obiekt self jako domyślny odbiorca komunikatów (162)
  • 5.1.5. Określanie zmiennych instancji za pośrednictwem obiektu self (164)
• 5.2. Określanie zasięgu (166)
  • 5.2.1. Zasięg globalny i zmienne globalne (166)
  • 5.2.2. Zasięg lokalny (169)
  • 5.2.3. Interakcja między zasięgiem lokalnym i obiektem self (171)
  • 5.2.4. Zasięg i określanie stałych (173)
  • 5.2.5. Składnia zmiennych klasy, zasięg i widoczność (175)
• 5.3. Wdrażanie reguł uzyskiwania dostępu do metod (182)
  • 5.3.1. Metody prywatne (182)
  • 5.3.2. Metody chronione (186)
• 5.4. Tworzenie i używanie metod najwyższego poziomu (187)
  • 5.4.1. Definiowanie metody najwyższego poziomu (187)
  • 5.4.2. Predefiniowane (wbudowane) metody najwyższego poziomu (188)
• 5.5. Podsumowanie (189)

Rozdział 6. Techniki przepływu sterowania (191)

• 6.1. Warunkowe wykonywanie kodu (192)
  • 6.1.1. Instrukcja if i powiązane z nią instrukcje (192)
  • 6.1.2. Składnia przypisania w treści instrukcji warunkowych i testach (197)
  • 6.1.3. Instrukcje case (200)
• 6.2. Powtarzanie działań za pomocą pętli (205)
  • 6.2.1. Bezwarunkowe wykonywanie pętli za pomocą metody loop (205)
  • 6.2.2. Warunkowe wykonywanie pętli za pomocą słów kluczowych while i until (206)
  • 6.2.3. Wykonywanie pętli na bazie listy wartości (209)
• 6.3. Iteratory i bloki kodu (209)
  • 6.3.1. Elementy iteracji (209)
  • 6.3.2. Iteracja w zwykłym stylu (210)
  • 6.3.3. Anatomia wywołania metody (210)
  • 6.3.4. Porównanie nawiasów klamrowych oraz pary słów kluczowych do i end w składni bloku kodu (211)
  • 6.3.5. Implementowanie metody times (213)
  • 6.3.6. Ważność metody each (214)
  • 6.3.7. Od metody each do metody map (216)
  • 6.3.8. Parametry bloku i zasięg zmiennych (218)
• 6.4. Obsługa błędów i wyjątki (221)
  • 6.4.1. Zgłaszanie wyjątków i stosowanie dla nich klauzuli rescue (221)
  • 6.4.2. Słowo kluczowe rescue na ratunek! (222)
  • 6.4.3. Jawne zgłaszanie wyjątków (224)
  • 6.4.4. Przechwytywanie wyjątku w klauzuli rescue (225)
  • 6.4.5. Klauzula ensure (227)
  • 6.4.6. Tworzenie własnych klas wyjątków (228)
• 6.5. Podsumowanie (229)

CZĘŚĆ II. WBUDOWANE KLASY I MODUŁY (231)

Rozdział 7. Wbudowane elementy podstawowe (233)

• 7.1. Konstruktory literałów języka Ruby (234)
• 7.2. Powracający "lukier" składniowy (235)
  • 7.2.1. Definiowanie operatorów przez określanie metod (236)
  • 7.2.2. Dostosowywanie operatorów jednoargumentowych (238)
• 7.3. Metody z nazwą zakończoną wykrzyknikiem i metody "niebezpieczne" (239)
  • 7.3.1. Destrukcyjne efekty (zmieniające odbiorcę) uznawane za "niebezpieczne" (240)
  • 7.3.2. Destrukcyjność i "niebezpieczeństwo" zmieniają się niezależnie (241)
• 7.4. Metody wbudowane i niestandardowe to_* służące do konwersji (242)
  • 7.4.1. Konwersja łańcucha: metoda to_s (243)
  • 7.4.2. Konwersja tablic za pomocą metody to_a i operatora * (246)
  • 7.4.3. Konwersja liczb za pomocą metod to_i i to_f (247)
  • 7.4.4. Metody z rodziny to_* przyjmujące role (248)
• 7.5. Stany i obiekty boolowskie oraz obiekt nil (250)
  • 7.5.1. Obiekty true i false jako stany (251)
  • 7.5.2. Obiekty true i false (252)
  • 7.5.3. Obiekt specjalny nil (254)
• 7.6. Porównanie dwóch obiektów (255)
  • 7.6.1. Testy równości (255)
  • 7.6.2. Porównania i moduł Comparable (256)
• 7.7. Inspekcja możliwości obiektów (258)
  • 7.7.1. Wyświetlanie listy metod obiektu (259)
  • 7.7.2. Odpytywanie obiektów klas i modułów (260)
  • 7.7.3. Listy filtrowanych i wybranych metod (261)
• 7.8. Podsumowanie (261)

Rozdział 8. Łańcuchy, symbole i inne obiekty skalarne (263)

• 8.1. Zastosowanie łańcuchów (264)
  • 8.1.1. Notacja łańcuchów (264)
  • 8.1.2. Podstawowe modyfikacje łańcuchów (268)
  • 8.1.3. Odpytywanie łańcuchów (272)
  • 8.1.4. Porównywanie łańcuchów i określanie ich kolejności (275)
  • 8.1.5. Transformacja łańcuchów (276)
  • 8.1.6. Konwersje łańcuchów (279)
  • 8.1.7. Kodowanie łańcuchów 3 krótkie wprowadzenie (280)
• 8.2. Symbole i ich zastosowanie (282)
  • 8.2.1. Główne cechy charakterystyczne symboli (283)
  • 8.2.2. Symbole i identyfikatory (284)
  • 8.2.3. Symbole w praktyce (286)
  • 8.2.4. Porównanie łańcuchów i symboli (288)
• 8.3. Obiekty liczbowe (289)
  • 8.3.1. Klasy liczbowe (290)
  • 8.3.2. Wykonywanie operacji arytmetycznych (290)
• 8.4. Czas i daty (292)
  • 8.4.1. Tworzenie instancji obiektów daty/czasu (293)
  • 8.4.2. Metody odpytywania obiektów daty i czasu (295)
  • 8.4.3. Metody formatujące datę i czas (296)
  • 8.4.4. Metody konwersji daty i czasu (297)
• 8.5. Podsumowanie (299)

Rozdział 9. Obiekty kolekcji i kontenerów (301)

• 9.1. Porównanie tablic i tablic asocjacyjnych (302)
• 9.2. Przetwarzanie kolekcji za pomocą tablic (304)
  • 9.2.1. Tworzenie nowej tablicy (304)
  • 9.2.2. Wstawianie, pobieranie i usuwanie elementów tablicy (308)
  • 9.2.3. Łączenie tablic z innymi tablicami (311)
  • 9.2.4. Transformacje tablic (312)
  • 9.2.5. Odpytywanie tablic (314)
• 9.3. Tablice asocjacyjne (315)
  • 9.3.1. Tworzenie nowej tablicy asocjacyjnej (315)
  • 9.3.2. Wstawianie, pobieranie i usuwanie par tablic asocjacyjnych (317)
  • 9.3.3. Określanie domyślnych wartości i zachowania tablic asocjacyjnych (319)
  • 9.3.4. Łączenie tablic asocjacyjnych z innymi tablicami asocjacyjnymi (320)
  • 9.3.5. Transformacje tablic asocjacyjnych (321)
  • 9.3.6. Odpytywanie tablic asocjacyjnych (322)
  • 9.3.7. Tablice asocjacyjne jako ostatnie argumenty metody (323)
  • 9.3.8. Powrót do składni argumentów: argumenty nazwane (słów kluczowych) (324)
• 9.4. Zakresy (326)
  • 9.4.1. Tworzenie zakresu (327)
  • 9.4.2. Logika włączenia do zakresów (328)
• 9.5. Zbiory (330)
  • 9.5.1. Tworzenie zbiorów (331)
  • 9.5.2. Modyfikowanie elementów zbioru (331)
  • 9.5.3. Podzbiory i nadzbiory (334)
• 9.6. Podsumowanie (335)

Rozdział 10. Kolekcje: moduł Enumerable i klasa Enumerator (337)

• 10.1. Zapewnianie możliwości wyliczania za pośrednictwem metody each (338)
• 10.2. Zapytania boolowskie dotyczące modułu Enumerable (340)
• 10.3. Wyszukiwanie i wybieranie obiektów wyliczeniowych (343)
  • 10.3.1. Uzyskiwanie pierwszego dopasowania za pomocą metody find (343)
  • 10.3.2. Uzyskiwanie wszystkich dopasowań za pomocą metod find_all (inaczej select) i reject (345)
  • 10.3.3. Wybieranie dopasowań operatora równości === za pomocą metody grep (345)
  • 10.3.4. Organizowanie wyników wybierania za pomocą metod group_by i #partition (347)
• 10.4. Operacje wyliczeniowe dotyczące elementów (348)
  • 10.4.1. Metoda first (348)
  • 10.4.2. Metody take i drop (350)
  • 10.4.3. Metody min i max (350)
• 10.5. Metody powiązane z metodą each (352)
  • 10.5.1. Metoda reverse_each (352)
  • 10.5.2. Metoda each_with_index (oraz metoda each.with_index) (352)
  • 10.5.3. Metody each_slice i each_cons (353)
  • 10.5.4. Metoda cycle (354)
  • 10.5.5. Zmniejszanie obiektu wyliczeniowego za pomocą metody inject (355)
• 10.6. Metoda map (356)
  • 10.6.1. Wartość zwracana metody map (357)
  • 10.6.2. Odwzorowywanie wewnętrzne za pomocą metody map! (358)
• 10.7. Łańcuchy jako quazi-obiekty wyliczeniowe (359)
• 10.8. Sortowanie obiektów wyliczeniowych (360)
  • 10.8.1. W jaki sposób moduł Comparable przydaje się (albo nie) podczas sortowania obiektów wyliczeniowych? (362)
  • 10.8.2. Definiowanie logiki kolejności sortowania przy użyciu bloku (363)
  • 10.8.3. Zwięzłe sortowanie za pomocą metody sort_by (364)
• 10.9. Enumeratory i następny wymiar możliwości wyliczania (364)
  • 10.9.1. Tworzenie enumeratorów z blokiem kodu (365)
  • 10.9.2. Powiązanie enumeratorów z innymi obiektami (367)
  • 10.9.3. Niejawne tworzenie enumeratorów za pomocą wywołań iteratora bez użycia bloku kodu (369)
• 10.10. Semantyka enumeratorów i ich zastosowanie (369)
  • 10.10.1. Sposób użycia metody each enumeratora (370)
  • 10.10.2. Ochrona obiektów za pomocą enumeratorów (372)
  • 10.10.3. Rozbudowana iteracja z wykorzystaniem enumeratorów (373)
  • 10.10.4. Zapewnianie możliwości wyliczania za pomocą enumeratora (374)
• 10.11. Tworzenie łańcucha metod enumeratora (375)
  • 10.11.1. Zmniejszanie liczby obiektów pośrednich (376)
  • 10.11.2. Indeksowanie obiektów wyliczeniowych za pomocą metody with_index (377)
  • 10.11.3. Operacje alternatywy wykluczającej na łańcuchach z wykorzystaniem enumeratorów (378)
• 10.12. "Leniwe" enumeratory (380)
  • 10.12.1. Problem FizzBuzz w przypadku "leniwego" enumeratora (381)
• 10.13. Podsumowanie (382)

Rozdział 11. Wyrażenie regularne i operacje na łańcuchach oparte na wyrażeniach regularnych (385)

• 11.1. Czym są wyrażenia regularne? (386)
• 11.2. Tworzenie wyrażeń regularnych (387)
  • 11.2.1. Wyświetlanie wzorców (387)
  • 11.2.2. Proste dopasowywanie za pomocą wyrażeń regularnych literału (388)
• 11.3. Tworzenie wzorca w wyrażeniu regularnym (389)
  • 11.3.1. Znaki literału we wzorcach (389)
  • 11.3.2. Znak wieloznaczny kropki (.) (390)
  • 11.3.3. Klasy znaków (390)
• 11.4. Dopasowywanie i przechwytywanie podłańcuchów oraz obiekt MatchData (392)
  • 11.4.1. Przechwytywanie dopasowań podrzędnych za pomocą nawiasów okrągłych (392)
  • 11.4.2. Dopasowanie pomyślne i zakończone niepowodzeniem (394)
  • 11.4.3. Dwa sposoby uzyskiwania przechwyceń (395)
  • 11.4.4. Inne informacje zawarte w obiekcie MatchData (397)
• 11.5. Dostrajanie wyrażeń regularnych za pomocą kwantyfikatorów, zakotwiczeń i modyfikatorów (398)
  • 11.5.1. Ograniczanie dopasowań za pomocą kwantyfikatorów (398)
  • 11.5.2. "Zachłanne" (i inne) kwantyfikatory (400)
  • 11.5.3. Zakotwiczenia i asercje wyrażeń regularnych (403)
  • 11.5.4. Modyfikatory (406)
• 11.6. Wzajemna konwersja łańcuchów i wyrażeń regularnych (408)
  • 11.6.1. Idiomy związane z przepływem od łańcucha do wyrażenia regularnego (408)
  • 11.6.2. Przejście od wyrażenia regularnego do łańcucha (410)
• 11.7. Typowe metody używające wyrażeń regularnych (411)
  • 11.7.1. Metoda String#scan (411)
  • 11.7.2. Metoda String#split (412)
  • 11.7.3. sub/sub! i gsub/gsub! (414)
  • 11.7.4. Równość przypadków i metoda grep (415)
• 11.8. Podsumowanie (417)

Rozdział 12. Operacje wejścia-wyjścia i operacje na plikach (419)

• 12.1. Struktura systemu operacji wejścia-wyjścia w języku Ruby (420)
  • 12.1.1. Klasa IO (420)
  • 12.1.2. Obiekty IO jako obiekty wyliczeniowe (421)
  • 12.1.3. Obiekty STDIN, STDOUT i STDERR (422)
  • 12.1.4. Trochę więcej o danych wprowadzanych za pomocą klawiatury (423)
• 12.2. Podstawowe operacje na plikach (424)
  • 12.2.1. Podstawy operacji odczytywania z plików (424)
  • 12.2.2. Odczytywanie plików oparte na wierszach (425)
  • 12.2.3. Odczytywanie plików w oparciu o bajty i znaki (426)
  • 12.2.4. Szukanie pozycji w pliku oraz odpytywanie o nią (427)
  • 12.2.5. Odczytywanie plików za pomocą metod klasy File (428)
  • 12.2.6. Zapisywanie w plikach (429)
  • 12.2.7. Użycie bloków do określania zasięgu operacji na plikach (430)
  • 12.2.8. Możliwości wyliczeniowe plików (431)
  • 12.2.9. Wyjątki i błędy dotyczące plikowych operacji wejścia-wyjścia (432)
• 12.3. Odpytywanie obiektów IO i File (433)
  • 12.3.1. Uzyskiwanie informacji z klasy File i modułu FileTest (434)
  • 12.3.2. Uzyskiwanie informacji o plikach za pomocą klasy File::Stat (435)
• 12.4. Modyfikowanie katalogów za pomocą klasy Dir (436)
  • 12.4.1. Wczytywanie pozycji katalogu (436)
  • 12.4.2. Modyfikowanie i odpytywanie katalogów (439)
• 12.5. Narzędzia plikowe biblioteki standardowej (440)
  • 12.5.1. Moduł FileUtils (440)
  • 12.5.2. Klasa Pathname (442)
  • 12.5.3. Klasa StringIO (444)
  • 12.5.4. Moduł open-uri (446)
• 12.6. Podsumowanie (446)

CZĘŚĆ III. DYNAMIKA JĘZYKA RUBY (449)

Rozdział 13. Indywidualizacja obiektów (451)

• 13.1. Tam, gdzie znajdują się metody pojedynczego obiektu: klasa pojedynczych obiektów (452)
  • 13.1.1. Podwójne określanie za pomocą klas pojedynczych obiektów (453)
  • 13.1.2. Bezpośrednie sprawdzanie i modyfikowanie klasy pojedynczych obiektów (454)
  • 13.1.3. Klasy pojedynczych obiektów w ścieżce wyszukiwania metod (456)
  • 13.1.4. Metoda singleton_class (461)
  • 13.1.5. Obszerne omówienie metod klasy (461)
• 13.2. Modyfikowanie podstawowych klas i modułów języka Ruby (463)
  • 13.2.1. Zagrożenia związane z modyfikowaniem podstawowych funkcjonalności (463)
  • 13.2.2. Zmiany addytywne (469)
  • 13.2.3. Zmiany z przekazaniem (469)
  • 13.2.4. Zmiany poszczególnych obiektów za pomocą metody extend (472)
  • 13.2.5. Użycie doprecyzowań do zmiany zachowania podstawowych obiektów (475)
• 13.3. BasicObject jako przodek i klasa (476)
  • 13.3.1. Użycie klasy BasicObject (476)
  • 13.3.2. Implementowanie podklasy klasy BasicObject (478)
• 13.4. Podsumowanie (480)

Rozdział 14. Obiekty umożliwiające wywoływanie i uruchamianie (483)

• 14.1. Podstawowe funkcje anonimowe: klasa Proc (484)
  • 14.1.1. Obiekty Proc (484)
  • 14.1.2. Obiekty Proc i bloki oraz różnice między nimi (485)
  • 14.1.3. Konwersje dotyczące bloków i obiektów Proc (487)
  • 14.1.4. Użycie metody Symbol#to_proc do zapewnienia zwięzłości (490)
  • 14.1.5. Obiekty Proc w roli domknięć (491)
  • 14.1.6. Argumenty i parametry obiektu Proc (494)
• 14.2. Tworzenie funkcji za pomocą metody lambda i konstruktora -> (494)
• 14.3. Metody jako obiekty (496)
  • 14.3.1. Przechwytywanie obiektów Method (496)
  • 14.3.2. Powody używania metod jako obiektów (497)
• 14.4. Rodzina metod eval (499)
  • 14.4.1. Przetwarzanie dowolnych łańcuchów jako kodu za pomocą metody eval (499)
  • 14.4.2. Zagrożenia stwarzane przez metodę eval (501)
  • 14.4.3. Metoda instance_eval (501)
  • 14.4.4. Użycie metody class_eval (inaczej module_eval) (503)
• 14.5. Równoległe wykonywanie za pomocą wątków (505)
  • 14.5.1. Kończenie działania, zatrzymywanie i uruchamianie wątków (506)
  • 14.5.2. Serwer dat z wątkami (508)
  • 14.5.3. Tworzenie serwera rozmów sieciowych używającego gniazd i wątków (509)
  • 14.5.4. Wątki i zmienne (511)
  • 14.5.5. Modyfikowanie kluczy wątków (512)
• 14.6. Wykonywanie poleceń systemowych w obrębie programów Ruby (515)
  • 14.6.1. Metoda system i odwrócone apostrofy (515)
  • 14.6.2. Komunikacja z programami za pośrednictwem metod open i Open3.popen3 (518)
• 14.7. Podsumowanie (521)

Rozdział 15. Wywołania zwrotne, "haki" i introspekcja w czasie wykonywania kodu (523)

• 15.1. Wywołania zwrotne i "haki" (524)
  • 15.1.1. Przechwytywanie nierozpoznanych komunikatów za pomocą metody method_missing (525)
  • 15.1.2. Wychwytywanie operacji dołączania i wstawiania na początku (528)
  • 15.1.3. Przechwytywanie operacji rozszerzania (529)
  • 15.1.4. Przechwytywanie dziedziczenia za pomocą metody Class#inherited (531)
  • 15.1.5. Metoda Module#const_missing (532)
  • 15.1.6. Metody method_added i singleton_method_added (533)
• 15.2. Interpretowanie zapytań dotyczących możliwości obiektów (535)
  • 15.2.1. Wyświetlanie metod nieprywatnych obiektu (535)
  • 15.2.2. Wyświetlanie listy metod prywatnych i chronionych (537)
  • 15.2.3. Uzyskiwanie metod instancji klas i modułów (539)
  • 15.2.4. Wyświetlanie listy metod pojedynczego obiektu danego obiektu (541)
• 15.3. Introspekcja zmiennych i stałych (543)
  • 15.3.1. Wyświetlanie listy zmiennych lokalnych lub globalnych (543)
  • 15.3.2. Wyświetlanie listy zmiennych instancji (543)
• 15.4. Śledzenie wykonywania kodu (544)
  • 15.4.1. Sprawdzanie danych śledzenia stosu za pomocą metody caller (544)
  • 15.4.2. Tworzenie narzędzia do analizowania danych śledzenia stosu (546)
• 15.5. Wywołania zwrotne i inspekcja metod w praktyce (549)
  • 15.5.1. Fundament środowiska MicroTest: MiniTest (549)
  • 15.5.2. Określanie i implementowanie narzędzia MicroTest (551)
• 15.6. Podsumowanie (554)

Skorowidz (557)