Шаблоны проектирования JavaScript - шаблоны цепочки ответственности, синглтоны и легковесы

Паттерны проектирования - основа любого хорошего программного обеспечения. Программы на JavaScript не исключение.

В этой статье мы рассмотрим цепочку ответственности, шаблоны синглтон и наилегчайший вес.

Схема цепочки ответственности

Цепочка ответственности аналогична шаблону наблюдателя, за исключением того, что он отправляет уведомление одному объекту, а затем этот объект отправляет уведомление другому объекту и так далее.

В шаблоне наблюдателя уведомление отправляется всем наблюдателям одновременно.

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

Мы можем реализовать это следующим образом:

const backend = {
  receive(data) {
    // do something with data
  }
}
const middleLayer = {
  notify(data) {
    backend.receive(data);
  }
}
const frontEnd = {
  notify(data) {
    middleLayer.notify(data);
  }
}

В приведенном выше коде у нас есть frontEnd, который вызывает метод notify объекта middleLayer, который, в свою очередь, вызывает метод backend ‘s receive.

Таким образом, мы можем беспрепятственно передавать данные между ними одним методом.

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

Синглтон

В шаблоне singleton мы создаем только один экземпляр объекта.

В JavaScript мы можем создавать объекты с одним экземпляром, создав литерал объекта.

Мы можем создать его, написав:

const obj = {
  foo: 1,
  bar: 'baz'
}

Литерал объекта - это просто набор пар ключ-значение, где значением также могут быть другие объекты.

Если мы используем классы, мы также можем написать:

class Foo {
  constructor() {
    if (!Foo.instance) {
      Foo.instance = {
        foo: 1,
        bar: 2
      }
    }
    return Foo.instance;
  }
}

Мы присвоили созданный экземпляр свойству instance Foo.

Затем, когда мы создаем конструктор, мы проверяем свойство instance, чтобы увидеть, создано ли что-нибудь для него.

Если ему ничего не назначено, мы назначаем ему объект.

Затем мы возвращаем Foo.instance, чтобы получить экземпляр.

Теперь, если мы создадим 2 экземпляра Foo:

const foo = new Foo();
const bar = new Foo();

Затем мы можем увидеть, являются ли они одним и тем же экземпляром, написав:

console.log(foo === bar);

Мы должны получить true, поскольку они оба ссылаются на один и тот же экземпляр.

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

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

Выкройка наилегчайшего веса

В паттерне-легковесе мы ограничиваем создание объектов,

Мы создаем набор небольших объектов, каждый из которых потребляет меньшее количество ресурсов.

Эти объекты находятся за объектом-грузиком, который используется для взаимодействия с этими объектами,

Эти объекты также взаимодействуют с нашим кодом.

Таким образом, мы получаем преимущества большого объекта, в то время как мы взаимодействуем с более мелкими объектами, которые более управляемы.

Например, мы можем реализовать это следующим образом:

class Student {
 //..
}
const studentIdentity = {
 getIdentity(){
   const student = new Student();
    //..
    return {
    //...
    }
  }
}
const studentScore = {
 getScore(){
   const student = new Student();
    //..
    return {
    //...
    }
  }
}

У нас есть Student класс, представляющий данные учащегося.

Затем в объектах studentIdentity и studentScore у нас есть методы для получения его или ее личности или оценки соответственно.

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

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

Заключение

Мы можем использовать шаблон singleton для создания одноразовых объектов.

Мы можем создавать экземпляры класса только с одним экземпляром или с объектными литералами.

В паттерне «Легковес» мы создаем более мелкие объекты для работы с большими объектами, тем самым снижая сложность.

Шаблон цепочки ответственности позволяет нам последовательно отправлять данные от одного объекта к другому.