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

«Элементы стиля программирования», написанная П. Дж. Плаугером и Брайаном В. Керниганом, является классической книгой в этой области.

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

Теперь давайте пройдемся по урокам:

  1. Пишите четко — не будьте слишком умны.
    — Иногда хороший код не в том, чтобы иметь много ярлыков или быть неявным; речь идет о написании четких и простых для понимания заявлений.
  2. Говорите, что вы имеете в виду, просто и прямо.
    — При написании заявления не переусердствуйте с кодом. Сделайте его кратким и осмысленным.
  3. Используйте библиотечные функции, когда это возможно.
    — В каждом языке программирования есть библиотечные функции, поэтому постарайтесь максимально использовать их, а не реализовывать все самостоятельно.
  4. Избегайте слишком большого количества временных переменных.
    — Использование слишком большого количества временных переменных (например, temp*, v_1, v_2) может затруднить понимание вашего кода, поскольку они часто имеют очень ограниченные определения.
  5. Писайте четко — не жертвуйте ясностью ради эффективности.
    — Хотя эффективность важна, она не так важна, как написание кода, который легко читать и понимать.
  6. Позвольте машине сделать всю грязную работу.
    — Вы тот, кто управляет компьютером, так что используйте его по максимуму и не думайте, как машина.
  7. Замените повторяющиеся выражения вызовами общих функций.
    — Когда вы заметите повторяющийся шаблон, преобразуйте его в упрощенную функцию.
  8. Заключите скобки, чтобы избежать двусмысленности.
    — Если выражение сбивает с толку, используйте скобки для группировки отношений и избегайте путаницы.
  9. Выберите имена переменных, которые не будут путаться.
    — Если имена переменных сбивают с толку или трудно читаются (например, nnn, nnnn), вам может быть трудно понять их позже.
  10. Избегайте ненужных ветвей.
    — Обоснование этого правила заключается в том, что меньшее количество ответвлений, таких как «если», «иначе», «переключатель» и «случай», обычно приводит к более легкому чтению, пониманию и сопровождению кода.
  11. Если логическое выражение трудно понять, попробуйте его преобразовать.
    — Иногда преобразование сложного логического выражения в функцию может облегчить его понимание.
  12. Выберите представление данных, упрощающее программу.
    — Правильно организуйте структуру данных, чтобы максимально упростить вычисления.
  13. Сначала напишите на понятном псевдоязыке, а затем переведите на нужный вам язык программирования.
    — Прежде чем решать задачи по программированию, напишите легко читаемый псевдокод и конвертируйте его в язык программирования.
  14. Модулизируйте. Используйте процедуры и функции.
    — Хороший код должен быть разделен на модули, каждый из которых выполняет определенную роль. Избегайте написания функций или чего-либо еще, что выходит за рамки его предполагаемой цели.
  15. Полностью избегайте переходов, если вы можете сохранить читабельность программы.
    — В некоторых языках программирования, таких как Go, есть операторы GOTO, которые могут переходить в разные места кода. Однако это может привести к грязному и трудночитаемому коду. Чтобы ваш код было легко читать, старайтесь не использовать GOTO
  16. Не исправляйте плохой код — перепишите его.
    — Если вы столкнулись с плохо написанным кодом, не исправляйте его так, чтобы он усложнился. Вместо этого реорганизуйте его, чтобы сделать его более читабельным.
  17. Напишите и протестируйте большую программу небольшими частями.
    — разделяйте и властвуйте, а также разбивайте программу на более мелкие части для упрощения тестирования и повторного использования кода.
  18. Используйте рекурсивные процедуры для рекурсивно определенных структур данных.
    Рекурсия может быть очень дорогостоящей (с точки зрения времени выполнения и использования памяти), поэтому используйте рекурсию только для решения проблем. которые этого требуют. Кроме того, вы можете использовать динамическое программирование для решения проблем.
  19. Проверяйте входные данные на правдоподобие и достоверность.
    — Всегда проверяйте свои входные данные
  20. Убедитесь, что ввод не нарушает ограничений программы.
    — Ограничьте ввод тем, что ваша программа может обработать без сбоев.
  21. Выявление неверных входных данных; восстановить, если это возможно.
    — Иногда ввод может содержать человеческие ошибки. Идентифицируйте и устраняйте их, чтобы предотвратить сбои в работе вашей программы. Это можно сделать, проверив условия, зарегистрировав ошибки, пропустив проблемные данные и прочитав новые данные из следующей строки.
  22. Сделайте ввод легко подготавливаемым, а вывод не требующим пояснений.
    — Постарайтесь сделать так, чтобы ваша программа принимала удобный для пользователя ввод и выдавала понятный вывод. Избегайте ввода, который может вызвать ошибки. Например, вместо того, чтобы требовать серийные коды для элементов, примите тип элемента, чтобы облегчить пользователям задачу.
  23. Используйте единые форматы ввода.
     —
    Пожалуйста, стандартизируйте формат входных данных в своем приложении.
  24. Облегчить корректировку ввода.
    — При разработке программы, которая принимает ввод (может быть подсказка или запрос JSON), вы должны убедиться, что формат и структура ввода удобны для пользователей. читать, понимать и проверять.
  25. Используйте самоидентифицирующий ввод. Разрешить значения по умолчанию. Эхо на выходе.
    — в некоторых случаях разрешать ввод по умолчанию.
  26. Перед использованием убедитесь, что все переменные инициализированы.
    — Всегда проверяйте, что каждая объявляемая вами переменная инициализирована или ей присвоено значение.
  27. Не останавливайтесь на одной ошибке.
    Помните, что одна ошибка может привести к нескольким ошибкам.
  28. Используйте отладочные компиляторы.
    — Всегда используйте инструменты отладки, поскольку они намного эффективнее ручной проверки.
  29. Остерегайтесь ошибок "один на один".
     – Ошибки "на один" могут возникать при неправильной проверке длин, например при установке условия цикла for на i ≤ arr.length, что может привести к выходу индекса за пределы
  30. Позаботьтесь о правильном ветвлении в отношении равенства.
    — вам необходимо убедиться, что вы выполняете ветвление правильно в зависимости от желаемого результата. Распространенной ошибкой является запись условий в неправильном порядке или использование неправильного реляционного оператора, что приводит к неожиданному поведению. Например, js == и ===
  31. Будьте осторожны, если петля выходит в одно и то же место из середины и снизу.
    Будьте осторожны при проектировании циклов, которые могут выходить из нескольких точек, так как это может привести к путанице и потенциальным ошибкам.
  32. Убедитесь, что ваш код «ничего» не делает изящно.
    Иногда, когда нет работы, которую нужно выполнить, или ввода для обработки, код не обрабатывает этот случай; следовательно возникает ошибка. Обязательно напишите код, который будет надежным и для этого.
  33. Тестируйте программы на их граничных значениях.
    Тестирование вашего кода с входными значениями в пределах ожидаемого диапазона. Это гарантирует, что ваш код может обрабатывать пограничные случаи и ведет себя ожидаемым образом во всех сценариях.
  34. Проверьте некоторые ответы вручную.
    Ручная проверка вывода вашего кода для конкретных тестовых случаев, чтобы убедиться в правильности
  35. 10,0 умножить на 0,1 вряд ли когда-нибудь получится 1,0
    при работе с числами с плавающей запятой и учете потенциальных ошибок округления.
  36. 7/8 равно нулю, а 7,0/8,0 не равно нулю.
    — Это очень важно: при делении целых чисел результат всегда равен 0, если делитель больше делимого. Однако в случае с числами с плавающей запятой результат не равен 0. В мире блокчейнов из-за различий в десятичных точках разные языки по-разному обрабатывают числа с плавающей запятой, поэтому часто используются целые числа.
  37. Не сравнивайте числа с плавающей запятой исключительно на равенство.
    НЕ сравнивайте числа с плавающей запятой, просто используя оператор ==. Этого не достаточно. Например,
    пусть х = 0,1 + 0,2;
    пусть y = 0,3;
    x == y ложно в JS 🥲
  38. Сделайте это правильно, прежде чем делать это быстрее.
    Правильность по сравнению с оптимизацией производительности
  39. Прежде чем делать быстрее, сделайте его отказоустойчивым.
    Надежность по сравнению с оптимизацией производительности
  40. Уточните, прежде чем делать это быстрее.
    Ясность оптимизации производительности
  41. Не жертвуйте ясностью ради незначительного повышения эффективности.
    Основная цель этих уроков — «НАПИСАТЬ ЧИТАЕМЫЙ КОД», поэтому жертвовать ясностью ради эффективности — НЕ ПУТЬ.
  42. Позвольте вашему компилятору выполнить простую оптимизацию.
    Доверяйте своим инструментам, доверяйте своему компилятору. Не делайте это хакерским, чтобы он достиг точки, когда он не читается
  43. Не пытайтесь повторно использовать код; вместо этого реорганизуйте его.
    Сделайте его модульным, удобным в сопровождении, с единой ответственностью и отделите его от забот. Иногда повторное использование кода — не лучшая практика, когда функция не подходит естественным образом и может привести к запутанному и сложному в сопровождении коду.
  44. Убедитесь, что особые случаи действительно особенные.
    Когда дело доходит до обработки особых случаев, код может быть очень сложным для понимания, поэтому убедитесь, что случаи ДЕЙСТВИТЕЛЬНО особенные, прежде чем усложнять их.
  45. Не усложняйте процесс, чтобы сделать его быстрее.
    Лучший и быстрый код не обязательно должен быть сложным. ПОЦЕЛУЙ (будь проще и глупее)
  46. Не переделывайте код, чтобы сделать его быстрее — найдите лучший алгоритм.
    Поощряйте поиск более эффективных алгоритмов вместо внесения небольших изменений в код, которые могут незначительно повлиять на производительность и усложнить работу.
  47. Инструментируйте свои программы. Измерьте, прежде чем вносить изменения в эффективность.
    Убедитесь, что ваша программа протестирована, прежде чем переходить к оптимизации.
  48. Убедитесь, что комментарии и код совпадают.
    Убедитесь, что комментарии точно отражают коды. Комментарии, которые противоречат коду или искажают его, могут ввести в заблуждение и вызвать путаницу.
  49. Не повторяйте код с комментариями — учитывайте каждый комментарий. — рекомендуется писать комментарии, предоставляющие дополнительную информацию или контекст, а не просто повторять, что делает код.
  50. Не комментируйте плохой код — перепишите его.
    Если код плохой, не утруждайте себя комментариями, чтобы объяснить этот плохой код 😅, ПЕРЕПИШИТЕ ЕГО!
  51. Используйте имена переменных, которые что-то значат.
    Пожалуйста, назовите переменные, которые четко передают их назначение. Так что, возможно, вам вообще не нужно комментировать
  52. Используйте ярлыки утверждений, которые что-то означают.
    Напишите осмысленную функцию, модуль и имя класса.
  53. Отформатируйте программу так, чтобы читатель мог ее понять.
    Вы должны применить правильное форматирование кода, включая отступы, пробелы и макет. У нас есть красивее и Eslint в современной разработке приложений. Так что используйте это
  54. Задокументируйте макеты данных.
    — Четкие комментарии делают код более читабельным.
  55. Не комментируйте слишком много
    — не комментируйте все; комментируйте только то, что необходимо, когда код не передает достаточно смысла. Прежде чем писать комментарий, спросите себя: почему? Есть ли недостающие контексты, которые следует добавить? Нужно ли добавлять дополнительные детали для объяснения кода?