I think one of the most underutilized methods for developers is the Print method! Beyond which, those that do use it often don’t necessarily use it to its full potential.

What Is The Print Method?

The print method allow us to output (or ‘print’) information/values/content to VBA/VBE the Immediate Window.
 

How Is That Useful?

I know developers that don’t see the utility of Print when they have MsgBox, but they serve 2 distinct purposes.

MsgBox is more for the end-user, to display a message to them. Sadly, you can interact with a MsgBox. Amongst other things, you can’t copy the contents.

Print is only for the developer as it is displayed in the VBE Immediate Window.  The beauty here is:

• that you can copy/paste its content which is great to search up those error numbers/descriptions.
• use it while in the VBE creating code without having to switch back and forth to the Access GUI and VBE windows
• using the options, and other techniques, you can format the output.
• you can sprinkle it throughout procedure to see the evolution of variables, … in real-time. This is great for debugging purposes.

Basic Usage

Its most basic usage would be

a = "Some"
b = "Value"
Debug.Print a & " " & b

which will the return (in the VBE Immediate Window)

Some Value

Blank Line

There are times that it is useful to insert separation lines, a blank line and this is very easy to do!  Simply do either

Debug.Print

OR

Debug.Print ""

Options You Say

If you look at the documentation for a moment, you will see they mention Spc(n), Tab(n) & ;, so what are these and how do they work.

Spc

So using Spc(n) you can insert n number of space in front of value, after the value or on it’s own.

Debug.Print Spc(12)

will return what appears to be a blank line, when in fact there are 12 space characters on it

Now realistically, no ones really going to output a series of spaces on their own like the example above, well not very often at least, but this can be used to pad/align content.

a = "Some"
b = "Value"
Debug.Print Spc(12); a
Debug.Print a; Spc(12)
Debug.Print a; Spc(12); b

which then outputs something along the lines of

            Some
Some            
Some            Value

where the

• value ‘Some’ starts as the 13th character on the 1st line
• 2nd line has 12 training spaces.
• there is a 12 space gap between the words on the 3rd line

Tab(n)

So, in plain English, somewhat like the spc(), tab enables you to position the output to a specific position (column).  Pay particular attention to the term absolute!  so it is not in function of a relative position, but the absolute position which is great for fixed position output.

Thus, we can quickly learn that

Debug.Print a

is the same as

Debug.Print Tab(1); a

as Tab(1) indicates to output the content on the 1st column.

You can also use Tab() to add whitespaces

a = "Some"
b = "Value"
Debug.Print a; Tab(10)

Some     

In the above, it adds 5 spaces, so the next available character would start on the 10th column. Thus, we could use it for fixed length output

a = "Some"
b = "Value"
Debug.Print a; Tab(10); b

Some     Value

Semi-Colon (;)

Let’s talk about the colon (;)!

Normally, when you perform a Print, it outputs the ‘value’ and then you start fresh on a new line.  The ; is a continuation operator telling the output to continue from the current position.  Thus, it allows us to continue to output content on the same line as the previous output.  Now, the example above doesn’t do it justice, so let’s try another more concrete example

a = "Some"
b = "Value"
   
Debug.Print a;
Debug.Print Spc(12);
Debug.Print b

which outputs

Some            Value

So we can now split the Debug.Print into multiple lines while having the output remain on a single line.

This can be very helpful when building long output.  Rather than creating a really long variable, string, … you can simply Debug.Print each on their own line, but use the ; so they continue to print out on the same line in the VBA/VBE Immediate Window.

Here’s a real example

        With oCol
            Debug.Print .Caption
            Debug.Print , .Description;
            Debug.Print , .Domain;
            Debug.Print , .InstallDate;
            Debug.Print , .LocalAccount;
            Debug.Print , .Name;
            Debug.Print , .SID;
            Debug.Print , .SIDType;
            Debug.Print , .Status
        End With

So the outputs 2 lines, one with just the Caption and a 2nd line with all the details for that entry. While Debugging, this format is much easier to read and tweak.

Here’s one more example, used to output the content of a recordset so that each record is on a single line.

Do While rs.EOF = False
    For i = 0 To rs.Fields.Count - 1
        Debug.Print rs(i) & ",";
    Next i
    Debug.Print
    rs.MoveNext
Loop

Comma (,)

The comma!  The comma performs an indentation.  Like the spc() & tab() it can be used to aid legibility, add indentations …

Its usage is very straightforward.  Let’s pretend we’re gathering Disk Drive information and breaking down the partitions by drive.  Now let’s output it using some of the techniques we’ve discussed thus far

a = "Disk 1"
b = "Partition 1"
c = "Partition 2"
d = "Partition 3"
e = "Disk 2"
f = "Partition 1"
g = "Partition 2"

Debug.Print a & " " & b & " " & c & " " & d & " " & e & " " & f & " " & g
Debug.Print
Debug.Print a
Debug.Print b
Debug.Print c
Debug.Print d
Debug.Print e
Debug.Print f
Debug.Print g
Debug.Print
Debug.Print a
Debug.Print , b
Debug.Print , c
Debug.Print , d
Debug.Print e
Debug.Print , f
Debug.Print , g

this will then output something resembling

Disk 1 Partition 1 Partition 2 Partition 3 Disk 2 Partition 1 Partition 2

Disk 1
Partition 1
Partition 2
Partition 3
Disk 2
Partition 1
Partition 2

Disk 1
              Partition 1
              Partition 2
              Partition 3
Disk 2
              Partition 1
              Partition 2

I think it is pretty evident how useful the comma (,) is to making the output MUCH more legible!
 

Printing In The Immediate Window

There are times, debugging being the most common, when you wish to perform a Debug.Print directly in the Immediate Windows itself.  Here we can simplify things and instead of doing

Debug.Print a

We can simply do

? a

The ? replaces Debug.Print when entered directly in the Immediate Window!
 

Limitations

Sadly, you cannot use a With statement, thus something like

With Debug
    .Print a
    .Print b
    .Print C
    .Print d
    .Print e
    .Print f
    .Print g
End With

does not work.

Nor can you just use .Print on its own.

Nor can you use the ? directly in VBA code as it only works in the Immediate Window directly.
 

Useful Resources

Print method (Visual Basic for Applications)

Prints text in the Immediate window.