Coppwr, tj. GUI nástroj pro nízkoúrovňové ovládání PipeWire, byl vydán v nové verzi 1.6.0. Zdrojové kódy jsou k dispozici na GitHubu. Instalovat lze také z Flathubu.
Byla vydána dubnová aktualizace aneb nová verze 1.89 editoru zdrojových kódů Visual Studio Code (Wikipedie). Přehled novinek i s náhledy a animovanými gify v poznámkách k vydání. Vypíchnout lze, že v terminálu lze nově povolit vkládání kopírovaného textu stisknutím středního tlačítka myši. Ve verzi 1.89 vyjde také VSCodium, tj. komunitní sestavení Visual Studia Code bez telemetrie a licenčních podmínek Microsoftu.
Proton, tj. fork Wine integrovaný v Steam Play a umožňující v Linuxu přímo ze Steamu hrát hry určené pouze pro Windows, byl vydán ve verzi 9.0-1 (𝕏). Přehled novinek se seznamem nově podporovaných her na GitHubu. Aktuální přehled her pro Windows běžících díky Protonu také na Linuxu na stránkách ProtonDB.
Byla vydána verze 1.78.0 programovacího jazyka Rust (Wikipedie). Podrobnosti v poznámkách k vydání na GitHubu. Vyzkoušet Rust lze například na stránce Rust by Example.
Služba Dropbox Sign (původně HelloSign) pro elektronické podepisování smluv byla hacknuta.
Byla vydána nová major verze 8.0 textového editoru GNU nano (Wikipedie). Podrobný přehled novinek a oprav v oznámení v diskusním listu info-nano nebo v souboru ChangeLog na Savannah. Volbou --modernbindings (-/) lze povolit "moderní" klávesové zkratky: ^C kopírování, ^V vložení, ^Z vrácení zpět, … Tato volba je aktivována také pokud binárka s nano nebo link na ni začíná písmenem "e".
Před 60 lety, 1. května 1964, byl představen programovací jazyk BASIC (Beginners' All-purpose Symbolic Instruction Code).
Byla vydána nová verze 12.0 minimalistické linuxové distribuce (JeOS, Just enough Operating System) pro Kodi (dříve XBMC) a multimediálního centra LibreELEC (Libre Embedded Linux Entertainment Center). Jedná se o fork linuxové distribuce OpenELEC (Open Embedded Linux Entertainment Center). LibreELEC 12.0 přichází s Kodi 21.0 "Omega".
Microsoft vydal novou velkou aktualizaci 2404.23 v září 2019 pod licencí SIL Open Font License (OFL) zveřejněné rodiny písma Cascadia Code pro zobrazování textu v emulátorech terminálu a vývojových prostředích.
OpenTofu, tj. svobodný a otevřený fork Terraformu vzniknuvší jako reakce na přelicencování Terraformu z MPL na BSL (Business Source License) společností HashiCorp, bylo vydáno ve verzi 1.7.0. Přehled novinek v aktualizované dokumentaci. Vypíchnout lze State encryption.
1. Výstup na obrazovku
1.1 Příkaz puts
1.2 Příkaz print
1.3 Příkaz printf
2. Vstup z klávesnice
2.1 Příkaz gets
(readline
)
2.2 Metoda chomp
2.3 Metoda to_i
2.4 Metoda to_f
Jak už je v Ruby zvykem, máme pro tyto účely
hned několik možností, a to v podobě příkazů puts
,
print
a printf
. Pojďme se na ně podívat
blíže.
puts
Nejzákladnějším a taky asi nejobvyklejším příkazem k vypsání textu na
obrazovku je puts
, a pokud jste byli pozorní, několikrát jsem
jej už použil v minulých dílech (3, 2, 1):
irb(main):001:0> puts "Ahoj, svete!" Ahoj, svete! => nil irb(main):002:0>
Jak vidíte, příkaz vypíše to, co je mu zadáno jako parametr, a odřádkuje. Jelikož se ve skutečnosti jedná o metodu (o metodách si budeme povídat zanedlouho a také zjistíme, že v Ruby jsou vlastně všechny příkazy metodami), lze jej zapsat i pro metody obvyklejším způsobem, tedy se závorkami:
irb(main):002:0> puts("Ahoj, svete!") Ahoj, svete! => nil irb(main):003:0>
Tento způsob zápisu se však v Ruby příliš nepoužívá.
Vypisovat lze hodnoty všech základních datových typů, kromě Hashe:
irb(main):003:0> puts "Ahoj" # String Ahoj => nil irb(main):004:0> puts 256 # Fixnum 256 => nil irb(main):005:0> puts 1_079_252_848 # Bignum 1079252848 => nil irb(main):006:0> puts -7.25 # Float -7.25 => nil irb(main):007:0> puts ['Prvni', 'Druhy', 'Treti'] Prvni Druhy Treti => nil irb(main):008:0>
Pochopitelně lze vypisovat i výrazy a proměnné:
irb(main):008:0> PI = 3.14 => 3.14 irb(main):009:0> puts PI 3.14 => nil irb(main):010:0> puts PI * 4**2 50.24 => nil irb(main):011:0> puts "Raz" + " a dva" Raz a dva => nil irb(main):012:0>
...a kupodivu i proměnnou typu Hash:
irb(main):012:0> udaje = { irb(main):013:1* "jmeno" => "Frantisek", irb(main):014:1* "prijmeni" => "Voprsalek" irb(main):015:1> } => {"jmeno"=>"Frantisek", "prijmeni"=>"Voprsalek"} irb(main):016:0> puts udaje jmenoFrantisekprijmeniVoprsalek => nil irb(main):017:0>
...jejíž výstup ovšem není příliš použitelný a jak vidno, chtělo by jej učesat.
Údajů můžeme k vypsání předat i více. Jako oddělovač poslouží čárka a každý se vypíše na nový řádek:
irb(main):017:0> puts "Prvni", "Druhy", "Treti" Prvni Druhy Treti => nil irb(main):018:0>
Vůbec nejobvyklejší (a taky nejpoužitelnější) je však kombinace výše uvedených možností:
irb(main):018:0> puts "Knock, knock, " + jmeno + "."*3 Knock, knock, Neo... => nil irb(main):019:0>
print
Příkaz print
je svým použitím puts
velmi
podobný a ve skutečnosti se odlišuje jen tím, že po vypsání požadovaných
údajů nepřejde sám od sebe na nový řádek:
irb(main):019:0> print "Kampak se nam zatoulal konec radku?" Kampak se nam zatoulal konec radku?=> nil irb(main):020:0>
Toto chování je neocenitelné v případě, že máme v plánu k textu později něco dopsat, ať už v cyklu, nebo na základě větvení programu (k tomu se také dostaneme). Odlišné je také chování při vypsání více údajů:
irb(main):020:0> print "Prvni", "Druhy", "Treti" PrvniDruhyTreti=> nil irb(main):021:0>
Na tomto místě by možná nebylo špatné ukázat si základní možnosti formátování textu, a to pomocí takzvaných escape sekvencí (tj. speciálních řídících znaků). Ty nám umožňují třeba vložit konec řádku ve kterékoli části řetězce, nebo použít tabulátor. Následující tabulka shrnuje ty nejběžnější:
sekvence: | význam: |
---|---|
\\ |
zpětné lomítko \ |
\' |
apostrof ' |
\" |
uvozovky " |
\b |
návrat o jeden znak |
\n |
přesun na další řádek |
\r |
přesun na začátek současného řádku |
\t |
tabulátor |
Použití některých z nich pak ilustruje následující příklad:
irb(main):021:0> print "Jmeno:\t\t", udaje["jmeno"], "\nprijmeni:\t", udaje["prijmeni"], "\n" Jmeno: Frantisek prijmeni: Voprsalek => nil irb(main):022:0>
Jak vidíte, s vhodným použitím escape sekvencí můžeme dosáhnout mnohem přehlednějších a hezčích výstupů.
printf
Escape sekvence jsou šikovná věc, nicméně můžeme se dostat do situace,
kdy zjistíme, že nám prostě nestačí - třeba v případě, že budeme chtít
zobrazovat údaje s přesností na určitý počet desetinných míst nebo je
zarovnat na určitou stranu. Právě k těmto účelům je nám k dispozici
příkaz printf
, který možnosti formátování značně rozšiřuje.
Použití je obdobné jako v jazyku C nebo Perl:
irb(main):022:0> printf "PI = %0.3f\n", 3.14159 PI = 3.142 => nil irb(main):023:0>
Co jsem to právě udělal? Prvním parametrem je řetězec obsahující
zástupné symboly, na jejichž místo jsou pak dosazovány hodnoty v dalších
parametrech. %0.3f
je zmíněná zástupná značka a udává,
v jakém formátu bude na její místo hodnota dosazena. Pojďme si ji nyní
rozebrat znak po znaku:
%
– označuje začátek zástupné značky0
– označuje šířku vypisovaného údaje v počtu
znaků; toto je vhodné např. při zarovnání do sloupců (viz dále),
přesahuje-li skutečná šířka tuto hodnotu, je údaj vypsán
kompletní.0
– označuje počet zobrazených desetinných míst;
jak je vidět z příkladu, dochází zde dokonce k zaokrouhlováníf
– označuje typ konverze, v tomto případě reálné
čísloNejpoužívanější druhy konverze shrnuje následující tabulka:
znak: | význam: |
b |
převod do binární soustavy |
c |
zadaná hodnota je převedena na příslušný znak dle tabulky ASCII |
d |
celé číslo |
e |
desetinné číslo v exponenciálním tvaru |
E |
shodné s e , jen exponent je označován velkým
znakem E |
f |
reálné číslo |
o |
převod do osmičkové soustavy |
s |
řetězec |
x |
převod do šestnáctkové soustavy |
X |
shodné s x , jen velkými písmeny |
Pojďmě si některé z nich ukázat:
irb(main):023:0> printf "%b", 42 101010=> nil irb(main):024:0> printf "#97 => '%c'", 97 #97 => 'a'=> nil irb(main):025:0> printf "%0.3e", 1_079_252_848 1.079e+09=> nil irb(main):026:0> r=255;g=128;b=64 => 64 irb(main):027:0> printf "rgb(%d,%d,%d) --> #%x%x%x", r, g, b, r, g, b rgb(255,128,64) --> #ff8040=> nil irb(main):028:0> printf "Hello, %s. How are you?", ENV["USER"] Hello, blackened. How are you?=> nil irb(main):029:0> irb(main):016:0> printf "%7.2f\n%7.2f\n%7.2f\n", 3.14, 9.8, 20.645 3.14 9.80 20.64 => nil irb(main):030:0>
Další často používanou vlastností je nechat vyplnit mezery zleva nulami:
irb(main):030:0> printf "%07.2f\n%07.2f\n%07.2f\n", 3.14, 9.8, 20.645 0003.14 0009.80 0020.64 => nil irb(main):031:0>
Možností formátování je pochopitelně mnohem víc, popisovat je všechny však přesahuje záběr tohoto seriálu. Neměl by však být problém si je dohledat v dokumentaci, velice dobře je tato problematika vysvětlena také v prvním dílu Učebnice jazyka C autora Pavla Herouta.
gets
(readline
)Může se stát, že ve svém programu budete potřebovat za běhu přijmout
údaje od uživatele. K tomuto účelu lze využít příkazu gets
(eventuálně readline
– jejich chování je totožné),
který ze standardního vstupu přečte řetězec znaků, ukončený znakem konce
řádku (tedy vše až do stisku klávesy Enter):
irb(main):031:0> jmeno = gets Jaromir => "Jaromir\n" irb(main):032:0> puts "Good evening, #{jmeno}." Good evening, Jaromir . => nil irb(main):033:0>
Takto získaný vstup má však několik nedostatků – řetězec je uložen včetně znaku nového řádku (všimněte si tečky v příkladu), druhý nedostatek pak spočívá v tom, že uložená hodnota je vždy typu String bez ohledu na to, zadáme-li třeba číslo.
chomp
První nedostatek elegantně řeší metoda chomp
, která
z řetězce odstraní poslední znak, jedná-li se o znak konce řádku
(v unixových systémech je to '\n'
, v Microsoft Windows pak
'\r\n'
):
irb(main):033:0> jmeno => "Jaromir\n" irb(main):034:0> jmeno.chomp => "Jaromir" irb(main):035:0> "Jaromir\r\n".chomp => "Jaromir" irb(main):036:0>
Jak vidíme, v případě kombinace znaků '\r\n'
dojde
k odstranění obou. Tak je zaručena přenositelnot našeho programu na jinou
platformu bez nutnosti dodatečných úprav zdrojového kódu. Tyto znaky však
musí být přesně v tomto pořadí; při jejich prohození dojde k odstranění
pouze posledního z nich:
irb(main):036:0> "Jaromir\n\r".chomp => "Jaromir\n" irb(main):037:0>
Metodu chomp
lze pochopitelně aplikovat přímo při čtení
ze vstupu:
irb(main):036:0> jmeno = gets.chomp Jaromir => "Jaromir" irb(main):037:0>
Jen pro úplnost, existuje také příslušná alternativa s vykřičníkem,
tedy chomp!
to_i
Říkal jsem, že příkazy gets
a readline
přijímají hodnotu typu String. Ale co když potřebujeme pracovat
s číselnými hodnotami?
K převodu proměnné typu String na celočíselný typ (Fixnum, Bignum)
slouží metoda to_i
:
irb(main):037:0> "18".to_i => 18 irb(main):038:0> "18:40".to_i => 18 irb(main):039:0> "18 hodin 40 minut".to_i => 18 irb(main):040:0> "Je prave 18 hodin.".to_i => 0 irb(main):041:0> "-13.27".to_i => -13 irb(main):042:0>
Tato metoda hledá na začátku řetězce celočíselnou hodnotu. Pokud ji najde, vrátí příslušné číslo, přičemž jakékoli další znaky ignoruje. Nenajde-li ji, vrátí hodnotu 0. Čtení celočíselné hodnoty pak může vypadat třeba takto:
irb(main):042:0> n = gets.to_i 4 => 4 irb(main):043:0> puts 2**n 16 => nil irb(main):044:0>
to_f
Stejně jako to_i
pro celá, slouží metoda to_f
k převodu řetězce na reálné číslo:
irb(main):044:0> "3.14159".to_f => 3.14159 irb(main):045:0> "2e-3".to_f => 0.002 irb(main):046:0> "37.6°C".to_f => 37.6 irb(main):047:0> "PI=3.14".to_f => 0.0 irb(main):048:0>
Čtení reálného čísla pak může vypadat třeba takto:
irb(main):048:0> polomer = gets.to_f 12.7 => 12.7 irb(main):049:0> printf "prumer = %0.2f\n", polomer * 2 prumer = 25.40 => nil irb(main):050:0>
V příštím díle se podíváme na řídící struktury v Ruby.
Nástroje: Tisk bez diskuse
Tiskni Sdílej:
irb(main):011:0> b = { :a => "prvni", :b => "druhy" } => {:b=>"druhy", :a=>"prvni"} irb(main):012:0> p b {:b=>"druhy", :a=>"prvni"} => nil
irb(main):001:0> require 'yaml' => true irb(main):002:0> b = { 'a' => "prvni", 'b' => { 'b1' => 'vnoreny1', 'b2'=>'vnoreny2' } } => {"a"=>"prvni", "b"=>{"b1"=>"vnoreny1", "b2"=>"vnoreny2"}} irb(main):003:0> str = b.to_yaml => "a: prvni\nb: \n b1: vnoreny1\n b2: vnoreny2\n" irb(main):004:0> puts str a: prvni b: b1: vnoreny1 b2: vnoreny2 => nilMetoda "y" se chová obdobně jako "p":
irb(main):005:0> y b a: prvni b: b1: vnoreny1 b2: vnoreny2 => nilDeserializace se provede takto:
irb(main):006:0> b2 = YAML::load( str ) => {"a"=>"prvni", "b"=>{"b1"=>"vnoreny1", "b2"=>"vnoreny2"}}