Состав наследственного имущества: ГК РФ Статья 1112. Наследство / КонсультантПлюс

: это довольно серьезно
 

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

Решение №4: За пределами банды четырех шаблонов

Python требовалась еще большая гибкость: не только для поддержки нескольких фильтров, но для поддержки нескольких выходов для одного потока сообщений журнала.На основе дизайна модулей логирования на других языках - см. PEP 282 Раздел «Влияния» для основных источников вдохновения - модуль ведения журнала Python реализует свой собственный шаблон «Композиция поверх наследования».

1. Класс Logger , с которым взаимодействуют вызывающие абоненты сам по себе не реализует ни фильтрацию, ни вывод. Вместо этого он поддерживает список фильтров и список обработчиков.
2. Для каждого сообщения журнала регистратор вызывает каждый из своих фильтров. Сообщение отбрасывается, если какой-либо фильтр отклоняет его.
3. Для каждого сообщения журнала, принятого всеми фильтрами, регистратор перебирает свои обработчики вывода и просит каждого из них на emit () сообщение.

Или, по крайней мере, в этом суть идеи. Ведение журнала в стандартной библиотеке на самом деле более сложное. Например, каждый обработчик может иметь собственный список фильтров в дополнение к перечисленным его регистратором. И каждый обработчик также указывает минимальный «уровень» сообщения. например, INFO или WARN , что, довольно сбивает с толку, не применяется ни самим обработчиком ни одним из фильтров обработчика, но вместо этого с помощью оператора if похоронен глубоко внутри регистратора, где он петляет над обработчиками.Таким образом, общий дизайн выглядит немного беспорядочно.

Но мы можем использовать основные идеи регистратора стандартной библиотеки - что сообщения регистратора может заслужить как несколько фильтров , так и несколько выходов - для полного разделения классов фильтров и классов обработчиков:

 # Регистратор теперь только один.

класс Logger:
    def __init __ (себя, фильтры, обработчики):
        self.filters = фильтры
        self.handlers = обработчики

    def log (self, message):
        если все (f.match (сообщение) для f в self.фильтры):
            для h в self.handlers:
                h.emit (сообщение)

# Фильтры теперь знают только о строках!

класс TextFilter:
    def __init __ (сам, шаблон):
        self.pattern = шаблон

    def match (self, text):
        вернуть self.pattern в тексте

# Обработчики выглядят так же, как «регистраторы» в предыдущем решении.

класс FileHandler:
    def __init __ (сам, файл):
        self.file = файл

    def emit (self, message):
        self.file.write (сообщение + '\ n')
        self.file.flush ()

класс SocketHandler:
    def __init __ (self, sock):
        себя.sock = носок

    def emit (self, message):
        self.sock.sendall ((сообщение + '\ n'). encode ('ascii'))

класс SyslogHandler:
    def __init __ (себя, приоритет):
        self.priority = приоритет

    def emit (self, message):
        syslog.syslog (собственный приоритет, сообщение)
 

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

Фактически, слово «журнал» полностью исчезло из названия класса фильтра, и по очень важной причине: в нем больше нет ничего особенного для ведения журнала! TextFilter теперь полностью многоразовый в любом контексте, который связан со строками. Наконец, отделившись от конкретной концепции ведения журнала, будет легче тестировать и поддерживать.

Опять же, как и все решения проблемы "композиция вместо наследования", классы составляются во время выполнения без необходимости наследования:

 f = TextFilter ('Ошибка')
h = FileHandler (sys.стандартный вывод)
logger = Регистратор ([f], [h])

logger.log ('Игнорируется: это не будет регистрироваться')
logger.log ('Ошибка: это важно')
 

Здесь есть важный урок: принципы проектирования, такие как композиция вместо наследования, в конце, важнее отдельных паттернов, таких как Адаптер или Декоратор. Всегда следуйте принципу. Но не всегда стесняйтесь выбрать узор из официального списка. Дизайн, к которому мы пришли более гибкий и простой в обслуживании чем любой из предыдущих дизайнов, хотя они были основаны на официальных паттернах Банды четырех но этот окончательный дизайн - нет.Иногда да, вы найдете существующий шаблон дизайна это идеально подходит для вашей проблемы - но если нет, ваш дизайн может быть сильнее, если вы выйдете за их рамки.

Dodge: утверждения «если»

Я подозреваю, что приведенный выше код поразил многих читателей. Типичному программисту на Python: такое интенсивное использование классов может показаться полностью надуманным - неловкое упражнение в попытке воплотить старые идеи 80-х кажутся актуальными для современного Python.

Когда появляется новое требование к конструкции, делает ли типичный программист Python действительно идти писать новый класс? Нет! «Лучше простое, чем сложное.” Зачем добавлять класс, когда вместо этого будет работать оператор if ? Один класс регистратора может постепенно наращивать условные выражения пока он не обработает все те же дела как в наших предыдущих примерах:

 # Каждая новая функция в виде оператора «если».

класс Logger:
    def __init __ (self, pattern = None, file = None, sock = None, priority = None):
        self.pattern = шаблон
        self.file = файл
        self.sock = носок
        self.priority = приоритет

    def log (self, message):
        если self.pattern не равен None:
            если сам.шаблон отсутствует в сообщении:
                возвращение
        если self.file не равен None:
            self.file.write (сообщение + '\ n')
            self.file.flush ()
        если self.sock не равен None:
            self.sock.sendall ((сообщение + '\ n'). encode ('ascii'))
        если self.priority не равен None:
            syslog.syslog (собственный приоритет, сообщение)

# Работает нормально.

logger = Регистратор (шаблон = 'Ошибка', файл = sys.stdout)

logger.log ('Предупреждение: не так важно')
logger.log ('Ошибка: это важно')
 

Вы можете узнать этот пример как более типичный для практики проектирования Python вы сталкивались с реальными приложениями.

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

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

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

1. Населенный пункт. Реорганизация кода для использования операторов if не был явным преимуществом для удобочитаемости. Если вам поручено улучшить или отладить одну конкретную функцию - скажем, поддержка записи в сокет - вы обнаружите, что не можете прочитать его код в одном месте. Код, стоящий за этой единственной функцией разбросаны по списку параметров инициализатора, код инициализатора, и сам метод log () .
2. Возможность удаления. Недооцененное свойство хорошего дизайна в том, что это упрощает удаление функций.Возможно, только ветераны крупных и зрелых приложений Python достаточно сильно оценит важность удаления кода для здоровья проекта. В случае наших решений на основе классов, мы можем тривиально удалить такую ​​функцию, как вход в сокет удалив класс SocketHandler и его модульные тесты как только приложение больше не нуждается в этом. Напротив, удаление функции сокета из леса , если операторы не только требует осторожности чтобы избежать нарушения смежного кода, но возникает неудобный вопрос, что делать с параметром socket в инициализаторе.Его можно удалить? Нет, если нам нужно поддерживать согласованность списка позиционных параметров - нам нужно будет сохранить параметр, но вызовите исключение, если оно когда-либо использовалось.
3. Анализ мертвого кода. Относится к предыдущему пункту заключается в том, что когда мы используем композицию вместо наследования, анализаторы мертвого кода может тривиально обнаружить когда исчезает последнее использование SocketHandler в базе кода. Но анализ мертвого кода часто беспомощен, чтобы сделать такое определение, как «Теперь вы можете удалить все атрибуты и утверждения if, если связанные с выходом сокета, потому что не сохранился вызов инициализатора передает что-либо для socket , кроме Нет .”
4. Тестирование. Один из самых сильных сигналов о работоспособности кода, который дают наши тесты. сколько строк нерелевантного кода нужно запустить не дойдя до тестируемой линии. Протестировать такую ​​функцию, как вход в сокет, легко если тест может просто запустить экземпляр SocketHandler , передайте ему активную розетку, и попросите его на emit () сообщение. Никакой код не запускается, кроме кода, относящегося к функции. Но тестируем логирование сокета в нашем лесу , если утверждения будет выполняться как минимум в три раза больше строк кода.Необходимость настройки регистратора с правильным сочетанием нескольких функций просто проверить один из них это важный предупреждающий знак, это может показаться тривиальным в этом небольшом примере но приобретает решающее значение по мере роста системы.
5. Эффективность. Я намеренно ставлю этот вопрос в последнюю очередь, потому что удобочитаемость и ремонтопригодность обычно более важные проблемы. А вот в дизайне проблемы с лесом , если заявление также свидетельствует о неэффективности подхода.Даже если вам нужен простой нефильтрованный журнал в один файл, каждое отдельное сообщение будет принудительно запускать инструкцию if против всех возможных функций, которые вы могли бы включить. Техника композиции, напротив, запускает код только для функций, которые вы составили вместе.

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

Dodge: множественное наследование

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

Вернемся к примеру кода, с которого мы начали, где FilteredLogger и SocketLogger были двумя разными подклассами базового класса Logger . На языке, поддерживающем только одиночное наследование, FilteredSocketLogger пришлось бы выбрать наследовать от SocketLogger или FilteredLogger , а затем придется дублировать код из другого класса.

Но Python поддерживает множественное наследование, поэтому новый FilteredSocketLogger может указывать как SocketLogger , так и FilteredLogger как базовые классы и наследовать от обоих:

 # Базовый класс и подклассы нашего исходного примера.

класс Logger (объект):
    def __init __ (сам, файл):
        self.file = файл

    def log (self, message):
        self.file.write (сообщение + '\ n')
        self.file.flush ()

класс SocketLogger (Регистратор):
    def __init __ (self, sock):
        себя.sock = носок

    def log (self, message):
        self.sock.sendall ((сообщение + '\ n'). encode ('ascii'))

класс FilteredLogger (Регистратор):
    def __init __ (сам, шаблон, файл):
        self.pattern = шаблон
        super () .__ init __ (файл)

    def log (self, message):
        если self.pattern в сообщении:
            super (). log (сообщение)

# Класс, полученный посредством множественного наследования.

класс FilteredSocketLogger (FilteredLogger, SocketLogger):
    def __init __ (self, pattern, sock):
        FilteredLogger.__init __ (сам, шаблон, нет)
        SocketLogger .__ init __ (сам, носок)

# Работает нормально.

logger = FilteredSocketLogger ('Ошибка', sock1)
logger.log ('Предупреждение: не так важно')
logger.log ('Ошибка: это важно')

print ('Получен сокет:% r'% sock2.recv (512))
 

 Сокет получил: b'Error: это важно \ n '
 

Имеет несколько поразительных сходств к нашему решению Decorator Pattern. В обоих случаях:

• Есть класс регистратора для каждого вида вывода (вместо асимметрии нашего адаптера между записью файлов напрямую а не файлы через переходник).
• Сообщение сохраняет точное значение, предоставленное вызывающим абонентом (вместо привычки нашего Адаптера замены его значением, специфичным для файла добавив новую строку).
• Фильтр и логгеры симметричны в том, что они оба реализуют один и тот же метод log () . (Другие наши решения помимо Decorator были классы фильтров, предлагающие один метод а выходные классы предлагают другой).
• Фильтр никогда не пытается произвести вывод самостоятельно, но, если сообщение проходит фильтрацию, переносит задачу вывода на другой код.

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

Если у нас есть тщательные модульные тесты как для регистратора, так и для фильтра, насколько мы уверены, что они будут работать вместе?

1. Успех примера Decorator зависит только от публичного поведения каждого класса: что LogFilter предлагает метод log () который, в свою очередь, вызывает log () для объекта, который он обертывает (что тест может тривиально проверить с помощью крошечного фальшивого регистратора), и что каждый регистратор предлагает рабочий метод log () .Пока наши модульные тесты проверяют эти два публичных поведения, мы не можем нарушить композицию не провалив наших модульных тестов.

   Множественное наследование, напротив, зависит от поведения, которое невозможно проверить просто создавая экземпляры рассматриваемых классов. Публичное поведение FilteredLogger в том, что он предлагает метод log () который и фильтрует, и записывает в файл. Но множественное наследование зависит не только от этого публичного поведения, но о том, как это поведение реализовано внутри.Множественное наследование будет работать если метод подчиняется своему базовому классу с помощью super () , но нет, если метод выполняет свой собственный write () в файл, даже если любая реализация удовлетворяет модульному тесту.

   Таким образом, набор тестов должен выходить за рамки модульного тестирования. и выполнить фактическое множественное наследование класса - или патч обезьяны, чтобы убедиться, что log () вызывает super (). log () - чтобы гарантировать, что множественное наследование продолжает работать как будущие разработчики работают над кодом.

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

   У вас может возникнуть соблазн придумать схему чтобы избежать нового __init __ () для каждого подкласса, например, принять * args и затем передать их super ().__init __ () . (Если вы будете придерживаться этого подхода, просмотрите классическое эссе «Питон считается вредным в высшей степени опасным». который утверждает, что только ** кВт на самом деле безопасен.) Проблема с такой схемой в том, что она ухудшает читаемость - вы больше не можете понять, какие аргументы принимает метод __init __ () просто прочитав его список параметров. И инструменты проверки типов больше не сможет гарантировать правильность.

   Но даете ли вы каждому производному классу свой собственный __init __ () или объедините их в цепочку, ваши модульные тесты оригинального FilteredLogger и SocketLogger не могут сами по себе гарантировать что классы правильно инициализируются при объединении.

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

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

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

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

По любой из этих причин модульные тесты двух базовых классов могут оставаться зелеными даже если их способность объединяться посредством множественного наследования сломано.Это означает, что "Банда четырех" «Взрыв подклассов для поддержки каждой комбинации» также огорчит ваши тесты. Только путем тестирования каждая комбинация м × n базовых классов в вашем приложении Можете ли вы сделать безопасным для приложения использование таких классов во время выполнения.

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

4. Самоанализ просто в случае с Decorator. Просто print (my_filter.logger) или просмотреть этот атрибут в отладчике чтобы увидеть, какой тип выходного регистратора прикреплен. Однако в случае множественного наследования вы можете только узнать, какой фильтр и регистратор были объединены изучив метаданные самого класса - либо прочитав его __mro__ или подвергая объект серии тестов isinstance () .
5. В случае с Decorator все тривиально взять живую комбинацию фильтра и логгера и во время выполнения заменить другой регистратор через присвоение .атрибут регистратора - скажем, потому что пользователь только что переключил предпочтение в интерфейсе приложения. Но сделать то же самое в случае множественного наследования потребует более нежелательного маневра перезаписи класса объекта. При изменении класса объекта во время выполнения не невозможно в динамическом языке, таком как Python, это обычно считается симптомом эта разработка программного обеспечения пошла не так.
6. Наконец, множественное наследование не имеет встроенного механизма чтобы помочь программисту правильно упорядочить базовые классы. FilteredSocketLogger не будет успешно записывать в сокет, если его базовые классы поменяны местами и, как свидетельствуют десятки вопросов о переполнении стека, Программистам на Python вечно трудно с размещением сторонних базовых классов в правильном порядке. Паттерн Decorator, напротив, делает очевидным, каким образом составляются классы: фильтр __init __ () хочет объект регистратора , но регистратор __init __ () не запрашивает фильтр .

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

Dodge: Миксины

The FilteredSocketLogger из предыдущего раздела нужен собственный метод __init __ () потому что ему нужно было принимать аргументы для обоих своих базовых классов. Но оказывается, что эта ответственность можно избежать.Конечно, в случаях, когда подкласс не требует дополнительных данных, проблемы не возникает. Но даже классы, требующие дополнительных данных может доставить его другими способами.

Мы можем сделать FilteredLogger более дружелюбен к множественному наследованию если мы предоставим значение по умолчанию для шаблона в самом классе а затем предложите вызывающим абонентам настроить атрибут напрямую, внеполосная инициализация:

 # Не принимайте «шаблон» во время инициализации.класс FilteredLogger (Регистратор):
    шаблон = ''

    def log (self, message):
        если self.pattern в сообщении:
            super (). log (сообщение)

# Множественное наследование стало проще.

класс FilteredSocketLogger (FilteredLogger, SocketLogger):
    pass # Этот подкласс не требует дополнительного кода!

# Вызывающий может просто установить «шаблон» напрямую.

logger = FilteredSocketLogger (sock1)
logger.pattern = 'Ошибка'

# Работает нормально.

logger.log ('Предупреждение: не так важно')
logger.log ('Ошибка: это важно')

print ('Получен сокет:% r'% sock2.recv (512))
 

 Сокет получил: b'Error: это важно \ n '
 

Повернув FilteredLogger к маневру инициализации который ортогонален базовому классу, почему бы не довести идею ортогональности до логического завершения? Мы можем преобразовать FilteredLogger в «миксин» который живет полностью вне иерархии классов с которым его объединит множественное наследование.

 # Упростите фильтр, сделав его миксином.

class FilterMixin: # Нет базового класса!
    шаблон = ''

    def log (self, message):
        если сам.шаблон в сообщении:
            super (). log (сообщение)

# Множественное наследование выглядит так же, как указано выше.

класс FilteredLogger (FilterMixin, FileLogger):
    pass # Опять же, подкласс не требует дополнительного кода.

# Работает нормально.

logger = FilteredLogger (sys.stdout)
logger.pattern = 'Ошибка'
logger.log ('Предупреждение: не так важно')
logger.log ('Ошибка: это важно')
 

Миксин концептуально проще чем отфильтрованный подкласс, который мы видели в последнем разделе: у него нет базового класса, который мог бы усложнить порядок разрешения методов, поэтому super () всегда будет звонить следующий базовый класс, указанный в заявлении class .

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

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

Dodge: Динамическое построение классов

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

Множественное наследование в общем случае по-прежнему требует «Увеличение количества классов» с м × n заявлений о классе что каждый выглядит:

 класс FilteredSocketLogger (FilteredLogger, SocketLogger):
    ...
 

Но оказывается, что Python предлагает обходной путь.

Представьте, что наше приложение читает файл конфигурации чтобы узнать фильтр журнала и место назначения журнала, которое он должен использовать, файл, содержимое которого неизвестно до времени выполнения. Вместо того, чтобы строить все м × n возможных классов заблаговременно а затем выбрав нужный, мы можем подождать и воспользоваться этим фактом что Python не только поддерживает оператор class но встроенная функция типа () который динамически создает новые классы во время выполнения:

 # Представьте себе 2 отфильтрованных регистратора и 3 регистратора вывода.filter = {
    'шаблон': PatternFilteredLog,
    'severity': SeverityFilteredLog,
}
output = {
    'файл': FileLog,
    'сокет': SocketLog,
    'syslog': SyslogLog,
}

# Выберите два класса, которые мы хотим объединить.

с open ('config') как f:
    имя_фильтра, имя_вывода = f.read (). split ()

filter_cls = фильтры [имя_фильтра]
output_cls = выходы [output_name]

# Создаем новый производный класс (!)

name = имя_фильтра.title () + output_name.title () + 'Журнал'
cls = тип (имя, (filter_cls, output_cls), {})

# Вызовите его как обычно, чтобы создать экземпляр.logger = cls (...)
 

Кортеж классов передан в type () имеет то же значение как ряд базовых классов в заявлении class . Вызов type () выше создает новый класс через множественное наследование как от отфильтрованного регистратора, так и от регистратора вывода.

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

Но создание классов «на лету» связано с серьезными проблемами.

• Страдает читаемость. Человек, читающий приведенный выше фрагмент кода придется делать дополнительную работу чтобы определить, какой объект является экземпляром cls . Кроме того, многие программисты Python не знакомы с типом () и нужно будет остановиться и ломать голову над его документацией. Если у них возникнут трудности с новой концепцией что классы могут быть определены динамически, они все еще могут быть сбиты с толку.
• Если сконструированный класс, например PatternFilteredFileLog указан в сообщении об исключении или ошибке, разработчик, вероятно, будет недоволен, обнаружив что ничего не возникает, когда они ищут код для этого имени класса.Отладка становится сложнее когда вы даже не можете найти класс. Может быть потрачено много времени поиск кодовой базы для type () звонков и пытаемся определить, какой из них сгенерировал класс. Иногда разработчикам приходится прибегать для вызова каждого метода с плохими аргументами и используя номера строк в результирующих трассировках отследить базовые классы.
• Самоанализ типа, в общем случае, сбой для классов, динамически создаваемых во время выполнения. Ярлыки «Перейти к классу» в редакторе некуда будет тебя отвезти когда вы выделяете экземпляр PatternFilteredFileLog в отладчике.И движки проверки типов, такие как mypy и пир-чек вряд ли предложит сильную защиту для вашего сгенерированного класса что они могут предоставить для обычных классов Python.
• Прекрасный блокнот Jupyter с функцией автозагрузки % обладает почти сверхъестественными способностями для обнаружения и перезагрузки измененного исходного кода в живом интерпретаторе Python. Но этому мешает, например, множественное наследование классов. что matplotlib строит во время выполнения через type () вызывает внутри своего subplot_class_factory () .

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

Наследование или композиция: что лучше для вашего проекта JavaScript? | автор: Фернандо Доглио

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

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

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

Приведенный выше код TypeScript показывает основы наследования.Оба класса Dog и Cat расширяют или наследуют от FourLeggedAnimal , что означает, что они принимают все свои свойства и методы, нам не нужно переопределять их, если, как в моем примере, мы не хотим перезаписать что они делают. Наследование позволяет нам абстрагировать общее поведение, состояние (другими словами, методы и свойства) в одном месте, откуда мы можем извлечь (родительский класс).

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

Еще одно большое преимущество наследования, в основном для строго типизированных языков, таких как JAVA, TypeScript и другие, заключается в том, что переменные, объявленные с типом вашего родительского класса, могут также содержать объекты из его дочерних классов. Другими словами:

Следуя тем же определениям классов, что и раньше, в этом примере объявляется список элементов типа FourLeggedAnimals , в то время как на самом деле он содержит Cat и Dog . Это возможно, потому что оба объекта имеют один и тот же родительский класс.то же самое касается того факта, что мы можем безопасно вызвать метод speak в строке 6. Благодаря тому факту, что этот метод уже определен в родительском классе, мы знаем, что он будет у всех наших объектов (мы можем Не знаю, какая именно реализация будет использоваться, если мы не видели код, но мы можем быть уверены, что эта строка не выдаст ошибку из-за ошибки отсутствующего метода).

А что насчет композиции?

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

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

Если мы вернемся к нашему примеру с животными, мы можем переосмыслить нашу внутреннюю архитектуру и получить что-то вроде этого:

По сути, теперь у нас есть три разных компонента, в двух из которых мы инкапсулировали поведение ( Barker и компоненты Meower ) и заявляют, что в AnimalProperties мы инкапсулировали наше состояние.У нас больше нет общего класса для Dog и Cat , от которого мы могли бы наследовать.

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

Теперь мы можем перейти на следующий уровень и, добавив простой интерфейс, мы можем еще больше упростить наш код.

Проверьте это, мы снова имеем только один класс животных, который содержит нашу основную логику.И чтобы уточнить, интерфейс позволяет нам только обобщать форму нашего объекта, он ничего не реализует (интерфейсы на самом деле не реализуют код, а только определяют свой API). С его помощью мы можем создать общий «тип», если хотите, который описывает форму нашего объекта, что, в свою очередь, позволяет нам определить переменную для переноса любого из них внутрь (см. Свойство субъект внутри класса Animal ).

Как же тогда создать Dog или Cat ? Позвольте мне показать вам:

Перво-наперво: обратите внимание, что конечный результат такой же.Мы можем создать общий список животных, перебрать его и вызвать тот же метод со 100% уверенностью, что он будет у всех объектов. Опять же, мы не знаем, как это будет реализовано, потому что именно здесь компоненты (в данном случае) вступают в игру.

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

И если вы еще не заметили, хотя тот же эффект может быть достигнут либо наследованием, либо композицией, первый происходит во время компиляции (или интерпретации), а второй - во время выполнения.Насколько это важно? На самом деле очень важно, , видите ли, при правильном наборе методов вы можете превратить Cat в Dog или даже в совершенно новое животное во время выполнения, чего вы не могли бы сделать с наследованием.

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

Теперь, когда мы понимаем, что это такое и как их можно использовать, правда в том, что они оба великолепны!

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

Случай наследования

Наследование имеет смысл, потому что мы склонны связывать концепции ООП с объектами реального мира, а затем пытаемся обобщить их поведение, обобщая их природу.

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

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

Чемодан для композиции

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

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

Еще одно большое преимущество, которое я вижу, заключается в том, что при наследовании, если вам нужно создать новый конкретный класс (например, добавить сейчас класс Lion ), вам нужно будет понять код класса FourLeggedAnimal , чтобы сделать уверен, что теперь ты получаешь от этого. И это было бы просто для того, чтобы вы могли реализовать другую версию метода speak . Однако, если вы выбрали композицию, все, что вам нужно было сделать, это создать новый класс, реализующий новую логику для метода speak , не зная ни о чем другом, и все.

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

путь к алгебраическим типам данных

Сколько раз вы работали с иерархией наследования, которую было практически невозможно изменить? Что заставило вас почувствовать, что вы не тот, кто все контролирует, а просто вставляете кусочки и кусочки в этого большого колосса? Если вы какое-то время зарабатываете на жизнь программированием, скорее всего, вы сталкивались с этим не раз.Так как же этого избежать?

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

В чем проблема?

Смоделируем изделие. Товар имеет название и может быть оценен двумя способами. Либо в какой-то валюте (в нашем случае евро) , либо относительно другого продукта (например, большая кола всегда стоит на 50% дороже, чем меньшая кола) . Первая попытка смоделировать это с помощью наследования, вероятно, будет выглядеть так:

Пока все хорошо с наследованием, но теперь появляется новое требование.Товар может быть доставлен в пределах определенного города или получен по конкретному адресу. Продолжая исходное решение, мы получим 4 финальных класса:

• Возможна поставкаФиксированная цена товара
• Отправляемая Относительная цена Товар
• Самовывоз с фиксированной ценой
• Самовывоз Относительная цена Товар

Вы видите, что он не идеален. Особенно, если будет другое требование аналогичным образом, в результате чего всего будет 8 классов, затем еще 16 и так далее.Или что, если мы хотим добавить еще один способ доставки (расширить текущее требование) ?

IS против HAS

Чтобы решить эту проблему, нам нужно переосмыслить то, как мы моделируем наши данные. На данный момент наша модель утверждает, что, например, Cola - это продукт с фиксированной ценой, который можно отгрузить . Вместо этого мы можем заявить, что у Cola есть фиксированная цена, а у - доставка. Давайте сделаем это.

Довольно просто. Без наследования, мы составили продукт из 2-х вещей.Как выглядит Price или Delivery ?

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

Но мы использовали наследование для композиции ?!

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

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

Но поскольку нам нужно вызвать http-клиент в этой функции, чтобы получить обменный курс, это решение очень плохое.Мы не хотим жестко кодировать HTTP-вызов клиента в объекте. Кроме того, могут быть сотни функций, которые ведут себя по-разному для каждого типа цены, и мы не хотим загрязнять классы всеми этими методами. Более того, мы могли бы работать с этим классом из другой сборки, а это значит, что мы не можем расширить класс таким образом. Лучше посчитаем цену в каком-нибудь сервисе.

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

Алгебраические типы данных

Если вы присмотритесь, мы смоделировали все с помощью простых отношений «И» и «ИЛИ». Например Товар состоит из Цена И Доставка . Цена состоит из FixedPrice ИЛИ RelativePrice . RelativePrice состоит из BaseProduct И Adjustment . Вы видите образец? Добро пожаловать в мир алгебраических типов данных.

Два из них соответствуют отношениям «И» и «ИЛИ».Они служат типами для составления любого другого типа. Первый называется , продукт , в основном известный как кортеж. Он соединяет вместе любые другие типы. Так, например, RelativePrice - это продукт из Продукт и Процент . Или Продукт является продуктом из Цена и Доставка .

Тот, который представляет «ИЛИ», называется копродуктом , также известным как тип суммы или размеченное объединение.Это менее известный среди программистов, но настоящий источник энергии. Он берет несколько других типов и создает один тип, который может быть только одним из них. Цена из примера: RelativePrice или FixedPrice . Не может быть и того, и другого, но должен быть хотя бы один. C # изначально не поддерживает типы сумм (пока) , но, например, в F # они есть с первого дня. Чтобы использовать их в C #, вы можете смоделировать их с наследованием, как мы это делали в примере, и будьте осторожны, чтобы поддерживать иерархию в хорошем состоянии или использовать какую-либо библиотеку.Используя нашу библиотеку FuncSharp, Price будет выглядеть как (более подробный пример см. В документации и коде) .

Настоящая сила алгебраических типов данных в том, что они заставляют композицию, заставляя нас вести себя.

Исчерпание

Теперь давайте изменим наш PricingService , чтобы использовать нашу новую Price .

У каждого сопродукта есть функция Match , которая принимает функцию для каждого случая. Он имитирует концепцию, называемую сопоставлением с образцом.Важно то, что количество функций равно количеству типов. Это означает, что если мы теперь добавим новый тип Price и расширим его с Coproduct2 до Coproduct3, этот код не будет компилироваться. Компилятор заставит нас проверять все места и заставит их работать также с недавно добавленным типом Price .

Уловы?

Во всем остальном в программировании есть свои минусы.

Что делать, если вы хотите написать функцию, которая принимает Продукт с относительной ценой в качестве аргумента? Это невозможно, но мы потеряли, что при изменении отношения с на на получается .Иногда имеет смысл выбрать один из них и сказать, что Product - это RelativePricedProduct или FixedPricedProduct и поделиться кодом внутри них с некоторой общей структурой данных (или даже через наследование) . Однако будьте осторожны и используйте его только при необходимости.

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

Что дальше?

Некоторые ресурсы, которые могут оказаться полезными:

Техническая группа Mews предоставила вам дополнительную информацию об инженерных решениях: