Golang string interpolation Explained [With Examples]

What is String Interpolation

String interpolation is the process of inserting data from a variable or expression into a placeholder within a string. It is an important feature because it enables us to provide our applications more readable and flexible instead of hard coding.

 

Different formatting functions in GO

The following table describes the functions provided by the fmt package, which can format strings

Advertisement
Name Description
Sprintf(t, ...vals) This function returns a string, which is created by processing the template t. The remaining arguments are used as values for the template verbs.
Printf(t, ...vals) This function creates a string by processing the template t. The remaining arguments are used as values for the template verbs. The string is written to the standard out.
Fprintf(writer, t, ...vals) This function creates a string by processing the template t. The remaining arguments are used as values for the template verbs. The string is written to a Writer.
Errorf(t, ...values) This function creates an error by processing the template t. The remaining arguments are used as values for the template verbs. The result is an error value whose Error method returns the formatted string.

 

Using General-Purpose Formatting Verbs

The general-purpose verbs can be used to display any value as described in below table.

Verb Description
%v This verb displays the default format for the value. Modifying the verb with a plus sign (%+v) includes field names when writing out struct values.
%#v This verb displays a value in a format that could be used to re-create the value in a Go code file.
%T This verb displays the Go type of a value.

 

Using Integer Formatting Verbs

The following table describes the formatting verbs for integer values, regardless of their size.

Verb Description
%b This verb displays an integer value as a binary string.
%d This verb displays an integer value as a decimal string. This is the default format for integer values, applied when the %v verb is used.
%o, %O These verbs display an integer value as an octal string. The %O verb adds the 0o prefix.
%x, %X These verbs display an integer value as a hexadecimal string. The letters A–F are displayed in lowercase by the %x verb and in uppercase by the %X verb.

 

Using Floating-Point Formatting Verbs

The following table describes the formatting verbs for floating-point values, which can be applied to both float32 and float64 values.

Verb Description
%b This verb displays a floating-point value with an exponent and without a decimal place.
%e, %E These verbs display a floating-point value with an exponent and a decimal place. The %e uses a lowercase exponent indicator, while %E uses an uppercase indicator.
%f, %F These verbs display a floating-point value with a decimal place but no exponent. The %f and %F verbs produce the same output.
%g This verb adapts to the value it displays. The %e format is used for values with large exponents, and the %f format is used otherwise. This is the default format, applied when the %v verb is used.
%G This verb adapts to the value it displays. The %E format is used for values with large exponents, and the %f format is used otherwise.
%x, %X These verbs display a floating-point value in hexadecimal notation, with lowercase (%x) or uppercase (%X) letters.

 

Using String and Character Formatting Verbs

The below table describes the formatting verbs for strings

Verb Description
%s This verb displays a string. This is the default format, applied when the %v verb is used.
%c This verb displays a character. Care must be taken to avoid slicing strings into individual bytes, as explained in the text after the table.
%U This verb displays a character in the Unicode format so that the output begins with U+ followed by a hexadecimal character code.

 

Using Boolean Formatting Verb

We can use %t where this verb formats bool values and displays true or false. Here we have a simple go code where we check the length of a variable and print the Boolean value.

package main

import "fmt"

func Printfln(template string, values ...interface{}) {
	fmt.Printf(template+"\n", values...)
}
func main() {
	name := "GoLinuxCloud"
	Printfln("Bool: %t", len(name) > 1)
	Printfln("Bool: %t", len(name) > 100)
}

Output:

Advertisement
$ go run main.go 
Bool: true
Bool: false

 

Using Pointer Formatting Verb

We can use %p where this verb displays a hexadecimal representation of the pointer’s storage location. Here is a small code to demonstrate this verb:

package main

import "fmt"

func Printfln(template string, values ...interface{}) {
	fmt.Printf(template+"\n", values...)
}

func main() {
	name := "GoLinuxCloud"
	Printfln("Pointer: %p", &name)
}

In the output we can see hexadecimal format of the pointer location:

$ go run main.go 
Pointer: 0xc000010230

 

Method 1: Using Sprintf() function

We can include string interpolation in Go using the Sprintf() function:

func Sprint(a ...any) string: Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

This method is defined in the fmt package. Hence, we need to import it before using it:

import "fmt"

Here’s an example of using the Sprintf() function:

package main

import "fmt"

func main() {
	thisYear := 2022
	thisMonth := 9
	thisDay := 13
	thisHour := 10
	thisMinute := 30
	thisSecond := 45
	// date is a string which relaces variables into placeholders
	thisDate := fmt.Sprintf("%d-%d-%d", thisYear, thisMonth, thisDay)
	thisTime := fmt.Sprintf("%d:%d:%d", thisHour, thisMinute, thisSecond)
	dateTime := fmt.Sprintf("Date: %s, Time: %s", thisDate, thisTime)
	// print the string variables
	fmt.Println(thisDate)
	fmt.Println(thisTime)
	fmt.Println(dateTime)
}

Output:

$ go run main.go
2022-9-13
10:30:45
Date: 2022-9-13, Time: 10:30:45

 

Method 2: Using Printf() function

The Printf() function can be used to print the formatted string to the console. The only difference between Sprintf() and Printf() is that Sprintf() writes data into a character array, while Printf() writes data to stdout, the standard output device.

func Printf(format string, a ...any) (n int, err error): Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

Here’s an example of using the Printf() function:

package main

import "fmt"

func main() {
	thisYear := 2022
	thisMonth := 9
	thisDay := 13
	thisHour := 10
	thisMinute := 30
	thisSecond := 45
	// directly print formatted string to console
	fmt.Printf("%d-%d-%d", thisYear, thisMonth, thisDay)
	fmt.Println()
	fmt.Printf("%d:%d:%d", thisHour, thisMinute, thisSecond)
}

Output:

$ go run main.go
2022-9-13
10:30:45

 

Method 3: Using Fprintf() function

The syntax here is func fmt.Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)

Advertisement

The fmt package also provides functions for writing formatted strings to a Writer, Fprintf formats according to a format specifier and writes to w. It returns the number of bytes written and any write error encountered.

package main

import (
	"fmt"
	"io"
	"strings"
)

func writeFormatted(writer io.Writer, template string, vals ...interface{}) {
	fmt.Fprintf(writer, template, vals...)
}
func main() {
	var writer strings.Builder
	template := "Name: %s, Category: %s, Price: $%.2f"
	writeFormatted(&writer, template, "Car", "Honda", float64(3500))
	fmt.Println(writer.String())
}

The writeFormatted function uses the fmt.Fprintf function to write a string formatted with a template to a Writer. Compile and execute the project, and you will see the following output:

$ go run main.go 
Name: Car, Category: Honda, Price: $3500.00

 

Method-4: Using Errorf() function

The syntax for declaration is func fmt.Errorf(format string, a ...interface{}) error

Errorf formats according to a format specifier and returns the string as a value that satisfies error. If the format specifier includes a %w verb with an error operand, the returned error will implement an Unwrap method returning the operand. It is invalid to include more than one %w verb or to supply it with an operand that does not implement the error interface. The %w verb is otherwise a synonym for %v.

package main

// Importing fmt
import (
	"fmt"
)

// Calling main
func main() {

	// Declaring some constant variables
	const (
		Name   = "Deepak"
		Age    = 34
		Salary = 1500.50
	)

	// Calling the Errorf() function with verb
	// %v which is used for a string character
	// %d is used for integer character
	// %.2f is used to specify the number of digits after the decimal place in floating character
	err := fmt.Errorf("employee %v of age %d has salary of %.2f", Name, Age, Salary)

	// Printing the error message
	fmt.Println(err.Error())
}

Output:

$ go run main.go 
employee Deepak of age 34 has salary of 1500.50

 

Advertisement

Summary

In this short article, we discussed how to perform string interpolation in the Go programming language. You may notice that the method of string interpolation in Go is very different from other languages such as Python. This is because Go is a statically typed language and it does matter the type of value you interpolate.

 

References

https://pkg.go.dev/fmt#Printf
https://pkg.go.dev/fmt

 

Didn't find what you were looking for? Perform a quick search across GoLinuxCloud

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can either use the comments section or contact me form.

Thank You for your support!!

Leave a Comment

X