learnxinyminutes-docs/sk-sk/elixir-sk.html.markdown

---
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 Elixir 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 Elixir 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
# Elixir 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 Elixir
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 Elixir 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