Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00401 008761 10734332 na godz. na dobę w sumie
Ruby. Przewodnik programisty. Wydanie II - ebook/pdf
Ruby. Przewodnik programisty. Wydanie II - ebook/pdf
Autor: Liczba stron: 568
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-1106-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> rails - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).
Jest to właściwy moment dla języka Ruby! Zapewnia on takie możliwości jak język Java lub C++, a ponadto oferuje funkcje dynamiczne, które umożliwiają tworzonemu kodowi reagowanie w odpowiedni sposób na zmiany w środowisku wykonawczym. Ponieważ język Ruby wyróżnia elegancja, tworzenie aplikacji, narzędzi programistycznych oraz skryptów administracyjnych jest łatwiejsze i bardziej zrozumiałe. Wraz z długo oczekiwaną wersją 2., aktywną społecznością programistów oraz niezliczonymi bibliotekami i narzędziami, język Ruby podąża własną drogą rozwoju.

Poznaj kluczowe pojęcia związane z językiem Ruby. W kolejnych rozdziałach znajdziesz istotne informacje na temat składni, dostępnych elementów oraz typowych konstrukcji. Ponadto zobaczysz, jak korzystać z obiektów, metod i zmiennych, oraz nauczysz się budować właściwą strukturę Twojego projektu. Po opanowaniu podstaw będziesz swobodnie tworzył proste programy oraz przejdziesz do zaawansowanych tematów związanych z technikami przepływu sterowania, wbudowanymi elementami, kolekcjami oraz wyrażeniami regularnymi. Ta książka jest doskonałym podręcznikiem dla wszystkich osób chcących nauczyć się języka Ruby i wykorzystać jego potencjał w kolejnych projektach.

Dzięki tej książce:

Poznaj i wykorzystaj jego możliwości języka Ruby! 

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: The Well-Grounded Rubyist Tłumaczenie: Piotr Pilch Projekt okładki: Studio Gravite / Olsztyn; Obarek, Pokoński, Pazdrijowski, Zaprucki ISBN: 978-83-283-1103-9 Original edition copyright © 2014 by Manning Publications Co. All rights reserved. Polish edition copyright © 2015 by HELION SA. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/rubprp Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:258)ci Przedmowa 17 Przedmowa do pierwszego wydania 19 Podzi(cid:218)kowania 21 O ksi(cid:200)(cid:285)ce 23 CZ(cid:125)(cid:165)(cid:109) I FUNDAMENTY J(cid:125)ZYKA RUBY .................................................... 29 Rozdzia(cid:239) 1. Wprowadzenie do nauki j(cid:218)zyka Ruby 31 1.1. Ogólne wprowadzenie do j(cid:218)zyka Ruby 32 1.1.1. Niezb(cid:218)dna sk(cid:239)adnia j(cid:218)zyka Ruby 33 1.1.2. Ró(cid:285)norodno(cid:258)(cid:202) identyfikatorów j(cid:218)zyka Ruby 35 1.1.3 Wywo(cid:239)ania metod, komunikaty i obiekty j(cid:218)zyka Ruby 37 1.1.4. 1.1.5. Kierowanie programu do interpretera j(cid:218)zyka Ruby 40 1.1.6. Operacje wej(cid:258)cia-wyj(cid:258)cia zwi(cid:200)zane z plikami i danymi wprowadzanymi Tworzenie i zapisywanie prostego programu 39 przy u(cid:285)yciu klawiatury 42 1.2. Anatomia instalacji j(cid:218)zyka Ruby 45 Podkatalog standardowych bibliotek j(cid:218)zyka Ruby 46 1.2.1. 1.2.2. Katalog rozszerze(cid:241) j(cid:218)zyka C (RbConfig::CONFIG[archdir]) 46 1.2.3. Katalogi site_ruby (RbConfig::CONFIG[sitedir]) i vendor_ruby (RbConfig::CONFIG[vendordir]) 47 1.2.4. Katalog gems 47 1.3. Rozszerzenia i biblioteki programistyczne j(cid:218)zyka Ruby 48 (cid:146)adowanie plików i rozszerze(cid:241) zewn(cid:218)trznych 48 (cid:146)adowanie pliku okre(cid:258)lonego w domy(cid:258)lnej (cid:258)cie(cid:285)ce (cid:239)adowania 49 (cid:191)(cid:200)danie sk(cid:239)adnika 50 Polecenie require_relative 52 1.3.1. 1.3.2. 1.3.3. 1.3.4. Standardowe narz(cid:218)dzia i aplikacje j(cid:218)zyka Ruby 52 1.4.1. Opcje wiersza polece(cid:241) interpretera 53 1.4.2. Omówienie interaktywnego interpretera j(cid:218)zyka Ruby irb 57 1.4.3. Narz(cid:218)dzia ri i Rdoc 59 1.4.4. Narz(cid:218)dzie do zarz(cid:200)dzania zadaniami rake 60 1.4.5. Podsumowanie 64 Instalowanie pakietów za pomoc(cid:200) polecenia gem 62 1.4. 1.5. Rozdzia(cid:239) 2. Obiekty, metody i zmienne lokalne 65 2.1. Komunikowanie si(cid:218) z obiektami 66 J(cid:218)zyk Ruby i obiektowo(cid:258)(cid:202) 66 Tworzenie obiektu ogólnego 67 2.1.1. 2.1.2. Poleć książkęKup książkę 8 Spis tre(cid:258)ci 2.2. 2.1.3. Metody pobieraj(cid:200)ce argumenty 69 2.1.4. Warto(cid:258)(cid:202) zwracana metody 70 Tworzenie obiektu: dzia(cid:239)anie biletu 71 2.2.1. Obiekt biletu — przede wszystkim dzia(cid:239)anie 71 2.2.2. Odpytywanie obiektu biletu 72 2.2.3. 2.2.4. Dost(cid:218)pno(cid:258)(cid:202) biletu: wyra(cid:285)anie stanu boolowskiego w metodzie 74 Skracanie kodu obiektu biletu za pomoc(cid:200) interpolacji (cid:239)a(cid:241)cuchów 73 2.3. Wbudowane zachowania obiektu 76 2.3.1. Unikatowe identyfikowanie obiektów za pomoc(cid:200) metody object_id 77 2.3.2. Uzyskiwanie mo(cid:285)liwo(cid:258)ci obiektu za pomoc(cid:200) metody respond_to? 78 2.3.3. Wysy(cid:239)anie komunikatów do obiektów za pomoc(cid:200) metody send 79 2.4. Dok(cid:239)adna analiza argumentów metody 80 2.4.1. Argumenty wymagane i opcjonalne 80 2.4.2. Warto(cid:258)ci domy(cid:258)lne argumentów 81 2.4.3. Kolejno(cid:258)(cid:202) parametrów i argumentów 82 2.4.4. Dzia(cid:239)ania niedozwolone w przypadku list argumentów 85 Zmienne lokalne i przypisywanie do zmiennych 85 2.5.1. 2.5.2. Odwo(cid:239)ania w przypisaniu do zmiennej i ponowne przypisanie 89 2.5.3. Odwo(cid:239)ania i argumenty metody 91 2.5.4. Podsumowanie 93 Zmienne lokalne i przypominaj(cid:200)ce je elementy 92 Zmienne, obiekty i odwo(cid:239)ania 87 2.5. 2.6. Rozdzia(cid:239) 3. Organizowanie obiektów za pomoc(cid:200) klas 95 3.1. Klasy i instancje 96 3.1.1. Metody instancji 97 Przes(cid:239)anianie metod 97 3.1.2. 3.1.3. Ponowne otwieranie klas 98 Zmienne instancji i stan obiektu 100 3.2.1. Inicjowanie obiektu ze stanem 102 3.2. 3.3. Metody ustawiaj(cid:200)ce 103 3.3.1. 3.3.2. 3.3.3. Znak równo(cid:258)ci (=) w nazwach metod 104 „Lukier” sk(cid:239)adniowy dla metod przypominaj(cid:200)cych przypisania 105 Pe(cid:239)nia mo(cid:285)liwo(cid:258)ci metod ustawiaj(cid:200)cych 106 3.4. Atrybuty i rodzina metod attr_* 108 3.4.1. Automatyzowanie tworzenia atrybutów 108 3.4.2. Podsumowanie metod attr_* 111 3.5. Dziedziczenie i hierarchia klas j(cid:218)zyka Ruby 111 3.5.1. 3.5.2. 3.5.3. Pojedyncze dziedziczenie: po jednym dla klienta 113 Przodkowie obiektów i nie do ko(cid:241)ca brakuj(cid:200)ce (cid:239)(cid:200)cze: klasa Object 113 Starszy brat El Viejo: BasicObject 114 3.6. Klasy jako obiekty i odbiorcy komunikatów 115 Tworzenie obiektów klasy 115 3.6.1. 3.6.2. Wywo(cid:239)ywanie metod przez obiekty klasy 116 3.6.3. Metoda pojedynczego obiektu 117 3.6.4. Kiedy i dlaczego nale(cid:285)y tworzy(cid:202) metod(cid:218) klasy? 119 3.6.5. Porównanie metod klasy z metodami instancji 120 Poleć książkęKup książkę Spis tre(cid:258)ci 9 3.7. 3.8. 3.9. Podstawowe zastosowanie sta(cid:239)ych 121 Porównanie ponownego przypisania z modyfikowaniem sta(cid:239)ych 123 Szczegó(cid:239)y dotycz(cid:200)ce sta(cid:239)ych 120 3.7.1. 3.7.2. „Natura” i „wychowanie” w przypadku obiektów j(cid:218)zyka Ruby 124 Podsumowanie 126 Rozdzia(cid:239) 4. Modu(cid:239)y i organizacja programu 127 4.1. Podstawowe informacje dotycz(cid:200)ce tworzenia i u(cid:285)ywania modu(cid:239)ów 128 4.1.1. Modu(cid:239) hermetyzuj(cid:200)cy „podobie(cid:241)stwo do stosu” 129 4.1.2. Dodawanie modu(cid:239)u do klasy 131 4.1.3. Bardziej zaawansowane u(cid:285)ycie modu(cid:239)ów 133 4.2. Modu(cid:239)y, klasy i wyszukiwanie metody 135 4.2.1. Demonstracja podstaw wyszukiwania metod 135 4.2.2. Definiowanie tej samej metody wi(cid:218)cej ni(cid:285) raz 138 4.2.3. 4.2.4. 4.2.5. Nawigacja w obr(cid:218)bie (cid:258)cie(cid:285)ki wyszukiwania metod za pomoc(cid:200) Sposób dzia(cid:239)ania instrukcji prepend 141 Podsumowanie regu(cid:239) wyszukiwania metod 142 s(cid:239)owa kluczowego super 143 4.3. Metoda method_missing 145 (cid:146)(cid:200)czenie metody method_missing ze s(cid:239)owem kluczowym super 146 4.3.1. Projekt i nadawanie nazw w przypadku klas i modu(cid:239)ów 150 4.4.1. Dodawanie modu(cid:239)ów do klas i/lub dziedziczenie 151 4.4.2. Podsumowanie 154 Zagnie(cid:285)d(cid:285)anie modu(cid:239)ów i klas 153 4.4. 4.5. Rozdzia(cid:239) 5. Obiekt domy(cid:258)lny (self), zasi(cid:218)g i widoczno(cid:258)(cid:202) 155 5.1. Obiekt self, czyli obiekt bie(cid:285)(cid:200)cy/domy(cid:258)lny 156 5.1.1. Co zostaje obiektem self i w jakim miejscu? 157 5.1.2. Obiekt self najwy(cid:285)szego poziomu 158 5.1.3. Obiekt self w definicjach klas, modu(cid:239)ów i metod 159 5.1.4. Obiekt self jako domy(cid:258)lny odbiorca komunikatów 162 5.1.5. Okre(cid:258)lanie zmiennych instancji za po(cid:258)rednictwem obiektu self 164 5.2. Okre(cid:258)lanie zasi(cid:218)gu 166 5.2.1. 5.2.2. 5.2.3. 5.2.4. 5.2.5. Zasi(cid:218)g globalny i zmienne globalne 166 Zasi(cid:218)g lokalny 169 Interakcja mi(cid:218)dzy zasi(cid:218)giem lokalnym i obiektem self 171 Zasi(cid:218)g i okre(cid:258)lanie sta(cid:239)ych 173 Sk(cid:239)adnia zmiennych klasy, zasi(cid:218)g i widoczno(cid:258)(cid:202) 175 5.3. Wdra(cid:285)anie regu(cid:239) uzyskiwania dost(cid:218)pu do metod 182 5.3.1. Metody prywatne 182 5.3.2. Metody chronione 186 5.4. Tworzenie i u(cid:285)ywanie metod najwy(cid:285)szego poziomu 187 5.4.1. Definiowanie metody najwy(cid:285)szego poziomu 187 5.4.2. Podsumowanie 189 5.5. Predefiniowane (wbudowane) metody najwy(cid:285)szego poziomu 188 Poleć książkęKup książkę 10 Spis tre(cid:258)ci Rozdzia(cid:239) 6. Techniki przep(cid:239)ywu sterowania 191 6.1. Warunkowe wykonywanie kodu 192 6.2. 6.3. Instrukcja if i powi(cid:200)zane z ni(cid:200) instrukcje 192 Sk(cid:239)adnia przypisania w tre(cid:258)ci instrukcji warunkowych i testach 197 Instrukcje case 200 6.1.1. 6.1.2. 6.1.3. Powtarzanie dzia(cid:239)a(cid:241) za pomoc(cid:200) p(cid:218)tli 205 6.2.1. Bezwarunkowe wykonywanie p(cid:218)tli za pomoc(cid:200) metody loop 205 6.2.2. Warunkowe wykonywanie p(cid:218)tli za pomoc(cid:200) s(cid:239)ów kluczowych while i until 206 6.2.3. Wykonywanie p(cid:218)tli na bazie listy warto(cid:258)ci 209 Iteratory i bloki kodu 209 6.3.1. Elementy iteracji 209 6.3.2. 6.3.3. Anatomia wywo(cid:239)ania metody 210 6.3.4. Porównanie nawiasów klamrowych oraz pary s(cid:239)ów kluczowych do i end w sk(cid:239)adni bloku kodu 211 Implementowanie metody times 213 Iteracja w zwyk(cid:239)ym stylu 210 6.3.5. 6.3.6. Wa(cid:285)no(cid:258)(cid:202) metody each 214 6.3.7. Od metody each do metody map 216 6.3.8. Parametry bloku i zasi(cid:218)g zmiennych 218 6.4. Obs(cid:239)uga b(cid:239)(cid:218)dów i wyj(cid:200)tki 221 Zg(cid:239)aszanie wyj(cid:200)tków i stosowanie dla nich klauzuli rescue 221 S(cid:239)owo kluczowe rescue na ratunek! 222 Jawne zg(cid:239)aszanie wyj(cid:200)tków 224 Przechwytywanie wyj(cid:200)tku w klauzuli rescue 225 6.4.1. 6.4.2. 6.4.3. 6.4.4. 6.4.5. Klauzula ensure 227 6.4.6. Podsumowanie 229 Tworzenie w(cid:239)asnych klas wyj(cid:200)tków 228 6.5. CZ(cid:125)(cid:165)(cid:109) II WBUDOWANE KLASY I MODU(cid:146)Y .............................................231 Rozdzia(cid:239) 7. Wbudowane elementy podstawowe 233 7.1. Konstruktory litera(cid:239)ów j(cid:218)zyka Ruby 234 7.2. Powracaj(cid:200)cy „lukier” sk(cid:239)adniowy 235 7.2.1. Definiowanie operatorów przez okre(cid:258)lanie metod 236 7.2.2. Dostosowywanie operatorów jednoargumentowych 238 7.3. Metody z nazw(cid:200) zako(cid:241)czon(cid:200) wykrzyknikiem i metody „niebezpieczne” 239 7.3.1. Destrukcyjne efekty (zmieniaj(cid:200)ce odbiorc(cid:218)) uznawane za „niebezpieczne” 240 7.3.2. Destrukcyjno(cid:258)(cid:202) i „niebezpiecze(cid:241)stwo” zmieniaj(cid:200) si(cid:218) niezale(cid:285)nie 241 7.4. Metody wbudowane i niestandardowe to_* s(cid:239)u(cid:285)(cid:200)ce do konwersji 242 7.4.1. Konwersja (cid:239)a(cid:241)cucha: metoda to_s 243 7.4.2. Konwersja tablic za pomoc(cid:200) metody to_a i operatora * 246 7.4.3. Konwersja liczb za pomoc(cid:200) metod to_i i to_f 247 7.4.4. Metody z rodziny to_* przyjmuj(cid:200)ce role 248 Stany i obiekty boolowskie oraz obiekt nil 250 7.5.1. Obiekty true i false jako stany 251 7.5.2. Obiekty true i false 252 7.5.3. Obiekt specjalny nil 254 7.5. Poleć książkęKup książkę Spis tre(cid:258)ci 11 7.6. 7.7. 7.8. Testy równo(cid:258)ci 255 Porównania i modu(cid:239) Comparable 256 Porównanie dwóch obiektów 255 7.6.1. 7.6.2. Inspekcja mo(cid:285)liwo(cid:258)ci obiektów 258 7.7.1. Wy(cid:258)wietlanie listy metod obiektu 259 7.7.2. Odpytywanie obiektów klas i modu(cid:239)ów 260 7.7.3. Listy filtrowanych i wybranych metod 261 Podsumowanie 261 Rozdzia(cid:239) 8. (cid:146)a(cid:241)cuchy, symbole i inne obiekty skalarne 263 8.1. 8.2. Podstawowe modyfikacje (cid:239)a(cid:241)cuchów 268 Porównywanie (cid:239)a(cid:241)cuchów i okre(cid:258)lanie ich kolejno(cid:258)ci 275 Transformacja (cid:239)a(cid:241)cuchów 276 Zastosowanie (cid:239)a(cid:241)cuchów 264 8.1.1. Notacja (cid:239)a(cid:241)cuchów 264 8.1.2. 8.1.3. Odpytywanie (cid:239)a(cid:241)cuchów 272 8.1.4. 8.1.5. 8.1.6. Konwersje (cid:239)a(cid:241)cuchów 279 8.1.7. Kodowanie (cid:239)a(cid:241)cuchów (cid:127) krótkie wprowadzenie 280 Symbole i ich zastosowanie 282 8.2.1. G(cid:239)ówne cechy charakterystyczne symboli 283 8.2.2. 8.2.3. 8.2.4. Symbole i identyfikatory 284 Symbole w praktyce 286 Porównanie (cid:239)a(cid:241)cuchów i symboli 288 8.3. Obiekty liczbowe 289 8.3.1. Klasy liczbowe 290 8.3.2. Wykonywanie operacji arytmetycznych 290 8.4. Czas i daty 292 Tworzenie instancji obiektów daty/czasu 293 8.4.1. 8.4.2. Metody odpytywania obiektów daty i czasu 295 8.4.3. Metody formatuj(cid:200)ce dat(cid:218) i czas 296 8.4.4. Metody konwersji daty i czasu 297 Podsumowanie 299 8.5. 9.1. 9.2. 9.3. Tworzenie nowej tablicy 304 Rozdzia(cid:239) 9. Obiekty kolekcji i kontenerów 301 Porównanie tablic i tablic asocjacyjnych 302 Przetwarzanie kolekcji za pomoc(cid:200) tablic 304 9.2.1. 9.2.2. Wstawianie, pobieranie i usuwanie elementów tablicy 308 (cid:146)(cid:200)czenie tablic z innymi tablicami 311 9.2.3. 9.2.4. Transformacje tablic 312 9.2.5. Odpytywanie tablic 314 Tablice asocjacyjne 315 9.3.1. 9.3.2. Wstawianie, pobieranie i usuwanie par tablic asocjacyjnych 317 9.3.3. Okre(cid:258)lanie domy(cid:258)lnych warto(cid:258)ci i zachowania tablic asocjacyjnych 319 9.3.4. 9.3.5. (cid:146)(cid:200)czenie tablic asocjacyjnych z innymi tablicami asocjacyjnymi 320 Transformacje tablic asocjacyjnych 321 Tworzenie nowej tablicy asocjacyjnej 315 Poleć książkęKup książkę 12 Spis tre(cid:258)ci Tablice asocjacyjne jako ostatnie argumenty metody 323 Powrót do sk(cid:239)adni argumentów: argumenty nazwane (s(cid:239)ów kluczowych) 324 Tworzenie zakresu 327 Logika w(cid:239)(cid:200)czenia do zakresów 328 9.3.6. Odpytywanie tablic asocjacyjnych 322 9.3.7. 9.3.8. Zakresy 326 9.4.1. 9.4.2. Zbiory 330 9.5.1. 9.5.2. Modyfikowanie elementów zbioru 331 9.5.3. Podsumowanie 335 Podzbiory i nadzbiory 334 Tworzenie zbiorów 331 9.4. 9.5. 9.6. Rozdzia(cid:239) 10. Kolekcje: modu(cid:239) Enumerable i klasa Enumerator 337 10.1. Zapewnianie mo(cid:285)liwo(cid:258)ci wyliczania za po(cid:258)rednictwem metody each 338 10.2. Zapytania boolowskie dotycz(cid:200)ce modu(cid:239)u Enumerable 340 10.3. Wyszukiwanie i wybieranie obiektów wyliczeniowych 343 10.3.1. Uzyskiwanie pierwszego dopasowania za pomoc(cid:200) metody find 343 10.3.2. Uzyskiwanie wszystkich dopasowa(cid:241) za pomoc(cid:200) metod find_all (inaczej select) i reject 345 10.3.3. Wybieranie dopasowa(cid:241) operatora równo(cid:258)ci === za pomoc(cid:200) metody grep 345 10.3.4. Organizowanie wyników wybierania za pomoc(cid:200) metod group_by i #partition 347 10.4. Operacje wyliczeniowe dotycz(cid:200)ce elementów 348 10.4.1. Metoda first 348 10.4.2. Metody take i drop 350 10.4.3. Metody min i max 350 10.5. Metody powi(cid:200)zane z metod(cid:200) each 352 10.5.1. Metoda reverse_each 352 10.5.2. Metoda each_with_index (oraz metoda each.with_index) 352 10.5.3. Metody each_slice i each_cons 353 10.5.4. Metoda cycle 354 10.5.5. Zmniejszanie obiektu wyliczeniowego za pomoc(cid:200) metody inject 355 10.6. Metoda map 356 10.6.1. Warto(cid:258)(cid:202) zwracana metody map 357 10.6.2. Odwzorowywanie wewn(cid:218)trzne za pomoc(cid:200) metody map! 358 10.7. (cid:146)a(cid:241)cuchy jako quazi-obiekty wyliczeniowe 359 10.8. Sortowanie obiektów wyliczeniowych 360 10.8.1. W jaki sposób modu(cid:239) Comparable przydaje si(cid:218) (albo nie) podczas sortowania obiektów wyliczeniowych? 362 10.8.2. Definiowanie logiki kolejno(cid:258)ci sortowania przy u(cid:285)yciu bloku 363 10.8.3. Zwi(cid:218)z(cid:239)e sortowanie za pomoc(cid:200) metody sort_by 364 10.9. Enumeratory i nast(cid:218)pny wymiar mo(cid:285)liwo(cid:258)ci wyliczania 364 10.9.1. Tworzenie enumeratorów z blokiem kodu 365 10.9.2. Powi(cid:200)zanie enumeratorów z innymi obiektami 367 10.9.3. Niejawne tworzenie enumeratorów za pomoc(cid:200) wywo(cid:239)a(cid:241) iteratora bez u(cid:285)ycia bloku kodu 369 Poleć książkęKup książkę Spis tre(cid:258)ci 13 10.10. Semantyka enumeratorów i ich zastosowanie 369 10.10.1. Sposób u(cid:285)ycia metody each enumeratora 370 10.10.2. Ochrona obiektów za pomoc(cid:200) enumeratorów 372 10.10.3. Rozbudowana iteracja z wykorzystaniem enumeratorów 373 10.10.4. Zapewnianie mo(cid:285)liwo(cid:258)ci wyliczania za pomoc(cid:200) enumeratora 374 10.11. Tworzenie (cid:239)a(cid:241)cucha metod enumeratora 375 10.11.1. Zmniejszanie liczby obiektów po(cid:258)rednich 376 10.11.2. Indeksowanie obiektów wyliczeniowych za pomoc(cid:200) metody with_index 377 10.11.3. Operacje alternatywy wykluczaj(cid:200)cej na (cid:239)a(cid:241)cuchach z wykorzystaniem enumeratorów 378 10.12. „Leniwe” enumeratory 380 10.12.1. Problem FizzBuzz w przypadku „leniwego” enumeratora 381 10.13. Podsumowanie 382 Rozdzia(cid:239) 11. Wyra(cid:285)enie regularne i operacje na (cid:239)a(cid:241)cuchach oparte na wyra(cid:285)eniach regularnych 385 11.1. Czym s(cid:200) wyra(cid:285)enia regularne? 386 11.2. Tworzenie wyra(cid:285)e(cid:241) regularnych 387 11.2.1. Wy(cid:258)wietlanie wzorców 387 11.2.2. Proste dopasowywanie za pomoc(cid:200) wyra(cid:285)e(cid:241) regularnych litera(cid:239)u 388 11.3. Tworzenie wzorca w wyra(cid:285)eniu regularnym 389 11.3.1. Znaki litera(cid:239)u we wzorcach 389 11.3.2. Znak wieloznaczny kropki (.) 390 11.3.3. Klasy znaków 390 11.4. Dopasowywanie i przechwytywanie pod(cid:239)a(cid:241)cuchów oraz obiekt MatchData 392 11.4.1. Przechwytywanie dopasowa(cid:241) podrz(cid:218)dnych za pomoc(cid:200) nawiasów okr(cid:200)g(cid:239)ych 392 11.4.2. Dopasowanie pomy(cid:258)lne i zako(cid:241)czone niepowodzeniem 394 11.4.3. Dwa sposoby uzyskiwania przechwyce(cid:241) 395 11.4.4. Inne informacje zawarte w obiekcie MatchData 397 11.5. Dostrajanie wyra(cid:285)e(cid:241) regularnych za pomoc(cid:200) kwantyfikatorów, zakotwicze(cid:241) i modyfikatorów 398 11.5.1. Ograniczanie dopasowa(cid:241) za pomoc(cid:200) kwantyfikatorów 398 11.5.2. „Zach(cid:239)anne” (i inne) kwantyfikatory 400 11.5.3. Zakotwiczenia i asercje wyra(cid:285)e(cid:241) regularnych 403 11.5.4. Modyfikatory 406 11.6. Wzajemna konwersja (cid:239)a(cid:241)cuchów i wyra(cid:285)e(cid:241) regularnych 408 Idiomy zwi(cid:200)zane z przep(cid:239)ywem od (cid:239)a(cid:241)cucha do wyra(cid:285)enia regularnego 408 11.6.1. 11.6.2. Przej(cid:258)cie od wyra(cid:285)enia regularnego do (cid:239)a(cid:241)cucha 410 11.7. Typowe metody u(cid:285)ywaj(cid:200)ce wyra(cid:285)e(cid:241) regularnych 411 11.7.1. Metoda String#scan 411 11.7.2. Metoda String#split 412 11.7.3. sub/sub! i gsub/gsub! 414 11.7.4. Równo(cid:258)(cid:202) przypadków i metoda grep 415 11.8. Podsumowanie 417 Poleć książkęKup książkę 14 Spis tre(cid:258)ci Rozdzia(cid:239) 12. Operacje wej(cid:258)cia-wyj(cid:258)cia i operacje na plikach 419 12.1. Struktura systemu operacji wej(cid:258)cia-wyj(cid:258)cia w j(cid:218)zyku Ruby 420 12.1.1. Klasa IO 420 12.1.2. Obiekty IO jako obiekty wyliczeniowe 421 12.1.3. Obiekty STDIN, STDOUT i STDERR 422 12.1.4. Troch(cid:218) wi(cid:218)cej o danych wprowadzanych za pomoc(cid:200) klawiatury 423 12.2. Podstawowe operacje na plikach 424 12.2.1. Podstawy operacji odczytywania z plików 424 12.2.2. Odczytywanie plików oparte na wierszach 425 12.2.3. Odczytywanie plików w oparciu o bajty i znaki 426 12.2.4. Szukanie pozycji w pliku oraz odpytywanie o ni(cid:200) 427 12.2.5. Odczytywanie plików za pomoc(cid:200) metod klasy File 428 12.2.6. Zapisywanie w plikach 429 12.2.7. U(cid:285)ycie bloków do okre(cid:258)lania zasi(cid:218)gu operacji na plikach 430 12.2.8. Mo(cid:285)liwo(cid:258)ci wyliczeniowe plików 431 12.2.9. Wyj(cid:200)tki i b(cid:239)(cid:218)dy dotycz(cid:200)ce plikowych operacji wej(cid:258)cia-wyj(cid:258)cia 432 12.3. Odpytywanie obiektów IO i File 433 12.3.1. Uzyskiwanie informacji z klasy File i modu(cid:239)u FileTest 434 12.3.2. Uzyskiwanie informacji o plikach za pomoc(cid:200) klasy File::Stat 435 12.4. Modyfikowanie katalogów za pomoc(cid:200) klasy Dir 436 12.4.1. Wczytywanie pozycji katalogu 436 12.4.2. Modyfikowanie i odpytywanie katalogów 439 12.5. Narz(cid:218)dzia plikowe biblioteki standardowej 440 12.5.1. Modu(cid:239) FileUtils 440 12.5.2. Klasa Pathname 442 12.5.3. Klasa StringIO 444 12.5.4. Modu(cid:239) open-uri 446 12.6. Podsumowanie 446 CZ(cid:125)(cid:165)(cid:109) III DYNAMIKA J(cid:125)ZYKA RUBY ........................................................449 Rozdzia(cid:239) 13. Indywidualizacja obiektów 451 13.1. Tam, gdzie znajduj(cid:200) si(cid:218) metody pojedynczego obiektu: klasa pojedynczych obiektów 452 13.1.1. Podwójne okre(cid:258)lanie za pomoc(cid:200) klas pojedynczych obiektów 453 13.1.2. Bezpo(cid:258)rednie sprawdzanie i modyfikowanie klasy pojedynczych obiektów 454 13.1.3. Klasy pojedynczych obiektów w (cid:258)cie(cid:285)ce wyszukiwania metod 456 13.1.4. Metoda singleton_class 461 13.1.5. Obszerne omówienie metod klasy 461 13.2. Modyfikowanie podstawowych klas i modu(cid:239)ów j(cid:218)zyka Ruby 463 13.2.1. Zagro(cid:285)enia zwi(cid:200)zane z modyfikowaniem podstawowych funkcjonalno(cid:258)ci 463 13.2.2. Zmiany addytywne 469 13.2.3. Zmiany z przekazaniem 469 13.2.4. Zmiany poszczególnych obiektów za pomoc(cid:200) metody extend 472 13.2.5. U(cid:285)ycie doprecyzowa(cid:241) do zmiany zachowania podstawowych obiektów 475 Poleć książkęKup książkę Spis tre(cid:258)ci 15 13.3. BasicObject jako przodek i klasa 476 13.3.1. U(cid:285)ycie klasy BasicObject 476 13.3.2. Implementowanie podklasy klasy BasicObject 478 13.4. Podsumowanie 480 Rozdzia(cid:239) 14. Obiekty umo(cid:285)liwiaj(cid:200)ce wywo(cid:239)ywanie i uruchamianie 483 14.1. Podstawowe funkcje anonimowe: klasa Proc 484 14.1.1. Obiekty Proc 484 14.1.2. Obiekty Proc i bloki oraz ró(cid:285)nice mi(cid:218)dzy nimi 485 14.1.3. Konwersje dotycz(cid:200)ce bloków i obiektów Proc 487 14.1.4. U(cid:285)ycie metody Symbol#to_proc do zapewnienia zwi(cid:218)z(cid:239)o(cid:258)ci 490 14.1.5. Obiekty Proc w roli domkni(cid:218)(cid:202) 491 14.1.6. Argumenty i parametry obiektu Proc 494 14.2. Tworzenie funkcji za pomoc(cid:200) metody lambda i konstruktora - 494 14.3. Metody jako obiekty 496 14.3.1. Przechwytywanie obiektów Method 496 14.3.2. Powody u(cid:285)ywania metod jako obiektów 497 14.4. Rodzina metod eval 499 14.4.1. Przetwarzanie dowolnych (cid:239)a(cid:241)cuchów jako kodu za pomoc(cid:200) metody eval 499 14.4.2. Zagro(cid:285)enia stwarzane przez metod(cid:218) eval 501 14.4.3. Metoda instance_eval 501 14.4.4. U(cid:285)ycie metody class_eval (inaczej module_eval) 503 14.5. Równoleg(cid:239)e wykonywanie za pomoc(cid:200) w(cid:200)tków 505 14.5.1. Ko(cid:241)czenie dzia(cid:239)ania, zatrzymywanie i uruchamianie w(cid:200)tków 506 14.5.2. Serwer dat z w(cid:200)tkami 508 14.5.3. Tworzenie serwera rozmów sieciowych u(cid:285)ywaj(cid:200)cego gniazd i w(cid:200)tków 509 14.5.4. W(cid:200)tki i zmienne 511 14.5.5. Modyfikowanie kluczy w(cid:200)tków 512 14.6. Wykonywanie polece(cid:241) systemowych w obr(cid:218)bie programów Ruby 515 14.6.1. Metoda system i odwrócone apostrofy 515 14.6.2. Komunikacja z programami za po(cid:258)rednictwem metod open i Open3.popen3 518 14.7. Podsumowanie 521 Rozdzia(cid:239) 15. Wywo(cid:239)ania zwrotne, „haki” i introspekcja w czasie wykonywania kodu 523 15.1. Wywo(cid:239)ania zwrotne i „haki” 524 15.1.1. Przechwytywanie nierozpoznanych komunikatów za pomoc(cid:200) metody method_missing 525 15.1.2. Wychwytywanie operacji do(cid:239)(cid:200)czania i wstawiania na pocz(cid:200)tku 528 15.1.3. Przechwytywanie operacji rozszerzania 529 15.1.4. Przechwytywanie dziedziczenia za pomoc(cid:200) metody Class#inherited 531 15.1.5. Metoda Module#const_missing 532 15.1.6. Metody method_added i singleton_method_added 533 15.2. Interpretowanie zapyta(cid:241) dotycz(cid:200)cych mo(cid:285)liwo(cid:258)ci obiektów 535 15.2.1. Wy(cid:258)wietlanie metod nieprywatnych obiektu 535 15.2.2. Wy(cid:258)wietlanie listy metod prywatnych i chronionych 537 Poleć książkęKup książkę 16 Spis tre(cid:258)ci 15.2.3. Uzyskiwanie metod instancji klas i modu(cid:239)ów 539 15.2.4. Wy(cid:258)wietlanie listy metod pojedynczego obiektu danego obiektu 541 15.3. Introspekcja zmiennych i sta(cid:239)ych 543 15.3.1. Wy(cid:258)wietlanie listy zmiennych lokalnych lub globalnych 543 15.3.2. Wy(cid:258)wietlanie listy zmiennych instancji 543 15.4. (cid:165)ledzenie wykonywania kodu 544 15.4.1. Sprawdzanie danych (cid:258)ledzenia stosu za pomoc(cid:200) metody caller 544 15.4.2. Tworzenie narz(cid:218)dzia do analizowania danych (cid:258)ledzenia stosu 546 15.5. Wywo(cid:239)ania zwrotne i inspekcja metod w praktyce 549 15.5.1. Fundament (cid:258)rodowiska MicroTest: MiniTest 549 15.5.2. Okre(cid:258)lanie i implementowanie narz(cid:218)dzia MicroTest 551 15.6. Podsumowanie 554 Skorowidz 557 Poleć książkęKup książkę Wprowadzenie do nauki j(cid:218)zyka Ruby W tym rozdziale: (cid:81) Niezb(cid:266)dna sk(cid:225)adnia j(cid:266)zyka Ruby. (cid:81) Obja(cid:286)nienie podstawowych operacji programistycznych j(cid:266)zyka Ruby: pisanie kodu, zapisywanie, uruchamianie i sprawdzanie programów pod k(cid:261)tem b(cid:225)(cid:266)dów. (cid:81) Omówienie instalacji j(cid:266)zyka Ruby. (cid:81) Mechanizmy rozszerze(cid:276) j(cid:266)zyka Ruby. (cid:81) Standardowe narz(cid:266)dzie wiersza polece(cid:276) j(cid:266)zyka Ruby, w tym jego interaktywny interpreter (irb). Ksi(cid:200)(cid:285)ka zapewni fundamenty j(cid:218)zyka Ruby, a rozdzia(cid:239) ten stanowi przygotowanie do tego. Celem rozdzia(cid:239)u jest wprowadzenie do nauki j(cid:218)zyka Ruby przez przekazanie wiedzy i umiej(cid:218)tno(cid:258)ci wystarczaj(cid:200)cych do dalszego poznawania j(cid:218)zyka w (cid:239)atwy sposób. Przyjrzymy si(cid:218) podstawowej sk(cid:239)adni j(cid:218)zyka Ruby i zwi(cid:200)zanym z nim technikom, a tak(cid:285)e sposobowi jego dzia(cid:239)ania. B(cid:218)dzie mowa o dzia(cid:239)aniach wykonywanych podczas pisania kodu programu, metodach uruchamiania programu przez interpreter j(cid:218)zyka Ruby oraz sposobie dzielenia programu na wi(cid:218)cej ni(cid:285) jeden plik. Poznasz kilka prze- (cid:239)(cid:200)czników zmieniaj(cid:200)cych sposób dzia(cid:239)ania interpretera j(cid:218)zyka Ruby (program o nazwie ruby, do którego kierowane s(cid:200) pliki programu w celu ich wykonania), a tak(cid:285)e dowiesz si(cid:218), jak u(cid:285)ywa(cid:202) wa(cid:285)nych narz(cid:218)dzi pomocniczych maj(cid:200)cych za zadanie u(cid:239)atwienie pracy programi(cid:258)cie korzystaj(cid:200)cemu z j(cid:218)zyka Ruby i zwi(cid:218)kszenie jej efektywno(cid:258)ci. Poleć książkęKup książkę 32 ROZDZIA(cid:224) 1. Wprowadzenie do nauki j(cid:218)zyka Ruby Tre(cid:258)(cid:202) rozdzia(cid:239)u bazuje na ogólnym obrazie ca(cid:239)o(cid:258)ci j(cid:218)zyka Ruby podzielonym na nast(cid:218)puj(cid:200)ce trzy fundamentalne poziomy: (cid:81) Podstawowy j(cid:218)zyk: regu(cid:239)y projektowe, sk(cid:239)adnia i semantyka. (cid:81) Rozszerzenia i biblioteki do(cid:239)(cid:200)czone do j(cid:218)zyka Ruby oraz u(cid:239)atwienia s(cid:239)u(cid:285)(cid:200)ce do dodawania rozszerze(cid:241) we w(cid:239)asnym zakresie. (cid:81) Narz(cid:218)dzia wiersza polece(cid:241) oferowane przez j(cid:218)zyk Ruby, w przypadku których uruchamiany jest interpreter oraz kilka innych wa(cid:285)nych narz(cid:218)dzi. Nie zawsze mo(cid:285)liwe jest osobne omawianie tych trzech poziomów, poniewa(cid:285) jednak stanowi(cid:200) one cz(cid:218)(cid:258)(cid:202) jednego systemu, w niniejszym rozdziale post(cid:200)pimy w ten sposób w takim stopniu, w jakim jest to mo(cid:285)liwe. W ka(cid:285)dej sytuacji mo(cid:285)esz jednak pos(cid:239)u(cid:285)y(cid:202) si(cid:218) opisami tych trzech poziomów jak „wieszakami”, na których b(cid:218)d(cid:200) zawieszane tematy podrz(cid:218)dne po ich wprowadzeniu. Ruby, ruby i... RUBY?! Ruby to j(cid:266)zyk programowania. Mowa jest o takich poj(cid:266)ciach jak „nauka j(cid:266)zyka Ruby”. Zadajemy nast(cid:266)puj(cid:261)ce pytania: „Czy znasz j(cid:266)zyk Ruby?”. Nazwa ruby zapisana ma(cid:225)ymi literami dotyczy programu komputerowego, a dok(cid:225)adniej rzecz bior(cid:261)c, interpretera j(cid:266)zyka Ruby, który wczytuje programy i uruchamia je. Nazwa ta b(cid:266)dzie u(cid:298)ywana w nast(cid:266)puj(cid:261)- cych zdaniach: „Uruchomi(cid:225)em program ruby dla mojego pliku, ale nic si(cid:266) nie sta(cid:225)o” lub „Jaka jest pe(cid:225)na (cid:286)cie(cid:298)ka do pliku wykonywalnego ruby?”. I wreszcie: wyst(cid:266)puje nazwa RUBY, ale w(cid:225)a(cid:286)ciwie nie powinna ona istnie(cid:252). Nazwa Ruby nie jest akronimem, dlatego nigdy nie b(cid:266)dzie poprawne zapisywanie jej za pomoc(cid:261) wy(cid:225)(cid:261)cznie du(cid:298)ych liter. Wiele osób tak post(cid:266)puje, podobnie jak (równie(cid:298) niew(cid:225)a(cid:286)ciwie) w przypadku nazwy Perl, by(cid:252) mo(cid:298)e z tego powodu, (cid:298)e mia(cid:225)y do czynienia z nazwami j(cid:266)zyków takimi jak BASIC i COBOL. Ruby nie jest tego rodzaju j(cid:266)zykiem. Nazwa Ruby dotyczy j(cid:266)zyka, a nazwa ruby odnosi si(cid:266) do jego interpretera. Czy pierwszy rozdzia(cid:239) pe(cid:239)ni wy(cid:239)(cid:200)cznie rol(cid:218) przygotowania do dalszych rozdzia(cid:239)ów? Tre(cid:258)(cid:202) tego rozdzia(cid:239)u rz(cid:200)dzi si(cid:218) swoim w(cid:239)asnymi prawami: poznasz w nim rzeczywiste techniki zwi(cid:200)zane z j(cid:218)zykiem Ruby oraz wa(cid:285)ne kwestie dotycz(cid:200)ce struktury j(cid:218)zyka. Celem jest przygotowanie Czytelnika. Jednak nawet ten proces b(cid:218)dzie obejmowa(cid:202) bli(cid:285)- sze omówienie niektórych kluczowych aspektów j(cid:218)zyka Ruby. 1.1. Ogólne wprowadzenie do j(cid:266)zyka Ruby Celem niniejszego podrozdzia(cid:239)u jest zaznajomienie z j(cid:218)zykiem Ruby. Opiera si(cid:218) to na metodzie przegl(cid:200)dowej obejmuj(cid:200)cej omówienie ca(cid:239)ego cyklu poznawania wybranej sk(cid:239)adni, pisania kodu i uruchamiania programów. Na tym etapie wymagane jest zainstalowanie j(cid:218)zyka Ruby na komputerze.1 Przy- k(cid:239)ady zamieszczone w ksi(cid:200)(cid:285)ce bazuj(cid:200) na j(cid:218)zyku Ruby w wersji 2.1.0. Niezb(cid:218)dny jest równie(cid:285) edytor tekstu (mo(cid:285)esz skorzysta(cid:202) z dowolnego preferowanego edytora, je(cid:258)li jest on zwyk(cid:239)ym edytorem tekstu, a nie procesorem tekstu) oraz katalog (inaczej folder), w którym b(cid:218)d(cid:200) zapisywane pliki programów Ruby. Katalog ten mo(cid:285)e mie(cid:202) nazw(cid:218) 1 Kompletne i aktualne instrukcje instalacji j(cid:218)zyka Ruby dost(cid:218)pne s(cid:200) pod adresem http://ruby-lang.org. Poleć książkęKup książkę 1.1. Ogólne wprowadzenie do j(cid:218)zyka Ruby 33 kod_ruby lub przyk(cid:239)ady_ruby. Dowolna nazwa jest poprawna, pod warunkiem (cid:285)e odró(cid:285)- nia ona katalog od innych katalogów roboczych, aby umo(cid:285)liwi(cid:202) (cid:258)ledzenie plików progra- mów s(cid:239)u(cid:285)(cid:200)cych do (cid:202)wicze(cid:241). Interaktywny program konsoli j(cid:266)zyka Ruby (irb) — Twój nowy, najlepszy przyjaciel Narz(cid:266)dzie irb wchodzi w sk(cid:225)ad j(cid:266)zyka Ruby. Jest to najpowszechniej u(cid:298)ywane narz(cid:266)dzie wiersza polece(cid:276) j(cid:266)zyka inne ni(cid:298) sam interpreter. Po uruchomieniu tego narz(cid:266)dzia wprowa- dzasz w nim kod Ruby, który nast(cid:266)pnie jest wykonywany. Na ko(cid:276)cu wy(cid:286)wietlana jest warto(cid:286)(cid:252) wynikowa. W wierszu polece(cid:276) wpisz polecenie irb i wprowad(cid:296) przyk(cid:225)adowy kod znaleziony w tre(cid:286)ci ksi(cid:261)(cid:298)ki. Oto przyk(cid:225)ad: 100 + 32 = 132 Otwarcie sesji narz(cid:266)dzia irb oznacza, (cid:298)e mo(cid:298)esz testowa(cid:252) fragment kodu Ruby w dowol- nym momencie i ilo(cid:286)ci. Wi(cid:266)kszo(cid:286)(cid:252) projektantów programów Ruby uwa(cid:298)a to narz(cid:266)dzie za niezast(cid:261)pione. W dalszej cz(cid:266)(cid:286)ci rozdzia(cid:225)u zamieszczono kilka przyk(cid:225)adów jego u(cid:298)ycia. W przyk(cid:225)adach zastosowania narz(cid:266)dzia irb, które zawarto w ksi(cid:261)(cid:298)ce, u(cid:298)ywana b(cid:266)dzie opcja --simple-prompt u(cid:225)atwiaj(cid:261)ca odczytanie danych wyj(cid:286)ciowych narz(cid:266)dzia. irb --simple-prompt Aby sprawdzi(cid:252) efekt dzia(cid:225)ania tej opcji, spróbuj uruchomi(cid:252) narz(cid:266)dzie irb z t(cid:261) opcj(cid:261) i bez niej. Jak si(cid:266) oka(cid:298)e, opcja powoduje, (cid:298)e zawarto(cid:286)(cid:252) ekranu jest znacznie bardziej przej- rzysta. W domy(cid:286)lnym wariancie (bez tej opcji) narz(cid:266)dzie irb wy(cid:286)wietla wi(cid:266)cej informacji, takich jak licznik wierszy sesji interaktywnej. Jednak w przypadku analizowanych przy- k(cid:225)adów opcja --simple-prompt jest wystarczaj(cid:261)ca. Poniewa(cid:298) irb to jedno z narz(cid:266)dzi wiersza polece(cid:276) do(cid:225)(cid:261)czonych do j(cid:266)zyka Ruby, szcze- gó(cid:225)owo zostanie omówione dopiero w punkcie 1.4.2. Mo(cid:298)esz ju(cid:298) teraz przej(cid:286)(cid:252) do niego i zaznajomi(cid:252) si(cid:266) z jego tre(cid:286)ci(cid:261). Jest to naprawd(cid:266) proste zadanie. Po zainstalowaniu j(cid:218)zyka Ruby i przygotowaniu (cid:258)rodowiska roboczego mo(cid:285)esz kon- tynuowa(cid:202) wprowadzenie do j(cid:218)zyka Ruby, aby zapewni(cid:202) sobie podstawy przed dalszym tworzeniem programów i eksplorowaniem j(cid:218)zyka. Niezb(cid:218)dne b(cid:218)dzie wcze(cid:258)niejsze poznanie w wystarczaj(cid:200)cym stopniu podstawowej sk(cid:239)adni j(cid:218)zyka Ruby. 1.1.1. Niezb(cid:266)dna sk(cid:225)adnia j(cid:266)zyka Ruby W zamieszczonych dalej trzech tabelach podsumowano wybrane funkcje j(cid:218)zyka Ruby, które pomog(cid:200) zrozumie(cid:202) przyk(cid:239)ady zawarte w rozdziale, a tak(cid:285)e rozpocz(cid:200)(cid:202) ekspery- mentowanie za pomoc(cid:200) j(cid:218)zyka Ruby. Nie musisz zapami(cid:218)tywa(cid:202) funkcji, ale przejrzyj je i w razie potrzeby wracaj do nich pó(cid:283)niej. W tabeli 1.1 wyszczególniono niektóre podstawowe operacje j(cid:218)zyka Ruby. W tabeli 1.2 omówiono operacje pobierania podstawowych danych wprowadzonych za pomoc(cid:200) klawiatury, wysy(cid:239)anie danych wyj(cid:258)ciowych na ekran oraz najprostsze instrukcje warun- kowe. W tabeli 1.3 w skrócie opisano obiekty specjalne j(cid:218)zyka Ruby i sk(cid:239)adni(cid:218) powi(cid:200)- zan(cid:200) z komentarzami. Poleć książkęKup książkę 34 ROZDZIA(cid:224) 1. Wprowadzenie do nauki j(cid:218)zyka Ruby Tabela 1.1. Podstawowe operacje j(cid:266)zyka Ruby Przyk(cid:225)ady Komentarze Operacja Arytmetyczna Przypisanie 2 + 3 (dodawanie) 2 – 3 (odejmowanie) 2 * 3 (mno(cid:298)enie) 2 / 3 (dzielenie) 10.3 + 20.25 103 - 202.5 32.9 * 10 100.0 / 0.23 x = 1 string = Witaj Wszystkie te operacje mog(cid:261) by(cid:252) wykonywane na liczbach ca(cid:225)kowitych i zmiennopozycyjnych. (cid:224)(cid:261)czenie ze sob(cid:261) liczb ca(cid:225)kowitych i zmiennopozycyjnych, tak jak ma to miejsce w niektórych przyk(cid:225)adach, powoduje uzyskanie wyniku w postaci liczby zmiennopozycyjnej. Zauwa(cid:298), (cid:298)e zamiast .23 musisz wpisa(cid:252) 0.23. Operacja wi(cid:261)(cid:298)e zmienn(cid:261) lokaln(cid:261) (po lewej stronie) z obiektem (po prawej stronie). Na razie obiekt mo(cid:298)esz traktowa(cid:252) jako warto(cid:286)(cid:252) reprezentowan(cid:261) przez zmienn(cid:261). Zauwa(cid:298), (cid:298)e wyst(cid:266)puj(cid:261) dwa znaki równo(cid:286)ci, a nie jeden jak w przypisaniu. Aby wykona(cid:252) operacj(cid:266) arytmetyczn(cid:261), musisz upewni(cid:252) si(cid:266), (cid:298)e dost(cid:266)pne s(cid:261) liczby, a nie (cid:225)a(cid:276)cuchy znakowe. Funkcja to_i dokonuje przekszta(cid:225)cenia (cid:225)a(cid:276)cucha w liczb(cid:266) ca(cid:225)kowit(cid:261). Porównywanie dwóch warto(cid:286)ci Przekszta(cid:225)canie (cid:225)a(cid:276)cucha liczbowego w liczb(cid:266) x == y x = 100 .to_i s = 100 x = s.to_i Tabela 1.2. Podstawowe metody danych wej(cid:286)ciowych i wyj(cid:286)ciowych oraz kontrola przep(cid:225)ywu w j(cid:266)zyku Ruby Operacja Wy(cid:286)wietlanie danych na ekranie Pobieranie wiersza danych wprowadzonych za pomoc(cid:261) klawiatury Wykonywanie warunkowe Przyk(cid:225)ady print Witaj puts Witaj x = Witaj puts x x = Witaj print x x = Witaj p x gets string = gets if x == y puts Tak! else puts Nie! end Komentarze Metoda puts dodaje znak nowego wiersza do zwracanego (cid:225)a(cid:276)cucha, je(cid:286)li na jego ko(cid:276)cu nie ma jeszcze tego znaku. Metoda print nie dodaje takiego znaku. Metoda ta wy(cid:286)wietla dok(cid:225)adnie takie dane, jakie jej kazano, a nast(cid:266)pnie umieszcza kursor na ich ko(cid:276)cu (uwaga: w przypadku niektórych platform dodatkowy wiersz jest automatycznie generowany na ko(cid:276)cu dzia(cid:225)ania programu). Metoda p zwraca (cid:225)a(cid:276)cuch inspekcji, który mo(cid:298)e zawiera(cid:252) dodatkowe informacje o wy(cid:286)wietlanych danych. Wiersz z wprowadzonymi danymi mo(cid:298)esz przypisa(cid:252) bezpo(cid:286)rednio do zmiennej (zmienna string w drugim przyk(cid:225)adzie). Instrukcje warunkowe zawsze s(cid:261) zako(cid:276)czone s(cid:225)owem end. Wi(cid:266)cej informacji na ich temat zamieszczono w rozdziale 6. Kilka zasadniczych aspektów j(cid:218)zyka Ruby i jego sk(cid:239)adni jest zbyt z(cid:239)o(cid:285)onych, aby zesta- wi(cid:202) je w tabeli. Konieczne b(cid:218)dzie rozpoznawanie grupy ró(cid:285)nych identyfikatorów j(cid:218)zyka Ruby, a przede wszystkim musisz zrozumie(cid:202), czym jest obiekt w tym j(cid:218)zyku, a tak(cid:285)e jak wygl(cid:200)da wywo(cid:239)anie metody. W dalszej cz(cid:218)(cid:258)ci rozdzia(cid:239)u przyjrzymy si(cid:218) obu aspek- tom j(cid:218)zyka. Poleć książkęKup książkę 1.1. Ogólne wprowadzenie do j(cid:218)zyka Ruby 35 Tabela 1.3. Obiekty specjalne i komentarze w j(cid:266)zyku Ruby Operacja Przyk(cid:225)ady Komentarze Obiekty specjalne jako warto(cid:286)ci true false nil Obiekt domy(cid:286)lny self Wstawianie komentarzy w plikach kodu # Komentarz A x = 1 # Komentarz A Obiekty true i false cz(cid:266)sto pe(cid:225)ni(cid:261) rol(cid:266) warto(cid:286)ci zwracanych w przypadku wyra(cid:298)e(cid:276) warunkowych. Obiekt nil to swego rodzaju „nieobiekt” wskazuj(cid:261)cy na brak warto(cid:286)ci lub wyniku. Obiekty false i nil powoduj(cid:261) niepowodzenie wyra(cid:298)enia warunkowego. Wszystkie inne obiekty (w tym oczywi(cid:286)cie obiekt true, ale te(cid:298) 0 i (cid:225)a(cid:276)cuchy puste) zapewniaj(cid:261) pomy(cid:286)lne zako(cid:276)czenie takich wyra(cid:298)e(cid:276). Wi(cid:266)cej informacji na ten temat zamieszczono w rozdziale 7. S(cid:225)owo kluczowe self odnosi si(cid:266) do obiektu domy(cid:286)lnego. S(cid:225)owo to okre(cid:286)la rol(cid:266), jak(cid:261) pe(cid:225)ni(cid:261) ró(cid:298)ne obiekty, zale(cid:298)nie od kontekstu wykonywania. Wywo(cid:225)ania metod, które nie wyszczególniaj(cid:261) obiektu wywo(cid:225)uj(cid:261)cego, s(cid:261) stosowane dla obiektu self. Wi(cid:266)cej informacji na ten temat zamieszczono w rozdziale 5. Komentarze s(cid:261) ignorowane przez interpreter. 1.1.2. Ró(cid:298)norodno(cid:286)(cid:252) identyfikatorów j(cid:266)zyka Ruby J(cid:218)zyk Ruby zawiera niewielk(cid:200) liczb(cid:218) typów identyfikatorów, jakie trzeba b(cid:218)dzie od razu rozpozna(cid:202) i odró(cid:285)nia(cid:202) od siebie. Oto struktura drzewa rodziny identyfikatorów: (cid:81) Zmienne: (cid:81) lokalne, (cid:81) instancji, (cid:81) klas, (cid:81) globalne. (cid:81) Sta(cid:239)e. (cid:81) S(cid:239)owa kluczowe. (cid:81) Nazwy metod. Jest to niewielka grupa, któr(cid:200) z (cid:239)atwo(cid:258)ci(cid:200) mo(cid:285)na opanowa(cid:202). W dalszej cz(cid:218)(cid:258)ci rozdzia(cid:239)u dokonamy ich przegl(cid:200)du. Pami(cid:218)taj o tym, (cid:285)e celem lektury tego punktu jest nabycie umiej(cid:218)tno(cid:258)ci rozpoznawania ró(cid:285)nych identyfikatorów. W ró(cid:285)nych miejscach ksi(cid:200)(cid:285)ki dowiesz si(cid:218) równie(cid:285) znacznie wi(cid:218)cej o tym, jak i kiedy z nich korzysta(cid:202). Na razie jest to tylko pierwsza lekcja z zakresu identyfikatorów. ZMIENNE Nazwy zmiennych lokalnych rozpoczynaj(cid:200) si(cid:218) od ma(cid:239)ej litery lub znaku podkre(cid:258)lenia, a ponadto sk(cid:239)adaj(cid:200) si(cid:218) z liter, znaków podkre(cid:258)lenia i/lub cyfr. x, string, abc, start_ (cid:180)value i firstName to poprawne nazwy zmiennych lokalnych. Zauwa(cid:285) jednak, (cid:285)e w przypadku tworzenia nazw zmiennych lokalnych przy u(cid:285)yciu wielu s(cid:239)ów konwencja w j(cid:218)zyku Ruby okre(cid:258)la stosowanie znaków podkre(cid:258)lenia zamiast liter o ró(cid:285)nej wielko(cid:258)ci (na przyk(cid:239)ad u(cid:285)ycie nazwy first_name zamiast nazwy firstName). Poleć książkęKup książkę 36 ROZDZIA(cid:224) 1. Wprowadzenie do nauki j(cid:218)zyka Ruby Nazwy zmiennych instancji, które s(cid:239)u(cid:285)(cid:200) do przechowywania informacji na potrzeby poszczególnych obiektów, zawsze rozpoczynaj(cid:200) si(cid:218) od pojedynczego znaku @, po którym wyst(cid:218)puje taki sam zestaw znaków co w przypadku zmiennych lokalnych (na przy- k(cid:239)ad @age i @last_name). Cho(cid:202) nazwa zmiennej lokalnej nie mo(cid:285)e zaczyna(cid:202) si(cid:218) od du(cid:285)ej litery, w nazwie zmiennej instancji mo(cid:285)e ona wyst(cid:218)powa(cid:202) na pierwszej pozycji po znaku @ (jednak na tej pozycji nie mo(cid:285)na u(cid:285)y(cid:202) cyfry). Znakiem stosowanym po znaku @ jest zwykle ma(cid:239)a litera. Nazw zmiennych klas przechowuj(cid:200)cych informacje dla poszczególnych hierarchii klas (i w tym przypadku nie przejmuj si(cid:218) na razie semantyk(cid:200)) dotycz(cid:200) te same regu(cid:239)y co nazw zmiennych instancji, z t(cid:200) ró(cid:285)nic(cid:200), (cid:285)e nazwy rozpoczynaj(cid:200) si(cid:218) od dwóch zna- ków @ (na przyk(cid:239)ad @@running_total). Nazwy zmiennych globalnych s(cid:200) rozpoznawane za pomoc(cid:200) umieszczonego na ich pocz(cid:200)tku znaku $ (na przyk(cid:239)ad $population). Segmentu nast(cid:218)puj(cid:200)cego po tym znaku nie dotycz(cid:200) konwencje obowi(cid:200)zuj(cid:200)ce przy okre(cid:258)laniu nazw zmiennych lokalnych. Zmienne globalne mog(cid:200) mie(cid:202) nazwy $:, $1 i $/, a tak(cid:285)e $stdin i $LOAD_PATH. Dopóki na pocz(cid:200)tku nazwy jest znak $, jest to nazwa zmiennej globalnej. Z identyfikatorami zawie- raj(cid:200)cymi w nazwie wy(cid:239)(cid:200)cznie inne znaki ni(cid:285) alfanumeryczne spotkasz si(cid:218) prawdopo- dobnie wy(cid:239)(cid:200)cznie w postaci predefiniowanych nazw, dlatego nie ma potrzeby mar- twienia si(cid:218) tym, jakie znaki interpunkcji s(cid:200) poprawne, a jakie nie. W tabeli 1.4 podsumowano regu(cid:239)y nadawania nazw zmiennym w j(cid:218)zyku Ruby. Tabela 1.4. Poprawne nazwy zmiennych w j(cid:266)zyku Ruby wed(cid:225)ug ich typu Typ Konwencja nazewnicza j(cid:266)zyka Ruby Nazwy niezgodne z konwencj(cid:261) Lokalne Instancji Klas Globalne first_name @first_name @@first_name $FIRST_NAME firstName, _firstName, __firstName, name1 @First_name, @firstName, @name1 @@First_name, @@firstName, @@name1 $first_name, $firstName, $name1 STA(cid:224)E Nazwy sta(cid:239)ych rozpoczynaj(cid:200) si(cid:218) od du(cid:285)ej litery. A, String, FirstName i STDIN to poprawne nazwy sta(cid:239)ych. W przypadku tworzenia nazw sta(cid:239)ych za pomoc(cid:200) wielu s(cid:239)ów konwen- cja nazewnicza j(cid:218)zyka Ruby okre(cid:258)la u(cid:285)ycie ró(cid:285)nej wielko(cid:258)ci liter (np. FirstName) lub znaku podkre(cid:258)lenia, który rozdziela s(cid:239)owa z(cid:239)o(cid:285)one wy(cid:239)(cid:200)cznie z du(cid:285)ych liter (np. FIRST_NAME). S(cid:224)OWA KLUCZOWE W j(cid:218)zyku Ruby wyst(cid:218)puje wiele s(cid:239)ów kluczowych: predefiniowane oraz zastrze(cid:285)one terminy powi(cid:200)zane ze specyficznymi zadaniami i kontekstami programistycznymi. S(cid:239)owa kluczowe obejmuj(cid:200) s(cid:239)owa def (na potrzeby definicji metod), class (do definio- wania klas), if (wykonywanie warunkowe) i __FILE__ (nazwa aktualnie wykonywanego pliku). Istnieje oko(cid:239)o 40 s(cid:239)ów kluczowych. Zwykle s(cid:200) one krótkimi identyfikatorami z(cid:239)o(cid:285)onymi z jednego wyrazu (w przeciwie(cid:241)stwie do tworzonych z wykorzystaniem znaku podkre(cid:258)lenia). Poleć książkęKup książkę 1.1. Ogólne wprowadzenie do j(cid:218)zyka Ruby 37 NAZWY METOD Nazw metod w j(cid:218)zyku Ruby dotycz(cid:200) te same regu(cid:239)y i konwencje co zmiennych lokal- nych (z tym wyj(cid:200)tkiem, (cid:285)e nazwy metod mog(cid:200) by(cid:202) zako(cid:241)czone znakami ?, ! lub =, któ- rych znaczenie zostanie pó(cid:283)niej przedstawione). Z definicji metody nie zwracaj(cid:200) na siebie uwagi jako takie, lecz po prostu (cid:239)(cid:200)cz(cid:200) si(cid:218) ze struktur(cid:200) programu w postaci wyra- (cid:285)e(cid:241), które zapewniaj(cid:200) warto(cid:258)(cid:202). W przypadku niektórych kontekstów samo przyjrze- nie si(cid:218) wyra(cid:285)eniu nie pozwala stwierdzi(cid:202), czy masz do czynienia z nazw(cid:200) zmiennej lokalnej, czy metody. Jest to zamierzone. Skoro mowa o metodach, to po ogólnym zaznajomieniu si(cid:218) z identyfikatorami j(cid:218)zyka Ruby powró(cid:202)my do jego semantyki, a w szczególno(cid:258)ci do bardzo wa(cid:285)nej roli obiektu i jego metod. 1.1.3. Wywo(cid:225)ania metod, komunikaty i obiekty j(cid:266)zyka Ruby W j(cid:218)zyku Ruby wszystkie struktury danych i warto(cid:258)ci, pocz(cid:200)wszy od prostych warto- (cid:258)ci skalarnych (niepodzielnych), takich jak liczby ca(cid:239)kowite i (cid:239)a(cid:241)cuchy, a sko(cid:241)czywszy na z(cid:239)o(cid:285)onych strukturach danych (np. tablice), s(cid:200) traktowane jako obiekty. Ka(cid:285)dy obiekt ma mo(cid:285)liwo(cid:258)(cid:202) rozpoznania okre(cid:258)lonego zbioru komunikatów. Ka(cid:285)dy komunikat zro- zumia(cid:239)y dla obiektu odpowiada bezpo(cid:258)rednio metodzie, czyli nazwanej procedurze wykonywalnej, której wykonanie mo(cid:285)e by(cid:202) wyzwolone przez obiekt. Obiekty s(cid:200) reprezentowane przez konstruktory litera(cid:239)u (np. znaki cudzys(cid:239)owu w przypadku (cid:239)a(cid:241)cuchów) lub zmienne, z którymi zosta(cid:239)y powi(cid:200)zane. Wysy(cid:239)anie komu- nikatu jest realizowane za po(cid:258)rednictwem specjalnego operatora kropki: komunikat znajduj(cid:200)cy si(cid:218) po jej prawej stronie jest wysy(cid:239)any do obiektu po lewej stronie kropki (dost(cid:218)pne s(cid:200) inne, bardziej specjalistyczne sposoby wysy(cid:239)ania komunikatów do obiek- tów, ale znak kropki to najcz(cid:218)stszy i najbardziej podstawowy z nich). Przeanalizuj nast(cid:218)- puj(cid:200)cy przyk(cid:239)ad z tabeli 1.1: x = 100 .to_i Kropka oznacza, (cid:285)e komunikat to_i jest wysy(cid:239)any do (cid:239)a(cid:241)cucha 100 , który jest wywo- (cid:239)ywany przez odbiorc(cid:218) komunikatu. Mo(cid:285)liwe jest równie(cid:285) stwierdzenie, (cid:285)e metoda to_i jest wywo(cid:239)ywana w (cid:239)a(cid:241)cuchu 100 . Wynik wywo(cid:239)ania metody, czyli liczba ca(cid:239)- kowita 100, pe(cid:239)ni rol(cid:218) prawej strony przypisania do zmiennej x. Sk(cid:261)d si(cid:266) wzi(cid:266)(cid:225)a podwójna terminologia? Dlaczego komplikuje si(cid:266) wszystko, u(cid:298)ywaj(cid:261)c zarówno okre(cid:286)lenia „wysy(cid:225)anie komuni- katu to_i”, jak i „wywo(cid:225)ywanie metody to_i”? Z jakiego powodu na dwa sposoby opisy- wana jest ta sama operacja? Wynika to st(cid:261)d, (cid:298)e nie do ko(cid:276)ca operacje s(cid:261) identyczne. Przewa(cid:298)nie komunikat jest wysy(cid:225)any do obiektu odbieraj(cid:261)cego, który wykonuje odpo- wiedni(cid:261) metod(cid:266). Jednak czasami nie istnieje odpowiednia metoda. Po prawej stronie kropki mo(cid:298)esz umie(cid:286)ci(cid:252) cokolwiek (cid:127) i nie ma gwarancji, (cid:298)e odbiorca b(cid:266)dzie zawiera(cid:252) metod(cid:266) pasuj(cid:261)c(cid:261) do wysy(cid:225)anego komunikatu. Je(cid:286)li wygl(cid:261)da to na chaos, tak nie jest, poniewa(cid:298) obiekty mog(cid:261) przechwytywa(cid:252) nieznane komunikaty i podejmowa(cid:252) próby nadania im znaczenia. Na przyk(cid:225)ad (cid:286)rodowisko do pro- jektowania aplikacji internetowych Ruby on Rails intensywnie korzysta z techniki polega- j(cid:261)cej na wysy(cid:225)aniu do obiektów nieznanych komunikatów, przechwytywaniu ich i dyna- micznemu nadawaniu im znaczenia na podstawie takich warunków dynamicznych jak nazwy kolumn tabel bie(cid:298)(cid:261)cej bazy danych. Poleć książkęKup książkę 38 ROZDZIA(cid:224) 1. Wprowadzenie do nauki j(cid:218)zyka Ruby Metody mog(cid:200) pobiera(cid:202) argumenty, które tak(cid:285)e s(cid:200) obiektami (prawie wszystko w j(cid:218)zyku Ruby ma posta(cid:202) obiektu, cho(cid:202) niektóre struktury syntaktyczne, które u(cid:239)atwiaj(cid:200) two- rzenie i modyfikowanie obiektów, same nie s(cid:200) nimi). Oto wywo(cid:239)anie metody z argu- mentem: x = 100 .to_i(9) Wywo(cid:239)anie metody to_i w obiekcie 100 z argumentem 9 generuje dziesi(cid:218)tn(cid:200) liczb(cid:218) ca(cid:239)kowit(cid:200) równoznaczn(cid:200) liczbie 100 o podstawie 9: zmienna x jest równa warto(cid:258)ci dzie- si(cid:218)tnej 81. Powy(cid:285)szy przyk(cid:239)ad prezentuje równie(cid:285) u(cid:285)ycie nawiasów okr(cid:200)g(cid:239)ych dla argumen- tów metody. Nawiasy te s(cid:200) zwykle opcjonalne, ale w bardziej z(cid:239)o(cid:285)onych przypadkach mog(cid:200) by(cid:202) niezb(cid:218)dne do zapewnienia przejrzysto(cid:258)ci tego, co w przeciwnym razie mo- g(cid:239)oby by(cid:202) niejednoznaczne w sk(cid:239)adni. Tak po prostu dla pewno(cid:258)ci wielu programistów korzysta z nawiasów okr(cid:200)g(cid:239)ych w wi(cid:218)kszo(cid:258)ci lub we wszystkich wywo(cid:239)aniach metod. Ca(cid:239)a zawarto(cid:258)(cid:202) programu Ruby to obiekty i wysy(cid:239)ane do nich komunikaty. Jako programista u(cid:285)ywaj(cid:200)cy j(cid:218)zyka Ruby wi(cid:218)kszo(cid:258)(cid:202) czasu sp(cid:218)dzisz na okre(cid:258)laniu dzia(cid:239)a(cid:241), jakie mog(cid:200) zosta(cid:202) zrealizowane przez obiekty (przez definiowanie metod), lub (cid:285)(cid:200)daniu od nich wykonania tych dzia(cid:239)a(cid:241) (przez wysy(cid:239)anie im komunikatów). Wszystko to zostanie znacznie obszerniej omówione w dalszej cz(cid:218)(cid:258)ci ksi(cid:200)(cid:285)ki. I tym razem ten krótki przegl(cid:200)d stanowi jedynie cz(cid:218)(cid:258)(cid:202) procesu wprowadzania do nauki j(cid:218)zyka Ruby. Gdy ujrzysz kropk(cid:218) w miejscu, które w innym razie by(cid:239)oby czym(cid:258) niewyt(cid:239)u- maczalnym, nale(cid:285)y interpretowa(cid:202) to jako komunikat (po prawej stronie kropki) wysy- (cid:239)any do obiektu (po lewej stronie kropki). Pami(cid:218)taj te(cid:285) o tym, (cid:285)e niektóre wywo(cid:239)ania metody przyjmuj(cid:200) form(cid:218) uproszczonych wywo(cid:239)a(cid:241), takich jak wywo(cid:239)anie komunikatu puts w nast(cid:218)puj(cid:200)cym przyk(cid:239)adzie: puts Witaj. Pomimo braku w tym przypadku kropki oznaczaj(cid:200)cej wysy(cid:239)anie komunikatu oraz jego jawnego odbiorcy ma miejsce wysy(cid:239)anie do obiektu komunikatu puts z argumentem Witaj. . Obiektem tym jest obiekt domy(cid:258)lny self. W czasie dzia(cid:239)ania programu zawsze zdefiniowany jest obiekt self, cho(cid:202) to, jaki obiekt jest tym obiektem, zmienia si(cid:218) zgodnie z okre(cid:258)lonymi regu(cid:239)ami. Znacznie wi(cid:218)cej informacji o obiekcie self zamiesz- czono w rozdziale 5. Na razie miej (cid:258)wiadomo(cid:258)(cid:202) tego, (cid:285)e uproszczone zapisy, takie jak puts, mog(cid:200) oznacza(cid:202) wywo(cid:239)anie metody. W j(cid:218)zyku Ruby najwa(cid:285)niejszym poj(cid:218)ciem jest obiekt. Blisko z nim powi(cid:200)zane i odgry- waj(cid:200)ce istotn(cid:200) dodatkow(cid:200) rol(cid:218) jest poj(cid:218)cie klasy. POCHODZENIE OBIEKTÓW W KLASACH Klasy definiuj(cid:200) klastry zachowania lub funkcjonalno(cid:258)ci, a ka(cid:285)dy obiekt jest instancj(cid:200) dok(cid:239)adnie jednej klasy. J(cid:218)zyk Ruby zapewnia du(cid:285)(cid:200) liczb(cid:218) klas wbudowanych, które reprezentuj(cid:200) wa(cid:285)ne podstawowe typy danych (s(cid:200) to na przyk(cid:239)ad klasy String, Array i Fixnum). Ka(cid:285)dorazowo podczas tworzenia obiektu (cid:239)a(cid:241)cuchowego tworzona jest instan- cja klasy String. Poleć książkęKup książkę 1.1. Ogólne wprowadzenie do j(cid:218)zyka Ruby 39 Mo(cid:285)liwe jest te(cid:285) tworzenie w(cid:239)asnych klas. Mo(cid:285)esz nawet modyfikowa(cid:202) istniej(cid:200)ce klasy j(cid:218)zyka Ruby. Je(cid:258)li nie lubisz sposobu dzia(cid:239)ania (cid:239)a(cid:241)cuchów lub tablic, mo(cid:285)esz to zmieni(cid:202). Cho(cid:202) prawie zawsze decydowanie si(cid:218) na co(cid:258) takiego nie jest dobrym pomy- s(cid:239)em, j(cid:218)zyk Ruby umo(cid:285)liwia to (w rozdziale 13. przyjrzymy si(cid:218) zaletom i wadom wpro- wadzania zmian w klasach wbudowanych). Wprawdzie ka(cid:285)dy obiekt j(cid:218)zyka Ruby jest instancj(cid:200) klasy, ale poj(cid:218)cie klasy ma mniejsze znaczenie ni(cid:285) obiektu. Wynika to z tego, (cid:285)e obiekty mog(cid:200) si(cid:218) zmienia(cid:202), zysku- j(cid:200)c metody i zachowania, które nie zosta(cid:239)y zdefiniowane w ich klasie. Klasa odpowiada za inicjowanie obiektu w ramach procesu okre(cid:258)lanego mianem tworzenia instancji. Pó(cid:283)niej jednak obiekt staje si(cid:218) niezale(cid:285)ny. Mo(cid:285)liwo(cid:258)(cid:202) adaptowania przez obiekty zachowa(cid:241), jakie nie zosta(cid:239)y zapewnione przez ich klas(cid:218), to jedna z najwa(cid:285)niejszych zasad definiuj(cid:200)cych projekt Ruby jako j(cid:218)zyk. Jak mo(cid:285)esz si(cid:218) domy(cid:258)li(cid:202), w ramach ró(cid:285)nych kontekstów cz(cid:218)sto b(cid:218)dziemy do tego wraca(cid:202). Na tym etapie b(cid:200)d(cid:283) jedynie (cid:258)wiadom tego, (cid:285)e cho(cid:202) ka(cid:285)dy obiekt ma klas(cid:218), nie jest ona jedynym wyznacznikiem mo(cid:285)liwo(cid:258)ci obiektu. Gdy ju(cid:285) dysponujesz podstawow(cid:200) wiedz(cid:200) na temat j(cid:218)zyka Ruby (w razie w(cid:200)tpli- wo(cid:258)ci mo(cid:285)esz powróci(cid:202) do przedstawionego wcze(cid:258)niej materia(cid:239)u), dokonajmy prze- gl(cid:200)du kroków zwi(cid:200)zanych z uruchamianiem programu. 1.1.4. Tworzenie i zapisywanie prostego programu Na tym etapie mo(cid:285)esz rozpocz(cid:200)(cid:202) tworzenie plików programu w utworzonym wcze- (cid:258)niej katalogu z przyk(cid:239)adowym kodem Ruby. Pierwszym programem b(cid:218)dzie konwer- ter jednostek temperatury ze stopni Celsjusza na stopnie Fahrenheita. UWAGA Oczywi(cid:258)cie praktycznie wykorzystywany konwerter stopni tempera- tury b(cid:218)dzie bazowa(cid:202) na liczbach zmiennopozycyjnych. W danych wej(cid:258)ciowych i wyj(cid:258)ciowych pozostaniemy przy liczbach ca(cid:239)kowitych, aby skoncentrowa(cid:202) si(cid:218) na kwestiach zwi(cid:200)zanych ze struktur(cid:200) programu i jego wykonywaniem. Poni(cid:285)szy przyk(cid:239)ad zostanie kilkakrotnie zastosowany. B(cid:218)dzie on stopniowy rozszerzany i modyfikowany. W kolejnych iteracjach zostan(cid:200) zrealizowane nast(cid:218)puj(cid:200)ce dzia(cid:239)ania: (cid:81) porz(cid:200)dkowanie danych wyj(cid:258)ciowych programu, (cid:81) akceptowanie danych wej(cid:258)ciowych wprowadzonych przez u(cid:285)ytkownika za pomoc(cid:200) klawiatury, (cid:81) wczytywanie warto(cid:258)ci z pliku, (cid:81) zapisywanie wyniku programu w pliku. Pierwsza wersja jest prosta. Skoncentrowano si(cid:218) w niej na procesach tworzenia pliku i uruchamiania programu, a nie na jakiejkolwiek wyszukanej logice programu. TWORZENIE PIERWSZEGO PLIKU PROGRAMU Za pomoc(cid:200) zwyk(cid:239)ego edytora tekstu wpisz kod z listingu 1.1 w pliku tekstowym i zapisz go pod nazw(cid:200) c2f.rb w katalogu z przyk(cid:239)adowym kodem. Poleć książkęKup książkę 40 ROZDZIA(cid:224) 1. Wprowadzenie do nauki j(cid:218)zyka Ruby Listing 1.1. Prosty konwerter jednostek temperatury ze stopni Celsjusza na stopnie Fahrenheita o ograniczonym zastosowaniu (plik c2f.rb) celsius = 100 fahrenheit = (celsius * 9 / 5) + 32 puts Oto wynik: puts fahrenheit puts . UWAGA Zale(cid:285)nie do u(cid:285)ywanego systemu operacyjnego mo(cid:285)esz mie(cid:202) mo(cid:285)liwo(cid:258)(cid:202) autonomicznego uruchamiania plików programu Ruby, czyli korzysta(cid:202) wy(cid:239)(cid:200)cz- nie z nazwy pliku lub nazwy skróconej (np. c2f) bez rozszerzenia pliku. Miej jednak (cid:258)wiadomo(cid:258)(cid:202) tego, (cid:285)e rozszerzenie pliku .rb jest obowi(cid:200)zkowe w niektórych sytuacjach. Przede wszystkim dotyczy to programów, które uwzgl(cid:218)dniaj(cid:200) wi(cid:218)- cej ni(cid:285) jeden plik (wi(cid:218)cej na ten temat dowiesz si(cid:218) w dalszej cz(cid:218)(cid:258)ci rozdzia(cid:239)u), a ponadto wymagaj(cid:200) mechanizmu wzajemnego znajdowania plików. W ksi(cid:200)(cid:285)ce wszystkie nazwy plików programu Ruby zako(cid:241)czone s(cid:200) rozszerzeniem .rb w celu zapewnienia, (cid:285)e przyk(cid:239)ady b(cid:218)d(cid:200) dzia(cid:239)a(cid:202) w przypadku wielu platform, wymaga- j(cid:200)c w jak najmniejszym stopniu dzia(cid:239)a(cid:241) administracyjnych. Dysponujesz teraz na dysku kompletnym (cho(cid:202) niewielkim) programem Ruby, który mo(cid:285)esz uruchomi(cid:202). 1.1.5. Kierowanie programu do interpretera j(cid:266)zyka Ruby Uruchamianie programu Ruby wi(cid:200)(cid:285)e si(cid:218) z przekazaniem jego pliku (cid:283)ród(cid:239)owego (lub plików) do interpretera j(cid:218)zyka Ruby o nazwie ruby. W pewnym sensie wykonasz teraz tak(cid:200) operacj(cid:218). Przeka(cid:285)esz program do interpretera ruby, ale zamiast (cid:285)(cid:200)da(cid:202) od niego uruchomienia programu, poprosisz o sprawdzenie kodu programu pod k(cid:200)tem b(cid:239)(cid:218)dów sk(cid:239)adni. SPRAWDZANIE POD K(cid:260)TEM B(cid:224)(cid:265)DÓW SK(cid:224)ADNI Je(cid:258)li we wzorze konwersji zamiast liczby 32 umie(cid:258)cisz liczb(cid:218) 31, wyst(cid:200)pi b(cid:239)(cid:200)d pro- gramistyczny. Interpreter j(cid:218)zyka Ruby w dalszym ci(cid:200)gu bez (cid:285)adnych problemów uruchomi program i zwróci b(cid:239)(cid:218)dny wynik. Je(cid:258)li jednak przypadkiem w drugim wier- szu kodu programu pominiesz nawias domykaj(cid:200)cy, wyst(cid:200)pi b(cid:239)(cid:200)d sk(cid:239)adni i interpreter nie wykona programu: $ ruby broken_c2f.rb broken_c2f.rb:5: syntax error, unexpected end-of-input, expecting ) B(cid:239)(cid:200)d zosta(cid:239) zg(cid:239)oszony w pi(cid:200)tym, czyli ostatnim wierszu programu, poniewa(cid:285) interpreter j(cid:218)zyka Ruby oczekuje cierpliwie na stwierdzenie, czy w ogóle zamierzasz domkn(cid:200)(cid:202) nawias, zanim uzna, (cid:285)e tak nie jest. W wygodny sposób interpreter j(cid:218)zyka mo(cid:285)e sprawdza(cid:202) programy pod k(cid:200)tem b(cid:239)(cid:218)dów sk(cid:239)adni bez ich uruchamiania. Interpreter wczytuje plik i informuje o tym, czy sk(cid:239)ad- nia jest poprawna. Aby dla pliku przeprowadzi(cid:202) sprawdzanie sk(cid:239)adni, wykonaj nast(cid:218)- puj(cid:200)ce polecenie: $ ruby -cw c2f.rb Poleć książkęKup książkę 1.1. Ogólne wprowadzenie do j(cid:218)zyka Ruby 41 Opcja wiersza polece(cid:241) -cw stanowi zapis skrócony dwóch opcji: -c i -w. Opcja -c powo- duje sprawdzanie pod k(cid:200)tem b(cid:239)(cid:218)dów sk(cid:239)adni. Opcja -w aktywuje wy(cid:285)szy poziom ostrze- (cid:285)e(cid:241): interpreter j(cid:218)zyka Ruby b(cid:218)dzie zg(cid:239)asza(cid:202) zastrze(cid:285)enia, je(cid:258)li wykonano dzia(cid:239)ania przez niego dopuszczane, ale budz(cid:200)ce w(cid:200)tpliwo(cid:258)ci z innych punktów widzenia ni(cid:285) sk(cid:239)adnia. Przy za(cid:239)o(cid:285)eniu, (cid:285)e poprawnie wpisano nazw(cid:218) pliku, na ekranie powinien zosta(cid:202) wy(cid:258)wietlony nast(cid:218)puj(cid:200)cy komunikat: Syntax OK URUCHAMIANIE PROGRAMU Aby uruchomi(cid:202) program, przeka(cid:285) jeszcze raz plik interpreterowi, lecz tym razem bez po(cid:239)(cid:200)czonych opcji -c i -w: $ ruby c2f.rb Je(cid:258)li wszystko si(cid:218) powiedzie, zostan(cid:200) zwrócone dane wyj(cid:258)ciowe oblicze(cid:241): Oto wynik: 212 . Wynik oblicze(cid:241) jest poprawny, ale nie(cid:239)adnie wygl(cid:200)daj(cid:200) dane wyj(cid:258)ciowe rozmieszczone w trzech wierszach. DRUGA ITERACJA KONWERTERA Problem mo(cid:285)e zosta(cid:202) sprowadzony do ró(cid:285)nicy mi(cid:218)dzy poleceniami puts i print. Pole- cenie puts dodaje znak nowego wiersza na ko(cid:241)cu wy(cid:258)wietlonego (cid:239)a(cid:241)cucha, je(cid:258)li nie jest on ju(cid:285) zako(cid:241)czony takim znakiem. Z kolei polecenie print wy(cid:258)wietla (cid:285)(cid:200)dany (cid:239)a(cid:241)- cuch, a nast(cid:218)pnie ko(cid:241)czy dzia(cid:239)anie. Polecenie nie powoduje automatycznego przej(cid:258)cia do nast(cid:218)pnego wiersza. Aby usun(cid:200)(cid:202) ten problem, zmie(cid:241) pierwsze dwa polecenia puts na polecenie print: print Oto wynik: print fahrenheit puts . Zwró(cid:202) uwag(cid:218) na znak spacji po znaku dwukropka; zapewnia ona, (cid:285)e mi(cid:218)dzy dwukrop- kiem i liczb(cid:200) pojawi si(cid:218) odst(cid:218)p. Dane wyj(cid:258)ciowe maj(cid:200) teraz nast(cid:218)puj(cid:200)c(cid:200) posta(cid:202): Oto wynik: 212. puts to skrót od s(cid:239)ów put (wy(cid:258)wietl) string ((cid:239)a(cid:241)cuch). Cho(cid:202) s(cid:239)owo put mo(cid:285)e nie wskazywa(cid:202) intuicyjnie przej(cid:258)cia do nast(cid:218)pnego wiersza, w(cid:239)a(cid:258)nie to powoduje polecenie puts. Podob- nie jak polecenie print wy(cid:258)wietla ono (cid:285)(cid:200)dane dane, ale te(cid:285) automatycznie zapewnia przej(cid:258)cie do nast(cid:218)pnego wiersza. Je(cid:258)li za(cid:285)(cid:200)dasz od polecenia puts wy(cid:258)w
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Ruby. Przewodnik programisty. Wydanie II
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: