Apps Artificial Intelligence CSS DevOps Go JavaScript Laravel Linux MongoDB MySQL PHP Python Rust Svelte Vue

Efficient String Concatenation in Go

1 min read .
Updated on
Efficient String Concatenation in Go

String concatenation appears everywhere in Go programs: generating text, building paths, formatting reports, or assembling protocol messages. The best technique depends on how many pieces you are joining and how the data is already structured.

1. The + Operator

For a small, fixed number of strings, + is clear and perfectly reasonable:

str1 := "Hello, "
str2 := "world!"
result := str1 + str2

Avoid repeatedly growing a string with + inside a large loop, because each result is a new immutable string and repeated copying can become expensive.

2. strings.Join

When the pieces already live in a slice, strings.Join is usually the clearest option:

parts := []string{"Hello", "world", "from", "Go!"}
result := strings.Join(parts, " ")

It is concise, takes a separator directly, and can allocate efficiently because it knows all inputs in advance.

3. bytes.Buffer

bytes.Buffer is useful when you are building bytes and strings together or when the result will also be consumed through byte-oriented APIs:

var buffer bytes.Buffer
buffer.WriteString("Hello, ")
buffer.WriteString("world!")
result := buffer.String()

It remains a useful standard-library type; it is not merely a legacy option.

4. strings.Builder

When the final result is a string and you are writing many pieces incrementally, strings.Builder is often a good default:

var builder strings.Builder
builder.WriteString("Hello, ")
builder.WriteString("world!")
result := builder.String()

If you can estimate the final size, call Grow first to reduce reallocations:

var builder strings.Builder
builder.Grow(128)
builder.WriteString("prefix: ")
builder.WriteString(value)
result := builder.String()

Quick Comparison

Method Best fit
+ A few fixed string expressions
strings.Join Joining a slice with a separator
bytes.Buffer Mixed byte/string construction or byte-oriented APIs
strings.Builder Incrementally building a string, especially in loops

Measure Before Optimizing

For small strings, readability matters more than tiny allocation differences. If concatenation is on a performance-sensitive path, benchmark the actual workload with Go’s testing package rather than assuming one technique will always be fastest.

Conclusion

Use + for simple expressions, strings.Join for slices, and strings.Builder when building a string incrementally. bytes.Buffer remains valuable when your work is naturally byte-oriented. Choosing the method that matches the data shape usually gives both readable code and good performance.

Golang

Related Posts

Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter
Updated on
Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter
Go arrays and slices are straightforward once you understand their different roles. Arrays have a fixed length that is part of their type, while slices are flexible views over an underlying array and are the collection type used most often in application code. The following examples use a slice of structs: Copy type Person struct { Name string Age int } people := []Person{ {Name: "Alice", Age: 30}, {Name: "Bob", Age: 25}, {Name: "John", Age: 20}, {Name: "Zara", Age: 35}, } 1. Add an Element Use append:
Golang Array Slice
Build a CRUD API with Go, Gin, MySQL, and GORM
Updated on
Build a CRUD API with Go, Gin, MySQL, and GORM
This tutorial builds a small CRUD API with Go, the Gin web framework, MySQL, and GORM. It also uses godotenv for local development configuration. 1. Create the Project Copy mkdir myapp cd myapp go mod init myapp 2. Install Dependencies Copy go get github.com/gin-gonic/gin go get gorm.io/gorm go get gorm.io/driver/mysql go get github.com/joho/godotenv Run go mod tidy after adding your imports so the module file reflects the dependencies actually used by the application.
Golang Gin MySQL GORM
Deploy a Go Web Server with systemd on Linux
Updated on
Deploy a Go Web Server with systemd on Linux
When developing a small Go web server, it is common to run it manually with go run main.go. The problem is that the process stops when the terminal closes, and it will not automatically return after a server reboot. A better production setup is to run the application as a systemd service. That gives you automatic startup, monitoring, service management, and optional restart behavior after failures. 1. Create a Simple Go Web Server Start with a minimal HTTP server:
Golang systemd
Easy Ways to Convert an Integer to a String in Go
Updated on
Easy Ways to Convert an Integer to a String in Go
Converting an integer to a string is common when building output, logs, identifiers, URLs, or serialized data. Go provides several standard-library options depending on whether you need a simple decimal conversion or more control over formatting. 1. strconv.Itoa() For an int in base 10, strconv.Itoa is usually the clearest choice: Copy package main import ( "fmt" "strconv" ) func main() { num := 42 str := strconv.Itoa(num) fmt.Println("String value:", str) } Itoa is equivalent to formatting the int as a base-10 integer.
Golang
Generate Random Strings in Go
Updated on
Generate Random Strings in Go
Random strings are useful for temporary identifiers, test data, filenames, invitation codes, and security-sensitive tokens. Go offers different random-number sources, and choosing the correct one matters. 1. math/rand for Non-Security Uses For simulations, test fixtures, randomized UI behavior, or other cases where predictability is not a security problem, math/rand is appropriate. With modern Go, create an explicit generator when you need independent pseudo-random state: Copy package main import ( "fmt" "math/rand" ) const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" func GenerateRandomString(r *rand.Rand, length int) string { result := make([]byte, length) for i := range result { result[i] = alphabet[r.Intn(len(alphabet))] } return string(result) } func main() { r := rand.New(rand.NewSource(42)) fmt.Println(GenerateRandomString(r, 10)) } A fixed seed is useful for reproducible tests. Do not use math/rand for secrets, session tokens, password-reset tokens, or other authentication material.
Golang
How to Check Whether a File Exists in Go
Updated on
How to Check Whether a File Exists in Go
Checking whether a file exists is a common task when working with configuration, local state, generated output, or other filesystem resources. Go’s os package provides the necessary APIs, but it is important to distinguish “does not exist” from other errors such as permission failures. 1. Check with os.Stat os.Stat returns file metadata when the path can be resolved: Copy package main import ( "errors" "fmt" "os" ) func fileExists(filename string) (bool, error) { _, err := os.Stat(filename) if err == nil { return true, nil } if errors.Is(err, os.ErrNotExist) { return false, nil } return false, err } func main() { filename := "example.txt" exists, err := fileExists(filename) if err != nil { fmt.Println("Error:", err) return } if exists { fmt.Printf("File '%s' exists.\n", filename) } else { fmt.Printf("File '%s' does not exist.\n", filename) } } Returning an error prevents permission or I/O problems from being mistaken for a missing file.
Golang
chevron-up