Объектно-ориентированное программирование в JavaScript, NoPrototype стиль [Object-oriented programming in JavaScript, NoPrototype style]

Большое количество статей присутствует в бескрайнем интернете об объектно-ориентированном программирование на JavaScript. Но мне как C# программисту, привыкшему к его ООП синтаксису и количеству возможностей, которые он дает, не одна из них не подходит. Почему же?

Задача
Что действительно нужно от ООП в JavaScript:

• Инкапсуляция
• Наследование
• Полиморфизм

А теперь, по-порядку.

NoPrototype
Многие способы реализации объект-ориентированного программирования в JavaScript основаны на использовании прототипа (например), но ни один из них не решает поставленную мной задачу. Данный способ не будет основан на прототипах, так что с этого следует и название стиля. Но об это далее.

Класс
Единственное, что нам нужно, так это выработать единый стиль написания класса в JavaScript.
Приведем пример класса на C#:

public class Book
    {
        // конструктор
        public Book(string newName)
        {
            name = newName;
        }
        // приватное поле
        private int id;
        // приватное поле
        private string name;
        // публичное поле
        public string Description;
        // публичное свойство
        public string Name
        {
            // getter
            get { return name; }
            // setter
            set { name = value; }
        }
        // приватный метод
        private void incrementId()
        {
            id++;
        }
        // публичный метод
        public void Buy()
        {
            Description += " (куплено)";
        }
    }

А теперь тот же класс только на JavaScript:

var Book = function (newName) {
    var self = this;

    // приватное поле
    var id = null;
    // приватное поле
    var name = null;
    // публичное поле
    self.Description = null;
    // приватный метод
    var incrementId = function () {
        id++;
    };
    // публичное свойство
    self.Name = function (value) {
        if (value === undefined) {
            // getter
            return name;
        } else {
            // setter
            name = value;
        }
    };
    // публичный метод
    self.Buy = function () {
        self.Description += " (куплено)";
    };

    // конструктор
    var constructor = function () {
        id = 0;
        name = newName;
    };
    constructor();
};

Очень важно соблюдать простые правила:

• this → self. Использовать self вместо this. Потому что: this можно подменить, и если скрипт будет сжиматься, то ключевые слова не сжимаются.
• Соблюдать порядок написания элементов:

1. Приватные поля
2. Публичные поля
3. Приватные методы и приватные свойства. Порядок среди все приватных методов/свойств зависит от использованных внутри других приватных методов/свойств. Например, если метод A() использует метод B() и C(), то порядок написания методов будет: B, C, A.
4. Публичные методы и публичные свойства. Порядок среди все публичных методов/свойств любой.
5. Конструктор

Инкапсуляция
В рассмотренном выше примере мы использовали всего 2 модификатора доступа:

• private. Описание элемента начинается с "var ". Доступ к элементу осуществляется по имени элемента. Например: если мы опишем приватное поле  var name = 'Some book'; то чтобы присвоить новое значение пишем name = 'New book';
• public. Описание элемента начинается с "self.". Доступ к элементу осуществляется по "self." + имя элемента. Например: описание публичного поля self.Description = null; и его использование self.Description = 'New description';

Приведу таблицу соответствия модификаторов доступа C# и JavaScript:

C#	JavaScript
public	public
private	private
protected	public
internal	public

Наследование
Для реализации наследования и полиморфизма воспользуемся следующим кодом:

function inherit(derivedInstance, baseClass, args) {
                var args = (args === undefined) ? [] : args;
                baseClass.apply(derivedInstance, args);
                var base = {};
                for (var methodName in derivedInstance) (function() {
                    var method = derivedInstance[methodName];
                    if (typeof (method) == "function") {
                        base[methodName] = function() {
                            return method.apply(derivedInstance, arguments);
                        };
                    }
                })();
                return base;
            }

Наследование реализовывается глобальной функцией inherit.
Аргументы функции inherit:

• derivedInstance - ссылка на объект, который будет наследоваться от класса baseClass
• baseClass - ссылка на функцию, которая описывает базовый класс, именно от этого базового класса будет осуществляться наследование
• args - массив аргументов конструктора базового класса, то есть аргументы, необходимые для создания объекта класса baseClass
• возвращаемое значение - это ссылка на объект, содержащий список базовых методов. Это необходимо для полиморфизма, об этом далее.

Ну и пример (выполнить):

var Car = function () {
    var self = this;

    self.Drive = function () {
        alert("Поехали!");
    };
};

var Toyota = function () {
    var base = inherit(this, Car);
    var self = this;
};

var ToyotaPrado = function () {
    var base = inherit(this, Toyota);
    var self = this;
};

var myPrado = new ToyotaPrado();
myPrado.Drive();

Полиморфизм
Для осуществления полиморфизма воспользуемся так же глобальной функцией inherit.
За неимением в JavaScript чего либо подобного virtual и override, нам опять же необходимо придерживаться правилу:

• Все виртуальные свойства/методы должны быть публичными, иначе мы никак не сможем переопределить их. Иными словами все публичные свойства/методы класса виртуальны.

Все просто, смотрим пример (выполнить):

var Car = function (motor) {
    var self = this;

    self.Drive = function () {
        alert("Включаем " + motor + " мотор. Поехали!");
    };
};

var Toyota = function (motor) {
    var base = inherit(this, Car, [motor]);
    var self = this;

    self.Drive = function () {
        base.Drive();
        alert("Причем на Toyota.");
    };
};

var ToyotaPrado = function (model) {
    var base = inherit(this, Toyota, ["бензиновый 4,0 л"]);
    var self = this;

    self.Drive = function () {
        base.Drive();
        alert("А теперь наш Prado " + model + " газ в пол!");
    };
};

var myToyota = new Toyota("неизвестный");
var myPrado = new ToyotaPrado("Premium");

alert("Запуск метод: myToyota.Drive()");
myToyota.Drive();

alert("Запуск метод: myPrado.Drive()");
myPrado.Drive();

Один из достоинств NoPrototype стиля - нативная поддержка браузером (если закрыть глаза на метод inherit) или отсутствие зависимости от фреймфорка (JQuery и т.д.), а также реализация инкапсуляции.