As a developer, we should be aware of all the available ways to implement a solution. This gives us the edge to implement a solution as per the needs.
In this short tutorial, you will learn multiple ways to concatenate a string and which is the fastest.
We will add benchmark testing, to analyse the performance of the function. The results may vary for you due to the machine.
Using Plus (+) Operator
The plus operator is not only used for integers and float but it can be used to concatenate strings, provided the operants are of string type.
// file: main.go
package main import "fmt" func main() { fmt.Println(plusOperator())
} func plusOperator() string { s1 := "practice" s2 := "go" return (s1 + s2)
}
Benchmark Test
// file: main_test.go
package main import "testing" func BenchmarkPlusOperator(b *testing.B) { for i := 0; i < b.N; i++ { plusOperator() }
} Output
~ go test -bench=.
goos: darwin
goarch: arm64
pkg: cb/practicegocode
BenchmarkPlusOperator-11 118339720 10.23 ns/op
PASS
ok Using Append (+=) Operator
The append operator appends one string to another.
// file: main.go
package main func main {
... func appendOperator() string { s1 := "practice" s2 := "go" s1 += s2 return s2
}
Benchmark Test
// file: main_test.go
package main import "testing" func BenchmarkAppendOperator(b *testing.B) { for i := 0; i < b.N; i++ { appendOperator() }
}
Output
~ go test -bench=.
goos: darwin
goarch: arm64
pkg: cb/practicegocode
BenchmarkAppendOperator-11 64080028 17.60 ns/op
PASS
ok Using Sprintf function
The fmt.Sprintf function is available in fmt package. This should be only used when you have to format a string of different data types or in a certain format.
// file: main.go
package main func main() {
... func sprintf() string { s1 := "practice" s2 := "go" return fmt.Sprintf("%s%s", s1, s2)
}
Benchmark Test
// file: main_test.go
package main import "testing" func BenchmarkSprintfOperator(b *testing.B) { for i := 0; i < b.N; i++ { sprintf() }
}
Output
~ go test -bench=.
goos: darwin
goarch: arm64
pkg: cb/practicegocode
BenchmarkSprintfOperator-11 16939860 70.79 ns/op
PASS
ok Using strings.Builder
The strings.Builder method appends the bytes of s1 and s2 strings to the str bytes.
// file: main.go
package main func main() {
... func stringBuilder() string { s1 := "practice" s2 := "go" var str strings.Builder str.WriteString(s1) str.WriteString(s2) return str.String()
}
Benchmark Test
// file: main_test.go
package main import "testing" func BenchmarkStringsBuilderOperator(b *testing.B) { for i := 0; i < b.N; i++ { stringsBuilder() }
}
Output
~ go test -bench=.
goos: darwin
goarch: arm64
pkg: cb/practicegocode
BenchmarkStringsBuilderOperator-11 42873091 26.40 ns/op
PASS
ok Final Test
Lets run all the benchmark tests together.
Output
BenchmarkPlusOperator-11 115559880 10.13 ns/op
BenchmarkAppendOperator-11 62112871 17.74 ns/op
BenchmarkSprintfOperator-11 16762341 72.46 ns/op
BenchmarkStringsBuilderOperator-11 45078675 26.17 ns/op
Conclusion
The + operator is the fastest way to concatenate strings and fmt.Sprintf is the slowest.
<----------------Fastest-------------------- + > += > strings.Builder > fmt.Sprintf ----------------Slowest--------------------> You can also watch this tutorial
You can connect with me at:
Dev.to
YouTube Channel
Personal Blog
Linkedin
Twitter
Discover more from Coursity
Subscribe to get the latest posts sent to your email.