Initial commit

Author: armino-dev

1-js/04-object-basics/04-object-methods/2-check-syntax/solution.md

@@ -1,29 +1,29 @@
-**Error**!
+**Eroare**!
 
-Try it:
+Incercați:
 
 ```js run
 let user = {
   name: "John",
   go: function() { alert(this.name) }
 }
 
-(user.go)() // error!
+(user.go)() // eroare!
 ```
 
-The error message in most browsers does not give understanding what went wrong.
+Din mesajul de eroare furnizat de majoritatea browserelor nu reiese ce a mers prost.
 
-**The error appears because a semicolon is missing after `user = {...}`.**
+**Eroarea apare deoarece semicolonul ";" lipsește după `user = {...}`.**
 
-JavaScript does not auto-insert a semicolon before a bracket `(user.go)()`, so it reads the code like:
+Limbajul JavaScript nu adaugă automat un semicolon înainte de paranteză `(user.go)()`, deci citește codul ca:
 
 ```js no-beautify
 let user = { go:... }(user.go)()
 ```
 
-Then we can also see that such a joint expression is syntactically a call of the object `{ go: ... }` as a function with the argument `(user.go)`. And that also happens on the same line with `let user`, so the `user` object has not yet even been defined, hence the error.
+Apoi, putem vedea, de asemenea, că o stfel de expresie combinată este sintactic un apel al obiectului `{ go: ... }` ca funcție cu argumentul `(user.go)`. Și asta se întâmplă și pe aceeași linie cu `let user`, deci obiectul `user` nu a fost încă definit, de unde și eroarea.
 
-If we insert the semicolon, all is fine:
+Dacă introducem un semicolon, totul este în regulă:
 
 ```js run
 let user = {
@@ -34,4 +34,4 @@ let user = {
 (user.go)() // John
 ```
 
-Please note that brackets around `(user.go)` do nothing here. Usually they setup the order of operations, but here the dot `.` works first anyway, so there's no effect. Only the semicolon thing matters.
+Rețineți că parantezele din jurul `(user.go)` nu fc nimic aici. De obicei setează ordinea operațiunilor, dar aici punctul `.` are oricum precedență, deci nu are niciun efect. Singura chestie care contează este semicolonul.

1-js/04-object-basics/04-object-methods/2-check-syntax/task.md

@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Syntax check
+# Verificare de sintaxă
 
-What is the result of this code?
+Care este rezultatul următorului cod?
 
 
 ```js no-beautify
@@ -16,4 +16,4 @@ let user = {
 (user.go)()
 ```
 
-P.S. There's a pitfall :)
+P.S. Există o capcană :)

1-js/04-object-basics/04-object-methods/3-why-this/solution.md

@@ -1,22 +1,21 @@
 
-Here's the explanations.
+Iată explicațiile.
 
-1. That's a regular object method call.
+1. Aceasta este o apelare normală a metodei obiectului.
 
-2. The same, brackets do not change the order of operations here, the dot is first anyway.
+2. Similar, aici, parantezele nu schimbă ordinea operațiunilor, punctul este oricum primul.
 
-3. Here we have a more complex call `(expression).method()`. The call works as if it were split into two lines:
+3. Aici avem un apel mai complex `(expression).method()`. Apelul funcționează ca și cum ar fi împărțit în două linii:
 
     ```js no-beautify
-    f = obj.go; // calculate the expression
-    f();        // call what we have
+    f = obj.go; // calculează expresia
+    f();        // apelează ce avem
     ```
 
-    Here `f()` is executed as a function, without `this`.
+    Aici `f()` este executat ca funcție, fără `this`.
 
-4. The similar thing as `(3)`, to the left of the dot `.` we have an expression.
+4. Chestia similară cu `(3)`, la stânga punctului `.` avem o expresie.
 
-To explain the behavior of `(3)` and `(4)` we need to recall that property accessors (dot or square brackets) return a value of the Reference Type.  
-
-Any operation on it except a method call (like assignment `=` or `||`) turns it into an ordinary value, which does not carry the information allowing to set `this`.
+Pentru a explica comportamentul apelurilor `(3)` și `(4)` trebuie să ne reamintim că accesorii de proprietăți (punct sau paranteze pătrate) returnează o valoare de Tip Referință.  
 
+Orice operațiune pe aceasta, cu excepția unui apel de metodă (precum alocarea `=` sau `||`) o transformă într-o valoare obișnuită, care nu poartă informațiile ce permit setarea variabilei `this`.

1-js/04-object-basics/04-object-methods/3-why-this/task.md

@@ -2,11 +2,11 @@ importance: 3
 
 ---
 
-# Explain the value of "this"
+# Explicați valoarea variabilei "this"
 
-In the code below we intend to call `user.go()` method 4 times in a row.
+În codul următor intenționăm să apelăm metoda `user.go()` de 4 ori la rând.
 
-But calls `(1)` and `(2)` works differently from `(3)` and `(4)`. Why?
+Însă apelurile `(1)` și `(2)` funcționează diferit de `(3)` și `(4)`. De ce?
 
 ```js run no-beautify
 let obj, method;
@@ -23,4 +23,3 @@ obj.go();               // (1) [object Object]
 
 (obj.go || obj.stop)(); // (4) undefined
 ```
-