translation javascript into Russian

1 files changed, 235 insertions, 268 deletions

diff --git a/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown
index ad66b501..dc35d18c 100644
--- a/ru-ru/javascript-ru.html.markdown
+++ b/ru-ru/javascript-ru.html.markdown
@@ -3,261 +3,250 @@ language: javascript
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
-translators:
-    - ["Maxim Koretskiy", "http://github.com/maximkoretskiy"]
 filename: javascript-ru.js
+translators:
+  - ["Alexey Gonchar", "http://github.com/finico"]
 lang: ru-ru
 ---
 
-Javascript был разработан Бренданом Айком из Netcape в 1995. Изначально 
-предполагалось, что он станет простым вариантом скриптового языка для сайтов, 
-дополняющий к Java, который бы в свою очередь использовался для более сложных 
-web-приложений. Но тонкая интегрированность javascript с web-страницей и 
-встроенная поддержка в браузерах привели к тому, чтобы он стал более 
-распространен в frontend-разработке, чем Java.
-
-Использование JavaScript не ограничивается браузерами. Проект Node.js, 
-предоставляющий независимую среду выполнения на движке Google Chrome V8 
-JavaScript, становится все более популярным.
+JavaScript был создан в 1995 году Бренданом Айком, работающим в компании Netscape.
+Изначально он был задуман как простой язык сценариев для веб-сайтов, дополняющий
+Java для более сложных веб-приложений, но его тесная интеграция с веб-страницами
+и втроенная поддержка браузерами привели к тому, что он стал более распространынным,
+чем Java в веб-интерфейсах.
 
-Обратная связь важна и нужна! Вы можете написаться мне
-на [@adambrenecki](https://twitter.com/adambrenecki) или
-[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+JavaScript не ограничивается только веб-браузером, например, Node.js, программная
+платформа, позволяющая выполнять JavaScript, основанная на движке V8 от браузера
+Google Chrome, становится все более популярной.
 
 ```js
-// Комментарии оформляются как в C.
-// Однострочнные коментарии начинаются с двух слешей,
-/* а многострочные с слеша и звездочки
-   и заканчиваются звездочеий и слешом */
+// Си-подобные комментарии. Однострочные комментарии начинаются с двух символов слэш,
+/* а многострочные комментарии начинаются с звёздочка-слэш
+   и заканчиваются символами слэш-звёздочка */
 
-// Выражения разделяются с помощью ;
+// Выражения заканчиваються точкой с запятой ;
 doStuff();
 
-// ... но этого можно и не делать, разделители подставляются автоматически
-// после перехода на новую строку за исключением особых случаев
+// ... но они необязательны, так как точки с запятой автоматически вставляются
+// везде, где есть символ новой строки, за некоторыми исключениями.
 doStuff()
 
-// Это может приводить к непредсказуемому результату и поэтому мы будем 
-// использовать разделители в этом туре.
-// Because those cases can cause unexpected results, we'll keep on using
-// semicolons in this guide.
+// Так как эти исключения могут привести к неожиданным результатам, мы будем всегда
+// использовать точку с запятой в этом руководстве.
 
 ///////////////////////////////////
 // 1. Числа, Строки и Операторы
-// 1. Numbers, Strings and Operators
 
-// В Javasript всего 1 числовой тип - 64-битное число с плавающей точкой
-// стандарта IEEE 754)
-// Числа имеют 52-битную мантиссу, чего достаточно для хранения хранения целых 
-// чисел до 9✕10¹⁵ приблизительно.
+// В JavaScript только один тип числа (64-bit IEEE 754 double).
+// Он имеет 52-битную мантиссу, которой достаточно для хранения целых чисел
+// с точностью вплоть до 9✕10¹⁵.
 3; // = 3
 1.5; // = 1.5
 
-// В основном базовая арифметика работает предсказуемо
+// Некоторые простые арифметические операции работают так, как вы ожидаете.
 1 + 1; // = 2
-.1 + .2; // = 0.30000000000000004
+0.1 + 0.2; // = 0.30000000000000004 (а некоторые - нет)
 8 - 1; // = 7
 10 * 2; // = 20
 35 / 5; // = 7
 
-// Включая нецелочисленное деление
+// Включая деление с остатком.
 5 / 2; // = 2.5
 
-// Двоичные операции тоже есть. Если применить двоичную операцию к float-числу,
-// оно будет приведено к 32-битному целому со знаком.
+// Побитовые операции так же имеются; Они производят операции, используя
+// двоичное представление числа, и возвращают новую последовательность из
+// 32 бит (число) в качестве результата.
 1 << 2; // = 4
 
-// (todo:перевести)
-// Приоритет выполнения операций можно менять с помощью скобок.
+// Приоритет в выражениях явно задаётся скобками.
 (1 + 3) * 2; // = 8
 
-// Есть три особых не реальных числовых значения:
-Infinity; // допустим, результат операции 1/0
--Infinity; //  допустим, результат операции -1/0
-NaN; //  допустим, результат операции 0/0
+// Есть три специальных значения, которые не являются реальными числами:
+Infinity; // "бесконечность", например, результат деления на 0
+-Infinity; // "минус бесконечность", результат деления отрицательного числа на 0
+NaN; // "не число", например, результат деления 0/0
 
-// Так же есть тип булевых данных.
+// Существует также логический тип.
 true;
 false;
 
-// Строки создаются с помощью ' или ". 
+// Строки создаются при помощи двойных или одинарных кавычек.
 'abc';
 "Hello, world";
 
-// Оператор ! означает отрицание
+// Для логического отрицания используется символ восклицательного знака.
 !true; // = false
 !false; // = true
 
-// Равество это ===
+// Строгое равенство ===
 1 === 1; // = true
 2 === 1; // = false
 
-// Неравенство это !==
+// Строгое неравенство !==
 1 !== 1; // = false
 2 !== 1; // = true
 
-// Еще сравнения
+// Другие операторы сравнения
 1 < 10; // = true
 1 > 10; // = false
 2 <= 2; // = true
 2 >= 2; // = true
 
-// Строки складываются с помощью +
+// Строки конкатенируются при помощи оператора +
 "Hello " + "world!"; // = "Hello world!"
 
-// и сравниваются с помощью < и >
+// и сравниваются при помощи < и >
 "a" < "b"; // = true
 
-// Приведение типов выполняется при сравнении с ==...
+// Проверка равенства с приведением типов осуществляется двойным символом равно
 "5" == 5; // = true
 null == undefined; // = true
 
-// ...в отличие от ===
+// ...а если использовать ===
 "5" === 5; // = false
 null === undefined; // = false 
 
-// Для доступа к конкретному символу строки используйте charAt
+// ...приведение типов может привести к странному поведению...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Вы можете получить доступ к любому символу строки, используя метод charAt
 "This is a string".charAt(0);  // = 'T'
 
-// ... или используйте substring  для получения подстроки
+// ...или используйте метод substring чтобы получить более крупные части
 "Hello world".substring(0, 5); // = "Hello"
 
-// length(длина) - свойство, не используйте ()
+// length это свойство, для его получения не нужно использовать ()
 "Hello".length; // = 5
 
-// Есть null и undefined
-null; // используется что бы указать явно, что значения нет
-undefined; // испрользуется чтобы показать, что значения не было установлено 
-           // собственно, undefined так и переводится
+// Так же есть null и undefined
+null; // используется для обозначения намеренного значения "ничего"
+undefined; // используется для обозначения переменных, не имеющих
+           // присвоенного значения (хотя переменная объявлена)
 
-// false, null, undefined, NaN, 0 и "" являются falsy-значениями(при приведении 
-// в булеву типу становятся false)
-// Обратите внимание что 0 приводится к false, а "0" к true, 
-// не смотря на то, что "0"==0
+// false, null, undefined, NaN, 0 и "" это ложь; все остальное - истина.
+// Следует отметить, что 0 это ложь, а "0" - истина, несмотря на то, что 0 == "0".
 
 ///////////////////////////////////
-// 2. Переменные, массивы и объекты
+// 2. Переменные, Массивы и Объекты
 
-// Переменные объявляются ключевым словом var. Javascript динамически 
-// типизируемый, так что указывать тип не нужно. 
-// Присвоение значения описывается с помощью оператора =
+// Переменные объявляются при помощи ключевого слова var. JavaScript - язык с
+// динамической типизацией, поэтому не нужно явно указывать тип. Для присваивания
+// значения переменной используется символ =
 var someVar = 5;
 
-// если не указать ключевого слова var, ошибки не будет...
+// если вы пропустите слово var, вы не получите сообщение об ошибке...
 someOtherVar = 10;
 
-// ...но переменная будет создана в глобальном контексте, в не области 
-// видимости, в которой она была объявлена.
+// ...но ваша переменная будет создана в глобальном контексте, а не в текущем
+// гед вы ее объявили.
 
-// Переменные объявленные без присвоения значения, содержать undefined
+// Переменным объявленным без присвоения устанавливается значение undefined.
 var someThirdVar; // = undefined
 
-// Для математических операций над переменными есть короткая запись:
-someVar += 5; // тоже что someVar = someVar + 5; someVar равно 10 теперь
-someVar *= 10; // а теперь -- 100
+// У математических операций есть сокращённые формы:
+someVar += 5; // как someVar = someVar + 5; someVar теперь имеет значение 10
+someVar *= 10; // теперь someVar имеет значение 100
 
-// еще более короткая запись для добавления и вычитания 1
-someVar++; // теперь someVar равно 101
-someVar--; // обратно к 100
+// а так же специальные операторы инкремент и декремент для увеличения и
+// уменьшения переменной на единицу соответственно
+someVar++; // теперь someVar имеет значение 101
+someVar--; // обратно 100
 
-// Массивы -- упорядоченные списки значений любых типов.
+// Массивы это нумерованные списки из значений любого типа.
 var myArray = ["Hello", 45, true];
 
-// Для доступу к элементам массивов используйте квадратные скобки.
-// Индексы массивов начинаются с 0
+// Их элементы могут быть доступны при помощи синтаксиса с квадратными скобками.
+// Индексы массивов начинаются с нуля.
 myArray[1]; // = 45
 
-// Массивы мутабельны(изменяемы) и имеют переменную длину. 
-myArray.push("World"); // добавить элемент
+// Массивы можно изменять, как и их длину.
+myArray.push("World");
 myArray.length; // = 4
 
-// Добавить или изменить значение по конкретному индексу
+// Добавлять и редактировать определенный элемент
 myArray[3] = "Hello";
 
-// Объекты javascript похожи на dictionary или map из других языков 
-// программирования. Это неупорядочнные коллекции пар ключ-значение.
+// Объекты в JavaScript похожи на "словари" или ассоциативные массиы в других
+// языках: неупорядоченный набор пар ключ-значение.
 var myObj = {key1: "Hello", key2: "World"};
 
-// Ключи -- это строки, но кавычки не требуются если названия явлюятся
-// корректными javascript идентификаторами. Значения могут быть любого типа.
+// Ключи это строки, но кавычки необязательны, если строка удовлетворяет
+// ограничениям для имён переменных. Значения могут быть любых типов.
 var myObj = {myKey: "myValue", "my other key": 4};
 
-// Доступ к атрибту объекта можно получить с помощью квадратных скобок
+// Атрибуты объектов можно также получить, используя квадратные скобки,
 myObj["my other key"]; // = 4
 
-// ... или используя точечную нотацию, при условии что ключ является 
-// корректным идентификатором.
+// или через точку, при условии, что ключ является допустимым идентификатором.
 myObj.myKey; // = "myValue"
 
-// Объекты мутабельны. В существуюещем объекте можно изменить значние 
-// или добавить новый атрибут.
+// Объекты изменяемы; можно изменять значения и добавлять новые ключи.
 myObj.myThirdKey = true;
 
-// При попытке доступа к атрибуту, который до этого не был создан, будет
-// возвращен undefined
+// Если вы попытаетесь получить доступ к несуществующему свойству,
+// вы получите undefined.
 myObj.myFourthKey; // = undefined
 
 ///////////////////////////////////
-// 3. Логика и Управляющие структуры
+// 3. Логика и управляющие конструкции.
 
-// Синтаксис управляющих структур очень похож на его реализацию в Java.
+// Синтаксис для этого раздела почти такой же как в Java.
 
-// if работает так как вы ожидаете.
+// Эта конструкция работает, как и следовало ожидать.
 var count = 1;
-if (count == 3){
-    // выполнится, если значение count равно 3
-} else if (count == 4){
-    // выполнится, если значение count равно 4
+if (count == 3) {
+    // выполняется, если count равен 3
+} else if (count == 4) {
+    // выполняется, если count равен 4
 } else {
-    // выполнится, если значение count не будет равно ни 3 ни 4
+    // выполняется, если не 3 и не 4
 }
 
-// Поведение while тоже вполне предсказуемо
+// Как это делает while.
 while (true){
-    // Бесконечный цикл
+    // Бесконечный цикл!
 }
 
-// Циклы do-while похожи на while, но они всегда выполняются хотябы 1 раз.
-// Do-while loops are like while loops, except they always run at least once.
+// Циклы do-while такие же как while, но они всегда выполняются хотя бы раз.
 var input
 do {
     input = getInput();
 } while (!isValid(input))
 
-// Цикл for такой же как в C и Java:
-// инициализация; условие продолжения; итерация
-for (var i = 0; i < 5; i++){
-    // выполнится 5 раз
+// цикл for является таким же, как C и Java:
+// инициализация; условие; шаг.
+for (var i = 0; i < 5; i++) {
+    // будет запущен 5 раз
 }
 
-// && - логическое и, || - логическое или
-if (house.size == "big" && house.color == "blue"){
+// && это логическое И, || это логическое ИЛИ
+if (house.size == "big" && house.colour == "blue") {
     house.contains = "bear";
 }
-if (color == "red" || color == "blue"){
-    // если цвет или красный или синий
+if (colour == "red" || colour == "blue") {
+    // цвет красный или синий
 }
 
-// && и || удобны для установки значений по умолчанию.
-// && and || "short circuit", which is useful for setting default values.
+// || используется как "короткий цикл вычисления" для присваивания переменных.
 var name = otherName || "default";
 
-// выражение switch проверяет равество с помощью ===
-// используйте 'break' после каждого case,
-// иначе помимо правильного case выполнятся и все последующие.
-grade = '4';    // оценка
+// Оператор switch выполняет проверку на равенство пр помощи ===
+// используйте break чтобы прервать выполнение после каждого case 
+// или выполнение пойдёт далее, игнорируя при этом остальные проверки. 
+grade = 'B';
 switch (grade) {
-  case '5':
-    console.log("Великолепно");
+  case 'A':
+    console.log("Great job");
     break;
-  case '4':
-    console.log("Неплохо");
+  case 'B':
+    console.log("OK job");
     break;
-  case '3':
-    console.log("Можно и лучше");
+  case 'C':
+    console.log("You can do better");
     break;
   default:
-    console.log("Да уж.");
+    console.log("Oy vey");
     break;
 }
 
@@ -265,213 +254,197 @@ switch (grade) {
 ///////////////////////////////////
 // 4. Функции, Область видимости и Замыкания
 
-// Функции в JavaScript объявляются с помощью ключевого слова function.
-function myFunction(thing){
-    return thing.toUpperCase(); // приведение к верхнему регистру
+// Функции в  JavaScript объявляются при помощи ключевого слова function.
+function myFunction(thing) {
+    return thing.toUpperCase();
 }
 myFunction("foo"); // = "FOO"
 
-// Помните, что значение, которое должно быть возкращено должно начинаться
-// на той же строке, где расположено ключевое слово 'return'. В противном случае
-// будет возвращено undefined. Такое поведения объясняется автоматической 
-// вставкой разделителей ';'. Помните этот факт, если используете
-// BSD стиль оформления кода.
-// Note that the value to be returned must start on the same line as the
-// 'return' keyword, otherwise you'll always return 'undefined' due to
-// automatic semicolon insertion. Watch out for this when using Allman style.
+// Обратите внимание, что значение, которое будет возвращено, должно начинаться
+// на той же строке, что и ключевое слово return, в противном случае вы будете
+// всегда возвращать undefined по причине автоматической вставки точки с запятой.
+// Следите за этим при использовании стиля форматирования Allman.
 function myFunction()
 {
-    return // <- разделитель автоматически будет вставлен здесь
+    return // <- здесь точка с запятой вставится автоматически
     {
         thisIsAn: 'object literal'
     }
 }
 myFunction(); // = undefined
 
-// Функции в JavaScript являются объектами, поэтому их можно назначить в 
-// переменные с разными названиями и передавать в другие функции, как аргументы,
-// на пример, при указании обработчика события.
-function myFunction(){
-    // этот фрагмент кода будет вызван через 5 секунд
+// JavaScript функции - это объекты, поэтому они могут быть переприсвоены на
+// различные имена переменных и передаваться другим функциям в качестве аргументов,
+// например, когда назначается обработчик события:
+function myFunction() {
+    // этот код будет вызван через 5 секунд
 }
 setTimeout(myFunction, 5000);
-// Обратите внимание, что setTimeout не является частью языка, однако он 
-// доступен в API браузеров и Node.js.
+// Примечание: setTimeout не является частью языка, но реализован в браузерах и Node.js
 
-// Объект функции на самом деле не обязательно объявлять с именем - можно  
-// создать анонимную функцию прямо в аргументах другой функции.
-setTimeout(function(){
-    // этот фрагмент кода будет вызван через 5 секунд
+// Функции не обязательно должны иметь имя при объявлении - вы можете написать
+// анонимное определение функции непосредственно в агрументе другой функции.
+setTimeout(function() {
+    // этот код будет вызван через 5 секунд
 }, 5000);
 
-// В JavaScript есть области видимости. У функций есть собственные области 
-// видимости, у других блоков их нет.
-if (true){
+// В JavaScript есть область видимости функции; функции имеют свою область
+// видимости, а другие блоки - нет.
+if (true) {
     var i = 5;
 }
-i; // = 5, а не undefined, как это было бы в языке, создающем
-   // области видисти для блоков кода
+i; // = 5 - не undefined как ожидалось бы в языках с блочной областью видимости
 
-// Это привело к появлению паттерна общего назначения "immediately-executing
-// anonymous functions" (сразу выполняющиеся анонимные функции), который
-// позволяет предотвратить запись временных переменных в общую облать видимости.
-(function(){
+// Это привело к общепринятому шаблону "самозапускающихся анонимных функций",
+// которые препятствуют проникновению переменных в глобальную область видимости
+(function() {
     var temporary = 5;
-    // Для доступа к глобальной области видимости можно использовать запись в 
-    // некоторый 'глобальный объект', для браузеров это 'window'. Глобальный 
-    // объект может называться по-разному в небраузерных средах, таких Node.js.
+    // Мы можем получить доступ к глобальной области для записи в "глобальный объект",
+    // который в веб-браузере всегда window. Глобальный объект может иметь другое
+    // имя в таких платформах, как Node.js
     window.permanent = 10;
 })();
-temporary; // вызывает исключение ReferenceError
+temporary; // вызовет сообщение об ошибке с типом ReferenceError
 permanent; // = 10
 
-// Одной из сильных сторон JavaScript являются замыкания. Если функция 
-// объявлена в внутри другой функции, внутренняя функция имеет доступ ко всем 
-// переменным внешней функции, даже после того, как внешняя функции завершила 
-// свое выполнение.
-function sayHelloInFiveSeconds(name){
-    var prompt = "Привет, " + name + "!";
-    // Внутренние функции помещаются в локальную область видимости, как-будто 
-    // они объявлены с ключевым словом 'var'.
-    function inner(){
+// Одной из самых мощных возможностей JavaScript являются замыкания. Если функция
+// определена внутри другой функции, то внутренняя функция имеет доступ к 
+// переменным внешней функции, даже после того, как контекст выполнения выйдет из
+// внешней функции.
+function sayHelloInFiveSeconds(name) {
+    var prompt = "Hello, " + name + "!";
+    // Внутренние функции по умолчанию помещаются в локальную область видимости,
+    // как если бы они были объявлены с var.
+    function inner() {
         alert(prompt);
     }
     setTimeout(inner, 5000);
-    // setTimeout является асинхроннной, и поэтому функция sayHelloInFiveSeconds
-    // завершит свое выполнение сразу и setTimeout вызовет inner позже.
-    // Однако, так как inner "закрыта внутри" или "замкнута в"
-    // sayHelloInFiveSeconds, inner все еще будет иметь доступ к переменной 
-    // prompt, когда будет вызвана.
+    // setTimeout асинхронна, поэтому функция sayHelloInFiveSeconds сразу выйдет
+    // и тело setTimeout будет вызвано позже. Однако, поскольку внутренняя
+    // функция "замкнута", она по-прежнему имеет доступ к переменной prompt,
+    // когда sayHelloInFiveSeconds вызывется.
 }
-sayHelloInFiveSeconds("Вася"); // откроет модальное окно с сообщением
-                               // "Привет, Вася" по истечении 5 секунд.
-
+sayHelloInFiveSeconds("Adam"); // откроется окно с "Hello, Adam!" через 5 секунд
 
 ///////////////////////////////////
-// 5. Немного еще об Объектах. Конструкторы и Прототипы
+// 5. Подробнее про Объекты, Конструкторы и Прототипы
 
-// Объекты могут содержать функции
+// Объекты могут содержать в себе функции.
 var myObj = {
-    myFunc: function(){
+    myFunc: function() {
         return "Hello world!";
     }
 };
 myObj.myFunc(); // = "Hello world!"
 
-// Когда функции прикрепленные к объекту вызываются, они могут получить доступ 
-// к данным объекта, ипользуя ключевое слово this.
+// Когда функции, прикрепленные к объекту, вызываются, они могут получить доступ
+// к этому объекту с помощью ключевого слова this.
 myObj = {
     myString: "Hello world!",
-    myFunc: function(){
+    myFunc: function() {
         return this.myString;
     }
 };
 myObj.myFunc(); // = "Hello world!"
 
-// Содержание this определяется исходя из того, как была вызвана функция, а 
-// не места её определения. По этой причине наша функция не будет работать вне
-// контекста объекта.
+// Какое это значение имеет к тому, как вызвана функция и где она определена.
+// Итак, наша функция не работает, если она вызывается не в контексте объекта.
 var myFunc = myObj.myFunc;
 myFunc(); // = undefined
 
-// И напротив, функция может быть присвоена объекту и получить доступ к нему
-// через this, даже если она не была прикреплена к объекту в момент её создания.
-var myOtherFunc = function(){
-    return this.myString.toUpperCase();
+// И наоборот, функция может быть присвоена объекту и получать доступ к нему
+// через this, даже если она не была присвоена при объявлении.
+var myOtherFunc = function() {
 }
 myObj.myOtherFunc = myOtherFunc;
 myObj.myOtherFunc(); // = "HELLO WORLD!"
 
-// Также можно указать контекс выполнения фунции с помощью 'call' или 'apply'.
-var anotherFunc = function(s){
+// Мы можем также указать контекст для выполнения функции, когда мы вызываем ее
+// с помощью call или apply.
+var anotherFunc = function(s) {
     return this.myString + s;
 }
 anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
 
-// Функция 'apply' очень похожа, но принимает массив со списком аргументов.
-
+// Функция apply аналогична, но принимает массив аргументов.
 anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
 
-// Это может быть удобно, когда работаешь с фунцией принимающей на вход 
-// последовательность аргументов и нужно передать их в виде массива.
-
+// Это полезно при работе с функцией, которая принимает последовательность
+// аргументов, и вы хотите передать массив.
 Math.min(42, 6, 27); // = 6
-Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min([42, 6, 27]); // = NaN (не сработает!)
 Math.min.apply(Math, [42, 6, 27]); // = 6
 
-// Однако, 'call' и 'apply' не имеют постоянного эффекта. Если вы хотите 
-// зафиксировать контекст для функции, используйте bind.
-
+// Но, call и apply - временные. Когда мы хотим связать функцию, мы можем
+// использовать bind.
 var boundFunc = anotherFunc.bind(myObj);
 boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
 
-// bind также можно использовать чтобы частично передать аргументы в 
-// функцию (каррировать).
-
-var product = function(a, b){ return a * b; }
+// Bind также может использоваться, для частичного применения (каррирование) функции
+var product = function(a, b) { return a * b; }
 var doubler = product.bind(this, 2);
 doubler(8); // = 16
 
-// Когда функция вызывается с ключевым словом new, создается новый объект.
-// Данный объект становится доступным функции через ключевое слово this. 
-// Функции спроектированные вызываться таким способом называются конструкторами.
-
-var MyConstructor = function(){
+// Когда вы вызываете функцию с помощью ключевого слова new создается новый объект,
+// и создает доступ к функции при помощи this. Такие функции называют конструкторами.
+var MyConstructor = function() {
     this.myNumber = 5;
 }
 myNewObj = new MyConstructor(); // = {myNumber: 5}
 myNewObj.myNumber; // = 5
 
-// Любой объект в JavaScript имеет 'прототип'. Когда вы пытаетесь получить 
-// доступ к свойству не объявленному в данном объекте, интерпретатор будет 
-// искать его в прототипе.
+// Каждый объект в JavaScript имеет свойтво prototype. Когда вы хотите получить
+// доступ к свойтву объекта, которое не существует в этом объекте, интерпритатор
+// будет искать это свойство в прототипе.
 
-// Некоторые реализации JS позволяют получить доступ к прототипу с помощью 
-// "волшебного" свойства __proto__. До момента пока оно не являются стандартным, 
-// __proto__ полезно лишь для изучения прототипов в JavaScript. Мы разберемся 
-// со стандартными способами работы с прототипом несколько позже.
+// Некоторые реализации языка позволяют получить доступ к объекту прототипа
+// через свойство __proto__. Несмотря на то, что это может быть полезно для
+// понимания прототипов, это не часть стандарта; мы увидим стандартные способы
+// использования прототипов позже.
 var myObj = {
     myString: "Hello world!"
 };
 var myPrototype = {
     meaningOfLife: 42,
-    myFunc: function(){
+    myFunc: function() {
         return this.myString.toLowerCase()
     }
 };
 
 myObj.__proto__ = myPrototype;
 myObj.meaningOfLife; // = 42
+
+// Для функций это так же работает.
 myObj.myFunc(); // = "hello world!"
 
-// Естественно, если в свойства нет в прототипе, поиск будет продолжен в 
+// Если интерпритатор не найдет свойство в прототипе, то продожит поиск в 
 // прототипе прототипа и так далее.
 myPrototype.__proto__ = {
     myBoolean: true
 };
 myObj.myBoolean; // = true
 
-// Ничего не копируется, каждый объект хранит ссылку на свой прототип. Если 
-// изменить прототип, все изменения отразятся во всех его потомках.
+// Здесь не участвует копирование; каждый объект хранит ссылку на свой прототип.
+// Это означает, что мы можем изменить прототип и наши изменения будут отражены везде
 myPrototype.meaningOfLife = 43;
 myObj.meaningOfLife; // = 43
 
-// Как было сказано выше, __proto__ не является стандартом, и нет стандартного
-// способа изменить прототип у созданного объекта. Однако, есть два способа 
-// создать объект с заданным прототипом.
+// Мы упомянули, что свойтсво __proto__ нестандартно, и нет никакого стандартного
+// способа, чтобы изменить прототип существующего объекта. Однако, есть два
+// способа создать новый объект с заданным прототипом.
 
-// Первый способ - Object.create, был добавлен в JS относительно недавно, и 
-// потому не доступен в более ранних реализациях языка.
+// Первый способ это Object.create, который появился в ECMAScript 5 и есть еще
+// не во всех реализациях языка.
 var myObj = Object.create(myPrototype);
 myObj.meaningOfLife; // = 43
 
-// Второй вариан доступен везде и связан с конструкторами. Конструкторы имеют 
-// свойство prototype. Это вовсе не прототип функции конструктора, напротив, 
-// это прототип, который присваевается новым объектам, созданным с этим 
-// конструктором с помощью ключевого слова new.
+// Второй способ, который работает везде, имеет дело с конструкторами.
+// У конструкторов есть свойство с именем prototype. Это не прототип
+// функции-конструктора; напротив, это прототип для новых объектов, которые
+// будут созданы с помощью этого конструктора и ключевого слова new
 MyConstructor.prototype = {
     myNumber: 5,
-    getMyNumber: function(){
+    getMyNumber: function() {
         return this.myNumber;
     }
 };
@@ -480,42 +453,41 @@ myNewObj2.getMyNumber(); // = 5
 myNewObj2.myNumber = 6
 myNewObj2.getMyNumber(); // = 6
 
-// У встроенных типов таких, как строки и числа, тоже есть конструкторы, 
-// создающие эквивалентные объекты-обертки.
+// У встроенных типов, таких как строки и числа также есть конструкторы, которые
+// создают эквивалентые объекты-обертки.
 var myNumber = 12;
 var myNumberObj = new Number(12);
 myNumber == myNumberObj; // = true
 
-// Правда, они не совсем эквивалентны.
+// За исключением того, что они не в точности равны.
 typeof myNumber; // = 'number'
 typeof myNumberObj; // = 'object'
 myNumber === myNumberObj; // = false
-if (0){
-    // Этот фрагмент кода не будет выпонен, так как 0 приводится к false
+if (0) {
+    // Этот код не выполнятся, потому что 0 - это ложь.
 }
-if (Number(0)){
-    // Этот фрагмент кода *будет* выпонен, так как Number(0) приводится к true.
+if (Number(0)) {
+    // Этот код выполнится, потому что Number(0) это истина.
 }
 
-// Однако, оберточные объекты и обычные встроенные типы имеют общие прототипы, 
-// следовательно вы можете расширить функциональность строки, например.
-String.prototype.firstCharacter = function(){
+// Впрочем, обертки это объекты и их можно расширять, например:
+String.prototype.firstCharacter = function() {
     return this.charAt(0);
 }
 "abc".firstCharacter(); // = "a"
 
-// Этот факт часто используется для создания полифилов(polyfill) - реализации 
-// новых возможностей JS в его более старых версиях для того чтобы их можно было 
-// использовать в устаревших браузерах.
+// Это часто используется в полифиллах, которые реализуют новые возможности
+// JavaScript в старой реализации языка, так что они могут быть использованы в
+// старых средах, таких как устаревшие браузеры.
 
-// Например, мы упомянули, что Object.create не доступен во всех версиях 
-// JavaScript, но мы можем создать полифилл.
-if (Object.create === undefined){ // не переопределяем, если есть
-    Object.create = function(proto){
-        // создаем временный конструктор с заданным прототипом
+// Например, мы упомянули, что Object.create доступен не во всех реализациях, но
+// мы сможем использовать его с этим полифиллом:
+if (Object.create === undefined) { // не перезаписывать метод, если он существует
+    Object.create = function(proto) {
+        // создать временный конструктор с правильным прототипом
         var Constructor = function(){};
         Constructor.prototype = proto;
-        // создаём новый объект с правильным прототипом
+        // затем использовать его для создания нового объекта, на основе прототипа
         return new Constructor();
     }
 }
@@ -523,21 +495,16 @@ if (Object.create === undefined){ // не переопределяем, если
 
 ## Что еще почитать
 
-[Современный учебник JavaScript](http://learn.javascript.ru/) от Ильи Кантора 
-является довольно качественным и глубоким учебным материалом, освещающим все 
-особенности современного языка. Помимо учебника на том же домене можно найти 
-[перевод спецификации ECMAScript 5.1](http://es5.javascript.ru/) и справочник по 
-возможностям языка.
-
-[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) позволяет 
-довольно быстро изучить основные тонкие места в работе с JS, но фокусируется 
-только на таких моментах
+[Современный учебник JavaScript (Илья Кантор)](http://learn.javascript.ru) - 
+качественный учебник по JavaScript на русском языке.
 
-[Справочник](https://developer.mozilla.org/ru/docs/JavaScript) от MDN 
-(Mozilla Development Network) содержит информацию о возможностях языка на 
-английском.
+[Mozilla Developer Network](https://developer.mozilla.org/ru/docs/Web/JavaScript) -
+предоставляет отличную документацию для JavaScript, как он используется в браузерах.
+Кроме того, это вики, поэтому, если вы знаете больше, вы можете помочь другим,
+делясь своими знаниями.
 
-Название проекта ["Принципы написания консистентного, идиоматического кода на 
-JavaScript"](https://github.com/rwaldron/idiomatic.js/tree/master/translations/ru_RU)
-говорит само за себя.
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) - это
+подробное руководство всех неинтуитивных особенностей языка.
 
+[Stack Overflow](http://stackoverflow.com/questions/tagged/javascript) - можно
+найти ответ почти на любой ваш вопрос, а если его нет, то задать вопрос самому.