More examples translated

Author: armino-dev

1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md

@@ -1,6 +1,6 @@
-**Answer: an error.**
+**Răspuns: o eroare.**
 
-Try it:
+Încercați:
 ```js run
 function makeUser() {
   return {
@@ -11,18 +11,18 @@ function makeUser() {
 
 let user = makeUser();
 
-alert( user.ref.name ); // Error: Cannot read property 'name' of undefined
+alert( user.ref.name ); // Eroare: Cannot read property 'name' of undefined
 ```
 
-That's because rules that set `this` do not look at object definition. Only the moment of call matters.
+Acest lucru se datorează faptului că regulile care setează `this` nu se uita la definirea obiectului. Doar momentul apelului contează .
 
-Here the value of `this` inside `makeUser()` is `undefined`, because it is called as a function, not as a method with "dot" syntax.
+Aici valoarea variabilei `this` din interiorul funcției `makeUser()` este `undefined`, deoarece este apelată ca funcție, nu ca o metodă cu sintaxa "punct".
 
-The value of `this` is one for the whole function, code blocks and object literals do not affect it.
+Valoarea variabilei `this` este unică pentru întreaga funcția, blocurile de cod și obiectele literale nu o afectează.
 
-So `ref: this` actually takes current `this` of the function.
+În concluzie `ref: this` preia de fapt variabila curentă `this` a funcției.
 
-Here's the opposite case:
+Iată cazul opus:
 
 ```js run
 function makeUser() {
@@ -41,4 +41,4 @@ let user = makeUser();
 alert( user.ref().name ); // John
 ```
 
-Now it works, because `user.ref()` is a method. And the value of `this` is set to the object before dot `.`.
+Acum funcționează, pentru că `user.ref()` este o metodă. Iar valoarea variabilei `this` este setată la obiectul dinaintea punctului `.`.

1-js/04-object-basics/04-object-methods/4-object-property-this/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Using "this" in object literal
+# Folosirea "this" în obiect literal
 
-Here the function `makeUser` returns an object.
+Aici funcția `makeUser` returnează un obiect.
 
-What is the result of accessing its `ref`? Why?
+Care este rezultatul accesării proprietății `ref`? De ce?
 
 ```js
 function makeUser() {
@@ -18,6 +18,5 @@ function makeUser() {
 
 let user = makeUser();
 
-alert( user.ref.name ); // What's the result?
+alert( user.ref.name ); // Care este rezultatul?
 ```
-

1-js/04-object-basics/04-object-methods/7-calculator/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Create a calculator
+# Creați un calculator
 
-Create an object `calculator` with three methods:
+Creați un obiect `calculator` cu trei metode:
 
-- `read()` prompts for two values and saves them as object properties.
-- `sum()` returns the sum of saved values.
-- `mul()` multiplies saved values and returns the result.
+- `read()` solicită două valori și le salvează ca proprietăți ale obiectului.
+- `sum()` returnează suma valorilor salvate.
+- `mul()` multiplică valorile salvate și returnează rezultatul.
 
 ```js
 let calculator = {
-  // ... your code ...
+  // ... codul vostru ...
 };
 
 calculator.read();
@@ -21,4 +21,3 @@ alert( calculator.mul() );
 ```
 
 [demo]
-

1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md

@@ -1,4 +1,4 @@
-The solution is to return the object itself from every call.
+Soluția este de a returna obiectul însuși la fiecare apelare.
 
 ```js run demo
 let ladder = {
@@ -26,7 +26,7 @@ let ladder = {
 ladder.up().up().down().up().down().showStep(); // 1
 ```
 
-We also can write a single call per line. For long chains it's more readable:
+De asemenea, putem scrie câte o apelare pe linie. Pentru lanțurile lungi este mai lizibil:
 
 ```js
 ladder

1-js/04-object-basics/04-object-methods/8-chain-calls/task.md

@@ -2,26 +2,26 @@ importance: 2
 
 ---
 
-# Chaining
+# Înlănțuirea
 
-There's a `ladder` object that allows to go up and down:
+Există un obiect `ladder` (scară) care permite urcarea și coborârea:
 
 ```js
 let ladder = {
   step: 0,
-  up() { 
+  up() {
     this.step++;
   },
-  down() { 
+  down() {
     this.step--;
   },
-  showStep: function() { // shows the current step
+  showStep: function() { // arată pasul curent
     alert( this.step );
   }
 };
 ```
 
-Now, if we need to make several calls in sequence, can do it like this:
+În acest moment, dacă avem nevoie să facem mai multe apelări în ordine, le putem face astfel:
 
 ```js
 ladder.up();
@@ -30,10 +30,10 @@ ladder.down();
 ladder.showStep(); // 1
 ```
 
-Modify the code of `up`, `down` and `showStep` to make the calls chainable, like this:
+Modificați codul pentru `up`, `down` și `showStep` pentru a face apelările înlănțuibile, astfel:
 
 ```js
 ladder.up().up().down().showStep(); // 1
 ```
 
-Such approach is widely used across JavaScript libraries.
+Asemenea abordare este utilizată pe scară largă în librăriile JavaScript.