Semenalidery.com

IT Новости из мира ПК
3 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Типы ошибок в программировании

Основные виды ошибок программирования

Дата добавления: 2013-12-23 ; просмотров: 4576 ; Нарушение авторских прав

Стиль программирования, облегчающий отладку

ОТЛАДКА ПРОГРАММ В СРЕДЕ ТУРБО-ПАСКАЛЬ

Опция Environment (состояние среды)

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

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

Существует ряд простых правил, которых желательно придерживаться при составлении программы:

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

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

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

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

5. Текст программы должен быть «рыхлым», не следует писать операторы компактно, вплотную друг к другу. Желательно, чтобы на строке было не более одного оператора. Поскольку отладчик Турбо-Паскаля работает построчно, такой подход облегчит локализацию ошибки. На одной строке в виде списка можно писать лишь те операторы, которые надежны в отношении отладки и в проверке не нуждаются: A:=10; B:=3.14; Str:=’Строка символов’; C:=True;.

6. Выполняемые в программе действия надо как можно чаще сопровождать комментариями < >, (* *). Известные программисты Керниган и Плоджер в своей книге «Элементы стиля программирования» рекомендуют, чтобы комментарием сопровождался каждый оператор программы.

В ходе отладки программы приходится сталкиваться с тремя видами ошибок:

1. Синтаксические ошибки — текст программы не отвечает требованиям языка Паскаль. Такие ошибки выявляются сразу при попытке компиляции и запуска программы.

2. Ошибки периода выполнения программы (RUNTIME ERROR) — ошибки, возникающие при выполнении программы, когда текст программы формально записан правильно, но при выполнении программы в результате неблагоприятного стечения обстоятельств возникает ошибочная ситуация и компьютер не может продолжить работу (например, в случае деления на ноль).

3. Ошибки в алгоритме (семантические ошибки) — программа работает без сбоев, но результаты получаются неверные.

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

Перечислим ошибки, наиболее часто допускаемые начинающими программистами, и разъясним сообщения Турбо-Паскаля, выдаваемые им при выявлении этих ошибок в процессе компиляции текста программы:

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

2. Unknown identifier — идентификатор (имя переменной, константы, процедуры и т.п.) не был упомянут в разделе описаний программы.

3. Duplicate identifier — попытка дважды описать один и тот же идентификатор.

4. Syntax error — синтаксическая ошибка, например строка символов не была заключена в кавычки.

5. Line too long — компилятор не может обрабатывать текст программы со строками длиннее 126 символов. Скорее всего, программист забыл поставить апостроф, закрывающий текстовую строку, записываемую в переменную или выводимую на экран.

6. Type identifier expected — не указан тип идентификатора.

7. Variable identifier expected — на этом месте в программе должна стоять переменная.

8. Error in type — объявление типа данных не может начинаться с этого символа.

9. Type mismatch — а)тип переменной, стоящей слева от знака присваивания, отличается от значения выражения, стоящего справа; б)при обращении к процедуре типы формального и фактического параметров не совпадают; в)переменная данного типа не может служить индексом массива.

10. Begin expected — нужен begin.

11. End expected — нужен end.

12. Integer expression expected — требуется выражение типа integer.

13. Boolean expression expected — требуется выражение типа boolean.

14. Do expected — пропущено слово «Do».

15. Of expected — пропущено слово «of».

16. Then expected — пропущено слово «then».

17. To expected — пропущено слово «to».

18. String variable expected — требуется строковая переменная.

19. Error in expression — данный символ не может участвовать в выражении таким образом.

20. Division by zero — деление на ноль.

21. Constant and case types do not math — тип меток и тип селектора в операторе CASE не соответствуют друг другу.

22. Label not within current block — оператор GOTO не может ссылаться на метку, находящуюся вне текущего модуля.

23. Label already defined — такая метка уже есть.

24. Floating point overflow operation — величина вещественного числа вышла за пределы диапазона, допускаемого Паскалем (обычно при делении на ноль).

25. Invalid procedure or function reference — неправильный вызов подпрограммы.

5 видов ошибок, с которыми сталкивается каждый программист во время кодирования

Как программист, вы должны быть готовы исправлять ошибки в своем коде. Во время кодирования программы мы часто допускаем некоторые ошибки. Сделать сложную программу без помарки просто невозможно. Для многих программистов написание кода является легкой частью создания приложения. Трудным шагом является отладка (поиск ошибок и их исправление). И порой случается такое, что при устранении одной проблемы появляется 10 других. Какие виды ошибок в программировании существуют.

Виды ошибок в программировании:

Может возникнуть огромное число ошибок при компиляции.

Компиляция в программировании — трансляция программы, составленной на исходном языке высокого уровня, в эквивалентную программу на низкоуровневом языке, близком машинному коду (абсолютный код, объектный модуль, иногда на язык ассемблера).

Крошечные ошибки

Эти типы ошибок могут быть миниатюрными, но справиться с ними непросто. Вы получите ошибки компилятора, а затем потратите часы или даже дни, пытаясь выяснить, где вы ошиблись. Такие ошибки включают в себя забывание этой маленькой точки с запятой или скобки. В языке программирования, таком как Python, вы можете столкнуться с проблемой, когда отступ выполняется неправильно. Крошечные ошибки могут быть обнаружены при использовании правильных IDE. Маленькие ошибки являются наиболее раздражающими из всех, потому что вы знаете, что их легко исправить, но вы потратили так много времени, пытаясь найти их.

Несуществующие ошибки

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

Большие ошибки

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

Скрытые ошибки

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

Читать еще:  Ошибка торрента не смонтирован

Сюрприз ошибок

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

Заключение

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

И главное! Если у вас возникла ошибка, обращайтесь в поисковику. Думаю, что ранее с такой проблемой сталкивались и другие.

Логические ошибки: основные беды начинающих программистов

Опытные программисты знают, что ошибки в программе делятся на два основных типа. Первая разновидность — это баги, которые вылавливаются при компиляции. К ним относятся преимущественно проблемы с синтаксисом, явная несовместимости типов и т.д. Эту разновидность багов исправляют на этапе разработки, так как компилятор «вылетает по ошибке». Их просто невозможно не заметить.

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

Выявить этот вид багов удается только на этапе тестирования. И хорошо, если ошибку удается исправить локальной «заплаткой». Нередко приходится менять практически весь алгоритм. А это – дополнительные затраты времени, сил, а в коммерческих проектах – финансовые, а иногда и репутационные потери.

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

Алгоритм – основа всех основ

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

Такой подход возможен при решении учебных задач на 10-15 строк кода. Но при работе над серьезным программным продуктом пренебрежение алгоритмом – почти гарантированный путь к логическим ошибкам и катастрофическим результатам.

Как работать с алгоритмом:

  • Начинайте с малого . Запишите алгоритм упрощенно, в виде «черных ящиков» (логических блоков без подробностей их работы). Это поможет оценить работоспособность идеи в целом.
  • Двигайтесь сверху вниз . Сначала – общая идея «в целом», далее – детализация основных функций и так далее. Не бойтесь ставить «заглушки» и прорабатывать мелкие детали в последнюю очередь. Двигаться сверху вниз проще и с точки зрения логики, и психологически.
  • Пишите команды «от имени компьютера». Помните, что вы имеете дело не с человеком, а с компьютером, который буквально выполняет команды и после каждого шага ждет ответа на вопрос «что делать». Например, логический блок «сохранение документа» будет понятен вам, но не компьютеру. Он вполне подойдет на этапе крупных блоков в качестве заглушки. Но далее придется проработать все действия пошагово с учетом выбранного языка программирования.
  • Делите код на отдельные модули (блоки) , которые можно будет запускать отдельно друг от друга. Это сильно облегчит как алгоритмизацию, так и процесс отладки.
  • Читайте алгоритм «как будто компьютер» . Проверяйте себя на каждом этапе. Главное правило – одинаковые данные всегда должны вести к одинаковым результатам.

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

«Не туда положил»: о типах данных

Здесь проблемы возникают в двух случаях:

  1. При статической типизации в таких языках, как С++, Java или С# неверно определен тип переменной. Большинство подобных ошибок выявляет компилятор. Но здесь есть свои «лазейки» для багов. Например, в С# вполне возможно «положить» вещественное значение в целочисленную переменную. И оно просто округлится до целого. Т.е. вместо 1,3 у вас будет храниться значение 1. Само собой, все дальнейшие вычисления будут содержать ошибку.
  2. При динамической типизации (JavaScript, Python, PHP) неявное приведение типов – самое обычное дело. А потому здесь даже компилятор промолчит в случае ошибки. Например, вы планируете получить целочисленное значение, для чего отправляете результаты вычислений в переменную типа int. Но программа видит «знаки после запятой», и переменная без вашего участия меняет тип на float.

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

Как вы думаете, какое число будет выведено на экран после выполнения последней строки? По идее, это должно быть 3,125. Но, например, в C# вы увидите целую цифру «3». Причем, тип переменной С будет float, как вы и заказывали.

Здесь проблема в другом: компилятор сначала проводит целочисленное деление, так как определяет переменные A и B как относящиеся к типу int. И полученный результат отправляет в переменную C (тип float). Целое значение (32 разряда) прекрасно помещается в 64-разрядный float, отведенный под хранение результата. Компилятор не видит ошибки. А у вас в программе появляются неточные вычисления, которые могут повлечь за собой большие проблемы.

Аналогичным образом компилятор округлит значение до целого и в Python 2. А уже в Python 3 алгоритм преобразования типов сработает иначе: сначала определится тип переменной, куда отправляется значение, а потом будет проводиться деление. После компиляции кода в Python 3 вы получите c=3,125.

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

Высвобождение ресурсов: до 100% загрузки процессора

Если вы работаете с языком, где реализована автоматическая сборка мусора, внимательно следите за тем, как происходит высвобождение ресурсов. В отдельных случаях эта полезная функция может начать работать во вред: отбирать для себя максимум памяти, загружать дополнительными задачами процессор, замедлять и даже «подвешивать» программу.

Например, в Java этот процесс работает так:

  • Виртуальная машина проводит поиск ненужных объектов;
  • Составляет из них очередь на удаление;
  • По мере продвижения очереди очищает ячейки памяти.

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

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

Намного надежнее своевременно применять функции типа try-with-resources и try-finally. И все ресурсы очищать в том коде, где вы их получили.

И еще: не забывайте закрывать сессии и файлы сразу после того, как они перестают быть нужны. Это должно быть также естественно, как закрыть скобку в коде.

Конфликт потоков: кто первый успеет?

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

Например: первый поток в результате вычислений получает значение 1, отправляет его в переменную. В это время второй поток перехватывает доступ и обнуляет эту переменную. А первый – сохраняет значение. В результате вы планировали запомнить значение 1. А у вас сразу после вычислений сохраняется 0. И далее копятся ошибка за ошибкой.

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

Переменные: склонность к глобализации

Эта ошибка популярна у новичков – стремление объявить сразу все переменные и сделать их глобальными. В результате таких действий вы:

  • перегружаете ресурсы оборудования;
  • получаете множество уязвимостей, которые сложно закрыть;
  • усложняете в разы отладку и поиск багов.
Читать еще:  Ватсап код ошибки 924

На глобальном уровне определяют только необходимый минимум – те самые глобальные переменные, с которыми работают практически все модули. Все остальные объявляйте в тех модулях, где они работают. И не забывайте об идентификаторах ограничения доступа: public, private и protected.

Переполнение буфера в С/С++: «танцы на граблях»

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

Но нередко для экономии ресурсов программисты используют C-библиотеки. В этом случае очень важно следить за буферизацией. Дело в том, что языки C/С++ очень уязвимы к переполнению буфера. Если он окажется меньше, чем нужно для работы, программа попытается использовать память за пределами выделенного участка. Результат – многочисленные, можно сказать, легендарные ошибки, когда в обрабатываемые данные попадает «неведомый мусор».

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

Изучите особенности работы с буфером и методы борьбы с его переполнением, чтобы не пополнить число «танцующих на граблях с 30-летней историей».

Отладка и поиск логических багов

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

  • Пользуйтесь возможностями отладчика вашей IDE . Ставьте контрольные точки, отражайте на консоли ход выполнения и значения переменных, переходите в «пошаговый режим» выполнения в наиболее «подозрительных» участках кода. Так вы быстрее сможете локализовать проблему.
  • Помните: компилятор может неправильно указывать строку с ошибкой . Если вам повезло, и компилятор помог вам выявить баг, не спешите радоваться. При «завершении с ошибкой» вы видите номер строки, в которой выполнение программы стало невозможным. Если проблема в простейшей опечатке (синтаксис), то строка с багом вам известна. В случае логических ошибок вероятнее всего, проблема появилась на более ранних этапах работы программы. А в указанной строке была попытка использовать ошибочные данные, что и привело к аварийному завершению.
  • Старый добрый листинг программы тоже может помочь . Если вы запутались и не знаете, что делать, распечатайте код и попробуйте его «выполнить» как будто вы – и есть компьютер. Шаг за шагом двигайте по командам. Переходите от блока к блоку так, как это делает программа. На каждом этапе вычисляйте и фиксируйте значения переменных (калькулятором пользоваться можно). И сверяйте результаты с ожидаемыми. Все в порядке? Двигайтесь дальше. Что-то не так? Ура! Вы локализовали баг. Можно возвращаться за компьютер и разбираться подробнее в этом фрагменте кода в отладчике.

И самое главное: не бойтесь что-то менять, в том числе, на глобальном уровне. Лучше переписать «сырой» код на раннем этапе разработки практически полностью, чем из-за серьезной логической ошибки терять в скорости и качестве работы программы, пытаясь использовать кучу «заплаток». От ошибок не застрахован никто. Потраченного времени жаль, но это – ваш личный практический опыт. А программа должна работать быстро, надежно и, самое главное, правильно.

15 наиболее распространенных ошибок в программировании

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

Избегая ошибок в программировании, приведенных ниже, вы сможете существенно повысить качество создаваемого кода!

Советы по JavaScript

1 – Ненужные манипуляции с DOM

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

Этот код модифицирует DOM 99 раз, и создает 99 ненужных объектов jQuery. Девяносто девять – сумасшедшая цифра! Более правильным решением было бы использовать фрагмент документа или создать строку, содержащую 100 элементов
, а затем вставить это дело в HTML. Таким образом мы обращаемся к DOM всего один раз. Вот пример:

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

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

2 – Нелогичные имена Переменных и Функций в JavaScript

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

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

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

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

Иногда можно называть функцию указывая тип возвращаемого результата. Например вы можете назвать функцию которая возвращает HTML именем getTweetHTML() . Вы также можете предварять название функции словом do , если функция только выполняет какие-либо инструкции и ничего не возвращает, например: doFetchTweets() .

Конструктор функции, следуя традициям классов в других языках, называется с большой буквы:

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

3 – Использование hasOwnProperty() в циклах for. in

Массивы в языке JavaScript не являются ассоциативными; использование их в качестве таких осуждается комьюнити. Объекты, с другой стороны, могут рассматриваться как хэш-таблицы. Такой подход подталкивает к перебору свойств объектов используя циклы for. in , например так:

Однако, нюанс в том, что цикл for. in перебирает свойства прототипа. Это может вызвать некоторые проблемы если вам нужно отобразить только существующие свойства выбранного объекта.

Можно решить эту проблему используя метод hasOwnProperty() . Вот пример:

Такой вариант выдаст только значения свойств, находящихся непосредственно в someObject .

4 – Сравнение булевых переменных

Сравнение булевых переменных это пустая трата вычислительного времени. Рассмотрим это на следующем примере:

Заметим что: foo == true . Сравнение foo и true не нужно, поскольку foo и без того булево значение (является ложью или истиной). Вместо сравнения foo , просто используем его значение, например:

Для значения false , используем логический оператор NOT (НЕ), как показано ниже:

5 – Назначение событий

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

Представьте, что у вас есть “сетка” изображений, которые нужно отображать в лайтбоксе. Вот чего не надо делать. Заметим: мы здесь используем jQuery, надеясь что используете похожую библитеку. Впрочем, эти принципы можно использовать и в чистом JavaScript.

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

В приведенном коде, и this и event.target ссылаются на элемент “ссылка”. Данная техника может применяться с любым родительским элементом. Только убедитесь, что правильно выбрали целевой элемент.

6 – Тернарная избыточность

Чрезмерное использование оператора тернаторсти обычное дело как в JavaScript, так и в PHP.

Условия всегда возвращают в качестве значения true или false , так что вам нет необходимости дополнительно указывать true / false в тернарном операторе. Вместо этого, можно просто вернуть значение сравнения:

Советы по PHP

7 – Используйте тернарный оператор при необходимости

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

Читать еще:  Как устранить ошибку error

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

Это четко, кратко, и обеспечивает всю необходимую функциональность.

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

8 – Используйте защищенные классы

Оператор if в основном используется для контроля пути выполнения функции или метода. Распространенное явление, когда выполняется большой фрагмент кода в случае когда условие true , и простой возврат значения в операторе else . Например:

Однако, такое решение может сильно усложнить читаемость вашего кода. Вы можете улучшить этот код всего лишь инвертировав условие. Вот улучшенная версия:

Легче читается, не правда ли? Это простое изменение, дающее резкое различие в читабельности кода.

9 – Поддерживайте понятность методов

Это одна из наиболее распространенных ошибок у новичков.

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

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

И вуаля наш код стал чище и легче для отладки!

10 – Избегайте большой вложенности

Слишком большее количество уровней вложенности делает ваш код сложным для чтения и обслуживания. Посмотрите на следующий код:

Используя ранее озвученный совет, “развернем” некоторые условия.

Этот код определенно лучше для восприятия, а делает тоже что и пример выше.

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

В таком случае извлеките вложенные методы, и объявите их собственные методы:

11 – Избегайте магических чисел и строк

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

Вместо подобной конструкции:

Укажите, что эти числа и строки значат, и присвойте их переменным с осмысленным именем, например так:

Кто-то может сказать что мы создаем ненужные переменные, но производительность пострадает незначительно. Читаемость кода всегда в приоритете. Запомните: не зацикливайтесь на производительности пока не сможете сказать зачем она вам нужна.

12 – Не борщите с переменными

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

Переменная $result здесь совсем ни к чему. Что и показывает следующий фрагмент:

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

Общие рекомендации про программированию

13 – Разумно называйте свои переменные

Дни когда переменные назывались x , y , z прошли (только если дело не касается систем координат конечно). Переменные представляют важную часть логики программы. Не хотите печатать длинное имя? Раздобудьте IDE по-лучше. Современные IDE имеют функцию автозавершения длинных имен.

Если вы будете постоянно писать код в течении шести месяцев. Вспомните ли вы что скрывает в себе переменная $sut , которую вы когда-то написали? Скорее всего нет: будьте описательны. Все короткое придает коду запашок.

14 – Методы описывающие действие

Ошибки случаются; важно учиться на них.

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

Кроме того, не допускайте применения любого другого языка, отличного от Английского. Порой раздражает видеть функции с именами вроде 做些什麼() или четоделать() в вашем проекте. Это может сделать непонятным для других программистов назначение ваших методов Сегодня Английский это стандарт де-факто в программировании. Используйте только его, особенно если вы работает в команде.

15 – Рекомендации по структуре

И наконец что касается структуры кода. Читаемость и понятность кода также важна как и все о чем мы сегодня говорили. Две рекомендации:

  • Используйте отступы в 2 или 4 пробела. Немного больше, например 8 пробелов, это слишком много и сделает ваш код сложным для чтения.
  • Установите разумную ширину и придерживайтесь ее. 40 символов в строке? Нет, мы уже не в 70х; установите ширину в 120 знаков, поставьте отметку на экране, и заставьте себя или вашу IDE соблюдать этот лимит. 120 знаков прекрасная ширина, не заставляющая скроллить.

Заключение.

“Я никогда не делал глупых ошибок программирования”

Ошибки случаются; важно учиться на них. Мы в Nettuts+ делали, и будем продолжать делать ошибки. Надеемся что вы научитесь на наших ошибках и постараетесь избегать их в будущем. Хотя, честно говоря, лучший способ научиться, это допустить собственные ошибки!

Обработка ошибок в программах на Си

Хотя C не обеспечивает прямой поддержки обработки ошибок (или обработки исключений), существуют способы, с помощью которых обработка ошибок может быть осуществлена в C. Программист должен в первую очередь предотвращать ошибки и тестировать возвращаемые значения из функций.
Многие вызовы функций C возвращают -1 или NULL в случае ошибки, поэтому быстрое тестирование этих возвращаемых значений легко выполнить, например, с помощью оператора if. Например, в Socket Programming возвращаемое значение функций, таких как socket (), listen () и т. Д., Проверяется на наличие ошибки или нет.

Пример: обработка ошибок в программировании сокетов

Различные методы обработки ошибок в C

    Глобальная переменная errno: когда в C вызывается функция, переменной с именем errno автоматически присваивается код (значение), который можно использовать для определения типа возникшей ошибки. Это глобальная переменная, указывающая, что ошибка произошла во время любого вызова функции и определена в заголовочном файле errno.h.
    Разные коды (значения) для errno означают разные типы ошибок. Ниже приведен список из нескольких различных значений errno и соответствующего значения:

// Реализация C, чтобы увидеть, как значение errno
// установить в случае любой ошибки в C
#include
#include

// Если файл открыт, который не существует,

// тогда это будет ошибка и соответствующая

// значение errno будет установлено

// открываем файл который

fp = fopen ( «GeeksForGeeks.txt» , «r» );

printf ( » Value of errno: %dn » , errno );

Примечание. Здесь значение errno установлено в 2, что означает — Нет такого файла или каталога. В онлайн-среде IDE может выдаваться ошибка № 13, в которой говорится, что разрешение отклонено.

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

    // Реализация C, чтобы увидеть, как perror () и strerror ()
    // функции используются для печати сообщений об ошибках.
    #include
    #include
    #include

    // Если файл открыт, который не существует,

    // тогда это будет ошибка и соответствующая

    // значение errno будет установлено

    fp = fopen ( » GeeksForGeeks.txt » , «r» );

    // открываем файл который

    printf ( «Value of errno: %dn » , errno );

    printf ( «The error message is : %sn» ,

    perror ( «Message from perror» );

    Выход:
    На личном рабочем столе:

    В онлайн IDE:

    Примечание . Функция perror () отображает переданную ей строку, за которой следует двоеточие и текстовое сообщение с текущим значением errno.

    Состояние выхода: Стандарт C определяет две константы: EXIT_SUCCESS и EXIT_FAILURE, которые могут быть переданы в exit () для указания успешного или неудачного завершения, соответственно. Это макросы, определенные в stdlib.h.

    // C реализация, которая показывает
    // использование EXIT_SUCCESS и EXIT_FAILURE.
    #include
    #include
    #include
    #include

  • Ссылка на основную публикацию
    Adblock
    detector