Ruby. Tao programowania w 400 przykładach
- Autor:
- Hal Fulton
- Ocena:
- 5.0/6 Opinie: 1
- Stron:
- 912
- Druk:
- oprawa twarda
Opis książki: Ruby. Tao programowania w 400 przykładach
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!
Wybrane bestsellery
-
Ruby. Kurs video obejmuje omówienie typów danych w Rubym i podstawy programowania obiektowego. Pokazuje, jak wykorzystać dynamiczne aspekty tego języka (niedostępne w większości innych języków), a dodatkowo przedstawia sposoby poprawnego wykonywania wielu czynności, takich jak instalacja bibliote...
Ruby. Kurs video. Poziom pierwszy. Podstawy języka i praktyczne przykłady Ruby. Kurs video. Poziom pierwszy. Podstawy języka i praktyczne przykłady
(0,00 zł najniższa cena z 30 dni)39.50 zł
79.00 zł(-50%) -
Jeśli chcesz się dowiedzieć, jak wykorzystać tę platformę w swoich projektach, jesteś na dobrym tropie! Dzięki tej książce poznasz możliwości i konstrukcje języka Ruby oraz mechanizm działania platformy Rails, a w szczególności interfejs Rack. Dowiesz się, jak zapewniać odpowiednią jakość swoich ...
Programowanie w języku Ruby. Mikrousługi i konteneryzacja Programowanie w języku Ruby. Mikrousługi i konteneryzacja
(0,00 zł najniższa cena z 30 dni)38.35 zł
59.00 zł(-35%) -
Podczas tego szkolenia nauczysz się konfigurować serwer i opanujesz zasady uruchamiania aplikacji napisanej w Ruby on Rails na własnym serwerze, by następnie zautomatyzować ten proces za pomocą skryptów napisanych w bibliotece Capistrano. Będziesz używać platformy chmurowej typu PaaS (Platform as...
Ruby on Rails. Kurs video. Wdrażanie (deployment) na własne serwery i chmurę Ruby on Rails. Kurs video. Wdrażanie (deployment) na własne serwery i chmurę
(0,00 zł najniższa cena z 30 dni)43.45 zł
79.00 zł(-45%) -
Kurs Programowanie w Ruby. Poziom drugi. Kurs video. Zaawansowane techniki trwa niecałe trzy godziny, jednak uwaga – dla Ciebie będzie to bardzo intensywny czas! W trakcie kursu opanujesz m.in. umiejętność implementowania języków dziedzinowych (DSL) takich jak RSpec. Poznasz model obiektowy...
Programowanie w Ruby. Poziom drugi. Kurs video. Zaawansowane techniki Programowanie w Ruby. Poziom drugi. Kurs video. Zaawansowane techniki
(0,00 zł najniższa cena z 30 dni)37.95 zł
69.00 zł(-45%) -
Skorzystaj ze szkolenia Ruby on Rails (RoR). Kurs video. Programowanie aplikacji internetowych, które wykorzystuje doświadczenie wydawnictwa Helion oraz stawia nacisk na praktyczne zastosowanie zdobytych umiejętności. Wraz z naszym ekspertem zbudujesz od zera swój pierwszy sklep internetowy. Pona...
Ruby on Rails (RoR). Kurs video. Programowanie aplikacji internetowych Ruby on Rails (RoR). Kurs video. Programowanie aplikacji internetowych
(0,00 zł najniższa cena z 30 dni)65.45 zł
119.00 zł(-45%) -
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, t...(0,00 zł najniższa cena z 30 dni)
48.95 zł
89.00 zł(-45%) -
Czytając tę książkę, poznasz elementy języka Ruby i nauczysz się programować obiektowo. Dowiesz się, w jaki sposób przetwarzać dane liczbowe, teksty i tablice, pliki i katalogi oraz dokumenty XML. Przeczytasz także o środowisku Ruby on Rails.(0,00 zł najniższa cena z 30 dni)
18.70 zł
34.00 zł(-45%) -
Elevate your Ruby skills to an advanced level by deepening your understanding of the design principles, best practices, and trade-offs involved in implementation approaches to future-proof your Ruby applications
-
Get to grips with the fundamentals of the Ruby programming language and learn how to build your own applications with the help of real-world examples and hands-on activities
-
Learn continuous deployment and automation with code-signing, continuous testing, building, deploying, and releasing of your app. About This BookA practical guide on automating your mobile development pipeline with Fastlane, Jenkins, and Slack.Build, test, run and deploy your mobile application r...
Ebooka przeczytasz na:
-
czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
-
systemach Windows, MacOS i innych
-
systemach Windows, Android, iOS, HarmonyOS
-
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi
Masz pytania? Zajrzyj do zakładki Pomoc »
Audiobooka posłuchasz:
-
w aplikacji Ebookpoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych
-
na dowolonych urządzeniach i aplikacjach obsługujących format MP3 (pliki spakowane w ZIP)
Masz pytania? Zajrzyj do zakładki Pomoc »
Kurs Video zobaczysz:
-
w aplikacji Ebookpoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych
-
na dowolonych urządzeniach i aplikacjach obsługujących format MP4 (pliki spakowane w ZIP)
Recenzje książki: Ruby. Tao programowania w 400 przykładach (1)
Poniższe recenzje mogły powstać po przekazaniu recenzentowi darmowego egzemplarza poszczególnych utworów bądź innej zachęty do jej napisania np. zapłaty.
-
Magazyn Internet KK, 04/2008
Obiektowy język programowania o nazwie Ruby został stworzony w 1995 roku przez Japończyka Yukihiro Matsumoto. Jego zadaniem było zapewnienie programistom jak największej wygody i ułatwienie im czerpania satysfakcji z pracy nad nowym oprogramowaniem. Od kilku lat Ruby zdobywa coraz większą popularność wśród twórców serwisów internetowych, głównie za sprawą środowiska Ruby on Rails. W przyswojeniu zasad programowania w tym języku oraz związanej z nim filozofii myślenia pomocna jest prezentowana książka. W obszernym wprowadzeniu autor opisuje w jaki sposób postrzega język Ruby i wyjaśnia jakimi założeniami kierował się przygotowując liczącą ponad dziewięćset stron publikację. Zasadnicze rozważania rozpoczyna od przeglądu języka obejmującego wprowadzenie do programowania obiektowego, podstawy składni i semantyki oraz uwagi związane z dynamicznymi aspektami Ruby. Począwszy od drugiego rozdziału mamy do czynienia z pogrupowanymi tematycznie poradami odnoszącymi się do konkretnych obszarów zastosowań prezentowanego języka. Autor przedstawia techniki operowania na łańcuchach znaków, uczy posługiwania się wyrażeniami regularnymi, pokazuje w jaki sposób tworzyć aplikacje w kilku wersjach językowych. Dowiadujemy się ponadto, jak wykonywać różnego rodzaju obliczenia numeryczne, poznajemy zastosowania symboli i przedziałów oraz operujemy na danych związanych z przechowywaniem informacji o dacie i godzinie. Nie zabrakło także materiałów traktujących o strukturach danych począwszy od tablic, przez kolejki, stosy aż po grafy. Kontynuując lekturę przyswajamy informacje o operacjach wejścia-wyjścia, składowaniu danych oraz zaawansowanych technikach programowania obiektowego. Warto zwrócić uwagę na porady odnoszące się do tworzenia graficznych interfejsów użytkownika. W dobie wzrastającej popularności procesorów wielordzeniowych należy też docenić rozdział traktujący o programowaniu wielowątkowym. Programiści sięgający po tę pozycję dowiedzą się również w jaki sposób uruchamiać zewnętrzne programy z poziomu języku Ruby, poznają wartościowe uwagi związane z formatami danych, a także uzyskają pomoc w zakresie testowania, diagnozowania i dystrybucji tworzonych programów. Godne odnotowania są też materiały przybliżające tworzenie rozwiązań sieciowych, aplikacji internetowych oraz programów rozproszonych. Całość wieńczy zestawienie zasobów zapewniających dostęp do użytecznych materiałów i do społeczności programistów korzystających z języka Ruby. Hal Fulton przygotował podręcznik, który wspomaga programistów w procesie rozwiązywania różnego rodzaju problemów w oparciu o język Ruby. W licznych przykładach przybliża nie tylko elementy tego języka i związane z nim techniki programistyczne, lecz prezentuje również sposób myślenia obowiązujący w świecie jego użytkowników. O tego typu postawie z uznaniem wypowiada się sam twórca języka. We wstępie do książki twierdzi wręcz, że autor publikacji podejmując trudne wyzwanie zaprezentowania Ruby uczynił to w taki sposób, jakby czytał w jego myślach. Zwraca także uwagę na korzystny wpływ społeczności programistów na ostateczną postać drugiego wydania książki. W przypadku tego typu pozycji trudno jest pokusić się o lepszą rekomendację.
Szczegóły książki
- Tytuł oryginału:
- The Ruby Way, Second Edition: Solutions and Techniques in Ruby Programming
- Tłumaczenie:
- Mikołaj Szczepaniak
- ISBN Książki drukowanej:
- 978-83-246-0958-1, 9788324609581
- Data wydania książki drukowanej:
- 2007-12-13
- Format:
- B5
- Numer z katalogu:
- 3988
- Przykłady na ftp
Ebook zawiera materiały dodatkowe, które możesz pobrać z serwera FTP - link znajdziesz na stronie redakcyjnej.
- Zgłoś erratę
- Kategorie:
Programowanie » Ruby - Programowanie
Spis treści książki
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
Słowo wstępne (21)
Podziękowania (25)
O autorze (29)
Wprowadzenie (31)
Rozdział 1. Przegląd języka Ruby (47)
Rozdział 2. Praca z łańcuchami (113)
Rozdział 3. Praca z wyrażeniami regularnymi (153)
Rozdział 4. Umiędzynaradawianie aplikacji Ruby (185)
Rozdział 5. Wykonywanie obliczeń numerycznych (217)
Rozdział 6. Symbole i przedziały (255)
Rozdział 7. Praca z datami i godzinami (273)
Rozdział 8. Tablice, tablice mieszające i inne wyliczeniowe struktury danych (295)
Rozdział 9. Zaawansowane struktury danych (347)
Rozdział 10. Operacje wejścia-wyjścia i techniki składowania danych (373)
Rozdział 11. Programowanie obiektowe i dynamiczne elementy języka Ruby (437)
Rozdział 12. Interfejsy graficzne dla Ruby (519)
Rozdział 13. Wątki w języku Ruby (585)
Rozdział 14. Tworzenie skryptów i administracja systemem (617)
Rozdział 15. Ruby i formaty danych (655)
Rozdział 16. Testowanie i diagnozowanie oprogramowania (689)
Rozdział 17. Pakowanie i dystrybucja kodu źródłowego (713)
Rozdział 18. Programowanie rozwiązań sieciowych (729)
Rozdział 19. Ruby i aplikacje internetowe (767)
Rozdział 20. Implementacja aplikacji rozproszonych w Ruby (819)
Rozdział 21. Narzędzia wytwarzania oprogramowania w Ruby (835)
Rozdział 22. Społeczność programistów języka Ruby (855)
Skorowidz (861)
Oceny i opinie klientów: Ruby. Tao programowania w 400 przykładach Hal Fulton (1)
Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię. Użytkownik mógł otrzymać punkty za opublikowanie opinii uprawniające do uzyskania rabatu w ramach Programu Punktowego.
(0)
(1)
(0)
(0)
(0)
(0)
Justyna,
Data dodania: 2009-07-22 Ocena: 5 Opinia niepotwierdzona zakupem