Programowanie
w Ruby. Od podstaw
Autor: Peter Cooper
T³umaczenie: Daniel Kaczmarek
ISBN: 978-83-246-1953-5
Tytu³ orygina³u:
Format: 158
×235, stron: 608
Poznaj mo¿liwoœci Ruby!
• Jak rozpocz¹æ przygodê z Ruby?
• Jakie mo¿liwoœci daje Ruby on Rails?
• Jak wykorzystaæ bazy danych w tym jêzyku?
Co sprawi³o, ¿e nieufne zwykle œrodowisko programistów przyjê³o Ruby z entuzjazmem?
Jakie to unikalne mo¿liwoœci posiada ów jêzyk? OdpowiedŸ jest prosta – jego g³ówne
atuty to przejrzysta i elastyczna sk³adnia z wbudowanymi wyra¿eniami regularnymi,
automatyczne oczyszczanie pamiêci oraz przeci¹¿anie operatorów. Ponadto skupiona
wokó³ Ruby ogromna i chêtna do pomocy spo³ecznoœæ sprawia, ¿e to rozwi¹zanie staje
siê jeszcze bardziej atrakcyjne i rozwojowe. „Programowanie w Ruby. Od podstaw” to
ksi¹¿ka, która pomo¿e Ci zorientowaæ siê w specyfice tego jêzyka.
Zanim rozpoczniesz przygodê z Ruby, warto dowiedzieæ siê, jak przygotowaæ swoje
œrodowisko pracy, oraz poznaæ podstawowe zagadnienia zwi¹zane z programowaniem
obiektowym. Po krótkim wstêpie przejdziesz do konkretów – zapoznasz siê ze sk³adni¹,
podstawowymi konstrukcjami oraz metodami sterowania przep³ywem. Zdobêdziesz tak¿e
wiedzê na temat wykonywania operacji na plikach i bazach danych oraz mo¿liwoœci
Ruby w zastosowaniach sieciowych. Nauczysz siê tworzyæ strukturê projektu, przygotowywaæ
dokumentacjê, wyszukiwaæ przydatne biblioteki. Z pewnoœci¹ zainteresuje Ciê rozdzia³
poœwiêcony Ruby on Rails – szkieletowi aplikacyjnemu, który niew¹tpliwie mia³ swój
wp³yw na wzrost popularnoœci tego jêzyka. To wszystko pozwoli Ci na swobodne
wykorzystanie mo¿liwoœci jêzyka Ruby w codziennej pracy!
• Przygotowanie œrodowiska pracy
• Podstawowe zagadnienia z dziedziny programowania obiektowego
• Sk³adnia i konstrukcje jêzyka Ruby
• Sterowanie przep³ywem
• Tworzenie dokumentacji
• Obs³uga b³êdów, testowanie i debugowanie aplikacji
• Obs³uga plików
• Wykorzystanie baz danych
• Mo¿liwoœci i zastosowanie Ruby on Rails
• Wykorzystanie zasobów sieci Internet w Ruby
• Obs³uga sieci, gniazd i demonów
• Przydatne pakiety i biblioteki w Ruby
Poznaj Ruby — od podstaw do perfekcji!
Spis treci
Przedmowa
.................................................................................... 15
O
autorze
....................................................................................... 19
O
redaktorach
technicznych
........................................................... 21
Podzikowania
............................................................................... 23
Wprowadzenie
................................................................................ 25
Cz I
Podstawy ..................................................................... 27
Rozdzia 1. Pierwsze kroki. Instalacja jzyka Ruby ............................................ 29
Instalowanie jzyka Ruby ............................................................................................... 30
Windows .................................................................................................................. 30
Apple Mac OS X ...................................................................................................... 33
Linux ........................................................................................................................ 35
Inne platformy .......................................................................................................... 37
Podsumowanie ................................................................................................................ 39
Rozdzia 2. Programowanie == zabawa.
Krótki przegld jzyka Ruby i zasad obiektowoci ........................... 41
Pierwsze kroki ................................................................................................................ 42
irb: interaktywny Ruby ............................................................................................. 42
Ruby to angielski dla komputerów ........................................................................... 43
Dlaczego Ruby jest doskonaym jzykiem programowania? ................................... 43
cieki umysu ......................................................................................................... 44
Zapisywanie pomysów w kodzie ródowym jzyka Ruby ........................................... 46
Jak Ruby interpretuje rzeczy za pomoc obiektów i klas ......................................... 47
Tworzenie osoby ...................................................................................................... 47
Podstawowe zmienne ............................................................................................... 49
Od osób do zwierzt ................................................................................................. 50
Wszystko jest obiektem .................................................................................................. 53
Metody klasy Kernel ................................................................................................ 55
Przekazywanie danych do metod ............................................................................. 55
Metody klasy String ................................................................................................. 56
Korzystanie z jzyka Ruby z pominiciem orientacji obiektowej .................................. 58
Podsumowanie ................................................................................................................ 59
6
Programowanie w Ruby. Od podstaw
Rozdzia 3. Podstawowe konstrukcje jzyka Ruby:
dane, wyraenia i przepyw sterowania ............................................ 61
Liczby i wyraenia ......................................................................................................... 61
Podstawowe wyraenia ............................................................................................ 62
Zmienne ................................................................................................................... 62
Operatory i wyraenia porównywania ...................................................................... 64
Iterowanie przez liczby przy uyciu bloków i iteratorów ......................................... 65
Liczby zmiennoprzecinkowe .................................................................................... 67
Stae .......................................................................................................................... 68
Tekst i cigi znaków ....................................................................................................... 69
Literay cigów znaków ........................................................................................... 69
Wyraenia z cigami znaków ................................................................................... 71
Interpolacja ............................................................................................................... 72
Metody klasy String ................................................................................................. 73
Wyraenia regularne i manipulowanie cigami znaków .......................................... 74
Tablice i listy .................................................................................................................. 80
Tablice podstawowe ................................................................................................. 80
Dzielenie cigów znaków na tablice ........................................................................ 82
Iterowanie w tablicy ................................................................................................. 83
Inne metody stosowane do dziaania na tablicach .................................................... 84
Tablice asocjacyjne ........................................................................................................ 86
Podstawowe metody do obsugi tablic asocjacyjnych .............................................. 86
Tablice asocjacyjne z tablicami asocjacyjnymi ........................................................ 88
Przepyw sterowania ....................................................................................................... 89
Instrukcje if i unless ................................................................................................. 89
Operator trójargumentowy ?: ................................................................................... 90
Instrukcje elsif oraz case .......................................................................................... 91
Instrukcje while i until .............................................................................................. 92
Bloki kodu ................................................................................................................ 93
Inne przydatne konstrukcje ............................................................................................. 95
Daty i czas ................................................................................................................ 95
Due liczby ............................................................................................................... 98
Zakresy ................................................................................................................... 100
Symbole ................................................................................................................. 101
Przeksztacanie klas ................................................................................................ 102
Podsumowanie .............................................................................................................. 103
Rozdzia 4. Prosta aplikacja w jzyku Ruby ..................................................... 105
Praca z plikami zawierajcymi kod ródowy .............................................................. 105
Tworzenie pliku testowego ..................................................................................... 106
Testowy plik z kodem ródowym ......................................................................... 107
Wykonywanie kodu ródowego ............................................................................ 108
Pierwsza aplikacja: analizator tekstu ............................................................................ 111
Podstawowe funkcje aplikacji ................................................................................ 111
Implementacja aplikacji ......................................................................................... 112
Uzyskanie przykadowego tekstu ........................................................................... 112
adowanie plików tekstowych i zliczanie wierszy ................................................. 113
Zliczanie znaków .................................................................................................... 114
Zliczanie sów ........................................................................................................ 115
Zliczanie zda i akapitów ....................................................................................... 117
Obliczenie wartoci rednich .................................................................................. 119
Kod ródowy aplikacji .......................................................................................... 119
Spis treci
7
Dodatkowe funkcje aplikacji ........................................................................................ 120
Procent sów „znaczcych” .................................................................................... 120
Podsumowanie prezentujce zdania „znaczce” .................................................... 122
Analiza plików innych ni text.txt .......................................................................... 124
Program w wersji finalnej ............................................................................................. 125
Podsumowanie .............................................................................................................. 127
Rozdzia 5. Ekosystem jzyka Ruby ................................................................ 129
Historia jzyka Ruby .................................................................................................... 129
Kraj Wschodzcego Soca .................................................................................... 130
Korzenie jzyka Ruby ............................................................................................ 131
Inwazja na Zachód ................................................................................................. 132
Ruby on Rails ............................................................................................................... 133
Po co utworzono platform Rails ........................................................................... 134
Jak zdobyto Web 2.0 .............................................................................................. 135
Kultura Open Source .................................................................................................... 135
Na czym polega ruch Open Source? ....................................................................... 136
Gdzie i jak uzyska pomoc? ......................................................................................... 137
Listy dystrybucyjne ................................................................................................ 137
Grupy dyskusyjne Usenet ....................................................................................... 138
Internet Relay Chat (IRC) ...................................................................................... 138
Dokumentacja ........................................................................................................ 139
Fora ........................................................................................................................ 140
Doczanie do spoecznoci .......................................................................................... 140
wiadczenie pomocy innym ................................................................................... 141
Dzielenie si kodem ródowym ............................................................................ 141
Blogi ....................................................................................................................... 142
Podsumowanie .............................................................................................................. 143
Cz II Rdze jzyka Ruby ..................................................... 145
Rozdzia 6. Klasy, obiekty i moduy ................................................................ 147
Po co uywa orientacji obiektowej? ............................................................................ 147
Podstawy orientacji obiektowej .................................................................................... 150
Zmienne lokalne, globalne, obiektu i klasy ............................................................ 151
Metody klasy a metody obiektu ............................................................................. 155
Dziedziczenie ......................................................................................................... 157
Nadpisywanie istniejcych metod .......................................................................... 159
Refleksja i odkrywanie metod dostpnych w obiektach ......................................... 161
Enkapsulacja .......................................................................................................... 162
Wielopostaciowo ................................................................................................. 167
Klasy zagniedone ................................................................................................ 168
Zasig staych ......................................................................................................... 169
Moduy, przestrzenie nazw i wczanie kodu ............................................................... 170
Przestrzenie nazw ................................................................................................... 170
Wczanie kodu ...................................................................................................... 173
Obiektowa tekstowa gra przygodowa ........................................................................... 180
Idea gry .................................................................................................................. 180
Klasy pocztkowe .................................................................................................. 180
Struktury: proste klasy danych ............................................................................... 182
Tworzenie komnat .................................................................................................. 184
Uruchamianie gry ................................................................................................... 185
Podsumowanie .............................................................................................................. 188
8
Programowanie w Ruby. Od podstaw
Rozdzia 7. Projekty i biblioteki ...................................................................... 191
Projekty i wykorzystanie kodu z innych plików ........................................................... 191
Proste doczanie pliku ........................................................................................... 192
Doczanie kodu z innych katalogów ..................................................................... 193
Logika programu a doczanie kodu ...................................................................... 194
Doczenia zagniedone ....................................................................................... 195
Biblioteki ...................................................................................................................... 195
Biblioteki standardowe ........................................................................................... 196
RubyGems .............................................................................................................. 198
Podsumowanie .............................................................................................................. 207
Rozdzia 8. Tworzenie dokumentacji, obsuga bdów,
debugowanie i testowanie ............................................................ 209
Tworzenie dokumentacji .............................................................................................. 209
Generowanie dokumentacji przy uyciu RDoc ...................................................... 210
Techniki pracy z RDoc ........................................................................................... 212
Debugowanie i bdy .................................................................................................... 215
Wyjtki i obsuga bdów ....................................................................................... 215
Metody catch i throw .............................................................................................. 219
Debuger jzyka Ruby ............................................................................................. 220
Testowanie .................................................................................................................... 223
Filozofia programowania sterowanego testami ...................................................... 224
Testy jednostkowe .................................................................................................. 226
Inne asercje biblioteki Test::Unit ........................................................................... 228
Testy wzorcowe i profilowanie .................................................................................... 229
Proste wzorcowe testy wydajnoci ......................................................................... 230
Profilowanie ........................................................................................................... 232
Podsumowanie .............................................................................................................. 233
Rozdzia 9. Pliki i bazy danych ....................................................................... 237
Wejcie i wyjcie .......................................................................................................... 237
Dane wejciowe z klawiatury ................................................................................. 238
Wejcie i wyjcie do pliku ...................................................................................... 239
Proste bazy danych ....................................................................................................... 253
Bazy danych w postaci plików tekstowych ............................................................ 253
Przechowywanie obiektów i struktur danych ......................................................... 256
Relacyjne bazy danych i jzyk SQL ............................................................................. 259
Idea relacyjnych baz danych .................................................................................. 260
Wielka czwórka: MySQL, PostgreSQL, Oracle i SQLite ...................................... 261
Instalacja SQLite .................................................................................................... 262
Krótki kurs podstawowych czynnoci w bazie danych i jzyka SQL ..................... 262
Korzystanie z SQLite w jzyku Ruby .................................................................... 267
czenie si z innymi systemami zarzdzania bazami danych ............................... 271
ActiveRecord. Krótki opis ...................................................................................... 276
Podsumowanie .............................................................................................................. 277
Rozdzia 10. Wdraanie aplikacji i bibliotek jzyka Ruby ................................... 281
Dystrybucja prostych programów napisanych w Ruby ................................................. 281
Wiersz ze ciek dostpu do interpretera .............................................................. 283
Skojarzone typy plików w systemie Windows ....................................................... 284
„Kompilowanie” kodu jzyka Ruby ....................................................................... 284
Wykrywanie rodowiska wykonawczego jzyka Ruby ................................................ 286
atwe wykrywanie systemu operacyjnego za pomoc zmiennej
RUBY_PLATFORM ........................................................................................... 287
Zmienne rodowiskowe .......................................................................................... 287
Odczytywanie argumentów wiersza polece .......................................................... 289
Spis treci
9
Udostpnianie i dystrybuowanie bibliotek jzyka Ruby w postaci pakietów gem ........ 290
Tworzenie pakietu gem .......................................................................................... 291
Dystrybucja pakietu gem ........................................................................................ 295
RubyForge .............................................................................................................. 295
Wdraanie aplikacji Ruby jako usug zdalnych ............................................................ 296
Skrypty CGI ........................................................................................................... 296
Serwery HTTP ogólnego przeznaczenia ................................................................ 299
Zdalne wywoania procedur ................................................................................... 303
Podsumowanie .............................................................................................................. 307
Rozdzia 11. Zaawansowane mechanizmy jzyka Ruby ...................................... 309
Dynamiczne wykonywanie kodu .................................................................................. 309
Wizania ................................................................................................................. 310
Inne postacie metody eval ...................................................................................... 311
Tworzenie wasnej wersji attr_accessor ................................................................. 313
Wykonywanie innych programów z poziomu jzyka Ruby ......................................... 314
Odczytywanie wyników dziaania innych programów ........................................... 314
Przekazywanie wykonania do innego programu .................................................... 315
Wykonywanie dwóch programów jednoczenie .................................................... 315
Komunikacja z innym programem ......................................................................... 316
Bezpieczne przetwarzanie danych i niebezpiecznych metod ........................................ 317
Niebezpieczne dane i obiekty ................................................................................. 317
Poziomy zabezpiecze ........................................................................................... 320
Praca z systemem Microsoft Windows ......................................................................... 321
Korzystanie z API systemu Windows .................................................................... 321
Kontrolowanie programów systemu Windows ....................................................... 323
Wtki ............................................................................................................................ 325
Podstawowe czynnoci z wykorzystaniem wtków Ruby ...................................... 325
Zaawansowane operacje z wykorzystaniem wtków ............................................. 326
Biblioteka RubyInline ................................................................................................... 328
Po co uywa C jako jzyka wplatanego? .............................................................. 329
Tworzenie prostej metody lub funkcji .................................................................... 329
Testy wzorcowe wydajnoci kodu C i Ruby .......................................................... 331
Obsuga Unicode i UTF-8 ............................................................................................ 332
Podsumowanie .............................................................................................................. 335
Rozdzia 12. Zaawansowana aplikacja w jzyku Ruby ....................................... 337
Implementacja bota ...................................................................................................... 337
Czym jest bot? ........................................................................................................ 337
Dlaczego bot? ......................................................................................................... 339
Jak implementuje si bota? ..................................................................................... 339
Biblioteka narzdzi do przetwarzania tekstu ................................................................ 340
Implementacja biblioteki WordPlay ....................................................................... 341
Testowanie biblioteki ............................................................................................. 346
Kod ródowy biblioteki WordPlay ........................................................................ 349
Implementacja gównego moduu bota ......................................................................... 351
Cykl ycia programu i jego elementy ..................................................................... 352
Dane dla bota .......................................................................................................... 353
Implementacja klasy Bot oraz mechanizmu adowania danych ............................. 357
Metoda response_to ................................................................................................ 358
Zabawa z botem ..................................................................................................... 363
Kod ródowy najwaniejszych elementów bota .......................................................... 366
bot.rb ...................................................................................................................... 367
basic_client.rb ........................................................................................................ 369
10
Programowanie w Ruby. Od podstaw
Rozszerzanie bota ......................................................................................................... 369
Wykorzystanie plików tekstowych jako róda danych wejciowych do
rozmowy .............................................................................................................. 370
Udostpnienie bota w sieci WWW ......................................................................... 370
Rozmowy midzy dwoma botami .......................................................................... 373
Podsumowanie .............................................................................................................. 374
Cz III Ruby w sieci .............................................................. 375
Rozdzia 13. Ruby on Rails: zabójcza aplikacja jzyka Ruby ............................... 377
Pierwsze kroki .............................................................................................................. 377
Czym jest platforma Rails i po co si jej uywa? ................................................... 378
Instalacja platformy Rails ....................................................................................... 379
Bazy danych ........................................................................................................... 381
Implementacja pierwszej aplikacji Rails ...................................................................... 381
Tworzenie pustej aplikacji Rails ............................................................................. 381
Inicjalizacja bazy danych ....................................................................................... 385
Tworzenie modelu i migracji .................................................................................. 388
Scaffolding ............................................................................................................. 392
Kontrolery i widoki ................................................................................................ 395
Routing ................................................................................................................... 404
Relacje midzy modelami ...................................................................................... 405
Sesje i filtry ............................................................................................................ 407
Pozostae funkcje .......................................................................................................... 409
Makiety .................................................................................................................. 409
Testowanie ............................................................................................................. 412
Moduy rozszerzajce ............................................................................................. 413
Dodatkowe zasoby i przykadowe aplikacje ................................................................. 414
Witryny i samouczki .............................................................................................. 415
Przykadowe aplikacje Rails ................................................................................... 415
Podsumowanie .............................................................................................................. 416
Rozdzia 14. Ruby i internet ............................................................................. 419
HTTP i sie WWW ....................................................................................................... 419
Pobieranie stron WWW .......................................................................................... 420
Generowanie stron WWW i kodu HTML .............................................................. 427
Przetwarzanie treci WWW ................................................................................... 432
Obsuga poczty elektronicznej ...................................................................................... 437
Odczytywanie poczty przy uyciu POP3 ............................................................... 437
Wysyanie wiadomoci pocztowych przy uyciu SMTP ........................................ 439
Wysyanie wiadomoci pocztowych przy uyciu ActionMailer ............................. 441
Transfer plików przy uyciu protokou FTP ................................................................. 442
Nawizywanie poczenia i wykonywanie podstawowych czynnoci FTP ............ 443
Pobieranie plików ................................................................................................... 444
adowanie plików na serwer .................................................................................. 445
Podsumowanie .............................................................................................................. 447
Rozdzia 15. Obsuga sieci, gniazd i demonów .................................................. 449
Najwaniejsze mechanizmy sieciowe ........................................................................... 449
TCP i UDP ............................................................................................................. 450
Adresy IP i DNS ..................................................................................................... 450
Podstawowe operacje sieciowe ..................................................................................... 451
Sprawdzanie dostpnoci komputera lub usugi ..................................................... 451
Wykonywanie zapyta DNS .................................................................................. 453
Nawizywanie bezporedniego poczenia z serwerem TCP ................................. 455
Spis treci
11
Serwery i klienty .......................................................................................................... 457
Klient i serwer UDP ............................................................................................... 457
Implementacja prostego serwera TCP .................................................................... 459
Serwery TCP do obsugi wicej ni jednego klienta .............................................. 460
GServer .................................................................................................................. 462
Serwer czatów oparty na GServer .......................................................................... 465
Serwery WWW i HTTP ......................................................................................... 468
Demony .................................................................................................................. 468
Podsumowanie .............................................................................................................. 470
Rozdzia 16. Przydatne biblioteki i pakiety gem jzyka Ruby ............................. 473
abbrev ........................................................................................................................... 475
Instalacja ................................................................................................................ 475
Przykady ............................................................................................................... 475
Dodatkowe informacje ........................................................................................... 476
base64 ........................................................................................................................... 477
Instalacja ................................................................................................................ 477
Przykady ............................................................................................................... 477
Dodatkowe informacje ........................................................................................... 479
BlueCloth ..................................................................................................................... 480
Instalacja ................................................................................................................ 480
Przykady ............................................................................................................... 480
Dodatkowe informacje ........................................................................................... 481
cgi ................................................................................................................................. 482
Instalacja ................................................................................................................ 482
Przykady ............................................................................................................... 482
Dodatkowe informacje ........................................................................................... 487
chronic .......................................................................................................................... 488
Instalacja ................................................................................................................ 488
Przykady ............................................................................................................... 488
Dodatkowe informacje ........................................................................................... 489
Digest ........................................................................................................................... 490
Instalacja ................................................................................................................ 490
Przykady ............................................................................................................... 490
Dodatkowe informacje ........................................................................................... 492
English .......................................................................................................................... 493
Instalacja ................................................................................................................ 493
Przykady ............................................................................................................... 493
Dodatkowe informacje ........................................................................................... 494
ERB .............................................................................................................................. 495
Instalacja ................................................................................................................ 495
Przykady ............................................................................................................... 495
Dodatkowe informacje ........................................................................................... 497
FasterCSV .................................................................................................................... 498
Instalacja ................................................................................................................ 498
Przykady ............................................................................................................... 498
Dodatkowe informacje ........................................................................................... 502
iconv ............................................................................................................................. 503
Instalacja ................................................................................................................ 503
Przykady ............................................................................................................... 503
Dodatkowe informacje ........................................................................................... 504
logger ............................................................................................................................ 505
Instalacja ................................................................................................................ 505
Przykady ............................................................................................................... 505
Dodatkowe informacje ........................................................................................... 507
12
Programowanie w Ruby. Od podstaw
pp .................................................................................................................................. 508
Instalacja ................................................................................................................ 508
Przykady ............................................................................................................... 508
Dodatkowe informacje ........................................................................................... 509
RedCloth ....................................................................................................................... 510
Instalacja ................................................................................................................ 510
Przykady ............................................................................................................... 510
Dodatkowe informacje ........................................................................................... 511
StringScanner ............................................................................................................... 512
Instalacja ................................................................................................................ 512
Przykady ............................................................................................................... 512
Dodatkowe informacje ........................................................................................... 514
tempfile ......................................................................................................................... 515
Instalacja ................................................................................................................ 515
Przykady ............................................................................................................... 515
Dodatkowe informacje ........................................................................................... 517
uri ................................................................................................................................. 518
Instalacja ................................................................................................................ 518
Przykady ............................................................................................................... 518
Dodatkowe informacje ........................................................................................... 521
zlib ................................................................................................................................ 522
Instalacja ................................................................................................................ 522
Przykady ............................................................................................................... 522
Dodatkowe informacje ........................................................................................... 523
Dodatki .................................................................................... 525
Dodatek A Podsumowanie mechanizmów jzyka Ruby dla programistów ........... 527
Podstawy ...................................................................................................................... 528
Definicje i pojcia .................................................................................................. 528
Interpreter jzyka Ruby i wykonywanie kodu Ruby .............................................. 529
Interactive Ruby ..................................................................................................... 530
Wyraenia, logika i przepyw sterowania ......................................................................... 531
Podstawowe wyraenia .......................................................................................... 531
Niezgodnoci klas .................................................................................................. 532
Wyraenia porównawcze ....................................................................................... 533
Przepyw sterowania .............................................................................................. 534
Orientacja obiektowa .................................................................................................... 538
Obiekty ................................................................................................................... 538
Klasy i metody ....................................................................................................... 539
Refleksja ................................................................................................................. 541
Ponowne otwieranie klas ........................................................................................ 542
Widoczno metod ................................................................................................. 543
Dane ............................................................................................................................. 544
Cigi znaków .......................................................................................................... 544
Wyraenia regularne .............................................................................................. 545
Liczby ..................................................................................................................... 546
Tablice .................................................................................................................... 548
Tablice asocjacyjne ................................................................................................ 549
Struktury zoone ................................................................................................... 549
Wejcie-wyjcie ............................................................................................................ 550
Pliki ........................................................................................................................ 550
Bazy danych ........................................................................................................... 551
Sie WWW ............................................................................................................. 551
Spis treci
13
Biblioteki ...................................................................................................................... 552
Organizacja plików ................................................................................................ 552
Tworzenie pakietów ............................................................................................... 553
Dodatek B Przegld jzyka Ruby .................................................................... 555
Przydatne klasy i metody .............................................................................................. 555
Array ...................................................................................................................... 555
Bignum i Fixnum ................................................................................................... 557
Enumerable ............................................................................................................ 558
Float ....................................................................................................................... 559
Hash ....................................................................................................................... 559
Integer .................................................................................................................... 560
Numeric .................................................................................................................. 560
Object ..................................................................................................................... 561
String ...................................................................................................................... 562
Skadnia wyrae regularnych ...................................................................................... 564
Opcje wyrae regularnych .................................................................................... 564
Specjalne znaki i formacje ..................................................................................... 565
Sufiksy znaków i podwyrae ................................................................................ 565
Klasy wyjtków ............................................................................................................ 566
Zmienne specjalne ........................................................................................................ 568
Licencja jzyka Ruby ................................................................................................... 570
Dodatek C Przydatne róda informacji ........................................................... 573
Informacje ogólne ......................................................................................................... 573
Ruby ....................................................................................................................... 573
Ruby on Rails ......................................................................................................... 574
Blogi ............................................................................................................................. 575
Blogi spoecznociowe i spisy blogów ................................................................... 575
Blogi prywatne ....................................................................................................... 576
Fora i grupy dyskusyjne ............................................................................................... 577
Listy dystrybucyjne ...................................................................................................... 577
Czaty w czasie rzeczywistym ....................................................................................... 578
Samouczki i przewodniki ............................................................................................. 579
Instalacja ................................................................................................................ 579
Ruby i sposoby korzystania z niego ....................................................................... 580
Ruby on Rails ......................................................................................................... 581
Inne ........................................................................................................................ 582
Skorowidz
.................................................................................... 583
Rozdzia 4.
Prosta aplikacja
w jzyku Ruby
Jak dotd skupialimy si na podstawach jzyka Ruby i przedstawianiu jego mechanizmów
na najbardziej podstawowym poziomie. W tym rozdziale przejdziemy ju do praktycz-
nych zagadnie zwizanych z implementacj aplikacji i opracujemy pen, cho prost
aplikacj w jzyku Ruby, która bdzie wykorzystywa proste funkcje. Po zaimplemento-
waniu i przetestowaniu prostej aplikacji przedstawione zostan sposoby jej rozbudowy,
tak by staa si bardziej uyteczna. W trakcie tworzenia aplikacji omówione zostan nowe
aspekty programowania, o których nie wspominano jeszcze we wczeniejszych rozdziaach.
Najpierw zostan opisane podstawowe zagadnienia dotyczce organizacji kodu ródowe-
go. Dopiero potem rozpoczniemy programowanie z prawdziwego zdarzenia.
Praca z plikami
zawierajcymi kod ródowy
Dotychczas do nauki jzyka uywalimy interaktywnego interpretera jzyka Ruby — irb.
Jednak aby zaimplementowa jakikolwiek program, którego bdzie mona uy równie
w póniejszym czasie, kod ródowy programu trzeba zapisa w pliku przechowywanym
na dysku (albo przesyanym w internecie, przechowywanym na pycie CD itp.).
Narzdzia do tworzenia i manipulowania plikami z kodem ródowym zale od uywa-
nego systemu operacyjnego oraz osobistych preferencji programisty. W systemie Windows
do tworzenia i edycji plików tekstowych wystarczy znany wikszoci uytkowników
Notatnik. Z kolei w wierszu polece Linuksa mona skorzysta z edytora vi, Emacs
albo pico/nano. Uytkownicy komputerów Mac maj do dyspozycji program TextEdit.
Bez wzgldu na to, które narzdzie zostanie ostatecznie uyte, musi ono umoliwia
tworzenie nowych plików i zapisywanie ich jako zwykych plików tekstowych, aby
106
Cz I
i Podstawy
interpreter jzyka Ruby móg odpowiednio z nich korzysta. W nastpnych kilku punk-
tach przedstawione zostan wybrane narzdzia dostpne dla kadej z wymienionych plat-
form, które nadaj si do tworzenia programów w jzyku Ruby.
Tworzenie pliku testowego
Pierwszym krokiem na drodze do utworzenia aplikacji w jzyku Ruby jest zaznajomienie
si z edytorem tekstu. Oto kilka wskazówek dotyczcych najwaniejszych platform
systemowych.
Czytelnicy, którzy potrafi ju korzysta z edytorów tekstu i wiedz, jak pisze si i zapi-
suje kod ródowy, mog od razu przej do lektury punktu pod tytuem „Testowy plik
z kodem ródowym”.
Windows
Jeeli wykonano przedstawione w rozdziale 1. instrukcje dotyczce pobrania i instalacji
jzyka Ruby, w grupie programów Ruby w menu Start powinny by dostpne dwa edytory
tekstu o nazwach SciTE oraz FreeRIDE. SciTE to ogólne narzdzie do edycji kodu
ródowego, natomiast FreeRIDE to edytor kodu ródowego w jzyku Ruby, zreszt
równie zaimplementowany w Ruby. SciTE dziaa nieco szybciej, natomiast FreeRIDE
jest wystarczajco szybki, aby wykonywa w nim ogólne zadania programistyczne, a poza
tym jest lepiej zintegrowany z interpreterem jzyka Ruby.
Po uruchomieniu edytora otwierany jest pusty dokument, w którym mona zacz wpisy-
wa kod ródowy Ruby (we FreeRIDE nowy dokument tworzy si przez wybranie
odpowiedniego polecenia z menu File). W menu File znajduj si równie polecenia do
zapisania kodu ródowego na dysku, co uczynimy w nastpnym punkcie. FreeRIDE
pozwala ponadto zgrupowa pojedyncze pliki z kodem w ramach jednego projektu.
Mac OS X
System Mac OS X udostpnia kilka edytorów tekstu. Najczciej uywanym edytorem
wród programistów Ruby jest TextMate firmy MacroMates (http://www.macromates.
com/), widoczny na rysunku 4.1. Edytor ten nie jest jednak darmowy — jego koszt
wynosi w przyblieniu 50 dolarów. Ciekaw alternatyw jest edytor Xcode doczany do
pakietu OS X Development Tools, lecz wymaga on umiejtnoci instalowania i uywania
narzdzi programistycznych (dostpnych na dysku instalacyjnym OS X). W zalenoci
od tego, jaki komputer Mac jest uywany, Xcode moe wydawa si stosunkowo wol-
nym narzdziem.
Darmowym edytorem dostpnym w OS X jest TextEdit. Aby go uruchomi, naley
otworzy folder Applications i dwukrotnie klikn ikon TextEdit. W domylnym trybie
pracy TextEdit nie jest edytorem zwykego tekstu, natomiast gdy w menu Format wybie-
rze si polecenie Make Plain Text, edytor zostanie przeczony w tryb odpowiedni do
edytowania kodu ródowego jzyka Ruby.
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
107
Rysunek 4.1.
Edytor TextMate
Na razie wystarczy wpisa albo wklei kawaek kodu Ruby i wybra polecenie File/Save,
aby zapisa kod w wybranej lokalizacji na dysku. Dobrym rozwizaniem bdzie zapewne
utworzenie we wasnym folderze domowym (czyli w folderze po lewej stronie, którego
nazw jest nazwa uytkownika) folderu o nazwie ruby i zapisanie w nim wanie pliku
z kodem ródowym. W dalszych instrukcjach bdziemy bowiem przyjmowa zaoenie,
e w folderze domowym uytkownika istnieje wanie folder o nazwie ruby.
Linux
Dystrybucje systemu Linux zwykle zawieraj co najmniej kilka rónych edytorów tekstu;
zawsze natomiast w kadej dystrybucji znajduje si co najmniej jeden edytor. Uytkownicy
korzystajcy wycznie z wiersza polece albo z okna terminala bd zapewne umieli
korzysta z edytora vi, Emacs, pico albo nano — wszystkie te narzdzia równie na-
daj si do tworzenia kodu ródowego Ruby. Jeeli uywany jest Linux z graficznym
interfejsem uytkownika, zapewne dostpny jest edytor Kate (KDE Advanced Text
Editor) i (lub) gedit (GNOME Editor). Wszystkie wspomniane programy s doskonaymi
edytorami kodów ródowych.
Mona take pobra i zainstalowa FreeRIDE, czyli darmowy, wieloplatformowy edytor
kodu ródowego stworzony z myl o programistach Ruby. Edytor pozwala wyko-
nywa kod ródowy jednym klikniciem myszy bezporednio z poziomu narzdzia
(jeeli uywany jest graficzny interfejs uytkownika X). Kod wpisywany w edytorze
jest ponadto kolorowany zgodnie ze skadni jzyka, dziki czemu atwiej si go czyta.
Wicej informacji na temat FreeRIDE znajduje si na stronie pod adresem http://freeride.
rubyforge.org/.
Na razie najlepszym pomysem bdzie utworzenie we wasnym folderze domowym no-
wego folderu o nazwie ruby, w którym póniej zapisywane bd pliki z kodem jzyka Ruby.
Testowy plik z kodem ródowym
Po wybraniu rodowiska, w którym bd edytowane i zapisywane pliki tekstowe, mona
wpisa nastpujcy kod:
x = 2
print "Aplikacja dziaa poprawnie, jeli 2 + 2 = #{x + x}"
108
Cz I
i Podstawy
Jeeli przedstawiony kod nie jest zrozumiay, moe to oznacza, e pominito zbyt
wiele punktów z poprzednich rozdziaów. Naley zatem powróci do lektury rozdziau 3.
W niniejszym rozdziale potrzebna jest znajomo wszystkich zagadnie prezento-
wanych w rozdziale 3.
Kod ródowy naley zapisa w pliku o nazwie a.rb, w wybranym folderze. Warto w tym
celu utworzy folder o nazwie ruby w atwo dostpnej lokalizacji. W systemie Windows
folder ruby moe znajdowa si w katalogu gównym na dysku C, natomiast w syste-
mach OS X i Linux mona go umieci we wasnym katalogu domowym.
RB
to standardowe rozszerzenie plików z kodem jzyka Ruby, tak samo jak
PHP
jest
rozszerzeniem plików z kodem PHP,
TXT
dotyczy plików ze zwykym tekstem, a
JPG
jest standardowym rozszerzeniem obrazków w formacie JPEG.
Czas wic uruchomi kod ródowy.
Wykonywanie kodu ródowego
Gdy utworzony ju zostanie plik z kodem ródowym jzyka Ruby o nazwie a.rb, trzeba
ten kod wykona. Jak zwykle sposób uruchamiania kodu zaley od uywanego systemu
operacyjnego, dlatego najlepiej jest przeczyta tre którego z kolejnych punktów, po-
wiconych konkretnym systemom. Jeeli uywany system nie jest opisywany w adnym
z punktów, wówczas najprawdopodobniej trzeba bdzie wykona czynnoci identyczne
z tymi, które dotycz systemu OS X albo Linux.
Zawsze, gdy w ksice bdzie mowa o „wykonaniu” albo „uruchomieniu” programu, cho-
dzi bdzie o wykonanie czynnoci opisywanych w punkcie powiconym okrelonemu
systemowi operacyjnemu.
W tym rozdziale utworzona zostanie pena aplikacja, jednak i tak nadal w niektórych
momentach warto bdzie korzysta z irb, aby sprawdzi dziaanie niektórych instrukcji
albo przetestowa opisywane rozwizania. Najlepiej samodzielnie i na bieco de-
cydowa, którego z tych dwóch narzdzi (irb i edytor kodu) uy. W przypadku krótkich
rozwiza i niewielkich bloków kodu bardziej uyteczne bdzie zapewne irb, poniewa
nie bdzie trzeba wówczas powica dodatkowego czasu na przeczanie si midzy
edytorem kodu a interpreterem.
Windows
Jeeli uywany jest program SciTE albo FreeRIDE zainstalowany przez instalator Ruby
dla systemu Windows, wówczas bezporednio z ich poziomu mona uruchamia programy
napisane w jzyku Ruby (rysunek 4.2). W obu programach do uruchamiania kodu ró-
dowego suy klawisz F5. Podobnym rozwizaniem jest wybranie polecenia z menu
(Tools/Go w SciTE albo Run/Run w FreeRIDE). Jednak przed wykonaniem kodu trzeba
najpierw zapisa plik, w którym ten kod si znajduje. Jeeli plik nie zostanie zapisany,
kod moe da nieprzewidziane wyniki (na przykad moe doj do wykonania ostatnio
zapisanej wersji kodu) albo wywietlony zostanie komunikat z prob o zapisanie pliku.
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
109
Rysunek 4.2.
Efekt wykonania
kodu w narzdziu
FreeRIDE w systemie
Windows (wynik
dziaania kodu znajduje
si w dolnym oknie
edytora)
Programy Ruby mona take uruchamia w wierszu polece. W tym celu naley przej
do wiersza polece (w menu Start wybra polecenie Uruchom i wpisa
cmd
, a nastpnie
klikn przycisk OK), za pomoc polecenia
cd
przej do folderu, w którym znajduje si
plik a.rb, i wpisa polecenie
ruby a.rb
.
Metoda z wierszem polece jest jednak przeznaczona dla osób, które potrafi porusza
si po dysku przy uyciu polece systemu operacyjnego. Inn opcj, tym razem dla uyt-
kowników potraficych definiowa skróty, jest utworzenie skrótu prowadzcego do pliku
wykonywalnego Ruby (ruby.exe) i przeciganie na ten skrót pliku zawierajcego kod
ródowy.
Mac OS X
W systemie Mac OS X najprostsz metod uruchamiania aplikacji napisanych w Ruby
jest wykorzystanie okna Terminal, tak samo jak do uruchamiania interpretera irb. Dziaa-
nie okna Terminal opisano w rozdziale 1. Jeeli wykonane zostay przedstawione tam
instrukcje, naley podj nastpujce dodatkowe dziaania:
1.
Uruchomi Terminal (znajduje si on w Applications/Utilities).
2.
Za pomoc polecenia
cd
przej do folderu, w którym zapisano plik a.rb, na
przykad
cd ~/ruby
. Polecenie o tej treci spowoduje, e Terminal przejdzie
do folderu ruby znajdujcego si w domowym folderze uytkownika.
3.
Wpisa polecenie
ruby a.rb
i nacisn klawisz Enter, aby wykona skrypt Ruby.
4.
Jeeli zwrócony zostanie bd o treci
ruby: No such file or directory – a.rb
(LoadError)
, oznacza to, e biecym folderem jest folder inny ni ten, w którym
zapisano plik a.rb, i konieczne jest ponowne ustalenie, gdzie plik z kodem
ródowym si znajduje.
110
Cz I
i Podstawy
Jeeli wykonanie pliku a.rb da prawidowy wynik, bdzie mona przej od razu do
punktu „Pierwsza aplikacja: Analizator tekstu”.
Linux i inne systemy uniksowe
W Linuksie oraz systemach z rodziny Unix aplikacje napisane w jzyku Ruby uruchamia
si z poziomu powoki (czyli w oknie terminala) w taki sam sposób, w jaki uruchamia si
irb. Sposób uruchamiania irb opisano w rozdziale 1., dlatego przedstawione tam procedury
trzeba wykona ponownie, a nastpnie podj dziaania zaprezentowane poniej:
1.
Uruchomi emulator terminala (na przykad xterm), aby przej do wiersza
polece lub powoki Linuksa.
2.
Za pomoc polecenia
cd
przej do katalogu, w którym znajduje si plik a.rb
(na przykad polecenie
cd ~/ruby
spowoduje przejcie do katalogu ruby
znajdujcego si bezporednio w katalogu domowym, którym zazwyczaj jest
/home/nazwauytkownika/).
3.
Wpisa polecenie
ruby a.rb
i nacisn Enter, aby wykona skrypt a.rb.
Jeeli na skutek wykonania skryptu a.rb zwrócone zostan oczekiwane wyniki, mona
przej do lektury kolejnych punktów.
Edytory tekstu a edytory kodu ródowego
Wczeniej powiedziano, e zasadniczo kod ródowy jest zwykym tekstem. To oczywicie
prawda i kod ródowy mona pisa w zwykym edytorze tekstów, jednak wykorzystanie do
tego specjalistycznego edytora kodu ródowego (albo zintegrowanego rodowiska progra-
mistycznego IDE) z pewnoci przyniesie dodatkowe korzyci.
Edytor FreeRIDE jest przykadem edytora stworzonego konkretnie z myl o programistach Ruby.
Narzdzie pozwala edytowa tekst, podobnie jak kady inny edytor tekstu, lecz oprócz tego
udostpnia take dodatkowe funkcje, takie jak kolorowanie kodu ródowego, a take umoliwia
wykonywanie kodu bezporednio z poziomu edytora.
Wedug niektórych programistów kolorowanie skadni kodu ródowego jest funkcj nie do
przecenienia, poniewa dziki temu kod jest bardziej czytelny. Nazwy zmiennych, wyraenia,
literay cigów znaków oraz inne elementy kodu ródowego s prezentowane w odmiennych
kolorach, dziki czemu atwiej je wyowi z tekstu.
Wybór midzy edytorem kodu ródowego a zwykym edytorem tekstów jest wycznie decyzj
programisty, najlepiej jednak wypróbowa narzdzia reprezentujce obydwie grupy. Wielu
programistów ceni sobie wolno korzystania ze zwykego edytora tekstów i uruchamiania tak
zaimplementowanego kodu w wierszu polece; inni z kolei s zdeklarowanymi uytkownikami
zintegrowanego rodowiska programistycznego.
FreeRIDE jest dostpny w witrynie pod adresem http://freeride.rubyforge.org/, za konku-
rencyjne wobec niego narzdzie do edycji kodu ródowego Ruby i Rails noszce nazw Ra-
dRails jest dostpne w witrynie pod adresem http://www.radrails.org/. Warto jest wypró-
bowa w uywanym systemie operacyjnym obydwa wymienione narzdzia, poniewa mog
one lepiej spenia oczekiwania i uatwia prac programistyczn.
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
111
Pierwsza aplikacja: analizator tekstu
Celem niniejszego rozdziau jest zaimplementowanie aplikacji bdcej analizatorem tekstu.
Kod jzyka Ruby bdzie wczytywa tekst znajdujcy si w pliku zewntrznym, analizowa
tekst pod ktem statystycznym oraz wystpowania rónych wzorców, a nastpnie wywie-
tla wyniki analizy uytkownikowi. Nie jest to wprawdzie adna aplikacja z trójwymiarow
grafik ani efektowna witryna internetowa, lecz programy do przetwarzania tekstu to
podstawowe narzdzia wykorzystywane w celu administrowania systemami i tworzenia
aplikacji. Tego rodzaju aplikacje s nieocenione, gdy zachodzi konieczno parsowania
plików dziennika zdarze oraz tekstu wpisywanego przez uytkownika w witrynach inter-
netowych, a take w przypadku wykonywania operacji na innych danych tekstowych.
Dziki obecnoci funkcji do obsugi wyrae regularnych jzyk Ruby doskonale nadaje
si do analizy tekstu i dokumentów; równie przydatne s metody
scan
i
split
. Zarówno
wspomniane metody, jak i funkcje do obsugi wyrae regularnych bd czsto wykorzy-
stywane w dalszej czci ksiki.
W trakcie tworzenia aplikacji skupimy si na jak najszybszym zaimplementowaniu
potrzebnych funkcji kosztem projektowania precyzyjnej struktury obiektowej, tworzenia
dokumentacji czy testowania aplikacji zgodnie z przyjtymi metodologiami. Reguy
orientacji obiektowej zostan szczegóowo omówione w rozdziale 6., za zagadnienia
dotyczce dokumentowania i testowania kodu bd przedmiotem rozdziau 8.
Podstawowe funkcje aplikacji
Analizator tekstu bdzie generowa statystyki, w których bd si znajdowa nastpujce
dane:
Liczba znaków.
Liczba znaków bez znaków spacji.
Liczba wierszy.
Liczba sów.
Liczba zda.
Liczba akapitów.
rednia liczba sów w zdaniu.
rednia liczba zda w akapicie.
Ostatnie dwie wartoci atwo jest obliczy na podstawie danych szczegóowych. Jeeli
znana jest liczba wszystkich sów oraz liczba wszystkich zda, to wystarczy wykona prost
operacj dzielenia, aby wyznaczy redni liczb sów w jednym zdaniu.
112
Cz I
i Podstawy
Implementacja aplikacji
Przed przystpieniem do implementowania nowego programu warto jest najpierw zasta-
nowi si nad najwaniejszymi czynnociami, które program bdzie wykonywa. W prze-
szoci czsto rysowano tak zwane diagramy przepywu (ang. flow charts), ilustrujce
kolejno operacji wykonywanych przez komputer. Obecnie jednak dostpne nowoczesne
narzdzia, takie jak Ruby, pozwalaj na eksperymentowanie i modyfikowanie aplikacji
„na ywo”. Aplikacja bdzie musiaa wykonywa nastpujce czynnoci:
1.
Zaadowa plik lub dokument zawierajcy tekst, który ma podlega analizie.
2.
W trakcie adowania tekstu z pliku zlicza kolejne wiersze (jest to jedna
ze zwracanych statystyk).
3.
Umieszcza tekst w cigu znaków i zmierzy jego dugo, aby uzyska
liczb znaków.
4.
Tymczasowo usun wszystkie znaki niewidoczne i ponownie zmierzy
dugo tekstu, aby otrzyma liczb znaków bez znaków spacji.
5.
Podzieli tekst wzgldem znaków niewidocznych, aby uzyska liczb sów.
6.
Podzieli tekst wzgldem znaków kropki, aby uzyska liczb zda.
7.
Podzieli tekst wzgldem wystpujcych jeden po drugim znaków nowego
wiersza, aby uzyska liczb akapitów.
8.
Wykona obliczenia, aby uzyska wartoci rednie.
Naley utworzy nowy, pusty plik kodu ródowego Ruby i zapisa go w folderze ruby
pod nazw analyzer.rb. Plik bdzie wypeniany kolejnymi fragmentami kodu ródowego
w nastpnych punktach.
Uzyskanie przykadowego tekstu
Przed rozpoczciem kodowania trzeba najpierw przygotowa dane testowe, które bd
przetwarzane przez analizator. Doskonaym przykadem moe by fragment ksiki
Oliver Twist w wersji oryginalnej, której tre jest dostpna za darmo i atwa do znalezienia.
Tekst powieci znajduje si pod adresem http://www.rubyinside.com/book/oliver.txt
oraz http://www.dickens-literature.com/Oliver_Twist/0.html i mona jego fragment sko-
piowa do pliku tekstowego. Plik najlepiej jest zapisa w tym samym folderze, w którym
znajduje si ju analyzer.rb, pod nazw text.txt. Domylnie nasza aplikacja bdzie prze-
twarza wanie zawarto pliku o nazwie text.txt (cho póniej zostanie rozszerzona
o moliwo wskazywania jej równie innych róde danych).
Jeeli strony pod podanymi adresami s w danym momencie niedostpne, mona
wpisa w wyszukiwarce tekst „twist workhouse rendered profound thingummy”
— powinno to uatwi znalezienie innego róda tekstu powieci. Alternatywnym
rozwizaniem jest wykorzystanie innego dostpnego fragmentu tekstu.
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
113
Jeeli jako przykad uywany jest fragment powieci Oliver Twist, to aby uzyska wyniki
przynajmniej zblione do prezentowanych w kolejnych przykadach z tego rozdziau,
naley skopiowa jedynie fragment tekstu z pocztku powieci, zawarty midzy nastpu-
jcymi zdaniami:
Among other public buildings in a certain town, which for many reasons it will be prudent
´to refrain from mentioning
Oraz:
Oliver cried lustily. If he could have known that he was an orphan, left to the tender
´mercies of church-wardens and overseers, perhaps he would have cried the louder.
adowanie plików tekstowych i zliczanie wierszy
Czas zacz kodowa! Pierwsza czynno polega na zaadowaniu pliku. Ruby udostpnia
bogaty zbiór metod do operowania na plikach, które nale do klasy
File
. W niektórych
innych jzykach programowania przetwarzanie pliku wymaga wywoywania metod ró-
nych klas, natomiast w jzyku Ruby cay interfejs jest bardzo prosty. Oto polecenie, które
otwiera plik text.txt:
File.open("text.txt").each { |line| puts line }
Polecenie mona zapisa w pliku analyzer.rb i je wykona. Jeeli text.txt znajduje si
w biecym katalogu, w wyniku wykonania polecenia na ekranie pojawi si peen
tekst zawarty w pliku.
Przedstawione polecenie da od klasy
File
otwarcia pliku o nazwie text.txt, a nastp-
nie — podobnie jak w przypadku tablicy — bezporednio na tym pliku mona wywoa
metod
each
, dziki czemu kady wiersz tekstu zostanie przekazany do wewntrznego
bloku kodu. W bloku kodu natomiast znajduje si metoda
puts
, która wywietli wiersz na
ekranie. (W rozdziale 9. mechanizmy otwierania i manipulowania plikami zostan przed-
stawione bardziej szczegóowo; omówione zostan take rozwizania bardziej efektywne
ni stosowane w tym rozdziale!).
Tre kodu naley zmieni na nastpujc:
line_count = 0
File.open("text.txt").each { |line| line_count += 1 }
puts line_count
Najpierw inicjowana jest zmienna
line_count
, która bdzie przechowywa liczb wierszy
tekstu. Nastpnie plik zostaje otwarty i wykonywana jest iteracja przez kolejne jego wier-
sze; jednoczenie w kadej iteracji warto zmiennej
line_count
jest zwikszana o
1
. Po
zakoczeniu iteracji uzyskana liczba jest wywietlana na ekranie (w przypadku tekstu
z powieci Oliver Twist powinna zosta zwrócona liczba zbliona do 121). W ten sposób
uzyskano pierwsz statystyk!
Wiersze zostay zatem policzone, wci jednak nie mamy dostpu do zawartoci pliku,
aby policzy wystpujce w nim sowa, akapity, zdania i tak dalej. Nie jest to jednak trudne
zadanie. Wystarczy zmieni nieco dotychczasowy kod i doda w nim zmienn
text
, do
której dopisywane bd kolejne odczytywane wiersze:
114
Cz I
i Podstawy
text=''
line_count = 0
File.open("text.txt").each do |line|
line_count += 1
text << line
end
puts "#{line_count} wierszy"
Naley pamita, e nawiasy klamrowe
{ i } otaczajce blok kodu to standardowy styl
wyznaczania bloków zawierajcych tylko jeden wiersz kodu, natomiast w przypadku
bloków wielowierszowych lepiej jest uywa sów
do i end. Jest to jednak tylko konwen-
cja, a nie wymóg.
W odrónieniu od poprzedniej wersji kodu nowa wersja zawiera zmienn
text
i dodaje
do niej kolejne wiersze odczytywane z pliku. Gdy iteracja przez zawarto pliku dobiegnie
koca — to znaczy gdy wszystkie wiersze zostan ju wczytane —
text
bdzie zawiera
cig znaków z pen zawartoci tekstu z pliku, gotowy do przetwarzania.
Jest to najprostszy sposób wczytywania zawartoci pliku do pojedynczego cigu zna-
ków i zliczania wierszy. Klasa File udostpnia jednak równie inne metody, za pomoc
których tekst z pliku mona wczyta szybciej. Przykadowy kod mona przepisa do na-
stpujcej postaci:
lines = File.readlines("text.txt")
line_count = lines.size
text = lines.join
puts "#{line_count} wierszy"
Ten sposób jest o wiele prostszy! Klasa
File
implementuje metod
readlines
, która
wczytuje ca zawarto do tablicy wiersz po wierszu. W ten sposób mona jednoczenie
policzy wiersze i poczy je w jeden cig znaków.
Zliczanie znaków
Drug statystyk, któr najatwiej bdzie policzy, jest liczba znaków znajdujcych si
w pliku. Dziki temu, e caa zawarto pliku znajduje si w zmiennej
text
i zmienna ta
jest cigiem znaków, wystarczy uy udostpnianej przez kady cig znaków metody
length
, aby uzyska rozmiar pliku, a co za tym idzie — liczb znaków.
Na kocu kodu z poprzedniego przykadu w pliku analyzer.rb trzeba dopisa nastpujce
dwa wiersze:
total_characters = text.length
puts "#{total_characters} znaków"
Wykonanie kodu z pliku analyzer.rb na tekcie Oliver Twist spowoduje zwrócenie nast-
pujcych wyników:
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
115
121 wierszy
6165 znaków
Drug wymagan statystyk, która wie si z liczb znaków, jest czna liczba znaków
w tekcie z wyczeniem znaków spacji. Jak pamitamy z rozdziau 3., cigi znaków
udostpniaj metod
gsub
, która wykonuje globalne zastpienie (podobnie jak operacja
„szukaj i zastp”) w cigu znaków, na przykad:
"to jest test".gsub(/t/, 'X')
Xo jesX XesX
W taki sam sposób za pomoc metody
gsub
mona usun z cigu znaków
text
wszystkie
znaki spacji, a nastpnie ponownie przy uyciu
length
odczyta dugo zmiennej
text
w nowej postaci. W pliku analyzer.rb naley dopisa nastpujce wiersze kodu:
total_characters_nospaces = text.gsub(/\s+/, '').length
puts "#{total_characters_nospaces} znaków nie liczc spacji"
Wykonanie kodu z pliku analyzer.rb na fragmencie powieci Oliver Twist spowoduje
zwrócenie nastpujcych wyników:
121 wierszy
6165 znaków
5055 znaków nie liczc spacji
Zliczanie sów
Funkcj standardowo udostpnian przez programy do przetwarzania tekstu jest
„licznik sów”. Zadaniem funkcji jest wskazywanie liczby penych sów znajdujcych
si w caym dokumencie lub w zaznaczonym fragmencie tekstu. Na podstawie tej in-
formacji mona oszacowa, ile stron zajmie dany tekst po wydrukowaniu. Czsto zdarza
si równie, e trzeba napisa dokument o okrelonej liczbie sów — wówczas funkcja
zliczania sów jest wrcz nieoceniona.
Funkcj mona zaimplementowa co najmniej na dwa róne sposoby, poprzez:
1.
odczytanie liczby cigych grup znaków za pomoc metody
scan
,
2.
podzielenie tekstu na czci wzgldem znaków spacji i odczytanie liczby
uzyskanych w ten sposób fragmentów przy uyciu metod
split
i
size
.
Przeanalizujemy obydwa podejcia i wybierzemy lepsze z nich. Jak pamitamy z roz-
dziau 3., metoda
scan
dziaa w ten sposób, e iteruje przez cig znaków z tekstem i od-
najduje wskazane wzorce, na przykad:
puts "to jest test".scan(/\w/).join
tojesttest
116
Cz I
i Podstawy
W przykadzie metoda
scan
wyszukuje w cigu znaków sekwencje pasujce do wzorca
\w
, czyli specjalnego wzorca reprezentujcego wszystkie znaki alfanumeryczne (wraz ze
znakiem podkrelenia), po czym umieszcza je w tablicy. Elementy tablicy zostaj zczone
ze sob do postaci cigu znaków, który na kocu jest wywietlany na ekranie.
Tak samo mona postpi z grupami znaków alfanumerycznych. W rozdziale 3. wspo-
mniano, e aby do wyraenia regularnego dopasowa wiksz liczb znaków, naley uy
znaku
+
. Spróbujmy zatem:
puts "to jest test".scan(/\w+/).join('-')
to-jest-test
Tym razem metoda wyszukaa wszystkie grupy znaków alfanumerycznych i umiecia je
w tablicy, której elementy zostay nastpnie poczone w jeden cig znaków z wykorzysta-
niem znaku
–
jako separatora.
Aby odczyta liczb sów znajdujcych si w cigu znaków, mona uy metod tabli-
cowych
length
albo
size
. Obydwie metody zwracaj liczb elementów, zamiast je ze
sob czy:
puts "to jest test".scan(/\w+/).length
3
Doskonale! A w jaki sposób mona wykorzysta metod
split
do podzielenia tekstu na
czci?
Zastosowanie metody
split
ilustruje gówn zasad jzyka Ruby (a take niektórych
innych jzyków, w szczególnoci Perla), wedug której „kad operacj mona wykona
na wicej ni jeden sposób!”. Analiza rónych rozwiza danego problemu jest warun-
kiem zostania dobrym programist, poniewa kade z moliwych rozwiza moe cha-
rakteryzowa si odmienn wydajnoci.
Cig znaków naley podzieli wzgldem znaków spacji, a nastpnie sprawdzi dugo
tak uzyskanej tablicy:
puts "to jest test".split.length
3
Domylnie metoda
split
dzieli cig znaków wzgldem znaków niewidocznych (poje-
dynczego lub wicej ni jeden nastpujcych po sobie znaków spacji, tabulacji, nowego
wiersza i tak dalej). Dziki temu kod ródowy jest krótszy i bardziej czytelny ni rozwi-
zanie wykorzystujce metod
scan
.
Czym si zatem róni obydwa rozwizania? Krótko mówic, pierwsze z nich polega na
wyszukaniu sów i zwróceniu ich w celu sprawdzenia ich liczby, za drugie sprowadza si
do podzielenia cigu znaków na podstawie znaków oddzielajcych od siebie kolejne sowa
— czyli znaków niewidocznych — i sprawdzeniu, na ile czci cig rzeczywicie zo-
sta podzielony. Co ciekawe, kade z tych rozwiza moe zwróci odmienne wyniki:
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
117
text = "Nic nie jest czarno-biae."
puts "Metoda scan: #{text.scan(/\w+/).length}"
puts "Metoda split: #{text.split.length}"
Metoda scan: 6
Metoda split: 4
To ciekawe! Metoda
scan
iteruje przez wszystkie bloki znaków alfanumerycznych,
których oczywicie jest sze w przykadowym zdaniu. Jeeli natomiast cig znaków
zostanie podzielony na podstawie znaków spacji, okae si, e sowa s tylko cztery.
Rónica wynika z obecnoci w cigu znaków sów ze znakiem mylnika. Mylnik nie
jest znakiem „alfanumerycznym”, dlatego
scan
traktuje „czarno” i „biae” jako dwa oddziel-
ne sowa.
W pliku analyzer.rb warto wykorzysta nowe informacje. Naley zatem dopisa na-
stpujce dwa wiersze kodu:
word_count = text.split.length
puts "#{word_count} sów"
Wykonanie kodu znajdujcego si w pliku analyzer.rb spowoduje wywietlenie nastpu-
jcych wyników:
121 wierszy
6165 znaków
5055 znaków nie liczc spacji
1093 sów
Zliczanie zda i akapitów
Dziki temu, e wiemy ju, w jaki sposób naley zlicza sowa, zliczenie zda i akapitów
jawi si ju jako proste zadanie. W przypadku analizy zda i akapitów trzeba obra inne
kryteria podziau ni dzielenie cigu znaków wzgldem znaków niewidocznych.
Zdania kocz si znakiem kropki, znakiem zapytania albo wykrzyknikiem. Czasem zda-
nia mog si te koczy mylnikiem albo innym znakiem interpunkcyjnym, jednak s to
przypadki na tyle rzadkie, e nie bdziemy ich brali pod uwag. Sam podzia jest bardzo
prosty. Zamiast nakaza interpreterowi Ruby, by podzieli tekst na czci wzgldem tylko
jednego znaku, trzeba wyda polecenie podziau wzgldem dowolnego z trzech znaków
w nastpujcy sposób:
sentence_count = text.split(/\.|\?|!/).length
Wyraenie regularne zastosowane w przykadzie moe wyda si dziwne, lecz znaki
kropki, zapytania i wykrzyknika s w nim wyranie widoczne. Przyjrzyjmy si samemu
wyraeniu regularnemu:
/\.|\?|!/
Znak ukonika znajdujcy si na pocztku i na kocu jest standardowym separatorem
wyraenia regularnego, zatem mona go zignorowa. Pierwszym elementem wyrae-
nia jest
\.
— fragment ten oznacza znak kropki. W wyraeniu nie mona wpisa samego
118
Cz I
i Podstawy
znaku kropki bez poprzedzajcego go ukonika, poniewa w wyraeniach regularnych
.
oznacza „dowolny znak” (zgodnie z informacjami zawartymi w rozdziale 3.). Kropk
naley zatem zneutralizowa za pomoc znaku ukonika, aby zostaa ona potraktowana
dosownie jako znak kropki. Z tego samego powodu znak ukonika poprzedza znak za-
pytania — znak zapytania oznacza zwykle w wyraeniach regularnych „aden lub jeden
ze znaków poprzedzajcych”, o czym równie wspomniano w rozdziale 3. Znaku
!
nie
trzeba neutralizowa, poniewa nie ma on adnej dodatkowej interpretacji w wyraeniach
regularnych.
Znaki potoku (czyli znaki
|
) oddzielaj od siebie trzy znaki gówne, co oznacza, e znaki
gówne maj by traktowane oddzielnie i metoda
split
ma dopasowywa cig znaków
do dowolnego z nich. Dziki temu cig znaków mona dzieli jednoczenie wzgldem
kropki, znaku zapytania i wykrzyknika. Aby si o tym przekona, mona wykona nast-
pujcy kod:
puts "Kod testowy! Dziaa. Na pewno? Tak.".split(/\.|\?|!/).length
4
Akapity równie mona wydzieli za pomoc wyrae regularnych. W ksikach dru-
kowanych, takich jak ta, akapity zwykle nie s oddzielane od siebie dodatkowym pustym
wierszem, natomiast akapity tekstu wpisywanego w komputerze s zazwyczaj tak od
siebie oddzielone. Zatem aby oddzieli od siebie poszczególne akapity, wystarczy podzieli
tekst wzgldem dwóch wystpujcych obok siebie znaków nowego wiersza (reprezento-
wanych przez specjaln kombinacj
\n\n
, oznaczajc dwa ssiadujce ze sob znaki
nowego wiersza), na przykad:
text = %q{
To jest test
akapitu pierwszego.
To jest test
drugiego akapitu.
A to jest test
akapitu numer trzy.
}
puts text.split(/\n\n/).length
3
Obydwa rozwizania naley zatem dopisa do pliku analyzer.rb:
paragraph_count = text.split(/\n\n/).length
puts "#{paragraph_count} akapitów"
sentence_count = text.split(/\.|\?|!/).length
puts "#{sentence_count} zda"
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
119
Obliczenie wartoci rednich
Ostatnimi statystykami, jakie ma liczy nasza pierwsza aplikacja, s: rednia liczba sów
w jednym zdaniu oraz rednia liczba zda w jednym paragrafie. Zmienne
word_count
,
paragraph_count
i
sentence_count
zawieraj ju wartoci wskazujce odpowiednio
liczb sów, akapitów i zda w tekcie. Pozostaje zatem jedynie wykona proste obli-
czenia arytmetyczne w nastpujcy sposób:
puts "#{sentence_count / paragraph_count} zda w jednym akapicie (rednio)"
puts "#{word_count / sentence_count} sów w jednym zdaniu (rednio)"
Obliczenia s na tyle proste, e mona je umieci bezporednio w poleceniach pre-
zentujcych ostateczne wartoci, zamiast wykonywa je w oddzielnych instrukcjach.
Kod ródowy aplikacji
W miar opracowywania koncepcji dziaania kolejnych funkcji kod aplikacji by stopnio-
wo rozbudowywany i za kadym razem odpowiednia logika bya implementowana jako
cz instrukcji
puts
wywietlajcej wynik oblicze uytkownikowi. Jednak w ostatecznej
wersji aplikacji lepiej jest zachowa porzdek i oddzieli logik od warstwy prezentacji,
a obliczenia przenie do oddzielnego bloku kodu i wykonywa je w caoci przed
rozpoczciem wywietlania wyników.
Sama logika pozostaje bez zmian, natomiast po wprowadzeniu opisanych modyfikacji kod
znajdujcy si w pliku analyzer.rb bdzie nieco bardziej uporzdkowany:
lines = File.readlines("text.txt")
line_count = lines.size
text = lines.join
word_count = text.split.length
character_count = text.length
character_count_nospaces = text.gsub(/\s+/, '').length
paragraph_count = text.split(/\n\n/).length
sentence_count = text.split(/\.|\?|!/).length
puts "#{line_count} wierszy"
puts "#{character_count} znaków"
puts "#{character_count_nospaces} znaków, nie liczc spacji"
puts "#{word_count} sów"
puts "#{paragraph_count} akapitów"
puts "#{sentence_count} zda"
puts "#{sentence_count / paragraph_count} zda w jednym akapicie (rednio)"
puts "#{word_count / sentence_count} sów w jednym zdaniu (rednio)"
Jeeli na razie wszystko jest zrozumiae, jest powód do dumy. W dalszej kolejnoci zasta-
nowimy si, w jaki sposób mona rozszerzy nieco funkcjonalno aplikacji o dodatkowe
interesujce statystyki.
120
Cz I
i Podstawy
Dodatkowe funkcje aplikacji
Analizator tekstu realizuje kilka podstawowych funkcji, nie robi jednak jakiego szcze-
gólnego wraenia. Liczba wierszy, akapitów i sów to z pewnoci przydatna informacja,
lecz Ruby pozwala na wyciganie zdecydowanie ciekawszych informacji na temat prze-
twarzanego tekstu. Jedynym ograniczeniem jest tak naprawd wyobrania programisty.
W tym punkcie opisanych zostanie kilka dodatkowych funkcji, a take przedstawiony zo-
stanie sposób ich implementacji.
W trakcie tworzenia aplikacji zawsze warto jednoczenie bra pod uwag prawdo-
podobiestwo tego, e program zostanie w przyszoci rozszerzony lub zmieniony i od
razu uwzgldnia t moliwo w trakcie implementacji. Zbyt restrykcyjne projektowa-
nie aplikacji powoduje zwykle, e póniejsze ich rozszerzanie jest zadaniem niezwykle
trudnym i czasochonnym.
Procent sów „znaczcych”
W wikszoci materiaów pisanych, równie w tej ksice, znajduje si wiele sów, które
nakrelaj kontekst i wyznaczaj struktur wypowiedzi, natomiast same w sobie nie nios
adnego konkretnego znaczenia. Choby znajdujce si w zdaniu poprzednim sowa „w”,
„si” czy „i” nie maj specjalnego znaczenia nawet pomimo tego, e bez nich cae zdanie
staoby si bezsensowne.
Tego typu sowa to tak zwane „sowa pomijane” (ang. stop words), które przez systemy
komputerowe odpowiedzialne za analiz i przeszukiwanie tekstu s najczciej pomijane.
Nie s to bowiem sowa, które s wyszukiwane przez uytkowników systemu (w odró-
nieniu na przykad od rzeczowników). Doskonaym przykadem tej reguy jest wyszu-
kiwarka Google, która nie przechowuje sów majcych zerow warto informacyjn
i bez znaczenia dla wykonywanych operacji wyszukiwania.
Wicej informacji na temat sów pomijanych, w tym pene listy takich sów, mona zna-
le na stronach pod adresami http://pl.wikipedia.org/wiki/Wikipedia:Stopwords
oraz http://en.wikipedia.org/wiki/Stop_words.
Mona si spodziewa, e tekst bardziej „interesujcy” albo napisany przez bardziej kom-
petentnego autora bdzie zawiera niszy odsetek sów pomijanych, a odsetek sów przy-
datnych albo interesujcych bdzie wyszy. atwo jest rozszerzy aplikacj o funkcj
obliczania procentowej iloci sów innych ni sowa pomijane w analizowanym tekcie.
Aby zaimplementowa tak funkcj, trzeba najpierw utworzy list sów pomijanych
(poniewa przykadowy tekst analizowany przez aplikacj jest tekstem jzyka angiel-
skiego, równie lista sów pomijanych bdzie zawiera sowa angielskie). Sów pomija-
nych mog by setki, jednak na pocztek nasza lista bdzie zawiera ich tylko kilka.
Sowa bd przechowywane w specjalnie w tym celu utworzonej tablicy:
stop_words = %w{the a by on for of are with just but and to the my I has some in}
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
121
Polecenie spowoduje utworzenie tablicy ze sowami pomijanymi, która jest przypi-
sywana zmiennej
stop_words
.
W rozdziale 3. tablice definiowano przy uyciu nastpujcego zapisu:
x = ['a', 'b',
'c']. Jednak, podobnie jak w wielu innych jzykach, Ruby pozwala na stosowanie
zapisów skrótowych, za pomoc których mona szybko tworzy tablice z tekstem
podzielonym na cigi znaków. Zapis z rozdziau 3. mona zastpi krótszym zapi-
sem
x = %w{a b c}, który zosta ju zastosowany w przedstawionym przed chwil
kodzie tworzcym list sów pomijanych.
Dla celów demonstracyjnych mona napisa krótki, samodzielny program, aby za jego
pomoc przetestowa nowe rozwizanie:
text = %q{Los Angeles has some of the nicest weather in the country.}
stop_words = %w{the a by on for of are with just but and to the my I has some}
words = text.scan(/\w+/)
key_words = words.select { |word| !stop_words.include?(word) }
puts key_words.join(' ')
Po wykonaniu przykadowego kodu zwrócony zostanie nastpujcy wynik:
Los Angeles nicest weather country
Ciekawe, prawda? Najpierw do programu wczytywany jest tekst, a nastpnie lista sów
pomijanych. W kolejnym kroku wszystkie sowa zostaj wczytane ze zmiennej
text
do
tablicy o nazwie
words
, a w kocu nastpuje gwód programu:
key_words = words.select { |word| !stop_words.include?(word) }
W przedstawionym wierszu kodu najpierw na tablicy sów o nazwie
words
wywoywana
jest metoda
select
, do której przekazywany jest blok kodu przetwarzajcy kade sowo
(podobnie jak iteratory, z którymi mielimy do czynienia w rozdziale 3.). Metoda
select
jest dostpna dla wszystkich tablic oraz tablic asocjacyjnych i zwraca elementy tablicy
albo tablicy asocjacyjnej, które pasuj do wyraenia zawartego w bloku kodu.
W tym konkretnym przykadzie kade sowo jest przekazywane do bloku kodu za pored-
nictwem zmiennej
word
, po czym kod sprawdza w tablicy
stop_words
, czy znajduje
si w niej element identyczny jak
word
. Tak wanie dziaa fragment
stop_words.
´include?(word)
.
Znak wykrzyknika (
!
) znajdujcy si przed wyraeniem oznacza jego negacj (wy-
krzyknik jest znakiem negacji dla kadego wyraenia w jzyku Ruby). Zastosowano go
dlatego, e niepotrzebne s nam sowa, które znajduj si w tablicy
stop_words
— intere-
suj nas wycznie te sowa, których w tej tablicy nie ma.
Reasumujc, metoda
select
pobiera wszystkie elementy z tablicy
words
, których nie ma
w tablicy
stop_words
, i przypisuje je zmiennej
key_words
. Aby kontynuowa lektur, trzeba
precyzyjnie zrozumie dziaanie kodu, poniewa tego typu jednowierszowe konstrukcje
czsto wykorzystuje si w trakcie implementowania aplikacji w jzyku Ruby.
122
Cz I
i Podstawy
Po uzyskaniu listy sów znaczcych obliczenie procentowej iloci sów innych ni sowa
pomijane w stosunku do wszystkich sów w tekcie wymaga ju tylko wykonania prostej
operacji arytmetycznej:
((key_words.length.to_f / words.length.to_f) * 100).to_i
Metody
to_f
uyto dlatego, e dugoci cigu znaków s traktowane jak liczby zmienno-
pozycyjne, dziki czemu obliczona warto uamkowa bdzie wyznaczona bardziej precy-
zyjnie. Gdy wynik dzielenia zostanie ju sprowadzony do wartoci procentowej, mona
j z powrotem przeksztaci w liczb cakowit.
Ostateczna implementacja mechanizmu zostanie zaprezentowana w finalnej wersji kodu
aplikacji na kocu tego rozdziau.
Podsumowanie prezentujce zdania „znaczce”
Edytory tekstu, takie jak Microsoft Word, posiadaj funkcje podsumowujce, które
wycigaj z tekstu o znacznej objtoci najbardziej znaczce zdania i na ich podstawie ge-
neruj podsumowanie. Mechanizm generowania takich podsumowa stawa si z biegiem
lat coraz bardziej skomplikowany, lecz jednym z najprostszych rozwiza pozwalajcych
na samodzielne utworzenie takiego podsumowania jest przeskanowanie zda pod ktem
pewnych cech.
Jedna z technik polega na wyszukaniu zda, których dugo jest zbliona do redniej
dugoci zdania w tekcie i które zawieraj rzeczowniki. Krótkie zdania prawdopodobnie
nie nios ze sob wielkiego znaczenia, za zdania wyranie dusze od przecitnej s po
prostu zbyt dugie, aby zamieszcza je w podsumowaniu. Do odnajdywania rzeczowników
trzeba by zaimplementowa system zdecydowanie bardziej skomplikowany ni rozwiza-
nia, którymi zajmujemy si w tej ksice, mona jednak pój „na skróty” i wyszukiwa
takie sowa, które wskazuj potencjaln obecno rzeczowników w tym samym zdaniu.
Sowami takimi w jzyku angielskim mog by na przykad „is” i „are” (na przykad
„Noun is”, „Nouns are” albo „There are x nouns”).
Zaómy, e naley zignorowa dwie trzecie zda zawartych w tekcie: jedn trzeci zda,
które s najkrótsze, i jedn trzeci zda najduszych. Pozostanie wówczas tylko jedna
trzecia zda z tekstu oryginalnego, co w zupenoci wystarczy do utworzenia podsu-
mowania.
Aby uatwi sobie implementacj, najlepiej jest zaimplementowa program zupenie od
nowa, a dopiero potem przenie zaimplementowan logik do gównej aplikacji. Naley
wic utworzy nowy program o nazwie summarize.rb i wpisa w nim nastpujcy kod:
text = %q{
Ruby is a great programming language. It is object oriented and has many groovy
features. Some people don't like it, but that's not our problem! It's easy to
learn. It's great. To learn more about Ruby, visit the official Ruby Web site
today.
}
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
123
sentences = text.gsub(/\s+/, ' ').strip.split(/\.|\?|\!/)
sentences_sorted = sentences.sort_by { |sentence| sentence.length }
puts sentences_sorted.length
one_third = sentences_sorted.length / 3
ideal_sentences = sentences_sorted.slice(one_third, one_third + 1)
ideal_sentences = ideal_sentences.select { |sentence| sentence =~ /is|are/ }
puts ideal_sentences.join(". ")
Od razu mona przetestowa dziaanie kodu:
Ruby is a great programming language. It is object oriented and has many groovy features
Wyglda doskonale! Przeanalizujmy dziaanie programu.
Najpierw definiowana jest zmienna
text
, która przechowuje dugi cig znaków zawierajcy
kilka zda — podobnie rozpoczyna si kod w pliku analyzer.rb. Nastpnie tekst w zmien-
nej
text
jest dzielony na tablic pojedynczych zda w nastpujcy sposób:
sentences = text.gsub(/\s+/, ' ').strip.split(/\.|\?|\!/)
Rozwizanie to róni si nieco od rozwizania zastosowanego w pliku analyzer.rb.
W acuchu metod znajduje si dodatkowe ogniwo w postaci metody
gsub
, a take metoda
split
. Metoda
gsub
usuwa wszystkie fragmenty zoone z wicej ni jednego znaku
niewidocznego i zastpuje je pojedynczym znakiem spacji (zapis
\s+
oznacza „jeden lub
wicej znaków niewidocznych”). Dziaanie metody ma wic tylko charakter kosmetyczny.
Z kolei
strip
usuwa wszystkie nadmiarowe znaki niewidoczne z pocztku i koca cigu
znaków. Metoda
strip
jest wic uywana w taki sam sposób jak w aplikacji analizatora.
W kolejnym kroku zdania s porzdkowane na podstawie ich dugoci po to, by móc
odrzuci jedn trzeci zda najkrótszych i jedn trzeci zda najduszych:
sentences_sorted = sentences.sort_by { |sentence| sentence.length }
Tablice i tablice asocjacyjne posiadaj metod
sort_by
, która zmienia kolejno znaj-
dujcych si w nich elementów niemal w dowolny sposób. Metoda
sort_by
przyjmuje jako
argument blok kodu, którym jest wyraenie definiujce sposób sortowania. W naszym
przykadzie sortowaniu podlega zawarto tablicy
sentences
. Kade zdanie jest prze-
kazywane do bloku w postaci zmiennej
sentence
, a nastpnie jego pozycja jest wy-
znaczana na podstawie dugoci zdania za pomoc wywoanej na nim metody
length
.
Po wykonaniu kodu w tym wierszu zmienna
sentences_sorted
bdzie zawiera tablic
ze zdaniami uoonymi w kolejnoci zalenej od ich dugoci.
Nastpnie z tablicy
sentences_sorted
trzeba wyodrbni jedn trzeci zda, które maj
redni dugo, poniewa to wanie te zdania z najwikszym prawdopodobiestwem s
najbardziej interesujce. W tym celu dugo tablicy trzeba podzieli przez
3
, aby uzyska
liczb zda wchodzcych w skad jednej trzeciej tekstu, po czym wczyta tak wyznaczon
liczb zda do nowej tablicy (warto zwróci uwag, e z tablicy
sentences_sorted
pobierane jest tak naprawd o jedno zdanie wicej, aby zniwelowa zaokrglenie po-
wstae w trakcie dzielenia liczb cakowitych). Czynnoci te s realizowane w ramach
nastpujcych dwóch polece:
one_third = sentences_sorted.length / 3
ideal_sentences = sentences_sorted.slice(one_third, one_third + 1)
124
Cz I
i Podstawy
W pierwszym wierszu odczytywana jest dugo tablicy, po czym zostaje ona podzielona
przez
3
w celu uzyskania liczby równej „jednej trzeciej tablicy”. W drugim wierszu
wykonana zostaje metoda
slice
, która wycina fragment tablicy i przypisuje ten frag-
ment zmiennej
ideal_sentences
. Zaómy na przykad, e tablica
sentences_sorted
zawiera sze elementów. Sze podzielone przez trzy daje dwa, zatem trzecia cz
tablicy skada si z dwóch zda. Metoda
slice
wycina z tablicy dwa elementy (plus
jeden) poczwszy od elementu numer dwa; ostatecznie wic z tablicy wydzielone zo-
stan elementy o numerach
2
,
3
i
4
(jak pamitamy, numerowanie elementów w tabli-
cach zaczyna si od zera). W ten sposób uzyskiwana jest rodkowa z trzech czci ta-
blicy, zawierajca zdania o najlepszej dugoci.
W przedostatnim wierszu kodu nastpuje sprawdzenie, czy zdanie zawiera sowa „is” lub
„are”; ostatecznie zaakceptowane zostaj wycznie zdania, w których te sowa wystpuj:
ideal_sentences = ideal_sentences.select { |sentence| sentence =~ /is|are/ }
W powyszym wierszu metoda
select
jest wykorzystywana w taki sam sposób jak w po-
leceniu usuwajcym sowa pomijane w poprzednim punkcie. Blok kodu zawiera wy-
raenie regularne, do którego dopasowywana jest zawarto zmiennej
sentence
. Wyrae-
nie zawarte w bloku ma warto
true
jedynie wówczas, gdy w zmiennej
sentence
znajduje
si sowo „is” lub „are”. Dziki temu w tablicy
ideal_sentences
znajd si ostatecznie
tylko te zdania, które nale do rodkowej z trzech czci zbioru zda i zawieraj sowo
„is” lub „are”.
W ostatnim wierszu nastpuje ju tylko poczenie zawartoci tablicy
ideal_sentences
za
pomoc znaku kropki wraz ze znakiem spacji, aby zwikszy czytelno podsumowania
w ostatecznej postaci:
puts ideal_sentences.join(". ")
Analiza plików innych ni text.txt
W kodzie aplikacji w obecnej postaci jawnie wpisana jest nazwa pliku text.txt. Mona nad
takim rozwizaniem przej do porzdku dziennego, lecz lepiej byoby zapewni, by przy
kadym uruchomieniu programu mona byo wskaza konkretny plik przeznaczony do
analizy.
Prezentowana technika jest przydatna jedynie wówczas, gdy program analyzer.rb
bdzie uruchamiany z poziomu wiersza polece albo w powoce, w systemie Mac
OS X lub Linux (bd te w Windows, jeeli uywany jest wiersz polece tego systemu).
Jeeli natomiast uywane jest rodowisko IDE dziaajce w Windows, wówczas
rozwizanie opisane w tym punkcie mona potraktowa jedynie jako ciekawostk.
Zazwyczaj gdy program uruchamia si w wierszu polece, na kocu polecenia wywouj-
cego program mona dopisywa dodatkowe parametry, które program ma przetworzy.
Tak samo mona postpi z aplikacj napisan w jzyku Ruby.
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
125
Ruby automatycznie umieszcza wszystkie parametry dopisane w poleceniu uruchamiaj-
cym program w specjalnej tablicy o nazwie
ARGV
. Aby si o tym przekona, mona
utworzy nowy skrypt o nazwie argv.rb i wpisa w nim nastpujcy kod:
puts ARGV.join('-')
W wierszu polece skrypt naley uruchomi w taki sposób:
ruby argv.rb
adne dane wynikowe nie zostan wówczas zwrócone. W drugiej próbie skrypt naley
wykona za pomoc polecenia:
ruby argv.rb test 123
test-123
Tym razem z tablicy odczytywane s znajdujce si tam parametry, zostaj one poczone
znakiem mylnika i wywietlone na ekranie. W ten sposób w kodzie analizatora z pliku
analyzer.rb wskazanie pliku text.txt mona zastpi zapisem
ARGV[0]
albo
ARGV.first
(w obu przypadkach zwrócony zostanie pierwszy element tablicy
ARGV
). Polecenie,
które odpowiada za wczytanie zawartoci pliku, bdzie wówczas mie posta:
lines = File.readlines(ARGV[0])
Aby teraz przetworzy plik text.txt, program naley uruchomi za pomoc polecenia:
ruby analyzer.rb text.txt
Wicej informacji na temat wdraania programów i uatwiania pracy z nimi, w tym rów-
nie przez wykorzystanie tablicy
ARGV
, znajdzie si w rozdziale 10.
Program w wersji finalnej
Kod ródowy naszego pierwszego programu zosta ukoczony ju wczeniej, wypada
jednak dopisa w pliku analyzer.rb kod wszystkich nowych funkcji opisanych w punkcie
poprzednim. W ten sposób uzyskana zostanie finalna wersja analizatora tekstów.
Wszystkie kody ródowe prezentowane w tej ksice s dostpne na stronie Wydaw-
nictwa Helion pod adresem http://helion.pl/przyklady/prubpo.zip. Nie trzeba wic
rcznie przepisywa kodu ródowego przedstawionego poniej.
Oto kod aplikacji w wersji finalnej:
# analyzer.rb -- Analizator tekstu
stop_words = %w{the a by on for of are with just but and to the my I has some in}
lines = File.readlines("text.txt")
line_count = lines.size
text = lines.join
126
Cz I
i Podstawy
# zliczenie znaków
character_count = text.length
character_count_nospaces = text.gsub(/\s+/, '').length
# zliczenie sów, zda i akapitów
word_count = text.split.length
sentence_count = text.split(/\.|\?|!/).length
paragraph_count = text.split(/\n\n/).length
# utworzenie listy sów z tekstu, które nie s sowami pomijanymi
# zliczenie tych sów i wyznaczenie procentowej iloci sów pomijanych
# w zbiorze wszystkich sów
all_words = text.scan(/\w+/)
good_words = all_words.select{ |word| !stop_words.include?(word) }
good_percentage = ((good_words.length.to_f / all_words.length.to_f) * 100).to_i
# podsumowanie – wyodrbnienie zda potencjalnie najbardziej znaczcych
sentences = text.gsub(/\s+/, ' ').strip.split(/\.|\?|\!/)
sentences_sorted = sentences.sort_by { |sentence| sentence.length }
one_third = sentences_sorted.length / 3
ideal_sentences = sentences_sorted.slice(one_third, one_third + 1)
ideal_sentences = ideal_sentences.select { |sentence| sentence =~ /is|are/ }
# wywietlenie uytkownikowi wyników analizy
puts "#{line_count} wierszy"
puts "#{character_count} znaków"
puts "#{character_count_nospaces} znaków, nie liczc spacji"
puts "#{word_count} sów"
puts "#{paragraph_count} akapitów"
puts "#{sentence_count} zda"
puts "#{sentence_count / paragraph_count} zda w jednym akapicie (rednio)"
puts "#{word_count / sentence_count} sów w jednym zdaniu (rednio)"
puts "#{good_percentage}% sów to sowa znaczce"
puts "Podsumowanie:\n\n" + ideal_sentences.join(". ")
puts "-- Koniec analizy"
Uytkownicy systemu Windows powinni zastpi odwoanie
ARGV[0] jawnym wska-
zaniem pliku text.txt, aby zapewni, e skrypt bdzie dziaa prawidowo w FreeRIDE
i SciTE. Jeeli jednak program bdzie uruchamiany z poziomu wiersza polece, to
powinien dziaa prawidowo take bez tej zmiany.
Wykonanie programu analyzer.rb w wersji finalnej na przykadowym tekcie z po-
wieci Oliver Twist spowoduje zwrócenie nastpujcych danych wynikowych:
121 wierszy
6165 znaków
5055 znaków nie liczc spacji
1093 sów
18 akapitów
45 zda
2 zda w jednym akapicie (rednio)
24 sów w jednym zdaniu (rednio)
76% sów to sowa znaczce
Rozdzia 4.
i Prosta aplikacja w jzyku Ruby
127
Podsumowanie:
' The surgeon leaned over the body, and raised the left hand. Think what it is
´to be a mother, there's a dear young lamb do. 'The old story,' he said, shaking
´his head: 'no wedding-ring, I see. What an excellent example of the power of
´dress, young Oliver Twist was. ' Apparently this consolatory perspective of a mother's
´prospects failed in producing its due effect. ' The surgeon had been sitting with
´his face turned towards the fire: giving the palms of his hands a warm and a rub
´alternately. ' 'You needn't mind sending up to me, if the child cries, nurse,'
´said the surgeon, putting on his gloves with great deliberation. She had walked
´some distance, for her shoes were worn to pieces; but where she came from, or
´where she was going to, nobody knows. ' He put on his hat, and, pausing by the
´bed-side on his way to the door, added, 'She was a good-looking girl, too; where
´did she come from
-- Koniec analizy
Warto sprawdzi dziaanie programu analyzer.rb równie na innych fragmentach tekstu
(pochodzcych na przykad z wybranej strony internetowej) i zobaczy, czy mona jesz-
cze rozszerzy jego dziaanie o dodatkowe funkcje. Aplikacj bdzie mona rozszerzy na
przykad o elementy, o których bdzie mowa w nastpnych kilku rozdziaach ksiki.
Warto o tym pamita, gdy najdzie kogo ochota na poeksperymentowanie z jakim
kodem.
Komentarze w kodzie ródowym
W finalnym kodzie aplikacji znajduj si wiersze poprzedzone znakiem
#. S to tak zwane
komentarze, które wpisuje si w kodzie programów i z których póniej korzystaj zarówno
sami autorzy kodu, jak i inni uytkownicy, którzy ten kod póniej przegldaj. Komentarze
przydaj si szczególnie wówczas, gdy zawieraj informacje na temat przyczyn, dla których
zdecydowano si na zaimplementowanie rozwizania w taki, a nie inny sposób i które po
jakim czasie mog autorowi kodu ulecie z pamici.
W kodzie ródowym jzyka Ruby komentarze mog znajdowa si w oddzielnych wierszach
albo na kocu wiersza kodu. Oto dwa przykadowe komentarze w kodzie Ruby:
puts "2+2 = #{2+2}" # Dodaje 2+2 i zwraca 4
# Komentarz zapisany w oddzielnym wierszu
Jeli tylko komentarz znajduje si w oddzielnym wierszu albo na kocu wiersza kodu, dzia-
anie programu nie zmieni si. Warto zamieszcza jak najwicej komentarzy, aby po upywie
duszego czasu atwiej byo sobie przypomnie dziaanie kodu.
Podsumowanie
W tym rozdziale zaimplementowano pen, cho prost aplikacj zgodnie z wczeniej
opracowanym zbiorem wymaga i podanych funkcji. Nastpnie aplikacj rozszerzono
o kilka dodatkowych funkcji, których obecno nie wpywaa jednak na realizacj pod-
stawowych funkcji programu. Wszystko dziki temu, e Ruby pozwala na szybkie im-
plementowanie aplikacji.
128
Cz I
i Podstawy
Na podstawie aplikacji zaimplementowanej w tym rozdziale pokazano, e jeeli konieczne
jest przeprowadzenie analizy znacznej iloci tekstu albo wykonanie oblicze i zrobienie
tych czynnoci rcznie byoby zbyt mudne, mona posuy si jzykiem Ruby.
Rozdzia 4. jest ostatnim rozdziaem pierwszej czci ksiki, w którym prezentowane s
praktyczne wiczenia. W rozdziale 5. przedstawiona zostanie krótka historia jzyka Ruby,
spoeczno programistów Ruby, historyczne uwarunkowania niektórych funkcji udostp-
nianych przez Ruby, a take sposoby uzyskiwania pomocy i doczenia do spoecznoci
Ruby. Pisanie kodu to tylko poowa drogi do zostania doskonaym programist!
Wyszukiwarka
Podobne podstrony:
ALGORYTMY-PREZENTACJA, SZKOLNE PLIKI-mega zbiory (od podstawówki do magisterki), Programowanie struk
Programowanie Od podstaw id 39 Nieznany
SQL Server 2005 Programowanie Od podstaw
Programowanie Od podstaw progpo
Programowanie Od podstaw progpo
Programowanie Od podstaw 2
Programowanie Od podstaw progpo 2
SQL Server 2005 Programowanie Od podstaw
Programowanie Od podstaw
informatyka programowanie aplikacji na iphone 4 poznaj platforme ios sdk3 od podstaw david mark eboo
więcej podobnych podstron