Connect with us


Past Console.log() – Stage up Your Debugging Abilities – SitePoint

You’ll have established a sample of coding that makes use of just a few key instruments supplied by your browser’s console. However have you ever dug any deeper currently? There are some highly effective instruments out there to you, and so they may simply revolutionize the way in which you’re employed.

The Consolation Zone

As builders, we wish to discover a manner of working that make us really feel environment friendly. The lure, although, is that we get snug with a sure workflow and assume there’s no higher manner. We’ve internalized an strategy and don’t have to consider what we do.

A standard developer workflow is to put in writing code in an editor, reserve it, then change to the browser and cargo the product to see if every part works. We then use the developer instruments within the browser to tweak the CSS and possibly check how the merchandise react to resizing and cell emulation. We debug our scripts by including a console.log() assertion wherever we’d like some insights — holding a good connection between line numbers and debugging.

This ends in a little bit of a multitude. In the event you preserve your browser instruments open when browsing the Internet, you’ll see plenty of messages within the code that shouldn’t find yourself in a remaining product. It not solely makes it complicated for individuals who open them accidentally, however may also be daunting for brand new builders to have a look at.

We solely use a small share of the instruments at our disposal, and we might miss out on alternatives to work higher and with much less effort. That’s okay, however let’s see how we will do higher.

We’ll have a look at just a few options of freely out there developer instruments you in all probability use however don’t find out about. Particularly, these options are within the Chromium browser developer instruments and a few in Visible Studio Code. Let’s begin by studying extra a couple of perennial favourite — the Console.

Leveling Up Our Console Recreation

We’re conditioned early on in our improvement profession so as to add a console.log(factor) anyplace in our code to study what’s happening. Typically that’s sufficient, however typically you continue to don’t get the proper data, or it’s in some uncooked format that’s laborious to grasp.

You’ll be able to see all the next methods by grabbing this demo web page on GitHub and opening it in your browser together with your developer instruments open. (Or view a [live demo on CodePen](on CodePen).

The primary trick right here is so as to add curly braces to variables you log. This not solely prints out their worth, but additionally the identify of the variable. It makes it simpler to trace down within the log what worth got here from the place.

let x = 2;

Formatting logs

You may as well use specifiers in your log message which begin with a share signal. These help you log sure values in several codecs:

  • %s: logs as strings
  • %i or %d: logs as integers
  • %f: logs as floating-point worth
  • %o: logs as an expandable DOM ingredient
  • %O: logs as an expandable JavaScript object

You’ll be able to combine and match these. The order of alternative within the first string is the parameter order following it:

console.log('%ix %s developer', 10, 'console');

You’ll be able to even convert with this, in case you get data that isn’t in a format you want:

console.log('%i', 12.34455241234324234); 

The %c specifier permits you utilize CSS to fashion your log message in case you actually wish to stand out:

console.log('%cPay consideration to me','colour:firebrick;font-size:40px')

Logging is nice, however there are extra choices you should use to make issues extra apparent and to keep away from having to put in writing performance your self.

Grouping logs

You’ll be able to group your logs utilizing to indicate them as expandable and collapsible teams.

const label = 'The Millenium Falcon Crew';;

You’ll be able to nest teams, and you should use console.groupCollapsed() to not develop them by default:

const extendedlabel = 'The Millenium Falcon Crew prolonged';
const meat = 'Humanoids';
const metallic = 'Droids';;

Toggling nested console groups

Enable for log filtering

As an alternative of console.log() it’s also possible to use, console.error() and console.warn(). This lets you filter the messages you see within the console utilizing the console sidebar or the degrees selector. That manner, you make it simpler to seek out your personal messages amongst these coming from third-party scripts and different scripts in you challenge.

filtering the console output

Different helpful console strategies

You’ve in all probability created variables in your debugging journey that rely how typically a sure methodology was known as or performance executed. You are able to do the identical factor through the use of the console.rely() and console.countReset() strategies. You’ll be able to create as a lot of them as you need and distinguish by label:


You may as well measure how lengthy a sure a part of your script takes utilizing the console.time() methodology:

for(let i = 0; i < 200000; i+=1) {
  let x = Math.random()*2000;

Relying on the information you wish to log, it additionally is smart to make use of the proper methodology for the job. Utilizing console.dir() shows not solely the content material but additionally the kind of information you ship it. If you need an XML illustration of a node, for instance, you should use console.dirxml(). And console.desk() is superb for exhibiting JSON information as a sortable desk.

Changing Logging with Stay Expressions

It’s tempting to make use of console.log() to observe issues that change quite a bit. This isn’t solely sluggish, but additionally fairly robust to comply with. Whereas it’s helpful that the console routinely teams comparable values as cases, it’s nonetheless plenty of motion, and also you typically end up solely eager to test the worth as a substitute of scrolling again to see the place a sure change occurred.

That is the place dwell expressions are available. You’ll be able to add dwell expressions by activating the attention button within the developer instruments. You’re then requested to enter any legitimate JavaScript expression, and its worth will present up above the console.

Attempt it out by activating the attention button and getting into doc.activeElement. The expression ought to present physique as a price till you activate or give attention to another ingredient within the web page. You’ll be able to see it in motion on the SitePoint web site within the following video:

Every expression has an x button subsequent to it to cease monitoring the worth. Stay expressions are persistent and never related to a sure area or web site. That’s why it is smart to take away them after you’ve completed debugging to keep away from errors.

Stay expressions are great little helpers to observe modifications within the information of your scripts with out having to make use of the console. That is particularly helpful whenever you log very busy values — such because the mouse place. That is in all probability the way you’d strategy that:

let x = 0;
let y = 0;
doc.addEventListener('mousemove', e => {
  x = e.x;
  y = e.y;
  console.log({x}, {y});

The result’s a very busy log, and it’s simple to overlook essential data. Utilizing dwell expressions, you don’t have to understand a fast-moving log, which probably can be a sooner debugging expertise. You’ll be able to see the distinction within the following video.

Attempt it out your self: seize the demo code for transferring the mouse with logging and transferring the mouse with out logging and check out working each examples within the browser.

Utilizing the Console to Manipulate the Present Doc

The Console within the developer instruments is a lot greater than a approach to show a log. It’s a REPL that permits you to write and execute JavaScript and study out there strategies and properties of the present doc utilizing autocomplete. Simply go to the Console within the developer instruments, kind doc, and hit tab, and it’ll routinely convert it to doc. In the event you add a full cease, you’ll see all of the out there strategies and properties. This is a fascinating and easy approach to study out there strategies and properties, and it permits you to write plenty of code in a brief period of time.

Console autocomplete in action

Along with that, the Console can be a wonderful approach to work together with the present doc and entry components of it. There’s a lot of comfort strategies and shortcuts out there to you as Console Utilities. A few of these are:

  • $_ shops the results of the final command. So in case you have been to kind 2+2 and hit enter, typing $_ offers you 4.
  • $0 to $4 is a stack of the final inspected parts, the place $0 is all the time the latest one.
  • $() and $$() are quick for doc.querySelector() and doc.querySelectorAll().
  • $x() permits you to choose DOM parts by XPATH.
  • copy() copies no matter you give it to the clipboard.
  • clear() clears the console.
  • getEventListeners(node) lists all of the occasion listeners of a node.
  • monitorEvents(node, occasions) screens and logs the occasions that occur on a node.
  • monitor(methodology) creates a log merchandise every time a way known as.

A few of these strategies are extremely highly effective and are issues we in all probability have written ourselves as a sequence of console.log() statements previously.

Listed below are some methods you should use these strategies:

monitorEvents(window, ['resize', 'scroll']);

monitorEvents($0, 'key');

This logs each time the window scrolls or will get resized. The second instance is attention-grabbing, because it logs any key motion on the at present chosen ingredient:


This retrieves all of the hyperlinks within the doc (as $$('a') is brief for doc.querySelectorAll('a')) and shows them as a sortable desk. The array as a second parameter of the desk methodology defines the columns of the desk. In any other case, every property of the hyperlink would turn into a column and that’s laborious to navigate. The enjoyable bit is that the desk will not be solely sortable, however you’ll be able to copy and paste it — for instance, into Excel.

Grab all links from sitepoint and paste into Excel

As an alternative of writing advanced JavaScript to filter these outcomes, you should use the facility of CSS selectors. For instance, if you wish to have a desk of the src and alt data of all photos within the doc that aren’t inline photos, you should use the next:

console.desk($$('img:not([src^=data])'), ['src','alt'])

Nonetheless, probably the most enjoyable with that is to put in writing scripts that run within the context of the web page.

For instance, whenever you use Markdown to generate HTML, most web page turbines will create automated IDs on headings to permit for deep linking to that a part of the doc. A # New Stuff heading will flip into <h1 id="new-stuff">New stuff</h1>. I wanted to batch-create plenty of quick URLs pointing to those deep hyperlinks and didn’t wish to create them by hand.

So I began to put in writing a script for the Console to do this for me:

let out = '';
$$('#fundamental [id]').filter(
    elm => {return elm.nodeName.startsWith('H')}
).forEach(elm => {
   out += `${elm.innerText}

The result’s a block of textual content with the textual content content material of every heading adopted by the total URL pointing to it.

This additionally reveals an attention-grabbing further characteristic of the $$ shortcut. A doc.querySelectorAll('#fundamental [id]').filter() would end in an error, because the returned worth isn’t an Array however a NodeList. You’d have to forged it to an Array with [...document.querySelectoAll('#main [id]').filter()] or Array.from(doc.querySelectoAll('#fundamental [id]').filter()), which has been an annoyance for folks coming from jQuery to JavaScript for fairly some time. The $$ comfort methodology permits for all of the Array strategies immediately.

Typically, you could have plenty of energy to entry and alter something on the rendered web page within the browser from the Console. And also you even have the additional advantage of utilizing the Parts tab of the developer instruments to get the proper path. Activate the ... menu subsequent to every node and choose from the context menu’s copy menu to seize what you want.

selecting a part of the page and copying the JS path

Shifting from Console to Sources

When you’ve discovered some enjoyable methods to govern web pages, you’ll quickly run into the constraints of the Console as a script setting. It may be a bit robust to code on the Console, as you’re working in a single-line setting. Hitting Enter instantly executes what you typed and sometimes you try this accidentally. There’s a trick, although. You’ll be able to write multi-line scripts through the use of Shift + Enter as a substitute.

Normally, the Console makes for an amazing testing setting however for a poor modifying expertise. Fortunately sufficient, there’s additionally a full editor out there within the Sources panel. There, you’ll be able to examine the code of the present web page and write extra advanced scripts to work together with it.

Discovering a sure instrument within the browser’s developer instruments will be daunting, as there are such a lot of out there. The instruments have grown organically through the years, and most of the specialist sections might by no means be for you, whereas different folks depend on them.

Fairly than having to undergo a number of menus to seek out what you want, there’s a useful shortcut, the Command Menu.

You’ll be able to entry the command menu by urgent Management + Shift + P (Home windows, Linux) or Command + Shift + P (macOS). Or select the “Customise And Management DevTools” ( or ) menu (high proper of the DevTools window) after which select Run Command.

Both manner, you get a menu that permits you to entry the entire devtools performance by keyboard, which regularly means a a lot sooner and direct manner. As hinted within the identify, it’s also possible to set off performance with this menu.


Snippets are a wonderful approach to preserve scripts you write that work together with a doc. They’re small scripts which have entry to each the at present open browser doc and the comfort strategies of the Console.

Attempt it out proper now by hitting the Command Menu keyboard shortcut, typing snip and hitting Enter, successfully telling the Developer Instruments to create a brand new snippet. This will get you to the Snippets editor, and it’ll have created a brand new snippet with a generic identify. Open the context menu on the file identify of the Snippet on the left, choose rename and name it Get all hyperlinks, as proven on this GIF:

Creating a news snippet

On the proper, you could have a full-fledged editor with colour coding, autocompletion, a number of cursors and all the opposite stuff you count on lately. You can begin writing your script. How about writing a script that will get all of the hyperlinks and their textual content (or equivalents) from the present doc? We must also flag up which of them encompass photos and print out an error message with a listing of all those who that don’t have any textual content. These must also get a purple border so we will see the difficulty.

Right here’s the script. It makes use of fairly just a few of the issues we checked out earlier. Copy and paste it into the snippets editor:

let out = '';
let issues = [];
$$('a').forEach(a => {
  let textual content = a.innerText.trim();
  let prefix = ''; 
  if (!textual content) {
    if (a.querySelector('img')){
      textual content = a.querySelector('img').alt;
      prefix = 'Picture: ';
    if (a.getAttribute('aria-label')) {
      textual content = a.getAttribute('aria-label');
      prefix = 'Aria Label: ';
    if (a.getAttribute('aria-labelledby')) {
      textual content = $('#' + a.getAttribute('aria-labelledby')).innerText;
      prefix = 'Aria Labelled By: ';
  if (textual content) {
    textual content = prefix + textual content
  } else { = '1px strong firebrick';
  out += `
if (out === '') {
  console.warn('Sorry, no hyperlinks discovered');
} else {
  copy(out);'accomplished harvesting hyperlinks, prepared to stick');
  if (issues.size > 0) {
    console.warn('There have been %d points:', issues.size);
    console.groupCollapsed('Hyperlinks with out textual content');
    issues.forEach(a => {console.dirxml(a)});
    console.groupEnd('Hyperlinks with out textual content');

When you’ve pasted new content material or edited a snippet, you’ll see that the file identify on the tab above and within the checklist on the left has an asterisk. This implies it’s an unsaved file. To retailer it in your pc, press CMD + s on macOS and Ctrl + s on Home windows/Linux. You run the snippet within the editor by activating the play button under or hitting CMD + Enter on macOS and Ctrl + Enter on Home windows/Linux.

The next GIF reveals the script working on the What’s New in DevTools 89 doc:

Saving and executing the snippet

You’ll be able to create as many snippets as you need, and so they’re not related to a sure URL or doc. You’ll be able to run them in opposition to any net content material you need.

One very nice characteristic of Snippets is that you just don’t want to enter the editor to run them. When you’ve saved them in your gadget, it’s also possible to attain them from the Command Menu. All it’s worthwhile to do is to delete the > and exchange it with an !. This offers you an autocomplete menu with all of the snippets on the pc. Begin typing the one you wish to run and hit Enter.

Run snippet from menu

That manner, you’ll be able to shortly entry all of you snippets to run in opposition to the present web site. All by typing ! adopted by the identify of the snippet.

In my case, this seems like this:

snippet list

Snippets are nice if you wish to manually run a script to govern the present doc. However what if you wish to routinely run a script or change one thing in a web site each time it hundreds? Learn on.


Overrides are native copies of distant information. As an alternative of all the time loading the file from the server, the browser’s developer instruments interject and exchange the information together with your native copy. That is extremely helpful if you need, for instance, to edit a full fashion sheet of a fancy web site with out constructing it domestically or ready for deployment to complete. It’s additionally an effective way to seek out efficiency issues by serving information which might be sluggish to load from you laborious drive throughout improvement.

You get began with Overrides by organising a folder in your native laborious drive. In my case, I created a folder known as local-overrides in my Downloads folder.

For instance, in case you now wished to inject some JavaScript into my weblog, you’d have to navigate to the Sources tab in developer instruments and choose the Overides tab within the backside menu.

The overrides tab in the sources folder

Under, you could find a + Choose folder for overides button. Activating this one will immediate you to pick a folder in your laborious drive to retailer information in.

Selecting an overrides folder

As developer instruments might want to retailer data there, you get requested to offer permission to take action by activating the Settle for button.

Giving folder access

As soon as that’s accomplished, the native overrides folder seems under. Above is a checkbox to toggle overrides. That is useful, as a result of it means you don’t have to delete the folder or scripts on a regular basis. You’ll be able to uncheck this selection and the browser will load assets from the Internet once more. The button with the round icon subsequent to the choice deletes all overrides.

Giving folder access

Subsequent, you’ll be able to choose a file to override. Change to the Web page tab and go right down to the entry. Broaden the part and also you’ll discover a analytics.js file. Click on it to open it within the editor.

Selecting the analytics.js file to override

This additionally reveals an attention-grabbing characteristic of the editor. It routinely detects when a file is minified and gives to pretty-print it to make it simpler to learn. You are able to do that with any file by activating the {} button on the underside proper.

For now, let’s simply choose all of the code and exchange it with a easy:'I'm in!')

When you’ve saved the file utilizing CMD + s (macOS) or Ctrl + s (Home windows, Linux), you’ll see a purple dot subsequent to the file identify. This reveals you which of them information aren’t loaded from the supply site any longer however are coming from you laborious drive as a substitute.

Overide files have a purple dot next to them

In the event you now navigate anyplace on, it received’t load the analytics file any longer, however will run the one from you laborious drive as a substitute. The console says “I’m in”, and I by no means wrote that code.

Overide files have a purple dot next to them

In the event you now look into your local-overrides folder, you’ll discover a folder with the analytics.js file inside it. You’ll be able to both edit the file within the developer instruments, or immediately in that folder with an editor of your alternative. Any change to the file might be mirrored within the different setting.

Sync Your Improvement and Debugging Duties with Workspaces

Relating to syncing, Workspaces are one other characteristic that doesn’t appear to get sufficient utilization. After we suppose again to our widespread improvement strategy to start with of this text, we appear to develop in our editors and debug within the browser. This is smart, however the larger situation is how we get the issues we modified again into our supply code? Typically we simply tweak just a few settings after which repeat the modifications in our editor. There’s a greater manner.

The very first thing that is probably not identified to you but is that there’s a Modifications instrument. Say, for instance, you’re employed on the small to-do checklist demo and also you wish to tweak the feel and appear a bit. You’d usually try this within the Parts instrument, as proven within the following GIF:

changing a background color using Elements

The widespread approach to get this alteration again into your code can be to repeat and paste the colour code from the CSS and duplicate it again into the supply code in you editor. However what about extra modifications? Developer instruments additionally preserve monitor of what you’ve modified, and in case you go to the Modifications tab, you get a listing of all of the information you modified and what modified in them. The best approach to entry that is to make use of the Command Menu once more and sort modifications, which provides you the “Present Modifications” possibility.

Tracked changes in the developer tools

This makes it simpler to trace your modifications, but it surely nonetheless feels bizarre to repeat the modifications again into your supply code.

You may make the developer instruments work together with your editor by including your challenge folder to a Workspace. To make this occur, go to the Sources instrument and drag and drop your challenge folder onto it.

Tracked changes in Devtools

You as soon as once more have to offer the developer instruments permission to entry this folder, very like we did within the overrides instance earlier. When you’ve accomplished that, any change you make to the file within the developer instruments might be synced. You’ll be able to see this within the following GIF. On the left-hand facet is my VS Code editor with the file open, and on the proper is the browser. Altering the colour within the Parts instrument not solely updates it dwell within the browser, but additionally modifications the code in my editor. Not one of the tweaking you do must get an additional copy and paste step.

Syncing changes to editor with workspaces

It appears a good suggestion to carry the facility of an amazing editor and the inspection energy of the browser developer instruments collectively. That is why we created an extension for Visible Studio Code that does precisely that. If that is your editor of alternative, you’ll be able to set up the Microsoft Edge Instruments for VS Code extension and also you get the developer instruments proper in your editor, full with a completely practical browser. You’ll be able to see what that appears like within the following GIF.

VS Code Extension embedding the browser tools in the editor

What’s Subsequent?

I hope that, in studying this text, you’ve gotten some concepts about the way to use your browser’s developer instrument options past simply including a console.log() into your scripts. The following step for me, as a developer, was to maneuver away from the console altogether and get accustomed to utilizing breakpoint debugging. The advantages are that your code stops and you’ll examine the modifications that occur alongside the way in which as a substitute of tracing again what occurred as soon as it was executed. It’s a distinct manner of approaching the identical drawback and never as simple, but it surely’s nicely value your time.

Click to comment

Leave a Reply

Your email address will not be published. Required fields are marked *