Learn the coding skills for your next job

Concatenating with strings.Builder Quickly in Golang

The Go standard library makes concatenating strings easy. Concatenation is just a fancy word for adding strings together to make a larger string. For example, if we concatenate "hello", " " and "world" we’d get "hello world".

The built-in fmt.Sprintf function takes a format and a variadic list of interfaces as input.

func Sprintf(format string, a ...interface{}) string
Code language: Go (go)

The formatting option lets us template out how the final string will look, then we can add inputs that will be interpolated into the string.

s := fmt.Sprintf("%v has been subscribed since %v.\n", user.Name, user.CreatedAt)
Code language: Go (go)

%v is a simple token that will be replaced by the default format of whatever the given arguments are. In our case, it was a string and a time.Time. Check out the documentation for all the formatting options.

Learn the Go the right way

Go is the language of cloud-native technologies. If you’re interested in modern web systems then our Go Mastery track of courses and projects will give you all the skills you need to have a successful switch.

Efficient string concatenation

Go 1.10+ released the awesome strings.Builder type, which lets us more efficiently build strings. Because it minimizes memory copying, strings.Builder is a high-performance option when it comes to doing bulk string concatenation.

Quickly writing a user list – example

First, let’s create an empty builder.

var builder strings.Builder
Code language: Go (go)

Next, let’s add a title string to our list.

b.WriteString("user list\n")
Code language: Go (go)

Now we’ll iterate from 0-9, and for each number write a line containing “user #{i}“. Because strings.Builder implements the io.Writer interface, we can use the standard fmt.Fprintf function.

for i := 0; i < 10; i++ { fmt.Fprintf(&b, "user #%d\n", i) }
Code language: Go (go)

To actually print the full string we can use the String() method.

Code language: Go (go)

Full code:

package main import ( "fmt" "strings" ) func main() { var b strings.Builder     b.WriteString("user list\n")     for i := 0; i < 10; i++ {         fmt.Fprintf(&b, "user #%d\n", i)     }     fmt.Println(b.String()) }
Code language: Go (go)

Preallocation for more speed

If you really want to speed up your string building, and you already know the size of your final string, you can use the builder’s Grow() method to preallocate the size of the buffer. This saves your code from needing to grow the memory dynamically.

// Grow grows b's capacity, if necessary, to guarantee space for another n bytes. // After Grow(n), at least n bytes can be written to b without another allocation. // If n is negative, Grow panics. func (b *Builder) Grow(n int)
Code language: Go (go)

So to preallocate for our example we could do the following.

package main import ( "fmt" "strings" ) func main() { var b strings.Builder b.Grow(90) // we will be writing 90 bytes     b.WriteString("user list\n")     for i := 0; i < 10; i++ {         fmt.Fprintf(&b, "user #%d\n", i)     }     fmt.Println(b.String()) }
Code language: Go (go)

Trying to find your next programming job?

If you are a self-taught developer having trouble finding your first programming job, we've got your back! We have the learning resources and tight-knit dev community that you need to land the coding job you've been looking for. To get started, create a free account and join our Discord community.

Have questions or feedback?

If we've made a mistake in the article, please let us know so we can get it corrected!