diff options
Diffstat (limited to 'sk-sk/elixir.html.markdown')
| -rw-r--r-- | sk-sk/elixir.html.markdown | 470 |
1 files changed, 0 insertions, 470 deletions
diff --git a/sk-sk/elixir.html.markdown b/sk-sk/elixir.html.markdown deleted file mode 100644 index 2401f92e..00000000 --- a/sk-sk/elixir.html.markdown +++ /dev/null @@ -1,470 +0,0 @@ ---- -language: elixir -contributors: - - ["Joao Marques", "http://github.com/mrshankly"] - - ["Dzianis Dashkevich", "https://github.com/dskecse"] - - ["Ryan Plant", "https://github.com/ryanplant-au"] -translators: - - ["Peter Szatmary", "https://github.com/peterszatmary"] -lang: sk-sk -filename: learnelixir-sk.ex ---- - -Elixir je moderný funkcionálny jazyk vytvorený nad Erlang VM (virtuálnym -strojom). Je plne kompatibilný s Erlangom, ale ponúka viac štandardnú syntax -a množstvo funkcií. - -```Elixir - -# Jednoriadkový komentár začína symbolom # - -# Neexistuje viacriadkový komentár, avšak je možné vyskladať za sebou viac -# jednoriadkových komentárov. - -# Pre spustenie Elixir shellu zadajte príkaz `iex` -# Kompiláciu zdrojových kódov vykonáte príkazom `elixirc` - -# Obe príkazy by sa už mali nachádzať v path pokiaľ ste nainštalovali elixir -# správne. - -## --------------------------- -## -- Základné typy -## --------------------------- - -# Čísla -3 # integer -0x1F # integer -3.0 # float - -# Atómy, sú literály, konštanty s rovnakým menom. Začínajú s `:`. -:ahoj # atom - -# Tzv. Tuples sú v pamäti uložené súvisle. -{1,2,3} # tuple - -# Pristúpiť k tuple elementu vieme pomocou funkcie `elem`: -elem({1, 2, 3}, 0) #=> 1 - -# Zoznamy sú implementované ako linkované zoznamy. -[1,2,3] # zoznam - -# Vieme pristúpiť k hlavičke (head) a chvostu (tail) zoznamu: -[head | tail] = [1,2,3] -head #=> 1 -tail #=> [2,3] - -# V Elixire, rovnako ako v Erlangu, `=` znamená pattern matching a nie -# klasické priradenie. -# -# To znamená, že ľavá strana (pattern / vzor) je postavená oproti pravej -# strane. -# -# Takto funguje aj príklad vyššie s čítaním hlavičky a chvosta zoznamu. - -# Pattern match končí chybou ak sa obe strany nezhodujú, v tomto príklade majú -# tuples rôznu veľkosť. -# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2} - -# Binárne typy -<<1,2,3>> # binary - -# Reťazce a zoznamy znakov -"ahoj" # reťazec -'ahoj' # zoznam znakov - -# Viacriadkový reťazec -""" -Ja som viacriadkový -reťazec. -""" -#=> "Ja som viacriadkový\nreťazec.\n" - -# Reťazce sú kódované v UTF-8: -"héllò" #=> "héllò" - -# Reťazce sú skutočne iba binárne typy, a zoznamy znakov sú iba zoznamy. -<<?a, ?b, ?c>> #=> "abc" -[?a, ?b, ?c] #=> 'abc' - -# `?a` v elixire vráti ASCII číselnú reprezentáciu pre znak `a` -?a #=> 97 - -# Pre spájanie zoznamov sa používa `++`, pre binárne typy `<>` -[1,2,3] ++ [4,5] #=> [1,2,3,4,5] -'ahoj ' ++ 'svet' #=> 'ahoj svet' - -<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>> -"Ahoj " <> "svet" #=> "ahoj svet" - -# Rozsahy sú reprezentované ako `začiatok..koniec` (obe inkluzívne) -1..10 #=> 1..10 -dolna..horna = 1..10 # Na rozsahy možno použiť rovnako pattern matching -[dolna, horna] #=> [1, 10] - -# Mapy sú páry kľúč-hodnota -pohlavia = %{"david" => "muž", "gillian" => "žena"} -pohlavia["david"] #=> "muž" - -# Mapy s kľúčmi reprezentovanými atómami môžu byť použité takto -pohlavia = %{david: "muž", gillian: "žena"} -pohlavia.gillian #=> "žena" - -## --------------------------- -## -- Operátory -## --------------------------- - -# Trošku matematiky -1 + 1 #=> 2 -10 - 5 #=> 5 -5 * 2 #=> 10 -10 / 2 #=> 5.0 - -# V elixire operátor `/` vždy vráti float (reálne číslo). - -# Pre celočíselné delenie sa používa `div` -div(10, 2) #=> 5 - -# Pre celočíselné delenie so zvyškom `rem` -rem(10, 3) #=> 1 - -# Boolean operátory: `or`, `and` a `not`. -# Tieto operátori očakávajú ako svoj prvý argument boolean. -true and true #=> true -false or true #=> true -# 1 and true #=> ** (ArgumentError) argument error - -# Elixir tiež poskytuje `||`, `&&` a `!` , ktoré akceptujú argumenty -# ľubovoľného typu. -# Všetky hodnoty okrem `false` a `nil` budú vyhodnotené ako true. -1 || true #=> 1 -false && 1 #=> false -nil && 20 #=> nil -!true #=> false - -# Pre porovnávanie máme: `==`, `!=`, `===`, `!==`, `<=`, -`>=`, `<` a `>` -1 == 1 #=> true -1 != 1 #=> false -1 < 2 #=> true - -# `===` a `!==` sú viac striktné pri porovnávaní celých čísel (integer) a -# desatinných čísel (float). -1 == 1.0 #=> true -1 === 1.0 #=> false - -# Vieme porovnať dokonca dva rôzne údajové typy: -1 < :ahoj #=> true - -# Celkové poradie triedenia: -# -# číslo < atom < referencia < funkcia < port < pid < tuple < zoznam < bitový -# string - -# Výrok Joe Armstronga: "Aktuálne poradie nie je dôležité, ale -# dôležité je to, že celkové poradie je dobre definované." - -## --------------------------- -## -- Riadenie toku -## --------------------------- - -# `if` výraz -if false do - "Toto nebude nikdy videné" -else - "Toto bude" -end - -# Existuje aj `unless` -unless true do - "Toto nebude nikdy videné" -else - "Toto bude" -end - -# Pamätáte sa na pattern matching? Mnoho štruktúr pre riadenie toku v -# elixire sa spoliehajú práve na pattern matching. - -# `case` dovolí nám porovnať hodnotu oproti mnohým vzorom: -case {:one, :two} do - {:four, :five} -> - "Toto nebude zhodné" - {:one, x} -> - "Toto bude zhodné a nastaví `x` na hodnotu `:two` " - _ -> - "Toto bude zhodné z ľubovoľnou hodnotou." -end - -# Je zvyčajné nastaviť hodnotu do `_` ak ju nepotrebujete. -# Napríklad, ak je pre nás potrebná iba hlavička zoznamu (head): -[head | _] = [1,2,3] -head #=> 1 - -# Pre lepšiu čitateľnosť môžme urobiť nasledovné: -[head | _tail] = [:a, :b, :c] -head #=> :a - -# `cond` dovoľuje kontrolovať viac podmienok naraz. -# Použite `cond` namiesto vnorovania mnohých `if` výrazov. -cond do - 1 + 1 == 3 -> - "Nebudem nikdy videný" - 2 * 5 == 12 -> - "Ani ja" - 1 + 2 == 3 -> - "Ja budem" -end - -# Je bežné nastaviť poslednú podmienku rovnajúcu sa `true` , ktorá bude vždy -# zodpovedať. -cond do - 1 + 1 == 3 -> - "Nebudem nikdy videný" - 2 * 5 == 12 -> - "Ani ja" - true -> - "Ale ja budem (je to v podstate vetva else)" -end - -# `try/catch` sa používa na zachytenie hodnôt, ktoré boli vyhodené, takisto -# podporuje `after` klauzulu, ktorá je zavolaná vždy, či bola hodnota -# zachytená alebo nie. -try do - throw(:ahoj) -catch - message -> "Mám #{message}." -after - IO.puts("Som after klauzula.") -end -#=> Som after klauzula -# "Mám :ahoj" - -## --------------------------- -## -- Moduly a funkcie -## --------------------------- - -# Anonymné funkcie (všimnite si bodku) -stvorec = fn(x) -> x * x end -stvorec.(5) #=> 25 - -# Takisto akceptujú viax klauzúl a tzv. stráže (guards). -# Stráže vám umožnia pattern matching ešte viac zlepšiť, tieto časti sú -# označené kľúčovým slovom `when`: -f = fn - x, y when x > 0 -> x + y - x, y -> x * y -end - -f.(1, 3) #=> 4 -f.(-1, 3) #=> -3 - -# Elixir tiež poskytuje množstvo vstavaných funkcií. -# Tie sú dostupné v aktuálnom scope (viditeľnej oblasti). -is_number(10) #=> true -is_list("hello") #=> false -elem({1,2,3}, 0) #=> 1 - -# Možno zgrupovať viac funkcií do jedného modulu. V module použite `def` -# na definíciu funkcie. -defmodule Matematika do - def sucet(a, b) do - a + b - end - - def na_druhu(x) do - x * x - end -end - -Matematika.sucet(1, 2) #=> 3 -Matematika.na_druhu(3) #=> 9 - -# Na zkompilovanie našeho Matematika modulu ho uložte ako `math.ex` a použite -# `elixirc` v termináli: elixirc math.ex - -# V module môžme definovať funkcie s `def` a privátne funkcie s `defp`. -# Funkcia definovaná s `def` je možné volať z iných modulov, privátne funkcie -# môžu byť volané iba lokálne. -defmodule SukromnaMatematika do - def sucet(a, b) do - rob_sucet(a, b) - end - - defp rob_sucet(a, b) do - a + b - end -end - -SukromnaMatematika.sucet(1, 2) #=> 3 -# SukromnaMatematika.rob_sucet(1, 2) #=> ** (UndefinedFunctionError) - -# Deklarácie funkcií tiež podporujú stráže (guards) a viacnásobné klauzuly: - -defmodule Geometria do - def oblast({:obdlznik, w, h}) do - w * h - end - - def oblast({:kruh, r}) when is_number(r) do - 3.14 * r * r - end -end - -Geometria.oblast({:obdlznik, 2, 3}) #=> 6 -Geometria.oblast({:kruh, 3}) #=> 28.25999999999999801048 -# Geometria.oblast({:kruh, "nie_je_cislo"}) -#=> ** (FunctionClauseError) no function clause matching in Geometria.oblast/1 - -# Vďaka nemeniteľnosti (immutability) je rekurzia významnou časťou elixiru -defmodule Rekurzia do - def sumuj_zoznam([hlavicka | schvost], acc) do - sumuj_zoznam(chvost, acc + hlavicka) - end - - def sumuj_zoznam([], acc) do - acc - end -end - -Rekurzia.sumuj_zoznam([1,2,3], 0) #=> 6 - -# Elixir moduly podporujú atribúty, existujú vstavané atribúty a takisto -# môžte pridávať vlastné. -defmodule MojModul do - @moduledoc """ - Toto je vstavaný atribút v príkladovom module. - """ - - @moj_udaj 100 # Toto je vlastný atribút. - IO.inspect(@moj_udaj) #=> 100 -end - -# Pipe operátor (rúra) |> umožnuje predať výsledok výrazu ako prvý parameter -# do ďalšej funkcie. - -Range.new(1,10) -|> Enum.map(fn x -> x * x end) -|> Enum.filter(fn x -> rem(x, 2) == 0 end) -#=> [4, 16, 36, 64, 100] - -## --------------------------- -## -- Štruktúry a výnimky -## --------------------------- - -# Štruktúry sú rozšírenia postavené na mapách, ktoré prinášajú defaultné -# hodnoty, garancie v čase kompilácie a polymorfizmus do Elixiru. -defmodule Osoba do - defstruct meno: nil, vek: 0, vyska: 0 -end - -joe_info = %Osoba{ meno: "Joe", vek: 30, vyska: 180 } -#=> %Osoba{vek: 30, vyska: 180, meno: "Joe"} - -# Prístup k hodnote mena -joe_info.meno #=> "Joe" - -# Zmena hodnoty veku -starsi_joe_info = %{ joe_info | vek: 31 } -#=> %Osoba{vek: 31, vyska: 180, meno: "Joe"} - -# `try` blok s kľúčovým slovom `rescue` sa používa na riadenie výnimiek -try do - raise "nejaký error" -rescue - RuntimeError -> "zachytí runtime error" - _error -> "zachytí ľubovoľný iný error" -end -#=> "zachytí runtime error" - -# Každá výnimka má správu -try do - raise "nejaký error" -rescue - x in [RuntimeError] -> - x.message -end -#=> "nejaký error" - -## --------------------------- -## -- Konkurencia -## --------------------------- - -# Elixir sa pri konkurencii spolieha na Actor model. Všetko čo je -# potrebné na písanie konkuretných programov v elixire sú tri primitívy: -# spawning procesy, posielanie a prijímanie správ. - -# Na spustnenie nového procesu použijeme `spawn` funkciu, ktorá má ako -# parameter funkciu. -f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245> -spawn(f) #=> #PID<0.40.0> - -# `spawn` vracia pid (identifikátor procesu), tento pid možno použiť na -# posielanie správ procesu. Správu pošleme `send` operatorátorom. -# Aby všetko fungovalo ako má, potrebujeme byť schopný správu prijať. To -# dosiahneme s `receive` mechanizmom: - -# `receive do` blok sa používa na počúvanie správ a ich spracúvavanie v čase -# prijatia. `receive do` blok spracuje iba jednu prijatú správu. Pre -# spracovanie viacerých správ, musí funkcia s `receive do` blokom rekurzívne -# volať samu seba, aby sa dostala opäť do `receive do` bloku. - -defmodule Geometria do - def slucka_oblasti do - receive do - {:obdlznik, w, h} -> - IO.puts("Oblast = #{w * h}") - slucka_oblasti() - {:kruh, r} -> - IO.puts("Oblast = #{3.14 * r * r}") - slucka_oblasti() - end - end -end - -# Kompiluj modul a vytvor proces, ktorý vyhodnotí `slucka_oblasti` v shelli - -pid = spawn(fn -> Geometria.slucka_oblasti() end) #=> #PID<0.40.0> -# Alternatívne -pid = spawn(Geometria, :slucka_oblasti, []) - -# Pošli správu ku `pid`, ktorá bude v zhode so vzorom v receive časti -send pid, {:obdlznik, 2, 3} -#=> Oblast = 6 -# {:obdlznik,2,3} - -send pid, {:kruh, 2} -#=> Oblast = 12.56000000000000049738 -# {:kruh,2} - -# Shell je takisto proces, môžete použiť `self` pre zistenie aktuálneho pid-u -self() #=> #PID<0.27.0> - -## --------------------------- -## -- Agenti -## --------------------------- - -# Agent je proces, ktorý udržuje informácie o meniacej sa hodnote - -# Vytvor agenta s `Agent.start_link` parametrom, ktorého je funkcia -# Iniciálny stav agenta bude čokoľvek, čo daná funkcia vráti -{ok, moj_agent} = Agent.start_link(fn -> ["cervena, zelena"] end) - -# `Agent.get` vezme meno agenta a `fn` , ktorej je odovzdaný aktuálny stav -# Čokoľvek čo `fn` vráti je to, čo dostanete späť -Agent.get(moj_agent, fn farby -> farby end) #=> ["cervena, "zelena"] - -# Zmena stavu agenta rovnakým spôsobom -Agent.update(moj_agent, fn farby -> ["modra" | farby] end) -``` - -## Referencie - -* [Začíname](http://elixir-lang.org/getting-started/introduction.html) z -[Elixir stránky](http://elixir-lang.org) -* [Elixir dokumentácia](http://elixir-lang.org/docs/master/) -* [Elixir programovanie](https://pragprog.com/book/elixir/programming-elixir) - od Dave Thomasa -* [Elixir ťahák](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) -* [Nauč sa kúsok Erlangu pre veľké dobro!](http://learnyousomeerlang.com/) od -Freda Heberta -* [Erlang programovanie: Softvér pre konkurentný svet](https://pragprog -.com/book/jaerlang2/programming-erlang) od Joe Armstronga |