diff options
Diffstat (limited to 'ro-ro')
| -rw-r--r-- | ro-ro/bash-ro.html.markdown | 159 | ||||
| -rw-r--r-- | ro-ro/bf-ro.html.markdown | 90 | ||||
| -rw-r--r-- | ro-ro/coffeescript-ro.html.markdown | 102 | ||||
| -rw-r--r-- | ro-ro/haskell-ro.html.markdown | 455 | ||||
| -rw-r--r-- | ro-ro/json-ro.html.markdown | 61 | ||||
| -rw-r--r-- | ro-ro/latex-ro.html.markdown | 256 | ||||
| -rw-r--r-- | ro-ro/python-ro.html.markdown | 17 | ||||
| -rw-r--r-- | ro-ro/xml-ro.html.markdown | 133 |
8 files changed, 1189 insertions, 84 deletions
diff --git a/ro-ro/bash-ro.html.markdown b/ro-ro/bash-ro.html.markdown index debeb67a..32a878b2 100644 --- a/ro-ro/bash-ro.html.markdown +++ b/ro-ro/bash-ro.html.markdown @@ -12,166 +12,171 @@ lang: ro-ro filename: LearnBash-ro.sh --- -Bash este numele shell-ului unix, care a fost de asemenea distribuit drept shell pentru sistemul de operare GNU si ca shell implicit pentru Linux si Mac OS X. +Bash este numele shell-ului UNIX, care a fost de asemenea distribuit drept shell pentru sistemul de operare GNU și ca shell implicit pentru Linux si Mac OS X. Aproape toate exemplele de mai jos pot fi parte dintr-un script sau pot fi executate direct in linia de comanda. -[Citeste mai multe:](http://www.gnu.org/software/bash/manual/bashref.html) +[Citește mai multe:](http://www.gnu.org/software/bash/manual/bashref.html) ```bash #!/bin/bash # Prima linie din script se numeste "shebang" -# care spune systemului cum sa execute scriptul +# care spune sistemului cum să execute scriptul # http://en.wikipedia.org/wiki/Shebang_(Unix) -# Dupa cum te-ai prins deja, comentariile incep cu #. +# După cum te-ai prins deja, comentariile încep cu #. # Shebang este de asemenea un comentariu. # Exemplu simplu de hello world: echo Hello world! -# Fiecare comanda incepe pe o linie noua, sau dupa punct si virgula ; +# Fiecare comandă începe pe o linie nouă, sau după punct și virgula ; echo 'Prima linie'; echo 'A doua linie' # Declararea unei variabile se face astfel: -VARIABLE="Niste text" +VARIABLE="Niște text" -# DAR nu asa: +# DAR nu așa: VARIABLE = "Niste text" -# Bash va crede ca VARIABLE este o comanda care trebuie executata si va -# returna o eroare pentru ca nu va putea fi gasita. +# Bash va crede că VARIABLE este o comandă care trebuie executată și va +# returna o eroare pentru că nu va putea fi găsita. # Folosind variabila: echo $VARIABLE echo "$VARIABLE" echo '$VARIABLE' -# Atunci cand folosesti variabila, o atribui, o exporti sau altfel, -# numele ei se scrie fara $. -# Daca vrei sa folosesti valoarea variabilei, atunci trebuie sa folosesti $. -# Atentie la faptul ca ' (apostrof) nu va inlocui variabla cu valoarea ei. +# Atunci când folosesti variabila, o atribui, o exporți sau altfel, +# numele ei se scrie fără $. +# Daca vrei sa folosesti valoarea variabilei, atunci trebuie să folosești $. +# Atentie la faptul că ' (apostrof) nu va inlocui variabla cu valoarea ei. -# Inlocuirea de caractere in variabile -echo ${VARIABLE/Some/A} -# Asta va inlocui prima aparitie a "Some" cu "A" in variabila de mai sus. +# Inlocuirea de caractere în variabile +echo ${VARIABLE/Niște/Un} +# Asta va înlocui prima apariție a "Niște" cu "Un" în variabila de mai sus. -# Substring dintr-o variabila +# Substring dintr-o variabilă echo ${VARIABLE:0:7} # Asta va returna numai primele 7 caractere din variabila. # Valoarea implicita a unei variabile: -echo ${FOO:-"ValoareaImplicitaDacaFOOLipsesteSauEGoala"} -# Asta functioneaza pentru null (FOO=), -# sir de caractere gol (FOO=""), zero (FOO=0) returneaza 0 +echo ${FOO:-"ValoareaImplicitaDacaFOOLipseșteSauEGoală"} +# Asta functionează pentru null (FOO=), +# sir de caractere gol (FOO=""), zero (FOO=0) returnează 0 # Variabile pre-existente -echo "Ulima valoare returnata de ultimul program rulat: $?" -echo "ID-ul procesului (PID) care ruleaza scriptul: $$" -echo "Numarul de argumente: $#" +echo "Ulima valoare returnată de ultimul program rulat: $?" +echo "ID-ul procesului (PID) care rulează scriptul: $$" +echo "Numărul de argumente: $#" echo "Argumentele scriptului: $@" -echo "Argumentele scriptului separate in variabile: $1 $2..." +echo "Argumentele scriptului separate în variabile: $1 $2..." -# Citind o valoare din consola -echo "Care e numele tau?" -read NAME # Observa faptul ca nu a trebuit sa declaram o variabila noua +# Citind o valoare din consolă +echo "Care e numele tău?" +read NAME # Observă faptul că nu a trebuit să declarăm o variabilă nouă echo Salut, $NAME! # Avem obisnuita instructiune "if" -# Foloseste "man test" pentru mai multe informatii -# despre instructinea conditionala +# Folosește "man test" pentru mai multe informații +# despre instrucținea conditionala if [ $NAME -ne $USER ] then - echo "Numele tau este username-ul tau" + echo "Numele tău este username-ul tău" else - echo "Numele tau nu este username-ul tau" + echo "Numele tău nu este username-ul tău" fi -# Este de asemenea si executarea conditionala de comenzi -echo "Intotdeauna executat" || echo "Executat daca prima instructiune esueaza" -echo "Intotdeauna executat" && echo "Executat daca prima instructiune NU esueaza" +# Există, de asemenea, și executarea conditională de comenzi +echo "Întotdeauna executat" || echo "Executat dacă prima instrucțiune eșuează" +echo "Întotdeauna executat" && echo "Executat dacă prima instrucțiune NU esuează" -# Expresiile apar in urmatorul format +# Expresiile apar în urmatorul format echo $(( 10 + 5 )) -# Spre deosebire de alte limbaje de programare bash este un shell - asa ca -# functioneaza in contextul directorului curent. Poti vedea fisiere si directoare +# Spre deosebire de alte limbaje de programare, bash este un shell - așa că +# funcționează in contextul directorului curent. Poți vedea fișiere și directoare # din directorul curent folosind comanda "ls": ls -# Aceste comenzi au optiuni care la controleaza executia -ls -l # Listeaza fiecare fisier si director pe o linie separata +# Aceste comenzi au optiuni care le controlează execuțiă +ls -l # Listează fiecare fișier și director pe o linie separată # Rezultatele comenzii anterioare pot fi -# trimise urmatoarei comenzi drept argument -# Comanda grep filtreaza argumentele trimise cu sabloane. +# trimise următoarei comenzi drept argument +# Comanda grep filtrează argumentele trimise cu sabloane. # Astfel putem vedea fiserele .txt din directorul curent. ls -l | grep "\.txt" -# De asemenea poti redirectiona o comanda, input si error output -python2 hello.py < "input.in" -python2 hello.py > "output.out" -python2 hello.py 2> "error.err" -# Output-ul va suprascrie fisierul daca acesta exista. -# Daca vrei sa fie concatenate poti folosi ">>" - -# Comenzile pot fi inlocuite in interiorul altor comenzi folosind $( ): -# Urmatoarea comanda afiseaza numarul de fisiere -# si directoare din directorul curent -echo "Sunt $(ls | wc -l) fisiere aici." - -# Acelasi lucru se poate obtine folosind apostrf-ul inversat ``, -# dar nu pot fi folosite unele in interiorul celorlalte asa ca modalitatea -# preferata este de a folosi $( ) -echo "Sunt `ls | wc -l` fisiere aici." - -# Bash foloseste o instructiune 'case' care functioneaza -# in mod similar cu instructiunea switch din Java si C++ +# De asemenea, poți redirecționa date de intrare spre sau erori/date de ieșire +# dinspre o comandă +python2 hello.py < "intrare.in" +python2 hello.py > "ieșire.out" +python2 hello.py 2> "erori.err" +# Output-ul va suprascrie fișierul dacă acesta există. +# Daca vrei să fie concatenate datele poți folosi ">>" în loc de ">" + +# Comenzile pot fi înlocuite în interiorul altor comenzi folosind $( ): +# Urmatoarea comandă afișează numărul de fișiere +# și directoare din directorul curent +echo "Sunt $(ls | wc -l) fișiere aici." + +# Același lucru se poate obține folosind apostroful inversat ``, +# dar nu pot fi folosite limbricate, așa ca modalitatea +# preferată este de a folosi $( ) +echo "Sunt `ls | wc -l` fișiere aici." + +# Bash folosește o instrucțiune 'case' care funcționeaza +# în mod similar cu instructiunea switch din Java si C++ case "$VARIABLE" in 0) echo "Este un zero.";; 1) echo "Este un unu.";; *) echo "Nu este null";; esac -# Instructiunea for parcurge toate elementele trimise: -# Continutul variabilei $VARIABLE este printat de 3 ori +# Instrucțiunea 'for' parcurge toate elementele trimise: +# Conținutul variabilei $VARIABLE este printat de 3 ori for VARIABLE in {1..3} do echo "$VARIABLE" done -# while loop: +# Buclă while: while [true] do - echo "in interiorul iteratiei aici..." + echo "în interiorul iterației aici..." break done -# De asemenea poti defini functii -# Definitie: +# De asemenea poți defini funcții +# Definiție: function foo () { - echo "Argumentele functioneaza ca si argumentele scriptului: $@" + echo "Argumentele funcționeaza ca și argumentele scriptului: $@" echo "Si: $1 $2..." - echo "Asta este o functie" + echo "Asta este o funcție" return 0 } -# sau mai simplu +# sau mai simplu: bar () { - echo "Alta metoda de a declara o functie" + echo "Altă metodă de a declara o funcție" return 0 } -# Invocarea unei functii +# Invocarea unei funcții: foo "Numele meu este: " $NAME -# Sunt o multime de comenzi utile pe care ar trebui sa le inveti: +# Sunt o multime de comenzi utile pe care ar trebui să le inveți: tail -n 10 file.txt -# printeaza ultimele 10 linii din fisierul file.txt +# afișează ultimele 10 linii din fișierul file.txt + head -n 10 file.txt -# printeaza primele 10 linii din fisierul file.txt +# afișează primele 10 linii din fișierul file.txt + sort file.txt -# sorteaza liniile din file.txt +# sortează liniile din file.txt + uniq -d file.txt -# raporteaza sau omite liniile care se repeta, cu -d le raporteaza +# raporteaza sau omite liniile care se repetă. Cu -d le raporteaza + cut -d ',' -f 1 file.txt -# printeaza doar prima coloana inainte de caracterul "," +# printează doar prima coloană inainte de caracterul "," ``` diff --git a/ro-ro/bf-ro.html.markdown b/ro-ro/bf-ro.html.markdown new file mode 100644 index 00000000..61b555ed --- /dev/null +++ b/ro-ro/bf-ro.html.markdown @@ -0,0 +1,90 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Petru Dimitriu", "http://petru-dimitriu.github.io"] +lang: ro-ro +--- + +Brainfuck (un nume propriu care nu primește majusculă inițială decât la începutul +propoziției) este un limbaj de programare Turing-comple extrem de minimalist cu +doar 8 instrucțiuni. + +Puteți încerca brainfuck în navigatorul dumneavoastră cu [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/). + +``` +Orice caracter in afara de "><+-.,[]" (fara ghilimele) este ignorat. + +Brainfuck se reprezinta ca un vector de 30 000 de celule initializate cu zero +si un pointer de date care trimite spre celula curenta. + +Exista opt comenzi: ++ : Incrementeaza valoarea celulei curente cu 1. +- : Decrementeaza valoarea celulei curente cu 1. +> : Muta pointerul de date la urmatoarea celula (o celula la dreapta). +< : Muta pointerul de date la celula precedenta (o celula la stanga). +. : Afiseaza valoarea caracterului ASCII din celul caurenta (ex. 65 = 'A'). +, : Citeste un singur caracter si plaseaza valoarea lui in celula curenta. +[ : Daca valoarea in celula curenta este zero, sare la urmatorul caracter ] . + Altfel, merge la urmatoarea instructiune. +] : Daca valoarea in celula curenta este zero, sare la urmatoarea + instructiune. + Altfel, se intoarce la instructiunea de dupa caracterul [ precedent . + +[ and ] formeaza un ciclu. Evident, trebuie ca parantezarea sa fie corecta. + +Sa privim cateva programe brainfuck simple. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Acest program afiseaza litera 'A'. Mai intai, incrementeaza celula #1 pana +la valoarea 6. Celula #1 va fi folosita pentru ciclare. Apoi, intra in ciclu +([) si muta pointerul la celula #2. Incrementeaza celula #2 de 10 ori, +muta pointerul la celula #1 si decrementeaza celula #1. Acest ciclu parcurge +6 iteratii (este nevoie de 6 decrementari pentru ca celula #1 sa ajunga la 0), +iar dupa aceea se trece la caracterul ] corespunzator si se continua executia. + +In acest moment, ne aflam in celula #1, care are valoarea 0, in timp ce celula +#2 are valoarea 60. Ne mutam pe celula #2, incrementam de 5 ori, pentru a +obtine valoarea 65, si apoi afisam valoarea celulei #2. 65 este codul ASCII +pentru 'A', deci se afiseaza 'A' in terminal. + +, [ > + < - ] > . + +Acest program citeste un caracter de la intrarea utilizator si copiaza caracterul +in celula #1. Apoi incepem un ciclu. Se muta pointerul in celula #2, se +incremneteaza valoarea de la celula #2, se muta inapoi la celula #1, se +decrementeaza valoarea de la celula #1. Aceasta continua pana cand celula #1 este +0 iar celula #2 retine vechea valoare a celulei #1. Deoarece ne aflam in celula +#1 la sfarsitul ciclului, ne mutam pe celula #2 si afisam simbolul corespunzator +in ASCII. + +Aveti in vedere ca spatiile sunt doar pentru usurinta citirii. La fel de bine +programul ar fi putut fi scris astfel: + +,[>+<-]>. + +Incercati sa va dati seama ce face acest program: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Acest program citeste doua numere ca intrare si le inmulteste. + +Pe scurt, programul citeste doua date de intrare, apoi incepe ciclul +mare, a carui conditie se afla in celula #1; apoi se muta la celula #2 +si incepe un ciclu imbricat a carui conditie de reluare se afla in +celula #2, si care incrementeaza celula #3. Totusi aici intervine o +problema: La sfarsitul ciclului imbricat, celula #2 este zero. In +acest caz, celula ciclul imbricat nu va mai functiona data viitoare. +Pentru a rezolva aceasta problema, incrementam celula si #4, si +recopiem celula #4 in celula #2. In final, celula #3 este rezultatul. + +``` + +Așadar acesta este limbajul brainfuck. Nu e atât de greu, nu? Pentru +amuzament, puteți să scrieți propriile dumneavoastră limbaje, sau puteți +scrie un interpretor pentru brainfuck într-un alt limbaj. Interpretorul +este destul de ușor de implementat, dar dacă sunteți masochist, încercați +să implementați un interpretor de brainfuck… în brainfuck.
\ No newline at end of file diff --git a/ro-ro/coffeescript-ro.html.markdown b/ro-ro/coffeescript-ro.html.markdown new file mode 100644 index 00000000..695274d2 --- /dev/null +++ b/ro-ro/coffeescript-ro.html.markdown @@ -0,0 +1,102 @@ +--- +language: coffeescript +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +translators: + - ["Bogdan Lazar", "http://twitter.com/tricinel"] +filename: coffeescript-ro.coffee +lang: ro-ro +--- + +CoffeeScript este un limbaj de programare care este compilat in Javascript. Nu exista un interpretator la runtime-ul aplicatiei. Fiind unul din successorii Javascript, CoffeeScript incearca sa compileze Javascript usor de citit si performant. + +Mai cititi si [website-ul CoffeeScript](http://coffeescript.org/), care contine un tutorial complet Coffeescript. + +```coffeescript +# CoffeeScript este un limbaj de hipster. +# Se foloseste de trendurile multor limbaje moderne de programare. +# Comentarii sunt ca in Ruby sau Python. + +### +Comentariile in bloc sunt create cu `###`, iar acestea sunt transformate in `/*` si `*/` pentru Javascript + +Ar trebuie sa intelegeti Javascript pentru a continua cu acest ghid. +### + +# Atribuirea valorilor: +numar = 42 #=> var numar = 42; +opus = true #=> var opus = true; + +# Conditii: +numar = -42 if opus #=> if(opus) { numar = -42; } + +# Functii: +laPatrat = (x) -> x * x #=> var laPatrat = function(x) { return x * x; } + +plin = (recipient, lichid = "cafea") -> + "Umplem #{recipient} cu #{cafea}..." +#=>var plin; +# +#plin = function(recipient, lichid) { +# if (lichid == null) { +# lichid = "cafea"; +# } +# return "Umplem " + recipient + " cu " + lichid + "..."; +#}; + +# Liste: +lista = [1..5] #=> var lista = [1, 2, 3, 4, 5]; + +# Obiecte: +matematica = + radacina: Math.sqrt + laPatrat: laPatrat + cub: (x) -> x * square x +#=> var matematica = { +# "radacina": Math.sqrt, +# "laPatrat": laPatrat, +# "cub": function(x) { return x * square(x); } +# }; + +# Splats: +cursa = (castigator, alergatori...) -> + print castigator, alergatori +#=>cursa = function() { +# var alergatori, castigator; +# castigator = arguments[0], alergatori = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(castigator, alergatori); +# }; + +# Verificarea existentei: +alert "Stiam eu!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Stiam eu!"); } + +# Operatiuni cu matrice: +cuburi = (math.cube num for num in list) +#=>cuburi = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = list.length; _i < _len; _i++) { +# num = list[_i]; +# _results.push(math.cube(num)); +# } +# return _results; +# })(); + +alimente = ['broccoli', 'spanac', 'ciocolata'] +mananca aliment for aliment in alimente when aliment isnt 'ciocolata' +#=>alimente = ['broccoli', 'spanac', 'ciocolata']; +# +#for (_k = 0, _len2 = alimente.length; _k < _len2; _k++) { +# aliment = alimente[_k]; +# if (aliment !== 'ciocolata') { +# eat(aliment); +# } +#} +``` + +## Resurse aditionale + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) diff --git a/ro-ro/haskell-ro.html.markdown b/ro-ro/haskell-ro.html.markdown new file mode 100644 index 00000000..082f138b --- /dev/null +++ b/ro-ro/haskell-ro.html.markdown @@ -0,0 +1,455 @@ +--- +language: Haskell +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["Petru Dimitriu", "http://petru-dimitriu.github.io"] +lang: ro-ro +filename: haskell-ro.html +--- + +Haskell este un limbaj de programare practic, pur funcțional. + +```haskell +-- Comentariile pe o singura linie incep cu 2 cratime. +{- Comentariile multilinie + se scriu astfel. +-} + +---------------------------------------------------- +-- 1. Tipuri de date primitive si operatori +---------------------------------------------------- + +-- Exista numere +3 -- 3 + +-- Matematica functioneaza ca de obicei +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 +35 / 5 -- 7.0 + +-- Impartirea este cu virgula +35 / 4 -- 8.75 + +-- Impartirea cu rest +35 `div` 4 -- 8 + +-- Valorile booleene sunt primitive +True +False + +-- Operatii logice +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- In exemplele de mai sus, `not` este o functie ce primeste o valoare. +-- In Haskell nu se pun paranteze pentru apelurile de functie. Toate +-- argumentele sunt insirate dupa numele functiei. Sablonul general este: +-- func arg1 arg2 arg3 +-- Vedeti sectiunea despre functii pentru a afla cum sa scrieti propria functie. + +-- Caractere si siruri de caractere +"Acesta este un sir de caractere" +'a' -- un caracter +'Nu se pot folosi apostroafe pentru siruri.' -- eroare! + +-- Sirurile pot fi concatenate +"Hello " ++ "world!" -- "Hello world!" + +-- Un string e de fapt o lista de caractere +['H', 'e', 'l', 'l', 'o'] -- "Hello" +"Acesta este un string" !! 0 -- 'A' + + +---------------------------------------------------- +-- Liste si tupli +---------------------------------------------------- + +-- Fiecare element dintr-o lista trebuie sa aiba acelasi tip. +-- Urmatoarele liste sunt identice. +[1, 2, 3, 4, 5] +[1..5] + +-- Intervalele sunt versatile. +['A'..'F'] -- "ABCDEF" + +-- Se poate specifica un pas pentru intervale. +[0,2..10] -- [0, 2, 4, 6, 8, 10] +[5..1] -- Aceasta nu functioneaza deoarece pasul implicit este incrementarea. +[5,4..1] -- [5, 4, 3, 2, 1] + +-- indexarea intr-o lista este de la zero +[1..10] !! 3 -- se obtine 4 + +-- Se pot crea liste infinite +[1..] -- lista tuturor numerelor naturale + +-- Listele infinite functioneaza pentru ca Haskell foloseste "evaluare lenesa" +-- adica evalueaza lucrurile doar cand este nevoie de ele. Deci se poate +-- cere al 1000-lea element din lista infinita a numerelor naturale astfel: + +[1..] !! 999 -- rezulta 1000 + +-- Haskell a evaluat elementele 1 - 1000 din lista... dar restul elementelor +-- acestei liste "infinite" nu exista inca! Haskell nu le va evalua pana +-- nu va fi nevoie de ele. + +-- concatenarea a doua liste +[1..5] ++ [6..10] + +-- alipirea la capul listei +0:[1..5] -- [0, 1, 2, 3, 4, 5] + +-- operatii cu liste +head [1..5] -- 1 +tail [1..5] -- [2, 3, 4, 5] +init [1..5] -- [1, 2, 3, 4] +last [1..5] -- 5 + +-- intelegerea listelor +[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] + +-- folosind o conditie +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] + +-- Fiecare element dintr-un tuplu poate fi de un tip diferit +-- dar un tuplu are lungime fixa +-- Un tuplu: +("haskell", 1) + +-- accesarea elementelor unui tuplu pereche +fst ("haskell", 1) -- "haskell" (first) +snd ("haskell", 1) -- 1 (second) + +---------------------------------------------------- +-- 3. Functii +---------------------------------------------------- +-- O functie simpla ce sumeaza doua variabile +add a b = a + b + +-- Aveti in vedere ca daca folositi ghci (interpretorul Haskell) +-- trebuie sa scrieti in fata si `let`, adica +-- let add a b = a + b + +-- Apelarea functiei +add 1 2 -- rezulta 3 + +-- Numele functiei se poate pune si intre argumente +-- folosind apostrof intors: +1 `add` 2 -- 3 + +-- Se pot defini functii fara litere in denumire! Astfel se pot +-- defini noi operatori! De exemplu, iata un operator care realizeaza +-- impartirea intreaga +(//) a b = a `div` b +35 // 4 -- rezulta 8 + +-- Guards: o metoda usoara de a crea ramuri de executie +fib x + | x < 2 = 1 + | otherwise = fib (x - 1) + fib (x - 2) + +-- Potrivirea sirurilor se face similar. Aici am definit 3 definitii +-- pentru fib. Haskell o va alege automat pe prima care se potriveste +-- cu sablonul valorii. +fib 1 = 1 +fib 2 = 2 +fib x = fib (x - 1) + fib (x - 2) + +-- Potrivirea in tupli: +foo (x, y) = (x + 1, y + 2) + +-- Potrivirea in liste. Aici `x` este primul element al listei, +-- iar `xs` este restul litei. Putem scrie propria functie +-- de mapare +myMap func [] = [] +myMap func (x:xs) = func x:(myMap func xs) + +-- Functiile anonime sunt create folosind un backslash urmat +-- de toate argumentele. +myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] + +-- utilizarea fold (denumit `inject` in alte limbaje) cu o functie +-- anonima. foldl1 inseamna pliere la stanga, folosind prima valoare +-- din lista drept valoarea initiala pentru acumulator +foldl1 (\acc x -> acc + x) [1..5] -- 15 + +---------------------------------------------------- +-- 4. Mai multe functii +---------------------------------------------------- + +-- aplicare partiala; daca nu se introduc toate argumentele unei functii, +-- este "aplicata partial", adica returneaza o noua functie ce primeste +-- restul argumentelor, avand deja setate argumentele introduse + +add a b = a + b +foo = add 10 -- foo este o functie ce primeste un numar si ii aduna 10 +foo 5 -- 15 + +-- alta maniera de a scrie acelasi lucru +foo = (10+) +foo 5 -- 15 + +-- compunerea functiilor +-- operatorul `.` inlantuieste functiile. +-- De exeplu, aici foo este o functie care aduna 10 unui numar, il inmul +-- teste cu 4 si returneaza rezultatul calcului +foo = (4*) . (10+) + +-- 4*(10 + 5) = 60 +foo 5 -- 60 + +-- alterarea precedentei +-- Haskell detine un operator numit `$`. Acest operator aplica o functie +-- unui parametru dat. Fata de aplicarea standard a functiilor, care +-- foloseste prioritatea maxim posibila 10 si este asociativa la stanga, +-- operatorul `$` are prioritatea 0 si este asociativ la dreapta. +-- Aceasta inseamna ca expresia de la dreapta este aplicata ca parametru +-- functiei din stanga + +-- inainte +even (fib 7) -- false + +-- echivalent +even $ fib 7 -- false + +-- compunerea functiilor +even . fib $ 7 -- false + + +---------------------------------------------------- +-- 5. Type signatures +---------------------------------------------------- + +-- Haskell are un sistem de tipuri de date foarte puternic; fiecare expresie +-- valida are un tip. + +-- Cateva tipuri de baza: +5 :: Integer +"hello" :: String +True :: Bool + +-- Functiile au tipuri de asemenea. +-- `not` primeste un boolean si returneaza un boolean. +-- not :: Bool -> Bool + +-- Iata o functie ce primeste doi intregi +-- add :: Integer -> Integer -> Integer + +-- Cand se defineste o valoare, este bine sa se precizeze tipul ei deasupra. +double :: Integer -> Integer +double x = x * 2 + +--------------------------------------------------------- +-- 6. Controlul executiei si instructiunile conditionale +--------------------------------------------------------- + +-- expresia conditionala if +haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" + +-- cand expresiile sunt pe mai multe linii, este importanta indentarea +haskell = if 1 == 1 + then "awesome" + else "awful" + +-- expresiile de tip case; iata cum se verifica argumentele programului +case args of + "help" -> printHelp + "start" -> startProgram + _ -> putStrLn "bad args" + + +-- Haskell nu foloseste cicluri, ci recursie +-- map aplica o functie fiecarui element dintr-o lista + +map (*2) [1..5] -- [2, 4, 6, 8, 10] + +-- se poate face o functie for folosind map +for array func = map func array + +-- si apoi se poate folosi astfel: +for [0..5] $ \i -> show i + +-- se poate scrie si asa: +for [0..5] show + +-- Se poate folosi foldl sau foldr pentru a reduce o lista +-- foldl <fn> <valoare initiala> <lista> +foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 + +-- Acelasi lucru ca a scrie +(2 * (2 * (2 * 4 + 1) + 2) + 3) + +-- foldl functioneaza spre stanga, foldr spre dreapta +foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 + +-- Acealsi lucru ca: +(2 * 1 + (2 * 2 + (2 * 3 + 4))) + +---------------------------------------------------- +-- 7. Tipuri de date +---------------------------------------------------- + +-- Iata cum se creeaza un tip de date in Haskell + +data Culoare = Rosu | Albastru | Verde + +-- Acum poate fi folosit in functii + + +spune :: Culoare -> String +spune Rosu = "Esti Rosu!" +spune Albastru = "Esti Albastru!" +spune Verde = "Esti Verde!" + +-- Tipul de date poate avea si parametri. + +data Maybe a = Nothing | Just a + +-- Toate acestea sunt de tipul Maybe +Just "hello" -- de tipul `Maybe String` +Just 1 -- de tipul `Maybe Int` +Nothing -- de tipul `Maybe a` pentru oricare `a` + +---------------------------------------------------- +-- 8. IO in Haskell +---------------------------------------------------- + +-- Desi IO nu se poate explica intru totul fara a explica monadele, +-- nu este atat de greu de explicat pentru o idee de baza. + +-- Cand se executa un program Haskell, se apeleaza `main`. +-- Trebuie sa returneze o valoare de tio `IO a` pentru un anumit tip `a`. +-- De exemplu: + +main :: IO () +main = putStrLn $ "Hello, sky! " ++ (say Blue) +-- putStrLn are tipul String -> IO () + +-- Cel mai usor se lucreaza cu IO daca se implementeaza programul +-- ca o functie de la String la String. Functia +-- interact :: (String -> String) -> IO () +-- citeste un text, executa o functie asupra ei, apoi afiseaza +-- iesirea. + +countLines :: String -> String +countLines = show . length . lines + +main' = interact countLines + +-- O valoare de tipul `IO ()` poate fi privita ca reprezentand +-- o secventa de actiuni pe care care computerul sa le execute, +-- similar cu felul in care un program este scris intr-un limbaj +-- imperativ. Putem folosi notatia `do` pentru a inlantui actiunile. +-- De exemplu: + +sayHello :: IO () +sayHello = do + putStrLn "What is your name?" + name <- getLine -- citeste o linie + putStrLn $ "Hello, " ++ name + +-- Exercise: Scrieti propria functie `interact` care citeste +-- o singura linie de la intrare. + + +-- Codul din `sayHello` nu va fi niciodata executat. Singura actiunile +-- care este executata este valoarea lui `main`. +-- Pentru a rula `sayHello.`, eliminati definitia de mai sus a `main`. +-- si inlocuiti-o cu +-- main = sayHello + +-- Sa intelegem mai bine cum functioneaza functia `getLine`. +-- Tipul ei este: +-- getLine :: IO String +-- Pueti privi o valoare de tipul `IO a` ca fiind un program +-- de computer care va genera o valoare de tipul `a` cand +-- este executata (pe langa orice altceva face). O putem denumi +-- si refolosi utilizand `<-`. De asemenea putem face propriile +-- actiuni te tipul `IO String`: + +action :: IO String +action = do + putStrLn "Aceasta e o linie." + input1 <- getLine + input2 <- getLine + --Tipul instructiunii `do` este cel de pe ultima sa linie. + -- `return` nu este un cuvant cheie, ci o functie + return (input1 ++ "\n" ++ input2) -- return :: String -> IO String + +-- Putem folosi aceasta exact cum am folosit `getLine`: + +main'' = do + putStrLn "I will echo two lines!" + result <- action + putStrLn result + putStrLn "This was all, folks!" + +-- Tipul `IO` este un exemplu de "monada". Felul in care Haskell foloseste +-- o monada pentru a realiza opeartii de intrare si iesire il face un limbaj +-- pur functional. Orice functie care interactioneaza cu exteriorul (adica +-- realieaza IO) este marcata ca `IO` in semnatura ei. Aceasta ne permite +-- sa spunem ce functii sunt "pure", adica nu interactioneaza cu exteriorul. + +-- Aceasta este o facilitate foarte puternica, deoarece este usor sa +-- se ruleze functii pure concurent; asadar, concurenta in Haskell se face usor + +---------------------------------------------------- +-- 9. REPL in Haskell +---------------------------------------------------- + +-- Se porneste introducand `ghci`. +-- Dupa aceasta, se poate introduce cod Haskell. +-- Toate valorile noi trebuie precedate de `let`. + +let foo = 5 + +-- Puteti vedea tipul oricarei valori sau expresii cu `:t`. + +> :t foo +foo :: Integer + +-- Operatorii, precum `+`, `:` si `$` sunt functii. +-- Tipul lor poate fi observat punand operatorii intre paranteze. + +> :t (:) +(:) :: a -> [a] -> [a] + +-- Se pot obtine informatii despre fiecare nume folosind `:i` + +> :i (+) +class Num a where + (+) :: a -> a -> a + ... + -- Defined in ‘GHC.Num’ +infixl 6 + + +--De asemenea se poate executa orice actiune de tipul `IO ()` + +> sayHello +What is your name? +Friend! +Hello, Friend! + +``` +Mai sunt multe de spus despre Haskell, printre care typclasses și monade. +Acestea sunt marile idei care fac programarea în Haskell atât de interesantă. +Vă las un exemplu final în Haskell: o variantă de implementare a sortării rapide +(quicksort) în Haskell: + +```haskell +qsort [] = [] +qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater + where lesser = filter (< p) xs + greater = filter (>= p) xs +``` + +Există două maniere populare de a instala Haskell: prin [instalarea bazată pe Cabal](http://www.haskell.org/platform/), și prin mai noul [proces bazat pe Stack](https://www.stackage.org/install). + +Se poate găsi o introducere în Haskell mult mai blândă la adresele +[Learn you a Haskell](http://learnyouahaskell.com/) sau +[Real World Haskell](http://book.realworldhaskell.org/). diff --git a/ro-ro/json-ro.html.markdown b/ro-ro/json-ro.html.markdown new file mode 100644 index 00000000..e897059c --- /dev/null +++ b/ro-ro/json-ro.html.markdown @@ -0,0 +1,61 @@ +--- +language: json +filename: learnjson-ro.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Serban Constantin", "https://github.com/fuzzmz"] +lang: ro-ro +--- + +Deoarece JSON este un fromat foarte simplu de schimb de date acesta va fi +probabil cel mai simplu Invata X in Y minute. + +JSON in forma cea mai pura nu contine comentarii insa majoritatea parserelor +vor accepta comentarii in stil C (`//`, `/* */`). Pentru acest caz insa totul +va fi JSON 100% valid. Din fericire codul vorbeste de la sine. + +```json +{ + "cheie": "valoare", + + "chei": "trebuie mereu inconjurate de ghilimele", + "numere": 0, + "stringuri": "Bunã. Tot setul unicode este permis, chiar si \"escaping\".", + "are booleane?": true, + "nimic": null, + + "numere mari": 1.2e+100, + + "obiecte": { + "comentariu": "Majoritatea structurii va veni din obiecte.", + + "vectori": [0, 1, 2, 3, "Vectorii pot avea orice in ei.", 5], + + "alt obiect": { + "comentariu": "Lucrurile pot fi subordonate. Foarte util." + } + }, + + "glumite": [ + { + "surse de potasiu": ["banane"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "stil alternativ": { + "comentariu": "ia uite la asta!" + , "pozitia virgulei": "nu conteaza - daca e inaintea valorii atunci e valida" + , "alt comentariu": "ce dragut" + }, + + "a fost scurt": "Am terminat. Acum stii tot ce are JSON de oferit." +} +``` diff --git a/ro-ro/latex-ro.html.markdown b/ro-ro/latex-ro.html.markdown new file mode 100644 index 00000000..f661db0a --- /dev/null +++ b/ro-ro/latex-ro.html.markdown @@ -0,0 +1,256 @@ +--- +language: latex +contributors: + - ["Chaitanya Krishna Ande", "http://icymist.github.io"] + - ["Colton Kohnke", "http://github.com/voltnor"] + - ["Sricharan Chiruvolu", "http://sricharan.xyz"] + - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"] +translators: + - ["Petru Dimitriu", "http://petru-dimitriu.github.io"] +filename: learn-latex-ro.tex +lang: ro-ro +--- + +```tex +% Toate comentariile încep cu % +% Nu există comentarii multi-linie + +% LaTeX NU este un program software de procesare text de tipul +% "What You See Is What You Get" +% precum MS Word, sau OpenOffice Writer + +% Toate comenzile LaTeX încep cu backslash. (\) + +% Documentele LaTeX încep cu o linie care definește tipul documentului +% care urmează a fi compilat. Alte tipuri de documente sunt book (carte), +% presentation (prezentare), etc. Opțiunile pentru document apar +% între paranteze drepte. În acest caz, specificăm că vrem să folosim +% un corp de text (font) de 12 puncte. +\documentclass[12pt]{article} + +% Mai apoi definim pachetele pe care documentul le folosește. +% Dacă vreți să includeți grafice, text colorat sau +% cod sursă din alt fișier în documentul dumneavoastră, +% trebuie să îmbogățiți capabilitățile LaTeX. Aceasta se realizează +% adăugând pachete. Voi include pachetele float și caption pentru +% imagini. +\usepackage{caption} +\usepackage{float} +% această comandă este necesară atunci când vreți să scrieți codul +% sursă folosind diacrtice! (cum e cazul aici, unde translatorul +% a vrut să scrie neapărat folosind diacriticele românești) +\usepackage[utf8]{inputenc} + +% De asemenea, putem defini și alte proprietăți pentru documente. +\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu \\ Traducere de Petru Dimitriu} +\date{\today} +\title{Învățați LaTeX în Y minute!} + +% Suntem gata să începem documentul. +% Tot ce se află înaintea acestei linii se numește "Preambul" +\begin{document} +% dacă am setat autorul, data și titlul, putem cere LaTeX să +% creeze o pagină de titlu +\maketitle + +% Cele mai multe documente științifice au un rezumat; puteți folosi comenzile +% predefinite pentru acesta. Acesta ar trebui să apară, așa cum ar fi logic, +% după titlu, dar înainte de secțiunile principale ale corpului. +% Această comandă este disponibilă în clasele de document article și report. +\begin{abstract} + Documentațue LaTeX scrisă în LaTeX. O idee nicidecum nouă și nicidecum a mea! +\end{abstract} + +% Comenzile pentru secțiuni sunt intuitive. +% Toate titlurile secțiunilor sunt adăugate automat la tabla de materii (cuprins). +\section{Introducere} +Salut, mă numesc Petru. Astăzi vom învăța împreună LaTeX! + +\section{Altă secțiune} +Acesta este textul pentru altă secțiune. Vom face o subsecțiune. + +\subsection{Aceasta este o subsecțiune} +Și încă una. + +\subsubsection{Pitagora} +Mult mai bine. +\label{subsec:pitagora} + +% Folosind asteriscul putem suprima numărătoarea automată a LaTeX. +% Aceasta funcționează și pentru alte comenzi LaTeX. +\section*{Secțiune fără numerotare} +Totuși nu toate secțiunile trebuie să fie nenumerotate! + +\section{Note despre text} +În general LaTeX se pricepe să pună textul unde trebuie. Dacă o linie are \\ +nevoie \\ să \\ fie \\ întreruptă, puteți adăuga două caractere backslash +la codul sursă. + +\section{Liste} +Listele sunt printre cel mai simplu de făcut lucruri în LaTeX! Mâine merg la +cumpărături așa că fac o listă: +\begin{enumerate} % Aceasta creează un mediu "enumerate" + % \item spune mediului "enumerate" să incrementeze + \item salată + \item 27 pepeni + \item un singur iepuroi + % putem suprascrie numărul elementului folosind [] + \item[câte?] conserve de ton + + Nu este un element din listă, dar încă face parte din "enumerate". + +\end{enumerate} % Toate mediile trebuie să aibă o instrucțiune de încheiere. + +\section{Matematică} + +Una dintre principalele întrebuințări ale LaTeX este realizarea +articolelor academice sau a fișelor tehnice, de obicei aflate în +universul matematicii și științelor exacte. Astfel, trebuie să putem +adăuga simboluri speciale în documentul nostru! \\ + +Matematica are multe simboluri, mult mai multe decât se găsesc +pe o tastatură - printre ele, simboluri pentru mulțimi și relații, +săgeți, operatori și litere grecești.\\ + +Mulțimile și relațiile sunt esențiale în lucrările științifce matematice. +Iată cum se scrie: toți y aparținând lui X.\\ +$\forall$ x $\in$ X. \\ + +% Observați cum am avut nevoie să pun semnul $ înainte și după simboluri. +% Aceasta pentru că atunci când scriem, suntem în modul text (text-mode). +% Totuși simbolurile matematice există numai în modul matematic (math-mode). +% Când ne aflăm în text-mode, putem scrie texte în math-mode punând $ înainte +% și după simboluri. La fel și viceversa. Și variabilele pot fi redate +% în math-mode. Putem intra în math-mode și scriind \[\]. + +\[a^2 + b^2 = c^2 \] + +Îmi place litera $\xi$. De asemenea îmi plac $\beta$, $\gamma$ și +$\sigma$. Nu există nicio literă grecească necunoscută pentru LaTeX! + +Operatorii sunt esențiali într-un document matematic! +funcțiile trigonometrice ($\sin$, $\cos$, $\tan$), +logaritmii și exponențialele ($\log$, $\exp$), +limitele ($\lim$), etc. +au comenzi definite în LaTeX pentru fiecare. +Să vedem cum scriem o ecuație: \\ + +$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ + +Fracțiile (numărător - numitor) pot fi scrise astfel: +% 10 / 7 +$^{10}/_{7}$ \\ + +% Fracții relativ complexe pot fi scrie ca +% \frac{numărător}{numitor} +$\frac{n!}{k!(n - k)!}$ \\ + +Putem insera ecuații și într-un "mediu pentru ecuații". + +% Afișează text matematic într-un mediu pentru ecuații. +\begin{equation} % intră în math-mode + c^2 = a^2 + b^2. + \label{eq:pitagora} % pentru referențiere +\end{equation} +% toate instrucțiunile cu \begin trebuie să fie cuplate cu o instrucțiune cu \end + +Putem referenția noua noastră ecuație! +~\ref{eq:pitagora} este cunoscută și ca Teorema lui Pitagora, despre care vorbim și la Sec.~\ref{subsec:pitagora}. Multe lucruri prot fi etichetate: +figuri, ecuații, secțiuni, etc. + +Sumele discrete și integralele se scriu cu comenzile sum și int. + +% Unele compilatoare LaTeX nu acceptă să existe linii goale +% într-un mediu pentru ecuații. +\begin{equation} + \sum_{i=0}^{5} f_{i} +\end{equation} +\begin{equation} + \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x +\end{equation} + +\section{Figuri} + +Să inserăm o figură. Așezarea figurilor poate fi ușor dificilă. +Eu trebuie să mă uit peste opțiunile de așezare de fiecare dată. + +\begin{figure}[H] % H denumește opțiunle de așezare + \centering % centrează figura pe pagină + % Inserează o figură scalată la 0.8 din lățimea paginii. + %\includegraphics[width=0.8\linewidth]{right-triangle.png} + % Comentat pentru a nu împiedica fișierul să compileze. + \caption{Triunghi dreptunghic cu laturile $a$, $b$, $c$} + \label{fig:right-triangle} +\end{figure} + +\subsection{Tabel} +Putem insera tabele la fel cum inserăm figuri. + +\begin{table}[H] + \caption{Descriere pentru tabel} + % argumentele {} controlează cum vor fi afișate coloanele + \begin{tabular}{c|cc} + Număr & Nume & Prenume \\ % Numele coloanelor sunt separate prin $ + \hline % a linie orizonală + 1 & Popescu & Ion \\ + 2 & Sima & Felix + \end{tabular} +\end{table} + +% \section{Hyperlinkuri} % În curând + +\section{Cum facem ca LaTeX să nu compileze ceva (de exemplu cod sursă)} +Să zicem că vrem să includem niște cod în documentul nostru LaTeX. +Vom avea nevoie ca LaTeX să nu încerce să interpreteze acel cod, +ci doar să îl redea în document. Vom face asta cu un mediu verbatim. + +% Există și alte pachete (i.e. minty, lstlisting, etc.) +% dar verbatim este pachetul cel mai simplu. +\begin{verbatim} + print("Salut lume!") + a%b; % hei! putem folosi % în verbatim + random = 4; +\end{verbatim} + +\section{Compilarea} +Acum vă întrebați cum se compilează acest document minunat și să vă +minunați de rezultat, un PDF LaTeX. (da, documentul acesta chiar +compilează). \\ +Realizarea documentului cu LaTeX va parcurge următorii pași: + \begin{enumerate} + \item Se scrie documentul în text simplu. (codul sursă) + \item Se compilează documentul pentru a produce un PDF. + Compilarea arată cam așa în Linux:\\ + \begin{verbatim} + $pdflatex learn-latex.tex learn-latex.pdf + \end{verbatim} + \end{enumerate} + +Anumite editoare pentru LaTeX combină pașii 1 și 2 în același produs software. +Așadar, dacă vreți să vedeți realizați pasul 1 dar nu și pasul 2, el se poate +realiza "în spate". + +Scrieți toate informațiile de formatare în pasul 1. Compilarea din pasul 2 +se ocupă de producerea documentului în formatul definit în pasul 1. + +\section{Final} + +Asta e tot pentru moment! + +% De multe ori veți vrea să aveți o secțiune cu bibliografie în document. +% Cea mai ușoară modalitate este folosind mediul thebibliography. +\begin{thebibliography}{1} + % Similar celorlalte liste, comanda \bibitem e folosită pentru a înșirui + % elemente; fiecare element poate fi citat în interiorul textului + \bibitem{latexwiki} Uimitoarea carte wiki LaTeX: {\em https://en.wikibooks.org/wiki/LaTeX} + \bibitem{latextutorial} Un tutorial propriu-zis: {\em http://www.latex-tutorial.com} +\end{thebibliography} + +% încheie documentul +\end{document} +``` + +## Mai multe despre LaTeX + +* Uimitoarea carte wiki LaTeX: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX) +* Un tutorial propriu-zis: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/) diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown index 125ba2f4..c96e30dc 100644 --- a/ro-ro/python-ro.html.markdown +++ b/ro-ro/python-ro.html.markdown @@ -8,14 +8,16 @@ filename: learnpython-ro.py lang: ro-ro --- -Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a devenit astăzi unul din -cele mai populare limbaje de programare. M-am indrăgostit de Python pentru claritatea sa sintactică. -Python este aproape pseudocod executabil. +Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a +devenit astăzi unul din cele mai populare limbaje de programare. +M-am indrăgostit de Python pentru claritatea sa sintactică. Python este aproape +pseudocod executabil. -Opinia dumneavoastră este binevenită! Puteţi sa imi scrieţi la [@ociule](http://twitter.com/ociule) sau ociule [at] [google's email service] +Opinia dumneavoastră este binevenită! Puteţi sa imi scrieţi la [@ociule](http://twitter.com/ociule) +sau ociule [at] [google's email service] -Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. O versiune Python 3 va apărea -în curând, în limba engleză mai întâi. +Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. +O versiune Python 3 va apărea în curând, în limba engleză mai întâi. ```python # Comentariile pe o singură linie încep cu un caracter diez. @@ -36,7 +38,8 @@ Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. O 10 * 2 #=> 20 35 / 5 #=> 7 -# Împărţirea este un pic surprinzătoare. Este de fapt împărţire pe numere întregi şi rotunjeşte +# Împărţirea este un pic surprinzătoare. Este de fapt împărţire pe numere +# întregi şi rotunjeşte # automat spre valoarea mai mică 5 / 2 #=> 2 diff --git a/ro-ro/xml-ro.html.markdown b/ro-ro/xml-ro.html.markdown new file mode 100644 index 00000000..269010c2 --- /dev/null +++ b/ro-ro/xml-ro.html.markdown @@ -0,0 +1,133 @@ +--- +language: xml +filename: learnxml-ro.xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Serban Constantin", "https://github.com/fuzzmz"] +lang: ro-ro +--- + +XML este un limbaj de markup ce are ca scop stocarea si transportul de date. + +Spre deosebire de HTML, XML nu specifica cum sa fie afisata sau formatata +informatia, ci doar o transporta. + +* Sintaxa XML + +```xml +<!-- Comentariile in XML arata asa --> + +<?xml version="1.0" encoding="UTF-8"?> +<librarie> + <carte categorie="GATIT"> + <titlu limba="ro">Mancaruri italiene</titlu> + <autor>Giada De Laurentiis</autor> + <an>2005</an> + <pret>30.00</pret> + </carte> + <carte categorie="COPII"> + <titlu limba="ro">Harry Potter</titlu> + <autor>J K. Rowling</autor> + <an>2005</an> + <pret>29.99</pret> + </carte> + <carte categorie="WEB"> + <titlu limba="ro">Invata XML</titlu> + <autor>Erik T. Ray</autor> + <an>2003</an> + <pret>39.95</pret> + </carte> +</librarie> + +<!-- Deasupra este un fisier XML obisnuit. + Incepe cu o declaratie ce adauga niste metadata (optional). + + XML foloseste o structura arborescenta. Deasupra, nodul de baza este + 'librarie', care are trei noduri copil, toate 'carti'. Acele noduri au la + randul lor noduri copii si asa mai departe... + + Nodurile sunt create folosind taguri deschise/inchise, iar copii sunt doar + noduri intre tagurile de deschis si inchis.--> + + +<!-- XML transporta doua tipuri de date: + 1 - Atribute -> Metadata despre un nod. + In general, parserul XML foloseste aceasta informatie sa stocheze + proprietatile datelor. + Este caracterizat de aparitia in paranteze in cadrul tagului deschis + 2 - Elemente -> Date pure. + Asta este ceea ce parserul va extrage din documentul XML. + Elementele apar intre tagurile deschis si inchis, fara paranteze. --> + + +<!-- Dedesubt, un element cu doua atribute --> +<file type="gif" id="4293">computer.gif</file> + + +``` + +* Document bine formatat x Validare + +Un document XML este bine formatat daca este corect sintactic. +Cu toate astea este posibil sa injectam mai multe constrangeri in document +folosind definitii precum DTD si XML Schema. + +Un document XML ce foloseste o definitie de document este numit valid in +contextul documentului. + +Cu acest tool poti verifica datele XML in afara codului aplicatiei. + +```xml + +<!-- Dedesubt este o versiune simplificata a documentului librarie, + cu aditia definitiei DTD.--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "Librarie.dtd"> +<librarie> + <carte categorie="GATIT"> + <titlu >Everyday Italian</titlu> + <pret>30.00</pret> + </carte> +</librarie> + +<!-- DTD-ul poate fi ceva similar cu:--> + +<!DOCTYPE note +[ +<!ELEMENT librarie (carte+)> +<!ELEMENT carte (titlu,pret)> +<!ATTLIST carte categorie CDATA "Literatura"> +<!ELEMENT titlu (#PCDATA)> +<!ELEMENT pret (#PCDATA)> +]> + + +<!-- DTD-ul incepe cu o declaratie. + Dupa, nodul de baza este declarat, cerand unul sau mai multe noduri copii + de tipul 'carte'. + Fiecare 'carte' trebuie sa contina exact un 'titlu' si 'pret' si un atribut + numit 'categorie', cu "Literatura" ca valoare implicita. + Nodurile 'titlu' si 'pret' contin parsed character data.--> + +<!-- DTD-ul poate fi declara si in interiorul fisierului XML.--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT librarie (carte+)> +<!ELEMENT carte (titlu,pret)> +<!ATTLIST carte categorie CDATA "Literatura"> +<!ELEMENT titlu (#PCDATA)> +<!ELEMENT pret (#PCDATA)> +]> + +<librarie> + <carte categorie="GATIT"> + <titlu >Everyday Italian</titlu> + <pret>30.00</pret> + </carte> +</librarie> +``` |