diff --git a/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown
index b5556f49..f0c91278 100644
--- a/ru-ru/javascript-ru.html.markdown
+++ b/ru-ru/javascript-ru.html.markdown
@@ -443,8 +443,10 @@ sayHelloInFiveSeconds("Вася"); // откроет модальное окно
///////////////////////////////////
+// 5. Немного об Объектах. Конструкторы и Прототипы
// 5. More about Objects; Constructors and Prototypes
+// Объекты погут содержать функции
// Objects can contain functions.
var myObj = {
myFunc: function(){
@@ -453,6 +455,8 @@ var myObj = {
};
myObj.myFunc(); // = "Hello world!"
+// Когда функции прикрепленные к объекту вызываются, они могут получить доступ
+// к данным объекта, ипользую ключевое слово this.
// When functions attached to an object are called, they can access the object
// they're attached to using the this keyword.
myObj = {
@@ -463,12 +467,17 @@ myObj = {
};
myObj.myFunc(); // = "Hello world!"
+// Содержание this определяется исходя из того, как была вызвана функция, а
+// не места её определения. По этой причине наша функция не будет работать вне
+// контекста объекта.
// What this is set to has to do with how the function is called, not where
// it's defined. So, our function doesn't work if it isn't called in the
// context of the object.
var myFunc = myObj.myFunc;
myFunc(); // = undefined
+// И напротив, функция может быть присвоена объекту и получить доступ к нему
+// через this, даже если она не была прикреплена к объекту в момент её создания.
// Inversely, a function can be assigned to the object and gain access to it
// through this, even if it wasn't attached when it was defined.
var myOtherFunc = function(){
@@ -477,6 +486,7 @@ var myOtherFunc = function(){
myObj.myOtherFunc = myOtherFunc;
myObj.myOtherFunc(); // = "HELLO WORLD!"
+// Также можно указать контекс выполнения фунции с помощью 'call' или 'apply'.
// We can also specify a context for a function to execute in when we invoke it
// using 'call' or 'apply'.
@@ -485,10 +495,13 @@ var anotherFunc = function(s){
}
anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+// Функция 'apply' очень похожа, но принимает массив со списком аргументов.
// The 'apply' function is nearly identical, but takes an array for an argument list.
anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+// Это может быть удобно, когда работаешь с фунцией принимающей на вход
+// последовательность аргументов и нужно передать их в виде массива.
// This is useful when working with a function that accepts a sequence of arguments
// and you want to pass an array.
@@ -496,18 +509,25 @@ Math.min(42, 6, 27); // = 6
Math.min([42, 6, 27]); // = NaN (uh-oh!)
Math.min.apply(Math, [42, 6, 27]); // = 6
+// Однако, 'call' и 'apply' не имеют постоянного эффекта. Если вы хотите
+// зафиксировать контекст для функции, используйте bind.
// But, 'call' and 'apply' are only temporary. When we want it to stick, we can use
// bind.
var boundFunc = anotherFunc.bind(myObj);
boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+// bind можно использовать чтобы частично передать аргументы в
+// функцию (каррировать).
// Bind can also be used to partially apply (curry) a function.
var product = function(a, b){ return a * b; }
var doubler = product.bind(this, 2);
doubler(8); // = 16
+// Когда функция вызывается с ключевым словом new, создается новый объект.
+// Данный объект становится доступным функции через ключевое слово this.
+// Функции спроектированные вызываться таким способом называются конструкторами.
// When you call a function with the new keyword, a new object is created, and
// made available to the function via the this keyword. Functions designed to be
// called like that are called constructors.
@@ -518,10 +538,17 @@ var MyConstructor = function(){
myNewObj = new MyConstructor(); // = {myNumber: 5}
myNewObj.myNumber; // = 5
+// Любой объект в JavaScript имеет 'прототип'. Когда выпытаетесь получить доступ
+// к свойству не объявленному в данном объекте, интерпретатор будет искать его
+// в прототипе.
// Every JavaScript object has a 'prototype'. When you go to access a property
// on an object that doesn't exist on the actual object, the interpreter will
// look at its prototype.
+// Некоторые реализации JS позволяют получить доступ к прототипу с помощью
+// волшебного свойства __proto__. До момента пока оно не являются стандартным,
+// __proto__ полезно лишь для изучения прототипов в JavaScript. Мы разберемся
+// со стандартными способами работы с прототипом несколько позже.
// Some JS implementations let you access an object's prototype on the magic
// property __proto__. While this is useful for explaining prototypes it's not
// part of the standard; we'll get to standard ways of using prototypes later.
@@ -537,10 +564,10 @@ var myPrototype = {
myObj.__proto__ = myPrototype;
myObj.meaningOfLife; // = 42
-
-// This works for functions, too.
myObj.myFunc(); // = "hello world!"
+// Естествно, если в свойства нет в прототипе, поиск будет продолжен в прототипе
+// прототипа и так далее.
// Of course, if your property isn't on your prototype, the prototype's
// prototype is searched, and so on.
myPrototype.__proto__ = {
@@ -548,21 +575,32 @@ myPrototype.__proto__ = {
};
myObj.myBoolean; // = true
+// Ничего не копируется, каждый объект хранит ссылку на свой прототип. Если
+// изменить прототип, все изменения отразятся во всех его потомках.
// There's no copying involved here; each object stores a reference to its
// prototype. This means we can alter the prototype and our changes will be
// reflected everywhere.
myPrototype.meaningOfLife = 43;
myObj.meaningOfLife; // = 43
+// Как было сказано выше, __proto__ не является стандартом, и нет стандартного
+// способа изменить прототип у созданного объекта. Однако, есть два способа
+// создать объект с заданным прототипом.
// We mentioned that __proto__ was non-standard, and there's no standard way to
// change the prototype of an existing object. However, there are two ways to
// create a new object with a given prototype.
+// Первый способ - Object.create, был добавлен в JS относительно недавно, и
+// потому не доступен в более ранних реализациях языка.
// The first is Object.create, which is a recent addition to JS, and therefore
// not available in all implementations yet.
var myObj = Object.create(myPrototype);
myObj.meaningOfLife; // = 43
+// Второй вариан доступен везде и связан с конструкторами. Конструкторы имеют
+// свойство prototype. Это воовсе не прототип функции конструктора, напротив,
+// это прототип, который присваевается новым объектам, созданным с этим
+// конструктором с помощью ключевого слова new.
// The second way, which works anywhere, has to do with constructors.
// Constructors have a property called prototype. This is *not* the prototype of
// the constructor function itself; instead, it's the prototype that new objects
@@ -578,23 +616,30 @@ myNewObj2.getMyNumber(); // = 5
myNewObj2.myNumber = 6
myNewObj2.getMyNumber(); // = 6
+// У встроенных типов таких, как строки и числа, тоже есть конструкторы,
+// создающие эквивалентные объекты-обертки.
// Built-in types like strings and numbers also have constructors that create
// equivalent wrapper objects.
var myNumber = 12;
var myNumberObj = new Number(12);
myNumber == myNumberObj; // = true
+// Правда, они не совсем эквивалентны.
// Except, they aren't exactly equivalent.
typeof myNumber; // = 'number'
typeof myNumberObj; // = 'object'
myNumber === myNumberObj; // = false
if (0){
+ // Этот фрагмент кода не будет выпонен, так как 0 приводится к false
// This code won't execute, because 0 is falsy.
}
if (Number(0)){
+ // Этот фрагмент кода *будет* выпонен, так как Number(0) приводится к true.
// This code *will* execute, because Number(0) is truthy.
}
+// Однако, оберточные объекты и обычные встроенные типы имеют общие прототипы,
+// следовательно вы можете расширить функциональность строки, например.
// However, the wrapper objects and the regular builtins share a prototype, so
// you can actually add functionality to a string, for instance.
String.prototype.firstCharacter = function(){
@@ -602,17 +647,23 @@ String.prototype.firstCharacter = function(){
}
"abc".firstCharacter(); // = "a"
+// Этот факт часто используется для создания полифилов(polyfill) - реализации
+// новых возможностей JS в его болле старых версиях для того чтобы их можно было
+// использовать в устаревших браузерах.
// This fact is often used in "polyfilling", which is implementing newer
// features of JavaScript in an older subset of JavaScript, so that they can be
// used in older environments such as outdated browsers.
+// Например, мы упомянули, что Object.create не доступен во всех версиях
+// JavaScript, но мы може создать полифилл.
// For instance, we mentioned that Object.create isn't yet available in all
// implementations, but we can still use it with this polyfill:
-if (Object.create === undefined){ // don't overwrite it if it exists
+if (Object.create === undefined){ // не переопределяем если есть
Object.create = function(proto){
- // make a temporary constructor with the right prototype
+ // создаем временный конструктор с заданным прототипом
var Constructor = function(){};
Constructor.prototype = proto;
+ // создаём новый объект с правильным прототипом
// then use it to create a new, appropriately-prototyped object
return new Constructor();
}