renovations

1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/solution.md

@@ -0,0 +1,19 @@
+Да, возможны.
+
+Они должны возвращать одинаковый объект. При этом если функция возвращает объект, то `this` не используется.
+
+Например, они могут вернуть один и тот же объект `obj`, определённый снаружи:
+
+```js
+//+ run
+var obj = {};
+
+function A() { return obj; }
+function B() { return obj; }
+
+var a = new A;
+var b = new B;
+
+alert( a == b ); // true
+```
+

1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/task.md

@@ -0,0 +1,17 @@
+# Две функции один объект
+
+[importance 2]
+
+Возможны ли такие функции `A` и `B` в примере ниже, что соответствующие объекты `a,b` равны (см. код ниже)?
+
+```js
+function A() { ... }
+function B() { ... }
+
+var a = new A;
+var b = new B;
+
+alert( a == b ); // true
+```
+
+Если да -- приведите пример кода с такими функциями. 

1-js/6-objects-more/3-constructor-new/2-calculator-constructor/_js.view/solution.js

@@ -0,0 +1,15 @@
+function Calculator() {
+
+  this.read = function() {
+    this.a = +prompt('a?', 0); 
+    this.b = +prompt('b?', 0);
+  };
+
+  this.sum = function() {
+    return this.a + this.b;
+  };
+
+  this.mul = function() {
+    return this.a * this.b;
+  };
+}

1-js/6-objects-more/3-constructor-new/2-calculator-constructor/_js.view/test.js

@@ -0,0 +1,25 @@
+sinon.stub(window, "prompt")
+
+prompt.onCall(0).returns("2");
+prompt.onCall(1).returns("3");
+
+describe("calculator", function() {
+  var calculator;
+  before(function() {
+    calculator = new Calculator();
+    calculator.read();
+  });
+
+  it("при вводе 2 и 3 сумма равна 5", function() {
+    assert.equal( calculator.sum(), 5 );
+  });
+
+  it("при вводе 2 и 3 произведение равно 6", function() {
+    assert.equal( calculator.mul(), 6 );
+  });
+
+});
+
+after(function() {
+  prompt.restore();
+});

1-js/6-objects-more/3-constructor-new/2-calculator-constructor/solution.md

@@ -0,0 +1,27 @@
+
+
+```js
+//+ run demo
+function Calculator() {
+
+  this.read = function() {
+    this.a = +prompt('a?', 0); 
+    this.b = +prompt('b?', 0);
+  };
+
+  this.sum = function() {
+    return this.a + this.b;
+  };
+
+  this.mul = function() {
+    return this.a * this.b;
+  };
+}
+
+var calculator = new Calculator();
+calculator.read();
+
+alert( "Сумма=" + calculator.sum() );
+alert( "Произведение=" + calculator.mul() );
+```
+

1-js/6-objects-more/3-constructor-new/2-calculator-constructor/task.md

@@ -0,0 +1,22 @@
+# Создать Calculator при помощи конструктора
+
+[importance 5]
+
+Напишите *функцию-конструктор* `Calculator`, которая создает объект с двумя методами:
+<ul>
+<li>Метод `read()` запрашивает два значения при помощи `prompt` и запоминает их в свойствах объекта.</li>
+<li>Метод `sum()` возвращает сумму запомненных свойств.</li>
+<li>Метод `mul()` возвращает произведение запомненных свойств.</li>
+</ul>
+
+Пример использования:
+
+```js
+var calculator = new Calculator();
+calculator.read();
+
+alert( "Сумма=" + calculator.sum() );
+alert( "Произведение=" + calculator.mul() );
+```
+
+[demo /]

1-js/6-objects-more/3-constructor-new/3-accumulator/_js.view/solution.js

@@ -0,0 +1,8 @@
+function Accumulator(startingValue) {
+  this.value = startingValue;
+
+  this.read = function() {
+    this.value += +prompt('Сколько добавлять будем?', 0);
+  };
+
+}

1-js/6-objects-more/3-constructor-new/3-accumulator/_js.view/test.js

@@ -0,0 +1,37 @@
+describe("Accumulator(1)", function() {
+  var accumulator;
+  before(function() {
+    accumulator = new Accumulator(1);
+  });
+
+  beforeEach(function() {
+    sinon.stub(window, "prompt")
+  });
+
+  afterEach(function() {
+    prompt.restore();
+  });
+
+  it("начальное значение 1", function() {
+    assert.equal( accumulator.value, 1 );
+  });
+
+  it("после ввода 0 значение 1", function() {
+    prompt.returns("0");
+    accumulator.read();
+    assert.equal( accumulator.value, 1 );
+  });
+
+  it("после ввода 1 значение 2", function() {
+    prompt.returns("1");
+    accumulator.read();
+    assert.equal( accumulator.value, 2 );
+  });
+
+  it("после ввода 2 значение 4", function() {
+    prompt.returns("2");
+    accumulator.read();
+    assert.equal( accumulator.value, 4 );
+  });
+
+});

1-js/6-objects-more/3-constructor-new/3-accumulator/solution.md

@@ -0,0 +1,19 @@
+
+
+```js
+//+ run demo
+function Accumulator(startingValue) {
+  this.value = startingValue;
+
+  this.read = function() {
+    this.value += +prompt('Сколько добавлять будем?', 0);
+  };
+
+}
+
+var accumulator = new Accumulator(1);
+accumulator.read();
+accumulator.read();
+alert( accumulator.value );
+```
+

1-js/6-objects-more/3-constructor-new/3-accumulator/task.md

@@ -0,0 +1,24 @@
+# Создать Accumulator при помощи конструктора
+
+[importance 5]
+
+Напишите *функцию-конструктор* `Accumulator(startingValue)`. 
+Объекты, которые она создает, должны хранить текущую сумму и прибавлять к ней то, что вводит посетитель.
+
+Более формально, объект должен:
+<ul>
+<li>Хранить текущее значение в своём свойстве `value`. Начальное значение свойства `value` ставится конструктором равным `startingValue`.</li>
+<li>Метод `read()` вызывает `prompt`, принимает число и прибавляет его к свойству `value`.</li> 
+</ul>
+Таким образом, свойство `value` является текущей суммой всего, что ввел посетитель при вызовах метода `read()`, с учетом начального значения `startingValue`.
+
+Ниже вы можете посмотреть работу кода:
+
+```js
+var accumulator = new Accumulator(1); // начальное значение 1
+accumulator.read(); // прибавит ввод prompt к текущему значению
+accumulator.read(); // прибавит ввод prompt к текущему значению
+alert( accumulator.value ); // выведет текущее значение
+```
+
+[demo /]

1-js/6-objects-more/3-constructor-new/4-calculator-extendable/_js.view/solution.js

@@ -0,0 +1,29 @@
+function Calculator() {
+
+  var methods = {
+    "-": function(a, b) {
+      return a - b;
+    },
+    "+": function(a, b) {
+      return a + b;
+    }
+  };
+
+  this.calculate = function(str) {
+
+    var split = str.split(' '),
+      a = +split[0],
+      op = split[1],
+      b = +split[2]
+
+    if(!methods[op] || isNaN(a) || isNaN(b)) {
+      return NaN;
+    }
+
+    return methods[op](+a, +b);
+  }
+
+  this.addMethod = function(name, func) {
+    methods[name] = func;
+  };
+}

1-js/6-objects-more/3-constructor-new/4-calculator-extendable/_js.view/test.js

@@ -0,0 +1,26 @@
+var calculator;
+before(function() {
+  calculator = new Calculator;
+});
+
+it("calculate(12 + 34) = 46", function() {
+  assert.equal( calculator.calculate("12 + 34"), 46 );
+});
+
+it("calculate(34 - 12) = 22", function() {
+  assert.equal( calculator.calculate("34 - 12"), 22 );
+});
+
+it("добавили умножение: calculate(2 * 3) = 6", function() {
+  calculator.addMethod("*", function(a, b) {
+    return a * b;
+  });
+  assert.equal( calculator.calculate("2 * 3"), 6 );
+});
+
+it("добавили возведение в степень: calculate(2 ** 3) = 8", function() {
+  calculator.addMethod("**", function(a, b) {
+    return Math.pow(a, b);
+  });
+  assert.equal( calculator.calculate("2 ** 3"), 8 );
+});

1-js/6-objects-more/3-constructor-new/4-calculator-extendable/solution.md

@@ -0,0 +1,55 @@
+
+
+```js
+//+ run
+function Calculator() {
+
+  var methods = {
+    "-": function(a, b) {
+      return a - b;
+    },
+    "+": function(a, b) {
+      return a + b;
+    }
+  };
+
+  this.calculate = function(str) {
+
+    var split = str.split(' '),
+      a = +split[0],
+      op = split[1],
+      b = +split[2]
+
+    if(!methods[op] || isNaN(a) || isNaN(b)) {
+      return NaN;
+    }
+
+    return methods[op](+a, +b);
+  }
+
+  this.addMethod = function(name, func) {
+    methods[name] = func;
+  };
+}
+
+var calc = new Calculator;
+
+calc.addMethod("*", function(a, b) {
+  return a * b;
+});
+calc.addMethod("/", function(a, b) {
+  return a / b;
+});
+calc.addMethod("**", function(a, b) {
+  return Math.pow(a, b);
+});
+
+var result = calc.calculate("2 ** 3");
+alert(result); // 8
+```
+
+<ul>
+<li>Обратите внимание на хранение методов. Они просто добавляются к внутреннему объекту.</li>
+<li>Все проверки и преобразование к числу производятся в методе `calculate`. В дальнейшем он может быть расширен для поддержки более сложных выражений.</li>
+</ul>
+

1-js/6-objects-more/3-constructor-new/4-calculator-extendable/task.md

@@ -0,0 +1,41 @@
+# Создайте калькулятор
+
+[importance 5]
+
+Напишите конструктор `Calculator`, который создаёт расширяемые объекты-калькуляторы.
+
+Эта задача состоит из двух частей, которые можно решать одна за другой.
+<ol>
+<li>Первый шаг задачи: вызов `calculate(str)` принимает строку, например "1 + 2", с жёстко заданным форматом "ЧИСЛО операция ЧИСЛО" (по одному пробелу вокруг операции), и возвращает результат. Понимает плюс `+` и минус `-`.
+
+Пример использования:
+
+```js
+var calc = new Calculator;
+
+alert(calc.calculate("3 + 7")); // 10
+```
+
+</li>
+<li>Второй шаг -- добавить калькулятору метод `addMethod(name, func)`, который учит калькулятор новой операции. Он получает имя операции `name` и функцию от двух аргументов `func(a,b)`, которая должна её реализовывать.
+
+Например, добавим операции умножить `*`, поделить `/` и возвести в степень `**`:
+
+```js
+var powerCalc = new Calculator;
+powerCalc.addMethod("*", function(a, b) { return a * b; });
+powerCalc.addMethod("/", function(a, b) { return a / b; });
+powerCalc.addMethod("**", function(a, b) { return Math.pow(a, b); });
+
+var result = powerCalc.calculate("2 ** 3");
+alert(result); // 8
+```
+
+</li>
+</ol>
+
+<ul>
+<li>Поддержка скобок и сложных математических выражений в этой задаче не требуется.</li>
+<li>Числа и операции могут состоять из нескольких символов. Между ними ровно один пробел.</li>
+<li>Предусмотрите обработку ошибок. Какая она должна быть - решите сами.</li>
+</ul>

1-js/6-objects-more/3-constructor-new/article.md

@@ -0,0 +1,191 @@
+# Создание объектов через "new"
+
+Обычный синтаксис `{...}` позволяет создать один объект. Но зачастую нужно создать много однотипных объектов.
+
+Для этого используют "функции-конструкторы", запуская их при помощи специального оператора `new`.
+[cut]
+## Конструктор
+
+Конструктором становится любая функция, вызванная через `new`.
+
+Например:
+
+```js
+function Animal(name) {
+  this.name = name;
+  this.canWalk = true;  
+}
+
+*!*
+var animal = new Animal("ёжик");
+*/!*
+```
+
+Технически, любую функцию можно вызвать при помощи `new`. Но при этом она работает несколько иным образом, чем обычно, поэтому функции, предназначенные к вызову через `new`, называют с большой буквы.
+
+**Алгоритм работы функции, запущенной через `new`:**
+
+<ol>
+<li>Автоматически создается новый пустой объект.</li>
+<li>Ключевое слово `this` получает ссылку на этот объект.</li>
+<li>Функция выполняется. Как правило, она модифицирует `this`, добавляет методы, свойства.</li>
+<li>Возвращается `this`.</li>
+</ol>
+
+
+В результате вызова `new Animal("ёжик");` получаем такой объект:
+
+```js
+animal = {
+  name: "ёжик",
+  canWalk: true
+}
+```
+
+Иными словами, при вызове `new Animal` происходит что-то в таком духе (первая и последняя строка -- это то, что делает интерпретатор):
+
+```js
+function Animal(name) {
+*!*
+  // this = {}
+*/!*
+
+  // в this пишем свойства, методы  
+  this.name = name;
+  this.canWalk = true;  
+
+*!*
+  // return this
+*/!*
+}
+```
+
+## Правила обработки return
+
+Как правило, конструкторы ничего не возвращают. Их задача -- записать всё, что нужно, в `this`, который автоматически станет результатом.
+
+Но если явный вызов `return` всё же есть, то применяется простое правило:
+<ul>
+<li>При вызове `return` с объектом, будет возвращён он, а не `this`.</li>
+<li>При вызове `return` с примитивным значением, оно будет отброшено.</li>
+</ul>
+
+Иными словами, вызов `return` с объектом вернёт объект, а с чем угодно, кроме объекта -- возвратит, как обычно, `this`.
+
+Например, возврат объекта:
+
+```js
+//+ run
+function BigAnimal() {
+
+  this.name = "Мышь";
+
+  return { name: "Годзилла" };  // <-- возвратим объект
+}
+
+alert( new BigAnimal().name );  // Годзилла, получили объект вместо this
+```
+
+А вот пример с возвратом строки:
+
+```js
+//+ run
+function BigAnimal() {
+
+  this.name = "Мышь";
+
+  return "Годзилла"; // <-- возвратим примитив
+}
+
+alert( new BigAnimal().name );  // Мышь, получили this (а Годзилла пропал)
+```
+
+Эта особенность работы `new` прописана в стандарте, но используется она весьма редко.
+
+[smart header="Можно без скобок"]
+Кстати, при вызове `new` без аргументов скобки можно не ставить:
+
+```js
+var animal = new BigAnimal; // <-- без скобок
+// то же самое что 
+var animal = new BigAnimal();
+```
+
+Не сказать, что выбрасывание скобок -- "хороший стиль", но такой синтаксис допустим стандартом.
+[/smart]
+
+## Создание методов в конструкторе   
+
+Использование функций для создания объекта дает большую гибкость. Можно передавать конструктору параметры,  определяющие как его создавать, и он будет "клепать" объекты заданным образом.
+
+Добавим в создаваемый объект ещё и метод.
+
+Например, `new User(name)` создает объект с заданным значением свойства `name` и методом `sayHi`:
+
+```js
+//+ run
+function User(name) {
+  this.name = name;
+ 
+  this.sayHi = function() {
+    alert("Моё имя: " + this.name);
+  };
+}
+
+*!*
+var ivan = new User("Иван");
+
+ivan.sayHi(); // Моё имя: Иван
+*/!*
+
+/* 
+ivan = {
+   name: "Иван", 
+   sayHi: функция
+} 
+*/
+```
+
+## Локальные переменные   
+
+В функции-конструкторе бывает удобно объявить вспомогательные локальные переменные и вложенные функции, которые будут видны только внутри:
+
+```js
+//+ run
+function User(firstName, lastName) {
+*!*
+  // вспомогательная переменная
+  var phrase = "Привет";
+ 
+  //  вспомогательная вложенная функция
+  function getFullName() { 
+    return firstName + " " + lastName;
+  }
+*/!*
+ 
+  this.sayHi = function() {
+    alert(phrase + ", " + getFullName()); // использование
+  };
+}
+
+var vasya = new User("Вася", "Петров");
+vasya.sayHi(); // Вася Петров
+```
+
+Мы уже говорили об этом подходе ранее, в главе [](/closures-usage). 
+
+Те функции и данные, которые должны быть доступны для внешнего кода, мы пишем в `this` -- и к ним можно будет обращаться, как например `vasya.sayHi()`, а вспомогательные, которые нужны только внутри самого объекта, сохраняем в локальной области видимости.
+
+## Итого
+
+Объекты могут быть созданы при помощи функций-конструкторов:
+
+<ul>
+<li>Любая функция может быть вызвана с `new`, при этом она получает новый пустой объект в качестве `this`, в который она добавляет свойства. Если функция не решит возвратить свой объект, то её результатом будет `this`.</li>
+<li>Функции, которые предназначены для создания объектов, называются *конструкторами*. Их названия пишут с большой буквы, чтобы отличать от обычных.</li>
+</ul>
+
+
+
+
+