Ruby pro začátečníky - 3 (datové typy)

1. 3. 2006 | Jaromír Hradílek | Programování | 10491×

V minulém díle našeho seriálu jsme si ukázali práci s proměnnými, dnes se podíváme blíže na jednotlivé datové typy.

Obsah

1. Dynamické datové typy
2. Fixnum a Bignum
3. Float
4. String
5. Array
6. Hash

1. Dynamické datové typy

Už jsem se několikrát zmínil, že je Ruby dynamicky typovaný jazyk. Nyní si vysvětlíme, co to znamená.

Jak jsme viděli, proměnná může uchovávat nejrůznější druhy hodnot - celá a reálná čísla, řetězce, ba dokonce pole a hashe. Chceme-li kteroukoli z těchto hodnot uložit do proměnné, musí dojít k vyhrazení určitého místa v paměti počítače. V nízkoúrovňových jazycích, jako je C, proto před použitím nějaké proměnné musíme explicitně uvést, jakého bude typu (co do ní hodláme uložit). Tomuto se říká statické typování.

Naproti tomu v dynamicky typovaných jazycích proměnná nabývá typu až podle přiřazené hodnoty a tento typ se navíc může v průběhu jejího života libovolně měnit.

Základními datovými typy v Ruby jsou Fixnum, Bignum, Float, String, Array a Hash. Pojďme si je tedy postupně probrat.

2. Fixnum a Bignum

Fixnum a Bignum označují celá čísla a jsou v podstatě ekvivalenty typů integer a long integer, známých z jiných jazyků. Jaký je mezi nimi rozdíl?

Fixnum je určen pro menší čísla a zabírá i méně místa v paměti. Chceme-li uchovávat čísla větší, přijde na řadu Bignum, který může nabývat teoreticky nekonečných hodnot (omezením je pochopitelně velikost dostupné paměti počítače). Jak se s nimi pracuje? Jednoduše. Interpretr sám pozná, který typ má použít:

irb(main):001:0> a = 10
=> 10
irb(main):002:0> a.class
=> Fixnum
irb(main):003:0> a = 10_000_000_000
=> 10000000000
irb(main):004:0> a.class
=> Bignum
irb(main):005:0>

Jelikož čitelnost větších čísel je obtížná, umožňuje Ruby oddělovat řády pomocí znaku _ (podtržítko). Podtržítka jsou interpretrem ignorována (vidíme, že návratová hodnota je 10000000000), programátoři je však jistě ocení.

Druhou zajímavou věcí je metoda class. O metodách si toho řekneme více, až přejdeme k objektově orientovanému přístupu; zatím nás zajímá jen výsledek, a tím je právě typ proměnné.

3. Float

S typem Float jsme se už taky setkali a označuje reálná čísla (čísla s plovoucí desetinnou čárkou, angl. floating point). Stejně jako ve většině programovacích jazyků je místo u nás běžné čárky používána k oddělení desetinných míst tečka:

irb(main):005:0> a = 3.14159
=> 3.14159
irb(main):006:0> a.class
=> Float
irb(main):007:0>

Marně bychom v Ruby hledali typ double, Float bez obtíží pojme i obrovská čísla.

4. String

String, neboli řetězec, je už poněkud komplikovanější a běžně se vytváří uzavřením skupiny znaků mezi apostrofy ('), nebo do uvozovek ("):

irb(main):007:0> pozdrav = 'Ahoj!'
=> "Ahoj!"
irb(main):008:0> den = "Streda"
=> "Streda"
irb(main):009:0>

Na první pohled se zdá, že je zcela jedno, jestli použijeme apostrofů, nebo uvozovek. To však není pravda. Asi první, co vás napadne, je použít apostrofy tam, kde v našem řetězci chceme mít uvozovky, a naopak:

irb(main):009:0> pozdrav = '"No nazdar," usklibl se.'
=> "\"No nazdar,\" usklibl se."
irb(main):010:0> titul = "Blackened's Ruby tutorial"
=> "Blackened's Ruby tutorial"
irb(main):011:0>

Je zde ale ještě jeden podstatnější rozdíl: v řetězci uzavřeném v uvozovkách se berou v potaz speciální znaky, uvozené znakem \ (zpětné lomítko) a vyhodnocují se výrazy uzavřené v #{}. V řetězci uzavřeném v apostrofech se těmto znakům nepřipisuje žádný zvláštní význam a je s nimi zacházeno jako s jakýmikoliv jinými. Více nám ukáží následující příklady:

irb(main):011:0> puts "Ahoj\nsvete!"
Ahoj
svete!
=> nil
irb(main):012:0> puts 'Ahoj\nsvete!'
Ahoj\nsvete!
=> nil
irb(main):013:0>

Příkazem puts se budeme detailněji zabývat v některém z dalších dílů, prozatím nám stačí vědět, že slouží k vypsání hodnot na obrazovku.

Z příkladu je jasně vidět odlišné chování - speciální sekvence \n zastupuje zalomení řádku a podle toho byla v prvním případě vyhodnocena. V případě druhém se s ní zacházelo jako s běžným řetězcem.

Možná vás napadlo, jak docílit třeba vypsání znaku zpětného lomítka v řetězci s uvozovkami. Použije-li se zpětné lomítko zdvojeně, je vypsáno jako standardní znak:

irb(main):013:0> puts "Toto je zpetne lomitko: \\"
Toto je zpetne lomitko: \
=> nil
irb(main):014:0>

Zpětné lomítko totiž stejně jako dovede znakům speciální význam dávat, umí ho i brát:

puts "\"No nazdar,\" pravil a zatvaril se kysele."
"No nazdar," pravil a zatvaril se kysele.
=> nil
irb(main):015:0>

Když se podíváte o pár příkladů zpátky na návratovou hodnotu přiřazení do proměnné pozdrav, zjistíte, že Ruby dělá vlastně při použití apostrofů totéž.

Druhou zajímavou vlastností je vyhodnocování výrazů uzavřených v #{}:

irb(main):015:0> puts "5 x 5 = #{5*5}"
5 x 5 = 25
=> nil
irb(main):016:0>

Lze pochopitelně použít i proměnných:

irb(main):016:0> jazyk = "Ruby"
=> "Ruby"
irb(main):017:0> puts "#{jazyk} je muj nejoblibenejsi jazyk!"
Ruby je muj nejoblibenejsi jazyk!
=> nil
irb(main):018:0>

Kdybychom se o totéž pokusili s apostrofy, moc bychom neuspěli:

irb(main):018:0> puts '#{jazyk} je muj nejoblibenejsi jazyk!'
#{jazyk} je muj nejoblibenejsi jazyk!
=> nil
irb(main):019:0>

Avšak jeden zápis přeci jen vyhodnocuje jinak, a to když chceme vypsat právě apostrof:

irb(main):019:0> puts 'Blackened\'s Ruby Tutorial'
Blackened's Ruby Tutorial
=> nil
irb(main):020:0>

Řetězce se také dají velmi snadno spojovat:

irb(main):020:0> 'Ahoj ' + 'svete!'
=> "Ahoj svete!"
irb(main):021:0>

... a to i v případě proměnných typu String:

irb(main):021:0> jmeno = 'Bilbo'
=> "Bilbo"
irb(main):022:0> prijmeni = 'Pytlik'
=> "Pytlik"
irb(main):023:0> celeJmeno = jmeno + ' ' + prijmeni
=> "Bilbo Pytlik"
irb(main):024:0>

Co je však ještě zajímavější, řetězce se dají i násobit:

irb(main):024:0> 'la'*3
=> "lalala"
irb(main):025:0>

Krom toho se dají s řetězci vyvádět psí kusy:

# vypise delku retezce
irb(main):025:0> 'Ahoj, svete!'.length 
=> 12

# prevede vsechna pismena na velka
irb(main):026:0> 'Ahoj, svete!'.upcase
=> "AHOJ, SVETE!"

# prevede vsechna pismena na mala
irb(main):027:0> 'Ahoj, svete!'.downcase
=> "ahoj, svete!"

# zameni velka pismena za mala a naopak
irb(main):028:0> 'Ahoj, svete!'.swapcase
=> "aHOJ, SVETE!"

# vypise retezec pozpatku
irb(main):029:0> 'Ahoj, svete!'.reverse  
=> "!etevs ,johA"
irb(main):030:0>

O metodách si budeme povídat důkladněji, až přejdeme k objektově orientovanému přístupu a třídám. Vidíte však už teď, že se s nimi dá užít pořádné legrace :-).

Použijeme-li jednu z výše uvedených metod na nějaký řetězec, jeho původní hodnota se nezmění:

irb(main):030:0> pozdrav = 'Ahoj, svete!'
=> "Ahoj, svete!"
irb(main):031:0> pozdrav.upcase
=> "AHOJ, SVETE!"
irb(main):032:0> pozdrav
=> "Ahoj, svete!"
irb(main):033:0>

Dost často by se nám ale hodilo naši změnu do proměnné uložit. Běžným způsobem se to dá provést následovně:

irb(main):033:0> pozdrav = pozdrav.upcase
=> "AHOJ, SVETE!"
irb(main):034:0> pozdrav
=> "AHOJ, SVETE!"
irb(main):035:0>

Ruby však nabízí elegantnější řešení, a tím je použití metody s vykřičníkem na konci:

irb(main):017:0> pozdrav.downcase!
=> "ahoj, svete!"
irb(main):018:0> pozdrav
=> "ahoj, svete!"
irb(main):019:0>

Hezké, ne? Pochopitelně ne všechny metody mají definovaný ekvivalent s vykřičníkem, například v souvislosti s metodou length v tom ani mnoho užitku nevidím.

5. Array

Typ Array bývá česky překládán jako pole a v některých jazycích je označován taky jako list (seznam). Pole je zvláštní datový typ, který může oproti výše uvedeným nabývat více hodnot:

irb(main):019:0> cisla = [1, 2, 3]
=> [1, 2, 3]
irb(main):020:0>

Takto jsme vytvořili proměnnou cisla typu Array, obsahující tři prvky typu Fixnum. Důležitou vlastností polí v Ruby je, že mohou obsahovat i prvky různých typů:

irb(main):020:0> pelmel = [3, "Ahoj", -12.4]
=> [3, "Ahoj", -12.4]
irb(main):021:0>

Pole může dokonce obsahovat další pole:

irb(main):021:0> pelmel = [3, "Ahoj", -12.4, cisla]
=> [3, "Ahoj", -12.4, [1, 2, 3]]
irb(main):022:0>

Stejně jako tomu bylo u typu String, lze mezi sebou pole sčítat, nebo je násobit:

irb(main):022:0> pelmel + cisla
=> [3, "Ahoj", -12.4, [1, 2, 3], 1, 2, 3]
irb(main):023:0> cisla * 3
=> [1, 2, 3, 1, 2, 3, 1, 2, 3]
irb(main):024:0>

Takto můžeme vytvářet seznamy nejrůznějších prvků. Ale jak s nimi pak pracovat a k jednotlivým prvkům přistupovat? Pole je vlastně seznam prvků, indexovaných od nuly - obsah naší proměnné cisla tedy vypadá nějak takto:

         +---+---+---+
hodnota: | 1 | 2 | 3 |
         +---+---+---+
index:     0   1   2

Chceme-li vypsat 2. prvek pole cisla (tedy prvek s indexem 1), uděláme to takto:

irb(main):024:0> cisla[1]
=> 2
irb(main):025:0>

Pole lze indexovat i odzadu:

         +---+---+---+
hodnota: | 1 | 2 | 3 |
         +---+---+---+
index:     0   1   2
index:    -3  -2  -1

irb(main):025:0> cisla[-1]
=> 3
irb(main):026:0> cisla[-3]
=> 1
irb(main):027:0>

Pokusíme-li se zobrazit neexistující prvek pole, bude nám vrácena prázdná hodnota nil:

irb(main):027:0> cisla[10]
=> nil
irb(main):028:0>

Kromě zobrazování jednotlivých prvků má Ruby i další možnosti:

irb(main):028:0> cisla = [1, 2, 3, 4, 5, 6]
=> [1, 2, 3, 4, 5, 6]
irb(main):029:0> cisla[0,3]  # vypise 3 prvky, pocinaje indexem 0
=> [1, 2, 3]
irb(main):030:0> cisla[0..3]  # vypise prvky s indexem 0 az 3 vcetne
=> [1, 2, 3, 4]
irb(main):031:0> cisla[0...3]  # vypise prvky s indexem 0 az 2
=> [1, 2, 3]
irb(main):032:0> cisla[-3,2]  # vypise 2 prvky, pocinaje indexem -3
=> [4, 5]
irb(main):033:0>

Prvky lze podle indexů i přidávat, nebo nahrazovat:

irb(main):033:0> jmena = ['Jaromir', 'Lukas', 'Radek']
=> ["Jaromir", "Lukas", "Radek"]
irb(main):034:0> jmena[3] = 'Jiri'
=> "Jiri"
irb(main):035:0> jmena
=> ["Jaromir", "Lukas", "Radek", "Jiri"]
irb(main):036:0>

V případě, že přidáme prvek na index větší než je dosavadní rozsah, jsou "chybějící" prvky nahrazeny prázdnou hodnotou nil:

irb(main):036:0> jmena[7] = 'Martin'
=> "Martin"
irb(main):037:0> jmena
=> ["Jaromir", "Lukas", "Radek", "Jiri", nil, nil, nil, "Martin"]
irb(main):038:0>

Stejně jako String, má i Array spoustu užitečných metod:

# vrati pocet prvku pole
irb(main):038:0> jmena.length
=> 8

# vrati pole s obracenym poradim prvku
irb(main):039:0> jmena.reverse
=> ["Martin", nil, nil, nil, "Jiri", "Radek", "Lukas", "Jaromir"]

# zkrati pole o prazdne hodnoty
irb(main):040:0> jmena.compact
=> ["Jaromir", "Lukas", "Radek", "Jiri", "Martin"]
irb(main):041:0>

Další zajímavou možností je převod pole na řetězec a naopak:

irb(main):041:0> retezec = jmena.join(';')
=> "Jaromir;Lukas;Radek;Jiri;;;;Martin"
irb(main):042:0> retezec.split(';')
=> ["Jaromir", "Lukas", "Radek", "Jiri", "", "", "", "Martin"]
irb(main):043:0>

V závorce obou metod uvádíme řetězec, který má být použit/rozpoznán jako oddělovač prvků. Převod z řetězce na pole však není 100% - bez ohledu na prapůvodní typ jsou všechny prvky převedeny na řetězec.

K vymazání prvku z pole slouží metoda delete:

irb(main):043:0> jmena.delete("Jaromir")
=> "Jaromir"
irb(main):044:0> jmena
=> ["Lukas", "Radek", "Jiri", nil, nil, nil, "Martin"]
irb(main):045:0>

Pomocí správných metod lze pole využít jako frontu s filozofií fifo (first in, first out - první dovnitř, první ven):

# vytvorime prazdnou frontu
irb(main):045:0> buffer = []
=> []

# pridame prvek na konec fronty
irb(main):046:0> buffer.push("Jaromir")
=> ["Jaromir"]

# pridame prvek na konec fronty
irb(main):047:0> buffer.push("Lukas")
=> ["Jaromir", "Lukas"]

# pridame prvek na konec fronty
irb(main):048:0> buffer.push("Radek")
=> ["Jaromir", "Lukas", "Radek"]

# odebereme prvek na zacatku fronty a vratime jeho hodnotu
irb(main):049:0> buffer.shift
=> "Jaromir"

# na prvni misto se dostal nasledujici prvek
irb(main):050:0> buffer
=> ["Lukas", "Radek"]
irb(main):051:0>

Další užitečné metody lze nalézt v referenci jazyka Ruby, v části o třídě Array.

6. Hash

Hash nebo taky asociativní pole slouží také k ukládání více hodnot. Namísto číselných indexů však používá k označení prvků takzvaných klíčů. Hash je uzavřen ve složených závorkách:

irb(main):051:0> udaje = {"jmeno" => "Jaromir", "prijmeni" => "Hradilek"}
=> {"jmeno"=>"Jaromir", "prijmeni"=>"Hradilek"}
irb(main):052:0>

Hodnoty se zadávají vždy ve dvojici klíč => hodnota a navzájem jsou oddělené čárkou. K jednotlivým hodnotám se pak přistupuje pomocí klíče:

irb(main):053:0> udaje["jmeno"]
=> "Jaromir"
irb(main):054:0> udaje["prijmeni"]
=> "Hradilek"
irb(main):055:0>

Nový údaj lze do hashe snadno přidat:

irb(main):055:0> udaje["pohlavi"] = "muz"
=> "muz"
irb(main):056:0> udaje
=> {"jmeno"=>"Jaromir", "prijmeni"=>"Hradilek", "pohlavi"=>"muz"}
irb(main):057:0>

I typ Hash má definovanou spoustu metod:

irb(main):057:0> udaje.length  # vrati pocet prvku
=> 3
irb(main):058:0> udaje.keys  # vrati pole vsech klicu
=> ["jmeno", "prijmeni", "pohlavi"]
irb(main):059:0> udaje.values  # vrati pole vsech hodnot
=> ["Jaromir", "Hradilek", "muz"]
irb(main):060:0> udaje.index("Jaromir")  # vrati klic k dane hodnote
=> "jmeno"
irb(main):061:0> udaje.invert  # zameni klice s hodnotami
=> {"Hradilek"=>"prijmeni", "Jaromir"=>"jmeno", "muz"=>"pohlavi"}
irb(main):062:0>

Dost často by se nám hodilo zjistit, zdali náš hash obsahuje určitý klíč:

irb(main):062:0> udaje.has_key?("prijmeni")
=> true
irb(main):063:0>

Návratovou hodnotou metody je buď true (pravda) v případě, že daný klíč existuje, nebo false (nepravda) v případě, že ne. Podobně lze zjišťovat i přítomnost hodnot:

irb(main):063:0> udaje.has_value?("Pavel")
=> false
irb(main):064:0>

Z hashe lze prvky i odebírat:

irb(main):064:0> udaje.delete("pohlavi")
=> "muz"
irb(main):065:0> udaje
=> {"jmeno"=>"Jaromir", "prijmeni"=>"Hradilek"}
irb(main):066:0>

Jako parametr je metodě delete předán klíč mazané položky, návratovou hodnotou je její hodnota. Chceme-li smazat všechny prvky, můžeme použít metodu clear:

irb(main):066:0> udaje.clear
=> {}
irb(main):067:0> udaje
=> {}
irb(main):068:0>

Úplný přehled metod najdete v referenci jazyka Ruby.

       

Komentáře

[Pmx]

udaje.has_key?("prijmeni")

Ten otazník je součástí názvu funkce? Není to trochu zvláštní, mít interpunkční znaménka v názvech funkcí?

[blackened]

Zvláštní to je, ale skutečně tam patří.

[Kyosuke]

Proč zvláštní? V Ruby je to běžná mnemotechnika pro metody vracející pravdivostní hodnotu. Stejně tak vykřičník je symbolem destruktivních operací, tím spíše, pokud k nim existuje nedetruktivní (kopírující) ekvivalent.

Půlka jazyků, co znám, tyhle věci dovoluje. V Ruby je to nutnost, neboť prakticky vše jsou běžné metody, včetně operací +, ++, %...you name it. Jak byste je chtěl definovat, když by tyhle znaky nebyly povolené v identifikátorech?

[podlesh]

Je to nezvyklé, ale o to nápadnější. Jinak je to velice dobrý zvyk, převzatý z LISPu. Například v Pythonu je vidět, že tam vyloženě chybí.

[mig]

Tak mě napadá, že si neodpustím malou reklamu

Hash z principu neuchovává pořadí položek (jako php Array),

h = Hash.new
h['z'] = 1
h['a'] = 2
h['x'] = 3
p h  # { 'a'=>2, 'x'=>3, 'z'=>1 }

Jak vidíte, prvky jsou seřazené podle abecedy, nikoli v pořadí, jak byly do hashe přidány.

Pokud byste chtěli simulovat chování php pole, zkuste OrderedHash.

[ucimsetaky]

Ano, naco mit pole serazene tak jak bylo slozeno, kdyz pak se s nim peracuje objektove :)