An Introduction to String Formatting in Go

In the Go programming language, string formatting, otherwise known as string interpolation, is when you insert a custom string or variable into predefined text. It works like this:

What you see above isn’t code that would work in any language but it illustrates what I mean. You have the string:

After the word to, you want to insert a custom string (New Stack) into the pre-defined text, such that it would read:

The variable a is our custom string and everything else is the pre-defined text.

The Go language has this capability as well and it’s something you should learn early in your journey.

Before you learn how to format strings in Golang, you’ll need to understand the concept of printing verbs. If you’ve ever written a bash script in Linux, you might find these familiar. These verbs always start with a % character and can be used in a line of your pre-defined text.

Let’s say you have the string:

What you want to do is use string formatting to insert a name and an age into the string. For that, you could use the printing verb %s, which is the basic string printing verb, and the %d verb, which is for standing base-10 formatting (the place value system that uses decimal numbers). The above line, with the verbs added, would look something like this:

A sample of possible string printing verbs includes:

• %b – base-2
• %c – a character represented by its corresponding Unicode value
• %o – base-8
• %O – base-8 with the added Oo prefix
• %q – a single-quoted character
• %x – base-16
• %X – base-16 with upper-case letters
• %U – unicode format
• %b – decimal-less scientific notation with the exponent power of 2.
• %e – scientific notification
• %E – scientific notation with capital letters
• %f – decimal point without an exponent

Of course, it’s not really that simple because you have to do a bit more programming to get it to work. You’ll also need to make use of the Sprintf() function, which returns a formatted string and supports custom format specifiers. Sprintf() is found within the fmt package, so it has to be imported before your applications can use the functionality.

There’s also the printf() function. What’s the difference? Simply put, printf() sends output to stdout (standard output stream) and Sprintf() stores the formatted data in a buffer that you allocate. In our example below, we’ll use both of these functions, the first to store the string in a buffer and the second to print the buffer to standard output.

Okay, let’s format a string.

We’ll create the application as I described above, which will print out your name and age accordingly.

The first thing we’ll do is inform the Go compiler that the package should compile as an executable program. We do that with the line:

Next, we import the fmt package with:

Now, we’ll define our function with main(), which will define two variables (name and age) format the string, and then print the string. The function looks like this:

The := operator is used to declare a variable, which is unlike =, as that is used to change a variable’s value.

Think of := this way:

is shorthand for:

Essentially := allows you to both declare and define a variable in a single line.

Now that you understand this concept, you should be able to grasp the function above.

We put the whole thing together like so:

Create the file with the name format.go. Save and close the file. You can then run the code with the command:

The output will be something like this:

If you want to compile that into an executable, the command would be:

There’s another handy trick you might want to use with your printing verbs to format numbers. Say, for instance, you want to specify some padding for spaces in your numbers, which can help set numbers off or even allow you to print things out in columns (which, of course, requires some trickery with spacing).

Let’s say (using our example above) that you want to add some spaces before the age. When you do this, it will automatically right-justify the number and pad its left side with spaces. For example, %6d will add 6 spaces to the left of the number. That line would then look like:

What if you wanted to format that output so the name is on one line and the age is on another? For that, you could use the newline string (\n) like so:

The output of that would be:

Ah, the simplicity and flexibility of Golang string formatting. Once you start using this, you start to see just how important the concept is.

Jack Wallen is what happens when a Gen Xer mind-melds with present-day snark. Jack is a seeker of truth and a writer of words with a quantum mechanical pencil and a disjointed beat of sound and soul. Although he resides...

Read more from Jack Wallen