The fastest way to concatenate strings in Golang
Tags: go, webdev, softwaredevelopment
Published: 2024-04-30 16:43:36

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
{% embed https://www.youtube.com/watch?v=u2VnLNq8qDw&ab_channel=practicego %}

You can connect with me at:
[Dev.to](https://dev.to/schadokar)
[YouTube Channel](https://www.youtube.com/@practicego)
[Personal Blog](https://schadokar.dev)
[Linkedin](https://linkedin.com/in/schadokar)
[Twitter](https://twitter.com/schadokar1)

---