skip to content

In Chrome DevTools, what does putting a script on the ignore list change about stepping, exceptions and stack traces, and what does it leave alone?

level: middleimportance: should knowfreq 33%

answer

  1. a debugger view, not a page change
  2. stepping skips through it
  3. no stop on its exceptions
  4. frames hidden in Call Stack
  5. Show ignore-listed frames brings them back

basics

~10 s

An ignored script still runs unchanged. The debugger skips stepping through it and won't stop on its exceptions, and its frames are hidden from the Call Stack pane until you check Show ignore-listed frames.

solid answer

~50 s

The ignore list changes how the debugger treats a script, not what the script does on the page. DevTools says it plainly on an ignored file: the debugger will skip stepping through this script and won't stop on exceptions. So stepping passes through library internals back to your code, and pause on exceptions stays quiet for errors thrown there. Its frames drop out of the **Call Stack** pane until you check **Show ignore-listed frames**, the file is greyed in the file tree, and the Console hides third-party frames that a map's `ignoreList` field flags. Scripts get there from that field, by a right-click, or from a pattern in Settings. The cost is hiding the bug when it really is in ignored code, so if an exception never pauses, I look for an ignored file, then use `Remove from ignore list`. A bundle on the list may also stay unmapped.

go deeper

for a junior

Recall what it is for: keeping the debugger out of library code. The script still runs, and only the way DevTools steps and shows frames changes.

for a middle

Explain the specific effects: stepping skips through, no stop on exceptions, hidden frames, greyed files. Know the three routes onto the list, including a map's ignoreList field.

for a senior

Treat the list as the first suspect when evidence looks wrong, such as a missing pause or a short stack. Know how to rule it out quickly, and that a broad pattern can also cost a bundle its map.

for a principal

The angle is what a team's map ships by default: flagging third-party sources gives everyone cleaner stacks with no setup, at the price that bugs inside those sources are harder to notice.

## What the ignore list is for When you debug a modern page, most of the call stack is code you did not write: frameworks, utility libraries, browser extensions. The **ignore list** is the Chrome DevTools list of scripts the debugger should treat as not your concern. It exists so that stepping and stack reading stay on your own code. It is a debugging preference held by DevTools, and the page has no idea it exists. The most useful sentence to remember comes from DevTools itself, shown on any ignored file: `This script is on the debugger's ignore list`, followed by `The debugger will skip stepping through this script, and won't stop on exceptions`. ## What changes Putting a script on the list changes several things you see while debugging: - **Stepping.** You never step into the script's functions when stepping through your code. - **Exceptions.** By the notice's own wording, the debugger won't stop on exceptions in the script, even with pause on exceptions turned on. - **Call Stack pane.** Ignored frames are hidden by default, and the **Show ignore-listed frames** checkbox in that section shows the full stack. - **Console stack traces.** When a source map uses its `ignoreList` field, the Console hides those third-party frames from stack traces by default and offers a control to expand them. - **File tree.** Ignored scripts and folders are greyed out, and a tooltip marks them as ignore listed. ## What does not change | Aspect | Effect of ignore-listing | |---|---| | Whether the script runs | None. It loads and executes as before | | The page's behaviour | None. Errors are still thrown and still reach any handler | | What visitors get | None. It is your local DevTools preference | | Network requests | None. This is not request blocking | That last row is a common confusion. Ignore-listing is not **request blocking**: blocking stops a request and changes the page, whereas ignore-listing changes only how the debugger behaves around code that is still running. ## How a script gets on the list There are three routes, and it helps to know which one applied when you did not add the script yourself: 1. **From the source map.** A map's `ignoreList` field names its third-party sources, and a setting on the ignore-list tab of DevTools Settings adds such known third-party scripts automatically. This is why library frames may be missing without you having done anything. 2. **By hand from a right-click.** You can add a script or a folder from the file tree, add the open script from the editor, or add one from a frame in the Call Stack pane. 3. **By pattern.** The same settings tab holds custom exclusion rules, where a script name or a regular expression covers a whole family of files. The tab also has a main switch for ignore-listing as a whole, and an option for extension content scripts. ## When it hides the bug The feature assumes the problem is not in the ignored code. Sometimes it is, and the symptoms look like a broken debugger: - **An exception that never pauses.** The error appears in the Console, but pause on exceptions sails past it, because it was thrown inside an ignored script. - **A stack that seems too short.** Frames are missing, so the path from your code to the failure looks impossible. - **A file that stays minified.** Ignoring a bundle by pattern can lead to `Source map skipped for this file`, whose advice is to make sure the file isn't on the ignore list and reload. `Add source map…` is also not offered for a URL you ignore-listed. To recover, work through these steps: 1. Check **Show ignore-listed frames** to see the whole stack. 2. Open the suspect file and read the notice at the top of its editor. 3. Use `Remove from ignore list` for that file, or `Configure` to open the settings and find the pattern that matched it. ## The judgement to show A good answer treats the list as a filter that is usually right. Trust it for routine debugging, because it cuts the noise of stepping through framework internals. When the evidence stops making sense, such as a missing pause or an implausibly short stack, suspect the filter before suspecting the tool. That instinct is what separates someone who has used the feature from someone who has only read about it: they know the fastest way to rule the filter out, and they turn it back on afterwards.

  • An exception shows up in the Console, but pause on exceptions never stops on it. How does the ignore list explain that?
    If the throw happens inside an ignored script, the debugger won't stop there, though the error is still thrown and logged. Check Show ignore-listed frames once you are paused elsewhere, open the file named in the Console stack and look for the ignore-list notice. Remove that file from the list to get the pause.
  • Library frames are missing from your stack and you never ignored anything. Why?
    A source map can name its third-party sources in its ignoreList field, and DevTools can add those automatically through a setting on its ignore-list tab. You did nothing, because the build's map asked for it. Show ignore-listed frames reveals them for the Call Stack, and that setting controls the behaviour as a whole.
  • How can ignore-listing a bundle leave it unmapped?
    A deployed file with a map reference can show Source map skipped for this file, and that notice tells you to make sure the file isn't on the ignore list and reload. Add source map is also not offered for a URL you ignore-listed. So a broad pattern can quietly cost you the original files as well.

  • Ignore-listing a script stops it from loading or running on the page.
  • Only third-party libraries can go on the ignore list, never your own files.
  • Ignored frames are gone from the Call Stack for good once a script is listed.
  • Pause on exceptions still stops inside an ignored script, since only stepping changes.
  • Ignore-listing has no effect on source maps, so a listed bundle always stays mapped.