Паттерн JavaScript псевдо-класс (pseudo-classical)

В паттерне, объект создается в конструкторе, а его методы объявляются в прототипе.

Данный паттерн используется во фреймворках, таких как Google Closure Library. Нативные объекты JavaScript также используют данный паттернт.

Объявление Pseudo-class

Термит Pseudo-class выбран потому, что в JavaScript нет как таковых классов, как в других языка как C, Java, PHP и др., но данный паттерн близок к определению класса.

Псевдо-класс состоит из функции конструктора и методов.

Например, псевдо-класс Animal состоит за одного метода sit и 2 свойств:

function Animal(name) {
  this.name = name
}

Animal.prototype = { 
  canWalk: true,
  sit: function() {
    this.canWalk = false
    alert(this.name + ' sits down.')
  }
}

var animal = new Animal('Pet') // (1)

alert(animal.canWalk) // true

animal.sit()             // (2)

alert(animal.canWalk) // false

1. Когда вызывается new Animal(name), объект получается ссылку __proto__ на Animal.prototype (см. правую часть схемы).
2. Метод animal.sit изменяет animal.canWalk в экземпляре, поэтому наше животное больше не может ходить, а другие могут.

Схема псевдо-класса:

1. Методы и свойства по умолчанию определяются в прототипе.
2. Методы в prototype используют this, который указывает на текущий объект так как значение this зависит от контекста вызова. Поэтому в animal.sit() this относиться к animal.

Наследование

Давайте создадим новый класс, который будет наследоваться от Animal, например Rabbit:

function Rabbit(name) {
  this.name = name
}

Rabbit.prototype.jump = function() {
  this.canWalk = true
  alert(this.name + ' jumps!')
}

var rabbit = new Rabbit('John')

Как видим, кролик имеет такую же структуру как и Animal — метод определен в прототипе.

Для наследования от Animal, необходимо сделать так Rabbit.prototype.__proto__ == Animal.prototype. Это естественное требование, так как если метод не найден в Rabbit.prototype, то его будем искать в методах родителя Animal.prototype.

Вот так, например:

Чтобы реализовать это, мы должны создать сначала пустой объект Rabbit.prototype наследуемы от Animal.prototype и после этого добавить методы.

function Rabbit(name) {
  this.name = name
}

Rabbit.prototype = inherit(Animal.prototype)

Rabbit.prototype.jump = function() { ... }

Где inherit создает пустой объект с указанным __proto__:

function inherit(proto) {
  function F() {}
  F.prototype = proto
  return new F
}

Вот что получилось в конце:

// Animal 
function Animal(name) {
  this.name = name
}

// Animal methods
Animal.prototype = { 
  canWalk: true,
  sit: function() {
    this.canWalk = false
    alert(this.name + ' sits down.')
  }
}

// Rabbit
function Rabbit(name) {
  this.name = name
}

// inherit
Rabbit.prototype = inherit(Animal.prototype)

// Rabbit methods
Rabbit.prototype.jump = function() {
  this.canWalk = true
  alert(this.name + ' jumps!')
}

// Usage
var rabbit = new Rabbit('Sniffer')

rabbit.sit()   // Sniffer sits.
rabbit.jump()  // Sniffer jumps!

Не используйте new Animal для наследования

Хорошо известный, но не правильный способ наследования, это когда вместо Rabbit.prototype = inherit(Animal.prototype) люди делают следующее:

// inherit from Animal
Rabbit.prototype = new Animal()

Как результат, мы получаем new Animal в прототипе. Наследование работает, так как new Animal естественно, наследует Animal.prototype.

… Но кто сказал, что new Animal() может быть вызван без name? Конструктор может строго требовать аргументов и умереть без них.

На самом деле, проблеме более концептуальная чем эта. Мы не хотим создавать Animal. Мы всего лишь хотим наследовать от него.

Вот почему Rabbit.prototype = inherit(Animal.prototype) более предпочтителен. Аккуратный наследство без побочных эффектов.

Вызов конструктора суперкласса

Конструктор суперкласса теперь вызывается автоматически. Мы можем вызвать его ручками с помощью Animal.apply() для текущего объекта:

function Rabbit(name) {
  Animal.apply(this, arguments)
}

Данный код исполняет конструктор Animal в контексте текущего объекта и он задает name экземпляра.

Переопределение методов (полиморфизм)

Чтобы переопределить родительский метод, замените его в дочернем прототипе:

Rabbit.prototype.sit = function() {
  alert(this.name + ' sits in a rabbity way.')
}

При вызове rabbit.sit() sit ищется по цепочке rabbit -> Rabbit.prototype -> Animal.prototype и находит его в Rabbit.prototype не доходя до Animal.prototype.

Конечно, мы может переопределить его иначе — напрямую в объекте:

rabbit.sit = function() {
  alert('A special sit of this very rabbit ' + this.name)
}

Вызов родительского метода после переопределения

После переопределения метода, нам по-прежнему может понадобиться вызвать метод родителя. Это возможно если мы напрямую обратимся к прототипу родителя.

Rabbit.prototype.sit = function() {
  alert('calling superclass sit:')
  Animal.prototype.sit.apply(this, arguments)
}

Все родительские методы вызываются с помощью apply/call куда передается текущий объект как this. Простой вызов Animal.prototype.sit() будет использовать Animal.prototype как this.

Sugar: removing direct reference to parent

В предыдущем примере, мы вызывали родительский класс напрямую. Как конструктор: Animal.apply..., или метод: Animal.prototype.sit.apply....

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

Обычно, языки программирования позволяют вызвать родительские методы с помощью специальный ключевых слов, как, например, parent.method() или super().

Но в JavaScript такого нет, но мы может смоделировать это.

Следующая функция расширяет наследование и также задает родителя и конструктор без прямой ссылки на него:

function extend(Child, Parent) {
  Child.prototype = inherit(Parent.prototype)
  Child.prototype.constructor = Child
  Child.parent = Parent.prototype
}

Вот так вот можно использовать:

function Rabbit(name) {
  Rabbit.parent.constructor.apply(this, arguments) // super constructor
}

extend(Rabbit, Animal)

Rabbit.prototype.run = function() {
    Rabbit.parent.run.apply(this, arguments) // parent method
    alert("fast")
}

В результате, мы можем переименовать Animal или создать промежуточных класс GrassEatingAnimal и изменения затронут только Animal и extend(...).

Приватные и защищенные методы (инкапсуляция)

Защищённые (protected) методы и свойства поддерживаются с договоренностью об именование. Методы, начинающиеся с подчеркивания '_', не должны вызваться из вне (на деле могут).

Приватные (private) методы не поддерживаются.

Статические (static) методы и свойства

Статические методы и свойства определяются в конструкторе:

function Animal() { 
  Animal.count++
}
Animal.count = 0

new Animal()
new Animal()

alert(Animal.count) // 2

Итого

Вот и наш супер-мега-ООП фреймворк:

function extend(Child, Parent) {
  Child.prototype = inherit(Parent.prototype)
  Child.prototype.constructor = Child
  Child.parent = Parent.prototype
}
function inherit(proto) {
  function F() {}
  F.prototype = proto
  return new F
}

Использование:

// --------- the base object ------------
function Animal(name) {
  this.name = name
}

// methods
Animal.prototype.run = function() {
  alert(this + " is running!")
}

Animal.prototype.toString = function() {
  return this.name
}


// --------- the child object -----------
function Rabbit(name) {
  Rabbit.parent.constructor.apply(this, arguments)
}

// inherit
extend(Rabbit, Animal)

// override
Rabbit.prototype.run = function() {
  Rabbit.parent.run.apply(this)
  alert(this + " bounces high into the sky!")
}

var rabbit = new Rabbit('Jumper')
rabbit.run()

В наш фреймворк можно добавить чуток сахарку, например, функцию, которая копирую свойства из одного объекта в другой:

mixin(Animal.prototype, { run: ..., toString: ...})

Но на самом деле вам не очень-то и нужно использовать этот ООП паттерн. Всего лишь две функции справятся с этим.

Автор: Arkasha

Источник