Ruby_Tao_programowania_w_400_przykladach_swruby.pdf

(427 KB) Pobierz
Ruby. Tao programowania
w 400 przyk³adach
Autor: Hal Fulton
T³umaczenie: Miko³aj Szczepaniak
ISBN: 978-83-246-0958-1
Tytu³ orygina³u:
The Ruby Way, Second Edition:
Solutions and Techniques in Ruby Programming
Format: B5, stron: 912
oprawa twarda
Przyk³ady na ftp: 54 kB
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
Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
Tworzenie aplikacji internetowych w technologii Ruby on Rails
Przyspiesz proces tworzenia witryn i aplikacji z Ruby!
SPIS TREŚCI
5
S
PIS TREŚCI
Słowo wstępne .................................................................................................. 21
Podziękowania .................................................................................................. 25
O autorze ............................................................................................................ 29
Wprowadzenie .................................................................................................. 31
ROZDZIAŁ 1.
Przegląd języka Ruby ...................................................................................... 47
1.1.
Wprowadzenie do programowania obiektowego ........................... 48
1.1.1.
Czym jest obiekt? ................................................................... 49
1.1.2.
Dziedziczenie .......................................................................... 50
1.1.3.
Polimorfizm ............................................................................. 53
1.1.4.
Kilka dodatkowych pojęć ..................................................... 54
1.2.
Podstawy składni i semantyki języka Ruby ..................................... 55
1.2.1.
Słowa kluczowe i identyfikatory ......................................... 57
1.2.2.
Komentarze i dokumentacja osadzana
w kodzie
źródłowym
............................................................. 58
1.2.3.
Stałe, zmienne i typy ............................................................. 58
1.2.4.
Operatory i priorytety operatorów ..................................... 61
1.2.5.
Program przykładowy .......................................................... 62
1.2.6.
Pętle i struktury sterujące ..................................................... 65
1.2.7.
Wyjątki ..................................................................................... 70
1.3.
Programowanie obiektowe w języku Ruby ...................................... 73
1.3.1.
Obiekty .................................................................................... 74
1.3.2.
Klasy wbudowane ................................................................. 74
1.3.3.
Moduły i klasy mieszane ...................................................... 76
1.3.4.
Tworzenie klas ........................................................................ 77
1.3.5.
Metody i atrybuty .................................................................. 82
1.4.
Aspekty dynamiczne języka programowania Ruby ....................... 84
1.4.1.
Kodowanie w czasie wykonywania .................................... 85
1.4.2.
Refleksja ................................................................................... 86
1.4.3.
Brakujące metody .................................................................. 88
1.4.4.
Odzyskiwanie pamięci .......................................................... 89
6
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
1.5.
1.6.
1.7.
ROZDZIAŁ 2.
Ć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
Żargon
języka Ruby ............................................................................ 108
Konkluzja .............................................................................................. 112
Praca z
łańcuchami
......................................................................................... 113
2.1.
Reprezentowanie typowych
łańcuchów
......................................... 114
2.2.
Reprezentowanie
łańcuchów
w notacjach alternatywnych ........ 115
2.3.
Stosowanie dokumentu wbudowanego ......................................... 115
2.4.
Określanie długości
łańcuchów
........................................................ 118
2.5.
Przetwarzanie po jednym wierszu w każdej iteracji .................... 118
2.6.
Przetwarzanie po jednym bajcie w każdej iteracji ........................ 118
2.7.
Stosowanie wyspecjalizowanych technik
porównywania
łańcuchów
................................................................ 119
2.8.
Dzielenie
łańcuchów
na tokeny ....................................................... 121
2.9.
Formatowanie
łańcuchów
................................................................. 122
2.10. Stosowanie
łańcuchów
w roli obiektów wejścia-wyjścia ............. 123
2.11. Konwersja wielkich i małych liter .................................................... 123
2.12. Uzyskiwanie dostępu i przypisywanie podłańcuchów ................ 125
2.13. Zamiana
łańcuchów
........................................................................... 127
2.14. Przeszukiwanie
łańcuchów
............................................................... 128
2.15. Konwertowanie znaków na kody ASCII ......................................... 129
2.16. Konwersja jawna i niejawna ............................................................. 129
2.17. Dołączanie elementów do
łańcuchów
............................................. 132
2.18. Usuwanie końcowych znaków nowego wiersza
i innych symboli specjalnych ............................................................ 133
2.19. Usuwanie znaków białych z początku i końca
łańcucha
............. 134
2.20. Powielanie
łańcuchów
........................................................................ 134
2.21. Osadzanie wyrażeń w ramach
łańcuchów
..................................... 135
2.22. Opóźnianie przetwarzania
łańcuchów
........................................... 135
2.23. Analiza składniowa danych oddzielonych przecinkami .............. 136
2.24. Konwertowanie
łańcuchów
na liczby (dziesiętne i inne) ............. 137
2.25. Kodowanie i dekodowanie tekstu szyfrowanego
za pomocą metody rot13 .................................................................... 139
2.26. Szyfrowanie
łańcuchów
..................................................................... 140
2.27. Kompresja
łańcuchów
........................................................................ 141
2.28. Wyznaczanie liczby wystąpień znaków w
łańcuchach
................ 142
2.29. Odwracanie kolejności znaków w
łańcuchu
.................................. 142
2.30. Usuwanie powtarzających się znaków ............................................ 143
2.31. Usuwanie określonych znaków ........................................................ 143
2.32. Wyświetlanie znaków specjalnych .................................................. 143
SPIS TREŚCI
7
2.33.
2.34.
2.35.
2.36.
2.37.
2.38.
2.39.
2.40.
2.41.
ROZDZIAŁ 3.
Generowanie kolejnych
łańcuchów
.................................................. 144
Wyznaczanie 32-bitowych sum CRC ............................................... 144
Wyznaczanie kodów MD5 dla
łańcuchów
..................................... 145
Wyznaczanie odległości Levenshteina dzielącej dwa
łańcuchy
...... 146
Kodowanie i dekodowanie
łańcuchów
w formacie base64 ......... 148
Kodowanie i dekodowanie
łańcuchów
za pomocą narzędzi uuencode oraz uudecode .............................. 149
Rozszerzanie i kompresja znaków tabulacji ................................... 149
Opakowywanie wierszy tekstu ........................................................ 150
Konkluzja .............................................................................................. 151
Praca z wyrażeniami regularnymi ............................................................... 153
3.1.
Składnia wyrażeń regularnych ......................................................... 154
3.2.
Kompilowanie wyrażeń regularnych .............................................. 156
3.3.
Stosowanie znaków specjalnych ...................................................... 157
3.4.
Stosowanie tzw. kotwic ...................................................................... 157
3.5.
Stosowanie kwantyfikatorów ............................................................ 158
3.6.
Antycypacja dodatnia i ujemna ........................................................ 160
3.7.
Uzyskiwanie dostępu do referencji wstecznych ............................ 161
3.8.
Stosowanie klas znaków .................................................................... 165
3.9.
Rozszerzone wyrażenia regularne ................................................... 166
3.10. Dopasowywanie znaku nowego wiersza do kropki ..................... 167
3.11. Stosowanie opcji osadzanych ............................................................ 168
3.12. Stosowanie podwyrażeń osadzanych ............................................. 169
3.13. Ruby i Oniguruma .............................................................................. 169
3.13.1. Testowanie dostępności mechanizmu Oniguruma ....... 170
3.13.2. Kompilacja silnika Oniguruma .......................................... 171
3.13.3. Przegląd wybranych nowości
zaimplementowanych w silniku Oniguruma ................. 172
3.13.4. Dodatnia i ujemna antycypacja wsteczna ...................... 172
3.13.5. Więcej o kwantyfikatorach ................................................. 174
3.13.6. Dopasowania nazwane ....................................................... 174
3.13.7. Rekurencja w wyrażeniach regularnych ......................... 176
3.14. Kilka przykładowych wyrażeń regularnych .................................. 177
3.14.1. Dopasowywanie adresów IP .............................................. 177
3.14.2. Dopasowywanie par klucz-wartość .................................. 178
3.14.3. Dopasowywanie liczb rzymskich ...................................... 179
3.14.4. Dopasowywanie stałych numerycznych ......................... 179
3.14.5. Dopasowywanie
łańcuchów
zawierających datę
i godzinę ................................................................................ 180
3.14.6. Wykrywanie powtarzających się
wyrazów w tekście ............................................................... 181
3.14.7. Dopasowywanie słów pisanych wielkimi literami ......... 181
3.14.8. Dopasowywanie numerów wersji .................................... 182
3.14.9. Kilka dodatkowych wzorców ............................................ 182
3.15. Konkluzja .............................................................................................. 183
8
RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH
ROZDZIAŁ 4.
Umiędzynaradawianie aplikacji Ruby ....................................................... 185
4.1.
Wstęp teoretyczny i terminologia .................................................... 187
4.2.
Kodowanie znaków we współczesnym
świecie
(po rezygnacji ze standardu ASCII) ................................................. 191
4.2.1.
Biblioteka jcode i zmienna globalna $KCODE ................ 192
4.2.2.
Ponowne spojrzenie na popularne operacje
na
łańcuchach
i wyrażeniach regularnych ...................... 193
4.2.3.
Wykrywanie schematów kodowania znaków ................ 198
4.2.4.
Normalizacja
łańcuchów
Unicode .................................... 198
4.2.5.
Problemy związane z porządkowaniem
łańcuchów
..... 200
4.2.6.
Konwertowanie
łańcuchów
zakodowanych
według różnych schematów .............................................. 204
4.3.
Stosowanie katalogów komunikatów .............................................. 207
4.3.1.
Wstęp teoretyczny i terminologia ..................................... 207
4.3.2.
Pierwsze kroki w
świecie
katalogów komunikatów ...... 208
4.3.3.
Lokalizacja prostej aplikacji ................................................ 209
4.3.4.
Informacje dodatkowe ........................................................ 214
4.4.
Konkluzja .............................................................................................. 215
Wykonywanie obliczeń numerycznych ..................................................... 217
5.1.
Reprezentowanie liczb w języku Ruby ........................................... 218
5.2.
Podstawowe operacje na liczbach .................................................... 219
5.3.
Zaokrąglanie liczb zmiennoprzecinkowych ................................... 220
5.4.
Porównywanie liczb zmiennoprzecinkowych ............................... 222
5.5.
Formatowanie liczb przeznaczonych do wyświetlenia ................ 223
5.6.
Formatowanie liczb z separatorami tysięcy .................................... 224
5.7.
Praca z bardzo dużymi liczbami całkowitymi ................................ 225
5.8.
Stosowanie typu BigDecimal ............................................................ 225
5.9.
Praca z liczbami wymiernymi ........................................................... 227
5.10. Operacje na macierzach ..................................................................... 228
5.11. Praca z liczbami zespolonymi ........................................................... 233
5.12. Stosowanie biblioteki mathn ............................................................. 234
5.13. Rozkład na czynniki pierwsze, największy wspólny dzielnik
i najmniejsza wspólna wielokrotność .............................................. 235
5.14. Praca z liczbami pierwszymi ............................................................. 236
5.15. Niejawna i bezpośrednia konwersja numeryczna ........................ 237
5.16. Koercja wartości numerycznych ...................................................... 238
5.17. Wykonywanie operacji bitowych na liczbach ................................ 240
5.18. Konwersje pomiędzy systemami liczbowymi ................................ 241
5.19. Wyznaczanie pierwiastków sześciennych, czwartego
stopnia, piątego stopnia itd. .............................................................. 242
5.20. Określanie porządku bajtów obowiązującego
w danej architekturze ......................................................................... 243
5.21. Numeryczna metoda wyznaczania całki oznaczonej ................... 244
5.22. Trygonometria w stopniach, radianach i gradach ......................... 245
ROZDZIAŁ 5.

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin