abclinuxu.cz AbcLinuxu.cz itbiz.cz ITBiz.cz HDmag.cz HDmag.cz abcprace.cz AbcPráce.cz
AbcLinuxu hledá autory!
Inzerujte na AbcPráce.cz od 950 Kč
Rozšířené hledání
×
    dnes 23:33 | Nová verze

    Immich byl vydán v první stabilní verzi 2.0.0 (YouTube). Jedná se o alternativu k výchozím aplikacím od Googlu a Applu pro správu fotografií a videí umožňující vlastní hosting serveru Immich. K vyzkoušení je demo. Immich je součástí balíčků open source aplikací FUTO. Zdrojové kódy jsou k dispozici na GitHubu pod licencí AGPL-3.0.

    Ladislav Hagara | Komentářů: 0
    dnes 22:33 | IT novinky

    Český telekomunikační úřad vydal zprávy o vývoji cen a trhu elektronických komunikací se zaměřením na rok 2024. Jaká jsou hlavní zjištění? V roce 2024 bylo v ČR v rámci služeb přístupu k internetu v pevném místě přeneseno v průměru téměř 366 GB dat na jednu aktivní přípojku měsíčně – celkově jich tak uživateli bylo přeneseno přes 18 EB (Exabyte). Nejvyužívanějším způsobem přístupu k internetu v pevném místě zůstal v roce 2024 bezdrátový

    … více »
    Ladislav Hagara | Komentářů: 0
    dnes 12:11 | Nová verze

    Raspberry Pi OS, oficiální operační systém pro Raspberry Pi, byl vydán v nové verzi 2025-10-01. Přehled novinek v příspěvku na blogu Raspberry Pi a poznámkách k vydání. Jedná o první verzi postavenou na Debianu 13 Trixie.

    Ladislav Hagara | Komentářů: 0
    dnes 05:22 | Nová verze

    Byla vydána nová verze 4.6 svobodného notačního programu MuseScore Studio (Wikipedie). Představení novinek v oznámení v diskusním fóru a také na YouTube.

    Ladislav Hagara | Komentářů: 0
    dnes 02:22 | Komunita

    Společnost DuckDuckGo stojící za stejnojmenným vyhledávačem věnovala 1,1 milionu dolarů (stejně jako loni) na podporu digitálních práv, online soukromí a lepšího internetového ekosystému. Rozdělila je mezi 29 organizací a projektů. Za 15 let rozdala 8 050 000 dolarů.

    Ladislav Hagara | Komentářů: 4
    včera 20:11 | Nová verze

    Svobodný multiplatformní herní engine Bevy napsaný v Rustu byl vydán ve verzi 0.17. Díky 278 přispěvatelům.

    Ladislav Hagara | Komentářů: 0
    včera 16:11 | Nová verze

    Bylo vydáno openSUSE Leap 16 (cs). Ve výchozím nastavení přichází s vypnutou 32bitovou (ia32) podporou. Uživatelům však poskytuje možnost ji ručně povolit a užívat si tak hraní her ve Steamu, který stále závisí na 32bitových knihovnách. Změnily se požadavky na hardware. Leap 16 nyní vyžaduje jako minimální úroveň architektury procesoru x86-64-v2, což obecně znamená procesory zakoupené v roce 2008 nebo později. Uživatelé se starším hardwarem mohou migrovat na Slowroll nebo Tumbleweed.

    Ladislav Hagara | Komentářů: 3
    včera 16:00 | IT novinky

    Ministerstvo průmyslu a obchodu (MPO) ve spolupráci s Národní rozvojovou investiční (NRI) připravuje nový investiční nástroj zaměřený na podporu špičkových technologií – DeepTech fond. Jeho cílem je posílit inovační ekosystém české ekonomiky, rozvíjet projekty s vysokou přidanou hodnotou, podpořit vznik nových technologických lídrů a postupně zařadit Českou republiku mezi země s nejvyspělejší technologickou základnou.

    … více »
    Ladislav Hagara | Komentářů: 3
    včera 12:55 | Nová verze

    Radicle byl vydán ve verzi 1.5.0 s kódovým jménem Hibiscus. Jedná se o distribuovanou alternativu k softwarům pro spolupráci jako např. GitLab.

    Ladislav Hagara | Komentářů: 3
    včera 03:22 | IT novinky

    Společnost OpenAI představila text-to-video AI model Sora 2 pro generování realistických videí z textového popisu. Přesnější, realističtější a lépe ovladatelný než předchozí modely. Nabízí také synchronizované dialogy a zvukové efekty.

    Ladislav Hagara | Komentářů: 4
    Jaké řešení používáte k vývoji / práci?
     (41%)
     (47%)
     (15%)
     (16%)
     (18%)
     (14%)
     (17%)
     (14%)
     (14%)
    Celkem 158 hlasů
     Komentářů: 9, poslední 24.9. 17:28
    Rozcestník

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

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

    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.

           

    Hodnocení: 100 %

            špatnédobré        

    Nástroje: Tisk bez diskuse

    Tiskni Sdílej: Linkuj Jaggni to Vybrali.sme.sk Google Del.icio.us Facebook

    Komentáře

    Vložit další komentář

    1.3.2006 19:09 Pmx
    Rozbalit Rozbalit vše Re: Ruby pro začátečníky - 3 (datové typy)
    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í?
    1.3.2006 20:06 blackened
    Rozbalit Rozbalit vše Re: Ruby pro začátečníky - 3 (datové typy)
    Zvláštní to je, ale skutečně tam patří.
    1.3.2006 20:45 Kyosuke | skóre: 28 | blog: nalady_v_modre
    Rozbalit Rozbalit vše Re: Ruby pro začátečníky - 3 (datové typy)
    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? ;-)
    2.3.2006 10:16 podlesh | skóre: 38 | Freiburg im Breisgau
    Rozbalit Rozbalit vše Re: Ruby pro začátečníky - 3 (datové typy)
    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í.
    9.3.2006 10:06 mig
    Rozbalit Rozbalit vše Re: Ruby pro začátečníky - 3 (datové typy)
    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.
    9.2.2008 11:50 ucimsetaky
    Rozbalit Rozbalit vše Re: Ruby pro začátečníky - 3 (datové typy)
    Ano, naco mit pole serazene tak jak bylo slozeno, kdyz pak se s nim peracuje objektove :)

    Založit nové vláknoNahoru

    ISSN 1214-1267   www.czech-server.cz
    © 1999-2015 Nitemedia s. r. o. Všechna práva vyhrazena.