Byla vydána beta verze openSUSE Leap 16. Ve výchozím nastavení s novým instalátorem Agama.
Devadesátková hra Brány Skeldalu prošla portací a je dostupná na platformě Steam. Vyšel i parádní blog autora o portaci na moderní systémy a platformy včetně Linuxu.
Lidi dělají divné věci. Například spouští Linux v Excelu. Využít je emulátor RISC-V mini-rv32ima sestavený jako knihovna DLL, která je volaná z makra VBA (Visual Basic for Applications).
Revolut nabídne neomezený mobilní tarif za 12,50 eur (312 Kč). Aktuálně startuje ve Velké Británii a Německu.
Společnost Amazon miliardáře Jeffa Bezose vypustila na oběžnou dráhu první várku družic svého projektu Kuiper, který má z vesmíru poskytovat vysokorychlostní internetové připojení po celém světě a snažit se konkurovat nyní dominantnímu Starlinku nejbohatšího muže planety Elona Muska.
Poslední aktualizací začal model GPT-4o uživatelům příliš podlézat. OpenAI jej tak vrátila k předchozí verzi.
Google Chrome 136 byl prohlášen za stabilní. Nejnovější stabilní verze 136.0.7103.59 přináší řadu novinek z hlediska uživatelů i vývojářů. Podrobný přehled v poznámkách k vydání. Opraveno bylo 8 bezpečnostních chyb. Vylepšeny byly také nástroje pro vývojáře.
Homebrew (Wikipedie), správce balíčků pro macOS a od verze 2.0.0 také pro Linux, byl vydán ve verzi 4.5.0. Na stránce Homebrew Formulae lze procházet seznamem balíčků. K dispozici jsou také různé statistiky.
Byl vydán Mozilla Firefox 138.0. Přehled novinek v poznámkách k vydání a poznámkách k vydání pro vývojáře. Řešeny jsou rovněž bezpečnostní chyby. Nový Firefox 138 je již k dispozici také na Flathubu a Snapcraftu.
Šestnáctý ročník ne-konference jOpenSpace se koná 3. – 5. října 2025 v Hotelu Antoň v Telči. Pro účast je potřeba vyplnit registrační formulář. Ne-konference neznamená, že se organizátorům nechce připravovat program, ale naopak dává prostor všem pozvaným, aby si program sami složili z toho nejzajímavějšího, čím se v poslední době zabývají nebo co je oslovilo. Obsah, který vytvářejí všichni účastníci, se skládá z desetiminutových
… více »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
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>
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>
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>
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
.
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>
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>
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>
times
a jí podobné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
.
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ě.
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 krok
u 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>
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.
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>
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>
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.
Nástroje: Tisk bez diskuse
Tiskni
Sdílej:
$ 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>
if row = sql.fetch_hash if row['id'] ... end end
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?
and
(resp. || a or
) se lisi prioritou. Operatory and
a or
maji velmi nizkou prioritu, viz. napr. zde.