Gulp Js Read File and Create New File

Node.js debugging in VS Code

The Visual Studio Code editor has congenital-in debugging support for the Node.js runtime and tin debug JavaScript, TypeScript, and many other languages that are transpiled into JavaScript. Setting up a projection for Node.js debugging is straightforward with VS Code providing appropriate launch configuration defaults and snippets.

There are a few ways you can debug your Node.js programs in VS Lawmaking:

• Use auto attach to debug processes you lot run in VS Lawmaking's integrated terminal.
• Use the JavaScript debug terminal, like to using the integrated last.
• Apply a launch config to start your program, or attach to a process launched outside of VS Lawmaking.

Auto Attach

If the Auto Attach feature is enabled, the Node debugger automatically attaches to certain Node.js processes that have been launched from VS Code's Integrated Final. To enable the feature, either use the Toggle Auto Adhere command from the Command Palette ( ⇧⌘P (Windows, Linux Ctrl+Shift+P)) or, if it's already activated, utilize the Machine Attach Status bar item.

At that place are three modes for auto attach, which y'all can select in the resulting Quick Pick and via the debug.javascript.autoAttachFilter setting:

• smart (default) - If you lot execute a script outside of your node_modules folder or use a mutual 'runner' script like mocha or ts-node, the process volition be debugged. You can configure the 'runner' script allow list using the Motorcar Attach Smart Pattern setting (debug.javascript.autoAttachSmartPattern).
• always - All Node.js processes launched in the Integrated Terminal will exist debugged.
• onlyWithFlag - Merely processes launched with the --inspect or --inspect-brk flag will exist debugged.

Subsequently enabling Motorcar Attach, you'll need to restart your last. This tin be done past clicking the ⚠ icon in the top right of the last, or only creating a new 1. Then, the debugger should attach to your program inside a 2nd:

When auto attach is on, the Motorcar Attach particular will appear in the status bar beyond the bottom of the VS Code window. Clicking it allows you to change the machine attach mode, or temporarily plow it off. Temporarily turning off motorcar attach is useful if you're running some one-off programs where you don't need debugging, only yous don't desire to disable the feature entirely.

Additional Configuration

Other Launch Configuration Properties

Y'all can apply other properties normally found in launch.json to auto attach in the debug.javascript.terminalOptions setting. For case, to add node internals to your skipFiles, you could add together the following to your user or workspace settings:

                                              "debug.javascript.terminalOptions"            : {                                    "skipFiles"            : [                                    "<node_internals>/**"                          ]                          },                  

Auto Adhere Smart Patterns

In smart Auto Adhere mode, VS Code will endeavor to adhere to your code, and not adhere to build tools you aren't interested in debugging. It does this past matching the master script against a list of glob patterns. The glob patterns are configurable in the debug.javascript.autoAttachSmartPattern setting, which defaults to:

                      [                                    '!**/node_modules/**'            ,                        // exclude scripts in node_modules folders                                    '**/$KNOWN_TOOLS$/**'                                    // just include some common tools            ];                  

$KNOWN_TOOLS$ is replaced list a list of common 'lawmaking runners' such as ts-node, mocha, ava, and and then on. You can modify this listing if these settings don't work. For example, to exclude mocha and include my-cool-examination-runner, you could add two lines:

                      [                                    '!**/node_modules/**'            ,                                    '**/$KNOWN_TOOLS$/**'            ,                                    '!**/node_modules/mocha/**'            ,                        // utilise "!" to exclude all scripts in "mocha" node modules                                    '**/node_modules/my-cool-test-runner/**'                                    // include scripts in the custom test runner            ];                  

JavaScript Debug Last

In a similar manner to auto attach, the JavaScript Debug Terminal will automatically debug whatsoever Node.js process you run in it. You tin create a Debug Terminal past running the Debug: Create JavaScript Debug Terminal command from the Control Palette (kbs(workbench.activity.showCommands)), or past selecting the Create JavaScript Debug Terminal from the terminal switcher dropdown.

Additional Configuration

Other Launch Configuration Properties

You can utilise other properties normally institute in launch.json to the debug terminal in the debug.javascript.terminalOptions setting. For example, to add node internals to your skipFiles, you could add the following to your user or workspace settings:

                      "debug.javascript.terminalOptions"            : {                                    "skipFiles"            : [                                    "<node_internals>/**"                          ]            },                  

Launch Configuration

Launch configs are the traditional way to set upwardly debugging in VS Code, and provide you the most configuration options for running circuitous applications.

In this section we'll go into more detail about configurations and features for more than advanced debugging scenarios. You lot'll find instruction for debugging with source maps, stepping over external code, doing remote debugging, and much more.

If you'd like to watch an introductory video, see Getting started with Node.js debugging.

Note: If y'all are just getting started with VS Lawmaking, you can learn about general debugging features and creating launch.json configuration files in the Debugging topic.

Launch configuration attributes

Debugging configurations are stored in a launch.json file located in your workspace's .vscode binder. An introduction into the cosmos and use of debugging configuration files is in the general Debugging article.

Below is a reference of common launch.json attributes specific to the Node.js debugger. You can view the complete set of options in the vscode-js-debug options documentation.

The following attributes are supported in launch configurations of type launch and adhere:

• outFiles - array of glob patterns for locating generated JavaScript files. See section Source maps.
• resolveSourceMapLocations - an array of glob patterns for locations where source maps should be parsed. See section Source maps.
• timeout - when restarting a session, give up after this number of milliseconds. Run across section Attaching to Node.js.
• stopOnEntry - break immediately when the programme launches.
• localRoot - VS Code's root directory. See section Remote debugging below.
• remoteRoot - Node'due south root directory. See department Remote debugging below.
• smartStep- try to automatically step over code that doesn't map to source files. See section Smart stepping.
• skipFiles - automatically skip files covered past these glob patterns. See section Skipping uninteresting code.
• trace - enable diagnostic output.

These attributes are only available for launch configurations of request type launch:

• program - an absolute path to the Node.js program to debug.
• args - arguments passed to the program to debug. This attribute is of type array and expects individual arguments as assortment elements.
• cwd - launch the programme to debug in this directory.
• runtimeExecutable - absolute path to the runtime executable to be used. Default is node. See section Launch configuration back up for 'npm' and other tools.
• runtimeArgs - optional arguments passed to the runtime executable.
• runtimeVersion - if "nvm" (or "nvm-windows") or "nvs" is used for managing Node.js versions, this attribute can be used to select a specific version of Node.js. See section Multi version support beneath.
• env - optional environs variables. This attribute expects surroundings variables equally a list of string typed key/value pairs.
• envFile - optional path to a file containing environment variable definitions. Come across section Load environment variables from external file below.
• console - the console to launch the program (internalConsole, integratedTerminal, externalTerminal). See section Node Console below.
• outputCapture - if gear up to std, output from the process stdout/stderr volition be shown in the Debug Console, instead of listening to output over the debug port. This is useful for programs or log libraries that write directly to the stdout/stderr streams instead of using console.* APIs.

This aspect is simply available for launch configurations of request type adhere:

• restart - restart the connexion on termination. See department Restarting debug session automatically.
• protocol - debug protocol to utilize. Run across section Supported Node-like runtimes above.
• port - debug port to utilise. Run into sections Attaching to Node.js and Remote debugging.
• address - TCP/IP accost of the debug port. See sections Attaching to Node.js and Remote debugging.
• processId - the debugger tries to adhere to this process after having sent a USR1 indicate. With this setting, the debugger tin can adhere to an already running process that was not started in debug mode. When using the processId attribute, the debug port is adamant automatically based on the Node.js version (and the used protocol) and cannot be configured explicitly. So don't specify a port attribute.
• continueOnAttach - whether to continue the process if it's paused when nosotros attach to it. This option is useful if you launch your program with --inspect-brk.

Launch configurations for common scenarios

You tin trigger IntelliSense ( ⌃Space (Windows, Linux Ctrl+Space)) in your launch.json file to come across launch configuration snippets for commonly used Node.js debugging scenarios.

Yous tin also bring up the snippets with the Add Configuration... button in the lower right of the launch.json editor window.

These are the bachelor snippets:

• Launch Program: Launch a Node.js plan in debug style.
• Launch via npm: Launch a Node.js program through an npm 'debug' script. If you have divers an npm debug script in your parcel.json, you can use it directly from your launch configuration. Brand sure that the debug port used in the npm script, corresponds to the port specified in the snippet.
• Attach: Adhere to the debug port of a locally running Node.js programme. Make sure that the Node.js programme to debug has been started in debug mode, and the debug port used is the same as the i specified in the snippet.
• Attach to Remote Program: Attach to the debug port of a Node.js plan running on the host specified by the address aspect. Brand sure that the Node.js plan to debug has been started in debug way, and the debug port used is the same as the i specified in the snippet. To aid VS Lawmaking map source files between your workspace and the filesystem of the remote host, make sure to specify right paths for the localRootand remoteRoot attributes.
• Attach by Process ID: Open up the process picker to select a node or gulp process for debugging. With this launch configuration, you tin fifty-fifty adhere to a node or gulp process that was not started in debug mode.
• Nodemon Setup: Use nodemon to relaunch a debug session automatically whenever the JavaScript source has changed. Make sure that you have nodemon installed globally. Note that terminating the debug session only terminates the program to debug, non nodemon itself. To end nodemon, printing Ctrl+C in the Integrated Terminal.
• Mocha Tests: Debug mocha tests in a examination binder of your project. Make certain that your project has 'mocha' installed in its node_modules folder.
• Yeoman generator: Debug a yeoman generator. The snippet asks you lot to specify the name of the generator. Brand sure that your projection has 'yo' installed in its node_modules folder and that your generated project has been installed for debugging by running npm link in the project folder.
• Gulp task: Debug a gulp task. Brand sure that your project has 'gulp' installed in its node_modules binder.
• Electron Chief: Debug the principal Node.js procedure of an Electron awarding. The snippet assumes that the Electron executable has been installed inside the node_modules/.bin directory of the workspace.

Node console

By default, Node.js debug sessions launch the target in the internal VS Code Debug Console. Since the Debug Console does not support programs that demand to read input from the console, you tin enable either an external terminal or use the VS Code Integrated Terminal by setting the panel attribute in your launch configuration to externalTerminal or integratedTerminal respectively. The default is internalConsole.

If an external terminal is used, yous can configure which terminal programme to employ via the terminal.external.windowsExec, terminal.external.osxExec, and terminal.external.linuxExec settings.

Launch configuration back up for 'npm' and other tools

Instead of launching the Node.js program directly with node, you can use 'npm' scripts or other task runner tools directly from a launch configuration:

• Any program available on the PATH (for example 'npm', 'mocha', 'gulp', etc.) can exist used for the runtimeExecutable attribute and arguments can be passed via runtimeArgs.
• You lot do not have to gear up the program attribute if your npm script or other tool implicitly specifies the program to launch.

Let's expect at an 'npm' case. If your packet.json has a 'debug' script, for case:

                                              "scripts"            : {                                    "debug"            :                        "node myProgram.js"                          },                  

the corresponding launch configuration would look like this:

                      {                                    "name"            :                        "Launch via npm"            ,                                    "type"            :                        "node"            ,                                    "request"            :                        "launch"            ,                                    "cwd"            :                        "${workspaceFolder}"            ,                                    "runtimeExecutable"            :                        "npm"            ,                                    "runtimeArgs"            : [            "run-script"            ,                        "debug"            ]            }                  

Multi version back up

If you are using 'nvm' (or 'nvm-windows') to manage your Node.js versions, it is possible to specify a runtimeVersion aspect in a launch configuration for selecting a specific version of Node.js:

                      {                                    "blazon"            :                        "node"            ,                                    "asking"            :                        "launch"            ,                                    "name"            :                        "Launch test"            ,                                    "runtimeVersion"            :                        "xiv"            ,                                    "programme"            :                        "${workspaceFolder}/exam.js"            }                  

If you are using 'nvs' to manage your Node.js versions, it is possible to use runtimeVersion attribute to select a specific version, architecture, and flavor Node.js, for example:

                      {                                    "type"            :                        "node"            ,                                    "request"            :                        "launch"            ,                                    "name"            :                        "Launch test"            ,                                    "runtimeVersion"            :                        "chackracore/viii.9.4/x64"            ,                                    "plan"            :                        "${workspaceFolder}/test.js"            }                  

Make sure to have those Node.js versions installed that y'all want to use with the runtimeVersion attribute, every bit the feature will not download and install the version automatically. For instance, you'll take to run something like nvm install vii.10.ane or nvs add vii.10.1 from the integrated terminal if you plan to add "runtimeVersion": "7.x.1" to your launch configuration.

If y'all omit the modest and patch version and take, for example, "runtimeVersion": "14", then the most recent 14.x.y version installed on your arrangement will be used.

Load environment variables from external file

The VS Code Node debugger supports loading environs variables from a file and passing them to the Node.js runtime. To utilize this feature, add an attribute envFile to your launch configuration and specify the accented path to the file containing the environment variables:

                                              //...                                    "envFile"            :                        "${workspaceFolder}/.env"            ,                                    "env"            : {                        "USER"            :                        "john doe"                          }                                    //...                  

Any environment variable specified in the env dictionary volition override variables loaded from the file.

Here'southward an example of an .env file:

          USER=doe Password=abc123  # a comment  # an empty value: empty=  # new lines expanded in quoted strings: lines="foo\nbar"                  

Attaching to Node.js

If you lot want to attach the VS Code debugger to an external Node.js plan, launch Node.js as follows:

                      node --inspect programme.js                  

or if the program shouldn't start running, but must wait for the debugger to attach:

                      node --audit-brk plan.js                  

Now y'all accept a couple options for attaching the debugger to your program:

• Open a "process picker" that lists all potential candidate processes and permit you pick 1, or
• Create an "attach" configuration that explicitly specifies all configuration options and then press F5.

Let'southward go through these options in detail:

Attach to Node Process action

The Attach to Node Process control from the Command Palette ( ⇧⌘P (Windows, Linux Ctrl+Shift+P)) opens a Quick Option menu that lists all potential processes that are available to the Node.js debugger:

The private processes listed in the picker show the debug port and process ID. Once you select your Node.js process in that list, the Node.js debugger will attempt to attach to information technology.

In addition to Node.js processes, the picker also shows other programs that were launched with 1 of the various forms --inspect arguments. This makes information technology possible to attach to Electron's or VS Code'southward helper processes.

Setting up an "Adhere" configuration

This option requires more work but in contrast to the previous 2 options it allows you to configure diverse debug configuration options explicitly.

The simplest "attach" configuration looks like this:

                      {                                    "name"            :                        "Adhere to Process"            ,                                    "type"            :                        "node"            ,                                    "request"            :                        "adhere"            ,                                    "port"            :                        9229            }                  

The port 9229 is the default debug port of the --inspect and --audit-brk options. To utilise a different port (for example 12345), add it to the options like this: --inspect=12345 and --inspect-brk=12345 and change the port attribute in the launch configuration to match.

If you want to adhere to a Node.js process that hasn't been started in debug way, you tin do this by specifying the procedure ID of the Node.js procedure as a string:

                      {                                    "name"            :                        "Attach to Process"            ,                                    "blazon"            :                        "node"            ,                                    "request"            :                        "adhere"            ,                                    "processId"            :                        "53426"            }                  

Since information technology is a bit laborious to repeatedly find the procedure ID and enter it in the launch configuration, Node debug supports a command variable PickProcess that will open up the process picker (from above).

Using the PickProcess variable the launch configuration looks similar this:

                      {                                    "name"            :                        "Attach to Process"            ,                                    "type"            :                        "node"            ,                                    "request"            :                        "attach"            ,                                    "processId"            :                        "${command:PickProcess}"            }                  

Finish debugging

Using the Debug: Stop action (bachelor in the Debug toolbar or via the Command Palette) stops the debug session.

If the debug session was started in "attach" fashion (and the cherry terminate button in the Debug toolbar shows a superimposed "plug"), pressing Cease disconnects the Node.js debugger from the debuggee that then continues execution.

If the debug session is in "launch" mode, pressing Stop does the following:

1. When pressing Stop for the get-go fourth dimension, the debuggee is requested to shut downwardly gracefully by sending a SIGINT signal. The debuggee is free to intercept this signal and clean upwards annihilation as necessary and and so shut down. If there are no breakpoints (or issues) in that shutdown code, the debuggee and the debug session will terminate.

2. Yet if the debugger hits a breakpoint in the shutdown code or if the debuggee does not cease properly by itself, then the debug session will not end. In this case, pressing Stop over again will force terminate the debuggee and its child processes (SIGKILL).

And so if you meet that a debug session doesn't finish when you press the ruby-red Stop button, and so printing the button again to forcefulness a shutdown of the debuggee.

Note that on the Windows operating organization, pressing Stop always forcibly kills the debuggee and its kid processes.

Source maps

The JavaScript debugger of VS Lawmaking supports source maps that help debugging of transpiled languages, for example, TypeScript or minified/uglified JavaScript. With source maps, it's possible to single step through or set breakpoints in the original source. If no source map exists for the original source, or if the source map is broken and cannot successfully map between the source and the generated JavaScript, so breakpoints prove upwardly equally unverified (gray hollow circles).

The source map characteristic is controlled past the sourceMaps attribute that defaults to true. This means that the debugger always tries to use source maps (if it tin can find any) and as a consequence, you can even specify a source file (for case, app.ts) with the program attribute. If you lot demand to disable source maps for some reason, you tin set the sourceMaps attribute to simulated.

Tool Configuration

Since source maps are non e'er automatically created, you should make certain to configure your transpiler to create them. For example:

TypeScript

For TypeScript, yous tin enable sourcemaps by passing --sourceMap to tsc, or by adding "sourceMap": true in your tsconfig.json file.

                      tsc --sourceMap --outDir bin app.ts                  

Babel

For Babel, you lot'll want to set the sourceMaps option to true, or pass the --source-maps option when compiling your code.

                      npx babel script.js --out-file script-compiled.js --source-maps                  

Webpack

Webpack has numerous source map options. Nosotros recommend setting the holding devtool: "source-map" in your webpack.config.js for the all-time allegiance of results, although y'all tin experiment with other settings causes slowdowns in your build.

As well, if y'all have boosted compilation steps in webpack, such equally using a TypeScript loader, you'll likewise want to make certain that those steps are set to generate sourcemaps. Otherwise, the sourcemaps that webpack generates will map back to the compiled lawmaking from the loader, instead of the real sources.

Source Map Discovery

By default, VS Code will search your entire workspace, excluding node_modules, for sourcemaps. In large workspaces, this search might be ho-hum. You can configure the locations where VS Code will search for source maps past setting the outFiles attribute in your launch.json. For example, this configuration will only notice sourcemaps for .js files in the bin folder:

                      {                                    "version"            :                        "0.2.0"            ,                                    "configurations"            : [                          {                                    "name"            :                        "Launch TypeScript"            ,                                    "type"            :                        "node"            ,                                    "request"            :                        "launch"            ,                                    "program"            :                        "app.ts"            ,                                    "outFiles"            : [            "${workspaceFolder}/bin/**/*.js"            ]                          }                          ]            }                  

Note that the outFiles should match your JavaScript files, non the source map files (which may end in .map instead of .js).

Source Map Resolution

By default, only source maps in your outFiles will exist resolved. This behavior is used to prevent dependencies from interfering with breakpoints you lot set. For example, if you had a file src/index.ts and a dependency had a source map that referenced webpack:///./src/index.ts, that would incorrectly resolve to your source file and could lead to surprising results.

You tin configure this beliefs by setting the resolveSourceMapLocations pick. If set to null, every source map will exist resolved. For instance, this configuration will additionally allow source maps in node_modules/some-dependency to be resolved:

                                              "resolveSourceMapLocations"            : [                                    "out/**/*.js"            ,                                    "node_modules/some-dependency/**/*.js"            ,                          ]                  

Smart stepping

With the smartStep attribute set to truthful in a launch configuration, VS Code volition automatically skip 'uninteresting lawmaking' when stepping through code in the debugger. 'Uninteresting code' is code that is generated past a transpiling procedure but is not covered by a source map so it does non map back to the original source. This code gets in your manner when stepping through source code in the debugger because it makes the debugger switch between the original source code and generated lawmaking that you are not interested in. smartStep will automatically step through code not covered by a source map until information technology reaches a location that is covered by a source map over again.

Smart stepping is especially useful for cases like async/await downcompilation in TypeScript, where the compiler injects helper code that is not covered by a source map.

The smartStep feature only applies to JavaScript lawmaking that was generated from source and therefore has a source map. For JavaScript without sources, the smart stepping option has no effect.

JavaScript source map tips

A common issue when debugging with source maps is that yous'll set a breakpoint, and information technology will turn grayness. If you lot hover the cursor over information technology, you lot'll come across the bulletin, "Breakpoint ignored because generated lawmaking non found (source map trouble?)". What now? There are a range of bug that tin lead to this. First, a quick explanation of how the Node debug adapter handles source maps.

When you set a breakpoint in app.ts, the debug adapter has to figure out the path to app.js, the transpiled version of your TypeScript file, which is what is actually running in Node. But, there is not a straightforward fashion to figure this out starting from the .ts file. Instead, the debug adapter uses the outFiles attribute in the launch.json to observe all the transpiled .js files, and parses them for a source map, which contains the locations of its associated .ts files.

When you build your app.ts file in TypeScript with source maps enabled, it either produces an app.js.map file, or a source map inlined equally a base64-encoded cord in a comment at the bottom of the app.js file. To detect the .ts files associated with this map, the debug adapter looks at ii properties in the source map, sources, and sourceRoot. sourceRoot is optional - if present, it is prepended to each path in sources, which is an assortment of paths. The effect is an assortment of accented or relative paths to .ts files. Relative paths are resolved relative to the source map.

Finally, the debug adapter searches for the full path of app.ts in this resulting listing of .ts files. If at that place'south a match, information technology has constitute the source map file to utilise when mapping app.ts to app.js. If there is no friction match, then it can't demark the breakpoint, and it will turn gray.

Hither are some things to try when your breakpoints turn grey:

• While debugging, run the Debug: Diagnose Breakpoint Problems command. This command will bring upwards a tool that tin can provide hints to help you lot resolve any issues from the Command Palette ( ⇧⌘P (Windows, Linux Ctrl+Shift+P)).
• Did you build with source maps enabled? Brand sure there are .js.map files, or inlined source maps in your .js files.
• Are the sourceRoot and sources properties in your source map correct? Tin they be combined to get the correct path to the .ts file?
• Take yous opened the folder in VS Code with the incorrect instance? It's possible to open up folder foo/ from the command line like code FOO in which instance source maps may not be resolved correctly.
• Try searching for help with your particular setup on Stack Overflow or by filing an consequence on GitHub.
• Endeavor adding a debugger statement. If it breaks into the .ts file there, but breakpoints at that spot don't bind, that is useful data to include with a GitHub issue.

Remote debugging

Note: VS Code at present has universal remote evolution capabilities. Using the Remote Development extensions, Node.js development in remote scenarios and containers is no unlike than Node.js development in a local setup. This is the recommended way to remote debug Node.js programs. Bank check out the Getting started department and Remote tutorials to learn more.

If y'all are unable to use any of the Remote Development extensions to debug your Node.js program, below is a guide on how to debug a remote Node.js program from your local instance of VS Code.

The Node.js debugger supports remote debugging where you attach to a process running on a dissimilar machine, or in a container. Specify a remote host via the address aspect. For example:

                      {                                    "type"            :                        "node"            ,                                    "request"            :                        "attach"            ,                                    "proper noun"            :                        "Adhere to remote"            ,                                    "address"            :                        "192.168.148.two"            ,                        // <- remote address here                                    "port"            :                        9229            }                  

By default, VS Lawmaking will stream the debugged source from the remote Node.js folder to the local VS Lawmaking and bear witness it in a read-only editor. Y'all can step through this lawmaking, simply cannot modify it. If yous want VS Code to open up the editable source from your workspace instead, y'all can fix upwardly a mapping between the remote and local locations. A localRoot and a remoteRoot attribute can exist used to map paths between a local VS Code project and a (remote) Node.js binder. This works even locally on the same system or beyond unlike operating systems. Whenever a code path needs to exist converted from the remote Node.js folder to a local VS Code path, the remoteRoot path is stripped off the path and replaced past localRoot. For the contrary conversion, the localRoot path is replaced past the remoteRoot.

                      {                                    "type"            :                        "node"            ,                                    "request"            :                        "adhere"            ,                                    "proper name"            :                        "Attach to remote"            ,                                    "address"            :                        "TCP/IP address of process to be debugged"            ,                                    "port"            :                        9229            ,                                    "localRoot"            :                        "${workspaceFolder}"            ,                                    "remoteRoot"            :                        "C:            \\            Users            \\            username            \\            project            \\            server"            }                  

Access Loaded Scripts

If you need to set a breakpoint in a script that is not function of your workspace and therefore cannot be easily located and opened through normal VS Code file browsing, you lot can access the loaded scripts via the LOADED SCRIPTS view in the Run view:

The LOADED SCRIPTS view lets you quickly select the script past typing its proper name or filter the list when Enable Filter on Type is on.

Scripts are loaded into a read-but editor where you lot tin can fix breakpoints. These breakpoints are remembered beyond debug sessions but you only have access to the script content while a debug session is running.

Restarting debug sessions automatically when source is edited

The restart attribute of a launch configuration controls whether the Node.js debugger automatically restarts after the debug session has ended. This feature is useful if you utilise nodemon to restart Node.js on file changes. Setting the launch configuration aspect restart to truthful makes the node debugger automatically try to reattach to Node.js after Node.js has terminated.

If you lot accept started your program server.js via nodemon on the command line like this:

                      nodemon --audit server.js                  

you can attach the VS Code debugger to it with the following launch configuration:

                      {                                    "proper name"            :                        "Attach to node"            ,                                    "blazon"            :                        "node"            ,                                    "asking"            :                        "attach"            ,                                    "restart"            :                        true            ,                                    "port"            :                        9229            }                  

Alternatively y'all can start your program server.js via nodemon directly with a launch config and attach the VS Code debugger:

                      {                                    "name"            :                        "Launch server.js via nodemon"            ,                                    "type"            :                        "node"            ,                                    "request"            :                        "launch"            ,                                    "runtimeExecutable"            :                        "nodemon"            ,                                    "plan"            :                        "${workspaceFolder}/server.js"            ,                                    "panel"            :                        "integratedTerminal"            ,                                    "internalConsoleOptions"            :                        "neverOpen"            }                  

Tip: Pressing the Stop button stops the debug session and disconnects from Node.js, just nodemon (and Node.js) will continue to run. To finish nodemon, you lot will accept to impale information technology from the control line (which is easily possible if you use the integratedTerminal as shown above).

Tip: In example of syntax errors, nodemon will not be able to start Node.js successfully until the error has been stock-still. In this case, VS Code volition continue trying to attach to Node.js but eventually give upward (afterward ten seconds). To avoid this, you lot tin can increase the timeout by adding a timeout aspect with a larger value (in milliseconds).

Restart frame

The Node debugger supports restarting execution at a stack frame. This can exist useful in situations where you take found a problem in your source code and you want to rerun a small portion of the code with modified input values. Stopping and and so restarting the full debug session can be time-consuming. The Restart Frame activity allows you lot to reenter the electric current function after you have changed variables with the Set Value activity:

Restart Frame won't roll back mutation to state outside of the function, so it may not always work as expected.

Breakpoints

Conditional Breakpoints

Provisional breakpoints are breakpoints that only pause when an expression returns a truthy value. You can create i by correct-clicking in the gutter beside a line number and selecting "Provisional Breakpoint":

Logpoints

Something y'all want to just log a bulletin or value when lawmaking hits a certain location, rather than pausing. You can do this with logpoints. Logpoints don't intermission, just rather log a message to the Debug Console when hit. In the JavaScript debugger, yous can use curly braces to interpolate expressions into the message, like current value is: {myVariable.property}.

You lot can create one by right-clicking in the gutter beside a line number and selecting "Logpoint". For example, this might log something like location is /usr/local:

Hit count breakpoints

The 'hitting count condition' controls how many times a breakpoint needs to exist hit before it will 'break' execution. You lot tin can place a hit count breakpoint by correct-clicking in the gutter beside a line number, selecting "Conditional Breakpoint", and so switching to "Hit Count".

The hitting count syntax supported past the Node.js debugger is either an integer or i of the operators <, <=, ==, >, >=, % followed by an integer.

Some examples:

• >10 break e'er after ten hits
• <three intermission on the outset two hits but
• 10 same as >=x
• %2 intermission on every other hitting

Breakpoint validation

For functioning reasons, Node.js parses the functions inside JavaScript files lazily on first admission. As a event, breakpoints don't work in source lawmaking areas that haven't been seen (parsed) by Node.js.

Since this behavior is not platonic for debugging, VS Code passes the --nolazy option to Node.js automatically. This prevents the delayed parsing and ensures that breakpoints can be validated before running the code (and then they no longer "bound").

Since the --nolazy option might increase the commencement-up time of the debug target significantly, you can hands opt out past passing a --lazy as a runtimeArgs attribute.

When doing and so, you will find that some of your breakpoints don't "stick" to the line requested but instead "spring" for the adjacent possible line in already-parsed code. To avert confusion, VS Code always shows breakpoints at the location where Node.js thinks the breakpoint is. In the BREAKPOINTS section, these breakpoints are shown with an arrow between requested and actual line number:

This breakpoint validation occurs when a session starts and the breakpoints are registered with Node.js, or when a session is already running and a new breakpoint is set. In this example, the breakpoint may "spring" to a different location. After Node.js has parsed all the lawmaking (for example, by running through it), breakpoints can be easily reapplied to the requested locations with the Reapply button in the BREAKPOINTS section header. This should brand the breakpoints "jump back" to the requested location.

Skipping uninteresting lawmaking

VS Code Node.js debugging has a feature to avoid source code that you don't want to pace through (also known every bit 'But My Code'). This feature tin can be enabled with the skipFiles aspect in your launch configuration. skipFiles is an array of glob patterns for script paths to skip.

For example, using:

                                              "skipFiles"            : [                                    "${workspaceFolder}/node_modules/**/*.js"            ,                                    "${workspaceFolder}/lib/**/*.js"                          ]                  

all lawmaking in the node_modules and lib folders in your projection will exist skipped. The skipFiles besides apply to the location shown when calling console.log and similar methods: the commencement non-skipped location in the stack will be shown abreast the output in the Debug Console.

Congenital-in core modules of Node.js can be referred to by the 'magic name' <node_internals> in a glob pattern. The post-obit example skips all internal modules:

                                              "skipFiles"            : [                                    "<node_internals>/**/*.js"                          ]                  

The exact 'skipping' rules are as follows:

• If you lot step into a skipped file, you lot won't stop there - you will cease on the adjacent executed line that is non in a skipped file.
• If you lot accept set the option to break on thrown exceptions, then you lot won't break on exceptions thrown from skipped files unless they bubble up into a not-skipped file.
• If y'all set up a breakpoint in a skipped file, you will stop at that breakpoint, and you will be able to stride through it until you step out of information technology, at which bespeak normal skipping behavior will resume.
• The location of console letters from inside skip files volition exist shown as the beginning non-skipped location in the telephone call stack.

Skipped source is shown in a 'dimmed' style in the Call STACK view:

Hovering over the dimmed entries explains why the stack frame is dimmed.

A context carte du jour particular on the call stack, Toggle skipping this file enables you to easily skip a file at runtime without calculation it to your launch config. This pick only persists for the current debugging session. You tin can also apply it to stop skipping a file that is skipped past the skipFiles selection in your launch config.

Note: The legacy protocol debugger supports negative glob patterns, just they must follow a positive pattern: positive patterns add to the set of skipped files, while negative patterns subtract from that set.

In the following (legacy protocol-only) example all merely a 'math' module is skipped:

                      "skipFiles"            : [                                    "${workspaceFolder}/node_modules/**/*.js"            ,                                    "!${workspaceFolder}/node_modules/math/**/*.js"            ]                  

Note: The legacy protocol debugger has to emulate the skipFiles characteristic because the V8 Debugger Protocol does not support it natively. This might upshot in slow stepping performance.

Supported Node-like runtimes

The current VS Code JavaScript debugger supports Node version at or to a higher place 8.ten, recent Chrome versions, and recent Edge versions (via the pwa-msedge launch type).

Next steps

In case yous didn't already read the Node.js section, take a look at:

• Node.js - Finish to end Node scenario with a sample application

To run into tutorials on the nuts of Node.js debugging, check out these videos:

• Intro Video - Debugging - Introductory video showcasing the basics of debugging.
• Getting started with Node.js debugging - Acquire how to adhere to a running Node.js procedure.

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

• Tasks - Running tasks with Gulp, Grunt, and Jake. Showing Errors and Warnings

To write your own debugger extension, visit:

• Debugger Extension - Steps to create a VS Code debug extension starting from a mock sample

Common questions

Can I debug if I'one thousand using symlinks?

Yes, if you've created symlinks for folders within your projection, such as with npm link, you lot tin can debug the symlinked sources by telling the Node.js runtime to preserve symlinked paths. Use the node.exe --preserve-symlinks switch in your launch configuration runtimeArgs attribute. runtimeArgs, an array of strings, are passed to the debugging session runtime executable, which defaults to node.exe.

                      {                                    "runtimeArgs"            : [            "--preserve-symlinks"            ]            }                  

If your principal script is inside a symlinked path, and then you will as well demand to add the "--preserve-symlinks-master" option. This pick is only bachelor in Node 10+.

How do I debug ECMAScript modules?

If yous use esm or pass --experimental-modules to Node.js in order to use ECMAScript modules, you can pass these options through the runtimeArgs aspect of launch.json:

• "runtimeArgs": ["--experimental-modules"] - Use the experimental ECMAScript modules support in Node v8.5.0+
• "runtimeArgs": ["-r", "esm"] - Use the esm ES module loader (["-r esm"] without a comma won't work)

two/iii/2022

matthewsthattles.blogspot.com

Source: https://code.visualstudio.com/docs/nodejs/nodejs-debugging

Share this post