Хабрахабр

Protected методы в JavaScript ES5

Про объектную модель в JavaScript написано много замечательных статей. Да и про различные способы создания приватных членов класса в интернете полно достойных описаний. А вот про protected методы — данных очень немного. Я бы хотел восполнить этот пробел и рассказать, как можно создать protected методы без библиотек на чистом JavaScript ECMAScript 5.

В этой статье:

Ссылка на git-hub репозиторий с исходный кодом и тестами.

Зачем нужны защищенные члены класса

Если коротко, то

  • проще понимать работу класса и находить в нем ошибки. (Сразу видно в каких case'ах используются члены класса. Если приватные — то анализировать надо только данный класс, ну, а если защищенные — то только данный и производные классы.)
  • легче управлять изменениями. (Например, можно убирать приватные члены, не опасаясь, что сломается что-то вовне редактируемого класса.)
  • уменьшается количество заявок в bug-трекере, т.к. пользователи библиотеки или контрола могут «зашиться» на наши «приватные» члены, которые в новой версии класса мы решили убрать, либо изменить логику их работы.
  • И в целом, защищенные члены класса — это инструмент проектирования. Хорошо иметь его под рукой отлаженным и хорошо протестированным.

Напомню, что основная идея protected членов заключается в том, чтобы скрыть методы и свойства от пользователей экземпляра класса, но при этом позволить производным классам иметь к ним доступ.

Например, мы разрабатываем контрол или библиотеку, которые пользователи будут устанавливать на свои сайты или приложения. Использование TypeScript'a не позволит вызывать защищенные методы, однако, после компиляции в JavaScript, все приватные и защищенные члены становятся публичными. В итоге, наш баг-трекер ломится от жалоб, что наша библиотека или контрол работают неправильно. Эти пользователи смогут делать с защищенными членами все, что хотят, нарушая целостность класса. Поэтому, чтобы облегчить всем жизнь, нужна такая защита, которая не будет давать возможность изменять значение приватных и защищенных членов класса. Мы тратим время и силы на то, чтобы разобраться — «это каким-таким образом объект оказался в том состоянии у клиента, что привело к ошибке?!».

Что нужно для понимания рассматриваемого метода

Для понимания метода объявления protected членов класса необходимо уверенное знание:

  • устройства классов и объектов в JavaScript.
  • способов создания приватных членов класса (как минимум через замыкание).
  • методов Object.defineProperty и Object.getOwnPropertyDescriptor

Про устройство объектной модели в JavaScript могу порекомендовать, например, прекрасную статью Андрея Акиньшина(DreamWalker) «Понимание ООП в JS [часть №1]».
Про приватные свойства есть хорошее и, на мой взгляд, достаточно полное описание аж 4-х различных способов создания приватных членов класса на сайте MDN.

Что касается метода Object.defineProperty, он позволит нам скрыть свойства и методы из for-in циклов, и, как следствие, от алгоритмов сериализации:

function MyClass()); this.publicNumber = 25;
}; var obj1 = new MyClass();
for(var prop in obj1){ console.log('property:' prop); //prop никогда не будет равен 'protectedNumber'
}
console.log(JSON.stringify(obj1)); // Выведет { 'publicNumber': 25 }

Подобное сокрытие необходимо выполнять, но этого, конечно же, не достаточно т.к. еще остается возможность вызвать метод/свойство напрямую:

console.log(obj1.protectedNumber); // Выведет 12.

Вспомогательный класс ProtectedError

Для начала нам потребуется класс ProtectedError, который наследуется от Error, и который будет выбрасываться, если нет доступа к защищенному методу или свойству.

function ProtectedError(){ this.message = "Encapsulation error, the object member you are trying to address is protected."; }
ProtectedError.prototype = new Error();
ProtectedError.prototype.constructor = ProtectedError;

Реализация protected членов класса в ES5

Теперь, когда у нас есть класс ProtectedError и мы понимаем что делает Object.defineProperty со значением enumerable: false, давайте разберем создание базового класса, который хочет разделить метод protectedMethod со всеми своими производными классами, но спрятать от всех остальных:

function BaseClass(){ if (!(this instanceof BaseClass)) return new BaseClass(); var _self = this; // Замыкаем экземпляр класса, чтобы в будущем не зависеть от контекста /** @summary Проверяет доступ к защищенным членам класса */ function checkAccess() { if (!(this instanceof BaseClass)) throw new ProtectedError(); if (this.constructor === BaseClass) throw new ProtectedError() } Object.defineProperty(_self, 'protectedMethod', { enumerable: false, // скроим метод из for-in циклов configurable:false, // запретим переопределять это свойство value: function(){ // Раз мы здесь, значит, нас вызвали либо как публичный метод на экземпляре класса Base, либо из производных классов checkAccess.call(this); // Проверяем доступ. protectedMethod(); } }); function protectedMethod(){ // Если нужно обратиться к членам данного класса, // то обращаемся к ним не через this, а через _self return 'example value'; } this.method = function (){ protectedMethod(); // правильный способ вызова защищенного метода из других методов класса BaseClass //this.protectedMethod(); // Неправильный способ вызова, т.к. он приведет к выбросу исключения ProtectedError }
}

Описание конструктора класса BaseClass

Возможно вас смутит проверка:

if (!(this instanceof BaseClass)) return new BaseClass();

Эта проверка «на любителя». Можете ее убрать, к protected методам она не имеет отношения. Однако, лично я в своем коде ее оставляю, т.к. она нужна для тех случаев, когда экземпляр класса создается некорректно, т.е. без ключевого слова new. Например, вот таким образом:

var obj1 = BaseClass();
// или так:
var obj2 = BaseClass.call({});

В таких случаях поступайте, как хотите. Можете, например, сгенерировать ошибку:

if (!(this instanceof BaseClass)) throw new Error('Wrong instance creation. Maybe operator "new" was forgotten');

А можете просто создать экземпляр корректно, как это сделано в BaseClass.

Далее мы сохраняем новый экземпляр в переменную _self (зачем это нужно поясню чуть позже).

Описание публичного свойства с именем protectedMethod

Входя в метод, вызываем проверку контекста на котором нас вызвали. Лучше проверку вынести в отдельный метод, например, checkAccess, т.к. одна и та же проверка понадобится во всех защищенных методах и свойствах классах. Так вот, первым делом проверяем тип контекста вызова «this». Если this имеет тип отличный от BaseClass, значит, тип — ни сам BaseClass, и ни один из его производных. Запрещаем подобные вызовы.

if(!(this instanceof BaseClass)) throw new ProtectedError();

Каким образом такое может произойти? Например, так:

var b = new BaseClass(); var someObject = {};
b.protectedMethod.call(someObject); // В этом случае, внутри protectedMethod this будет равен someObject и мы это отловим, т.к. someObject instanceof BaseClass будет ложным

В случае производных классов выражение this instanceof BaseClass будет истинным. Но и для экземпляров BaseClass выражение this instanceof BaseClass будет истинным. Поэтому, чтобы отличить экземпляры класса BaseClass от экземпляров производных классов проверяем конструктор. Если конструктор совпадает с BaseClass, значит, наш protectedMethod вызывают на экземпляре BaseClass, как обычный публичный метод:

var b = new BaseClass(); b.protectedMethod();

Запрещаем подобные вызовы:

if(this.constructor === BaseClass) throw new ProtectedError();

Далее идет вызов замкнутого метода protectedMethod, который, собственно, и является защищаемым нами методом. Внутри метода, если возникает потребность обратиться к членам класса BaseClass, можно это сделать, используя сохраненный экземпляр _self. Именно для этого _self и был создан, чтобы иметь доступ к членам класса из всех замкнутых/приватных, методов. Поэтому, если в вашем защищенном методе или свойстве не нужно обращаться к членам класса, то можете не создавать переменную _self.

Вызов защищенного метода внутри класса BaseClass

Внутри класса BaseClass к protectedMethod надо обращаться только по имени, а не через this. Иначе, внутри protectedMethod мы не сможем отличить, вызвали ли нас как публичный метод или изнутри класса. В данном случае замыкание нас спасает — protectedMethod ведет себя как обычный приватный метод, замкнутый внутри класса и видимый только внутри области видимости функции BaseClass.

Описание производного класса DerivedClass

Теперь давайте рассмотрим производный класс и как сделать в нем доступ к защищенному методу базового класса.

function DerivedClass(){ var _base = { protectedMethod: this.protectedMethod.bind(this) }; /** @summary Проверяет доступ к защищенным членам класса */ function checkAccess() { if (this.constructor === DerivedClass) throw new ProtectedError(); } // Переопределим метод для всех Object.defineProperty(this, 'protectedMethod', { enumerable: false, // т.к. мы создаем свойство на конкретном экземпляре this configurable: false,// то нужно опять запретить переопределение и показ в for-in циклах // Теперь можем объявлять анонимный метод value: function(){ checkAccess.call(_self); return _base.protectedMethod(); } }); // Использование защищенного метода базового класса в производном this.someMethod = function(){ console.log(_base.protectedMethod()); }
}
DerivedClass.prototype = new BaseClass();
Object.defineProperty(DerivedClass.prototype, 'constructor', { value : DerivedClass, configurable: false
});

Описание конструктора производного класса

В производном классе мы создаем объект _base, в котором размещаем ссылку на метод protectedMethod базового класса, замкнутую на контекст производного класса через стандартный метод bind. Это значит, что вызов _base.protectedMethod(); внутри protectedMethod this будет не объектом _base, а экземпляром класса DerivedClass.

Описание метода protectedMethod внутри класса DerivedClass

В классе DerivedClass обязательно нужно объявить публичный метод protectedMethod таким же образом, как мы делали в базовом классе через Object.defineProperty и проверить в нем доступ, вызывая метод checkAccess или совершая проверку прямо в методе:

Object.defineProperty(DerivedClass.prototype, 'protectedMethod', { enumerable: false, configurable: false, value: function(){ if(this.constructor === DerivedClass) throw new ProtectedError() return _base.protectedMethod(); } });

Проверяем — «а не вызвали ли нас как простой публичный метод?» У экземпляров класса DerivedClass конструктор будет равен DerivedClass. Если это так, то генерируем ошибку. Иначе — отправляем в базовый класс и уже он сделает все остальные проверки.

Одна объявлена через Object.defineProperty и нужна для классов производных от DerivedClass. Итак, в производном классе у нас две функции. Второй метод находится в объекте _base, который замкнут внутри класса DerivedClass и потому не виден никому извне и именно он используется для доступа к защищенному методу из всех методов DerivedClass. Она публичная и потому в ней есть проверка, запрещающая публичные вызовы.

Защита свойств

Со свойствами работа происходит чуть по другому. Свойства в BaseClass определяются как обычно через Object.defineProperty, только в геттерах и сеттерах нужно вначале добавить нашу проверку т.е. вызвать checkAccess:

function BaseClass(){ function checkAccess(){ ... } var _protectedProperty; Object.defineProperty(this, 'protectedProperty', { get: function () { checkAccess.call(this); return _protectedProperty; }, set: function (value) { checkAccess.call(this); _protectedProperty = value; }, enumerable: false, configurable: false });
}

Внутри класса BaseClass к защищенному свойству обращаемся не через this, а к замкнутой переменной _protectedProperty. В случае, если нам важно, чтобы отрабатывал геттер и сеттер при использовании свойства внутри класса BaseClass, тогда нужно создать приватные методы getProtectedPropety и setProtectedProperty, внутри которых не будет проверок, и их уже вызывать.

function BaseClass(){ function checkAccess(){ ... } var _protectedProperty; Object.defineProperty(this, 'protectedProperty', { get: function () { checkAccess.call(this); return getProtectedProperty(); }, set: function (value) { checkAccess.call(this); setProtectedProperty(value); }, enumerable: false, configurable: false }); function getProtectedProperty(){ // Делаем полезную работу return _protectedProperty; } function setProtectedProperty(value){ // Делаем полезную работу _protectedProperty = value; }
}

В производных классах работа со свойствами чуть посложнее, т.к. нельзя свойству подменить контекст. Поэтому, мы воспользуемся стандартным методом Object.getOwnPropertyDescriptor, чтобы из свойства базового класса получить геттер и сеттер как функции, которым уже можно поменять контекст вызова:

function DerivedClass(){ function checkAccess(){ ... } var _base = { protectedMethod: _self.protectedMethod.bind(_self), }; var _baseProtectedPropertyDescriptor = Object.getOwnPropertyDescriptor(_self, 'protectedProperty'); // объявляем защищенное свойство на объекте _base // чтобы внутри класса DerivedClass обращаться к защищенному свойству Object.defineProperty(_base, 'protectedProperty', { get: function() { return _baseProtectedPropertyDescriptor.get.call(_self); }, set: function(value){ _baseProtectedPropertyDescriptor.set.call(_self, value); } }) // Здесь же мы объявляем свойство публичным, чтобы у классов производных от DerivedClass была возможность добраться до защищенного метода. Object.defineProperty(_self, 'protectedProperty', { get: function () { checkAccess.call(_self); return base.protectedProperty; }, set: function (value) { checkAccess.call(_self); _base.protectedProperty = value; }, enumerable: false, configurable: false });
}

Описание наследования

И последнее, что хотелось бы прокомментировать — наследование DerivedClass от BaseClass. Как вы возможно знаете, DerivedClass.prototype = new BaseClass(); не только создает прототип, но и переписывает его свойство constructor. Из-за чего у каждого экземпляра DerivedClass свойство constructor становится равным BaseClass. Чтобы исправить это, обычно, после создания прототипа, переписывают свойство constructor:

DerivedClass.prototype = new BaseClass();
DerivedClass.prototype.constructor = DerivedClass;

Однако, чтобы никто не переписал это свойство после нас, используем все тот же Object.defineProperty. Свойство configurable: false запрещает переопределять свойство повторно:

DerivedClass.prototype = new BaseClass();
Object.defineProperty(DerivedClass.prototype, 'constructor', { value : DerivedClass, configurable: false
});

Теги
Показать больше

Похожие статьи

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Кнопка «Наверх»
Закрыть