Ruby pro začátečníky - 5 (řídící struktury)

21. 6. 2006 | Jaromír Hradílek | Programování | 6273×

Až dosud se naše „programy“ omezovaly jen na práci s proměnnými a výpis na obrazovku. V dnešním díle si vysvětlíme, co jsou to řídící struktury a ukážeme si, jak s nimi v Ruby pracovat.

Obsah

1. Logické výrazy
2. if...elsif...else...end
3. unless...else...end
4. case...when...else...end
5. Cyklus while
6. Cyklus until
7. Cyklus for
8. Metoda times a jí podobné
    8.1 times
    8.2 upto a downto
    8.3 step
9. Metoda each a jí podobné
    9.1 Array
    9.2 Hash
    9.3 String

1. Logické výrazy

Málokdy jsou požadavky na náš program takové, aby jen vykonával stále stejný sled úkonů; mnohem častěji je potřeba přizpůsobovat se nastalým událostem, vyhodnocovat vstupní data a na základě tohoto vyhodnocení pak dále pracovat – právě k tomuto účelu slouží řídící struktury.

K větvení programu dochází na základě určitých podmínek. Tyto podmínky zapisujeme formou logických výrazů, které jsou interpretrem vyhodnoceny jako pravdivé nebo nepravdivé:

irb(main):001:0> 4 > 3
=> true
irb(main):002:0> 2 * 3 < 5
=> false
irb(main):003:0>

Zápis 4 > 3 je logický výraz, porovnávající číselné hodnoty 4 a 3. Symbol > je relační operátor.

Relační operátory slouží ke srovnávání dvou hodnot a vrací buď hodnotu true v případě, že je výraz pravdivý, nebo false v případě, že pravdivý není. V jazyku Ruby rozeznáváme tyto základní relační operátory (existují i další, jimiž se budeme zabývat později):

operátor:	použití:	význam:
==	a == b	Pravda, je-li a rovno b.
!=	a != b	Pravda, není-li a rovno b.
>	a > b	Pravda, je-li a větší než b.
<	a < b	Pravda, je-li a menší než b.
>=	a >= b	Pravda, je-li a větší nebo rovno b.
<=	a <= b	Pravda, je-li a menší nebo rovno b.

Za pozornost stojí operátor rovnosti, pro který se v Ruby používá zdvojený znak rovnítka ==. Jednoduché = slouží jako operátor přiřazení a v případě jeho použití v podmíněném příkazu vypíše interpretr varování.

Další častou chybou bývá změna pořadí znaků =! => a =<. Tento zápis je nicméně neplatný a měl by vést k oznámení chyby. Mezi jednotlivé znaky také nesmíme vložit mezeru!

Vedle již zmíněných relačních operátorů se v Ruby také setkáme s následujícími logickými operátory, které možnosti logických výrazů významně rozšiřují:

operátor:	alternativa:	význam:
&&	and	Logické AND.
||	or	Logické OR.
!	not	Logické NOT.

Kterou volbu zápisu si zvolíte, záleží jen na vašem vkusu. Díky těmto operátorům pak můžeme podmínky skládat:

irb(main):004:0> 4 > 3 && 2*3 < 5
=> false
irb(main):005:0> 4 > 3 || 2*3 < 5
=> true
irb(main):006:0>

Jelikož každá relační operace vrací buď hodnotu true nebo false, srovnává logický operátor tyto hodnoty. Pro logický operátor AND pak platí:

výraz:	výsledná hodnota:
true && true	true
true && false	false
false && true	false
false && false	false

Pro logický operátor OR:

výraz:	výsledná hodnota:
true || true	true
true || false	true
false || true	true
false || false	false

Logický operátor NOT neguje výraz a obrací jeho význam:

výraz:	výsledná hodnota:
! true	false
! false	true

Relační operátory (==, >, !=, atd.) mají před logickými operátory (&&, ||, a !) přednost a proto se vyhodnocují jako první. Při složitějších konstrukcích je však přehlednější výrazy vhodně ozávorkovat a dát tím pořadí vyhodnocování jasně najevo (hodí se zvláště v případě, kdy nám implicitní pořadí nevyhovuje):

irb(main):006:0> (4 > 3) || (((2 + 3) * 3) < 5)
=> true
irb(main):007:0>

2. if...elsif...else...end

Dost bylo teorie, je čas se konečně podívat, jak funguje větvení programu v praxi. Řekněme, že si píšeme jednoduchou kalkulačku a chceme ošetřit, aby se ve jmenovateli neocitla nulová hodnota. Přesně k tomuto účelu nám může posloužit konstrukce if:

irb(main):007:0> delenec = 9; delitel = 3
=> 3
irb(main):008:0> if (delitel != 0) then
irb(main):009:1*   delenec / delitel.to_f
irb(main):010:1> end
=> 3.0
irb(main):011:0>

Jak to funguje? Za klíčovým slovem if je uveden logický výraz. Je-li tento vyhodnocen jako pravdivý, provedou se všechny příkazy v těle konstrukce, která je ukončena klíčovým slovem end. Do běžného jazyka by se dal tento zápis poněkud krkolomně přeložit jako „Je-li dělitel neroven nule, pak prověď dělení.“

Závorky okolo logického výrazu jsou nepovinné, nicméně přispívají k čitelnosti. Nepovinné je i slůvko then, začínají-li příkazy až na dalším řádku. Správné by tedy byly i následující zápisy:

if delitel != 0 then delenec / delitel.to_f end

if delitel != 0
  delenec / delitel.to_f
end

Často bychom chtěli, aby se něco provedlo v případě, že podmínka splněna nebyla, například aby se uživateli vypsala chyba. K tomu slouží else:

irb(main):011:0> delitel = 0
=> 0
irb(main):012:0> if (delitel != 0)
irb(main):013:1>   puts delenec / delitel.to_f
irb(main):014:1> else
irb(main):015:1*   puts "CHYBA: Deleni nulou!"
irb(main):016:1> end
CHYBA: Deleni nulou!
=> nil
irb(main):017:0>

Může se stát (resp. stane se velmi často), že budeme potřebovat reagovat na více podmínek. Jednou z možností by bylo podmínky zanořit do bloku za else, toto by ale nebylo ani elegantní, ani vstřícné k pozdějším úpravám a při větším počtu podmínek bychom se nejspíš utopili. Namísto toho použijeme konstrukci elsif:

irb(main):017:0> delitel = -4
=> -4
irb(main):018:0> if (delitel == 0)
irb(main):019:1>   puts "CHYBA: Deleni nulou!"
irb(main):020:1> elsif (delitel < 0) || (delenec < 0) 
irb(main):021:1>   puts "Zaporna jsme jeste nebrali... :-S"
irb(main):022:1> else
irb(main):023:1*   puts delenec / delitel.to_f
irb(main):024:1> end
Zaporna jsme jeste nebrali... :-S
=> nil
irb(main):025:0>

Částí elsif může být v konstrukci libovolný počet, příkaz if se však musí v bloku vyskytovat jen na začátku. Část else je nepovinná, je-li však uvedena, musí se vždy nacházet na konci. Konstrukci je třeba vždy uzavřít pomocí end.

Jako bonus pro milovníky kompaktních konstrukcí umožňuje Ruby také zápis s podmínkou if na konci:

irb(main):025:0> puts "Pripada vam tohle prehledne?!" if (true)
Pripada vam tohle prehledne?!
=> nil
irb(main):026:0>

3. unless...else...end

Konstrukce unless je ekvivalentní negaci if a do češtiny by se dala přeložit jako „není-li“:

irb(main):025:0> unless (delitel == 0)
irb(main):026:1>   puts delenec / delitel.to_f
irb(main):027:1> end
-2.25
=> nil
irb(main):028:0>

Přepis pomocí if by vypadal takto:

irb(main):028:0> if !(delitel == 0)
irb(main):029:1>   puts delenec / delitel.to_f
irb(main):030:1> end
-2.25
=> nil
irb(main):031:0>

Oproti konstrukci if však schází část elsif. Je však opět možný i zápis s podmínkou na konci:

irb(main):031:0> puts "Delitel neni nulovy" unless (delitel == 0)
Delitel neni nulovy
=> nil
irb(main):032:0>

4. case...when...else...end

V případě, že máme jednu proměnnou a chceme ji testovat na více hodnot, bylo by použití if poněkud neobratné. Příkaz case nám oproti tomu umožňuje testovat více hodnot naráz, včetně rozsahů:

irb(main):032:0> cas = 16
=> 16
irb(main):033:0> case cas
irb(main):034:1>   when 5 .. 7
irb(main):035:1>     puts "Dobre rano."
irb(main):036:1>   when 8 .. 11
irb(main):037:1>     puts "Hezke dopoledne."
irb(main):038:1>   when 12
irb(main):039:1>     puts "Dobre poledne."
irb(main):040:1>   when 13 .. 18
irb(main):041:1>     puts "Dobre odpoledne."
irb(main):042:1>   when 19 .. 21
irb(main):043:1>     puts "Dobry vecer."
irb(main):044:1>   when 24, 0
irb(main):045:1>     puts "Pulnoc!"
irb(main):046:1>   else
irb(main):047:1*     puts "Krasnou dobrou noc. "
irb(main):048:1> end
Dobre odpoledne.
=> nil
irb(main):049:0>

Jak vidíte, je možné zadávat rozsahy pomocí zápisu od .. do (včetně), jednu nebo více hodnot oddělených čárkou, i použít část else pro případ, že nevyhovuje žádná z uvedených podmínek. Konstrukci opět zakončuje end.

5. Cyklus while

Často bychom potřebovali, aby se určitá část programu vykonala opakovaně několikrát. K tomuto účelu Ruby nabízí hned několik druhů cyklů a jedním z nich je i while známý z jiných programovacích jazyků. Jeho syntaxe je následující:

while výraz do
  příkazy
end

Příkazy zapsané v těle cyklu se provádí po dobu, co je výraz vyhodnocen jako true. Podobně jako v případě if je i zde psaní do nepovinné, následují-li příkazy na samostatném řádku.

Činnost cyklu while si ukážeme na následujícím příkladu, který vypíše Fibonacciho řadu čísel menších než 100:

irb(main):049:0> a, b = 0, 1
=> [0, 1]
irb(main):050:0> while b < 100
irb(main):051:1>   print b, ", "
irb(main):052:1>   a, b = b, a + b
irb(main):053:1> end
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, => nil
irb(main):054:0>

6. Cyklus until

Velmi podobný while je cyklus until; ten se od něj liší jen tím, že příkazy v těle cyklu jsou prováděny po dobu, co je výraz vyhodnocen jako false a je tedy ekvivalentní zápisu:

while !(výraz) do
  příkazy
end

Modifikovaný výpočet Fibonacciho řady by pak vypadal:

irb(main):054:0> a, b = 0, 1
=> [0, 1]
irb(main):055:0> until b >= 100
irb(main):056:1>   print b, ", "
irb(main):057:1>   a, b = b, a + b
irb(main):058:1> end
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, => nil
irb(main):059:0>

7. Cyklus for

Cyklus for na rozdíl od předchozích slouží k procházení seznamu:

for položka in seznam do
  příkazy
end

Jistě není překvapením, že položku do lze vynechat. Použití může být třeba následující:

irb(main):059:0> kluci = ["Jiri", "Lukas", "Martin"]
=> ["Jiri", "Lukas", "Martin"]
irb(main):060:0> for jmeno in kluci
irb(main):061:1>   puts "Ahoj, ja jsem #{jmeno}."
irb(main):062:1> end
Ahoj, ja jsem Jiri.
Ahoj, ja jsem Lukas.
Ahoj, ja jsem Martin.
=> ["Jiri", "Lukas", "Martin"]
irb(main):063:0>

Stejně tak se hodí, víme-li, kolikrát se má cyklus vykonat, ačkoli k tomuto účelu má Ruby i lepší nástroje (viz dále):

irb(main):053:0> for i in (1..10)
irb(main):063:1>   print i, ", "
irb(main):064:1> end
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, => 1..10
irb(main):065:0>

8. Metoda times a jí podobné

8.1 times

Pro celočíselné typy je v Ruby definovaná metoda times (doslova krát):

irb(main):065:0> 3.times { puts "Ahoj" }
Ahoj
Ahoj
Ahoj
=> 3
irb(main):066:0>

Tímto zápisem říkáme, že se má blok příkazů mezi znaky { a } provést třikrát. Obecně při použití zápisu n.times dochází k iteraci od 0 do n-1. Pokud bychom chtěli využít aktuální hodnotu, můžeme to provést takto:

irb(main):066:0> 4.times do
irb(main):067:1*   |i|  # aktualni hodnotu ulozime do promenne i
irb(main):068:1*   puts "2^#{i} = #{2**i}"
irb(main):069:1> end
2^0 = 1
2^1 = 2
2^2 = 4
2^3 = 8
=> 4
irb(main):070:0>

Všimněte si také, že složené závorky je v tomto případě pro konzistentnost nahradit do a end.

8.2 upto a downto

Velice podobné metodě times jsou následující dvě:

irb(main):070:0> 3.upto(7) { |i| print i, " " }
3 4 5 6 7 => 3

irb(main):071:0> 5.downto(2) { |i| print i, " " }
5 4 3 2 => 5
irb(main):072:0>

Zápis n.upto(m) říká, že se má iterace bloku provést vzestupně od n po m. Obdobně v případě downto, avšak sestupně.

8.3 step

Všechny výše uvedené metody prováděly inkrementaci (dekrementaci) hodnoty právě o 1. Občas by ale přišlo vhod moci si tuto hodnotu zvolit jinak – právě k tomuto účelu slouží metoda step. Její obecný zápis je následující:

počáteční.step(konečná, krok) {|i| blok }

V tomto případě probíhá iterace od počáteční hodnoty, která je v každém průběhu inkrementována o hodnotu krok, dokud není výsledná hodnota větší než konečná. Hodnota kroku může být pochopitelně záporná:

irb(main):072:0> 27.step(2, -3) { |i| print i, " " }
27 24 21 18 15 12 9 6 3 => 27
irb(main):073:0>

9. Metoda each a jí podobné

K procházení položek seznamů jsme dosud používali cyklu for. Pro jednotlivé datové typy (pole, hashe, ba dokonce řetězce) však existuje také metoda each a od ní odvozené, jejichž zvládnutí vám usnadní práci a umožní elegantně dosáhnout toho, co byste jinak museli složitě obcházet.

9.1 Array

Pro datový typ Array (pole) je metoda each intuitivní a funguje obdobně, jako cyklus for:

irb(main):073:0> kluci = ["Lukas", "Radek", "Jiri", "Martin"]
=> ["Lukas", "Radek", "Jiri", "Martin"]
irb(main):074:0> kluci.each {
irb(main):075:1*   |jmeno|
irb(main):076:1*   print jmeno + ", "
irb(main):077:1> }
Lukas, Radek, Jiri, Martin, => ["Lukas", "Radek", "Jiri", "Martin"]
irb(main):078:0>

Na prvním řádku jsme si vytvořili seznam obsahující čtyři položky. Tento procházíme pomocí metody each, aktuální položka je vždy načtena do proměnné jmeno a vypsána na obrazovku.

Krom položek samotných lze pole procházet také po indexech:

irb(main):078:0> kluci.each_index {
irb(main):079:1*   |i|    
irb(main):080:1*   print i, ": ", kluci[i], "\n"
irb(main):081:1> }
0: Lukas
1: Radek
2: Jiri
3: Martin
=> ["Lukas", "Radek", "Jiri", "Martin"]
irb(main):082:0>

9.2 Hash

Podobně jako tomu bylo v případě polí, i u typu Hash dochází k průchodu po jednotlivých položkách, tentokrát však vrací metoda each klíč i jemu příslušející hodnotu:

irb(main):082:0> udaje = {"jmeno" => "Winston", "prijmeni" => "Smith"}
=> {"jmeno"=>"Winston", "prijmeni"=>"Smith"}
irb(main):083:0> udaje.each {
irb(main):084:1*   |klic, hodnota|
irb(main):085:1*   puts "Vase #{klic} je #{hodnota}."
irb(main):086:1> }
Vase jmeno je Winston.
Vase prijmeni je Smith.
=> {"jmeno"=>"Winston", "prijmeni"=>"Smith"}
irb(main):087:0>

Ne vždy se nám ale hodí obě hodnoty. Ruby myslí i na toto a proto definuje další dvě metody – each_key pro procházení klíčů a each_value pro totéž s hodnotami:

irb(main):087:0> udaje.each_key { |klic| puts klic }
jmeno
prijmeni
=> {"jmeno"=>"Winston", "prijmeni"=>"Smith"}

irb(main):088:0> udaje.each_value { |hodnota| puts hodnota }
Winston
Smith
=> {"jmeno"=>"Winston", "prijmeni"=>"Smith"}
irb(main):089:0>

9.3 String

Jelikož je řetězec skupina znaků, lze procházet i jej. Metoda each (nebo její ekvivalent each_line) slouží bez parametrů k procházení řetězců po řádcích:

irb(main):089:0> retezec = "Prvni\nDruhy\nTreti\nCtvrty"
=> "Prvni\nDruhy\nTreti\nCtvrty"
irb(main):090:0> retezec.each { |radek| print "- ", radek }
- Prvni
- Druhy
- Treti
- Ctvrty=> "Prvni\nDruhy\nTreti\nCtvrty"
irb(main):091:0>

Jak vidíte, je řetězec skutečně procházen po řádcích. Drobnou nepříjemností může být, že je zachován znak konce řádku, nicméně s tím si už jistě poradíte.

Pomocí parametru lze také explicitně zvolit znak nebo řetězec znaků, jenž má při procházení sloužit jako oddělovač. Následující příklad prochází řetězec po větách, které vypisuje každou na samostatný řádek. K rozpoznání konce vět zde slouží kombinace znaků '. ':

irb(main):091:0> retezec = "Dobry den, madam. Racte mne prosim nasledovat."
=> "Dobry den, madam. Racte mne prosim nasledovat."
irb(main):092:0> retezec.each(". ") { |veta| puts veta }
Dobry den, madam. 
Racte mne prosim nasledovat.
=> "Dobry den, madam. Racte mne prosim nasledovat."
irb(main):093:0>

Kromě toho je pro řetězce ještě definována metoda each_byte, která slouží k procházení řetězce po jednotlivých znacích:

irb(main):093:0> retezec = "Ahoj!"
=> "Ahoj!"
irb(main):094:0> retezec.each_byte { |znak| print znak, " " }
65 104 111 106 33 => "Ahoj!"
irb(main):095:0>

Co znamenají ta čísla? Metoda each_byte totiž vrací číselnou hodnotu daného znaku dle tabulky ASCII. Chceme-li vypsat konkrétní znak, musíme jej převést. K převodu celočíselné hodnoty na příslušný znak slouží metoda chr:

irb(main):095:0> retezec.each_byte { |znak| print znak.chr }
Ahoj!=> "Ahoj!"
irb(main):096:0>

Příště si řekneme, co to jsou regulární výrazy, a jak se s nimi v Ruby pracuje.

       

Komentáře

[Tom.š Ze.le.in]

Ahoj,

v popisu operátorů || a spol. mi chybí vcelku důležitá informace, zda je zaručeno, že pokud je výsledek operace jasný po vyhodnocení určitého počtu operandů, další se nevyhodnocují. Tedy, zda je bezproblémová konstrukce typu a != 0 && b == c/a (a s tím související informace o tom, zda je zaručeno, že se obecně operandy operátorů a funkcí vyhodnocují zleva doprava).

Nejsem (zatím) rubista, ale vím, že tohle je věc, na které při změně jazyka člověk občas uklouzne.

[Martin Povolný]

zleva doprava a líně

$ irb
irb(main):001:0> (1==1) || (puts "a")
=> true
irb(main):002:0> (1==1) && (puts "a")
a
=> nil
irb(main):003:0> (1==0) && (puts "a")
=> false
irb(main):004:0> (1==0) || (puts "a")
a
=> nil
irb(main):005:0>

[MiG]

Jen pozor na to, ze pritom nelze nastavit promennou a pak ji pouzit dale, napr. tohle nefunguje:

if row = sql.fetch_hash && row['id'] ... end

[MiG]

Jeste uvedu, jak to funguje:

if row = sql.fetch_hash 
   if row['id'] 
     ... 
   end
end

[Kyosuke]

irb(main):001:0> d=4
=> 4
irb(main):002:0> e=0
=> 0
irb(main):003:0> if (e=d) && (puts e+3) ; end
7
=> nil
irb(main):004:0>

Uniklo mi něco?

[bpfm]

chyba je v tom ze e=d && (puts e+3) se vyhodnocuje jako e=(d && (puts e+3))

[Michal Vyskočil]

To se nazývá zkrácené vyhodnocování. Třeba Pascal tím trpěl, protože se to muselo explicitně zapnout (a ve školách to zakazovali)

[Kyosuke]

Mě hlavně překvapuje, že ve školách najde člověk implicitně zapnutý Pascal...

[MiG]

Opravdu objektove myslet me naucilo az Ruby, do te doby jsem (v PHP) pomoci objektu jen obaloval jiny kod. Pritom ale oddeleny jmenny prostor je jen casti toho, co je na objektovem programovani hezke

[Pavel Janousek]

No to bylo v dobach, kdy zakladem programovani byla (spravne!) algoritmizace ukolu a ne lepeni a bastleni "komponent" jako dnes...

[Kyosuke]

Správnou algoritmizaci úkolu může člověk provést i v Pythonu nebo v Ruby. Zvláště pythonovský kód pak vypadá jako zkopírovaný pseudokód... Takže bych to tak hrozně neviděl.

[Michal Vyskočil]

To je argument pro Pascal (Delphi), nebo proti?