Знакомство с отладчиком Visual Studio
В этом разделе представлены средства отладчика, предоставляемые Visual Studio. В контексте Visual Studio отладка приложения обычно означает запуск приложения с подключенным отладчиком (то есть в режиме отладчика). При этом в отладчике доступно множество способов наблюдения за выполнением кода. Вы можете выполнить шаги по коду и просмотреть значения, хранящиеся в переменных, вы можете настроить контроль над переменными, чтобы увидеть, когда изменяются значения, можно проверить путь выполнения кода и т. д. Если это первый раз, когда вы попытались выполнить отладку кода, вам может потребоваться прочитать отладку для абсолютных начинающих , прежде чем перейти к этому разделу. Если вы пытаетесь выполнить определенную задачу и должны знать, какую функцию следует использовать, см . средство поиска функций отладчика. Сведения об отладке с помощью ИИ см. в разделе Отладка с помощью Copilot.
Описанные здесь функции применяются к C#, C++, Visual Basic, JavaScript и другим языкам, поддерживаемым Visual Studio (если не указано иное).
Установка точки останова и запуск отладчика
Точки останова полезны, если вам известны строка или раздел кода, которые вы хотите подробно изучить в среде выполнения. Дополнительные сведения о различных типах точек останова, которые можно задать, например об условных точках останова и точках останова в функциях, см. в разделе Использование точек останова.
Для отладки нужно запустить приложение с отладчиком, подключенным к процессу приложения. Для этого:
- Нажмите клавишу F5 (Отладка > Начать отладку), которая является наиболее распространенным методом.
Однако сейчас у вас, возможно, не задано ни одной точки останова для проверки кода приложения, поэтому мы сначала зададим их, а затем начнем отладку. Точки останова — это самая основная и важная функция надежной отладки. Точка останова указывает, где Visual Studio следует приостановить выполнение кода, чтобы вы могли проверить значения переменных или поведение памяти либо выполнение ветви кода.
Если вы открыли файл в редакторе кода, точку останова можно задать, щелкнув в поле слева от строки кода.
Нажмите клавишу F5 (Отладка > запуска отладки) или кнопку «Начать отладку» на панели инструментов отладки, а отладчик запускается в первую точку останова, с которой она сталкивается. Если приложение еще не запущено, при нажатии клавиши F5 запускается отладчик и выполняется остановка в первой точке останова.
Переход по коду в отладчике с помощью пошаговых команд
Мы указываем сочетания клавиш для большинства команд, так как они ускоряют навигацию по коду вашего приложения. (Аналогичные команды, такие как команды меню, отображаются в круглых скобках.) Дополнительные сведения об использовании команд пошагового выполнения см. в разделе Навигация по коду в отладчике.
Для запуска приложения с подключенным отладчиком нажмите клавишу F11 (Отладка > Шаг с заходом). F11 — это команда Шаг с заходом, которая выполняет приложение с переходом к следующему оператору. При запуске приложения с помощью клавиши F11 отладчик останавливается на первом выполняемом операторе.
Желтая стрелка представляет оператор, на котором приостановлен отладчик. В этой же точке приостанавливается выполнение приложения (этот оператор пока не выполнен).
Клавишу F11 удобно использовать для более детальной проверки потока выполнения. (Чтобы ускорить переход по коду, мы также показываем другие варианты.) По умолчанию отладчик пропускает код, отличный от пользователя (если требуется дополнительные сведения, см . только мой код).
В управляемом коде вы увидите диалоговое окно с запросом о том, хотите ли вы получать уведомления при автоматическом обходе свойств и операторов (поведение по умолчанию). Если вы хотите изменить этот параметр позже, отключите параметр Шаг с обходом свойств и операторов в меню Инструменты > Параметры в разделе Отладка.
Шаг с обходом по коду для пропуска функций
Когда вы находитесь в строке кода, представляющей собой вызов функции или метода, можно нажать клавишу F10 (Отладка > Шаг с обходом) вместо F11.
Клавиша F10 продолжает выполнение отладчика без захода в функции или методы в коде приложения (код продолжает выполняться). Нажав клавишу F10, вы можете обойти код, который вас не интересует. Так можно быстро перейти к важному для вас коду. Дополнительные сведения об использовании команд пошагового выполнения см. в разделе Навигация по коду в отладчике.
Быстрое выполнение до точки в коде с помощью мыши
Использование кнопки Выполнение до щелкнутого аналогично установке временной точки останова. Кроме того, эта команда удобна для быстрой работы в видимой области кода приложения. Выполнение до щелкнутого можно использовать в любом открытом файле. Дополнительные сведения об этой функции и аналогичных функциях навигации см. в разделе Выполнение до определенного места в коде.
Пока в отладчике наведите указатель мыши на строку кода, пока не появится кнопка «Запустить» (выполнить выполнение здесь).
Кнопка Выполнить о щелчка (Выполнить до этого места) доступна начиная с Visual Studio 2017.
Нажмите кнопку выполнения до щелкнутого (Выполнить до этого места). Отладчик продолжает выполнение до строки кода, которую вы щелкнули.
Вывод отладчика из текущей функции
В некоторых случаях может потребоваться продолжить сеанс отладки, однако полностью проведя отладчик сквозь текущую функцию.
Нажмите сочетание клавиш SHIFT + F11 (или выберите Отладка > Шаг с выходом).
Эта команда возобновляет выполнение приложения (и перемещает отладчик) до возврата текущей функции.
Выполнить до текущей позиции
При редактировании кода (вместо приостановки в отладчике) щелкните правой кнопкой мыши строку кода в приложении и выберите команду «Запустить в курсор» (или нажмите клавиши CTRL + F10). Эта команда запускает отладку и задает временную точку останова на текущей строке кода. Дополнительные сведения об этой функции и аналогичных функциях навигации см. в разделе Выполнение до определенного места в коде.
Если имеются заданные точки останова, отладчик приостанавливается в первой достигнутой точке останова.
Нажимайте клавишу F5, пока не достигнете строки кода, для которой выбрали Выполнить до текущей позиции.
Эта команда удобна, когда вы редактируете код и хотите быстро задать временную точку останова и одновременно запустить отладчик.
Вы можете использовать функцию Выполнить до текущей позиции в окне Стек вызовов во время отладки.
Быстрый перезапуск приложения
Нажмите кнопку «Перезапустить» на панели инструментов отладки (или нажмите клавиши CTRL+SHIFT+F5).
Кнопка Перезапустить позволяет сэкономить время, затрачиваемое на остановку приложения и перезапуск отладчика. Отладчик приостанавливается в первой точке останова, достигнутой при выполнении кода.
Если вы хотите остановить отладчик и вернуться в редактор кода, можно нажать красную кнопку остановки вместо перезапуска .
Редактирование кода в реальном времени
Visual Studio 2022 поддерживает динамическое редактирование кода в процессе отладки. Дополнительные сведения см. в следующих разделах.
- Создание и отладка выполняющегося кода
- Создание и отладка выполняющегося кода XAML с помощью Горячей перезагрузки XAML
- Изменить и продолжить
Изменение кода и продолжение отладки (C#, VB, C++, XAML)
В большинстве языков, поддерживаемых Visual Studio, можно изменять код во время сеанса отладки, а затем продолжать отладку. Для использования этой функции щелкните код, чтобы установить в нем курсор, когда отладчик приостановлен, внесите изменения и нажмите клавишу F5, F10 или F11, чтобы продолжить отладку. Дополнительные сведения об этой функции и ее ограничениях см. в статье Изменить и продолжить.
Сведения об изменении кода XAML во время сеанса отладки см. в статье Создание и отладка выполняющегося кода XAML с помощью горячей перезагрузки XAML.
Проверка переменных с помощью подсказок по данным
Теперь, когда вы немного освоились, у вас есть хорошая возможность проверить состояние приложения (переменные) с помощью отладчика. Функции, позволяющие проверять переменные, являются одними из самых полезных в отладчике. Реализовывать эту задачу можно разными способами. Часто при попытке выполнить отладку проблемы пользователь старается выяснить, хранятся ли в переменных значения, которые требуются в определенном состоянии приложения. Подробные сведения об использовании подсказок по данным см. в разделе Просмотр значений данных в подсказках по данным.
В режиме приостановки в отладчике наведите указатель мыши на объект, чтобы увидеть его текущее значение или значение по умолчанию.
Если переменная имеет свойства, объект можно развернуть, чтобы увидеть все его свойства.
Часто при отладке бывает необходимо быстро проверить значения свойств для объектов. Лучше всего для этого подходят подсказки по данным.
Проверка переменных с помощью окон «Видимые» и «Локальные»
В окне Видимые отображаются переменные вместе с текущим значением и типом. Окно Видимые показывает все переменные, используемые в текущей или предыдущей строке (в C++ это окно показывает переменные в трех предыдущих строках кода; сведения о поведении для конкретного языка см. в документации). Дополнительные сведения об использовании этих окон см. в статье Проверка переменных в окнах «Видимые» и «Локальные».
Во время отладки взгляните на окно Видимые в нижней части редактора кода.
В JavaScript окно Локальные поддерживается, а окно Видимые — нет.
Взгляните в окно Локальные. В окне Локальные показаны переменные, которые находятся в текущей области.
В этом примере объекты this и f находятся в области действия. Дополнительные сведения см. в статье Проверка переменных в окнах «Видимые» и «Локальные».
Установка контрольного значения
В окне Контрольное значение можно указать переменную (или выражение), которую необходимо отслеживать. Дополнительные сведения см. в статье Установка контрольных значений с помощью окон «Контрольное значение» и «Быстрая проверка».
Во время отладки щелкните правой объект кнопкой мыши и выберите пункт Добавить контрольное значение.
В этом примере у вас есть контрольное значение, заданное для объекта, и по мере перемещения по отладчику вы можете наблюдать за изменением его значения. В отличие от других окон переменных, в окне Контрольное значение всегда отображаются просматриваемые вами переменные (они выделяются серым цветом, когда находятся вне области действия).
Изучение стека вызовов
В окне Стек вызовов показан порядок вызова методов и функций. В верхней строке показана текущая функция. Во второй строке показана функция или свойство, из которого она вызывалась, и т. д. Стек вызовов хорошо подходит для изучения и анализа потока выполнения приложения. Дополнительные сведения см. в статье о просмотре стека вызовов.
Окно Стек вызовов аналогично перспективе «Отладка» в некоторых интегрированных средах разработки, например Eclipse.
Во время отладки щелкните окно Стек вызовов, которое по умолчанию открыто в нижней правой области.
Дважды щелкните строку кода, чтобы просмотреть исходный код. При этом также изменится текущая область, проверяемая отладчиком. Это не перемещает отладчик.
Для выполнения других задач можно воспользоваться контекстными меню из окна Стек вызовов. Например, можно вставлять точки останова в указанные функции, перезапускать приложение с помощью функции Выполнение до текущей позиции и изучать исходный код.
Проверка исключения
Когда приложение выдает исключение, отладчик переходит к строке кода, вызвавшей исключение. Подробные сведения см. в разделе Проверка исключения с помощью помощника по исправлению ошибок.
В этом примере Помощник по исправлению ошибок отображает исключение System.NullReferenceException и ошибку с сообщением о том, что для экземпляра объекта не задана ссылка на объект. Также он сообщает, что строковое значение имело значение NULL при попытке вызвать метод Trim .
В этом примере помощник по исправлению ошибок показывает исключение System.Argument и сообщение об ошибке, где сказано, что путь имеет недопустимую форму. Таким образом, мы знаем, что ошибка произошла в аргументе метода или функции.
В этом примере вызов DirectoryInfo выдал ошибку на пустой строке, хранящейся в переменной value .
Помощник по исправлению ошибок — это отличная функция, которая помогает отлаживать ошибки. Используя помощник по исправлению ошибок, вы также можете, например, просмотреть сведения об ошибке и добавить контрольное значение. При необходимости вы также можете изменить условия для возникновения конкретного исключения. См. дополнительные сведения об обработке исключений в коде в разделе Приемы и инструменты отладки.
Разверните узел Параметры исключений, чтобы просмотреть дополнительные параметры для обработки исключения этого типа, однако в рамках этого тура ничего менять не требуется.
Настройка отладки
Вы можете настроить проект для сборки, как описано в статье о конфигурации отладки или выпуска, настроить свойства проекта для отладки или настроить общие параметры для отладки. Кроме того, можно настроить отладчик для вывода пользовательских сведений с помощью таких компонентов, как атрибута DebuggerDisplay либо платформы NatVis для C/C++.
Свойства отладки зависят от типа проекта. Например, можно задать аргумент, который будет передан в приложение при запуске. Чтобы получить доступ к свойствам проекта приложения, щелкните имя проекта правой кнопкой мыши в обозревателе решений и выберите Свойства. Свойства отладки обычно отображаются на вкладке Сборка или Отладка в зависимости от типа проекта.
Начиная с Visual Studio 2022, вкладка Отладка для проектов .NET содержит ссылку на пользовательский интерфейс профилей запуска отладки, где можно задать свойства, связанные с отладкой.
Отладка интерактивных приложений ASP.NET в Службе приложений Azure
Сведения об отладке в службе приложение Azure см. в статье «Отладка приложений Azure».
Для Visual Studio Enterprise (только) отладчик моментальных снимков принимает моментальный снимок ваших рабочих приложений при выполнении кода. Чтобы указать отладчику на необходимость создать моментальный снимок, следует установить точки прикрепления и точки ведения в коде. Отладчик позволяет увидеть источник ошибки, не затрагивая трафик рабочего приложения. Средство Snapshot Debugger позволяет значительно сократить затраты времени на устранение проблем, возникающих в рабочих средах.
Коллекция моментальных снимков доступна для приложений ASP.NET, выполняющихся в Службе приложений Azure. Приложения ASP.NET должны выполняться на платформе .NET Framework 4.6.1 или более поздней версии, а приложения ASP.NET Core должны выполняться на платформе .NET Core 2.0 или более поздней версии в Windows.
Просмотр моментальных снимков с помощью возврата на шаг назад в IntelliTrace (Visual Studio Enterprise)
Функция возврата на шаг назад в IntelliTrace автоматически создает моментальный снимок вашего приложения для каждого события точки останова и шага отладчика. Используя записанные моментальные снимки, вы можете возвращаться к этим точкам останова и шагам, просматривая предыдущее состояние приложения. Возможность возврата на шаг назад в IntelliTrace позволяет сэкономить время в тех случаях, когда вам нужно просмотреть предыдущее состояние приложения, но не требуется перезапускать отладку или воссоздавать необходимое состояние приложения.
Для просмотра моментальных снимков и перехода между ними используйте кнопки На шаг назад и На шаг вперед на панели инструментов отладки. С помощью этих кнопок можно перейти к событиям, которые отображаются на вкладке События в окне Средства диагностики.
Отладка проблем производительности
Если приложение работает слишком медленно или использует слишком много памяти, возможно, вам следует протестировать его с помощью средств профилирования на раннем этапе. Дополнительные сведения о средствах профилирования, таких как средство загрузки ЦП и анализатор памяти, см. в разделе Знакомство со средствами профилирования.
Связанный контент
В этом руководстве вы кратко познакомились с функциями отладчика. Отдельные функции, например точки останова, вы можете изучить более подробно.
Use breakpoints in the Visual Studio debugger (Использование точек останова в отладчике Visual Studio)
Отладка в браузере
Давайте отвлечёмся от написания кода и поговорим о его отладке.
Отладка – это процесс поиска и исправления ошибок в скрипте. Все современные браузеры и большинство других сред разработки поддерживают инструменты для отладки – специальный графический интерфейс, который сильно упрощает отладку. Он также позволяет по шагам отследить, что именно происходит в нашем коде.
Мы будем использовать браузер Chrome, так как у него достаточно возможностей, в большинстве других браузеров процесс будет схожим.
Панель «Исходный код» («Sources»)
Версия Chrome, установленная у вас, может выглядеть немного иначе, однако принципиальных отличий не будет.
- Работая в Chrome, откройте тестовую страницу.
- Включите инструменты разработчика, нажав F12 (Mac: Cmd + Opt + I ).
- Щёлкните по панели Sources («исходный код»).
При первом запуске получаем следующее:
Кнопка-переключатель откроет вкладку со списком файлов.
Кликните на неё и выберите hello.js в дереве файлов. Вот что появится:
Интерфейс состоит из трёх зон:
- В зоне File Navigator (панель для навигации файлов) показаны файлы HTML, JavaScript, CSS, включая изображения, используемые на странице. Здесь также могут быть файлы различных расширений Chrome.
- Зона Code Editor (редактор кода) показывает исходный код.
- Наконец, зона JavaScript Debugging (панель отладки JavaScript) отведена для отладки, скоро мы к ней вернёмся.
Чтобы скрыть список ресурсов и освободить экранное место для исходного кода, щёлкните по тому же переключателю .
Консоль
При нажатии на клавишу Esc в нижней части экрана вызывается консоль, где можно вводить команды и выполнять их клавишей Enter .
Результат выполнения инструкций сразу же отображается в консоли.
Например, результатом 1+2 будет 3 , а вызов функции hello(«debugger») ничего не возвращает, так что результатом будет undefined :
Точки останова (breakpoints)
Давайте разберёмся, как работает код нашей тестовой страницы. В файле hello.js щёлкните на номере строки 4 . Да-да, щёлкайте именно по самой цифре, не по коду.
Ура! Вы поставили точку останова. А теперь щёлкните по цифре 8 на восьмой линии.
Вот что в итоге должно получиться (синим это те места, по которым вы должны щёлкнуть):
Точка останова – это участок кода, где отладчик автоматически приостановит исполнение JavaScript.
Пока исполнение поставлено «на паузу», мы можем просмотреть текущие значения переменных, выполнить команды в консоли, другими словами, выполнить отладку кода.
В правой части графического интерфейса мы видим список точек останова. А когда таких точек выставлено много, да ещё и в разных файлах, этот список поможет эффективно ими управлять:
- Быстро перейдите к точке останова в коде (нажав на неё на правой панели).
- Временно отключите точку останова, сняв с неё галочку.
- Удалите точку останова, щёлкнув правой кнопкой мыши и выбрав Remove (Удалить).
- …и так далее.
Условные точки останова
Щелчок правой кнопкой мыши по номеру строки позволяет создать условную точку останова. Она сработает только в тот момент, когда выражение, которое вы должны указать при создании такой точки, истинно.
Это удобно, когда нам нужно остановиться только при определённом значении переменной или для определённых параметров функции.
Команда debugger
Выполнение кода можно также приостановить с помощью команды debugger прямо изнутри самого кода:
function hello(name) < let phrase = `Привет, $!`; debugger; //
Такая команда сработает только если открыты инструменты разработки, иначе браузер ее проигнорирует.
Остановимся и оглядимся
В нашем примере функция hello() вызывается во время загрузки страницы, поэтому для начала отладки (после того, как мы поставили точки останова) проще всего её перезагрузить. Нажмите F5 (Windows, Linux) или Cmd + R (Mac).
Выполнение прервётся на четвёртой строчке (где находится точка останова):
Чтобы понять, что происходит в коде, щёлкните по стрелочкам справа:
- Watch – показывает текущие значения для любых выражений. Вы можете нажать на + и ввести выражение. Отладчик покажет его значение, автоматически пересчитывая его в процессе выполнения.
- Call Stack – показывает цепочку вложенных вызовов. В текущий момент отладчик находится внутри вызова hello() , вызываемого скриптом в index.html (там нет функции, поэтому она называется “анонимной”). Если вы нажмёте на элемент стека (например, «anonymous»), отладчик перейдёт к соответствующему коду, и нам представляется возможность его проанализировать.
- Scope показывает текущие переменные. Local показывает локальные переменные функций, а их значения подсвечены прямо в исходном коде. В Global перечисляются глобальные переменные (то есть вне каких-либо функций). Там также есть ключевое слово this , которое мы ещё не изучали, но скоро изучим.
Пошаговое выполнение скрипта
А теперь давайте пошагаем по нашему скрипту.
Для этого есть кнопки в верхней части правой панели. Давайте рассмотрим их.
– «Resume»: продолжить выполнение, быстрая клавиша F8 .
Возобновляет выполнение кода. Если больше нет точек останова, то выполнение просто продолжается, без контроля отладчиком.
Вот, что мы увидим, кликнув на неё:
Выполнение кода возобновилось, дошло до другой точки останова внутри say() , и отладчик снова приостановил выполнение. Обратите внимание на пункт «Call stack» справа: в списке появился ещё один вызов. Сейчас мы внутри say() .
– «Step»: выполнить следующую команду, быстрая клавиша F9 .
Выполняет следующую инструкцию. Если мы нажмём на неё сейчас, появится alert .
Нажатие на эту кнопку снова и снова приведёт к пошаговому выполнению всех инструкций скрипта одного за другим.
– «Step over»: выполнить следующую команду, но не заходя внутрь функции, быстрая клавиша F10 .
Работает аналогично предыдущей команде «Step», но ведёт себя по-другому, если следующая инструкция является вызовом функции (имеется ввиду: не встроенная, как alert , а объявленная нами функция).
Если сравнить, то команда «Step» переходит во вложенный вызов функцию и приостанавливает выполнение в первой строке, в то время как «Step over» выполняет вызов вложенной функции незаметно для нас, пропуская её внутренний код.
Затем выполнение приостанавливается сразу после вызова функции.
Это хорошо, если нам не интересно видеть, что происходит внутри вызова функции.
– «Step into», быстрая клавиша F11 .
Это похоже на «Step», но ведёт себя по-другому в случае асинхронных вызовов функций. Если вы только начинаете изучать JavaScript, то можете не обращать внимания на разницу, так как у нас ещё нет асинхронных вызовов.
На будущее просто помните, что команда «Step» игнорирует асинхронные действия, такие как setTimeout (вызов функции по расписанию), которые выполняются позже. «Step into» входит в их код, ожидая их, если это необходимо. См. DevTools manual для получения более подробной информации.
– «Step out»: продолжить выполнение до завершения текущей функции, быстрая клавиша Shift + F11 .
Продолжает выполнение и останавливает его в самой последней строке текущей функции. Это удобно, когда мы случайно вошли во вложенный вызов, используя , но это нас не интересует, и мы хотим продолжить его до конца как можно скорее.
– активировать/деактивировать все точки останова(breakpoints).
Эта кнопка не влияет на выполнение кода, она лишь позволяет массово включить/отключить точки останова.
– включить/отключить автоматическую паузу в случае ошибки.
При включении, если открыты инструменты разработчика, ошибка при выполнении скрипта автоматически приостанавливает его. Затем мы можем проанализировать переменные в отладчике, чтобы понять, что пошло не так. Поэтому, если наш скрипт умирает с ошибкой, мы можем открыть отладчик, включить эту опцию и перезагрузить страницу, чтобы увидеть, где он умирает и каков контекст в этот момент.
Continue to here
Щелчок правой кнопкой мыши по строке кода открывает контекстное меню с отличной опцией под названием «Continue to here» («продолжить до этого места»).
Это удобно, когда мы хотим перейти на несколько шагов вперёд к строке, но лень устанавливать точку останова (breakpoint).
Логирование
Чтобы вывести что-то на консоль из нашего кода, существует функция console.log .
Например, это выводит в консоль значения от 0 до 4 :
Отладка для абсолютных начинающих
Независимо от обстоятельств код, создаваемый разработчиками программного обеспечения, далеко не всегда работает так, как задумано. В некоторых случаях все идет совершенно не по плану! Когда происходит непредвиденное, следующая задача заключается в том, чтобы выяснить, почему, и хотя мы можем просто заманчиво просто следить за нашим кодом в течение нескольких часов, проще и эффективнее использовать средство отладки или отладчик.
К сожалению, отладчик не является той волшебной палочкой, по мановению которой будут выявлены абсолютно все проблемы в коде. Процесс отладки подразумевает пошаговое выполнение кода в средстве отладки (например, в Visual Studio) в поисках точки, в которой вы допустили ошибку при написании программы. Таким образом вы узнаете, какие исправления нужно внести в код. При этом средства отладки часто позволяют вносить временные изменения, чтобы продолжить работу с программой.
Эффективное использование отладчика также требует определенных навыков, которые вырабатываются только с практикой, однако умение работать с ним является основополагающим требованием к любому разработчику программного обеспечения. В этой статье мы представим основные принципы отладки и некоторые начальные рекомендации.
Проанализируйте проблему, задавая себе правильные вопросы
Это поможет вам выяснить, в чем состоит проблема, прежде чем приступать к ее решению. Мы полагаем, что вы уже сталкивались с проблемами в коде, иначе вряд ли читали бы сейчас эту статью в поисках советов по его отладке! Итак, прежде чем начать отладку, проанализируйте проблему, которую вы пытаетесь решить:
- Что именно должен был выполнить код?
- Что произошло на самом деле? Если при запуске приложения возникает ошибка (исключение), это может быть хорошо! Исключение возникает в том случае, если при выполнении кода происходит непредвиденное событие (как правило, это ошибка какого-либо рода). С помощью средства отладки вы можете перейти точно к тому месту в коде, где возникло исключение, и исследовать возможные способы исправления ситуации. Если произошло что-то еще, каковы признаки проблемы? Есть ли у вас предположения относительно того, в каком месте кода возникла проблема? Например, если код должен выводить какой-то текст, но при этом текст содержит ошибки, вы можете сделать вывод, что в этом случае используются неверные данные или код вывода текста содержит ошибки другого рода. При пошаговом выполнении кода в отладчике вы можете изучить каждое изменение переменных и точно определить, когда и каким образом были присвоены неверные значения.
Проверьте свои предположения
Прежде чем исследовать причины возникновения ошибки, проверьте предположения, на основании которых вы ожидаете тот или иной результат. Неявные или неизвестные вам предположения могут помешать выявлению проблемы, даже если вы прямо смотрите на ее причину в отладчике. У вас может быть длинный список возможных предположений! Чтобы проверить их, задайте себе несколько вопросов.
- Используете ли вы нужный API (то есть соответствующие объект, функцию, метод или свойство)? Возможно, используемый вами API работает не так, как вы ожидаете. (После проверки вызова API в отладчике исправление может потребовать поездки в документацию, чтобы определить правильный API.)
- Правильно ли вы используете API? Даже если вы выбрали нужный API, он может использоваться неправильно.
- Нет ли в вашем коде опечаток? Некоторые опечатки, например ошибки в написании имени переменной, могут быть незаметными, особенно при работе с языками, в которых не требуется объявление переменных перед их использованием.
- Вносили ли вы в код изменения, полагая, что они никак не связаны с возникшей проблемой?
- Должны ли объект или переменная содержать определенное значение (или определенный тип значения) и соответствует ли это действительности?
- Известно ли назначение кода? Отлаживать чужой код часто бывает сложнее. Если это не ваш код, возможно, для его эффективной отладки вам потребуется изучить, что он делает.
Совет При написании кода начинайте с небольших и гарантированно работающих фрагментов! (Хороший пример кода полезен здесь.) Иногда проще исправить большой или сложный набор кода, начиная с небольшого фрагмента кода, демонстрирующего основную задачу, которую вы пытаетесь достичь. Затем вы можете последовательно изменять или добавлять код в поисках точки возникновения ошибки.
Подспрошив предположения, вы можете сократить время, необходимое для поиска проблемы в коде. Вы также можете сократить время, необходимое для устранения проблемы.
Используйте режим пошагового выполнения во время отладки для поиска места возникновения проблемы.
Очевидно, что ошибки и неверные результаты можно увидеть только после выполнения кода приложения. Кроме того, работа программы может завершиться неожиданно без каких-либо сообщений.
При запуске приложения в отладчике, который также называется режимом отладки, отладчик активно отслеживает все, что происходит при запуске программы. Кроме того, вы можете в любой точке приостановить работу приложения, исследовать его состояние и пошагово выполнять код в каждой строке, чтобы видеть в деталях, что происходит.
В Visual Studio введите режим отладки с помощью F5 (или > команды меню "Запуск отладки" или кнопки "Начать отладку" на панели инструментов отладки). Если возникает исключение, помощник по исправлению ошибок Visual Studio направит вас к точке его появления и предоставит другую необходимую информацию. См. дополнительные сведения об обработке исключений в коде в разделе Приемы и инструменты отладки.
Если исключение не возникает, возможно, вы имеете некоторое представление о том, где искать проблему в коде. Этот шаг заключается в том, что вы используете точки останова с отладчиком, чтобы дать себе возможность тщательно изучить код. Точки останова — это самая основная и важная функция надежной отладки. Точка останова указывает, в каком месте Visual Studio следует приостановить выполнение, чтобы вы могли проверить значения переменных, работу памяти или последовательность выполнения кода.
Чтобы задать точку останова в Visual Studio, достаточно щелкнуть в левом поле рядом с интересующей вас строкой кода. Также для этого можно поместить указатель мыши в нужную строку и нажать клавишу F9.
Чтобы продемонстрировать это, мы рассмотрим пример кода, который уже содержит несколько ошибок. Здесь мы используем C#, однако функции отладки также применяются для Visual Basic, C++, JavaScript, Python и других поддерживаемых языков. Также предоставлен пример кода для Visual Basic, но снимки экрана приведены для C#.
Создание образца приложения с ошибками
Затем вы создадите приложение с несколькими ошибками.
- Необходимо установить Visual Studio и рабочую нагрузку разработки для классических приложений .NET. Установите Visual Studio бесплатно со страницы скачиваемых материалов Visual Studio, если еще не сделали этого. Если необходимо установить рабочую нагрузку, но у вас уже есть Visual Studio, выберите "Сервис >получения инструментов" и "Компоненты". Запускается Visual Studio Installer. Выберите рабочую нагрузку Разработка классических приложений .NET и нажмите Изменить.
- Откройте Visual Studio. На начальном экране выберите Создать проект. Введите консоль в поле поиска, выберите C# или Visual Basic в качестве языка, а затем выберите консольное приложение для .NET. Нажмите кнопку Далее. Введите имя проекта, например ConsoleApp_FirstApp , и нажмите кнопку "Далее". Выберите рекомендуемую целевую платформу или .NET 8, а затем нажмите кнопку "Создать". Если вы не видите шаблон проекта консольного приложения для .NET, перейдите в раздел "Сервис >получения инструментов и функций", который открывает установщик Visual Studio. Выберите рабочую нагрузку Разработка классических приложений .NET и нажмите Изменить. Visual Studio создаст консольный проект и откроет его в Обозревателе решений в области справа.
- Откройте файл Program.cs (или Program.vb) и замените все его содержимое по умолчанию следующим кодом. (Сначала выберите вкладку для нужного языка: C# или Visual Basic.)
using System; using System.Collections.Generic; namespace ConsoleApp_FirstApp < class Program < static void Main(string[] args) < Console.WriteLine("Welcome to Galaxy News!"); IterateThroughList(); Console.ReadKey(); >private static void IterateThroughList() < var theGalaxies = new List< new Galaxy() < Name="Tadpole", MegaLightYears=400, GalaxyType=new GType('S')>, new Galaxy() < Name="Pinwheel", MegaLightYears=25, GalaxyType=new GType('S')>, new Galaxy() < Name="Cartwheel", MegaLightYears=500, GalaxyType=new GType('L')>, new Galaxy() < Name="Small Magellanic Cloud", MegaLightYears=.2, GalaxyType=new GType('I')>, new Galaxy() < Name="Andromeda", MegaLightYears=3, GalaxyType=new GType('S')>, new Galaxy() < Name="Maffei 1", MegaLightYears=11, GalaxyType=new GType('E')>>; foreach (Galaxy theGalaxy in theGalaxies) < Console.WriteLine(theGalaxy.Name + " " + theGalaxy.MegaLightYears + ", " + theGalaxy.GalaxyType); >// Expected Output: // Tadpole 400, Spiral // Pinwheel 25, Spiral // Cartwheel, 500, Lenticular // Small Magellanic Cloud .2, Irregular // Andromeda 3, Spiral // Maffei 1, 11, Elliptical > > public class Galaxy < public string Name < get; set; >public double MegaLightYears < get; set; >public object GalaxyType < get; set; >> public class GType < public GType(char type) < switch(type) < case 'S': MyGType = Type.Spiral; break; case 'E': MyGType = Type.Elliptical; break; case 'l': MyGType = Type.Irregular; break; case 'L': MyGType = Type.Lenticular; break; default: break; >> public object MyGType < get; set; >private enum Type < Spiral, Elliptical, Irregular, Lenticular>> > Imports System Imports System.Collections.Generic Namespace ConsoleApp_FirstApp Friend Class Program Public Shared Sub Main(ByVal args As String()) Console.WriteLine("Welcome to Galaxy News!") Call IterateThroughList() Console.ReadKey() End Sub Private Shared Sub IterateThroughList() Dim theGalaxies = New List(Of Galaxy) From < New Galaxy() With < .Name = "Tadpole", .MegaLightYears = 400, .GalaxyType = New GType("S"c) >, New Galaxy() With < .Name = "Pinwheel", .MegaLightYears = 25, .GalaxyType = New GType("S"c) >, New Galaxy() With < .Name = "Cartwheel", .MegaLightYears = 500, .GalaxyType = New GType("L"c) >, New Galaxy() With < .Name = "Small Magellanic Cloud", .MegaLightYears = 0.2, .GalaxyType = New GType("I"c) >, New Galaxy() With < .Name = "Andromeda", .MegaLightYears = 3, .GalaxyType = New GType("S"c) >, New Galaxy() With < .Name = "Maffei 1", .MegaLightYears = 11, .GalaxyType = New GType("E"c) >> For Each theGalaxy As Galaxy In theGalaxies Console.WriteLine(theGalaxy.Name & " " & theGalaxy.MegaLightYears & ", " & theGalaxy.GalaxyType) Next End Sub End Class Public Class Galaxy Public Property Name As String Public Property MegaLightYears As Double Public Property GalaxyType As Object End Class Public Class GType Shared Operator &(ByVal left As String, ByVal right As GType) As String Return New String(left & right.ToString()) End Operator Public Sub New(ByVal type As Char) Select Case type Case "S"c MyGType = GType.Type.Spiral Case "E"c MyGType = GType.Type.Elliptical Case "l"c MyGType = GType.Type.Irregular Case "L"c MyGType = GType.Type.Lenticular Case Else End Select End Sub Private _MyGType As String Public Property MyGType As Object Get Return _MyGType End Get Set(ByVal value As Object) _MyGType = value.ToString() End Set End Property Private Enum Type Spiral Elliptical Irregular Lenticular End Enum End Class End Namespace Этот код выводит список, содержащий название галактики, расстояние до нее, а также тип галактики. При отладке важно учитывать предназначение кода. Ниже показан формат одной строки из списка, который мы хотим отобразить в выводе:
название галактики, расстояние, тип галактики.
Выполнить приложение
Нажмите клавишу F5 или кнопку "Начать отладку" на панели инструментов отладки, расположенной над редактором кода.
По результатам запуска приложения отладчик не демонстрирует никаких исключений. Тем не менее данные, выводимые в окне консоли, не соответствуют ожиданиям. Вот что мы должны были увидеть:
Tadpole 400, Spiral Pinwheel 25, Spiral Cartwheel, 500, Lenticular Small Magellanic Cloud .2, Irregular Andromeda 3, Spiral Maffei 1, Elliptical Но вместо этого вы увидите следующие выходные данные:
Tadpole 400, ConsoleApp_FirstApp.GType Pinwheel 25, ConsoleApp_FirstApp.GType Cartwheel, 500, ConsoleApp_FirstApp.GType Small Magellanic Cloud .2, ConsoleApp_FirstApp.GType Andromeda 3, ConsoleApp_FirstApp.GType Maffei 1, 11, ConsoleApp_FirstApp.GType По выходным данным и коду мы видим, что GType — это имя класса, содержащего тип галактики. Но мы пытаемся отобразить сам тип (например, Spiral, то есть спиральная), а не имя класса!
Отладка приложения
- Пока приложение еще работает, вставьте точку останова. Щелкните правой кнопкой мыши рядом с Console.WriteLine методом, чтобы получить контекстное меню и выберите точку останова вставить точку > останова в всплывающем меню.
foreach (Galaxy theGalaxy in theGalaxies)
For Each theGalaxy As Galaxy In theGalaxies Console.WriteLine(theGalaxy.Name & " " & theGalaxy.MegaLightYears & ", " & theGalaxy.GalaxyType) Next В месте установки точки останова в левом поле появится красный круг.
При возникновении проблемы в выходных данных вы начинаете отладку, просматривая предыдущий код, который задает выходные данные в отладчике.
" на панели инструментов отладки (CTRL + SHIFT +F5). Выполнение приложения приостановится в заданной точке останова. Место приостановки отладчика будет выделено желтым цветом (при этом желтая строка кода еще не выполнена).
Изначально вы ожидаете, что в окно консоли будет выведено именно значение Spiral. Поэтому вы можете получить доступ к значению в этом коде при запуске приложения. В этом сценарии мы используем неверный API-интерфейс. Давайте посмотрим, можно ли исправить это при выполнении кода в отладчике.
Примечание. Для отладки кода примера Visual Basic пропустите следующие несколько шагов, пока не будет указано, как нажать кнопку "Перезапустить ".
public object GalaxyType
public GType GalaxyType
Tadpole 400, Spiral Pinwheel 25, Spiral Cartwheel, 500, Lenticular Small Magellanic Cloud .2, Andromeda 3, Spiral Maffei 1, Elliptical public GType(char type) Public Sub New(ByVal type As Char) Здесь задается тип галактики, поэтому нам необходимо изучить эту строку более пристально.
" на панели инструментов отладки (CTRL + SHIFT +F5), чтобы перезапустить. Отладчик приостановит работу в строке кода, где вы задали точку останова.
Взглянув на код, вы заметите опечатку в инструкции case 'l' . Оно должно иметь значение case 'I' .Итоги
Если вы сталкиваетесь с проблемой, воспользуйтесь отладчиком и командами пошагового выполнения, такими как F10 и F11, для поиска области кода, в которой возникают ошибки.
Если выявить проблемную область кода не удается, задайте точку останова в коде, который выполняется перед возникновением ошибки, после чего используйте команды пошагового выполнения, пока проблема не проявится. Также вы можете использовать точки трассировки для вывода сообщений в окно вывода. Анализируя сообщения, которые выводятся в окно или отсутствуют в нем, нередко можно изолировать область кода, где возникает проблема. Для дальнейшего сужения области поиска этот процесс может потребоваться повторить несколько раз.
Выявив проблемную область кода, используйте отладчик для ее детального анализа. Чтобы определить причину возникновения проблемы, проверьте код во время выполнения приложения в отладчике.
- Проверьте переменные и убедитесь, что они содержат значения того типа, который вы ожидаете. Если переменная содержит недопустимое значение, найдите, где оно было задано. Для этого может потребоваться перезапустить отладчик, проверить стек вызовов или выполнить одновременно оба этих действия.
- Проверьте, выполняет ли ваше приложение код, который вы ожидаете. (Так, в примере приложения должна была выполняться инструкция switch , задающая тип галактики Irregular, однако нужный код был пропущен из-за опечатки.)
Отладчик представляет собой эффективное средства для выявления ошибок. Средство отладки может искать ошибки вместо вас в том случае, если ему известно предназначение кода. Для этого вы должны указать предназначение. Этого можно добиться с помощью модульных тестов.
Следующие шаги
Из этой статьи вы узнали общие принципы отладки приложений. Теперь вы можете приступить к изучению других возможностей отладчика.
Как отлаживать маленькие программы
Пусть у вас есть небольшая программа, которая… не работает. Причем не просто как-то не работает, а у вас есть конкретный тест, конкретный пример, на котором она не работает. (Если у вас такого примера нет, то у меня есть отдельный текст про то, что делать в таком случае.) Как понять, что в программе не так, и как это исправить?
На самом деле, на эту тему есть знаменитый текст «How to debug small programs» и его русский перевод, но на мой взгляд рекомендации, приведенные там, — это излишнее усложнение, не нужное на самом деле в 90% действительно простых программ.
Итак, у вас есть тест, но вы не понимаете, почему программа на нем выдает не тот результат, который нужен. Ну, во-первых, по возможности уменьшите тест. Если в вашей задаче вводится какой-то массив или т.п., то не надо разбираться с программой на массиве длины 10. Попробуйте найти тест длины 3-4, на котором программа тоже не будет работать. Если вводится одно число, но дальше будет цикл до этого числа, то подберите число поменьше. И т.п.
Дальше есть несколько подходов.
Представьте себе, что вы компьютер
Основной, самый главный подход, когда программа действительно небольшая, строк 10-20 максимум, состоит в том, чтобы представить себя на месте компьютера и в уме выполнить программу. Возьмите листочек бумажки (или откройте «Блокнот»), выпишите на нем список переменных, которые есть в вашей программе, оставив у каждой переменной место, куда вы будете записывать их значения. Это будет оперативная память вашего компьютера. (В дальнейшем, когда вы освоитесь, бумажка вам не будет нужна, вы будете держать все нужные значения в уме, и все это выполнение будет происходить весьма быстро.)
Далее выполняйте программу пошагово, с самого начала (ну можете пропустить ввод данных, если вы в нем на 200% уверены). При каждом изменении значения каждой переменной выписывая измененное значение на бумажке. Самое важное тут — это подробно и тщательно делать именно то, что написано в программе. Забудьте (точнее лучше задвиньте на задний план) вашу задачу, забудьте, зачем вы писали этот код. Вы работаете за компьютер, компьютер ничего не знает про то, какая у вас задача, он просто тупо выполняет написанный код. Полезно тщательно проговаривать каждую выполняемую операцию. Не забывайте, что операции — это не только присваивания, это еще и все управляющие конструкции (if’ы, циклы и т.д.); не забывайте, что в циклах на каждой итерации выполняются действия, относящиеся собственно к циклу (проверка условия в while, увеличение индекса цикла в for). Все изменения переменных отражайте на бумажке, каждый раз, когда вам нужно значение какой-то переменной, сверяйтесь с бумажкой.
При этом надо где-то глубоко в уме все-таки помнить, какую задачу вы решаете, и какой код зачем написан, чтобы, как только реальное выполнение кода отойдет от того, что вы имели в виду, сразу это и заметить.
Пример. Задача «Переставить элементы в обратном порядке». Типичный код, который тут многие пишут, примерно такой:
# a - массив, который вы считали for i in range(len(a)): t = a[i] a[i] = a[len(a) - i] a[len(a) - i] = t Вы запускаете программу на тесте 1 2 3 , и она падает. Хорошо, давайте представим, что мы выполняем эту программу за компьютер. У нас есть массив a , в котором записано 1 2 3 (и это записано у нас на бумажке), и переменные i и t . Поехали.
Начинается цикл for , переменная i становится равна 0 (на бумажке рядом с именем переменной i пишем 0 ).
Команда t = a[i] . Чему у нас равно i ? Смотрим на бумажку, i равно 0 . Чему равно a[i] ? Смотрим на бумажку, a[i] это a[0] это 1 . Это значение записывается в t . Записываем на бумажке рядом с t единицу.
Команда a[i] = a[len(a)-i] . Чему у нас равно i ? Нулю. Чему равно len(a) ? Трем. Чему равно len(a)-i ? Трем. Чему равно a[3] ? Ой, выход за пределы массива (не забываем, что элементы в массиве нумеруются с нуля; полезно на бумажке под значениями элементов массива подписать их индексы).
Вот собственно мы нашли первую ошибку. Обратите внимание, что мы специально тщательно и подробно все проговаривали; если бы вы действовали поверхностно, то вы могли бы сразу сказать: « a[len(a)-i] — это последний элемент массива (ведь я именно для этого писал этот код), поэтому это просто 3 ». И вы не заметили бы ошибку. Именно поэтому и надо по максимуму забыть, что обозначает этот код, а вместо этого просто четко и подробно выполнять то, что написано, постоянно сверяясь с бумажкой.
Хорошо, давайте исправим ошибку, теперь код такой:
# a - массив, который вы считали for i in range(len(a)): t = a[i] a[i] = a[len(a) - i - 1] a[len(a) - i - 1] = t Запускаем программу — и она выдает 1 2 3 , т.е. как будто массив не изменился. Это все равно неправильно, поэтому поехали еще раз.
Начинается цикл for , переменная i становится равна 0 (на бумажке рядом с именем переменной i пишем 0 ).
Команда t = a[i] . Чему у нас равно i ? Смотрим на бумажку, i равно 0 . Чему равно a[i] ? Смотрим на бумажку, a[i] это a[0] это 1 . Это значение записывается в t . Записываем на бумажке рядом с t единицу.
Команда a[i] = a[len(a)-i-1] . Чему у нас равно i ? Нулю. Чему равно len(a) ? Трем. Чему равно len(a)-i-1 ? Двум. Чему равно a[2] ? Трем. Это значение записывается в a[i] . Что такое a[i] ? У нас i равно 0 , поэтому это нулевой элемент массива. Зачеркиваем единичку, которая записана на бумажке на нулевом месте в массиве, записываем туда 3.
Команда a[len(a) - i - 1] = t . Чему у нас равно t ? Единице. Что такое a[len(a) - i - 1] ? Выражение в квадратных скобках мы только что считали (но надо как минимум внимательно проверить, что выражение тут написано то же, а лучше пересчитать), поэтому это a[2] . Значит, в a[2] записываем 1. Зачеркиваем число 3, которое раньше было написано в a[2] , записываем туда 1.
Продолжаем. Итерация цикла закончилась, начинается новая итерация цикла. i становится равно 1 .
Продолжаем все делать так же тщательно и подробно. Я не буду дальше все это расписывать, но (особенно если вы еще не видите ошибки в коде выше) можете продолжить и все-таки найти ошибку.
Добавьте отладочный вывод
Второй полезный подход — добавить в программу вывод на экран промежуточных значений переменных в ключевых местах программы. Тут надо суметь понять, что такое «ключевые места» и какие переменные выводить. Обычно, например, если у вас в программе есть какие-то циклы, то полезно добавить вывод как минимум в конце каждой итерации, и выводить те переменные, которые меняются в цикле, в том числе для циклов for — переменную цикла. Если у вас сложная конструкция из if’ов, то добавить вывод внутрь каждого if’а, чтобы видеть, в какой именно if зашла программа. Если у вас несколько функций или тем более рекурсия, то добавить отладочный вывод типа «вошли в такую-то функцию» (зачастую с указанием параметров функции) и «вышли из такой-то функции». Если у вас просто сложные вычисления, длинная формула или несколько формул — то добавить вывод промежуточных результатов вычислений; возможно, для этого придется длинную формулу разбить на части (и это заодно сделает ее понятнее).
После этого запускаете программу на том тесте, на котором она не работает, смотрите на отладочный вывод, проверяете все значения и находите первое значение, которое неверно. Таким образом вы довольно хорошо локализуете проблему, вы будете знать, что ошибка, например, в вычислении той или иной переменной. Дальше уже действуйте по ситуации: если программа не очень сложная, то эта переменная меняется в одном-двух местах, и вы сразу можете посмотреть, как она считается и почему значение получается неправильным. Тем более что вы, наверное, вывели на экран не только значение этой переменной, но и значения других переменных, от которых она зависит, поэтому сразу можете подставить эти значения в формулу и проверить.
Если же программа более сложная, эта переменная меняется в нескольких местах, или вы вывели на экран недостаточно информации, чтобы легко расследовать проблему, то добавьте еще отладочного вывода, чтобы более подробно видеть, откуда взялось это значение. И повторите.
Может быть и другая причина проблемы — не неправильное значение переменной, а, например, заход не в тот if или слишком раннее или слишком позднее окончание цикла, и т.д. Но в любом случае, как только вы добавили отладочный вывод, вы стали намного лучше понимать, что происходит в программе, и вам будет намного легче найти ошибку.
Рассмотрим в качестве примера тот же код, который мы разбирали выше. Добавим в него отладочный вывод примерно такой:
# a - массив, который вы считали for i in range(len(a)): t = a[i] a[i] = a[len(a) - i - 1] a[len(a) - i - 1] = t print("i=", i, "a выполните-программу-пошагово-в-среде-разработки">Выполните программу пошагово в среде разработки
Многие среды разработки позволяют вам выполнить код пошагово. По сути, это аналог первого указанного выше способа, но всю работу за вас делает компьютер, вам остается только многократно нажимать на одну и ту же кнопку. Это, безусловно, полезный во многих случаях способ, но на самом деле не стоит им злоупотреблять. В частности, когда речь идет про действительно небольшую программу, то использование пошаговой отладки зачастую оказывается более сложным и долгим, чем отладка любым из описанных выше способов, особенно когда вы уже освоили выполнение программы в уме.
Поговорите с уточкой
Еще одна стандартная рекомендация — это взять резиновую уточку (ну на самом деле любую игрушку, или даже можно и без игрушки), и подробно по порядку объяснить ей, что делает ваша программа, что делает в ней каждая строчка и почему всё написано так, а не иначе.
Вот прямо так и говорите: мне надо переставить элементы массива в обратном порядке. Для этого мне надо взять первый элемент массива и поменять местами с последним, потом второй с предпоследним и так далее. Как я это пишу в программе? Мне надо менять много пар элементов, поэтому я делаю цикл for . В цикле for переменная i обозначает номер элемента, который я буду менять местами с симметричным. Она должна меняться от 0 до… и вот тут вы понимаете, где ошибка в программе.
Это весьма полезный прием, если вы сумеете его освоить. Ключевой момент, что тут надо делать — надо подробно и про каждый элемент кода объяснить, зачем вы это делаете и почему код написан именно так. В частности, в примере выше фраза «она должна меняться от 0 до…» возникла потому, что вы видите, что в коде написано range(len(a)) , значит, надо объяснить уточке, почему написано именно так.
Важно все тщательно и подробно проговаривать; точно так же, как и при выполнении программы в уме вы должны последовательно выполнять все действия, а не «срезать углы» словами «а, это будет последний элемент массива», так и здесь не надо «срезать углы», пропуская объяснения тех или иных моментов и полагая, что они понятны и очевидны.
Помимо собственно поиска ошибок, метод уточки еще помогает вам обнаружить и осознать места в программе, которые вы не до конца понимаете, и самим в них подробнее разобраться (это близко и связано с поиском ошибок, но бывает полезно и в других ситуациях). Но про это и вообще про осознание кода я, пожалуй, напишу когда-нибудь еще один пост.
Мой курс по алгоритмическому программированию (и подготовке к олимпиадам) для школьников, студентов и всех желающих — algoprog.ru