Ruby_Tao_programowania_w_400_przykladach_swruby.pdf

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

Zbir gotowych rozwiĴzaĺ i porad dla programistw Ruby

¤ Omwienie moŃliwoľci jķzyka Ruby

¤ Zasady komunikacji z bazami danych

¤ Tworzenie interfejsw graficznych dla aplikacji

¤ Testowanie kodu łrdĀ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Ĵtkw oraz przetwarzania plikw tekstowych sprawiajĴ,

Ńe po ten jķzyk programowania siķga coraz wiķcej osb piszĴcych oprogramowanie.

KsiĴŃka â Ruby. Tao programowania w 400 przykĀadach Ò to podrķcznik dla tych

programistw, ktrzy 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ĺcuchw

tekstowych z zastosowaniem wyraŃeĺ regularnych oraz sposoby wykonywania nawet

najbardziej zĀoŃonych operacji matematycznych. Znajdziesz tu takŃe omwienie metod

komunikacji z bazami danych, budowania graficznych interfejsw uŃytkownika,

programowania wielowĴtkowego i pisania skryptw 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 interfejsw 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!

Wydawnictwo Helion

ul. Koľciuszki 1c

44-100 Gliwice

tel. 032 230 98 63

e-mail: helion@helion.pl

SPIS TREŚCI

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

RUBY. TAO PROGRAMOWANIA W 400 PRZYKŁADACH

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

ROZDZIAŁ 2.

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

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

ROZDZIAŁ 3.

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

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

ROZDZIAŁ 5.

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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: