Ruby pro začátečníky - 2 (komentáře, aritmetika, proměnné)

16. 2. 2006 | Jaromír Hradílek | Programování | 10722×

V dnešním díle o programování v jazyce Ruby se naučíme psát komentáře, provádět základní aritmetické operace a pracovat s lokálními a globálními proměnnými a konstantami.

Obsah

1. Komentáře
2. irb jako kalkulátor
  2.1 Základní aritmetické operace
  2.2 Modul
3. Proměnné
  3.1 Konstanty
  3.2 Lokální proměnné
  3.3 Globální proměnné
4. Přiřazení
5. Příště

Poznámka: ve většině příkladů budu k demonstraci jednotlivých příkazů a konstrukcí využívat interaktivního interpretru irb, jehož spuštění a základní ovládání jsme si vysvětlili v minulém díle (Ruby pro začátečníky - 1). Ukázky kódu tedy obsahují výstupy právě z tohoto prostředí.

1. Komentáře

Jednou z velmi důležitých, avšak programátory často opomíjených součástí zdrojového kódu programu, jsou komentáře. Komentář je část kódu, která se neprovádí (interpretr ji přeskočí, v případě kompilovaných jazyků je ignorována překladačem). A k čemu slouží?

Účelem komentářů je zpřehlednit zdrojový kód programu. Je proto třeba nakládat s nimi opatrně a najít správnou míru: příliš mnoho komentářů naopak čitelnost kódu zhoršuje. Správný komentář by měl být stručný a jasný a měl by dokumentovat, co konkrétní část dělá, nikoli jak to dělá. Proč?

Představte si, že programátor stojí před úkolem seřadit posloupnost celých čísel vzestupně. Existuje mnoho řadících algoritmů a ne všechny jsou stejně rychlé nebo náročné na paměť počítače. Časem programátor zjistí, že jím zvolený způsob řazení je příliš pomalý a rozhodne se jej tedy přepsat. Ovšem (a to se stává opravdu často) zapomene už přepsat komentář. Ten se tak stává pro případného čtenáře naopak matoucím a nejspíš napáchá víc škody, než užitku.

Ruby rozeznává dva druhy komentářů, přičemž nejčastěji používaným je klasický jednořádkový komentář. Ten je zahájen znakem # (mřížka) a říká, že vše, co za tímto znakem následuje až do konce řádku, je komentář a má být interpretrem ignorováno:

irb(main):001:0> # Toto je komentar.
irb(main):002:0* # Vse za znakem '#' je interpretrem ignorovano:
irb(main):003:0* # puts "Ahoj, svete!"

Komentář pochopitelně nemusí začínat na začátku řádku a mohou mu bezprostředně předcházet příkazy:

irb(main):004:0* puts "Ahoj, svete!" # vypise pozdrav
Ahoj, svete!
=> nil
irb(main):005:0>

Druhým druhem komentářů je takzvaný blok. Ten začíná příkazem =begin a končí =end. Cokoli mezi těmito klíčovými slovy je bráno jako komentář:

irb(main):005:0> =begin
irb(main):006:0= Toto je blokovy komentar, presahujici libovolny pocet .
irb(main):007:0= radku. Obzvlaste se hodi pro rozsahlejsi sdeleni, jakymi
irb(main):008:0= jsou kuprikladu informace o autorskych pravech nebo
irb(main):009:0= licenci, pod kterou je kod distribuovan.
irb(main):010:0= =end
irb(main):011:0>

2. irb jako kalkulátor

Krom toho, že si v něm můžeme nanečisto vyzkoušet chování některých našich programových konstrukcí, můžeme irb použít i jako šikovný kalkulátor (bohužel ne vždy je totiž po ruce bc).

2.1 Základní aritmetické operace

Binární aritmetické operátory dostupné v Ruby shrnuje následující tabulka:

Operátor:	Význam:
+	Součet
-	Rozdíl
*	Součin
/	Podíl (celočíselný i reálný, viz dále)
%	Modulo
**	Mocnina

První tři jsou nejspíše jasné a fungují přesně tak, jak bychom intuitivně očekávali:

irb(main):011:0> 27 + 15
=> 42
irb(main):012:0> 7 - 20
=> -13
irb(main):013:0> 3 * 6
=> 18
irb(main):014:0>

S dělením je to už trošku složitější, neboť záleží na tom, s jakým typem hodnot pracujeme. Výsledkem podílu dvou celých čísel je opět celé číslo:

irb(main):014:0> 7 / 3
=> 2
irb(main):015:0>

Celá čísla jsou však ve skutečném životě poměrně vzácný úkaz. Jelikož je Ruby (jak uvidíme později) dynamicky typovaný jazyk, chová se operátor dělení podle hodnot, jež jsou mu zadány:

irb(main):015:0> 7.0 / 3
=> 2.33333333333333
irb(main):016:0>

Zapsáním čísla 7 jako 7.0 (k oddělení desetinných míst se používá tečka) explicitně říkáme, že chceme pracovat s reálnými čísly. Ačkoli je tento přístup jednoduchý, z vlastní zkušenosti vím, že se toto chování může stát zdrojem velice nepříjemných chyb. Buďte proto prosím při psaní vlastních programů obezřetní.

Operátor % (procento) nám dává zbytek po celočíselném dělení:

irb(main):016:0> 7 % 3
=> 1
irb(main):017:0>

A konečně pomocí operátoru ** (dvě hvězdičky) můžeme čísla umocňovat:

irb(main):017:0> 2**4
=> 16
irb(main):018:0>

Nyní nám už nic nebrání směle se pustit i do složitějších matematických konstrukcí. Na jednotlivé operace jsou přitom uplatňována běžná pravidla známá z matematiky (tj. že násobení má přednost před sčítáním a podobně):

irb(main):018:0> 2 + 2 * 2
=> 6
irb(main):019:0>

Pro jednoznačné vynucení priorit nám také nic nebrání v použití závorek:

irb(main):019:0> 1.7 * (3.0 + (12.0 - 7.0) / 4.0)
=> 7.225
irb(main):020:0>

Závorky usnadňují čitelnost zápisu i tam, kde nejsou bezpodmínečně nutné, a doporučuji je proto používat.

2.2 Modul Math

Když už jsme u matematických operací, standardní součástí distribuce ruby je i modul Math, který obsahuje některé užitečné matematické funkce. Jejich kompletní výčet a popis naleznete v oficiální dokumentaci, ty asi nejpoužívanější shrnuje následující tabulka:

Funkce:	Vysvětlení:
Math.sqrt(n)	Vrátí nezápornou druhou odmocninu z čísla n. Je-li n záporné číslo, vyvolá výjimku ArgError.
Math.log(n)	Vrátí přirozený logaritmus n.
Math.log10(n)	Vrátí logaritmus n při základu 10.
Math.sin(n)	Vrátí sinus n, zadaného v radiánech.
Math.cos(n)	Vrátí kosinus n, zadaného v radiánech.
Math.tan(n)	Vrátí tangens n, zadaného v radiánech.

O výjimkách si budeme povídat v některém z dalších dílů.

3. Proměnné

Proměnné jsou jedním ze stavebních kamenů imperativních programovacích jazyků a pravděpodobně je již znáte z algebry. Oproti jazykům, jakými jsou C++ nebo Pascal, není třeba proměnné deklarovat, ani explicitně uvádět jejich typ. Proměnná vzniká v okamžiku, kdy je jí přiřazena nějaká hodnota:

irb(main):020:0> PI = 3.14
=> 3.14
irb(main):021:0>

Takto jsme vytvořili proměnnou (resp. konstantu, viz dále) PI, která obsahuje reálnou hodnotu 3.14. Stejně jako v matematice ji nyní můžeme použít:

irb(main):021:0> PI * 5**2
=> 78.5
irb(main):022:0>

Je však třeba si dát pozor na to, aby proměnná skutečně existovala, použití neexistující proměnné (takové, jíž nebyla předtím přiřazena žádná hodnota) vede k chybě:

irb(main):022:0> 2 * PI * r
NameError: undefined local variable or method `r' for main:Object
        from (irb):22
        from :0
irb(main):023:0>

Jak už jsem řekl, proměnné nejsou předem typovány. Jejich typ se mění s aktuální hodnotou:

irb(main):023:0> a = 42
=> 42
irb(main):024:0> a.class  # tohoto se nelekejte 
=> Fixnum
irb(main):025:0> a = 2.75
=> 2.75
irb(main):026:0> a.class
=> Float
irb(main):027:0> a = 'Ahojky!'
=> "Ahojky!"
irb(main):028:0> a.class
=> String
irb(main):029:0>

Jak náš program poroste, budeme v něm používat čím dál více proměnných. Stejně jako komentáře, i vhodný název proměnných přispívá k lepší čitelnosti kódu:

a = 2 * b * c

Tento zápis je sice srozumitelný, ale neříká nám nic o operaci, kterou provádíme. Vhodně pojmenované proměnné dokumentují operaci samy:

obvodKruhu = 2 * PI * polomer

Lepší, že? Nabízí se otázka, jak zacházet s víceslovnými názvy proměnných. Běžně se používají dva druhy zápisu:

viceslovnyNazev
viceslovny_nazev

Je na vás, který způsob vám vyhovuje lépe. Je však dobré si osvojit jeden a důsledně se ho držet, i to totiž přispívá k lepší srozumitelnosti.

3.1 Konstanty

Už jsem trochu nakousl, že naše PI je ve skutečnosti konstanta. Jaký je rozdíl mezi klasickou proměnnou a konstantou? Vysvětlení je nasnadě: konstanta nabývá jedné hodnoty při svém vytvoření a ta se již dále nemění, ba jakákoli změna její hodnoty je nežádoucí. Příkladem budiž naše PI. To má pevnou hodnotu 3.14, jakákoli jiná hodnota by v našich dalších výpočtech vedla k chybám.

Z pohledu jazyka Ruby spočívá rozdíl mezi konstantami a klasickými proměnnými v jejich názvu:

• název proměnné začíná znaky a-z nebo _ (podtržítko)
• název konstanty začíná znaky A-Z

Takto docílíme nejen výrazného optického rozdílu, ale i odlišného přístupu interpretru:

irb(main):029:0> a = 3.14  # promenna
=> 3.14
irb(main):030:0> a = 3  
=> 3
irb(main):031:0> PI = 3.14  # konstanta
=> 3.14
irb(main):032:0> PI = 3
(irb):32: warning: already initialized constant PI
=> 3
irb(main):033:0>

Nová hodnota sice byla konstantě přiřazena, ale změnu provázelo varování, což nám později při ladění programu ulehčí hledání, kde že se stala chyba.

3.2 Lokální proměnné

To, co jsme dosud tiše používali, jsou ve skutečnosti lokální proměnné. To neznamená nic jiného, než že existují jen v rámci určité funkce nebo třídy, jak ukazuje následující příklad:

irb(main):033:0> def pozdravuj
irb(main):034:1>   pozdrav = 'Nazdarek!'
irb(main):035:1>   puts pozdrav
irb(main):036:1> end
=> nil
irb(main):037:0> pozdrav = 'Ahoj.'
=> "Ahoj."
irb(main):038:0> puts pozdrav
Ahoj.
=> nil
irb(main):039:0> pozdravuj
Nazdarek!
=> nil
irb(main):040:0> puts pozdrav
Ahoj.
=> nil
irb(main):041:0>

Detaily definice funkce se zatím nezabývejme, důležité je, že vidíme na dvou místech přiřazení různých hodnot do proměnné pozdrav (dle číslování irb na řádcích 33 až 36). Poté postupně vypisujeme její hodnotu (řádky 38 až 40). Jak vidíme, proměnné pozdrav existují lokálně na dvou místech: jedna v rámci hlavního programu a druhá ve funkci pozdravuj a jsou na sobě nezávislé.

Pokud jste z výše uvedeného příkladu zmatení, nedělejte si starosti a klidně jej pro tuto chvíli pusťte z hlavy. Více pochopíte, až přejdeme k definicím funkcí.

Co je však třeba si pamatovat, je, že lokální proměnné začínají malým písmenem a-z nebo znakem _ (podtržítko).

3.3 Globální proměnné

Oproti lokálním proměnným existuje v programu vždy jen jedna globální proměnná určitého jména. Globální proměnné začínají znakem $:

irb(main):041:0> def pozdravuj
irb(main):042:1>   $pozdrav = 'Nazdarek!'
irb(main):043:1>   puts $pozdrav
irb(main):044:1> end
=> nil
irb(main):045:0> $pozdrav = 'Ahoj.'
=> "Ahoj."
irb(main):046:0> puts $pozdrav
Ahoj.
=> nil
irb(main):047:0> pozdravuj
Nazdarek!
=> nil
irb(main):048:0> puts $pozdrav
Nazdarek!
=> nil
irb(main):049:0>

Mírně modifikovaná ukázka z předchozí kapitolky ukazuje chování globálních proměnných. Proměnné $pozdrav je nejprve přiřazena hodnota 'Ahoj.' a následně pro kontrolu vypsána. Pak je zavolána funkce pozdravuj, v níž je hodnota proměnné změněna na 'Nazdarek!'. Na řádku 39 je již vypsána změněná hodnota.

Použití globálních proměnných se možná může zdát snadné a logické (vždyť přece chci mít svou uloženou hodnotu přístupnou odevšad, ne?), nicméně je také velmi nebezpečné, a proto se doporučuje s nimi šetřit, ba nejlépe nepoužívat je vůbec. Je až příliš snadné globální proměnnou nechtěně přepsat a zapříčinit tak chybné chování programu. Odhalit výskyt chyby v rozsáhlém zdrojovém kódu složité aplikace může zabrat hodiny nebo dny, které bychom místo toho mohli věnovat tvůrčí činnosti. Jak uvidíme dále, předávání hodnot pomocí parametrů je nejen elegantnější, ale usnadňuje i lokalizaci případných chyb.

4. Přiřazení

Zatím jsme používali jen jednoduché intuitivní přiřazení:

irb(main):049:0> polomer = 5.4
=> 5.4
irb(main):050:0>

Jistě jste už pochopili, že na levé straně rovnítka je název proměnné, na pravé straně pak samotná hodnota. Krom prostých číselných hodnot je však možné přiřazovat i výsledky matematických operací:

irb(main):050:0> obsah = 3.14 * 5.4**2
=> 91.5624
irb(main):051:0>

Je také možné na levé straně použít jiné proměnné:

irb(main):051:0> obsah = PI * polomer**2
=> 91.5624
irb(main):052:0>

Můžeme definovat i několik proměnných naráz:

irb(main):052:0> a = b = c = 4
=> 4
irb(main):053:0> a
=> 4
irb(main):054:0> b
=> 4
irb(main):055:0> c
=> 4
irb(main):056:0>

Lze dokonce přiřadit na jednom řádku několika proměnným různé hodnoty:

irb(main):056:0> a, b = 5, 2.3
=> [5, 2.3]
irb(main):057:0> a
=> 5
irb(main):058:0> b
=> 2.3
irb(main):059:0>

Dost často se také stává, že na levé straně stojí shodná proměnná:

irb(main):059:0> pocet = 1
=> 1
irb(main):060:0> pocet = pocet + 1
=> 2
irb(main):061:0>

Matematici teď určitě kroutí nevěřícně hlavou. Musíte si však uvědomit, že rovnítko zde plní funkci přiřazení, nikoli porovnání (k tomu slouží operátor ==, ale o tom až později).

Jelikož změna hodnoty proměnné v závislosti na původní hodnotě je poměrně častým úkolem, nabízí Ruby zkrácení ve formě operátorů následujících operátorů:

irb(main):061:0> a = 9
=> 9
irb(main):062:0> a += 1  # ekvivalentni k: a = a + 1
=> 10
irb(main):063:0> a -= 3  # ekvivalentni k: a = a - 3
=> 7
irb(main):064:0> a *= 4  # ekvivalentni k: a = a * 4
=> 28
irb(main):065:0> a /= 2  # ekvivalentni k: a = a / 2
=> 14
irb(main):066:0> a %= 9  # ekvivalentni k: a = a % 9
=> 5
irb(main):067:0>

5. Příště

V příštím díle se podíváme blíže na jednotlivé datové typy a dostane se i na práci s řetězci, poli a hashi.

       

Komentáře

Diskuse byla administrátory uzamčena

[Michal Vyskočil]

Je to sice seriál pro začítečníky, ale Ruby je objektový jazyk a myslím, že by bylo vhodné zdůraznit, že proměnné i konstanty jsou ve skutečnosti objekty, což je stejně vidět v kódu. Já tyhle nuance z počátku také moc nechápal. Holt jsem začínal na Basicu, assembleru a Pascalu a OOP jsem se učil na ObjectPascalu, který byl v Tubo Pascalu 7 a potom v C++.

Existuje v Ruby obdoba Pythonovského dir? Ten vrací seznam všech metod a atributu daného objektu, anebo jména v současném jmenném prostoru.

>>> dir(4)
['__abs__', '__add__', '__and__', '__class__', '__cmp__', ...
'__truediv__', '__xor__']
>>> dir()
['__builtins__', '__doc__', '__name__']

[Kyosuke]

Metoda "methods"? Ovšem ta vypisuje všechny metody včetně zděděných.

[Jaromír Hradílek]

...Ruby je objektový jazyk a myslím, že by bylo vhodné zdůraznit, že proměnné i konstanty jsou ve skutečnosti objekty...

Máte samozřejmě pravdu a až dojde na objekty (snad ) neopomenu toto uvést. Mám však zkušenost, že je lepší začátečníky z prvu moc nestrašit neznámými pojmy. Ze stejného důvodu například hovořím o fib v prvním díle jako o funkci, ačkoli dle striktní terminologie Ruby je to ve skutečnosti metoda.

Chápu, že ne každý se mnou bude v tomto souhlasit.

[mivrap]

Když se pokouší psát výukový materiál člověk bez zkušeností s výukou, tak to většinou dopadá špatně. Pokud je to navíc dvacetiletý studentík, pak to dopadá ještě hůře. A to je právě případ toho tvého výplodu nahoře.

Jestli chceš pojmout výuku objektového jazyka tak, jak jsi předvedl v dnešním díle, tak se na ten díl kde nakousneš objekty snad ani netěším.

Ale na druhé straně mi to nevadí. Čím více pokleslých výukových materiálů, tím více špatných programátorů a tím lépe pro kvalitní programátory.

[Botanicus]

Fajn, prudit umis, tak neco proboha napis sam! Navic o ruby toho v cestine moc napsano nebylo...zkus! J

[mikrom]

Serial som uz precital a pomohol mi zacat s Ruby - DOPORUCUJEM !

 

[jan molic]

osobne pouzivam k vylistovani atributu objektu

p objekt

nebo vyuziji yaml

require 'yaml'
puts objekt.to_yaml

co se tyce vylistovani metod,

p objekt.methods
puts objekt.methods.to_yaml

a konstant

p Module.constants

lze tez vyuzit grepovani v nazvech

p objekt.methods.grep /get_/

Osobne bych si z toho sestavil vlastni metodu pro listovani objektu, pojmenoval ji treba show a rozsiril ji na zacatku modul Kernel, aby byla dostupna uplne vsude.

module Kernel
   def show obj
      STDERR.puts obj
      STDERR.puts obj.methods.to_yaml
      ...
   end
end

objekt = 123123
objekt.show