[javascript/ru] Translating JavaScript guide into Russian

ru-ru/javascript-ru.html.markdown

@@ -6,6 +6,7 @@ contributors:
 filename: javascript-ru.js
 translators:
   - ["Alexey Gonchar", "http://github.com/finico"]
+  - ["Andre Polykanine", "https://github.com/Oire"]
 lang: ru-ru
 ---
 
@@ -15,7 +16,7 @@ Java для более сложных веб-приложений, но его
 и встроенная поддержка браузерами привели к тому, что он стал более распространённым,
 чем Java в веб-интерфейсах.
 
-JavaScript не ограничивается только веб-браузером, например, Node.js, программная
+JavaScript не ограничивается только веб-браузером: например, Node.js, программная
 платформа, позволяющая выполнять JavaScript, основанная на движке V8 от браузера
 Google Chrome, становится все более популярной.
 
@@ -24,7 +25,7 @@ Google Chrome, становится все более популярной.
 /* а многострочные комментарии начинаются с звёздочка-слэш
    и заканчиваются символами слэш-звёздочка */
 
-// Выражения заканчиваються точкой с запятой ;
+// Инструкции могут заканчиваться точкой с запятой ;
 doStuff();
 
 // ... но она необязательна, так как точки с запятой автоматически вставляются
@@ -53,12 +54,12 @@ doStuff()
 // Включая деление с остатком.
 5 / 2; // = 2.5
 
-// Побитовые операции также имеются; они производят операции, используя
+// Побитовые операции также имеются; когда вы проводите такую операцию,
-// двоичное представление числа, и возвращают новую последовательность из
+// ваше число с плавающей запятой переводится в целое со знаком 
-// 32 бит (число) в качестве результата.
+// длиной *до* 32 разрядов.
 1 << 2; // = 4
 
-// Приоритет в выражениях явно задаётся скобками.
+// Приоритет в выражениях можно явно задать скобками.
 (1 + 3) * 2; // = 8
 
 // Есть три специальных значения, которые не являются реальными числами:
@@ -71,10 +72,10 @@ true;
 false;
 
 // Строки создаются при помощи двойных или одинарных кавычек.
-'abc';
+'абв';
-"Hello, world";
+"Привет, мир!";
 
-// Для логического отрицания используется символ восклицательного знака.
+// Для логического отрицания используется восклицательный знак.
 !true; // = false
 !false; // = true
 
@@ -92,8 +93,8 @@ false;
 2 <= 2; // = true
 2 >= 2; // = true
 
-// Строки конкатенируются при помощи оператора +
+// Строки объединяются при помощи оператора +
-"Hello " + "world!"; // = "Hello world!"
+"привет, " + "мир!"; // = "Привет, мир!"
 
 // и сравниваются при помощи < и >
 "a" < "b"; // = true
@@ -102,7 +103,7 @@ false;
 "5" == 5; // = true
 null == undefined; // = true
 
-// ...а если использовать ===
+// ...если только не использовать ===
 "5" === 5; // = false
 null === undefined; // = false 
 
@@ -111,31 +112,33 @@ null === undefined; // = false
 "13" + !0; // '13true'
 
 // Вы можете получить доступ к любому символу строки, используя метод charAt
-"This is a string".charAt(0);  // = 'T'
+"Это строка".charAt(0);  // = 'Э'
 
 // ...или используйте метод substring, чтобы получить более крупные части
-"Hello world".substring(0, 5); // = "Hello"
+"Привет, мир".substring(0, 6); // = "Привет"
 
 // length - это свойство, для его получения не нужно использовать ()
-"Hello".length; // = 5
+"Привет".length; // = 6
 
 // Также есть null и undefined
-null; // используется для обозначения намеренного значения "ничего"
+null; // Намеренное отсутствие значения
 undefined; // используется для обозначения переменных, не имеющих
-           // присвоенного значения (хотя переменная объявлена)
+           // присвоенного значения (хотя непосредственно undefined
+           // является значением)
 
-// false, null, undefined, NaN, 0 и "" - это ложь; все остальное - истина.
+// false, null, undefined, NaN, 0 и "" — это ложь; всё остальное - истина.
-// Следует отметить, что 0 это ложь, а "0" - истина, несмотря на то, что 0 == "0".
+// Следует отметить, что 0 — это ложь, а "0" — истина, несмотря на то, что
+// 0 == "0".
 
 ///////////////////////////////////
 // 2. Переменные, Массивы и Объекты
 
-// Переменные объявляются при помощи ключевого слова var. JavaScript - язык с
+// Переменные объявляются при помощи ключевого слова var. JavaScript — язык с
 // динамической типизацией, поэтому не нужно явно указывать тип. Для присваивания
 // значения переменной используется символ =
 var someVar = 5;
 
-// если вы пропустите слово var, вы не получите сообщение об ошибке...
+// если вы пропустите слово var, вы не получите сообщение об ошибке, ...
 someOtherVar = 10;
 
 // ...но ваша переменная будет создана в глобальном контексте, а не в текущем,
@@ -148,34 +151,33 @@ var someThirdVar; // = undefined
 someVar += 5; // как someVar = someVar + 5; someVar теперь имеет значение 10
 someVar *= 10; // теперь someVar имеет значение 100
 
-// а также специальные операторы инкремент и декремент для увеличения и
+// Ещё более краткая запись увеличения и уменьшения на единицу:
-// уменьшения переменной на единицу соответственно
 someVar++; // теперь someVar имеет значение 101
-someVar--; // обратно 100
+someVar--; // вернулись к 100
 
-// Массивы - это нумерованные списки содержащие значения любого типа.
+// Массивы — это нумерованные списки, содержащие значения любого типа.
-var myArray = ["Hello", 45, true];
+var myArray = ["Привет", 45, true];
 
 // Их элементы могут быть доступны при помощи синтаксиса с квадратными скобками.
 // Индексы массивов начинаются с нуля.
 myArray[1]; // = 45
 
-// Массивы можно изменять, как и их длину.
+// Массивы можно изменять, как и их длину,
-myArray.push("World");
+myArray.push("Мир");
 myArray.length; // = 4
 
-// Добавлять и редактировать определенный элемент
+// добавлять и редактировать определённый элемент
-myArray[3] = "Hello";
+myArray[3] = "Привет";
 
-// Объекты в JavaScript похожи на "словари" или ассоциативные массиы в других
+// Объекты в JavaScript похожи на словари или ассоциативные массивы в других
 // языках: неупорядоченный набор пар ключ-значение.
-var myObj = {key1: "Hello", key2: "World"};
+var myObj = {key1: "Привет", key2: "Мир"};
 
-// Ключи это строки, но кавычки необязательны, если строка удовлетворяет
+// Ключи — это строки, но кавычки необязательны, если строка удовлетворяет
 // ограничениям для имён переменных. Значения могут быть любых типов.
 var myObj = {myKey: "myValue", "my other key": 4};
 
-// Атрибуты объектов можно также получить, используя квадратные скобки,
+// Атрибуты объектов можно также получить, используя квадратные скобки
 myObj["my other key"]; // = 4
 
 // или через точку, при условии, что ключ является допустимым идентификатором.
@@ -184,16 +186,16 @@ myObj.myKey; // = "myValue"
 // Объекты изменяемы; можно изменять значения и добавлять новые ключи.
 myObj.myThirdKey = true;
 
-// Если вы попытаетесь получить доступ к несуществующему свойству,
+// Если вы попытаетесь получить доступ к несуществующему значению,
 // вы получите undefined.
 myObj.myFourthKey; // = undefined
 
 ///////////////////////////////////
 // 3. Логика и управляющие конструкции.
 
-// Синтаксис для этого раздела почти такой же как в Java.
+// Синтаксис для этого раздела почти такой же, как в Java.
 
-// Эта конструкция работает, как и следовало ожидать.
+// Условная конструкция работает, как и следовало ожидать,
 var count = 1;
 if (count == 3) {
     // выполняется, если count равен 3
@@ -203,50 +205,51 @@ if (count == 3) {
     // выполняется, если не 3 и не 4
 }
 
-// Как это делает while.
+// ...как и цикл while.
 while (true){
     // Бесконечный цикл!
 }
 
-// Циклы do-while такие же как while, но они всегда выполняются хотя бы раз.
+// Цикл do-while такой же, как while, но он всегда выполняется хотя бы раз.
 var input
 do {
     input = getInput();
 } while (!isValid(input))
 
-// цикл for является таким же, как C и Java:
+// цикл for такой же, как в C и Java:
 // инициализация; условие; шаг.
 for (var i = 0; i < 5; i++) {
-    // будет запущен 5 раз
+    // выполнится 5 раз
 }
 
-// && это логическое И, || это логическое ИЛИ
+// && — это логическое И, || — это логическое ИЛИ
-if (house.size == "big" && house.colour == "blue") {
+if (house.size == "big" && house.color == "blue") {
     house.contains = "bear";
 }
-if (colour == "red" || colour == "blue") {
+if (color == "red" || color == "blue") {
     // цвет красный или синий
 }
 
-// || используется как "короткий цикл вычисления" для присваивания переменных.
+// && и || используют сокращённое вычисление, что полезно
+// для задания значений по умолчанию.
 var name = otherName || "default";
 
-// Оператор switch выполняет проверку на равенство пр помощи ===
+// Оператор switch выполняет проверку на равенство при помощи ===
-// используйте break чтобы прервать выполнение после каждого case 
+// используйте break, чтобы прервать выполнение после каждого case, 
-// или выполнение пойдёт далее, игнорируя при этом остальные проверки. 
+// или выполнение пойдёт далее даже после правильного варианта. 
-grade = 'B';
+grade = 4;
 switch (grade) {
-  case 'A':
+  case 5:
-    console.log("Great job");
+    console.log("Отлично");
     break;
-  case 'B':
+  case 4:
-    console.log("OK job");
+    console.log("Хорошо");
     break;
-  case 'C':
+  case 3:
-    console.log("You can do better");
+    console.log("Можете и лучше");
     break;
   default:
-    console.log("Oy vey");
+    console.log("Ой-вей!");
     break;
 }
 
@@ -273,33 +276,33 @@ function myFunction()
 }
 myFunction(); // = undefined
 
-// JavaScript функции - это объекты, поэтому они могут быть переприсвоены на
+// В JavaScript функции — это объекты первого класса, поэтому они могут быть
-// различные имена переменных и передаваться другим функциям в качестве аргументов,
+// присвоены различным именам переменных и передаваться другим функциям 
-// например, когда назначается обработчик события:
+// в качестве аргументов, например, когда назначается обработчик события:
 function myFunction() {
     // этот код будет вызван через 5 секунд
 }
 setTimeout(myFunction, 5000);
 // Примечание: setTimeout не является частью языка, но реализован в браузерах и Node.js
 
-// Функции не обязательно должны иметь имя при объявлении - вы можете написать
+// Функции не обязательно должны иметь имя при объявлении — вы можете написать
-// анонимное определение функции непосредственно в агрументе другой функции.
+// анонимное определение функции непосредственно в аргументе другой функции.
 setTimeout(function() {
     // этот код будет вызван через 5 секунд
 }, 5000);
 
-// В JavaScript есть область видимости функции; функции имеют свою область
+// В JavaScript есть область видимости; функции имеют свою область
-// видимости, а другие блоки - нет.
+// видимости, а другие блоки — нет.
 if (true) {
     var i = 5;
 }
-i; // = 5 - не undefined как ожидалось бы в языках с блочной областью видимости
+i; // = 5, а не undefined, как ожидалось бы в языках с блочной областью видимости
 
 // Это привело к общепринятому шаблону "самозапускающихся анонимных функций",
 // которые препятствуют проникновению переменных в глобальную область видимости
 (function() {
     var temporary = 5;
-    // Мы можем получить доступ к глобальной области для записи в "глобальный объект",
+    // Мы можем получить доступ к глобальной области для записи в «глобальный объект»,
     // который в веб-браузере всегда window. Глобальный объект может иметь другое
     // имя в таких платформах, как Node.js
     window.permanent = 10;
@@ -309,100 +312,101 @@ permanent; // = 10
 
 // Одной из самых мощных возможностей JavaScript являются замыкания. Если функция
 // определена внутри другой функции, то внутренняя функция имеет доступ к 
-// переменным внешней функции, даже после того, как контекст выполнения выйдет из
+// переменным внешней функции даже после того, как контекст выполнения выйдет из
 // внешней функции.
 function sayHelloInFiveSeconds(name) {
-    var prompt = "Hello, " + name + "!";
+    var prompt = "Привет, " + name + "!";
     // Внутренние функции по умолчанию помещаются в локальную область видимости,
-    // как если бы они были объявлены с var.
+    // как если бы они были объявлены с помощью var.
     function inner() {
         alert(prompt);
     }
     setTimeout(inner, 5000);
-    // setTimeout асинхронна, поэтому функция sayHelloInFiveSeconds сразу выйдет
+    // setTimeout асинхронна, поэтому функция sayHelloInFiveSeconds сразу выйдет,
-    // и тело setTimeout будет вызвано позже. Однако, поскольку внутренняя
+    // после чего setTimeout вызовет функцию inner. Однако поскольку функция inner
-    // функция "замкнута", она по-прежнему имеет доступ к переменной prompt,
+    // «замкнута» вокруг sayHelloInFiveSeconds, она по-прежнему имеет доступ к переменной prompt
-    // когда sayHelloInFiveSeconds вызывется.
+    // на то время, когда она наконец будет вызвана.
 }
-sayHelloInFiveSeconds("Adam"); // откроется окно с "Hello, Adam!" через 5 секунд
+sayHelloInFiveSeconds("Адам"); // Через 5 с откроется окно «Привет, Адам!»
 
 ///////////////////////////////////
-// 5. Подробнее про Объекты, Конструкторы и Прототипы
+// 5. Подробнее об объектах; конструкторы и прототипы
 
 // Объекты могут содержать в себе функции.
 var myObj = {
     myFunc: function() {
-        return "Hello world!";
+        return "Привет, мир!";
     }
 };
-myObj.myFunc(); // = "Hello world!"
+myObj.myFunc(); // = "Привет, мир!"
 
-// Когда функции, прикрепленные к объекту, вызываются, они могут получить доступ
+// Когда вызываются функции, прикреплённые к объекту, они могут получить доступ
 // к этому объекту с помощью ключевого слова this.
 myObj = {
-    myString: "Hello world!",
+    myString: "Привет, мир!",
     myFunc: function() {
         return this.myString;
     }
 };
-myObj.myFunc(); // = "Hello world!"
+myObj.myFunc(); // = "Привет, мир!"
 
-// Какое это значение имеет к тому, как вызвана функция и где она определена.
+// Значение this зависит от того, как функция вызывается, 
-// Итак, наша функция не работает, если она вызывается не в контексте объекта.
+// а не от того, где она определена. Таким образом, наша функция не работает, 
+// если она вызывается не в контексте объекта.
 var myFunc = myObj.myFunc;
 myFunc(); // = undefined
 
 // И наоборот, функция может быть присвоена объекту и получать доступ к нему
-// через this, даже если она не была присвоена при объявлении.
+// через this, даже если она не была прикреплена к нему при объявлении.
 var myOtherFunc = function() {
 }
 myObj.myOtherFunc = myOtherFunc;
-myObj.myOtherFunc(); // = "HELLO WORLD!"
+myObj.myOtherFunc(); // = "ПРИВЕТ, МИР!"
 
-// Мы можем также указать контекст для выполнения функции, когда мы вызываем ее
+// Мы можем также указать контекст для выполнения функции при её вызове,
-// с помощью call или apply.
+// используя call или apply.
 var anotherFunc = function(s) {
     return this.myString + s;
 }
-anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+anotherFunc.call(myObj, " И привет, Луна!"); // = "Привет, мир! И привет, Луна!"
 
-// Функция apply аналогична, но принимает массив аргументов.
+// Функция apply почти такая же, но принимает в качестве списка аргументов массив.
-anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+anotherFunc.apply(myObj, [" И привет, Солнце!"]); // = "Привет, мир! И привет, Солнце!"
 
 // Это полезно при работе с функцией, которая принимает последовательность
-// аргументов, и вы хотите передать массив.
+// аргументов, а вы хотите передать массив.
 Math.min(42, 6, 27); // = 6
-Math.min([42, 6, 27]); // = NaN (не сработает!)
+Math.min([42, 6, 27]); // = NaN (Ой-ой!)
 Math.min.apply(Math, [42, 6, 27]); // = 6
 
-// Но, call и apply - временные. Когда мы хотим связать функцию, мы можем
+// Но call и apply — только временные. Когда мы хотим связать функцию с объектом, 
-// использовать bind.
+// мы можем использовать bind.
 var boundFunc = anotherFunc.bind(myObj);
-boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+boundFunc(" И привет, Сатурн!"); // = "Привет, мир! И привет, Сатурн!"
 
-// Bind также может использоваться, для частичного применения (каррирование) функции
+// Bind также может использоваться для частичного применения (каррирования) функции
 var product = function(a, b) { return a * b; }
 var doubler = product.bind(this, 2);
 doubler(8); // = 16
 
-// Когда вы вызываете функцию с помощью ключевого слова new создается новый объект,
+// Когда вы вызываете функцию с помощью ключевого слова new, создается новый объект,
-// и создает доступ к функции при помощи this. Такие функции называют конструкторами.
+// доступный функции при помощи this. Такие функции называют конструкторами.
 var MyConstructor = function() {
     this.myNumber = 5;
 }
 myNewObj = new MyConstructor(); // = {myNumber: 5}
 myNewObj.myNumber; // = 5
 
-// Каждый объект в JavaScript имеет свойтво prototype. Когда вы хотите получить
+// У каждого объекта в JavaScript есть прототип. Когда вы хотите получить
-// доступ к свойтву объекта, которое не существует в этом объекте, интерпретатор
+// доступ к свойству объекта, которое не существует в этом объекте, интерпретатор
 // будет искать это свойство в прототипе.
 
-// Некоторые реализации языка позволяют получить доступ к объекту прототипа
+// Некоторые реализации языка позволяют получить доступ к прототипу объекта
-// через свойство __proto__. Несмотря на то, что это может быть полезно для
+// через «магическое» свойство __proto__. Несмотря на то, что это может быть полезно
-// понимания прототипов, это не часть стандарта; мы увидим стандартные способы
+// для понимания прототипов, это не часть стандарта; мы увидим стандартные способы
 // использования прототипов позже.
 var myObj = {
-    myString: "Hello world!"
+    myString: "Привет, мир!"
 };
 var myPrototype = {
     meaningOfLife: 42,
@@ -414,34 +418,34 @@ var myPrototype = {
 myObj.__proto__ = myPrototype;
 myObj.meaningOfLife; // = 42
 
-// Для функций это так же работает.
+// Для функций это тоже работает.
-myObj.myFunc(); // = "hello world!"
+myObj.myFunc(); // = "Привет, мир!"
 
-// Если интерпретатор не найдет свойство в прототипе, то продожит поиск в 
+// Если интерпретатор не найдёт свойство в прототипе, то продожит поиск
-// прототипе прототипа и так далее.
+// в прототипе прототипа и так далее.
 myPrototype.__proto__ = {
     myBoolean: true
 };
 myObj.myBoolean; // = true
 
 // Здесь не участвует копирование; каждый объект хранит ссылку на свой прототип.
-// Это означает, что мы можем изменить прототип и наши изменения будут отражены везде
+// Это означает, что мы можем изменить прототип, и наши изменения будут отражены везде.
 myPrototype.meaningOfLife = 43;
 myObj.meaningOfLife; // = 43
 
-// Мы упомянули, что свойтсво __proto__ нестандартно, и нет никакого стандартного
+// Мы упомянули, что свойство __proto__ нестандартно, и нет никакого стандартного
-// способа, чтобы изменить прототип существующего объекта. Однако, есть два
+// способа, чтобы изменить прототип существующего объекта. Однако есть два
 // способа создать новый объект с заданным прототипом.
 
-// Первый способ это Object.create, который появился в ECMAScript 5 и есть еще
+// Первый способ — это Object.create, который появился в JavaScript недавно,
-// не во всех реализациях языка.
+// а потому доступен ещё не во всех реализациях языка.
 var myObj = Object.create(myPrototype);
 myObj.meaningOfLife; // = 43
 
 // Второй способ, который работает везде, имеет дело с конструкторами.
-// У конструкторов есть свойство с именем prototype. Это не прототип
+// У конструкторов есть свойство с именем prototype. Это *не* прототип
 // функции-конструктора; напротив, это прототип для новых объектов, которые
-// будут созданы с помощью этого конструктора и ключевого слова new
+// будут созданы с помощью этого конструктора и ключевого слова new.
 MyConstructor.prototype = {
     myNumber: 5,
     getMyNumber: function() {
@@ -453,8 +457,8 @@ myNewObj2.getMyNumber(); // = 5
 myNewObj2.myNumber = 6
 myNewObj2.getMyNumber(); // = 6
 
-// У встроенных типов, таких как строки и числа также есть конструкторы, которые
+// У встроенных типов, таких, как строки и числа, также есть конструкторы, которые
-// создают эквивалентые объекты-обертки.
+// создают эквивалентные объекты-обёртки.
 var myNumber = 12;
 var myNumberObj = new Number(12);
 myNumber == myNumberObj; // = true
@@ -464,47 +468,49 @@ typeof myNumber; // = 'number'
 typeof myNumberObj; // = 'object'
 myNumber === myNumberObj; // = false
 if (0) {
-    // Этот код не выполнятся, потому что 0 - это ложь.
+    // Этот код не выполнится, потому что 0 - это ложь.
 }
 if (Number(0)) {
-    // Этот код выполнится, потому что Number(0) это истина.
+    // Этот код *выполнится*, потому что Number(0) истинно.
 }
 
-// Впрочем, обертки это объекты и их можно расширять, например:
+// Впрочем, объекты-обёртки и встроенные типы имеют общие прототипы,
+// поэтому вы можете расширить функционал строк, например:
 String.prototype.firstCharacter = function() {
     return this.charAt(0);
 }
 "abc".firstCharacter(); // = "a"
 
-// Это часто используется в полифиллах, которые реализуют новые возможности
+// Это часто используется в т.н. полифилах, которые реализуют новые возможности
 // JavaScript в старой реализации языка, так что они могут быть использованы в
-// старых средах, таких как устаревшие браузеры.
+// старых средах, таких, как устаревшие браузеры.
 
 // Например, мы упомянули, что Object.create доступен не во всех реализациях, но
-// мы сможем использовать его с этим полифиллом:
+// мы сможем использовать его с помощью такого полифила:
-if (Object.create === undefined) { // не перезаписывать метод, если он существует
+if (Object.create === undefined) { // не перезаписываем метод, если он существует
     Object.create = function(proto) {
-        // создать временный конструктор с правильным прототипом
+        // создаём временный конструктор с правильным прототипом
         var Constructor = function(){};
         Constructor.prototype = proto;
-        // затем использовать его для создания нового объекта, на основе прототипа
+        // затем используем его для создания нового,
+        // правильно прототипированного объекта
         return new Constructor();
     }
 }
 ```
 
-## Что еще почитать
+## Что ещё почитать
 
-[Современный учебник JavaScript (Илья Кантор)](http://learn.javascript.ru) - 
+[Современный учебник JavaScript (Илья Кантор)](http://learn.javascript.ru) — 
 качественный учебник по JavaScript на русском языке.
 
-[Mozilla Developer Network](https://developer.mozilla.org/ru/docs/Web/JavaScript) -
+[Mozilla Developer Network](https://developer.mozilla.org/ru/docs/Web/JavaScript) —
 предоставляет отличную документацию для JavaScript, как он используется в браузерах.
 Кроме того, это вики, поэтому, если вы знаете больше, вы можете помочь другим,
 делясь своими знаниями.
 
-[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) - это
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) — это
-подробное руководство всех неинтуитивных особенностей языка.
+подробное руководство по всем неинтуитивным особенностей языка.
 
-[Stack Overflow](http://stackoverflow.com/questions/tagged/javascript) - можно
+[Stack Overflow](http://stackoverflow.com/questions/tagged/javascript) — можно
 найти ответ почти на любой ваш вопрос, а если его нет, то задать вопрос самому.