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

471 lines
13 KiB
Elixir
Raw Normal View History

---
2023-04-27 20:09:38 +00:00
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
2016-10-30 23:34:51 +00:00
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í.
2024-04-03 11:16:08 +00:00
```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`
2023-04-27 20:09:38 +00:00
# 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'
2023-04-27 20:09:38 +00:00
# `?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
2023-04-27 20:09:38 +00:00
# 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
2023-04-27 20:09:38 +00:00
# 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
2016-11-05 15:10:14 +00:00
# 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
2016-11-05 15:10:14 +00:00
Geometria.oblast({:kruh, 3}) #=> 28.25999999999999801048
# Geometria.oblast({:kruh, "nie_je_cislo"})
#=> ** (FunctionClauseError) no function clause matching in Geometria.oblast/1
2023-04-27 20:09:38 +00:00
# Vďaka nemeniteľnosti (immutability) je rekurzia významnou časťou Elixir
2016-11-05 15:10:14 +00:00
defmodule Rekurzia do
def sumuj_zoznam([hlavicka | schvost], acc) do
sumuj_zoznam(chvost, acc + hlavicka)
end
def sumuj_zoznam([], acc) do
acc
end
end
2016-11-05 15:10:14 +00:00
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
2023-04-27 20:09:38 +00:00
# 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
2016-11-05 15:10:14 +00:00
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
2016-11-05 15:10:14 +00:00
* [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/)
2016-11-05 15:10:14 +00:00
* [Elixir programovanie](https://pragprog.com/book/elixir/programming-elixir)
od Dave Thomasa
* [Elixir ťahák](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
2016-11-05 15:10:14 +00:00
* [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