From cc9d2ca4a1691fd1af9527774dc72f441582d661 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juraj=20Kostolansk=C3=BD?= Date: Thu, 16 Jun 2016 15:03:19 +0200 Subject: [coffeescript/sk] Slovak translation for CoffeeScript (#1811) --- sk-sk/coffeescript.html.markdown | 108 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 sk-sk/coffeescript.html.markdown (limited to 'sk-sk') diff --git a/sk-sk/coffeescript.html.markdown b/sk-sk/coffeescript.html.markdown new file mode 100644 index 00000000..e716abed --- /dev/null +++ b/sk-sk/coffeescript.html.markdown @@ -0,0 +1,108 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +translators: + - ["Juraj Kostolanský", "http://www.kostolansky.sk"] +lang: sk-sk +filename: coffeescript.coffee +--- + +CoffeeScript je jazyk, ktorý sa kompiluje do ekvivalentného JavaScriptu, +neexistuje peňho interpretácia počas behu programu (runtime). +CoffeeScript sa snaží vytvárať čitateľný, pekne formátovaný a optimalizovaný +JavaScriptový kód pracujúci pod každým JavaScriptovým prostredím. + +Pozri tiež [stránku CoffeeScript](http://coffeescript.org/), ktoré obsahuje kompletný tutoriál o CoffeeScripte. + +```coffeescript +# CoffeeScript je jazyk hipsterov. +# Ide s trendom mnohých moderných jazykov. +# Komentáre sú podobné tým v Ruby a Pythone, používajú symbol #. + +### +Blokové komentáre vyzerajú takto, prekladajú sa priamo do '/ * ... * /' +pre výsledný kód JavaScriptu. + +Predtým, než budeš pokračovať, mal by si rozumieť sémantike JavaScriptu. +### + +# Priradenia: +cislo = 42 #=> var cislo = 42; +opak = true #=> var opak = true; + +# Podmienky: +cislo = -42 if opak #=> if(opak) { cislo = -42; } + +# Funkcie: +stvorec = (x) -> x * x #=> var stvorec = function(x) { return x * x; } + +vypln = (nadoba, tekutina = "káva") -> + "#{nadoba} sa napĺňa tekutinou #{tekutina}..." +#=>var vypln; +# +#vypln = function(nadoba, tekutina) { +# if (tekutina == null) { +# tekutina = "káva"; +# } +# return nadoba + " sa napĺňa tekutinou " + tekutina + "..."; +#}; + +# Rozsahy: +zoznam = [1..5] #=> var zoznam = [1, 2, 3, 4, 5]; + +# Objekty: +matika = + zaklad: Math.sqrt + stvorec: square + kocka: (x) -> x * square x +#=> var matika = { +# "zaklad": Math.sqrt, +# "stvorec": square, +# "kocka": function(x) { return x * square(x); } +#} + +# Splat operátor: +zavod = (vitaz, bezci...) -> + print vitaz, bezci +#=>zavod = function() { +# var vitaz, bezci; +# vitaz = arguments[0], +# bezci = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(vitaz, bezci); +#}; + +# Existencia: +alert "Vedel som to!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) +# { alert("Vedel som to!"); } + +# Pole: +kocky = (matika.kocka cislo for cislo in zoznam) +#=>kocky = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = zoznam.length; _i < _len; _i++) { +# cislo = zoznam[_i]; +# _results.push(matika.kocka(cislo)); +# } +# return _results; +# })(); + +jedla = ['brokolica', 'špenát', 'čokoláda'] +zjedz jedlo for jedlo in jedla when jedlo isnt 'čokoláda' +#=>jedla = ['brokolica', 'špenát', 'čokoláda']; +# +#for (_k = 0, _len2 = jedla.length; _k < _len2; _k++) { +# jedlo = jedla[_k]; +# if (jedlo !== 'čokoláda') { +# zjedz(jedlo); +# } +#} +``` + +## Ďalšie zdroje + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) -- cgit v1.2.3 From 84260a4cda5e15cf79da08b74831767fb4cca51c Mon Sep 17 00:00:00 2001 From: ven Date: Thu, 16 Jun 2016 15:03:46 +0200 Subject: Add filename to fix #1811 --- sk-sk/coffeescript.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sk-sk') diff --git a/sk-sk/coffeescript.html.markdown b/sk-sk/coffeescript.html.markdown index e716abed..30bbceec 100644 --- a/sk-sk/coffeescript.html.markdown +++ b/sk-sk/coffeescript.html.markdown @@ -6,7 +6,7 @@ contributors: translators: - ["Juraj Kostolanský", "http://www.kostolansky.sk"] lang: sk-sk -filename: coffeescript.coffee +filename: coffeescript-fr.coffee --- CoffeeScript je jazyk, ktorý sa kompiluje do ekvivalentného JavaScriptu, -- cgit v1.2.3 From 114387de05f459d558b05580b893fb45b8ccf89a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juraj=20Kostolansk=C3=BD?= Date: Thu, 16 Jun 2016 15:09:07 +0200 Subject: [json/sk] Slovak translation for JSON (#1812) --- sk-sk/json.html.markdown | 61 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 sk-sk/json.html.markdown (limited to 'sk-sk') diff --git a/sk-sk/json.html.markdown b/sk-sk/json.html.markdown new file mode 100644 index 00000000..b5cee796 --- /dev/null +++ b/sk-sk/json.html.markdown @@ -0,0 +1,61 @@ +--- +language: json +filename: learnjson.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Juraj Kostolanský", "http://www.kostolansky.sk"] +lang: sk-sk +--- + +Nakoľko je JSON extrémne jednoduchý formát na výmenu dát, toto bude +pravdepodobne najjednoduchšie "Learn X in Y Minutes". + +JSON v jeho základnej forme nemá komentáre, ale veľa parserov akceptuje +komentáre v štýle C (`//`, `/* */`). V tomto návode však bude všetko +100% valídny JSON. + +```json +{ + "kľúč": "hodnota", + + "kľúč": "musí byť vždy uzavretý v dvojitých uvodzovkách", + "čísla": 0, + "reťazce": "Ahøj, svet. Unicode je povolený pri použití \"únikovej sekvencie (escaping)\".", + "boolean?": true, + "nič": null, + + "veľké číslo": 1.2e+100, + + "objekty": { + "komentár": "Väčšina štruktúry bude pochádzať z objektov.", + + "pole": [0, 1, 2, 3, "Pole môže obsahovať čokoľvek.", 5], + + "iný objekt": { + "komentár": "Môžu byť vhniezdené, čo môže byť užitočné." + } + }, + + "nezmysly": [ + { + "zdroje draslíka": ["banány"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "alternatívny štýl": { + "komentár": "sleduj toto!" + , "pozícia čiarky": "nezáleží na nej - pokiaľ je pred hodnotou, všetko je ok" + , "iný komentár": "pekné, že?" + }, + + "to bolo rýchle": "A už sme aj na konci. Teraz ovládš všetko, čo ti JSON môže ponúknuť." +} +``` -- cgit v1.2.3 From d82da8357c526a738b7bfda3d44f2e34c423ea7d Mon Sep 17 00:00:00 2001 From: ven Date: Thu, 16 Jun 2016 15:09:37 +0200 Subject: Fix filename for #1812 --- sk-sk/json.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sk-sk') diff --git a/sk-sk/json.html.markdown b/sk-sk/json.html.markdown index b5cee796..2b1fbb58 100644 --- a/sk-sk/json.html.markdown +++ b/sk-sk/json.html.markdown @@ -1,6 +1,6 @@ --- language: json -filename: learnjson.json +filename: learnjson-sk.json contributors: - ["Anna Harren", "https://github.com/iirelu"] - ["Marco Scannadinari", "https://github.com/marcoms"] -- cgit v1.2.3 From 6419fa49074df3b24e8225f457cb462aededcc01 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juraj=20Kostolansk=C3=BD?= Date: Sun, 26 Jun 2016 15:32:29 +0200 Subject: [bash/sk] Slovak translation for Bash (#1517) --- sk-sk/bash.html.markdown | 286 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 286 insertions(+) create mode 100644 sk-sk/bash.html.markdown (limited to 'sk-sk') diff --git a/sk-sk/bash.html.markdown b/sk-sk/bash.html.markdown new file mode 100644 index 00000000..ba67b699 --- /dev/null +++ b/sk-sk/bash.html.markdown @@ -0,0 +1,286 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] + - ["Etan Reisner", "https://github.com/deryni"] +translators: + - ["Juraj Kostolanský", "http://www.kostolansky.sk"] +lang: sk-sk +filename: LearnBash.sh +--- + +Bash je pomenovanie pre unix shell (príkazový interpreter), ktorý bol +tiež distribuovaný ako shell pre GNU operačné systémy a ako predvolený +shell pre Linux a Mac OS X. +Takmer všetky príklady uvedené nižšie môžu byť súčasťou shell skriptu alebo +vykonané priamo v shelli. + +[Viac informácií tu.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# Prvý riadok skriptu je tzv. shebang, ktorý systému povie ako skript vykonať: +# http://en.wikipedia.org/wiki/Shebang_(Unix) +# Komentáre začínajú znakom #. Shebang je tiež komentár. + +# Jednoduchý príklad: +echo Ahoj svet! + +# Každý príkaz začína na novom riadku alebo za bodkočiarkou: +echo 'Toto je prvý riadok'; echo 'Toto je druhý riadok' + +# Deklarácia premenných vyzerá takto: +Premenna="Nejaky retazec" + +# Ale nie takto: +Premenna = "Nejaky retazec" +# Bash si bude myslieť, že Premenna je príkaz, ktorý musí vykonať. +# Výsledkom bude chyba, pretože taký príkaz nenájde. + +# Alebo takto: +Premenna= 'Nejaky retazec' +# Bash zistí, že 'Nejaky retazec' je príkaz, ktorý musí vykonať. +# Výsledkom je opäť chyba, lebo taký príkaz neexistuje. + +# Používanie premenných: +echo $Premenna +echo "$Premenna" +echo '$Premenna' +# Keď je premenná použitá samostatne - priradenie, exportovanie a pod. - jej +# meno sa píše bez znaku $. Keď sa používa hodnota premennej, pred názov sa +# dáva znak $. Pozor však pri použití ' (apostrof), ktorý nenahradí premennú +# hodnotou! + +# Nahradenie reťazca v premennej +echo ${Premenna/Nieco/A} +# Toto nahradí prvý výskyt reťazca "Nieco" za "A" + +# Podreťazec z premennej +Dlzka=7 +echo ${Premenna:0:Dlzka} +# Toto vráti iba prvých 7 znakov z hodnoty premennej + +# Predvolená hodnota premennej +echo ${Foo:-"PredvolenaHodnotaAkFooChybaAleboJePrazdna"} +# Toto funguje pre null (Foo=) a prázdny reťazec (Foo=""); +# nula (Foo=0) vráti 0. Všimni si, že toto iba vráti predvolenú hodnotu, +# ale nezmení hodnotu premennej. + +# Štandardné premenné: +# Existujú aj užitočné "vstavané" premenné, ako +echo "Hodnota vrátená posledným programom: $?" +echo "PID skriptu: $$" +echo "Počet argumentov: $#" +echo "Argumeny skriptu: $@" +echo "Argumeny skriptu oddelené do rôznych premenných: $1 $2..." + +# Čítanie hodnoty zo vstupu: +echo "Ako sa voláš?" +read Meno # Premenná nemusí byť deklarovaná skôr +echo Ahoj, $Meno! + +# Klasická if štruktúra: +# použi 'man test' Pre viac informácií o podmienkach +if [ $Meno -ne $USER ] +then + echo "Meno nie je tvoje používateľské meno" +else + echo "Meno je tvoje používateľské meno" +fi + +# Existuje aj podmienené vykonanie +echo "Vykonané vždy" || echo "Vykonané iba ak prvý príkaz zlyhá" +echo "Vykonané vždy" && echo "Vykonané iba ak prvý príkaz uspeje" + +# Pre použitie && a || s if-podmienkou je potrebné použiť zátvorky: +if [ $Meno == "Steve" ] && [ $Vek -eq 15 ] +then + echo "Toto sa spustí ak $Meno je Steve a $Vek je 15." +fi + +if [ $Meno == "Daniya" ] || [ $Meno == "Zach" ] +then + echo "Toto sa spustí ak $Meno je Daniya alebo Zach." +fi + +# Pre výrazy sa používa nasledovný formát: +echo $(( 10 + 5 )) + +# Na rozdiel od programovacích jazykov shell pracuje v kontexte aktuálneho +# adresára. Môžeš si prehliadať súbory a adresáre v aktuálnom adresári pomocou +# príkazu ls: +ls + +# Tieto príkazy majú aj argumenty pre úpravu ich správania: +ls -l # Vypíše zoznam súborov a priečinkov, každý na samostatnom riadku + +# Výsledok predchádzajúceho príkazu môže byť využitý priamo ako vstup pre +# ďalší príkaz. +# Príkaz grep filtruje vstupvyužitím poskytnutého vzoru. Takto môžeme vypísať +# iba .txt súbory: +ls -l | grep "\.txt" + +# Vstup a výstup príkazu (stdin, stdout, stderr) môžu byť presmerované. +# Toto číta stdin až po ^EOF$ a prepíše hello.py riadkami medzi "EOF": +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ import print_function +import sys +print("#stdout", file=sys.stdout) +print("#stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# Spustí hello.py s rôznymi presmerovaniami pre stdin, stdout a stderr: +python hello.py < "vstup.in" +python hello.py > "vystup.out" +python hello.py 2> "chyby.err" +python hello.py > "vystup-a-chyby.log" 2>&1 +python hello.py > /dev/null 2>&1 +# Chybový výstup prepíše uvedený súbor, ak už existuje. +# Ak chceš výstup pridať za existujúci obsah, použi ">>": +python hello.py >> "vystup.out" 2>> "chyby.err" + +# Prepíše vystup.out, pripojí k chyby.err a spočíta riadky: +info bash 'Basic Shell Features' 'Redirections' > vystup.out 2>> chyby.err +wc -l vystup.out chyby.err + +# Spustí príkaz a vypíše deskriptor súboru (napr. /dev/fd/123) +# pozri: man fd +echo <(echo "#ahojsvet") + +# Prepíše vystup.out s "#ahojsvet": +cat > vystup.out <(echo "#ahojsvet") +echo "#ahojsvet" > vystup.out +echo "#ahojsvet" | cat > vystup.out +echo "#ahojsvet" | tee vystup.out >/dev/null + +# Potichu odstráni dočasné súbory (pridaj '-i' pre interaktivitu) +rm -v vystup.out chyby.err vystup-a-chyby.log + +# Príkazy môžu byť nahradené v iných príkazoch použitím $( ): +# Nasledujúci príkaz vypíše počet súborov a adresárov v aktuálnom adresári +echo "Je tu $(ls | wc -l) súborov a priečinkov." + +# To isté sa dá spraviť pomocou spätného apostrofu ``, tie však nemôžu byť +# vhniezdené - preferovaný spôsob je preto $( ). +echo "Je tu `ls | wc -l` súborov a priečinkov." + +# Bash používa case, ktorý funguje podobne ako switch v Jave a C++: +case "$Premenna" in + #Zoznam vzorov pre podmienky + 0) echo "Je to nula.";; + 1) echo "Je to jednotka.";; + *) echo "Nie je to null.";; +esac + +# for-cyklus iteruje cez všetky argumenty: +# Obsah premennej $Premenna sa vypíše trikrát. +for Premenna in {1..3} +do + echo "$Premenna" +done + +# Alebo "tradičným" spôsobom: +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Môžu sa použiť aj na súbory.. +# Toto spustí príkaz 'cat' na subor1 a subor2 +for Premenna in subor1 subor2 +do + cat "$Premenna" +done + +# ..alebo na výstup príkazu. +# Toto použije príkaz cat na výstup z ls. +for Vystup in $(ls) +do + cat "$Vystup" +done + +# while-cykklus: +while [ true ] +do + echo "telo cyklu..." + break +done + +# Môžeš tiež definovať funkice +# Definícia: +function foo () +{ + echo "Argumenty fungujú rovnako ako pri skriptoch: $@" + echo "A: $1 $2..." + echo "Toto je funkcia" + return 0 +} + +# alebo jednoducho +bar () +{ + echo "Iný spôsob definície funkcií" + return 0 +} + +# Volanie funkcie +foo "Moje meno je" $Meno + +# Existuje veľa užitočných príkazov, ktoré sa oplatí naučiť: +# vypíše posledných 10 riadkov zo subor.txt +tail -n 10 subor.txt +# vypíše prvých 10 riadkov zo subor.txt +head -n 10 subor.txt +# zotriedi riadky zo subor.txt +sort subor.txt +# vypíše alebo vynechá opakované riadky, použitím -d ich vypíše +uniq -d subor.txt +# vypíše iba prvý stĺpecpred znakom ',' +cut -d ',' -f 1 subor.txt +# nahradí každý výskyt 'oukej' za 'super' v subor.txt (možnosť použiť regex) +sed -i 's/oukej/super/g' subor.txt +# vypíše všetky riadky zo subor.txt ktoré vyhovujú regexu +# ukážka vypíše riadky ktoré začínajú s "foo" a končia s "bar" +grep "^foo.*bar$" subor.txt +# pre výpis počtu riadkov vyhovujúcich regexu slúži "-c" +grep -c "^foo.*bar$" subor.txt +# pre vyhľadávanie reťazca bez regexu slúži fgrep (alebo grep -F) +fgrep "^foo.*bar$" subor.txt + + +# Prečítaj si dokumentáciu k Bash shellu použitím príkazu 'help': +help +help help +help for +help return +help source +help . + +# Prečítaj si Bash manpage dokumentáciu príkazom 'man' +apropos bash +man 1 bash +man bash + +# Prečítaj si info dokumentáciu pomocou 'info' (? pre help) +apropos info | grep '^info.*(' +man info +info info +info 5 info + +# Prečítaj si bash info dokumentáciu: +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` -- cgit v1.2.3 From 095d2e2405ced6a6e42b5f270d44a6ec6e9e3cb4 Mon Sep 17 00:00:00 2001 From: ven Date: Sun, 26 Jun 2016 15:32:45 +0200 Subject: #1517 --- sk-sk/bash.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sk-sk') diff --git a/sk-sk/bash.html.markdown b/sk-sk/bash.html.markdown index ba67b699..e9d1490c 100644 --- a/sk-sk/bash.html.markdown +++ b/sk-sk/bash.html.markdown @@ -14,7 +14,7 @@ contributors: translators: - ["Juraj Kostolanský", "http://www.kostolansky.sk"] lang: sk-sk -filename: LearnBash.sh +filename: LearnBash-sk.sh --- Bash je pomenovanie pre unix shell (príkazový interpreter), ktorý bol -- cgit v1.2.3 From e722b7c50d6568d1820ce4aee3b03ffb428f6196 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juraj=20Kostolansk=C3=BD?= Date: Fri, 16 Sep 2016 12:51:21 +0200 Subject: [ruby/sk] Slovak translation for Ruby (#1388) --- sk-sk/ruby.html.markdown | 553 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 553 insertions(+) create mode 100644 sk-sk/ruby.html.markdown (limited to 'sk-sk') diff --git a/sk-sk/ruby.html.markdown b/sk-sk/ruby.html.markdown new file mode 100644 index 00000000..ccf8afa7 --- /dev/null +++ b/sk-sk/ruby.html.markdown @@ -0,0 +1,553 @@ +--- +language: ruby +filename: learnruby.rb +contributors: + - ["David Underwood", "http://theflyingdeveloper.com"] + - ["Joel Walden", "http://joelwalden.net"] + - ["Luke Holder", "http://twitter.com/lukeholder"] + - ["Tristan Hume", "http://thume.ca/"] + - ["Nick LaMuro", "https://github.com/NickLaMuro"] + - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"] + - ["Ariel Krakowski", "http://www.learneroo.com"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] + - ["Levi Bostian", "https://github.com/levibostian"] + - ["Rahil Momin", "https://github.com/iamrahil"] +translators: + - ["Juraj Kostolanský", "http://www.kostolansky.sk"] +lang: sk-sk +--- + +```ruby +# Toto je komentár + +=begin +Toto je viacriadkový komentár +Nikto ho nepoužíva +Ani ty by si nemal +=end + +# V prvom rade: Všetko je objekt. + +# Čísla sú objekty + +3.class #=> Fixnum + +3.to_s #=> "3" + + +# Základná aritmetika +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 +2**5 #=> 32 + +# Aritmetika je iba syntaktickým cukrom +# pre volanie metódy nad objektom +1.+(3) #=> 4 +10.* 5 #=> 50 + +# Špeciálne hodnoty sú objektami +nil # nič +true # pravda +false # lož + +nil.class #=> NilClass +true.class #=> TrueClass +false.class #=> FalseClass + +# Rovnosť +1 == 1 #=> true +2 == 1 #=> false + +# Nerovnosť +1 != 1 #=> false +2 != 1 #=> true + +# Okrem samotného false, nil je jedinou ďalšou 'nepravdivou' hodnotou + +!nil #=> true +!false #=> true +!0 #=> false + +# Ďalšie porovnania +1 < 10 #=> true +1 > 10 #=> false +2 <= 2 #=> true +2 >= 2 #=> true + +# Logické operácie +true && false #=> false +true || false #=> true +!true #=> false + +# Existujú aj alternatívne verzie logických operátorov s nižšou prioritou. +# Tie sa využívajú ako konštrukcie pre riadenie toku na reťazenie výrazov +# kým jeden z nich nevráti true alebo false. + +# `sprav_nieco_ine` sa vykoná ak bude `sprav_nieco` úspešné (vráti true) +sprav_nieco() and sprav_nieco_ine() +# `zaznamenaj_chybu` sa vykoná ak `sprav_nieco` neuspeje (vráti false) +sprav_nieco() or zaznamenaj_chybu() + + +# Reťazce sú objekty + +'Ja som reťazec'.class #=> String +"Ja som tiež reťazec".class #=> String + +retazec = 'použiť interpoláciu reťazca' +"Môžem #{retazec} pri použití dvojitých úvodzoviek" +#=> "Môžem použiť interpoláciu reťazca pri použití dvojitých úvodzoviek" + +# Preferuj jednoduché úvodzovky pred dvojitými, ak je to možné +# Dvojité úvodzovky totiž vyžadujú ďalšie výpočty + +# Kombinuj reťazce, ale nie s číslami +'ahoj ' + 'svet' #=> "ahoj svet" +'ahoj ' + 3 #=> TypeError: can't convert Fixnum into String +'ahoj ' + 3.to_s #=> "ahoj 3" + +# Výpis na štandardný výstup +puts "Píšem!" + + +# Premenné +x = 25 #=> 25 +x #=> 25 + +# Všimni si, že priradenie vracia priradenú hodnotu +# To umožňuje viacnásobné priradenie: + +x = y = 10 #=> 10 +x #=> 10 +y #=> 10 + +# Podľa konvencie sa pre mená premenných využíva snake_case +snake_case = true + +# Používaj správne (opisné) mená premenných +cesta_ku_korenovemu_adresaru = '/dobre/meno/' +cesta = '/zle/meno/' + + +# Symboly (sú objektami) +# Symboly sú nemenné znovupoužiteľné konštanty, ktoré sú interne +# reprezentované ako číslo. Často sa používajú namiesto reťazcov +# pre efektívnu reprezentáciu špecifickej hodnoty. + +:cakajuci.class #=> Symbol + +status = :cakajuci + +status == :cakajuci #=> true + +status == 'cakajuci' #=> false + +status == :schvaleny #=> false + + +# Polia + +# Toto je pole +pole = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] + +# Polia môžu obsahovať rôzne typy objektov + +[1, 'ahoj', false] #=> [1, "ahoj", false] + +# Polia môžu byť indexované +# Od začiatku +pole[0] #=> 1 +pole[12] #=> nil + +# Podobne ako pri aritmetike, prístup prostredníctvom [var] +# je iba syntaktickým cukrom pre volanie metódy [] nad objektom +pole.[] 0 #=> 1 +pole.[] 12 #=> nil + +# Od konca +pole[-1] #=> 5 + +# Pomocou počiatočného indexu a dĺžky +pole[2, 3] #=> [3, 4, 5] + +# Alebo rozsahom +pole[1..3] #=> [2, 3, 4] + +# Pridanie prvku do pola +pole << 6 #=> [1, 2, 3, 4, 5, 6] +# Alebo takto +pole.push(6) #=> [1, 2, 3, 4, 5, 6] + +# Skontroluje, či už je objekt v poli +pole.include?(1) #=> true + + +# Asociatívne polia (hash) sú slovníkmi s dvojicami kľúč-hodnota. +# Asociatívne polia sú označované kučeravými zátvorkami: +asoc_pole = { 'farba' => 'zelena', 'cislo' => 5 } + +asoc_pole.keys #=> ['farba', 'cislo'] + +# V asociatívnych poliach sa rýchlo vyhľadáva pomocou kľúča +asoc_pole['farba'] #=> 'zelena' +asoc_pole['cislo'] #=> 5 + +# Asking a hash for a key that doesn't exist returns nil: +asoc_pole['nic tu nie je'] #=> nil + +# Od verzie Ruby 1.9 existuje špeciálna syntax, +# pri ktorej sa využíva symbol ako kľúč + +nove_asoc_pole = { defcon: 3, akcia: true } +nove_asoc_pole.keys #=> [:defcon, :akcia] + +# Skontroluje existenciu kľúča a hodnoty v asociatívnom poli +nove_asoc_pole.has_key?(:defcon) #=> true +nove_asoc_pole.has_value?(3) #=> true + +# Tip: Polia aj asociatívne polia sú vypočítateľné (Enumerable) +# Zdieľajú veľa užitočných metód ako each, map, count a ďalšie + + +# Štruktúry riadenia + +if true + 'if podmienka' +elsif false + 'else if, voliteľná vetva' +else + 'else, tiež voliteľná vetva' +end + +for pocitadlo in 1..5 + puts "iterácia #{pocitadlo}" +end +#=> iterácia 1 +#=> iterácia 2 +#=> iterácia 3 +#=> iterácia 4 +#=> iterácia 5 + +# NIKTO však nepoužíva for cyklus +# Aj ty by si mal preferovať metódu "each" a podať jej blok +# Blok kus kódu, ktorý môžeš podať metódam ako "each" +# Je podobný lambdám alebo anonymným funkciám v iných jazykoch +# +# Metóda "each" pre rozsah spustí blokpre každý element tohto rozsahu +# Blok získava počítadlo ako parameter +# Volanie metódy "each" s blokomvyzerá takto: + +(1..5).each do |pocitadlo| + puts "iterácia #{pocitadlo}" +end +#=> iterácia 1 +#=> iterácia 2 +#=> iterácia 3 +#=> iterácia 4 +#=> iterácia 5 + +# Blok môže byť uzavretý aj v kučeravých záítvorkách: +(1..5).each { |pocitadlo| puts "iterácia #{pocitadlo}" } + +# Obsah dátových štruktúr môže byť tiež prechádzaný pomocou metódy "each" +pole.each do |prvok| + puts "#{prvok} je súčasťou pola" +end +asoc_pole.each do |kluc, hodnota| + puts "#{kluc} je #{hodnota}" +end + +pocitadlo = 1 +while pocitadlo <= 5 do + puts "iterácia #{pocitadlo}" + pocitadlo += 1 +end +#=> iterácia 1 +#=> iterácia 2 +#=> iterácia 3 +#=> iterácia 4 +#=> iterácia 5 + +znamka = 'B' + +case znamka +when 'A' + puts 'Len tak ďalej, chlapče' +when 'B' + puts 'Viac šťastia nabudúce' +when 'C' + puts 'Zvládneš to aj lepšie' +when 'D' + puts 'S odratými ušami' +when 'F' + puts 'Zlyhal si!' +else + puts 'Iný systém známkovania, čo?' +end +#=> "Viac šťastia nabudúce" + +# prípady (cases) môžu tiež využívať rozsahy +znamka = 82 +case znamka +when 90..100 + puts 'Hurá!' +when 80...90 + puts 'Dobrá práca' +else + puts 'Zlyhal si!' +end +#=> "Dobrá práca" + +# Zaobchádzanie s výnimkami +begin + # kód, ktorý môže vyhodiť výnimku + raise NoMemoryError, 'Došla ti pamäť.' +rescue NoMemoryError => premenna_vynimky + puts 'Nastala vynimka NoMemoryError', premenna_vynimky +rescue RuntimeError => ina_premenna_vynimky + puts 'Nastala vynimka RuntimeError' +else + puts 'Toto sa spustí, ak nenastala žiadna výnimka' +ensure + puts 'Táto časť kódu sa spustí vždy' +end + +# Funkcie + +def zdvojnasob(x) + x * 2 +end + +# Funkcie (a bloky) implicitne vracajú hodnotu posledného výrazu +zdvojnasob(2) #=> 4 + +# Zátvorky sú voliteľné ak je výsledok jednoznačný +zdvojnasob 3 #=> 6 + +zdvojnasob zdvojnasob 3 #=> 12 + +def suma(x, y) + x + y +end + +# Argumenty metódy sa oddeľujú čiarkami +suma 3, 4 #=> 7 + +suma suma(3, 4), 5 #=> 12 + +# yield +# Všetky metódy majú implicitný, voliteľný parameter bloku +# môže byť zavolaný ako kľúčové slovo 'yield' + +def obal + puts '{' + yield + puts '}' +end + +obal { puts 'ahoj svet' } + +# { +# ahoj svet +# } + + +# Funkcii môžeš odovzdať blok +# "&" označuje referenciu na tento blok +def hostia(&blok) + blok.call 'nejake argumenty' +end + +# Tiež môžeš odovzdať zoznam argumentov, ktoré sa prevedú na pole +# Na to sa využíva operátor "*" +def hostia(*pole) + pole.each { |host| puts host } +end + + +# Trieda sa definuje kľúčovým slovom class +class Clovek + + # Premenná triedy. Je zdieľaná všetkými inštanciami tejto triedy. + @@druh = 'H. sapiens' + + # Jednoduchý inicializátor + def initialize(meno, vek = 0) + # Priradí argument k premennej inštancie "meno" + @meno = meno + # Ak nie je uvedený vek, použije sa špecifikovaná predvolená hodnota + @vek = vek + end + + # Jednoduchá metóda pre nastavenie hodnoty premennej + def meno=(meno) + @meno = meno + end + + # Jednoduchá metóda pre získanie hodnoty premennej + def meno + @meno + end + + # Vyššie uvedená funkcionalita môže byť zapúzdrená použitím + # metódy attr_accessor + attr_accessor :meno + + # Metódy pre nastavenie a získanie hodnoty premennej môžu byť vytvorené + # aj individuálne + attr_reader :meno + attr_writer :meno + + # Metóda triedy používa kľúčové slovo self pre odlíšenie + # od metód inštancií. Môže byť volaná iba nad triedou, nie inštanciou. + def self.povedz(sprava) + puts sprava + end + + def druh + @@druh + end +end + + +# Vytvorenie inštancie triedy +jim = Clovek.new('Jim Halpert') + +dwight = Clovek.new('Dwight K. Schrute') + +# Skúsme zavolať zopár metód +jim.druh #=> "H. sapiens" +jim.meno #=> "Jim Halpert" +jim.meno = "Jim Halpert II" #=> "Jim Halpert II" +jim.meno #=> "Jim Halpert II" +dwight.druh #=> "H. sapiens" +dwight.meno #=> "Dwight K. Schrute" + +# Volanie metódy triedy +Clovek.povedz('Ahoj') #=> "Ahoj" + +# Rozsah platnosti premennej je definovaná spôsobom, akým ju nazveme. +# Premenné začínajúce znakom $ majú globálnu platnosť. +$premenna = "Ja som globálna premenná" +defined? $premenna #=> "global-variable" + +# Premenné začínajúce znakom @ majú platnosť v rámci inštancie +@premenna = "Ja som premenná inštancie" +defined? @premenna #=> "instance-variable" + +# Premenné začínajúce znakmi @@ majú platnosť v rámci triedy +@@premenna= "Ja som premenná triedy" +defined? @@premenna #=> "class variable" + +# Premenné začínajúce veľkým písmenom sú konštanty +Premenna = "Ja som konštanta" +defined? Premenna #=> "constant" + +# Trieda je tiež objektom v ruby, takže aj ona môže mať premenné inštancie. +# Premenná triedy je zdieľaná triedou a jej nasledovníkmi. + +# Základná trieda +class Clovek + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(hodnota) + @@foo = hodnota + end +end + +# Odvodená trieda +class Pracovnik < Clovek +end + +Clovek.foo # 0 +Pracovnik.foo # 0 + +Clovek.foo = 2 # 2 +Pracovnik.foo # 2 + +# Premenné inštancie triedy nie sú zdieľané jej nasledovníkmi. + +class Clovek + @bar = 0 + + def self.bar + @bar + end + + def self.bar=(hodnota) + @bar = hodnota + end +end + +class Doktor < Clovek +end + +Clovek.bar # 0 +Doktor.bar # nil + +module PrikladModulu + def foo + 'foo' + end +end + +# Vloženie modulu (include) previaže jeho metódy s inštanciou triedy. +# Rozšírenie modulu (extend) previaže jeho metódy so samotnou triedou. + +class Osoba + include PrikladModulu +end + +class Kniha + extend PrikladModulu +end + +Osoba.foo # => NoMethodError: undefined method `foo' for Osoba:Class +Osoba.new.foo # => 'foo' +Kniha.foo # => 'foo' +Kniha.new.foo # => NoMethodError: undefined method `foo' + +# Spätné volania sú vykonané pri vložení alebo rozšírení modulu + +module PrikladKoncernu + def self.included(zaklad) + zaklad.extend(MetodyTriedy) + zaklad.send(:include, MetodyInstancie) + end + + module MetodyTriedy + def bar + 'bar' + end + end + + module MetodyInstancie + def qux + 'qux' + end + end +end + +class Nieco + include PrikladKoncernu +end + +Nieco.bar # => 'bar' +Nieco.qux # => NoMethodError: undefined method `qux' +Nieco.new.bar # => NoMethodError: undefined method `bar' +Nieco.new.qux # => 'qux' +``` + +## Ďalšie zdroje + +- [Nauč sa ruby v príkladoch s úlohami](http://www.learneroo.com/modules/61/nodes/338) - Variácia tejto referencie s úlohami v prehliadači. +- [Oficiálna dokumentácia](http://www.ruby-doc.org/core-2.1.1/) +- [Ruby z iných jazykov](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/) +- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Staršia [bezplatná edícia](http://ruby-doc.com/docs/ProgrammingRuby/) je dostupná online. +- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Komunitná príručka odporúčaných štýlov programovania v Ruby. -- cgit v1.2.3 From b40f6f37a5f1185a918ec1c082b3694339c883a7 Mon Sep 17 00:00:00 2001 From: ven Date: Fri, 16 Sep 2016 12:52:02 +0200 Subject: fixup #1388 --- sk-sk/ruby.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sk-sk') diff --git a/sk-sk/ruby.html.markdown b/sk-sk/ruby.html.markdown index ccf8afa7..799865b0 100644 --- a/sk-sk/ruby.html.markdown +++ b/sk-sk/ruby.html.markdown @@ -1,6 +1,6 @@ --- language: ruby -filename: learnruby.rb +filename: learnruby-sk.rb contributors: - ["David Underwood", "http://theflyingdeveloper.com"] - ["Joel Walden", "http://joelwalden.net"] -- cgit v1.2.3 From df1f8373c733a010238c3688dbe13941f239d8c9 Mon Sep 17 00:00:00 2001 From: nue Date: Sun, 16 Oct 2016 18:26:09 +0200 Subject: Creating new translation page for awesome Elixir in Slovak language (sk-sk). --- sk-sk/elixir.html.markdown | 470 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 470 insertions(+) create mode 100644 sk-sk/elixir.html.markdown (limited to 'sk-sk') diff --git a/sk-sk/elixir.html.markdown b/sk-sk/elixir.html.markdown new file mode 100644 index 00000000..baadbc0f --- /dev/null +++ b/sk-sk/elixir.html.markdown @@ -0,0 +1,470 @@ +--- +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.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. +<> #=> "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 +Geometry.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 Recurzia do + def sumuj_zoznam([hlavicka | schvost], acc) do + sumuj_zoznam(chvost, acc + hlavicka) + end + + def sumuj_zoznam([], acc) do + acc + end +end + +Recurzia.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 +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 -> Geometry.area_loop() 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) from the +[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) + by Dave Thomas +* [Elixir ťahák](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) +* ["Nauč sa kúsok Erlangu pre veľké dobro!"](http://learnyousomeerlang.com/) by +Fred Hebert +* ["Erlang programovanie: Softvér pre konkurentný svet"](https://pragprog +.com/book/jaerlang2/programming-erlang) by Joe Armstrong -- cgit v1.2.3 From 0c6b3e73374064d3e2c5a149608c4213ca2068d8 Mon Sep 17 00:00:00 2001 From: ven Date: Tue, 18 Oct 2016 22:36:03 +0200 Subject: Delete LearnGit-sk.txt --- sk-sk/LearnGit-sk.txt | 208 -------------------------------------------------- 1 file changed, 208 deletions(-) delete mode 100644 sk-sk/LearnGit-sk.txt (limited to 'sk-sk') diff --git a/sk-sk/LearnGit-sk.txt b/sk-sk/LearnGit-sk.txt deleted file mode 100644 index 070a0489..00000000 --- a/sk-sk/LearnGit-sk.txt +++ /dev/null @@ -1,208 +0,0 @@ -$ git init - -# Zobraz a Nastav Základné Konfiguračné Premenné (Globálne) -$ git config --global user.email "MôjEmail@Zoho.com" -$ git config --global user.name "Moje Meno - -# Rýchlo zobraz všetky dostupné príkazy -$ git help - -# Zobraz všetky dostupné príkazy -$ git help -a - -# Zobraz konkrétnu pomoc - použivateľský manuál -# git help -$ git help add -$ git help commit -$ git help init -# alebo git --help -$ git add --help -$ git commit --help -$ git init --help - -# Zobrazí vetvu, nesledované súbory, zmeny a ostatné rozdiely -$ git status -# Zistí iné vychytávky o git statuse -$ git help status - -# pridá súbor z tvojho pracovného adresára -$ git add HelloWorld.java - -# pridá súbor z iného adresára -$ git add /cesta/k/súboru/HelloWorld.c - -# Môžeš použiť regulárne výrazy! -$ git add ./*.java - -# zobraz existujúce vetvy a vzdialené repozitáre -$ git branch -a - -# vytvor novú vetvu -$ git branch myNewBranch - -# vymaž vetvu -$ git branch -d myBranch - -# premenuj vetvu -# git branch -m -$ git branch -m mojaStaraVetva mojaNovaVetva - -# zmeň opis vetvy -$ git branch myBranchName --edit-description - -# Zobrazí tagy -$ git tag -# Vytvorí tag so správou -# -m špecifikuje správu, ktorá bude s tagom uložená. -# Ak nešpeficikuješ správu pri tagu so správou, -# Git spustí tvoj editor, aby si ju napísal. -$ git tag -a v2.0 -m 'moja verzia 2.0' - -# Ukáž informácie o tagu -# Zobrazí zadané informácie, dátum tagnutia commitu -# a správu pred zobrazením informácií o commite. -$ git show v2.0 - -# Zverejní (pushne) jediný tag do vzdialeného repozitára -$ git push origin v2.0 - -# Zverejní viacero tagov do vzdialeného repozitára -$ git push origin --tags - -# Aktualizuj strom, aby odpovedal (predvolene) -# hlavnej vetve repozitáru (master branch) -$ git checkout - -# Aktualizuj strom, aby odpovedal konrkétnej vetve -$ git checkout menoVetvy - -# Vytvor novú vetvu & prepni sa na ňu -# ekvivalentný príkaz: "git branch ; git checkout " -$ git checkout -b nováVetva - -# Naklonuj learnxinyminutes-docs -$ git clone https://github.com/adambard/learnxinyminutes-docs.git - -# povrchné klonovanie - rýchlejšie, uloží iba najnovšiu snímku -$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git - -# naklonuj iba konkrétnu vetvu -$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch - -# commitni so správou -$ git commit -m "Pridal som multiplyNumbers() funkciu do HelloWorld.c" - -# automaticky pridaj zmenené a vymazané súbory do staging indexu, potom ich commitni. -$ git commit -a -m "Zmenil som foo.php a vymazal bar.php" - -# zmeň posledný commit (toto nahradí predchádzajúci commit novým) -$ git commit --amend -m "Správna správa" - -# Ukáž rozdiel medzi pracovným repozitárom a indexom. -$ git diff - -# Ukáž rozdiely medzi indexom a najnovším commitom. -$ git diff --cached - -# Ukáž rozdiely medzi pracovným adresárom a najnovším commitom. -$ git diff HEAD - -# Nastav, aby sa vo výsledkoch vyhľadávania zobrazovalo číslo riadku -$ git config --global grep.lineNumber true - -# Urob výsledky vyhľadávania čitateľnejšie, vrátane zoskupovania -$ git config --global alias.g "grep --break --heading --line-number" - -# Vďaka Travisovi Jefferymu za túto sekciu -# Hľadaj "názovPremennej" vo všetkých java súboroch -$ git grep 'názovPremennej' -- '*.java' - -# Hľadaj riadok, ktorý obsahuje "názovPoľa" a "add" alebo "remove" -$ git grep -e 'arrayListName' --and \( -e add -e remove \) - -# Zobraz všetky commity -$ git log - -# Zobraz iba správy a referencie commitov -$ git log --oneline - -# Zobraz zlúčené (merged) commity -$ git log --merges - -# Zobraz všetky commity vo forme ASCII grafu -$ git log --graph - -# Zlúč vybranú vetvu do aktuálnej. -$ git merge názovVetvy - -# Vždy vytvor zlučovací commit -$ git merge --no-ff názovVetvy - -# Premenuj súbor -$ git mv HelloWorld.c HelloNewWorld.c - -# Presuň súbor -$ git mv HelloWorld.c ./nová/cesta/HelloWorld.c - -# "Nasilu" premenuj, alebo presuň -# "existujúciSúbor" už v adresári existuje, bude prepísaný -$ git mv -f môjSúbor existujúciSúbor - -# Aktualizuje tvoj lokálny repozitár zlúčením nových zmien -# zo vzdialených "origin" a "master" vetiev. -# git pull -$ git pull origin master - -# Predvolene, git pull aktualizuje tvoju aktuálnu vetvu -# zlúčením nových zmien zo vzdialenej vetvy -$ git pull - -# Zlúč zmeny zo vzdialenej vetvy a presuň vetvu do nového základného commitu (rebase) -# vetva commitne na tvoj lokálny repozitár, ekvivalentný príkaz: "git pull , git rebase " -$ git pull origin master --rebase - -# Zverejni a zlúč zmeny z lokálneho repozitára do -# vzdialených vetiev s názvom "origin" a "master". -# git push -$ git push origin master - -# Predvolene git zverejní a zlúči zmeny z -# aktuálnej vetvy do vzdialenej vetvy s ňou spojenej -$ git push - -# Na spojenie lokálnej vetvy so vzdialenou pridaj -u: -$ git push -u origin master -# Kedykoľvek budeš chcieť zverejniť z rovnakej lokálnej vetvy, použi príkaz: -$ git push - -# Aplikuj commity z experimentálnej vetvy na master -# git rebase -$ git rebase master experimentBranch - -# Resetni index (vrstvu medzi pracovným stromom a Git repozitárom), aby odpovedal najnovšiemu commitu (adresár ostane nezmenený) -$ git reset - -# Resetni index, aby odpovedal najnovšiemu commitu (adresár sa prepíše) -$ git reset --hard - -# Presunie vrchol aktuálnuej vetvy do konkrétneho commitu (adresár ostane nezmenený) -# všetky zmeny sú zachované v adresári. -$ git reset 31f2bb1 - -# Vezmi späť konkrétny commit -$ git revert - -# odstráň HelloWorld.c -$ git rm HelloWorld.c - -# Odstráň súbor z vnoreného adresára -$ git rm /pather/to/the/file/HelloWorld.c - - - - - - - - - -- cgit v1.2.3 From ee26130c4dd5b9c496bc42ca6589142af292246d Mon Sep 17 00:00:00 2001 From: ven Date: Mon, 31 Oct 2016 00:34:51 +0100 Subject: #2536 --- sk-sk/elixir.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sk-sk') diff --git a/sk-sk/elixir.html.markdown b/sk-sk/elixir.html.markdown index baadbc0f..7b0c7bde 100644 --- a/sk-sk/elixir.html.markdown +++ b/sk-sk/elixir.html.markdown @@ -7,7 +7,7 @@ contributors: translators: - ["Peter Szatmary", "https://github.com/peterszatmary"] lang: sk-sk -filename: learnelixir.ex +filename: learnelixir-sk.ex --- Elixir je moderný funkcionálny jazyk vytvorený nad Erlang VM (virtuálnym -- cgit v1.2.3 From f9fc5c3b40803cab9a54ae8401dde6220e0f6b3f Mon Sep 17 00:00:00 2001 From: peterszatmary Date: Sat, 5 Nov 2016 16:10:14 +0100 Subject: Translation fixes. (#2557) --- sk-sk/elixir.html.markdown | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'sk-sk') diff --git a/sk-sk/elixir.html.markdown b/sk-sk/elixir.html.markdown index 7b0c7bde..2401f92e 100644 --- a/sk-sk/elixir.html.markdown +++ b/sk-sk/elixir.html.markdown @@ -215,7 +215,7 @@ cond do end # Je bežné nastaviť poslednú podmienku rovnajúcu sa `true` , ktorá bude vždy -zodpovedať. +# zodpovedať. cond do 1 + 1 == 3 -> "Nebudem nikdy videný" @@ -310,12 +310,12 @@ defmodule Geometria do end Geometria.oblast({:obdlznik, 2, 3}) #=> 6 -Geometry.oblast({:kruh, 3}) #=> 28.25999999999999801048 +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 Recurzia do +defmodule Rekurzia do def sumuj_zoznam([hlavicka | schvost], acc) do sumuj_zoznam(chvost, acc + hlavicka) end @@ -325,7 +325,7 @@ defmodule Recurzia do end end -Recurzia.sumuj_zoznam([1,2,3], 0) #=> 6 +Rekurzia.sumuj_zoznam([1,2,3], 0) #=> 6 # Elixir moduly podporujú atribúty, existujú vstavané atribúty a takisto # môžte pridávať vlastné. @@ -422,7 +422,7 @@ end # Kompiluj modul a vytvor proces, ktorý vyhodnotí `slucka_oblasti` v shelli -pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0> +pid = spawn(fn -> Geometria.slucka_oblasti() end) #=> #PID<0.40.0> # Alternatívne pid = spawn(Geometria, :slucka_oblasti, []) @@ -458,13 +458,13 @@ Agent.update(moj_agent, fn farby -> ["modra" | farby] end) ## Referencie -* [Začíname](http://elixir-lang.org/getting-started/introduction.html) from the +* [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) - by Dave Thomas +* [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/) by -Fred Hebert -* ["Erlang programovanie: Softvér pre konkurentný svet"](https://pragprog -.com/book/jaerlang2/programming-erlang) by Joe Armstrong +* [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 -- cgit v1.2.3