How to Join Strings in Go: Simple and Effective Methods

In Go, you can join strings using the strings.Join function from the strings package, which concatenates a slice of strings with a separator. Alternatively, you can use the + operator for simple concatenation of two strings.

Syntax

The main way to join multiple strings in Go is with strings.Join(slice []string, sep string) string. It takes a slice of strings and a separator string, then returns one combined string.

• slice []string: The list of strings to join.
• sep string: The string placed between each element.
• Returns a single string with all elements joined by the separator.

go

import "strings"

joined := strings.Join([]string{"apple", "banana", "cherry"}, ", ")
// joined is "apple, banana, cherry"

Example

This example shows how to join a slice of strings with a comma and space separator, and also how to concatenate two strings using the + operator.

go

package main

import (
	"fmt"
	"strings"
)

func main() {
	fruits := []string{"apple", "banana", "cherry"}
	joined := strings.Join(fruits, ", ")
	fmt.Println("Joined with strings.Join:", joined)

	first := "Hello"
	second := "World"
	concatenated := first + " " + second
	fmt.Println("Concatenated with + operator:", concatenated)
}

Output

Joined with strings.Join: apple, banana, cherry
Concatenated with + operator: Hello World

Common Pitfalls

One common mistake is trying to join strings without importing the strings package. Another is using + to join many strings in a loop, which can be inefficient. For joining many strings, use strings.Builder for better performance.

go

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Inefficient way: joining many strings with + in a loop
	words := []string{"Go", "is", "fun"}
	result := ""
	for _, w := range words {
		result += w + " "
	}
	fmt.Println("Inefficient join:", result)

	// Efficient way: using strings.Builder
	var builder strings.Builder
	for _, w := range words {
		builder.WriteString(w)
		builder.WriteString(" ")
	}
	fmt.Println("Efficient join:", builder.String())
}

Output

Inefficient join: Go is fun 
Efficient join: Go is fun 

Quick Reference

Here is a quick summary of string joining methods in Go:

Method	Usage	Notes
strings.Join	Join([]string, sep string) string	Best for joining slices with separator
+ operator	string + string	Simple concatenation of two strings
strings.Builder	Use WriteString in loop	Efficient for many concatenations
fmt.Sprintf	fmt.Sprintf("%s%s", a, b)	Flexible but slower

Key Takeaways

Use strings.Join to join multiple strings with a separator efficiently.

The + operator works well for simple concatenation of two strings.

Avoid using + in loops for many strings; prefer strings.Builder for performance.

Always import the strings package to use strings.Join.

strings.Builder helps build strings efficiently when joining many parts.