Что такое код debugger_off

Содержание

Visual Studio Code Debugger — Что такое app.js?

Я создал проект AngularJS 1.4 с использованием генератора с угловым генератором.

Я бы хотел запустить этот режим отладки в Visual Studio Code. Тем не менее, большинство примеров файла launch.json, который я видел в Интернете, предлагают установить значение «program» в «app.js»,

но генератор Yeoman не создал файл с этим именем.

В какой файл я должен войти? Файл, в котором определены угловые модули? Файл с кодом маршрутизации?

Debugging

One of the key features of Visual Studio Code is its great debugging support. VS Code’s built-in debugger helps accelerate your edit, compile and debug loop.

Debugger extensions

VS Code has built-in debugging support for the Node.js runtime and can debug JavaScript, TypeScript, or any other language that gets transpiled to JavaScript.

For debugging other languages and runtimes (including PHP, Ruby, Go, C#, Python, C++, PowerShell and many others), look for Debuggers extensions in our VS Code Marketplace or select Install Additional Debuggers in the top-level Debug menu.

Below are several popular extensions which include debugging support:

Tip: The extensions shown above are dynamically queried. Select an extension tile above to read the description and reviews to decide which extension is best for you.

Start debugging

The following documentation is based on the built-in Node.js debugger, but most of the concepts and features are applicable to other debuggers as well.

It is helpful to first create a sample Node.js application before reading about debugging. You can follow the Node.js walkthrough to install Node.js and create a simple «Hello World» JavaScript application ( app.js ). Once you have a simple application set up, this page will take you through VS Code debugging features.

Debug view

To bring up the Debug view, select the Debug icon in the Activity Bar on the s > ⇧⌘D (Windows, Linux Ctrl+Shift+D ) .

The Debug view displays all information related to debugging and has a top bar with debugging commands and configuration settings.

Debug menu

The top-level Debug menu has the most common debug commands:

Launch configurations

To debug a simple app in VS Code, press F5 and VS Code will try to debug your currently active file.

However, for most debugging scenarios, creating a launch configuration file is beneficial because it allows you to configure and save debugging setup details. VS Code keeps debugging configuration information in a launch.json file located in a .vscode folder in your workspace (project root folder) or in your user settings or workspace settings.

To create a launch.json file, open your project folder in VS Code (File > Open Folder) and then select the Configure gear icon on the Debug view top bar.

VS Code will try to automatically detect your debug environment, but if this fails, you will have to choose it manually:

Here is the launch configuration generated for Node.js debugging:

If you go back to the File Explorer view ( ⇧⌘E (Windows, Linux Ctrl+Shift+E ) ), you’ll see that VS Code has created a .vscode folder and added the launch.json file to your workspace.

Note: You can debug a simple application even if you don’t have a folder open in VS Code, but it is not possible to manage launch configurations and set up advanced debugging. The VS Code Status Bar is purple if you do not have a folder open.

Note that the attributes available in launch configurations vary from debugger to debugger. You can use IntelliSense suggestions ( ⌃Space (Windows, Linux Ctrl+Space ) ) to find out which attributes exist for a specific debugger. Hover help is also available for all attributes.

Do not assume that an attribute that is available for one debugger automatically works for other debuggers too. If you see green squiggles in your launch configuration, hover over them to learn what the problem is and try to fix them before launching a debug session.

Review all automatically generated values and make sure that they make sense for your project and debugging environment.

Launch versus attach configurations

In VS Code, there are two core debugging modes, Launch and Attach, which handle two different workflows and segments of developers. Depending on your workflow, it can be confusing to know what type of configuration is appropriate for your project.

If you come from a browser Developer Tools background, you might not be used to «launching from your tool,» since your browser instance is already open. When you open DevTools, you are simply attaching DevTools to your open browser tab. On the other hand, if you come from a server or desktop background, it’s quite normal to have your editor launch your process for you, and your editor automatically attaches its debugger to the newly launched process.

The best way to explain the difference between launch and attach is to think of a launch configuration as a recipe for how to start your app in debug mode before VS Code attaches to it, while an attach configuration is a recipe for how to connect VS Code’s debugger to an app or process that’s already running.

VS Code debuggers typically support launching a program in debug mode or attaching to an already running program in debug mode. Depending on the request ( attach or launch ), different attributes are required, and VS Code’s launch.json validation and suggestions should help with that.

Add a new configuration

To add a new configuration to an existing launch.json , use one of the following techniques:

  • Use IntelliSense if your cursor is located inside the configurations array.
  • Press the Add Configuration button to invoke snippet IntelliSense at the start of the array.
  • Choose Add Configuration option in the Debug menu.

VS Code also supports compound launch configurations for starting multiple configurations at the same time; for more details, please read this section.

In order to start a debug session, first select the configuration named Launch Program using the Configuration drop-down in the Debug view. Once you have your launch configuration set, start your debug session with F5 .

Alternatively you can run your configuration through the Command Palette ( ⇧⌘P (Windows, Linux Ctrl+Shift+P ) ), by filtering on Debug: Select and Start Debugging or typing ‘debug ‘ , and selecting the configuration you want to debug.

As soon as a debugging session starts, the DEBUG CONSOLE panel is displayed and shows debugging output, and the Status Bar changes color (orange for default color themes):

In addition, the debug status appears in the Status Bar showing the active debug configuration. By selecting the debug status, a user can change the active launch configuration and start debugging without needing to open the Debug view.

Debug actions

Once a debug session starts, the Debug toolbar will appear on the top of the editor.

  • Continue / Pause F5
  • Step Over F10
  • Step Into F11
  • Step Out ⇧F11 (Windows, Linux Shift+F11 )
  • Restart ⇧⌘F5 (Windows, Linux Ctrl+Shift+F5 )
  • Stop ⇧F5 (Windows, Linux Shift+F5 )

Tip: Use the setting debug.toolBarLocation to control the location of the debug toolbar. It can either be the default floating , docked to the debug viewlet or hidden . A floating debug toolbar can be dragged horizontally and also down to the editor area.

Run mode

In addition to debugging a program, VS Code supports running the program. The Debug: Start Without Debugging action is triggered with ⌃F5 (Windows, Linux Ctrl+F5 ) and uses the currently selected launch configuration. Many of the launch configuration attributes are supported in ‘Run’ mode. VS Code maintains a debug session while the program is running, and pressing the Stop button terminates the program.

Tip: The Run action is always available, but not all debugger extensions support ‘Run’. In this case, ‘Run’ will be the same as ‘Debug’.

Breakpoints

Breakpoints can be toggled by clicking on the editor margin or using F9 on the current line. Finer breakpoint control (enable/disable/reapply) can be done in the Debug view’s BREAKPOINTS section.

  • Breakpoints in the editor margin are normally shown as red filled circles.
  • Disabled breakpoints have a filled gray circle.
  • When a debugging session starts, breakpoints that cannot be registered with the debugger change to a gray hollow circle. The same might happen if the source is edited while a debug session without live-edit support is running.

The Reapply All Breakpoints command sets all breakpoints again to their original location. This is helpful if your debug environment is «lazy» and «misplaces» breakpoints in source code that has not yet been executed.

Optionally breakpoints can be shown in the editor’s overview ruler by enabling the setting debug.showBreakpointsInOverviewRuler :

Logpoints

A Logpoint is a variant of a breakpoint that does not «break» into the debugger but instead logs a message to the console. Logpoints are especially useful for injecting logging while debugging production servers that cannot be paused or stopped.

A Logpoint is represented by a «diamond» shaped icon. Log messages are plain text but can include expressions to be evaluated within curly braces (‘<>‘).

Just like regular breakpoints, Logpoints can be enabled or disabled and can also be controlled by a condition and/or hit count.

Note: Logpoints are currently only supported by VS Code’s built-in Node.js debugger, but can be implemented by other debug extensions. The Python extension, for example, supports Logpoints.

Data inspection

Variables can be inspected in the VARIABLES section of the Debug view or by hovering over their source in the editor. Variable values and expression evaluation are relative to the selected stack frame in the CALL STACK section.

Variable values can be modified with the Set Value action from the variable’s context menu.

Variables and expressions can also be evaluated and watched in the Debug view’s WATCH section.

Variable names and values can be filtered by typing while the focus is on the VARIABLES section

Launch.json attributes

There are many launch.json attributes to help support different debuggers and debugging scenarios. As mentioned above, you can use IntelliSense ( ⌃Space (Windows, Linux Ctrl+Space ) ) to see the list of available attributes once you have specified a value for the type attribute.

The following attributes are mandatory for every launch configuration:

  • type — the type of debugger to use for this launch configuration. Every installed debug extension introduces a type: node for the built-in Node debugger, for example, or php and go for the PHP and Go extensions.
  • request — the request type of this launch configuration. Currently, launch and attach are supported.
  • name — the reader-friendly name to appear in the Debug launch configuration drop-down.

Here are some optional attributes available to all launch configurations:

  • preLaunchTask — to launch a task before the start of a debug session, set this attribute to the name of a task specified in tasks.json (in the workspace’s .vscode folder). Or, this can be set to $ to use your default build task.
  • postDebugTask — to launch a task at the very end of a debug session, set this attribute to the name of a task specified in tasks.json (in the workspace’s .vscode folder).
  • internalConsoleOptions — this attribute controls the visibility of the Debug Console panel during a debugging session.
  • debugServer — for debug extension authors only: this attribute allows you to connect to a specified port instead of launching the debug adapter.
  • serverReadyAction — if you want to open a URL in a web browser whenever the program under debugging outputs a specific message to the debug console or integrated terminal. For details see section Automatically open a URI when debugging a server program below.

Many debuggers support some of the following attributes:

  • program — executable or file to run when launching the debugger
  • args — arguments passed to the program to debug
  • env — environment variables (the value null can be used to «undefine» a variable)
  • cwd — current working directory for finding dependencies and other files
  • port — port when attaching to a running process
  • stopOnEntry — break immediately when the program launches
  • console — what kind of console to use, for example, internalConsole , integratedTerminal , or externalTerminal

Variable substitution

VS Code makes commonly used paths and other values available as variables and supports variable substitution inside strings in launch.json . This means that you do not have to use absolute paths in debug configurations. For example, $ gives the root path of a workspace folder, $ the file open in the active editor, and $ the environment variable ‘Name’. You can see a full list of predefined variables in the Variables Reference or by invoking IntelliSense inside the launch.json string attributes.

Platform-specific properties

Launch.json supports defining values (for example, arguments to be passed to the program) that depend on the operating system where the debugger is running. To do so, put a platform-specific literal into the launch.json file and specify the corresponding properties inside that literal.

Below is an example that passes «args» to the program differently on Windows:

Valid operating properties are «windows» for Windows, «linux» for Linux and «osx» for macOS. Properties defined in an operating system specific scope override properties defined in the global scope.

In the example below debugging the program always stops on entry except on macOS:

Global launch configuration

VS Code supports adding a «launch» object inside your User settings. This «launch» configuration will then be shared across your workspaces. For example:

Tip: If a workspace contains a «launch.json» , the global launch configuration is ignored.

Advanced breakpoint topics

Conditional breakpoints

A powerful VS Code debugging feature is the ability to set conditions based on expressions, hit counts, or a combination of both.

  • Expression condition: The breakpoint will be hit whenever the expression evaluates to true .
  • Hit count: The ‘hit count’ controls how many times a breakpoint needs to be hit before it will ‘break’ execution. Whether a ‘hit count’ is respected and the exact syntax of the expression vary among debugger extensions.

You can add a condition and/or hit count when creating the breakpoint (with the Add Conditional Breakpoint action) or when modifying an existing one (with the Edit Breakpoint action). In both cases, an inline text box with a drop-down menu opens where you can enter expressions:

If a debugger does not support conditional breakpoints, the Add Conditional Breakpoint action will be missing.

Inline breakpoints

Inline breakpoints will only be hit when the execution reaches the column associated with the inline breakpoint. This is particularly useful when debugging minified code which contains multiple statements in a single line.

An inline breakpoint can be set using ⇧F9 (Windows, Linux Shift+F9 ) or through the context menu during a debug session. Inline breakpoints are shown inline in the editor.

Inline breakpoints can also have conditions. Editing multiple breakpoints on a line is possible through the context menu in the editor’s left margin.

Function breakpoints

Instead of placing breakpoints directly in source code, a debugger can support creating breakpoints by specifying a function name. This is useful in situations where source is not available but a function name is known.

A function breakpoint is created by pressing the + button in the BREAKPOINTS section header and entering the function name. Function breakpoints are shown with a red triangle in the BREAKPOINTS section.

Data breakpoints

If a debugger supports data breakpoints they can be set from the VARIABLES view and will get hit when the value of the underlying variable changes. Data breakpoints are shown with a red hexagon in the BREAKPOINTS section.

Debug Console REPL

Expressions can be evaluated with the Debug Console REPL (Read-Eval-Print Loop) feature. To open the Debug Console, use the Debug Console action at the top of the Debug pane or use the View: Debug Console command ( ⇧⌘Y (Windows, Linux Ctrl+Shift+Y ) ). Expressions are evaluated after you press Enter and the Debug Console REPL shows suggestions as you type. If you need to enter multiple lines, use Shift+Enter between the lines and then send all lines for evaluation with Enter .

Note: You must be in a running debug session to use the Debug Console REPL.

Redirect input/output to/from the debug target

Redirecting input/output is debugger/runtime specific, so VS Code does not have a built-in solution that works for all debuggers.

Here are two approaches you might want to consider:

Launch the program to debug («debug target») manually in a terminal or command prompt and redirect input/output as needed. Make sure to pass the appropriate command line options to the debug target so that a debugger can attach to it. Create and run an «attach» debug configuration that attaches to the debug target.

If the debugger extension you are using can run the debug target in VS Code’s Integrated Terminal (or an external terminal), you can try to pass the shell redirect syntax (for example » «) as arguments.

Here’s an example launch.json configuration:

This approach requires that the » preLaunchTask can be specified that is run before the individual debug sessions are started.

Compound launch configurations are displayed in the launch configuration drop-down menu.

Remote debugging

VS Code does not itself support remote debugging: this is a feature of the debug extension you are using, and you should consult the extension’s page in the Marketplace for support and details.

There is, however, one exception: the Node.js debugger included in VS Code supports remote debugging. See the Node.js Debugging topic to learn how to configure this.

Automatically open a URI when debugging a server program

Developing a web program typically requires opening a specific URL in a web browser in order to hit the server code in the debugger. VS Code has a built-in feature «serverReadyAction» to automate this task.

Here is an example of a simple Node.js Express application:

This application first installs a «Hello World» handler for the «/» URL and then starts to listen for HTTP connections on port 3000. The port is announced in the Debug Console and typically the developer would now type http://localhost:3000 into their browser application.

The serverReadyAction feature makes it possible to add a structured property serverReadyAction to any launch config and select an «action» to be performed:

Here the pattern property describes the regular expression for matching the program’s output string that announces the port. The pattern for the port number is put into parenthesis so that it is available as a regular expression capture group. In this example, we are extracting only the port number, but it is also possible to extract a full URI.

The uriFormat property describes how the port number is turned into a URI. The first %s is substituted by the first capture group of the matching pattern.

The resulting URI is then opened outside of VS Code («externally») with the standard application configured for the URI’s scheme.

Alternatively, the action can be set to debugWithChrome . In this case, VS Code starts a Chrome debug session for the URI (which requires that the Debugger for Chrome extension is installed). In this mode, a webRoot property can be added that is passed to the Chrome debug session.

To simplify things a bit, most properties are optional and we use the following fallback values:

  • pattern: «listening on.* (https?://\\S+|[0-9]+)» which matches the commonly used messages «listening on port 3000» or «Now listening on: https://localhost:5001».
  • uriFormat: «http://localhost:%s»
  • webRoot: «$«

And here the serverReadyAction feature in action:

Next steps

To learn about VS Code’s Node.js debugging support, take a look at:

  • Node.js — Describes the Node.js debugger, which is included in VS Code.

To see tutorials on the basics of Node.js debugging, check out these videos:

  • Intro Video — Debugging — Showcases the basics of debugging.
  • Getting started with Node.js debugging — Shows how to attach a debugger to a running Node.js process.

To learn about VS Code’s task running support, go to:

  • Tasks — Describes how to run tasks with Gulp, Grunt and Jake, and how to show errors and warnings.

To write your own debugger extension, visit:

  • Debugger Extension — Uses a mock sample to illustrate the steps required to create a VS Code debug extension.

Дебаг в WordPress

В разработке нужно иметь возможность смотреть где ошибка, когда что-то вдруг сломалось. В WordPress для этого есть специальный режим «дебаг» (режим отладки). В этой заметке разберем его на части и посмотрим что это за константа такая WP_DEBUG.

Зачем нужен «дебаг режим»?

Допустим, вы изменили код файла functions.php темы и сайт перестал работать. Вместо него белый экран — ничего не понятно. «дебаг» поможет разобраться, он покажет ошибку и скажет в какой она строке какого файла.

«Дебаг» выводит не только ошибки, из-за которых сайт перестает работать, но и заметки. Заметки могут создаваться самим PHP (например, когда неправильно используется переменная) или кодом PHP скрипта (например, WP создает такие заметки, если сайт использует устаревшую функцию WordPress, или устаревший параметр функции).

Есть два варианта режима «дебаг»:

  1. Показ ошибок на экран — константа WP_DEBUG_DISPLAY .
  2. Запись ошибок в лог файл — константа WP_DEBUG_LOG .

Сам «дебаг» режим включается константой WP_DEBUG . Все три константы могут принимать значения true или false (1 или 0). Подробнее ниже.

По умолчанию константы дебага имеют такие значения:

Использует три константы:

  • WP_DEBUG = false
  • WP_DEBUG_DISPLAY = true
  • WP_DEBUG_LOG = false

Все это константы определяются ранней функцией wp_initial_constants() и могут быть определены в файле wp-config.php .

Функция wp_debug_mode() устанавливает настройки PHP на основе установленных констант.

WP_DEBUG_DISPLAY и WP_DEBUG_LOG активируются, только если включена константа WP_DEBUG .

Включение WP_DEBUG не изменяет значение других констант. Т.е. если выключить WP_DEBUG, то WP_DEBUG_DISPLAY и WP_DEBUG_LOG сохранят свои дефолтные значения и на основе этих значений будут выставлены PHP настройки показа и логирования ошибок.

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

Как включить показ ошибок в AJAX запроса сморите в заметках в статье про AJAX.

Рекомендуется использовать «дебаг режим» в процессе работы над сайтом (темой или плагином).

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

Как включить «дебаг» (показ ошибок в WordPress)

Откройте файл wp-config.php в корне сайта и измените false на true в строке:

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

Включение и настройка дебага

Код ниже, включит запись ошибок, предупреждений и заметок в файл wp-content/debug.log и выключит показ заметок и предупреждений на экране, чтобы они не мешались при просмотре сайта.

Вставлять этот код нужно в файл wp-config.php куда угодно, но до строки:

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

Динамическое включение показа ошибок

Этот код помогает быстро включать константу WP_DEBUG , которая на рабочем сайте должна быть выключена. Также код позволяет включить запись ошибок в файл debug.log в папку /wp-content и отключить показ ошибок на экране.

Зачем это надо? Допустим, мы сделали сайт и он работает, но мы периодически правим код. При правках конечно возникают разные ошибки, в том числе фатальные. Чтобы видеть в чем причина, нам нужно включить дебаг, для этого нужно открыть wp-config.php и изменить константу, по завершению работ надо вернуть все обратно. Это неудобно, удобнее включить дебаг через URL и увидеть ошибки когда это нужно.

Включение ошибок сохраняется в куку.

Чтобы все начало работать, замените строку define( WP_DEBUG, false ); в файле wp-config.php на такой код:

Теперь, чтобы включить режим WP_DEBUG , нужно добавить в любой URL параметр запроса debug : http://example.com/?debug или http://example.com/?debug=1 (принудительный вывод на экран, если такой вывод отключен) или http://example.com/?debug=2 (логирование в файл).

Для защиты, параметр debug рекомендую изменить, указать что-то редкое и известное только вам.

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

WP_DEBUG — это PHP константа (глобальная постоянная — определяется всего один раз). Значение этой постоянной включает или отключает показ ошибок в PHP, а также она используется в разных местах кода WordPress для показа или подавления ошибок, где это необходимо.

WP_DEBUG нужно определять (устанавливать) в файле wp-config.php из корня сайта.

Для удобности, можно писать числа 1 или 0:

Заметка: нельзя указывать false в кавычках — ‘false’ . В этом случае дебаг будет включен, потому что значение равно строке false, а не логическому — нет.

PHP ошибки, предупреждения и заметки (errors, warnings и notices)

В PHP есть разные уровни ошибок. Если не вдаваться в подробности, то уровни значимости такие:

  1. errors — серьезная ошибка, которая приводит к остановке скрипта. PHP прерывает работу.
  2. warnings — не ошибка, а предупреждение о чем-либо. PHP не прерывает работу.
  3. notices — не ошибка, а заметка о чем-либо. PHP не прерывает работу. Заметки могут показать возможные баги в коде. Их исправление, как правило, делает код более стабильным.

«Режим дебаг» включает все уровни ошибок. Это не похоже на обычное поведение PHP, там обычно включены только ошибки уровня errors, а warnings и notices не отображаются. Подробнее читайте в описании error_reporting().

Устаревшие функции, хуки и устаревшие параметры функций

WP_DEBUG также включает внутренние заметки самого WordPress. В WordPress есть специальные функции вроде _deprecated_function(), которые показывают ошибку уровня notices, когда используется устаревшая функция или хук или параметр хука, функции и т.д. Эти заметки предупреждают, что функция WP считается устаревшей и её нужно заменить, потому что она в любой момент может быть удалена. В таких заметках чаще всего предлагается альтернативная функция для замены.

По умолчанию: true .

Еще один компонент WP_DEBUG , который контролирует вывод (показ) ошибок на экран.

ВАЖНО! Зависит от WP_DEBUG — логика этого параметра работает только, если дебаг включен — WP_DEBUG = true . В противном случае просто используется глобальное значение PHP опции display_errors .

Если указать в wp-config.php :

  • define( ‘WP_DEBUG_DISPLAY’, true ) — (по умолчанию) WP будет выводить (показывать) ошибки на экран.
  • define( ‘WP_DEBUG_DISPLAY’, false ) — ошибки не будут выводиться на экран. Это нужно, когда ошибки записываются в файл (см. WP_DEBUG_LOG ) и их можно смотреть позднее.
  • define( ‘WP_DEBUG_DISPLAY’, null ) — WP вообще не будет указывать значение для PHP опции display_errors , т.е. будет использована глобальная настройка PHP (сервера).

Показ ошибок всегда отключается для REST, AJAX или XML-RPC запросов. Для них срабатывает такой код ini_set( ‘display_errors’, 0 ) , но при этом значение константы WP_DEBUG_DISPLAY не изменяется!

По умолчанию: false

Еще один компонент дебага. Включает запись ошибок в файл /wp-content/debug.log . Зависит от WP_DEBUG — работает только если WP_DEBUG равен true.

Запись ошибок в файл может пригодится, когда нужно проверить наличие ошибок в коде, который ничего не выводит на экран. Например, при AJAX запросе или при тестировании CRON или REST.

Изменение адреса файла лога ошибок

Через WP

C WordPress 5.1, в WP_DEBUG_LOG можно указать путь к файлу лога:

Через PHP

Чтобы изменить название файла, добавьте следующую строку как можно раньше, например в MU плагины:

Но эту строку нельзя добавлять в wp-config.php — это слишком рано.

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

меню

По умолчанию: не определена .

Связанная с дебагом константана. При включении, все SQL запросы будут сохраняться в переменную $wpdb->queries в виде массива. В этом массиве можно будет посмотреть все SQL запросы и при необходимости найти нужный и убедиться что он правильный и т.п.

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

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

По умолчанию: false .

Связанная с дебагом константа. Контролирует какие JS и CSS файлы использовать: сжатые или полные. При включении WordPress будет использовать не сжатые версии (dev версии) JS и CSS файлов. По умолчанию используются min версии файлов. Это нужно для тестирования при изменении встроенных js или css файлов.

Как работает WP_DEBUG?

После установки констант дебага в wp-config.php мы заходим на сайт. И при генерации страницы, в самом начале загрузки WordPress (см. wp-settings.php) срабатывает функция wp_debug_mode(). Она, используя функции PHP, устанавливает как и какие уровни ошибок показывать, нужно ли создавать лог файл и т.д.

Не работает WP_DEBUG?

Иногда может возникнуть такая ситуация, когда вы включаете WP_DEBUG в конфиге, а ошибки все равно не видно. Такое поведение может возникнуть, когда где-то после установок параметров показа ошибок самим WordPress эти установки меняются. Например в MU плагине, обычном плагине или в теме, ошибки выключаются переустановкой ini директив PHP, примерно таким кодом:

В этом случает установки дебага WP перебиваются и он перестает работать.

Для решения, лучше всего найти где изменяются настройки и удалить такие строки, чтобы дальше работать только с константой WP_DEBUG.

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

Плагины для дебага и профилирования в WordPress

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

Query Monitor — выводит в подвале кучу полезной информации о текущем запросе. Сколько времени затрачено, сколько SQL запросов, какие запросы, сколько времени занял каждый запрос, сколько памяти затрачено, какие хуки использовались и т.д.

Debug Bar — комплекс плагинов по дебагингу и профилированию. Это основной плагин, после его установки к нему можно подключать еще другие плагины, которые расширяют возможности профилирования. Но я его как-то не оценил.

Log Deprecated Notices — записывает в лог все заметки о наличии устаревших функций WordPress или их параметров и т.д. Не зависит от WP_DEBUG — работает с отключенным WP_DEBUG.

WordPress mu-plugin for debugging — альтернативный дебаггер на базе библиотеки Kint.

  • Clockwork для WordPress — выводит любую отладочную информацию в консоль браузера Google Chrome или Firefox, работает на основе браузерного расширения Clockwork, чтобы иметь возможность передавать данные с сервера на клиент. Есть возможность отладки AJAX-запросов.
  • debugger

    На этой странице

    Выражение debugger открывает доступ к любому доступному в конкретном окружении отладочному функционалу, например к установке точек останова (т.н. брейкпоинтов). Если функционал отладки в среде выполнения недоступен, данное выражение не будет иметь никакого эффекта.

    Синтаксис

    Примеры

    Следующий пример показывает код, содержащий выражение debugger. Это позволяет вызвать функционал отладки (если таковой может быть использован) при вызове функции.

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

    Debugging Ngen code

    You can debug ngen (aka prejitted) code from VS2005 and also have the VS2005 IDE launch ngenned code. In practice, images are rarely ngenned as debuggable. And usually when under a debugger, assemblies are loaded with debuggable code-gen flags (In VS, this is the default). Thus it’s rare to load ngenned images when under a debugger. But it can be done.

    The quick answer is:
    1. Disable the VSHosting process. See instructions here. It’s also disabled if you enable interop-debugging.
    2. Ensure the code is ngenned by running «ngen install». You can add it as a post-build step under «Project Properties : Build Events»:

    c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\ngen.exe install $(TargetPath)

    «Ngen install» is smart and will work for both Debug and Release configurations because it detects the debuggable attribute. Beware that edit-and-continue is not allowed on ngenned modules.

    First, read Reid Wilkes’s excellent article on Ngen in .NET 2.0 for key background info about ngen.

    When does a CLR load ngen images ?
    Once a managed module is going to be loaded:


    1. The CLR first uses policy (ini files, debugger overrides, debuggable attributes, etc) to determine what codegen flags to use. The interesting code-gen flags here are debuggable code vs. optimized code. (See here for one example of the difference).
    2. The CLR then looks for an ngenned version of the assembly in the global ngen cache with matching properties (timestamp, etc) including matching code-gen flags (which ngen calls «scenarios» in its command line help). If it finds a matching version, it uses that. Else it jits it.

    This means that you can certainly have ngenned debuggable code; and that there’s nothing that prevents you from trying to debug ngenned optimized code.

    How to get a debugger to load ngen code?

    At a high-level, you just need the CLR to load ngen images, per the rules above, when under a debugger. Pracitcally, this means ensuring that a) the images are actually ngenned, and b) the debugger is configured in a way to use the ngen configurations. Some practical ways to do this are:


    1. Attach with a debugger after the ngen code is loaded : Since the app is launched outside of the debugger, you gaurantee that the debugger does not perturb anything.
    2. ngen the assemblies with the code-gen flags that the debugger is using : Generally, this means ngen for debuggable code.
    3. change the debugger settings to use code-gen flags that match what’s in the ngen cache :

    VSHost complicates this with VS2005. The VS2005 IDE will pre-launch an executable called VSHost while you’re still editing, and then when actually hit F5 to start debugging, VS does an attach to the existing VSHost process, instead of doing a launch of the target. An easy way to disable VSHost is to follow the instructions here, or to enable interop-debugging.

    How to tell if the ngen image is loaded?
    ICorDebug does not tell you if a managed module is ngenned by-design because we wanted to treat ngen as a performance optimization that the CLR would be free to adjust in the future. For example, if we had ICDModule::IsNGenned, how would that version if the CLR started allowing part of the module became Ngenned? (This is similar as to why ICD doesn’t tell which thread is the finalizer). But there are some very reliable heuristics for whidbey:

    1) Look for «.ni» modules
    Look for a native module that matches the managed module name but ends in «.ni.dll» or «.ni.exe», such as «mscorlib.ni.dll». Managed-only debugging doesn’t show native modules. But you’ll see it if you’re interop-debugging. Or you can use a utility like listdlls.exe to view it.

    For example, the debugger may see that the managed mscorlib module comes from: «C:\WINDOWS\assembly\GAC_32\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll». But when you look at the native module list, you’ll see «c:\WINDOWS\assembly\NativeImages_v2.0.50727_32\mscorlib\634bc4cfaf50134f9bc49aedecf3b262\mscorlib.ni.dll».

    2) Look at the current IP
    Another way to tell if the currently executing code is ngenned is to actually compare the current IP against the native module list. If it’s ngenned code, then the code is running from a native module, and so the instruction pointer should be in the native module list. For example, I stopped in some managed code, pull up the registers window (Debug : Windows : Registers), and I can see:

    EAX = 30006530 EBX = 0012F4AC ECX = 01308F7C EDX = 00000000
    ESI = 00187060 EDI = 00000000 EIP = 300025E2 ESP = 0012F47C
    EBP = 0012F490 EFL = 00000212
    300078F0 = 022B1ED4

    The numbers are in hex. I then see that there’s an ngenned module «RedirectOutput.ni.exe» at address range 30000000-30012000. Since that includes the current IP, I know that I’m actually executing ngenned code.

    Rules about debugging and ngen :
    Here are some key ground rules:


    1. The mere presence of a debugger does not change code-gen flags at the API level. This was an explicit feature in .Net 2.0. (see here). However, debuggers (such as VS) may still choose to use ICorDebug to disable optimization when under a debugger.
    2. ICorDebug provides APIs to enable / disable optimizations. (ICorDebugProcess2::SetDesiredNGenCompilerFlags, ICorDebugModule::EnableJITDebugging, ICorDebugModule2::SetJitCompilerFlags)
    3. ICorDebug does not formally expose if a module is ngenned. Ngen is considered an internal CLR performance optimization from the debugger’s perspective.
    4. Code can be optimized / not-optimized on a per-module basis. See the «optimized» column in VS’s managed module window. A debugger can query for this based off ICorDebugModule2::GetJITCompilerFlags.

    Example 1 : Launch Debuggable ngenned code from VS IDE

    In my case, my app is called RedirectOuput.exe.

    1. Ensure that VS’s «enable optimizations» is not checked.
    2. Build the Debug configuration of the app from VS IDE like normal.
    3. After you build it from the VS IDE, use ‘ngen install’, which will ngen the app and the necessary dependencies.

    As noted above, you can do this manually, or you can add it as a post-build step under «Project Properties : Build Events»:

    c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\ngen.exe install $(TargetPath)

    Ideally, you’d have a macro for the full ngen path instead of explicitly listing it out. The output will be something like:

    C:\bug\RedirectOutput\RedirectOutput\bin\Debug> ngen install RedirectOutput.exe
    Microsoft (R) CLR Native Image Generator — Version 2.0.50727.42
    Copyright (C) Microsoft Corporation 1998-2002. All rights reserved.
    Installing assembly C:\bug\RedirectOutput\RedirectOutput\bin\Debug\RedirectOutput.exe
    Compiling 1 assembly:
    Compiling assembly C:\bug\RedirectOutput\RedirectOutput\bin\Debug\RedirectOutput.exe .
    RedirectOutput, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

    Note that ‘ngen install’ automatically used the flags, because it sees the debuggable attribute (the app was compiled with csc /debug+ because it was a debug configuration).

    Thus in VS’s module window while interop-debugging, you see:
























    Name Process Optimized Path
    1) RedirectOutput.exe [6128] RedirectOutput.exe: Managed No c:\bug\RedirectOutput\RedirectOutput\bin\Debug\RedirectOutput.exe
    2) RedirectOutput.exe [6128] RedirectOutput.exe: Native N/A C:\bug\RedirectOutput\RedirectOutput\bin\Debug\RedirectOutput.exe
    3) RedirectOutput.ni.exe [6128] RedirectOutput.exe: Native N/A C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\RedirectOutput\ad196335d9f0794fb468d46d9bbe711d\RedirectOutput.ni.exe

    Case 1 is the managed module for RedirectOutput.exe. This corresponds to an ICorDebugModule.
    Case 2 is the native module for RedirectOutput.exe, which shows up in the native module list because managed modules are generally implemented as native modules.
    Case 3 is the ngen version of the module. You’ll notice this has the «.ni» in the name, and shows up in the native module list.
    There’s no VShost entry because we’re interop-debugging.

    Example 2: Launch Optimized ngen code from the VS IDE
    Follow example 1, but switch the configuration to «Release». Everything should just work.

    Example 3: Use VS to launch an ngenned executable

    If you’ve already ngenned the exe, you can directly open up an exe from VS (File : Open : Project / Solution, and then select the exe) and launch it. This will let you launch the exe under VS without building it.

    Code::Blocks — почему не работает отладчик?

    Добрый всем вечер!

    Установил я коде блок но почему то не работает отладчик, не останавливается в точке останова и т.д. подскажите куда копать?

    23.12.2020, 16:49

    Не работает отладчик в Code::Blocks (неактивны пункты меню)
    Начну немного издалека. Я купил новый ноут и решил спустить черный флаг и начать использовать не.

    Почему не работает Дебаггер в Code::Blocks?
    Здравствуйте. Почему у меня уже на 2 проекте не работает Дебаггер? Программа просто выполняется как.

    Не работает компилятор Code Blocks
    Здравствуйте! Я перерыл не один форум пытаясь решить эту проблему. И, как мне кажется, тут я.

    Не работает автозаполнение в Code::Blocks
    Ребят помогите не работает автозаполнение в CODE :: BLOCKS при попытки ввода названия библиотеки.

    Code::Blocks Не работает GDB
    Не могу дебажить программу. Точки останова просто «проскакиваются». Вот что выдаёт GDB: > break.

    23.12.2020, 16:54 2 23.12.2020, 16:58 [ТС] 3 24.12.2020, 11:44 4
    24.12.2020, 11:44
    24.12.2020, 18:22 5
    26.12.2020, 09:51 [ТС] 6

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

    Название и версия отладчика GNU gdb (GDB) 7.6.1

    [debug]>>>>>>cb_gdb:
    [debug]> set width 0
    [debug]>>>>>>cb_gdb:
    [debug]> set height 0
    [debug]>>>>>>cb_gdb:
    [debug]> set breakpoint pending on
    [debug]>>>>>>cb_gdb:
    [debug]> set print asm-demangle on
    [debug]>>>>>>cb_gdb:
    [debug]> set unwindonsignal on
    [debug]>>>>>>cb_gdb:
    [debug]> set print elements 0
    [debug]>>>>>>cb_gdb:
    [debug]> set new-console on
    [debug]>>>>>>cb_gdb:
    [debug]> set disassembly-flavor att
    [debug]>>>>>>cb_gdb:
    [debug]> catch throw
    [debug]No symbol table is loaded. Use the «file» command.
    [debug]Catchpoint 1 (throw)
    [debug]>>>>>>cb_gdb:
    [debug]> source \\. \My Documents\cipp\codeblocks\share\codeblocks/scripts/stl-views-1.0.3.gdb
    [debug]>>>>>>cb_gdb:
    [debug]> directory «/My Documents/cipp/codeblocks/test1/»
    [debug]Source directories searched:My Documents/cipp/codeblocks/test1;$cdir;$cwd
    [debug]>>>>>>cb_gdb:
    [debug]> break «/. /My Documents/cipp/codeblocks/test1/main.cpp:26»
    [debug]No symbol table is loaded. Use the «file» command.
    [debug]Breakpoint 2 («. /My Documents/cipp/codeblocks/test1/main.cpp:26») pending.
    [debug]>>>>>>cb_gdb:
    [debug]> run
    [debug]No executable specified, use `target exec’.
    [debug]Starting program:
    [debug]>>>>>>cb_gdb:

    Starting the debuggee failed: No executable specified, use `target exec’.

    Жёлтый лист
    Сайт о мире Linux

    Один из самых частов вопросов как среди администраторов, так и среди пользователей UNIX — как отлаживать скрипты на bash?

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

    Метод #1 — использование опции -x

    Просто запустите скрипт с опцией -x. Например:

    Метод #2 — использование встроенного набора команд

    Вы можете включать и выключать режим отладки используя следующие команды внутри скрипта:

    set -x — Показывать командны и параметры, которые выполняются.

    set -v — Показывать строки по мере их чтения.

    Вы можете использовать их следующим образом:

    Так же для отладки вы можете заменить первую строчку скрипта на #!/bin/bash -xv.

    Метод #3 — Написать отладочную функцию DEBUG

    Добавьте переменную _DEBUG и присвойте ей значение on:

    Затем добавьте следующую функцию в ваш скрипт:

    Далее во всех местах где нужна отладка используйте примерно вот такой код:

    Или даже вот такой:

    Когда отладка скрипта будет закончена можно просто присвоить переменной _DEBUG значение off.

    Рассмотрим вот такой скрипт:

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

    Теперь установим значение переменной _DEBUG в off и попробуем ещё раз выполнить скрипт. В результате мы увидим следующее:

    То что вы видели — пример простой и эффективной отладки скрипта.

    Отладка кода в WordPress: Как использовать WP_DEBUG

    Каждый уважающий себя разработчик перед началом работы над темой или плагином запустит отладчик. Собственно, WordPress Codex настоятельно рекомендует разработчикам использовать режим WP_DEBUG при работе над кодом, который они собираются выпускать в мир.

    К сожалению, многие разработчики не следуют этому совету просто потому, что забывают о встроенных в WordPress инструментах отладки или просто не умеют с ними работать.

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

    Отладка с помощью WP_DEBUG

    Основное средство разработки, о котором вам нужно знать — WP_DEBUG .

    WP_DEBUG — это константа типа boolean , которая включает режим отладки в WordPress. Она находится в файле wp-config.php в вашей папке WordPress.

    Если ее значение установлено » true «, вы увидите извещения PHP на страницах сайта (не столько ошибки, сколько полезные для разработчиков сообщения и WordPress сообщения, в частности информация об устаревших функциях).

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

    Чтобы включить WP_DEBUG, просто добавьте следующий код в ваш файл wp-config.php :

    Чтобы отключить режим, просто замените » true » на » false «. Для WP_DEBUG по умолчанию установлено значение false . WP_DEBUG предоставляет удобный способ поиска решения проблем, если что-то с вашим сайтом пошло не так.

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

    Записи ошибок с помощью WP_DEBUG_LOG

    Другой удобный инструмент — WP_DEBUG_LOG , который может использоваться в сочетании с WP_DEBUG для сохранения всех ошибок в файл debug.log , размещенный в папке /wp-content/ вашего сайта.

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

    Чтобы включить запись логов отладки, просто добавьте в ваш файл wp-config.php следующий код:

    Выключение отображения ошибок на сайте с помощью WP_DEBUG_DISPLAY

    Если вы не хотите, чтобы ошибки отображались на вашем сайте, вы должны использовать WP_DEBUG_DISPLAY .

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

    По умолчанию установлено значение » true «, то есть все ошибки и предупреждения отображаются. Изменив значение на » false «, вы спрячете все ошибки.

    Эта константа должна быть использована в сочетании с WP_DEBUG_LOG .

    Чтобы использовать эту возможность, просто добавьте в код вашего файла wp-config.php следующую строку:

    Все вместе

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

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

    Источник: wpmudev.org

    Насколько полезным был этот пост?

    Нажмите на звезду, чтобы оценить этот пост!

    Средний рейтинг: 5 / 5. Количество голосов: 3

    Отладка Angular в VS Code

    Родной средой для Angular приложений является редактор Visual Studio Code. Наиболее распространенным браузером на сегодняший день является Google Chrome, поэтому речь именно об этой связке (VS Code + Chrome).

    Чтобы отлаживать код Angular, нужно установить расширение отладчика для Chrome.

    Открываем Расширения ( Ctrl+Shift+X ) и набираем ‘chrome` в строке поиска. Вы увидите несколько расширений, связанных с Chrome.

    Нажмите кнопку Установить напротив расширения Debugger for Chrome. Кнопка изменится на Идет установка, а после завершения установки, она изменится на Перезагрузка. Нажмите Перезагрузка, чтобы перезапустить VS Code и активировать расширение.

    Настройка отладчика Chrome

    Сначала нужно настроить отладчик самой среды VS Code. Для этого перейдите в представление «Отладка» (Ctrl+Shift+D) и нажмите кнопку «Шестерёнка», чтобы создать launch.json файл конфигурации отладчика. Выберите Chrome в раскрывающемся меню Выбор среды. Это создаст launch.json файл в .vscode папке вашего проекта, которая включает в себя конфигурацию для запуска веб-сайта.

    Единственное, что нужно сделать с этим файлом — изменить порт от с 8080 на 4200 . После этого launch.json должен выглядеть так:

    Установка breakpoint’ов и отладка

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

    Нажмите F5 , чтобы запустить отладчик и открыть новый экземпляр браузера. Исходный код, в котором установлен breakpoint запускается после присоединения отладчика, поэтому мы не поймаем breakpoint до тех пор, пока не обновим веб-страницу.

    Исходный код можно исследовать по F10 (Шаг с обходом), F11 (Шаг с заходом) и Shift+F11 (Шаг с выходом). Также доступны текущие переменные, стек вызовов и контрольные значения.

    Небольшой нюанс: отладчик не работает, если в браузере открыты инструменты разработчика ( F12 ).

    Отладка в Хcode

    Азы работы с LLDB для Swift

    Сегодня мы поговорим о LLDB — замечательном инструменте для отладки и тестирования ваших проектов.

    Поймай их всех

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

    Отладка в среде Xcode

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

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

    Немного о LLDB

    LLDB это кроссплатформенный, высокопроизводительный отладчик, написанный на C++. На текущий момент он поддерживает i386, x86 и ARM архитектуры и может работать под управлением Unix-like и Linux операционных систем. В Xcode LLDB появился начиная с версии 4.3, где и остался стандартным отладчиком по сегодняшний день.

    Виды ошибок

    Существует бесчисленное множество ошибок, которое мы можем допустить при написании программного кода. Что-бы упростить себе задачу, систематизируем это множество, разделив его на:

    • Ошибки компиляции
    • Ошибки исполнения
    • Ошибки логики

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

    • EXC_BAD_INSTRUCTION
    • SIGABRT
    • EXC_BAD_ACCESS

    Начнем по порядку, EXC_BAD_INSTRUCTION означает, что вашу программу остановил один из Assertion’ов стандартной библиотеки по соображениям безопасности, вы точно знакомы с этой ошибкой если пишите на Swift’е, что-бы ее воспроизвести достаточно развернуть пустой опционал там, где этого делать не следует.

    SIGABRT, если вы когда-нибудь слышали о POSIX, возможно вы уже знакомы с этим сигналом. Sigabrt говорит о невозможности дальнейшего выполнения программы. Обычно, в Cocoa такой сигнал будет говорить о необработанном исключении и может показаться, что это не сильно относится к Swift программистам, которые в добровольно-принудительном порядке обязаны написать обработчик для исключения, если надобность в таковом заявлена в сигнатуре словом throws, но стоит помнить, что необработанное исключение может прилететь к вам из Objective-C библиотеки, если вы в той или иной мере пользуетесь бриджингом.

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

    Для примера напишем пару строчек, чтобы воспроизвести все рассмотренные ошибки:

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

    Запускаем LLDB

    Итак, подключаем нашу «игровую площадку» к точке входа:

    Готово, можно начинать. Собираем проект, видим, что статический анализатор действительно молчит, значит наш код синтаксически и семантически валиден, давай-те запускаться:

    Это ожидаемое поведение, давай-те узнаем больше информации о том, что случилось с нашим потоком, введя команду bt в терминале:

    Нас интересует строчка stop reason = EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0), итак мы узнали причину остановки, сработал assertion. Если внимательно посмотреть на стэк, можно увидеть, что наша логика последний раз вызывалась во втором фрэйме, давайте ее детализируем, набрав команду f 2 в терминале:

    В этом месте мы и вылезаем за границы диапазона, давайте посмотрим чему в данный момент у нас равны индекс и размерность массива:

    Помня, что массивы в Swift индексируются начиная с нуля, подтверждаем свою гипотезу и исправляем нашу функцию, используя оператор полуоткрытого диапазона:

    Перед тем как вносить изменения в код, проверим нашу задумку на месте, не выходя из отладчика. Откроем read-eval-print loop, набрав repl в консоли:

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

    Заключение

    Сегодня мы рассмотрели несколько простых взаимодействий с LLDB, а так же обсудили возможные типы фатальных ошибок и причины их возникновения, оставив довольно много интересных и полезных вещей за рамками данной статьи, например работу с breakpoint’ами. Мы обязательно вернемся и рассмотрим их в следующих статьях.

    Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

    Илон Маск рекомендует:  Шаблон сайта дома HTML, CSS, 1 страница
    Понравилась статья? Поделиться с друзьями:
    Кодинг, CSS и SQL