How to concatenate strings in Go

1The + and += operatorsRecommended

+ is Go's only concatenation operator — there is no ., no .., and no overloading. Both operands must already be strings, and the result is a brand-new string. a += b is exactly a = a + b. For a known, small number of parts this is the fastest and most readable option there is; the compiler even folds constant literals together at build time.

package main

import "fmt"

func main() {
	first := "Compile"
	second := "Bytes"

	full := first + second
	fmt.Println(full)

	// += appends to the variable and reassigns it
	greeting := "Hello, "
	greeting += full
	greeting += "!"
	fmt.Println(greeting)

	// Splitting a long literal: the + must END the line, or Go
	// inserts a semicolon and the next line stops compiling
	msg := "concatenation is " +
		"just a copy"
	fmt.Println(msg)

	// No implicit conversion: "port " + 8080 is a compile error
	fmt.Println("port " + fmt.Sprint(8080))
}

Prints CompileBytes, Hello, CompileBytes!, concatenation is just a copy, then port 8080. Two things bite newcomers here. First, line breaks: Go's automatic semicolon insertion means the + has to end the line, never start the next one. Second, types — mixing in a number is a compile error, not a silent conversion, so reach for strconv.Itoa(n) or fmt.Sprint(n) (see converting between strings and ints).

2Why += in a loop is O(n²)

A Go string value is a two-word header — a pointer to bytes and a length — and those bytes are read-only. s[0] = 'G' does not compile. So s += "x" can't extend anything: it allocates a buffer of len(s)+1 bytes, copies the old string in, appends the new byte, and points s at the result. Do that in a loop and iteration i copies i bytes — the total is n(n+1)/2, quadratic in the length of the output. The snippet below counts those copied bytes instead of timing anything, so the number is exact and identical on every run.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "go"
	// s[0] = 'G'   // compile error: cannot assign to s[0]
	b := []byte(s) // a copy you CAN modify
	b[0] = 'G'
	fmt.Println(s, string(b))

	// += makes a NEW string each time: every byte so far is copied
	// into a fresh allocation, then the old string is garbage.
	out := ""
	copied := 0
	for i := 0; i < 1000; i++ {
		copied += len(out) + 1 // bytes moved into the new allocation
		out += "x"
	}
	fmt.Println("final length:", len(out))
	fmt.Println("bytes copied:", copied)

	// Same 1000 bytes, one buffer, no recopying.
	var sb strings.Builder
	sb.Grow(1000)
	for i := 0; i < 1000; i++ {
		sb.WriteByte('x')
	}
	fmt.Println("builder length:", sb.Len())
	fmt.Println("same string:", out == sb.String())
}

The first line prints go Go — the original is untouched, because []byte(s) made a copy. Then the numbers: final length: 1000 but bytes copied: 500500, i.e. 500× more memory traffic than the result, plus a thousand allocations for the garbage collector to clean up. The builder produces builder length: 1000 and same string: true from a single buffer. Push the loop to 100,000 and += copies 5 billion bytes while the builder still copies 100,000.

3strings.Builder for loops

strings.Builder (Go 1.10+) accumulates bytes in one growable buffer and hands you the finished string with String() — with no copy at the end, because the builder guarantees nobody else holds the buffer. Its zero value is ready to use, so var b strings.Builder is the whole setup. Grow(n) reserves n bytes up front, turning the amortised handful of reallocations into exactly one; the argument is a byte count, not a character count.

package main

import (
	"fmt"
	"strings"
)

func main() {
	parts := []string{"go", "is", "fast"}

	var b strings.Builder
	b.Grow(16) // one allocation up front, if you can estimate the size

	for i, p := range parts {
		if i > 0 {
			b.WriteString(" ")
		}
		b.WriteString(p)
	}
	b.WriteByte('!')

	fmt.Println(b.String())
	fmt.Println("len:", b.Len())

	// A Builder is an io.Writer, so fmt can write straight into it
	b.Reset() // keeps the buffer, drops the contents
	fmt.Fprintf(&b, "%s-%d", "build", 42)
	fmt.Println(b.String())
}

Prints go is fast!, len: 11, then build-42. The four write methods cover everything: WriteString, WriteByte, WriteRune (which encodes to UTF-8 for you) and Write([]byte), and none of them can fail — the returned error is always nil. Two rules: pass a pointer when you hand a builder to another function or to fmt.Fprintf, and never copy a builder after first use — b2 := b panics with illegal use of non-zero Builder copied by value on the next write.

4strings.Join for a slice

When the pieces are already in a []string, stop writing loops: strings.Join(parts, sep) sums the lengths, allocates exactly once, and copies each element in. It is the fastest way to glue a slice together and it gets the separator logic right — the separator goes between elements, so there is no trailing comma to trim and a one-element slice comes back unchanged.

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	parts := []string{"usr", "local", "bin"}

	fmt.Println(strings.Join(parts, "/"))
	fmt.Println(strings.Join(parts, ""))
	fmt.Println(strings.Join(parts[:1], ", ")) // no separator to add
	fmt.Printf("%q\n", strings.Join(nil, ", ")) // empty input -> ""

	// Join only takes []string -- convert other types first
	nums := []int{1, 2, 3}
	strs := make([]string, len(nums))
	for i, n := range nums {
		strs[i] = strconv.Itoa(n)
	}
	fmt.Println(strings.Join(strs, ", "))
}

Prints usr/local/bin, usrlocalbin, usr, "" and 1, 2, 3. A nil or empty slice yields the empty string rather than panicking, and an empty separator makes Join a plain concatenate-everything. The catch is the signature: Join only accepts []string, so ints, floats and structs need a conversion pass first — make the destination at the right length and index into it, never append to a slice you already sized.

5fmt.Sprintf when you are formatting

fmt.Sprintf returns a formatted string instead of printing it, and it is the right tool when the job is formatting — interpolating numbers, padding columns, quoting values — rather than gluing strings. It pays for that with reflection on every argument, which makes it roughly an order of magnitude slower than +. Use it for templates and messages; don't use it to bolt two strings together in a hot loop.

package main

import "fmt"

func main() {
	name, port := "api", 8080

	addr := fmt.Sprintf("%s listening on :%d", name, port)
	fmt.Println(addr)

	// Verbs do the work: %q quotes, %v prints any value, %.2f rounds
	fmt.Println(fmt.Sprintf("%s=%q after %.2fs", "path", "/usr/bin", 1.5))

	// Sprint concatenates operands, adding a space only between two
	// non-strings; Sprintln always spaces and adds a newline
	fmt.Printf("%q\n", fmt.Sprint("a", "b", 1, 2, "c"))
	fmt.Printf("%q\n", fmt.Sprintln("a", 1))
}

Prints api listening on :8080, path="/usr/bin" after 1.50s, then "ab1 2c" and "a 1\n". That third line is the one people get wrong: fmt.Sprint inserts a space only when neither neighbour is a string, which is why a and b run together but 1 and 2 do not. If you want predictable output, spell it out with Sprintf or + instead of relying on that rule.

6bytes.Buffer and append([]byte)

If the destination is bytes — an HTTP body, a file, anything behind an io.Writer — build a []byte and skip the string entirely. bytes.Buffer is the read/write cousin of strings.Builder: same zero-value-ready API, plus Read, Bytes() and WriteTo. Lower still, append on a plain []byte needs no type at all, and the strconv.Append* family formats numbers straight into your buffer with zero intermediate strings.

package main

import (
	"bytes"
	"fmt"
	"strconv"
)

func main() {
	var buf bytes.Buffer
	buf.WriteString("GET ")
	buf.WriteString("/health")
	buf.WriteByte('\n')

	fmt.Print(buf.String())
	fmt.Println("bytes:", buf.Len())

	// No wrapper type at all: append onto a []byte
	out := make([]byte, 0, 32)
	out = append(out, "status="...) // a string spreads into append
	out = strconv.AppendInt(out, 200, 10)
	out = append(out, " ok"...)

	fmt.Println(string(out))
	fmt.Println(len(out), cap(out))
}

Prints GET /health, bytes: 12, status=200 ok and 13 32 — thirteen bytes used of the thirty-two reserved by make, so nothing had to grow. Note append(out, "status="...): Go special-cases spreading a string into a []byte append, no conversion needed. The trade-off versus strings.Builder is one copy: buf.String() allocates a fresh string, because a Buffer can still be written to afterwards.

7Which should you use?