Ruby. Przewodnik programisty. Wydanie II - Helion
Tytuł oryginału: The Well-Grounded Rubyist, 2nd edition
Tłumaczenie: Piotr Pilch
ISBN: 978-83-283-1103-9
stron: 568, Format: 168x237, okładka: miękka
Data wydania: 2015-10-12
Księgarnia: Helion
Cena książki: 89,00 zł
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%)
- Ruby on Rails. Od podstaw 49,00 zł, (26,95 zł -45%)
- Rails. Receptury 66,98 zł, (36,84 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)