Как сделать код повторно используемым?

Ответ 1

См. 10 советов по написанию многоразового кода для получения некоторой помощи.

• Сохраните код DRY. Сухое означает "Не повторяй себя".
• Сделать класс/метод сделать только одно.
• Напишите модульные тесты для ваших классов и упростите тестирование классов.
• Удалите бизнес-логику или основной код от любого кода рамки
• Попробуйте представить более абстрактно и использовать интерфейсы и абстрактные классы.
• Код для расширения. Напишите код, который можно легко продлить в будущем.
• Не пишите код, который не нужен.
• Попробуйте уменьшить сцепление.
• Будьте более модульными
• Введите код, похожий на ваш код, внешний API

Ответ 2

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

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

Ответ 3

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

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

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

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

Я предлагаю взглянуть на лучшие практики для выбранного вами языка программирования/парадигмы (например, шаблоны и SOLID для типов Java/С#), литературу программирования Lean/Agile и (конечно) книгу "Code Complete". Понимание преимуществ и недостатков этих подходов улучшит вашу практику кодирования без конца. После этого ваш код станет вполне обоснованным, но "случайно", а не по дизайну.

Также см. здесь: Написание поддерживаемого кода

Ответ 4

Для большинства определений "повторное использование" повторное использование кода является мифом, по крайней мере, в моем опыте. Можете ли вы сказать, что у меня есть некоторые шрамы?:-)

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

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

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

Ответ 5

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

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

• Скопируйте и исправьте. Теперь у вас есть почти похожие пакеты - дорогостоящая ошибка.

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

Просто сделайте это для повторного использования. Больше ничего. Слишком много думать о "потенциальном" повторном использовании и undefined "других ситуациях" может стать пустой тратой времени.

Ответ 6

Отличный способ повторного использования компонентов состоит в использовании Бит:

https://github.com/teambit/bit

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

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

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

p.s.

Существует также бесплатный центр сообщества для повторно используемых компонентов (веб, реакция, серверная сторона или что-то еще) для компонентов с открытым исходным кодом. Вы можете использовать его для своих собственных компонентов или находить и делиться с другими. Вот пример компонента с открытым исходным кодом с лицензией MIT, называемый array/diff".

Ответ 7

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

Итак, вам нужно идентифицировать модули, которые можно использовать повторно, для этого

• Определите основную компетенцию каждого модуля. Например, если ваш проект должен сжимать файлы, у вас будет модуль, который будет обрабатывать сжатие файлов. Do NOT сделать больше ONE THING. Только одно.

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

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

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

Оставьте все необходимое состояние или контекст вне библиотеки. Добавьте методы, чтобы указать состояние в библиотеке.

Ответ 8

• Придерживайтесь Единая ответственность Принцип - он гарантирует, что ваш класс только "делает одно", а это означает, что он, скорее всего, будет повторно использоваться для другого приложения, которое включает в себя то же самое.
• Придерживайтесь Лисков Принцип замены - он гарантирует, что ваш код "делает то, что он предположил без сюрпризов", а это означает, что он, скорее всего, будет повторно использоваться для другого приложения, которое нужно сделать то же самое.
• Соблюдайте Открытый/Закрытый принцип - он гарантирует, что ваш код может вести себя по-другому, не изменяя его источник, а это значит, что он больше вероятно, будет повторно использоваться без прямой модификации.

Ответ 9

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

• Сделайте эти общие функции, которые вам нужно повторно использовать
• Используйте конфигурационные файлы и создайте код, используя свойства, определенные в файлах /db
• Четко подставляйте свой код в такие функции/классы, которые предоставляют независимую функциональность и могут использоваться в разных сценариях и определять эти сценарии с помощью конфигурационных файлов.

Ответ 10

Я бы добавил концепцию "Class class over class inheritance" (которая получена из других ответов здесь). Таким образом, "скомпонованный" объект не заботится о внутренней структуре объекта, от которого он зависит - только его поведение, что приводит к лучшей инкапсуляции и упрощению ремонтопригодности (тестирование, меньше деталей, о которых нужно заботиться). В таких языках, как С# и Java, это часто имеет решающее значение, поскольку нет множественного наследования, поэтому он помогает избежать графа наследования, который может иметь ад.

Ответ 11

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

Один из способов помочь модульному коду - использовать инкапсуляцию, см. здесь теорию инкапсуляции: http://www.edmundkirwan.com/

Под ред.

Ответ 12

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

Ответ 13

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