LT   EN   RU  
2020 m. balandžio 1 d., trečiadienis Straipsniai.lt - Teminis naujienų ir straipsnių katalogas
  Programavimas
  Technologijos > Kompiuterinės technologijos > Programavimas
Lankomumo reitingas Publikuota: 2003-01-24 Spausdinti Spausdinti
Programavimas Ruby - pragmatiško programuotojo vadovas

Įžanga

Žmogus nori kurti. Aš bent jau žinau, kad aš mėgstu kurti. Ir nors aš nesu geras tapytojas, dailininkas ar muzikantas, aš galiu kurti programas.

Tuoj po to kai susipažinau su kompiuteriais, mane sudomino programavimo kalbos. Maniau, kad įmanoma sukurti idealią programavimo kalbą, ir aš norėjau būti jos kūrėju. Vėliau, įgavęs šiek tiek patirties, pamačiau, kad sukurti idealią, viskam tinkančią kalbą yra sudėtingiau nei maniau. Bet aš vis vyliausi sukurti kalbą, kuri tiktų daugumai dalykų, kuriuos man tenka programuoti kiekvieną dieną. Tokios buvo mano svajonės kol buvau studentas.

Po keleto metų aš kalbėjausi su kolegomis apie interpretuojamas kalbas, jų galingumą ir galimybes. Jau penkiolika metų man patiko objektinio programavimo idėja, todėl man atrodė, kad objektinis programavimas tiktų ir interpretuojamoms kalboms. Internete paieškojau objektinių interpretuojamų kalbų, bet radau tik Perl ir Python, o jos tiksliai neatspindėjo ko ieškojau. Norėjau kalbos, galingesnės už Perl ir labiau objektiškai orientuotos nei Python.

Tada prisiminiau savo seną svajonę sukurti programavimo kalbą. Pradžioje aš tik žaidžiausi su šia idėja darbe, bet pamažu ji išaugo į ganėtinai galingą įrankį, kuris galėjo pakeisti Perl. Pavadinau ją Ruby -- pagal brangųjį akmenį rubiną -- ir išleidau viešam naudojimui 1995 metais.

Nuo to laiko daug žmonių susidomėjo Ruby. Norit tikėkit, norit ne, bet jau dabar Ruby Japonijoje yra populiaresnis už Python. Tikiuosi jis bus panašiai pripažintas visame pasaulyje.

Manau, kad gyvenimo tikslas, jei ne pagrindinis, tai bent vienas svarbiausių, yra būti laimingam. Tikėdamas tuo sukūriau Ruby taip, kad juo būtų ne tik lengva programuoti, bet kad pats programavimas teiktų džiaugsmą. Ruby leidžia susikoncentruoti prie kūrybinės programavimo dalies, patiriant mažiau stresų. Jei netikite, perskaitykite šią knygą ir pamatysite patys.

Aš esu labai dėkingas žmonėms, kurie prisijungė prie Ruby bendruomenės, jie daug man padėjo. Aš beveik manau, kad Ruby yra vienas mano vaikų, bet iš tikrųjų, jis yra daugelio žmonių pastangų vaisius. Be jų pagalbos Ruby niekada nebūtų tapęs tuo kuo yra.

Aš esu labai dėkingas šios knygos autoriams Dave Thomas ir Andy Hunt. Ruby niekada nebuvo gerai dokumentuota kalba, nes aš pats visada teikdavau primenybę kodo, o ne dokumentų, rašymui, dėl to Ruby aprašymas yra skurdesnis nei jis turėtų būti. Kol nebuvo šios knygos, jūs būtumėte turėję skaityti pirminį kalbos kodą, norėdami sužinoti kaip veikia Ruby, bet dabar šį darbą už jus atliko šios knygos autoriai.

Jie susidomėjo mažai kam žinoma kalba iš Tolimųjų Rytų. Jie perskaitė tūkstančius kodo eilučių, parašė nesuskaičiuojamą daugybę bandomųjų programėlių ir elektroninio pašto laiškų, išsiaiškino neaiškias kalbos vietas, surado programavimo klaidų (ir netgi pays kai kurias jų ištaisė) ir galų gale parašė šią knygą. Dabar Ruby yra tikrai gerai dokumentuotas.

Autorių darbas tikrai nebuvo lengvas. Kol jie rašė šią knygą, aš keičiau kalbą. Bet mes dirbome drauge, tad ši knyga yra kiek galima tikslesnis kalbos aprašymas.

Tikiuosi kad Ruby ir ši knyga palengvins jūsų programavimą ir jis teiks jums daugiau malonumo. Sėkmės!

Yukihiro Matsumoto, a.k.a "Matz"
Japonija, 2000 spalis

Įvadas

Ši knyga yra kartu ir Ruby kalbos vadovėlis, ir aprašymas. Naudokitės Ruby, ir jūs rašysite geresnį kodą, būsite produktyvesni ir labiau džiaugsitės pačiu rogramavimu.

Tai labai stiprūs teiginiai, bet manome, kad perskaitę šią knygą, su jais pilnais sutiksite. Be to, mūsų patirtis taip įrodo šiuos teiginius.

Būdami pragmatiškais programuotojais mes bandėme daug daug kalbų norėdami rasti tą, kuri palengvintų mūsų gyvenimą ir leistų geriau atlikti savo darbą. Iki šiol mums vis tekdavo nusivilti.

Mūsų darbas yra spręsti problemas, o ne taikytis prie kompiliatoriaus taisyklių, todėl mums patinka dinaminės programavimo kalbos, kurios prisitaiko prie mūsų ir kurios neturi griežtų taisyklių. Mums reikia aiškumo, kad galėtume laisvai keistis kodu. Mes vertiname trumpumą ir galimybę kodu tiksliai ir aiškiai išreišti norimą problemos sprendimą. Kuo mažiau kodo mes rašome, tuo mažesnė tikimybė, kad yra klaidų (mūsų pirštai ir rankos taip pat lieka dėkingi).

Mes norime būti kuo produktyvesni, todėl norime kad kodas veiktų iš pirmo karto; laikas praleistas ieškant programos klaidų yra laikas, kurį pavagiame iš programavimo laiko. Taip pat yra gerai kai mes galime išbandyti kodą tuo pačiu metu kai jį rašome -- jei užtrunka 2 valandas, kol susikompiliuoja programa, sunku tai pavadinti produktyvumu.

Mes norime kalbos, kuri veiktų aukštame abstrakcijos lygyje. Kuo aukštesnio lygio kalba, tuo mažiau laiko užtrunka kol paverti algortimą kodu.

Kai užtikome Ruby, supratome, kad radome ko ieškojome. Daugiau nei bet kuri kita kalba, Ruby pasitraukia iš kelio ir leidžia daryti tai ką norite. Galite koncentruotis į problemos sprendimą, vietoj to, kad prakaituotumėte ties kalbos ir kompiliatoriaus plonybėmis. Štai kuo Ruby gali jums padėti tapti geresniu programuotoju: jūs spręsite problemas vartotojams, o ne kompiliatoriui.

Ruby ypatumai

Paimkite objektinę kalbą, tokią kaip Smalltalk. Išmeskite nepažįstamą sintaksę ir pereikite prie įprasto, bylų pagrindu sudaryto kodo. Dabar pridėkite nemažai tokų kalbų kaip Python ir Perl lankstumo ir patogumo.

Gavote Ruby.

Objektinio programavimo gerbėjai ras Ruby tokius dalykus kaip grynas objektiškumas (viskas yra objektas), metaklases, užbaigtumas(closure), kartotojus (iterators), visur esančias heterogenines aibes (ubiquitous heterogenous collections). Smalltalk vartotojai jausis kaip namie, o Java ir C++ vartotojai tik pavydės ;).

Tuo pačiu metu Perl ir Python programuotojai ras daugelį jų mėgstamų dalykų: paprastąsias išraiškas (regular expressions), tvirtą integraciją su vietine operacine sistema, patogias santrumpas ir dinaminį kodo įvertinimą.

Ruby lengva išmokti. Kasdienines užduotis nesunku programuoti, o kai jos jau suprogramuotos, kodą nesunku palaikyti ir plėsti. Dalykai, kurie galbūt iš pažiūros atrodo sudėtingai, pasirodo esą visiškai lengvi. Ruby vadovaujasi mažiausio nustebimo principu -- kodas veikia taip kaip ir tikisi programuotojas, ir yra labai mažai specialių atvejų ir išimčių. O tai tikrai svarbu programuojant.

Ruby galima vadinti permatoma kalba. Tuo mes norime pasakyti, kad Ruby nepaslepia jūsų problemo sprendimo kodo sintaksės brūzgynuose ir kad pakanka keleto eilučių jūsų programai parašyti. Rašant Ruby programas galima susikoncentruoti ties pačios problemos sprendimu. Problemų sprendimus galite elegentiškai išreikšti Ruby sintakse, kai kitomis kalbomis tai nėra lengva. Tai reiškia, kad jųūs programuojate greičiau, o jūsų kodas išlieka lengvai perskaitomas ir suprantamas.

Naudojantis Ruby jūs dažnai nustebsite pamatę kiek kodo galite parašyti vienu prisėdimu, ir kad jis veikia iš pirmo karto. Ruby yra nedaug sintaksės klaidų, jokių kintamųjų tipų pažeidimų ir mažiau kodo klaidų. Tai suprantama: kuo mažiau kodo, tuo mažiau klaidų. Nėra jokių dvitaškių, kuriuos reiktų mechaniškai rašyti eilutės pabaigoje. Nėra kintamųjų tipų deklaracijų, apie kuriuos niekada negalėtumėte pamiršti (ypač jei jie būtų skirtingose bylose). Nėra jokių nereikalingų žodžių, kurie būtų skirti tik kompiliatoriui patenkinti.

Taigi kodėl mokytis Ruby? Nes manome, kad tai jums padės geriau programuoti. Tai leis jums nesiblaškant koncentruotis ties problema, kurią jums reikia spręsti. Tai padarys jūsų gyvenimą lengvesnį.

Kokia kalba tas Ruby?

Senais laikais programavimo kalbas buvo lengva skirstyti į kompiliuojamas, kaip C ir Fortranas, ir interpretuojamas, kaip BASIC. Kompiliuojamos kalbos davė greitį ir žemą programavimo lygį. Interpretuojamos kalbos buvo aukštesnio lygio, bet lėtesnės.

Laikai keičiasi, ir viskas nebėra taip paprasta. Kai kurie autoriai pradėjo vadinti savo kalbas "Scenarijinėmis kalbomis". Tuo jie nori pasakyti, kad kalbos yra interpretuojamos, bet jomis galima pakeisti paketines bylas (batch files) ir aplinkos scenarijus (shell scripts) bei vadovauti programų vykdymui ir pačiai operacinei sistemai. Perl, TCL ir Python vadinamos scenarijinėmis kalbomis.

Tai kas iš tikrųjų yra scenarijinė kalba? Tiesą sakant abejojame ar svarbu jas apibrėžti. Su Ruby jūs galite pasiekti visus operacinės sistemos resursus. Su Ruby galite daryti viską, ką galite daryti su Perl ar Python, tačiau jūs tai galite daryti žymiai švariau. Tačiau Ruby yra kitoks. Tai tikra programavimo kalba su stipriomis teorinėmis šaknimis ir elegantiška, lengva sintakse. Su Ruby jūs galite parašyti daug scenarijų vienai problemai spręsti, bet jūs turbūt taip nedarysite. Vietoj to jūs parašysite programą, kurią bus lengva suprasti, palaikyti ir ateityje išplėsti.

Nors mes naudojome Ruby scenarijų rašymui, dažniau Ruby buvo pilna programavimo kalba bendroms problemoms spręsti. Mes naudojome Ruby grafinėms programoms, tarnybinių stočių procesams ir knygų formatavimui. Kiti vartojo Ruby tarnybinių stočių administravimui ir duomenų bazėms. Ruby pateikia WWW puslapius, jungiasi į duomenų bazes, generuoja dinaminį interneto puslapių turinį. Žmonės Ruby rašo dirbtinio intelekto ir kompiuterių mokymo programas, ir bent jau vienas žmogus naudoja Ruby natūralios evoliucijos tyrinėjimams. Ruby yra ir įrankis matematikos tyrinėjimams. Žmonės visame pasaulyje naudoja Ruby įvairių programų sulipdymui. Ruby yra puiki kalba, pritaikoma daugelyje sričių.

Ar Ruby man?

Ruby nėra panacėja visoms pragramavimo problemoms. Visada bus taip, kad prireiks kokios nors specialios kalbos: galbūt to reikalaus aplinka, galbūt reikės specialių bibliotekų, galbūt reikės ypač greitai vykdomo kodo arba galbūt bus žymiai lengviau parašyti programą kita kalba nei Ruby vien dėl to, kad ją geriau mokate. Mes nepamiršome tokių kalbų kaip Java ir C++ (nors kartais norsi kad būtume pamiršę).

Tačiau Ruby labiau pritaikomas negu jūs įsivaizduojate. Jį lengva tobulinti, tiek per pačią kalbą, tiek jungiant trečiųjų programuotojų bibliotekas. Ruby nesunku pernešti ant kitų platformų. Ruby yra "lengvas" ir naudoja mažai sistemos resursų. Ruby lengva išmokti, mes pažįstam žmonių, kurie parašė savo pirmas programas tą pačią dieną, kai perskaitė šią knygą. Mes naudojome Ruby rašydami X11 langų administratorių, o ši užduotis paprastai atliekama sudėtingu C kalbos programavimu. Ruby susidorojo puikiai ir mes parašėme kodą per porą valandų, kai tokią pačią programą ant C būtume rašę porą dienų.

Manome, kad kai susipažinsite su Ruby, jūs jį naudosite kaip pagrindinę programavimo kalbą.

Kodėl mes parašėme šią knygą?

Mes ką tik pabaigėme rašyti Pragmatiško programuotojo vadovą, mūsų šeimos vėl pradėjo su mumis kalbėtis, ir staiga mums prireikė parašyti dar vieną knygą. Kodėl? Manau tai susiję su kažkokia misionieriška aistra.

Ruby buvo sukurta Yukihiro Matsumoto (Matz) Japonijoje. Nuo 1995 metų jos populiarumas augo neregėtais tempais, ir kalbama, kad ji populiarumu Japonijoje pralenkė Python. Tačiau iki šios knygos visa Ruby dokumentacija buvo japoniška, tad Ruby nebuvo programavimo kalba, kurią lengva išmokti angliakalbiams.

Mes norėjome paskleisti žodį apie Ruby, norėjome, kad daugiau žmonių už Japonijos ribų galėtų juo naudotis jo teikiamais privalumais, todėl nusprendėme aprašyti Ruby angliškai. Tai, kas prasidėjo kaip nedidelis projektas pamažu išaugo į tai ką dabar skaitote...

Ruby versijos

Šioje knygoje aprašyta Ruby kalbos versija 1.6, kuri buvo išleista 2000 metų rugsėjį.

Ruby versijų numeriai panašūs į visų atviro kodo projektų versijų numerius. Versijos, besibaigiančios poriniais skaičiais (1.0, 1.2, 1.4 ir panašiai) yra stabilios. Kiekviena versija būna supakuojama, ir jas galima parsisiųsti iš įvairių Ruby svetainių.

Versijos, besibaigiančios neporiniais skaičiais (1.1, 1.3 ir panašiai), yra nestabilios versijos. Jas jūs turėsite parsisiųsti ir susikompiliuoti patys.

Ruby instaliavimas

Ruby galite parsisiųsti iš ftp://ftp.netlab.co.jp/pub/lang/ruby/, arba iš veidrodinių svetainių. Čia rasite tiek stabilias, tiek nestabilias Ruby versijas.

Jūs visada rasite Ruby išeities kodus, kartais rasite ir kompiliuotas Windows ar kitų operacinių sistemų versijas. (pavyzdžiui Ruby Windowsams galite rasti http://www.pragmaticprogrammer.com/ruby/downloads/ruby-install.html

Pats naujausias Ruby

Tie, kas nori turėti pačią naujausią, nepatikrintą Ruby versiją, ją gali gauti tiesiai iš programuotojų darbinės kodo saugyklos.

Ruby programuotojai naudojasi CVS (Concurrent Version System, kurią nemokamai galite gauti iš http://www.cvshome.com). Parašę šias CVS komandas galite anonimiškai gauti paskutinį Ruby kodą:

% cvs -d :pserver:anonymous@cvs.netlab.co.jp:/home/cvs
login
(Logging in to anonymous@cvs.netlab.co.jp)
CVS password: guest
% cvs -d :pserver:anonymous@cvs.netlab.co.jp:/home/cvs
checkout ruby

Dabar visas pats naujausias Ruby kodas bus nukopijuotas į "ruby" direktoriją jūsų kompiuteryje. Jei nuo paskutinio šios komandos vykdymo įvyko kodo paketimų, visi jie bus perkopijuoti. Taip visada savo kompiuteryje galite turėti naujausią Ruby kodo versiją. Argi ne puiku?

Ruby kompiliavimas

Ruby išeities koduose rasite bylą, pavadintą README, kuri smulkiai paaiškina įdiegimo procedūrą. Trumpai galime pasakyti, kad POSIX sistemose Ruby kompiliuoti reikia taip kaip ir daugumą kitų programų: ./configure, make, make test ir make install. Kitose aplinkose (pvz Windows) jūs galite sukompiliuoti Ruby naudodamiesi POSIX emuliavimo bibliotekomis (cygwin ant Windows -- žiūrėkite http://sourceware.cygnus.com/cygwin/) arba vietiniais kompiliatoriais -- žiūrėkite bylą "ntsetup.bat" win32 subdirektorijoje.

Ruby paleidimas

Dabar kai instaliavote Ruby, turbūt norėsite paleisti keletą programų. Yra du Ruby programų paleidimo būdai: kaip paprastos programos ir interaktyvus.

Interaktyvus Ruby

Lengviausia ruby paleisti komandinėje eilutėje surinkus "ruby".

% ruby
puts "Hello, world!"
^D
Hello, world!

Čia mes parašėme vieną puts sakinį ir bylos pabaigos žymę (kuri mūsų sistemoje yra control-D). Šis procesas paprastas, bet jei padarote rašybos klaidą, ją sunku ištaisyti, nes nelabai matote kas vyksta spausdinimo metu.

sample direktorijoje jūs rasite scenarijų, pavadintą "eval.rb". Jis yra vienu žingsniu tobulesnis, nes parodo kiekvieno įvesto sakinio reikšmę:

% cd sample
% ruby eval.rb
ruby> a = "Hello, world!"
"Hello, world!"
ruby> puts a
Hello, world!
nil
ruby> ^D
%

Čia mes galime matyti puts rezultatą, ir puts gražinąmą reikšmę (kuri yra nil).

Visa tai yra labai puiku, bet keleto eilučių kodas neveikia ir negalite taisyti jau parašytų eilučių.

Kitas žingsnis nuo "eval.rb" yra "irb" -- interaktyvus Ruby. irb yra Ruby apvalkalas su komandinės eilutės istorija ir eilutės taisymo galimybe. Jį galima prisitaikyti savo reikmėms pasirenkant reikiamus parametrus. Tų parametrų tiek daug, kad jie aprašomi atskirame šios knygos priede. Mes rekomenduojame bent šiek tiek susipažinti su irb, nes taip bus lengviau išbandyti šioje knygoje pateikiamus kodo gabaliukus.


Ruby programos

Galiausiai galite paleisti Ruby programas kaip ir bet kokį kitą scenarijų, Perl ar Python programą. Ruby interpretatoriui paprasčiausiai reikia perduoti scenarijaus bylos vardą:

% ruby myprog.rb

Arba galite naudotis UNIX "shebang" užrašu pirmoje bylos eilutėje. (Jei jūsų operacinė sistema tai palaiko, galite vietoj absoliutaus kelio iki ruby interpretatoriaus nurodyti /usr/bin/env ruby, tada pradžioje bus ieškomas aplinkos kintamasis ruby ir tik po to jis bus įvykdomas.)

#!/usr/local/bin/ruby -w

puts "Hello, World!"


Jei padarote šią bylą vykdomąja (tarkim komanda chmod +x myprog.rb), UNIX leis ją jums įvykdyti kaip programą:

% ./myprog.rb
Hello, World!

Kažką panašaus galite pasiekti ir Windows aplinkoje naudodami bylų asociacijas.

Šaltiniai

Pasilankykite Ruby interneto svetainėse http://www.rubycentral.com ir http://www.ruby-lang.org. Jose rasite naujausią informaciją apie Ruby, galėsite pabendrauti su kitais Ruby vartotojais naujienų gruėse ir susirašinėjimo sąrašuose (žiūrėkite priedą C)

Aišku mums būtų džiugu gauti iš jūsų atsiliepimų, komentarų, pasiūlymų, klaidų tekste, ar problemų, su kuriomis susiduriate pavyzdžiuose. Mūsų e-pašto adresas: rubybook@pragmaticprogrammer.com

Jei knygoje pastebėsite klaidų, mes visas jas aprašysime klaidų sąraše http://www.pragmaticprogrammer.com/ruby/errata/errata.html

Galiausiai aplankykite http://www.pragmaticprogrammer.com/ruby, kur rasite visoje knygoje esančių pavyzdžių išeities kodus.

Padėkos

Ši knyga yra didžiulis darbas, kuris niekada nebūtų baigtas be senų ir naujų bičiulių paramos. Dėkojame Addison-Wesley komandai: Mike Hendrickson, John Fuller, Julie Steele ir Julie DiNicola.

Dėkojame ir recenzentams, kurie privertė mus laikytis terminų ir recenzavo knygą: George Coe, Bob Davison, Jeff Deifik, Hal Fulton, Tadayoshi Funaba, Clemens Hintze, Kazuhiro Hiwada, Kikutani Makoto, Mike Linksvayer, Aleksi Niemelä, Lew Perin, Jared Richardson, Armin Roehrl, Conrad Schneiker, Patrick Schoenbach ir Eric Vought.

Keletas žmonių padėjo specifinėse knygos dalyse. Tadayoshi Funaba atsakinėjo mūsų klausimus elektroniniu paštu kol mes supratome kaip veikia Date modulis. Guy Decoux ir Clemens Hintze kantriai atsakinėjo į mūsų klausimus apie Ruby pratęsimus (extensions), o Masaki Suketa padėjo mums suprasti WinOLE modulį.

Nors daugiausiai Ruby dokumentacijos yra japoniškai, angliškų vertimų skaičius didėja. Dažniausiai vertėjais būna Japonijos programuotojai, kurių anglų kalbos žinios iki šiol mus stebina. Tokių autorių yra labai daug, tačiau būtų galima išskirti Goto Kentaro, kuris išvertė daug aukštos kokybės dokumentacijos ir patalpino ją internete.

Galiausiai norime padėkoti Yukihiro "Matz" Matsumoto, Ruby kūrėjui. Mes jam uždavėme begalę klausimų ir sulaukėme begalę kantrių ir detalių atsakymų. Matz sukūrė ne vien Ruby kalbą, bet ir atvirą Ruby bendruomenę, kurioje ši kalba gali klestėti.

Dėkui jums visiems. Domo arigato gozaimasu.

Dave Thomas ir Andy Hunt
The Pragmatic Programmers
http://www.pragmaticprogrammers.com

Žymėjimo susitarimai

Kodo pavyzdžiai bus žymimi šitaip:

class SampleCode
def run
#...
end
end

Tekste Fred#doIt reiškia išskirtinį (instance) klasės Fred metodą doIt, kai tuo tarpu Fred.new (kitose Ruby dokumentacijose galite rasti žymėjimą Fred::new -- tai irgi teisingas klasės metodo žymėjimas, tik mes manome, kad Fred.new lengviau perskaityti) reiškia klasės Fred metodą new. Fred::EOF yra klasės konstanta.

Knygoje yra daug Ruby kodo gabaliukų. Kur tik įmanoma bandėme parodyti kaip jie veikia. Paprastais atvejais veikimo rezultatą parašome šone:

a = 1
b = 2
a + b 3

Kartais mus domina ir priskyrimo sakinių reikšmės:

a = 1 1
b = 2 2
a + b 3

Jei programos vykdymo rezultatai sudėtingesni, mes juos pateikiame po programos kodu:

3.times { puts "Hello!" }

padaro:

Hello!
Hello!
Hello!

Kai kuriuose bibliotekų aprašymuose norėjome parodyti kur programų rezultatuose atsiranda tarpai. Šiuos tarpus matysite kaip "" simbolius.

Komandinės eilutės parametrai rašomi kursyvu. Jei parametras nebūtinas, jis parodomas laužtiniuose skliaustuose

ruby [
flags
]*
[
progname
] [
arguments
]+

Knygos planas

Pagrindinis šios knygos tekstas suskirstytas į keturias, dalis, kurios skiriasi stiliumi ir aprašo skirtingus Ruby kalbos aspektus.

Pirmoje dalyje, Ruby briaunos, rasite Ruby vadovėlį. Ji prasideda skyriumi apie terminologiją ir specifines Ruby sąvokas. Šiame skyriuje aprašoma tiek Ruby sintaksės, kad nebūtų sunku orientuotis kituose skyriuose. Likusi vadovėlio dalis yra visos kalbos apžvalga. Čia mes kalbame apie klases, objektus, tipus, sakinius ir kitus dalykus, kurie sudaro kalbą. Mes netgi baigiame trumpu skyriumi apie tai, ką daryti, jei kažkas neveikia.

Vienas iš išskirtiniausi Ruby bruožų yra jo puikus intergravimasis su aplinka. Apie tai skitykite antrojoje dalyje, Ruby ir aplinka. Čia jūs rasite praktinės informacijos apie tai, kaip paleisti Ruby ir kaip jį naudoti interneto programoms. Išmoksite rašyti grafines programas su Tk ir kaip naudoti Ruby Windows aplinkoje kartu su tokiais nuostabiais dalykais kaip vietinės API naudojimas, COM integracija ir Windows Automatizavimas. Taip pat suprasite kaip nesunku yra integruoti Ruby kodą į savo programavimo projektus kitomis kalbomis.

Trečioji dalis, Kristalizuotas Ruby, savyje turi sudėtingesnę medžiagą. Čia jūs rasite visas smulkmenas apie kalbą, metaklasių modelį, pažymėjimus (tainting), atspindėjimą (reflection), rikiavimus (marshalling).

Ketvirtoji dalis yra Ruby Bibliotekų aprašymai. Ji didelė. Mes aprašome virš 800 metodų, esančių daugiau nei 40 klasių, kurios yra kalbos dalis, ir be to mes skiriame 70 puslapių kitiems moduliams, kurie dažniausiai būna su Ruby.

Tai kaip jūs turėtumėte skaityti šią knygą? Tai priklauso nuo jūsų.

Priklausomai nuo jūsų programavimo patirties lygio, o ypač objektinio programavimo srityje, jums gal reikės perskaityti tik keletą šios knygos skyrių. Štai mūsų rekomendacijos.

Jei esante pradedantysis, pradėkite pirmąja knygos dalimi, kuris kartu yra ir vadovėlis. kai pradėsite rašyti programas, šalia savęs turėkite bibliotekų aprašymą. Apsipraskite su tokiomis klasėmis kaip Array, Hash ir String. Kai patogiai jausitės Ruby aplinkoje, jūs turbūt norėsite pasinagrinėti sudėtingesnes Ruby temas, aprašytas trečiojoje dalyje.

Jeigu jūs jau programuojate Perl, Python arba Smalltalk, siųlome jums persiskaityti įvadą, esantį 2-ame skyriuje. Tada jūs galite arba lėtai perskaityti vadovėlį, arba iš karto kibti į trečiąjį ir ketvirtąjį skyrius.

Ekspertai, guru ir visokie žmonės, kurie masto "Man-nereikia-jokių-pašvinkusių-vadovėlių", gali pradėti tiesiai nuo bibliotekų aprašymo, trumpai ją peržvelgti ir paskui naudoti knygą kaip (ganėtinai gražų) padėklą kavos puodukui.

Aišku nieko blogo jei pradėsite nuo pradžios ir perskaitysite iki galo.

Ir nepamirškite, kad jei susiduriate su problema, kurios negalite išspręsti, pagalba netoli. Žiūrėkite Priedą C.

Ruby.new

Kai mespradėjome rašyti šią knygą, mes turėjome didžiulį planą kip tai darysime (mes tada buvom jaunesni). Mes norėjome aprašyti kalbą iš kito galo -- pradėdami nuo klasių ir objektų ir baigiant smulkiomis sintaksės detalėmis. Pradžioje tai atrodė nebloga idėja. Juk viskas Ruby yra objektai, tad logiška, jei pradžioje kalbėtume apie objektus.

Bent jau mes taip manėme.

Deja, bet taip aprašyti kalbą yra labai sunku. Labai sunku sugalvoti kodo pavyzdžių, jei jūs nieko nežinote apie simbolių eilutes, if sakinius, priskyrimus ir kitas detales. Aprašydami viską nuo didelių objektų mes prieidavome mažas detales, apie kurias tiesiog privalėjome jums papasakoti kad suprastumėte kodo pavyzdžius.

Todėl mes sugalvojome naują didelį planą (mus ne šiaip sau vadina pragmatiškais). Mes vis tiek pradėsime Ruby aprašymą nuo viršaus. Bet prieš tai mes įdėsime trumpą skyrių, kuriame paaiškinsime visas kalbos ypatybes, kuriomis naudosimės kodo pavyzdžiuose. Tai bus lyg ir minivadovėlis, kuris leis jums naudotis visa likusia knyga.

Ruby yra objektinė kalba

Pakartokime tai dar kartą. Ruby yra grynai objektinė kalba. viskas, ką jūs manipuliuojate yra objektas, o šių manipuliacijų rezultatas taip pat yra objektas. Daug kalbų irgi vadina save objektinėmis ir dažnai jų objektiškumo supratimas būna skirtingas.

Taigi prieš pasinerdami į detales, pažiūrėkime, ką mes vadiname objektiškumu.

Kai jūs rašote objektinį kodą, jūs dažniausiai ieškote realaus pasaulio objektų analogų. Šio modeliavimo metu jūs pastebėsite skirtingas daiktų kategorijas, kurias reikia pavaizduoti kodo pagalba. Automatiniame patefone objektas "daina" galėtų būti viena iš tokių kategorijų. Ruby kalboje šias kategorijas atstovauja klasės. Klasė yra būsenos (pavyzdžiui, dainos pavadinimo) ir metodų, kurie naudojasi šia būsena (pavyzdžiui, metodas, kuriuo galima pagroti dainą), rinkinys.

Kai jau turime šias klases, reikia sukurti atskirus jų atvejus (instance). Automatiniame patefone, kuriame apibrėžta klasė Song, turėsime keletą atsikirųjų šios klasės atvejų tokioms dainoms kaip "Ruby Tuesday", "Enveloped in Python", "String of Pearls", "Small talk" ir panašiai. Žodis objektas vartojamas kaip pakaitalas atskirajam klasės atvejui (class instance).

Ruby kalboje objektai yra sukuriami iškviečiant jų konstruktorių, kuris yra specialus klasės metodas. Dažniausiai konstruktorius yra vadinamas new.

song1 = Song.new("Ruby Tuesday")
song2 = Song.new("Enveloped in Python")
# ir taip toliau

Šie objektai yra kilę iš vienos klasės, bet jie turi skirtingas charakteristikas. Pirma, kiekvienas objektas turi unikalų identifikatorių (object id). Antra, galima apibrėžti objekto kintamuosius (instance variable), kurie yra kintamieji, unikalūs visiems klasės atvejams. Pavyzdžiui, kiekviena mūsų daina turbūt turės objekto kintamąjį, kuriame bus saugomas dainos pavadinimas.

Kiekvienoje klasėje galima apibrėžti objekto metodus (instance methods). Kiekvienas metodas yra kodo gabaliukas, kurį galima iškviesti klasės viduje arba (priklauso nuo apribojimų) iš išorės. Objektų metodai gali pasiekti objektų kintamuosius bei objekto būseną.

Metodai iškviečiami nusiunčiant objektui pranešimą. Pranešime yra metodo vardas su metodo parametrų sąrašu (metodų išreiškimo pranešimais idėja kilusi iš Smalltalk). Kai objektas gauna pranešimą, jis peržiūri savo metodų sąrašą, ir jei randa reikiamą, jį įvykdo. Jei metodas nerandamas... mes prie to dar prieisime.

Gal visi šitie metodai ir pranešimai atrodo labai sudėtingai, bet praktikoje viskas labai natūralu. Pažiūrėkime į keletą metodų kvietimų (Prisiminkite, kad už rodykių mes rašome tai, ką gražina metodas)

"gin joint".length 9
"Rick".index("c") 2
-1942.abs 1942
sam.play(aSong) "duh dum, da dum de dum ..."

Čia viskas prieš tašką yra pranešimo gavėjas, o po taško -- metodo pavadinimas. Pirmasis pavyzdys prašo simbolių eilutės gražinti savo ilgį, antrasis prašo kitos simbolių eilutės surasti kur joje yra raidė "c". Trečiajame pavyzdyje prašome skaičiaus gražinti savo absoliučiąją reikšmę, ir galiausiai mes prašome Semo, kad jis pagrotų dainą.

Čia reikėtų paminėti Ruby skirtumą nuo kitų kalbų. Tarkime Java kalboje norėdami rasti absoliučią skaičiaus reikšmę, kviesite atskirą funkciją ir jai perduosite skaičių. Jūs turbūt rašysite:

number = Math.abs(number) // Java kodas

Ruby kalboje absoliučių skaičiaus reikšmių radimas yra pačiuose skaičiuose -- visos su tuo susijusios detalės atliekamos klasėje "skaičius". Tereikia pasiųsti pranešimą abs skaičiaus objektui ir darbas bus atliktas:

number = number.abs

Tas pats yra ir su Ruby objektais: C kalboje jūs rašytumėte strlen(name), o Ruby -- name.length ir taip toliau. Štai ką mes norėjome pasakyti, kai sakėme, kad Ruby yra objektinė kalba.

Šiek tiek paprasto Ruby

Nedaugelis žmonių mėgsta pačioje pradžioje skaityti nuobodžias kalbos sintaksės taisykles. Mes šiek tiek sukčiausime. Šiame skyriuje trumpai apžvelgsime keletą svarbesnių dalykų, kuriuos turite žinoti norėdami rašyti Ruby programas. Vėliau, 18-ame skyriuje, rasite visas detales.

Pradėkime paprasta Ruby programa. Parašysime metodą, kuris grąžina simbolių eilutę, pridėdamas prie jos asmens vardą. Paskui mes keletą kartų iškviesime šį metodą.

def sakykLabanakt(vardas)
rezultatas = "Labanakt, " + vardas
return rezultatas
end

# Laikas miegoti...
puts sakykLabanakt("Jonai")
puts sakykLabanakt("Maryte")

Pradžiai keletas pastabų. Ruby sintaksė yra švari. Nereikia jokių kabliataškių eilučių pabaigoje, jei eilutėje rašote tik po viena sakinį. Ruby komentarai prasideda simboliu # ir tęsiasi iki eilutės pabaigos. Kodo išdėstymas paliekamas jūsų valiai. Eilučių atitraukimas nuo krasto nėra svarbus.

Metodai apibrėžiami žodžiu def, po kurio seka metodo pavadinimas (šiuo atveju sakykLabanakt) ir skliausteliuose esantys metodo parametrai. Ruby nenaudoja figūrinių skliaustų kodo blokų riboms nustatyti, tad turite metodų apibrėžimą baigti žodžiu end. Mūsų metodas labai paprastas. Pirmas sakinys sujungia simbolių eilutę "Labanakt," su parametru vardas ir rezultatą išsaugo vietiniame kintamajame rezultatas. Kita eilutė gražina šį rezultatą metodo kvietėjui. Pažymėtina, kad mes neapibrėžėme kintamojo rezultatas -- jis tiesiog atsirado tuo metu, kai jam priskyrėme reikšmę.

Apsibrėžę metodą, mes jį iškviečiame du kartus. Abiem atvejais mes rezultatą perduodame metodui puts, kuris atvaizduoja simbolių eilutę kartu su naujos eilutės simboliu ekrane.

Labanakt, Jonai
Labanakt, Maryte

Eilutėje puts sakykLabanakt("Jonai") yra du metodų iškvietimai: vienas kviečia metodą sakykLabanakt, o kitas -- puts. Kodėl vieno jų argumentai skliausteliuose, o kito -- ne? Šiuo atveju tai tik skonio reikalas. Visos šios eilutės yra ekvivalenčios:

puts sakykLabanakt "Jonai"
puts sakykLabanakt("Jonai")
puts(sakykLabanakt "Jonai")
puts(sakykLabanakt("Jonai"))

Deja, gyvenimas dažnai nėra toks paprastas, gali būti sunku susigaudyti kokie argumentai tenka kokiems metodams, tad mes rekomenduojame visur, išskyrus pačius paprasčiausius atvejus, vartoti skliaustelius.

Šis pavyzdys taip pat parodo ir Ruby simbolių eilučių objektus. String objektą galima sukurti daugybe būdų, bet labiausiai paplitęs yra per tiesiogines simbolių eilutes (String literals): simbolių sekas tarp viengubų arba dvigubų kabučių. Iš viengubose kabutėse esančių simbolių sekų yra sukuriamas beveik visikai toks pats String objektas.

Su dvigubose kabutėse esančiose simbolių eilutėse yra sudėtingiau. Pirma, Ruby jose ieško galimų pakeitimų -- vietų eilutėse, kurios prasideda simboliu "\" -- ir pakeičia juos dvejetaine išraiška. Dažniausia jų yra "
", kuri yra pakeičiama naujos eilutės simboliu.

puts "Ir labanakt,
Senele"

atspausdina:

Ir labanakt,
Senele

Be to, Ruby interpoliuoja dvigubose kabutėse esančius kintamuosius. Eilutėje išraiška #{ sakinys } pakeičiamas sakinio reikšme. Galime tuo pasinaudoti perrašydami anksčiau apibrėžtą metodą:

def sakykLabanakt(vardas)
rezultatas = "Labanakt, #{vardas}"
return rezultatas
end

Kai Ruby konstruoja simbolių eilutės objektą, jis pasižiūri į dabartinę kintamojo vardas reikšmę, ir ja pakeičia #{vardas}. Išraiškoje #{...} gali būti bet kokio sudėtingumo kodas. Jei išraiška tėra tik paprastas kintamasis, figūrinius skliaustus netgi galite praleisti. Daugiau informacijos apie simbolių eilutes rasite 5 skyriuje.

Galiausiai, mes galime dar labiau supaprastinti mūsų metodą. Ruby metodo reikšmė yra lygi paskutinio jo sakinio reikšmei, tad galime atsikratyti return sakinio.

def sakykLabanakt(vardas)
"Labanakt, #{vardas}"
end

Mes žadėjome, kad šis skyrius bus trumpas, tačiau mes dar turime aptarti Ruby kintamųjų vardus. Mes kol kas neaiškinsime, kas yra klasių ir objektų kintamieji, tačiau aptarsime jų pavadinimų taisykles. Vėlesniuose skyriuose sužinosite kas yra tie objektų kintamieji ir kuo skiriasi nuo klasės kintamųjų.

Ruby naudoja kintamųjų žymėjimo taisykles kintamųjų tipams nustatyti. Pirmasis kintamojo vardo simbolis nurodo kokio tipo kintamasis tai yra. Vietiniai kintamieji, metodų parametrai ir metodų pavadinimai prasideda mažosiomis raidėmis, arba pabraukimo brūkšniu _. Globalieji kintamieji pasideda dolerio ženklu $, o objektų kintamieji -- ženklu @. Klasių kintamieji prasideda dviem "eta" ženklais (@@). Galiausiai, klasių pavadinimai, modulių pavadinimai ir konstantos prasideda didžiosiomis raidėmis. Čia pateikiame kintamųjų vardų pavyzdžius:

Vietiniai Globalieji Objektų Klasių Konstantos ir klasių pavadinimai
name
$debug
@name
@@total
PI

fishAndChips
$CUSTOMER
@point_1
@@symtab
FeetPerMile

x_axis
$_
@X
@@N
String

thx1138
$plan9
@_
@@x_pos
MyClass

_26
$Global
@plan9
@@SINGLE
Jazz_Song

Po pirmojo kintamojo vardo simbolio gali būti bet kokia raidžių, skaičių arba apatinių brūkšnių kombinacija (su išlyga kad simbolis, einantis tuoj po @ negali būti skaitmuo).

Paprasti ir asociatyvūs masyvai

Ruby kalboje paprasti ir asociatyvūs masyvai yra indeksuotos aibės. Abiejuose juose yra saugoma objektų aibė, kurią galima pasiekti naudojantis raktu. Paprastuose masyvuose raktu gali būti tik skaičius, o asociatyviuose -- bet koks objektas. Tiek paprasti, tiek asociatyvūs masyvai auga dinamiškai, priklausomai nuo elementų skaičiaus. Naudoti paprastuosius masyvus yra efektyviau, bet asociatyvieji suteikia daugiau lankstumo. Bet kuris masyvas gali saugoti bet kokio tipo objektus: vienu metu galite turėti masyvą, kuriame saugomas skaičius, simbolių eilutė ir trupmena.

Sukurti paprastąjį masyvą galima naudojant laužtinius skliaustus. Kai jau turite masyvą, jo elementus galima pasiekti tarp laužtinių skliaustų įrašant raktą:

a = [ 1, 'cat', 3.14 ] # paprastasis masyvas su trims elementais

# pirmasis elementas

a[0] » 1

# nustatome trečiąjį elementą

a[2] = nil

# išvedame visą masyvą

a » [1, "cat", nil]



Sukurti tuščią masyvą galima arba parašant tuščius laužtinius skliaustus, arba naudojantis masyvo objekto konstruktoriumi Array.new

tuscias1 = []
tuscias2 = Array.new



Kartais gali būti sunku sukurti masyvą iš žodžių, nes reikia naudoti daug kablelių ir kabučių. Gerai, kad tam yra trumpesnis kelias -- %w daro tai ko mums reikia.

a = %w{ ant bee cat dog elk }
a[0] » "ant"
a[3] » "dog"

Ruby asociatyvūs masyvai yra panašūs į paprastuosius. Jiems vietoje laužtinių skliaustų naudojame figūrinius ir turime nurodyti po du objektus -- vieną raktinį, o kitą reikšminį.

Tarkime, kad norime muzikos instrumentams nurodyti jų tipus:

instSkyriai = {
'violoncele' => 'styginiai',
'klarnetas' => 'puciamieji',
'bugnas' => 'perkusiniai',
'obojus' => 'puciamieji',
'trimitas' => 'puciamieji',
'smuikas' => 'styginiai'
}

Asociatyvaus masyvo elementus galima pasiekti taip pat kaip ir paprastojo masyvo elementus -- naudojant laužtinius skliaustus.

instSkyriai['obojus'] 'puciamieji'

instSkyriai['violoncele'] 'styginiai'

instSkyriai['lyra'] nil

Paskutinis pavyzdys rodo, kad asociatyvusis masyvas grąžina nil, jei savyje neturi tokio rakto, kuriuo bandoma pasiekti elementą. Dažnai tai labai patogu, nes nil sąlygos sakiniuose reiškia false. Kartais jums reikės pakeisti šia masyvo savybę. Tarkime, jums reikia naudojantis masyvu suskaičiuoti kiek kartų pasikartoja kiekvienas raktas. Tokiu atveju jums būtų patogu kad masyvas pagal nutylėjimą grąžintų nulį. Tai nesunku nurodyti sukuriant masyvą.

histogram = Hash.new(0)

histogram['key1'] » 0

histogram['key1'] = histogram['key1'] + 1

histogram['key1'] » 1

Masyvai turi daug naudingų metodų. Juos rasite kituose skyriuose.

Valdymo struktūros

Ruby turi visas įprastas valdymo struktūras, tokias kaip if sakinys ar while ciklas. Java, C ir Perl programuotojams gal būt atrodys keista, kad nėra figūrinių skliaustų. Vietoj jų Ruby kodo bloko pabaigai žymėti naudoja žodį end.

if count > 10
puts "Try again"
elsif tries == 3
puts "You lose"
else
puts "Enter a number"
end

Panašiai su end baigiami ir while ciklai.

while weight < 100 and numPallets <= 30
pallet = nextPallet()
weight += pallet.weight
numPallets += 1
end

Ruby sakinių modifikatoriai yra labai patogios santrumpos, jei if ar while sakinių kūną sudaro tik vienas sakinys. Paprasčiausiai tereikia parašyti sakinį ir jo gale pridėti if arba while bei sąlygą. Pavyzdžiui, štai paprastas if sakinys:

if radiation > 3000
puts "Danger, Will Robinson"
end

Čia tas pats sakinys, perrašytas naudojantis sakinių modifikatoriumi:

puts "Danger, Will Robinson" if radiation > 3000

Panašiai while ciklas

while square < 1000
square = square*square
end

tampa žymiai trumpesniu

square = square*square while square < 1000

Sakinių modifikatoriai turi būti pažįstami Perl programuotojams

Paprastosios išraiškos

Dauguma Ruby kintamųjų tipų yra įprasti visiems programuotojams. Dauguma kalbų turi simbolių eilutes, sveikuosius ir trupmeninius skaičius, masyvus ir taip toliau. Iki Ruby pasirodymo paprastosios išraiškos (regular expressions) egzistavo tik scenarinėse kalbose kaip Perl, Python ir awk. Ir gaila, nes paprastosios išraiškos, nors ir kartais sunkiai perskaitomos, yra labai svarbus įrankis.

Apie paprastąsias išraiškas parašytos ištisos knygos, tad mes net nebandysime visko apžvelgti viename trumpame skyriuje. Vietoje to mes tik pažvelgsime į keletą paprastų jų naudojimo pavyzdžių.

Paprastoji išraiška tėra būdas norodyti simbolių šabloną simbolių eilutėje. Ruby kalboje paprastosios išraiškos dažniausiai rašomos tarp dviejų pasvirusių brūkšnių /šablonas/. Ir aišku, kadangi čia Ruby, paprastosios išraiškos yra objektas, todėl gali būti manipuliuojamos kaip objektai.

Tarkime norime parašyti šabloną, kuris aptiktų simbolių eilutėje žodžius "Perl" arba "Python". Tam naudosime šią paprastąją išraišką:

/Perl|Python/

Pasvirę brūkšniai nurodo šablono ribas. Pats šablonas susideda iš dviejų dalykų, kuriuos bandome rasti, atskirtų simboliu `|'. Paprastosiose išraiškose, kaip ir matematikoje, galima naudotis skliaustais, tad šabloną galima perrašyti taip:

/P(erl|ython)/

Šablonuose galima nurodyti ir pasikartojimą. /ab+c/ ieško eilutės, kurioje yra raidė "a", po kurios seka viena ar daugiau raidžių "b", po kurių yra raidė "c". Jei pakeisime pliusą į žvaigždutę, /ab*c/ ieškos eilutės, kurioje yra raidė "a", po jos gali būti raidė "b" (bet gali ir nebūti), o po to -- raidė "c".

Šablone galima nurodyti ir visas simbolių grupes. Vienos populiariausių simbolių grupių yra "\s", kuri atitinka bet kokį "baltą" simbolį (tarpą, tabuliatoriaus, naujos eilutės simbolį ir panašiai), "\d", kuri atitinka bet kurį skaitmenį ir "\w", kuri atitinka bet kokį simbolį, kuris būna paprastame žodyje. Simbolis "." (taškas) atitinka bet kokį simbolį.

Visa tai sudėjus kartu galima gauti naudingų paprastųjų išraiškų:

/\d\d:\d\d:\d\d/ # laikas, tokiame formate kaip 12:34:56
/Perl.*Python/ # "Perl", nulis ar daugiau simbolių ir po to "Python"
/Perl\s+Python/ # "Perl", vienas ar daugiau tarpų ir po to "Python"
/Ruby (Perl|Python)/ # "Ruby", tarpas ir po to "Perl" arba "Python"

Kai jau sukuriate šabloną, reikia jį panaudoti. Taikant paprastąsias išraiškas, naudojame operatorių "=~". Jei eilutėje randama seka, atitinkanti šabloną, =~ grąžina sekos pradžios vietą eilutėje, kitu atveju jis grąžina nil. Tai reiškia, kad paprastąsias išraiškas galite naudoti if ir while sakiniuose. Pavyzdžiui šis kodo fragmentas parašo sakinį tik tuo atveju, jei eilutėje yra paminėta "Perl" arba "Python".

if line =~ /Perl|Python/
puts "Paminėta kalba: #{line}"
end



Dalis eilutės, kuri atitinka šabloną, gali būti pakeista kitu tekstu naudojantis Ruby pakeitimo funkcijomis

line.sub(/Perl/, 'Ruby') # pakeis pirmą sutiktą 'Perl' tekstu 'Ruby'
line.gsub(/Python/, 'Ruby') # pakeis kiekvieną 'Python' tekstu 'Ruby'



Šioje knygoje dar daugelyje vietų aptarsime paprastąsias išraiškas



Blokai ir kartotojai

Šiame skyrelyje trumpai aprašysime vieną didžiausių Ruby pliusų. Mes apžvelgsime kodo blokus: kodo gabaliukus, kuriuos galite perduoti metodams, lyg jie būtų metodų parametrai. Tai labai galingas įrankis. Jūs galite juos naudoti kaip callback funkcijas (bet jie paprastesni nei Javos anoniminės vidinės klasės), kodo gabaliukų perdavimui (bet Ruby blokai yra lankstesni nei C funkcijų rodyklės), bei kartotojams.

Kodo blokai yra paprasčiausi kodo gabaliukai tarp figūrinių skliaustų arba tarp do...end.

{ puts "Labas" } # čia kodo blokas

do #
club.enroll(person) # čia irgi kodo blokas
person.socialize #
end #

Kai jau sukūrėte kodo bloką, galite jį iškvietimo metu priskirti metodui. Tada metodas gali iškviesti bloką vieną ar kelis kartus naudodamasis Ruby yield sakiniu. Kitas pavyzdys kaip tik tai ir demonstruoja. Mes apibrėžiame metodą, kuris du kartus iškviečia yield. Tada mes iškviečiame šį metodą, po metodo pavadinimo (ir po metodo parametrų) perduodami jam bloką. Kai kurie žmonės įpratę apie kodo blokų perdavimą metodams galvoti kaip apie bloko perdavimą kaip metodo parametrą. Iš tiesų, kartais taip viskas ir vyksta, bet tai tik dalis pasakojimo. Būtų geriau, jei galvotumėte apie kodo blokus ir metodus kaip kartu egzistuojančias funkcijas, kurios viena kitai perduoda valdymą.

def callBlock
yield
yield
end

callBlock { puts "In the block" }

atspausdina:

In the block
In the block

Kaip matote, kodas, esantis bloke (puts "In the block") yra įvykdomas du kartus, nes buvo du yield sakiniai.

yield galima perduoti ir argumentus: jie bus perduoti kodo blokui. Kodo bloke gaunamų argumentų sąrašą reikia surašyti tarp vertikalių brūkšnių ("|"):

def callBlock
yield ,
end

callBlock { |, | ... }

Kodo blokai dažnai naudojami Ruby bibliotekose, nes jais lengva naudoti kaip kartotojus -- metodus, kurie paeiliui grąžina elementus iš kokios nors aibės (tarkim, masyvo):

a = %w( ant bee cat dog elk ) # sukuria masyvą
a.each { |animal| puts animal } # pakartoja kiekvienam elementui

atspausdina:

ant
bee
cat
dog
elk

Kaip galėtume parašyti Array klasės each kartotoją? each kartotojas kiekvienam masyvo elementui iškviečia yield. Pseudo-kodu tai galėtų atrodyti taip:

# klasėje Array...
def each
for each element
yield(element)
end
end

Tada galima pereiti per visus masyvo elementus naudojantis each metodu ir perduodant kodo bloką. Šis kodo blokas bus iškviestas kiekvienam masyvo elementui.

[ 'cat', 'dog', 'horse' ].each do |animal|
print animal, " -- "
end

atspausdina:

cat -- dog -- horse --

Dauguma ciklo sakinių Java ar C kalbose yra pačios kalbos dalis, tuo tarpu Ruby jie dažniausiai tėra tik metodų iškvietimai, jiems perduodant kodo blokus.

5.times { print "*" }
3.upto(6) {|i| print i }
('a'..'e').each {|char| print char }

atspausdina:

*****3456abcde

Čia mes liepiame skaičiui 5 iškviesti bloką penkis kartus, tada prašome skaičiaus 3 iškviesti bloką jam perduodant vis didesnes reišmes iki kol jos pasieks šešis. Galiausiai, simbolių aibė, susidedanti iš simbolių nuo 'a' iki 'e', iškviečia bloką, naudodamasi metodu each.

Skaitymas ir rašymas

Ruby turi didelę Įvedimo/Išvedimo (IO) biblioteką, tačiau šios knygos pavyzdžiuose dažniausiai apsiribosime paprastomis funkcijomis. Mes jau sutikome du metodus: puts atspausdina savo argumentus, po kiekvieno įdėdama naują eilutę, o print irgi atspausdina savo argumentus, bet be naujos eilutės. Abu šie metodai gali rašyti į bet kurį IO objektą, bet pagal nutylėjimą jie rašo į konsolę.

Kitas metodas, kuriuo dažnai naudosimės, yra printf, kuris atspausdina savo argumentus, naudodamasi formatavimo eilute (šis metodas veikia taip pat kaip printf metodai C arba Perl kalbose).

printf "Skaičius: %5.2f, Eilutė: %s", 1.23, "labas"

atspausdina:

Skaičius: 1.23, Eilutė: labas

Šiame pavyzdyje formatavimo eilutė "Skaičius: %5.2f, Eilutė: %s" liepia printf įstatyti trupmeninį skaičių (kurio ilgis daugiausiai gali būti 5 simboliai, su dviem simboliais po kablelio) ir simbolių eilutę.

Duomenų įvedimo būdų yra daug, bet dažniausiai naudojamas yra metodas gets, kuris grąžina kitą eilutę iš standartinio įvedimo šaltino (stdin):

line = gets
print line

gets metodas turi ir šalutinių poveikių: jis perskaitytą eilutę ne tik grąžina, bet ir išsuagoja globaliame kintamajame $_. Tai specialus kintamasis, kuris pagal nutylėjim naudojamas daugelyje metodų. Jei iškviesite print be parametrų, jis atspausdins $_ turinį. jei rašote if ar while sakinius tik su paprastąja išraiška, ši išraiška bus patikrinta su $_. Nors kai kurie mano kad tai atgrasus barbarizmas, šios santrumpos leidžia rašyti trumpas programas. Pavyzdžiui ši programa spausdina visas eilutes iš įvesties šaltinio, kuriose yra žodis "Ruby".

while gets # išsaugo eilutę $_
if /Ruby/ # patikrina su $_
print # spausdina $_
end
end

Visa tai galima perrašyti "Ruby būdu", naudojantis kartotoju:

ARGF.each { |line| print line if line =~ /Ruby/ }

Šis pavyzdys rodo objektą ARGF, kuris nurodo įvesties šaltinį.

Kas toliau?

Štai ir viskas. Mes pabaigėme trumpą Ruby apžvalgą. Mes trumpai apžvelgėme objektus, metodus, simbolių eilutes, kodo blokus, paprastąsias išraiškas, kontrolės struktūras ir kartotojus. Tikimės, kad šio skyriaus pakako trumpam susipažinimui su Ruby

Laikas keliauti toliau, į aukštesnį lygį. Toliau mes apžvelgsime klases ir objektus -- Ruby kalboje jie yra aukščiausio lygio struktūros, bet kartu ir patys svarbiausi kalbos elementai.

©opyleft moxliukas. Versta iš www.rubycentral.com

Griežtai draudžiama Straipsniai.lt paskelbtą informaciją panaudoti kitose interneto svetainėse, tradicinėse žiniasklaidos priemonėse ar kitur arba platinti mūsų medžiagą kuriuo nors pavidalu be sutikimo. Cituojant būtina aiški nuoroda į Straipsniai.lt kaip informacijos šaltinį.

Atsitiktinės gairės:    Kazimiera Prunskienė (13)    Žuvys (7)    Išpažintis (16)    Breakdance (4)    Saugus internetas (11)    Žala sveikatai (16)    Lietuvoje (5)    Lotynų kalba (11)    Žvejyba (30)    Dvarai (36)    Airija (9)    Šachmatai (11)    Gatvės šokiai (5)    Sel (10)    Stilius (86)    Interneto tinklai (4)    Lobių ieškotojai (3)    Vadyba (89)    Atsiprašymas (3)    Šv. Valentino diena (11)    Technologijos (1819)    Bibilija (10)    Turizmas (151)    Filatelija (11)    Gyvūnai (174)    Vartotojai (29)    Kinas (193)    Kovo 11 (4)    Makaronai (2)    Literatūra (239)    Šokiai (56)    Metalinės muzikos grupės (8)    Šventasis Antanas (2)    Žemgrobiai (6)    Teatrai (21)    Garso sistemos (15)    Įdomybės (87)    Geografija (22)    Mada (4)    Firmos (12)    Pelės (5)    Tamplieriai (7)    Interneto dienoraščiai (2)    TELE-2 (7)    Aerobika (3)    Toyota (2)    Chiromantija (3)    Vandenis (7)    Seimo rinkimai 2004 (3)    Kompiuterinis piratavimas (43)
1. LG paleido revoliucinį portalą programų kūrėjams
2. Užsakymai iš JAV paskatino "e-sense" investuoti į trimatę kompiuterinę grafiką
3. Kas yra optimizavimas paieškos sistemoms?
4. Kaip aplenkti savo virtualius konkurentus?
5. Projektas ALGO
6. Free Paskalis
7. Programuojančių Turbo Paskaliu tinklalapis
8. JavaScript atspindžiai
9. Kaip lankytoją nukreipti į kitą www puslapį?
10. Vaizdi rašysena
   
 
     
Prisijunk prie gerbėjų rato Google Plus! Mūsų jau 500. Skelbk informaciją, dalinkis naujienomis. Būk matomas!