Constructor, operator "new"

1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md

@@ -1,8 +1,8 @@
-Yes, it's possible.
+Ano, je to možné.
 
-If a function returns an object then `new` returns it instead of `this`.
+Jestliže funkce vrací objekt, pak jej `new` vrátí místo `this`.
 
-So they can, for instance, return the same externally defined object `obj`:
+Mohou tedy například vrátit stejný externě definovaný objekt `obj`:
 
 ```js run no-beautify
 let obj = {};

1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md

@@ -2,18 +2,18 @@ importance: 2
 
 ---
 
-# Two functions – one object
+# Dvě funkce – jeden objekt
 
-Is it possible to create functions `A` and `B` so that `new A() == new B()`?
+Je možné vytvořit funkce `A` a `B` tak, aby `new A() == new B()`?
 
 ```js no-beautify
 function A() { ... }
 function B() { ... }
 
-let a = new A;
-let b = new B;
+let a = new A();
+let b = new B();
 
 alert( a == b ); // true
 ```
 
-If it is, then provide an example of their code.
+Pokud ano, uveďte příklad jejich kódu.

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/solution.js

@@ -1,15 +1,15 @@
-function Calculator() {
+function Kalkulátor() {
 
-  this.read = function() {
+  this.načti = function() {
     this.a = +prompt('a?', 0);
     this.b = +prompt('b?', 0);
   };
 
-  this.sum = function() {
+  this.součet = function() {
     return this.a + this.b;
   };
 
-  this.mul = function() {
+  this.součin = function() {
     return this.a * this.b;
   };
 }

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js

@@ -1,27 +1,27 @@
 
-describe("calculator", function() {
-  let calculator;
+describe("kalkulátor", function() {
+  let kalkulátor;
   before(function() {
     sinon.stub(window, "prompt")
 
     prompt.onCall(0).returns("2");
     prompt.onCall(1).returns("3");
 
-    calculator = new Calculator();
-    calculator.read();
+    kalkulátor = new Kalkulátor();
+    kalkulátor.read();
   });
 
-  it("the read method asks for two values using prompt and remembers them in object properties", function() {
-    assert.equal(calculator.a, 2);
-    assert.equal(calculator.b, 3);
+  it("funkce načti se zeptá na dvě hodnoty pomocí prompt a zapamatuje si je jako vlastnosti objektu", function() {
+    assert.equal(kalkulátor.a, 2);
+    assert.equal(kalkulátor.b, 3);
   });
 
-  it("when 2 and 3 are entered, the sum is 5", function() {
-    assert.equal(calculator.sum(), 5);
+  it("když zadáme 2 a 3, součet je 5", function() {
+    assert.equal(kalkulátor.součet(), 5);
   });
 
-  it("when 2 and 3 are entered, the product is 6", function() {
-    assert.equal(calculator.mul(), 6);
+  it("když zadáme 2 a 3, součin je 6", function() {
+    assert.equal(kalkulátor.součin(), 6);
   });
 
   after(function() {

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/solution.md

@@ -1,23 +1,23 @@
 ```js run demo
-function Calculator() {
+function Kalkulátor() {
 
-  this.read = function() {
+  this.načti = function() {
     this.a = +prompt('a?', 0);
     this.b = +prompt('b?', 0);
   };
 
-  this.sum = function() {
+  this.součet = function() {
     return this.a + this.b;
   };
 
-  this.mul = function() {
+  this.součin = function() {
     return this.a * this.b;
   };
 }
 
-let calculator = new Calculator();
-calculator.read();
+let kalkulátor = new Kalkulátor();
+kalkulátor.načti();
 
-alert( "Sum=" + calculator.sum() );
-alert( "Mul=" + calculator.mul() );
+alert( "Součet=" + kalkulátor.součet() );
+alert( "Součin=" + kalkulátor.součin() );
 ```

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md

@@ -2,22 +2,22 @@ importance: 5
 
 ---
 
-# Create new Calculator
+# Vytvořte nový Kalkulátor
 
-Create a constructor function `Calculator` that creates objects with 3 methods:
+Vytvořte konstruktor `Kalkulátor`, který bude vytvářet objekty se třemi metodami:
 
-- `read()` asks for two values using `prompt` and remembers them in object properties.
-- `sum()` returns the sum of these properties.
-- `mul()` returns the multiplication product of these properties.
+- `načti()` se funkcí `prompt` zeptá na dvě hodnoty a uloží je jako vlastnosti objektu s názvy po řadě `a` a `b`.
+- `součet()` vrátí součet těchto hodnot.
+- `součin()` vrátí součin těchto hodnot.
 
-For instance:
+Například:
 
 ```js
-let calculator = new Calculator();
-calculator.read();
+let kalkulátor = new Kalkulátor();
+kalkulátor.načti();
 
-alert( "Sum=" + calculator.sum() );
-alert( "Mul=" + calculator.mul() );
+alert( "Součet=" + kalkulátor.součet() );
+alert( "Součin=" + kalkulátor.součin() );
 ```
 
 [demo]

1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js

@@ -1,8 +1,8 @@
-function Accumulator(startingValue) {
-  this.value = startingValue;
+function Akumulátor(počátečníHodnota) {
+  this.hodnota = počátečníHodnota;
 
-  this.read = function() {
-    this.value += +prompt('How much to add?', 0);
+  this.načti = function() {
+    this.hodnota += +prompt('Kolik přičíst?', 0);
   };
 
-}
+}

1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js

@@ -1,4 +1,4 @@
-describe("Accumulator", function() {
+describe("Akumulátor", function() {
 
   beforeEach(function() {
     sinon.stub(window, "prompt")
@@ -8,23 +8,23 @@ describe("Accumulator", function() {
     prompt.restore();
   });
 
-  it("initial value is the argument of the constructor", function() {
-    let accumulator = new Accumulator(1);
+  it("úvodní hodnota je argument konstruktoru", function() {
+    let akumulátor = new Akumulátor(1);
 
-    assert.equal(accumulator.value, 1);
+    assert.equal(akumulátor.hodnota, 1);
   });
 
-  it("after reading 0, the value is 1", function() {
-    let accumulator = new Accumulator(1);
+  it("po načtení 0 je hodnota 1", function() {
+    let akumulátor = new Akumulátor(1);
     prompt.returns("0");
-    accumulator.read();
-    assert.equal(accumulator.value, 1);
+    akumulátor.načti();
+    assert.equal(akumulátor.hodnota, 1);
   });
 
-  it("after reading 1, the value is 2", function() {
-    let accumulator = new Accumulator(1);
+  it("po načtení 1 je hodnota 2", function() {
+    let akumulátor = new Akumulátor(1);
     prompt.returns("1");
-    accumulator.read();
-    assert.equal(accumulator.value, 2);
+    akumulátor.načti();
+    assert.equal(akumulátor.hodnota, 2);
   });
 });

1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md

@@ -1,17 +1,17 @@
 
 
 ```js run demo
-function Accumulator(startingValue) {
-  this.value = startingValue;
+function Akumulátor(počátečníHodnota) {
+  this.hodnota = počátečníHodnota;
 
-  this.read = function() {
-    this.value += +prompt('How much to add?', 0);
+  this.načti = function() {
+    this.hodnota += +prompt('Kolik přičíst?', 0);
   };
 
 }
 
-let accumulator = new Accumulator(1);
-accumulator.read();
-accumulator.read();
-alert(accumulator.value);
+let akumulátor = new Akumulátor(1);
+akumulátor.načti();
+akumulátor.načti();
+alert(akumulátor.hodnota);
 ```

1-js/04-object-basics/06-constructor-new/3-accumulator/task.md

@@ -2,26 +2,26 @@ importance: 5
 
 ---
 
-# Create new Accumulator
+# Vytvořte nový Akumulátor
 
-Create a constructor function `Accumulator(startingValue)`.
+Vytvořte konstruktor `Akumulátor(počátečníHodnota)`.
 
-Object that it creates should:
+Objekt, který je tímto konstruktorem vytvořen, by měl:
 
-- Store the "current value" in the property `value`. The starting value is set to the argument of the constructor `startingValue`.
-- The `read()` method should use `prompt` to read a new number and add it to `value`.
+- Ukládat „aktuální hodnotu“ do vlastnosti `hodnota`. Počáteční hodnota se nastaví na argument konstruktoru `počátečníHodnota`.
+- Metoda `načti()` by se měla pomocí `prompt` zeptat na nové číslo a přičíst je k vlastnosti `hodnota`.
 
-In other words, the `value` property is the sum of all user-entered values with the initial value  `startingValue`.
+Jinými slovy, vlastnost `hodnota` bude součet všech uživatelem zadaných hodnot a úvodní hodnoty `počátečníHodnota`.
 
-Here's the demo of the code:
+Zde je ukázka kódu:
 
 ```js
-let accumulator = new Accumulator(1); // initial value 1
+let akumulátor = new Akumulátor(1); // počáteční hodnota 1
 
-accumulator.read(); // adds the user-entered value
-accumulator.read(); // adds the user-entered value
+akumulátor.načti(); // přičte uživatelem zadanou hodnotu
+akumulátor.načti(); // přičte uživatelem zadanou hodnotu
 
-alert(accumulator.value); // shows the sum of these values
+alert(akumulátor.hodnota); // zobrazí součet těchto hodnot
 ```
 
 [demo]