Шаблон проектирования «Посетитель» относится к поведенческим шаблонам и позволяет классам реализовывать некий дополнительный, не свойственный им и не относящийся к их основной ответственности функционал, вынося его в отдельные классы-посетители.

Описание работы.

Предположим, в нашем проекте есть некие сервисные классы, выполняющие определенные, специфические задачи. Появилась необходимость добавить им новый функционал, что бы они могли реализовать не свойственную им задачу. Самое простое — добавить соответствующие методы в каждый класс, однако это не всегда приемлемо, так как нарушает принципы SRP, OCP и другие.

Вместо этого создается отдельный новый класс — посетитель, в котором есть реализующие требуемый функционал методы.

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

Таким образом, в сервисные классы вносятся минимальные изменения (только принимающий метод), а весь дополнительный функционал реализуется в отдельном классе-посетителе.

Пример реализации

Есть CRM, в которой существуют разные типы записей — account, client, product, supplier и т.д. У каждого типа записи своя структура. Необходимо добавить реализацию экспорта всех записей в файл.

Для этого для каждого типа записи создается отдельный класс-посетитель, реализующий интерфейс Visitor с методом export.
В каждый класс записи добавляется метод accept, который принимает объект посетителя и вызывает его метод export.

В клиентском коде для экспорта у каждого экземпляра записи вызывается метод accept.

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

В данном примере метод accept можно вынести в базовый класс записей, так как его реализация одинакова для всех. Однако в реальных проектах это подходит не всегда и метод accept требуется реализовывать каждом классе.

Интрефейсы

// интерфейс для записей
interface Entity
{
    public function accept(Visitor $visitor): void;
}

// интерфейс для посетителей
interface Visitor
{
    public function export(Entity $entity): void;
}

// интерфейс для записей
interface Entity
{
    public function accept(Visitor $visitor): void;
}

// интерфейс для посетителей
interface Visitor
{
    public function export(Entity $entity): void;
}

Классы записей

class Product implements Entity
{
    protected string $title;
    protected float $price;

    public function accept(Visitor $visitor): void
    {
        $visitor->export($this);
    }
}


class Account implements Entity
{
    protected int $id;
    protected float $amount;

    public function accept(Visitor $visitor): void
    {
        $visitor->export($this);
    }
}

class Product implements Entity
{
    protected string $title;
    protected float $price;

    public function accept(Visitor $visitor): void
    {
        $visitor->export($this);
    }
}


class Account implements Entity
{
    protected int $id;
    protected float $amount;

    public function accept(Visitor $visitor): void
    {
        $visitor->export($this);
    }
}

Классы посетителей

class ProductVisitor implements Visitor
{

    public function export(Entity $entity)
    {
      // логика экспорта
    }
}


class ClientVisitor implements Visitor
{
    public function export(Entity $entity)
    {
      // логика экспорта
    }
}

class ProductVisitor implements Visitor
{

    public function export(Entity $entity)
    {
      // логика экспорта
    }
}


class ClientVisitor implements Visitor
{
    public function export(Entity $entity)
    {
      // логика экспорта
    }
}

Клиентский код

$product = new Product;
$account = new Account;

// делаем экспорт
$account->accept(new AccountVisitor);
$product->accept(new ProductVisitor);

$product = new Product;
$account = new Account;

// делаем экспорт
$account->accept(new AccountVisitor);
$product->accept(new ProductVisitor);

Ссылки:

https://github.com/maximmas/patterns

https://refactoring.guru/ru/design-patterns

Сообщение Шаблон «Посетитель (Visitor)» появились сначала на mcodex.

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

Соединение таблиц связано с понятием декомпозиции базы данных, поэтому сначала кратко разберемся, что это такое.
Декомпозиция — подход, при котором данные хранятся не в одной общей таблице, а в нескольких, более специфичных и связываются между собой по определенному полю, называемому внешним ключом. Декомпозиция облегчает поддержку и масштабируемость базы данных, но при ее использовании, что бы вывести полные данные записи, расположенные в разных таблицах, необходимо задействовать соединение.

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

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

Поэтому используется декомпозиция — каждая сущность (статья, автор, категория, комментарий) хранятся в отдельных таблицах и связываются между собой через внешние ключи.
Внешний ключ — столбец в таблице, в каждой строке которого хранится значение уникального идентификатора (обычно это первичный ключ) из связанной таблицы.
Таким образом, внешний ключ — своего рода указатель на строку другой таблицы, который используется при соединении.

Внешний ключ не является обязательным. Можно просто добавить столбец со значениями идентификаторов из связанной таблицы, не указывая, что это внешний ключ.
Но если такой столбец назначить внешним ключом, то на таблицу накладывается так называемое «ограничение» (constrains) — жесткое правило, гарантирующее, что в связанной таблице точно есть нужные данные. Такое ограничение используется для обеспечения «ссылочной целостности (консистентости)» базы данных — гарантии, что свзязи указывают на существующие данные.

Пример таблиц

Articles

Categories

Возвращаемся к соединению.
Предположим, есть задача получить записи статей, а так же ее автора и категорию.
Это можно сделать через операцию соединения таблиц используя оператор JOIN.

Предположим, есть задача получить записи статей c названиями категорий.
Это можно сделать через операцию соединения таблиц используя оператор JOIN.

Формат

SELECT поля_таблиц
FROM таблица_1
JOIN таблица_2
    ON условие_соединения
JOIN таблица_3
    ON условие_соединения
...    

SELECT поля_таблиц
FROM таблица_1
JOIN таблица_2
    ON условие_соединения
JOIN таблица_3
    ON условие_соединения
...    

Пример простого соединения 2-х таблиц (статьи и категории):

SELECT articles.id, articles.title, categories.name 
FROM articles
JOIN categories
  ON categories.id = articles.category_id;

SELECT articles.id, articles.title, categories.name 
FROM articles
JOIN categories
  ON categories.id = articles.category_id;

В результате будут выведены все заголовки статей и их категории.

Если нужны все столбцы из articles:

SELECT articles.*, categories.name 
FROM articles
JOIN categories
  ON categories.id = articles.category_id;

SELECT articles.*, categories.name 
FROM articles
JOIN categories
  ON categories.id = articles.category_id;

Если нужны все столбцы из обеих таблиц:

SELECT *
FROM articles
JOIN categories
  ON categories.id = articles.category_id;

SELECT *
FROM articles
JOIN categories
  ON categories.id = articles.category_id;

Соединение может быть внутренним (INNER) или внешним (OUTER)
Если тип соединения не указан, то по умолчанию используется внутреннее соединение.
Внешнее соединение может быть левое (LEFT) или правое (RIGHT)
Для внешнего соединения модификатор OUTER можно не указывать, тип (LEFT/RIGHT) — обязательно.

Примеры указания типов:
INNER JOIN — явно указано внутренне соединение
JOIN — тип не указан, то же самое, что INNER JOIN
LEFT OUTER JOIN = LEFT JOIN
RIGHT OUTER JOIN = RIGHT JOIN

Разница между типами соединений.

1. Внутреннее соединение возвращает только те строки, для которых выполняется условие соединения.
   В примере: статьи, у которых есть категории. Если в статье указана несуществующая категория — такая запись не попадет в результат.

Внутреннее соединение можно релизовать через оператор WHERE

SELECT articles.id, articles.title, categories.name 
FROM articles, categories
WHERE articles.category_id = categories.id;

SELECT articles.id, articles.title, categories.name 
FROM articles, categories
WHERE articles.category_id = categories.id;

2. Внешнее соединение возвращает все строки. Если условие не выполняется (в статье ссылка на несущуствующую категорию) в итогой таблице вместо значений будет подставленно NULL.

Варианты внешнего соединения:
LEFT JOIN — берутся все записи из левой таблицы, из правой — только совпавшие по условию соединения
RIGHT JOIN — берутся все записи из правой таблицы, из левой — только совпавшие по условию соединения

Положение таблицы (левая или правая) определяется ее позицией в запросе. Та что стоит первая - левая.

SELECT * 
FROM левая_таблица l
LEFT JOIN правая_таблица r
ON l.user_id = r.id;

SELECT * 
FROM левая_таблица l
LEFT JOIN правая_таблица r
ON l.user_id = r.id;

Пример LEFT JOIN

SELECT a.*, c.name 
FROM articles a
LEFT JOIN categories c
ON a.category_id = c.id;

SELECT a.*, c.name 
FROM articles a
LEFT JOIN categories c
ON a.category_id = c.id;

В результате будут выведены все статьи, если у статьи нет категории — в c.name будет NULL
Если у категории нет статьи — категория не появится в результатах.

Пример RIGHT JOIN

SELECT a.*, c.name 
FROM articles a
RIGHT JOIN categories c
ON a.category_id = c.id;

SELECT a.*, c.name 
FROM articles a
RIGHT JOIN categories c
ON a.category_id = c.id;

В результате будут выведены все категории, если у категории нет статьи — в столбцах a.* будет NULL
Тот же результат можно получить через LEFT JOIN, поменяв таблицы местами, поэтому на практике RIGHT JOIN редко используется.

Еще раз: LEFT JOIN - выводим все строки из первой таблицы, а из второй те, для которых выполняется условие соединения.

Фильтрация результатов с помощью оператора WHERE.

Порядок выполнения таких запросов:
FROM
JOIN
WHERE
SELECT

Пример:
Необходимо вывести названия и ID всех категорий, в которых нет статей.

Решение

SELECT c.id, c.name
FROM categories c
LEFT JOIN articles a
  ON c.id=a.category_id
WHERE a.id IS NULL;

SELECT c.id, c.name
FROM categories c
LEFT JOIN articles a
  ON c.id=a.category_id
WHERE a.id IS NULL;

Как работает:
Шаг 1. FROM .. JOIN ..
Создается соединение, в результате получается промежуточная таблица со всеми строками из таблицы категорий. Столбцы — все из обеих таблиц. Если у категории нет статьи — в ячейках (id, title, text, …) значение NULL
Шаг 2. Применяется фильтр WHERE, остаются только строки с aricles.id = NULL
Шаг 3. Применяется SELECT, остаются только categories.id/name.

Сообщение Соединение таблиц через JOIN в MySQL появились сначала на mcodex.

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

Роль спред-оператора.

Спред-оператор в JavaScript является синтаксической конструкцией, позволяющей передавать элементы итерируемых коллекций (например, массивы, строки или объекты) в другие итерируемые коллекции или функции.
Он указывается в виде трех точек “…”, за которыми следует выражение или коллекция.
Спред-оператор — это мощный инструмент, предоставляющий краткий и гибкий способ работы с
данными в JavaScript. Его можно использовать для соединения массивов, создания
поверхностных копий массивов, преобразования строк в массивы символов, соединения или клонирования объектов, а также для динамической передачи значений в функции или конструкторы, включая множество других способов применения.
Благодаря спред-оператору многие операции становятся проще и выразительнее, поэтому он и получил широкую популярность среди JavaScript-разработчиков.

Синтаксис и использование спред-оператора в JavaScript

Чтобы продемонстрировать синтаксис спред-оператора, давайте рассмотрим несколько примеров его применения при работе с массивами, строками и объектами.

1. Соединение массивов

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

Пример:

const originalArray = [[1, 2, 3, 4], 12];​
const copiedArray = [...originalArray];​
​
copiedArray[0].push(99);​
​
console.log(originalArray); // [[1, 2, 3, 4, 99], 12]​
console.log(copiedArray); // [[1, 2, 3, 4, 99], 12]​

const originalArray = [[1, 2, 3, 4], 12];​
const copiedArray = [...originalArray];​
​
copiedArray[0].push(99);​
​
console.log(originalArray); // [[1, 2, 3, 4, 99], 12]​
console.log(copiedArray); // [[1, 2, 3, 4, 99], 12]​

2. Преобразование строк

Спред-оператор можно использовать для преобразования строки в массив её символов. Это делает работу со строками удобнее: получив массив символов, вы можете применять к нему методы массивов или объединять его с другими массивами.

Пример:

const str = "Hello";​
​
const charArray = [...str];​
console.log(charArray); // ['H', 'e', 'l', 'l', 'o']​

const str = "Hello";​
​
const charArray = [...str];​
console.log(charArray); // ['H', 'e', 'l', 'l', 'o']​

3. Соединение и клонирование объектов

Спред-оператор можно использовать для передачи свойств из одного объекта в другой. Это помогает при соединении или клонировании объектов. Создается новый объект, в котором
некоторые свойства могут быть переопределены. Также можно извлекать из объекта нужные свойства.

Пример:​

const obj1 = { a: 1, b: 2 };​
const obj2 = { b: 3, c: 4 };​
​
// Соединение объектов​
const mergedObj = { ...obj1, ...obj2 };​
console.log(mergedObj); // Output: { a: 1, b: 3, c: 4 }​
​
// Клонирование​
const clonedObj = { ...obj1 };​
console.log(clonedObj); // Output: { a: 1, b: 2 }​

const obj1 = { a: 1, b: 2 };​
const obj2 = { b: 3, c: 4 };​
​
// Соединение объектов​
const mergedObj = { ...obj1, ...obj2 };​
console.log(mergedObj); // Output: { a: 1, b: 3, c: 4 }​
​
// Клонирование​
const clonedObj = { ...obj1 };​
console.log(clonedObj); // Output: { a: 1, b: 2 }​

4. Передача аргументов в функции.

Спред-оператор можно использовать в других ситуациях, например, в аргументах функции, для динамической передачи значений.

Пример:​

const numbers = [1, 2, 3];​
const sum = (a, b, c) => a + b + c;​

console.log(sum(...numbers)); // 6​

const numbers = [1, 2, 3];​
const sum = (a, b, c) => a + b + c;​

console.log(sum(...numbers)); // 6​

5. Объединение спред-оператора с остаточным параметром

Мощь функционального программирования особенно заметна, когда спред-оператор используется вместе с другими современными возможностями JavaScript — например, с деструктуризацией массивов и объектов. Такой подход позволяет легко извлекать и обрабатывать элементы массивов или свойства объектов, используя краткий и выразительный синтаксис.

Пример:​

const numbers = [1, 2, 3, 4, 5];​
const [first, second, ...rest] = numbers;​
​
console.log(first); // 1​
console.log(second); // 2​
console.log(rest); // [3, 4, 5]​

const numbers = [1, 2, 3, 4, 5];​
const [first, second, ...rest] = numbers;​
​
console.log(first); // 1​
console.log(second); // 2​
console.log(rest); // [3, 4, 5]​

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

Еще немного о спред-операторе и поверхностном копировании​.

Необходимо отметить, что с помощью спред-оператора можно создавать поверхностные копии массивов и объектов, а также увеличить производительность при создании больших массивов и
объектов.​

Пример

const originalArray = [[1, 2, 3, 4], 12];​
const copiedArray = [...originalArray];​

copiedArray[0].push(99);

​console.log(originalArray); // [[1, 2, 3, 4, 99], 12]​
console.log(copiedArray); // [[1, 2, 3, 4, 99], 12]

const originalArray = [[1, 2, 3, 4], 12];​
const copiedArray = [...originalArray];​

copiedArray[0].push(99);

​console.log(originalArray); // [[1, 2, 3, 4, 99], 12]​
console.log(copiedArray); // [[1, 2, 3, 4, 99], 12]

В этом коде originalArray состоит из двух элементов. С помощью спред-оператора мы создаем новый массив copiedArray и переносим в него элементы исходного массива. Затем мы изменяем первый элемент copiedArray, добавив число 99 с помощью метода push().

После вывода copiedArray мы видим, что к первому элементу массива было добавлено 99, но есть проблема с поверхностным копированием, которое делает спред-оператор. Изменения в copiedArray оказывают влияние на originalArray.

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

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

Необходимо разумно пользоваться спред-оператором и принимать во внимание наилучшие практики для достижения оптимальной производительности кода и удобства его поддержки.

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

Для оптимизации производительности и избежания распространенных ошибок при работе со спред-оператором используйте следующие рекомендации:

1.​ Не используйте спред-оператор для передачи элементов больших массивов или объектов в критичных для производительности участках кода.

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

3. Пользуйтесь спред-оператором разумно и, если производительность имеет значение, рассмотрите альтернативные подходы.

Резюме

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

Благодаря своей гибкости спред-оператор играет важную роль в развитии JavaScript, предоставляя разработчикам возможность писать более лаконичный, читабельный и эффективный код.

Оригинал статьи:

https://kinsta.com/knowledgebase/spread-operator-javascript

Сообщение Спред-оператор в JavaScript появились сначала на mcodex.