Merge branch 'ru' of https://github.com/iliakan/javascript-tutorial into ru

iliakan · iliakan · commit 53c1104d4140 · 2016-01-05T00:35:08.000+03:00
diff --git a/1-js/4-data-structures/9-array-iteration/article.md b/1-js/4-data-structures/9-array-iteration/article.md
@@ -8,7 +8,7 @@
 
 Метод ["arr.forEach(callback[, thisArg])"](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach) используется для перебора массива.
 
-Он для каждого элемента массива вызывает функцию `callback`. 
+Он для каждого элемента массива вызывает функцию `callback`.
 
 Этой функции он передаёт три параметра `callback(item, i, arr)`:
 
@@ -120,17 +120,17 @@ alert( arr.some(isPositive) ); // true, есть хоть одно положи
 
 Кроме `callback`, методу можно передать "начальное значение" -- аргумент `initialValue`. Если он есть, то на первом вызове значение `previousValue` будет равно `initialValue`, а если у `reduce` нет второго аргумента, то оно равно первому элементу массива, а перебор начинается со второго.
 
-Проще всего понять работу метода `reduce` на примере. 
+Проще всего понять работу метода `reduce` на примере.
 
-Например, в качестве "свёртки" мы хотим получить сумму всех элементов массива. 
+Например, в качестве "свёртки" мы хотим получить сумму всех элементов массива.
 
 Вот решение в одну строку:
 
 ```js
 //+ run
 var arr = [1, 2, 3, 4, 5]
 
-// для каждого элемента массива запустить функцию, 
+// для каждого элемента массива запустить функцию,
 // промежуточный результат передавать первым аргументом далее
 var result = arr.reduce(function(sum, current) {
   return sum + current;
@@ -212,13 +212,11 @@ var result = arr.reduce(function(sum, current) {
 alert( result ); // 15
 ```
 
-Результат -- точно такой же! Это потому, что при отсутствии `initialValue` в качестве первого значения берётся первый элемент массива, а перебор стартует со второго. 
+Результат -- точно такой же! Это потому, что при отсутствии `initialValue` в качестве первого значения берётся первый элемент массива, а перебор стартует со второго.
 
 Таблица вычислений будет такая же, за вычетом первой строки.
 
-**Метод [arr.reduceRight](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduceRight) работает аналогично, но идёт по массиву справа-налево:**
-
-
+**Метод [arr.reduceRight](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduceRight) работает аналогично, но идёт по массиву справа-налево.**
 
 ## Итого
 
@@ -232,4 +230,4 @@ alert( result ); // 15
 </ul>
 
 Во многих ситуациях их использование позволяет написать код короче и понятнее, чем обычный перебор через `for`.
- 
+
diff --git a/1-js/5-functions-closures/6-memory-management/article.md b/1-js/5-functions-closures/6-memory-management/article.md
@@ -17,7 +17,7 @@
 </ul>
 
 Эти значения гарантированно хранятся в памяти. Мы будем называть их *корнями*.
-</li> 
+</li>
 <li>**Любое другое значение сохраняется в памяти лишь до тех пор, пока доступно из корня по ссылке или цепочке ссылок.**</li>
 </ol>
 
@@ -31,7 +31,7 @@
 
 ### Достижимость и наличие ссылок
 
-Есть одно упрощение для работы с памятью: "значение остаётся в памяти, пока на него есть ссылка". 
+Есть одно упрощение для работы с памятью: "значение остаётся в памяти, пока на него есть хотя бы одна ссылка".
 
 Но такое упрощение будет верным лишь в одну сторону.
 
@@ -47,7 +47,7 @@ var user = {
 user = null;
 ```
 
-Теперь объект `{ name: "Вася" }` более недоступен. Память будет освобождена. 
+Теперь объект `{ name: "Вася" }` более недоступен. Память будет освобождена.
 </li>
 <li>**Неверно -- в другую сторону: наличие ссылки не гарантирует, что значение останется в памяти.**
 
@@ -62,9 +62,9 @@ petya.friend = vasya;
 vasya = petya = null;
 ```
 
-Несмотря на то, что на объекты `vasya`, `petya` ссылаются друг на друга через ссылку `friend`, то есть можно сказать, что на каждый из них есть ссылка, последняя строка делает эти объекты в совокупности недостижимыми. 
+Несмотря на то, что на объекты `vasya`, `petya` ссылаются друг на друга через ссылку `friend`, то есть можно сказать, что на каждый из них есть ссылка, последняя строка делает эти объекты в совокупности недостижимыми.
 
-Поэтому они будут удалены из памяти. 
+Поэтому они будут удалены из памяти.
 
 Здесь как раз и играет роль "достижимость" -- оба этих объекта становятся недостижимы из корней, в первую очередь, из глобальной области, стека.
 
@@ -138,7 +138,7 @@ window.family = null;
 Как видим, объекты в конструкции всё ещё связаны между собой. Однако, поиск от корня их не находит, они не достижимы, и значит сборщик мусора удалит их из памяти.
 
 [smart header="Оптимизации"]
-Проблема описанного алгоритма -- в больших задержках. Если объектов много, то на поиск всех достижимых  уйдёт довольно много времени. А ведь выполнение скрипта при этом должно быть остановлено, уже просканированные объекты не должны поменяться до окончания процесса. Получатся небольшие, но неприятные паузы-зависания в работе скрипта. 
+Проблема описанного алгоритма -- в больших задержках. Если объектов много, то на поиск всех достижимых  уйдёт довольно много времени. А ведь выполнение скрипта при этом должно быть остановлено, уже просканированные объекты не должны поменяться до окончания процесса. Получатся небольшие, но неприятные паузы-зависания в работе скрипта.
 
 Поэтому современные интерпретаторы применяют различные оптимизации.
 
@@ -157,7 +157,7 @@ function showTime() {
 
 ## Замыкания
 
-Объекты переменных, о которых шла речь ранее, в главе про замыкания, также подвержены сборке мусора. Они следуют тем же правилам, что и обычные объекты. 
+Объекты переменных, о которых шла речь ранее, в главе про замыкания, также подвержены сборке мусора. Они следуют тем же правилам, что и обычные объекты.
 
 Объект переменных внешней функции существует в памяти до тех пор, пока существует хоть одна внутренняя функция, ссылающаяся на него через свойство `[[Scope]]`.
 
@@ -206,7 +206,7 @@ function f() {
   return function() {};
 }
 
-// 3 функции, каждая ссылается на свой объект переменных, 
+// 3 функции, каждая ссылается на свой объект переменных,
 // каждый со своим значением value
 var arr = [f(), f(), f()];
 ```
@@ -224,15 +224,15 @@ function f() {
 }
 
 var g = f(); // функция g жива
-// а значит в памяти остается соответствующий объект переменных f() 
+// а значит в памяти остается соответствующий объект переменных f()
 
 g = null; // ..а вот теперь память будет очищена
 ```
 
 </li>
 </ul>
 
-### Оптимизация в V8 и её последствия 
+### Оптимизация в V8 и её последствия
 
 Современные JS-движки делают оптимизации замыканий по памяти. Они анализируют использование переменных и в случае, когда переменная из замыкания абсолютно точно не используется, удаляют её.
 
@@ -286,7 +286,7 @@ g();
 Это не глюк отладчика, а особенность работы V8, которая, возможно, будет когда-нибудь изменена. Вы всегда сможете проверить, не изменилось ли чего, запустив примеры на этой странице.
 [/warn]
 
-## Влияние управления памятью на скорость 
+## Влияние управления памятью на скорость
 
 На создание новых объектов и их удаление тратится время. Это важно иметь в виду в случае, когда важна производительность.
 
@@ -319,8 +319,8 @@ timeRecursion = performance.now() - timeRecursion;
 alert( "Разница в " + (timeRecursion / timeLoop) + " раз" );
 ```
 
-Различие в скорости на таком примере может составлять, в зависимости от интерпретатора, 2-10 раз. 
+Различие в скорости на таком примере может составлять, в зависимости от интерпретатора, 2-10 раз.
 
 Вообще, этот пример -- не показателен. Ещё раз обращаю ваше внимание на то, что такие искусственные "микротесты" часто врут. Правильно их делать -- отдельная наука, которая выходит за рамки этой главы. Но и на практике ускорение в 2-10 раз оптимизацией по количеству объектов (и вообще, любых значений) -- отнюдь не миф, а вполне достижимо.
 
-В реальной жизни в большинстве ситуаций такая оптимизация несущественна, просто потому что "JavaScript и так достаточно быстр". Но она может быть эффективной для "узких мест" кода. 
+В реальной жизни в большинстве ситуаций такая оптимизация несущественна, просто потому что "JavaScript и так достаточно быстр". Но она может быть эффективной для "узких мест" кода.
diff --git a/1-js/6-objects-more/3-constructor-new/4-calculator-extendable/_js.view/solution.js b/1-js/6-objects-more/3-constructor-new/4-calculator-extendable/_js.view/solution.js
@@ -20,10 +20,10 @@ function Calculator() {
       return NaN;
     }
 
-    return methods[op](+a, +b);
+    return methods[op](a, b);
   }
 
   this.addMethod = function(name, func) {
     methods[name] = func;
   };
-}
+}
diff --git a/1-js/9-prototypes/5-class-inheritance/4-clock-class-extended/solution.md b/1-js/9-prototypes/5-class-inheritance/4-clock-class-extended/solution.md
@@ -3,5 +3,3 @@
 ```js
 //+ src="extended-clock.js"
 ```
-
-[edit src="solution"]Открыть полное решение в редакторе[/edit]
diff --git a/7-frames-and-windows/1-window-methods/article.md b/7-frames-and-windows/1-window-methods/article.md
@@ -122,12 +122,14 @@ alert(newWin.location.href); // (*) about:blank, загрузка ещё не н
 newWin.onload = function() {
 
   // создать div в документе нового окна
-  var div = *!*newWin*/!*.document.createElement('div');
+  var div = *!*newWin*/!*.document.createElement('div'),
+      body = newWin.document.body;
+      
   div.innerHTML = 'Добро пожаловать!'
   div.style.fontSize = '30px'
 
   // вставить первым элементом в body нового окна
-  body.insertBefore(div, newWin.document.body.firstChild);
+  body.insertBefore(div, body.firstChild);
 }
 ```
 
diff --git a/figures.sketch b/figures.sketch

Original file line number	Diff line number	Diff line change
`@@ -20,10 +20,10 @@ function Calculator() {`
`20`	`20`	`return NaN;`
`21`	`21`	`}`
`22`	`22`
`23`		`- return methods[op](+a, +b);`
	`23`	`+ return methods[op](a, b);`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`this.addMethod = function(name, func) {`
`27`	`27`	`methods[name] = func;`
`28`	`28`	`};`
`29`		`-}`
	`29`	`+}`