Как вы делаете код многоразовым?
https://stackoverflow.com/questions/268258
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Любой код может быть так или иначе использован повторно, по крайней мере, если вы измените его.Случайный код как таковой не очень удобен для повторного использования.Когда я читаю некоторые книги, в них обычно говорится, что вы должны явно сделать код многоразовым, принимая во внимание и другие ситуации использования кода.Но определенный код также не должен быть всемогущим классом all doing.
Я хотел бы иметь повторно используемый код, который мне не нужно было бы менять позже.Как вы делаете код многоразовым?Каковы требования к многократному использованию кода?Какие функции обязательно должны быть в коде многократного использования, а какие являются необязательными?
Решение
Смотрите 10 советов по написанию кода для повторного использования за некоторую помощь.
<Ол>Другие советы
Если вы выберете подход, основанный на тестировании, то ваш код будет повторно использован только в качестве рефакторинга на основе будущих сценариев.
Лично я нахожу, что постоянное рефакторинг производит более чистый код, чем попытка угадать, для каких сценариев мне нужно кодировать определенный класс.
Больше всего наглядности делает код многократно используемым.
Повторное использование редко самоцель. Скорее, это побочный продукт написания хорошо структурированного, легко обслуживаемого и полезного кода.
Если вы собираетесь создавать код многократного использования, вы часто пытаетесь учесть требования к поведению, которые могут потребоваться в будущих проектах. Независимо от того, насколько вы хороши в этом, вы поймете, что неправильно понимаете эти требования к будущему.
С другой стороны, если вы начнете с минимальных требований текущего проекта, вы обнаружите, что ваш код может быть чистым, сжатым и элегантным. Когда вы работаете над другим проектом, который нуждается в аналогичной функциональности, вы естественным образом адаптируете свой исходный код.
Я предлагаю ознакомиться с лучшими практиками для выбранного вами языка / парадигмы программирования (например, Patterns и SOLID для типов Java / C #), литературой по Lean / Agile и (конечно) книгой «Code Complete». , Понимание преимуществ и недостатков этих подходов улучшит вашу практику кодирования без конца. Тогда весь ваш код станет пригодным для повторного использования - но «случайно», а не по замыслу.
Также см. здесь: Написание обслуживаемого кода
Для большинства определений «повторного использования» повторное использование кода является мифом, по крайней мере, по моему опыту. Можете ли вы сказать, что у меня есть некоторые шрамы от этого? :-)
Под повторным использованием я не имею в виду принятие существующих исходных файлов и отправку их до отправки, пока не выпадет новый компонент или служба. Я имею в виду использование определенного компонента или услуги и повторное использование его без изменений.
Я думаю, что первым шагом является установление мышления, что для создания повторно используемого компонента потребуется как минимум 3 итерации. Почему 3? Поскольку при первой попытке повторного использования компонента вы всегда обнаруживаете что-то, с чем он не может справиться. Итак, вы должны изменить это. Это происходит пару раз, пока, наконец, у вас не появится компонент, который, по крайней мере, можно использовать повторно.
Другой подход заключается в создании дорогого перспективного дизайна. Но тогда стоимость все заранее, и выгоды (могут) появиться некоторое время спустя. Если ваш начальник настаивает на том, что текущий график проекта всегда доминирует, этот подход не сработает.
Вы будете писать различные модули (части) при написании относительно большого проекта. Повторно используемый код на практике означает, что вы будете создавать библиотеки, которые могут использовать другие проекты, нуждающиеся в такой же функциональности.
Итак, вы должны определить модули, которые можно использовать повторно, для этого
<Ол>Определите основные компетенции каждого модуля. Например, если ваш проект должен сжимать файлы, у вас будет модуль, который будет обрабатывать сжатие файлов. НЕ заставляйте делать больше, чем ОДНА ВЕЩЬ . Только одна вещь.
Напишите библиотеку (или класс), которая будет обрабатывать сжатие файлов, не требуя ничего, кроме сжатого файла, вывода и формата сжатия. Это позволит отделить модуль от остальной части проекта, что позволит (его) использовать (использовать повторно) в других настройках.
Вам не нужно доводить ее до совершенства в первый раз, когда вы на самом деле повторно используете библиотеку, вы, вероятно, обнаружите недостатки в дизайне (например, вы не сделали ее достаточно модульной, чтобы иметь возможность легко добавлять новые форматы сжатия), и вы можете исправить их во второй раз и улучшить возможность повторного использования вашего модуля. Чем больше вы используете его (и исправляете недостатки), тем легче будет его повторно использовать.
Самое важное, что нужно учитывать, - это разделение, если вы пишете тесно связанный код, многократное использование - первая жертва.
Оставьте все необходимое состояние или контекст вне библиотеки. Добавьте методы для указания состояния в библиотеке.
Объектная ориентация позволяет вам преобразовать код в суперклассы. Это, пожалуй, самый простой, дешевый и эффективный вид повторного использования. Обычное наследование классов не требует много размышлений о «других ситуациях»; вам не нужно строить «всемогущий» код.
Помимо простого наследования, повторное использование - это то, что вы находите больше, чем изобретаете. Вы обнаружите ситуации повторного использования, когда вы хотите повторно использовать один из ваших собственных пакетов для решения немного другой проблемы. Если вы хотите повторно использовать пакет, который точно не соответствует новой ситуации, у вас есть два варианта.
<Ол>Скопируйте его и исправьте. Теперь вам нужно почти одинаковые пакеты - дорогая ошибка.
Сделайте исходный пакет многоразовым в двух ситуациях.
Просто сделайте это для повторного использования. Ничего более. Слишком много размышлений о «потенциале» повторное использование и неопределенное " другие ситуации " может стать пустой тратой времени.
Другие упоминали об этой тактике, но здесь она носит формальный характер.Эти трое заведут вас очень далеко:
- Придерживайтесь Единая Ответственность Принцип - это гарантирует, что ваш класс "делает только одно", что означает, что более вероятно, что он будет повторно использоваться для другого приложения, которое включает в себя то же самое.
- Придерживайтесь Лисков Принцип замещения - это гарантирует, что ваш код "делает то, что должен, без неожиданностей", что означает, что более вероятно, что его можно будет повторно использовать для другого приложения, которому требуется выполнить то же самое.
- Придерживайтесь Принцип открытия/Закрытия - это гарантирует, что ваш код можно заставить вести себя по-другому без изменения его исходного кода, что означает, что он с большей вероятностью будет использоваться повторно без прямого изменения.
Чтобы добавить к вышеперечисленным пунктам, я бы сказал:
- Сделайте те функции универсальными, которые вам нужно повторно использовать
- Используйте файлы конфигурации и заставьте код использовать свойства, определенные в files /db
- Четко разделите ваш код на такие функции / классы, которые обеспечивают независимую функциональность и могут использоваться в различных сценариях, и определите эти сценарии с помощью файлов конфигурации
Я бы добавил концепцию «Композиция классов поверх наследования классов». (который получен из других ответов здесь). Таким образом, «составленный» объект не заботится о внутренней структуре объекта, от которой он зависит, - только его поведение, которое приводит к лучшей инкапсуляции и упрощению сопровождения (тестирование, меньше деталей, о которых нужно заботиться). В таких языках, как C # и Java, это часто имеет решающее значение, так как нет множественного наследования, поэтому это помогает избежать того, что может иметь граф наследования.
Как уже упоминалось, модульный код более пригоден для повторного использования, чем немодульный код.
Одним из способов перехода к модульному коду является использование инкапсуляции, см. Теорию инкапсуляции здесь:http://www.edmundkirwan.com/
Изд.
Избегайте изобретать велосипед. Вот и все. И это само по себе имеет много преимуществ, упомянутых выше. Если вам нужно что-то изменить, то вы просто создаете еще один фрагмент кода, другой класс, другую константу, библиотеку и т. Д. ... это поможет вам и остальным разработчикам, работающим в одном приложении.
Прокомментируйте, подробно , все, что может показаться запутанным, когда вы вернетесь к коду в следующий раз. Чрезмерно подробные комментарии могут немного раздражать, но они намного лучше, чем редкие комментарии, и могут сэкономить часы, пытаясь выяснить WTF, который вы делали в прошлый раз.
