Merge pull request #180 from otmon76/1.8.4

Prototype methods, objects without __proto__

Author: otmon76

1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md

@@ -1,31 +1,31 @@
 
-The method can take all enumerable keys using `Object.keys` and output their list.
+Metoda může vzít všechny enumerovatelné klíče pomocí `Object.keys` a vydat jejich seznam.
 
-To make `toString` non-enumerable, let's define it using a property descriptor. The syntax of `Object.create` allows us to provide an object with property descriptors as the second argument.
+Abychom učinili `toString` neenumerovatelnou, definujme ji pomocí deskriptoru vlastnosti. Syntaxe `Object.create` nám umožní jako druhý argument poskytnout objekt s deskriptory vlastností.
 
 ```js run
 *!*
-let dictionary = Object.create(null, {
-  toString: { // define toString property
-    value() { // the value is a function
+let slovník = Object.create(null, {
+  toString: { // definujeme vlastnost toString
+    value() { // její hodnotou je funkce
       return Object.keys(this).join();
     }
   }
 });
 */!*
 
-dictionary.apple = "Apple";
-dictionary.__proto__ = "test";
+slovník.jablko = "Jablko";
+slovník.__proto__ = "test";
 
-// apple and __proto__ is in the loop
-for(let key in dictionary) {
-  alert(key); // "apple", then "__proto__"
+// v cyklu jsou jablko a __proto__
+for(let klíč in slovník) {
+  alert(klíč); // "jablko", pak "__proto__"
 }  
 
-// comma-separated list of properties by toString
-alert(dictionary); // "apple,__proto__"
+// seznam vlastností oddělených čárkou, vydaný metodou toString
+alert(slovník); // "jablko,__proto__"
 ```
 
-When we create a property using a descriptor, its flags are `false` by default. So in the code above, `dictionary.toString` is non-enumerable.
+Když vytvoříme vlastnost použitím deskriptoru, její přepínače jsou standardně `false`. V uvedeném kódu je tedy `slovník.toString` neenumerovatelná.
 
-See the chapter [](info:property-descriptors) for review.
+Pro přehled nahlédněte do kapitoly [](info:property-descriptors).

1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/task.md

@@ -2,30 +2,30 @@ importance: 5
 
 ---
 
-# Add toString to the dictionary
+# Přidejte toString do slovníku
 
-There's an object `dictionary`, created as `Object.create(null)`, to store any `key/value` pairs.
+Máme objekt `slovník` vytvořený použitím `Object.create(null)`, do něhož ukládáme libovolné dvojice `klíč/hodnota`.
 
-Add method `dictionary.toString()` into it, that should return a comma-delimited list of keys. Your `toString` should not show up in `for..in` over the object.
+Přidejte do něj metodu `slovník.toString()`, která by měla vracet seznam klíčů oddělených čárkou. Vaše metoda `toString` by se neměla ukazovat v cyklu `for..in` nad objektem.
 
-Here's how it should work:
+Takto by to mělo fungovat:
 
 ```js
-let dictionary = Object.create(null);
+let slovník = Object.create(null);
 
 *!*
-// your code to add dictionary.toString method
+// váš kód přidávající metodu slovník.toString
 */!*
 
-// add some data
-dictionary.apple = "Apple";
-dictionary.__proto__ = "test"; // __proto__ is a regular property key here
+// přidáme nějaká data
+slovník.jablko = "Jablko";
+slovník.__proto__ = "test"; // __proto__ je zde klíč obvyklé vlastnosti
 
-// only apple and __proto__ are in the loop
-for(let key in dictionary) {
-  alert(key); // "apple", then "__proto__"
+// v cyklu jsou jen jablko a __proto__
+for(let klíč in slovník) {
+  alert(klíč); // "jablko", pak "__proto__"
 }  
 
-// your toString in action
-alert(dictionary); // "apple,__proto__"
+// váš toString v akci
+alert(slovník); // "jablko,__proto__"
 ```

1-js/08-prototypes/04-prototype-methods/3-compare-calls/solution.md

@@ -1,20 +1,20 @@
 
-The first call has `this == rabbit`, the other ones have `this` equal to `Rabbit.prototype`, because it's actually the object before the dot.
+První volání má `this == králík`, v ostatních je `this` rovno `Králík.prototype`, protože je to ve skutečnosti objekt před tečkou.
 
-So only the first call shows `Rabbit`, other ones show `undefined`:
+Jedině první volání tedy zobrazí `Králík`, ostatní zobrazí `undefined`:
 
 ```js run
-function Rabbit(name) {
-  this.name = name;
+function Králík(jméno) {
+  this.jméno = jméno;
 }
-Rabbit.prototype.sayHi = function() {
-  alert( this.name );
+Králík.prototype.řekniAhoj = function() {
+  alert( this.jméno );
 }
 
-let rabbit = new Rabbit("Rabbit");
+let králík = new Králík("Králík");
 
-rabbit.sayHi();                        // Rabbit
-Rabbit.prototype.sayHi();              // undefined
-Object.getPrototypeOf(rabbit).sayHi(); // undefined
-rabbit.__proto__.sayHi();              // undefined
+králík.řekniAhoj();                        // Králík
+Králík.prototype.řekniAhoj();              // undefined
+Object.getPrototypeOf(králík).řekniAhoj(); // undefined
+králík.__proto__.řekniAhoj();              // undefined
 ```

1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md

@@ -2,26 +2,26 @@ importance: 5
 
 ---
 
-# The difference between calls
+# Rozdíl mezi voláními
 
-Let's create a new `rabbit` object:
+Vytvořme nový objekt `králík`:
 
 ```js
-function Rabbit(name) {
-  this.name = name;
+function Králík(jméno) {
+  this.jméno = jméno;
 }
-Rabbit.prototype.sayHi = function() {
-  alert(this.name);
+Králík.prototype.řekniAhoj = function() {
+  alert(this.jméno);
 };
 
-let rabbit = new Rabbit("Rabbit");
+let králík = new Králík("Králík");
 ```
 
-These calls do the same thing or not?
+Učiní všechna tato volání totéž, nebo ne?
 
 ```js
-rabbit.sayHi();
-Rabbit.prototype.sayHi();
-Object.getPrototypeOf(rabbit).sayHi();
-rabbit.__proto__.sayHi();
+králík.řekniAhoj();
+Králík.prototype.řekniAhoj();
+Object.getPrototypeOf(králík).řekniAhoj();
+králík.__proto__.řekniAhoj();
 ```