Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ Ruby

Ruby. Przewodnik programisty. Wydanie II Język: 1

978-83-283-1103-9

Cena Brutto: 88.20

Cena netto: 84.00

Ilość:
Wersja: Drukowana
Autor David A. Black
Liczba_stron 497
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2015-10-11

Ruby

Przewodnik programisty. Wydanie II


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


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)
powrót
 
Produkty Podobne
Programowanie w języku Ruby. Mikrousługi i konteneryzacja
Ruby on Rails Tutorial: Learn Web Development with Rails, 4th Edition
Ruby on Rails. Tworzenie aplikacji WWW
Ruby Performance Optimization
RESTful Rails Development
Text Processing with Ruby
Ruby. Przewodnik programisty. Wydanie II
Learn Game Programming with Ruby
Ruby Pocket Reference, 2nd Edition
Ruby on Rails Tutorial: Learn Web Development with Rails, 3rd Edition
Więcej produktów