How to reverse a string in Go
Tags: go, tutorial, beginners, programming
Published: 2022-11-22 09:41:19

---

In this article you’ll learn about how you can reverse a string using multiple ways in Golang, as of now in Golang, there is no built-in method to reverse a string yet, so we will create our own function to reverse a string.

In Golang, a string is a sequence of UTF-8 bytes. According to the UTF-8 encoding standard, ASCII characters are single-byte. However, other characters range between 1 and 4 bytes, because of this inconsistency, it is nearly impossible to index a specific character inside a string.

If we want to index a character in Golang, we can convert a string to an array or rune. A rune is basically a Unicode point. A Unicode point refers to a numerical value representing a Unicode character.

### Ways to reverse string in Golang
Below is the all ways to reverse a string in Golang:
- Simply append string
- Reverse a string — Rune by Rune
- Reverse a String — Swap Left Rune with Right
- From right side

These are the all possible implementations you will see in the action below, so without taking any extra time let’s see the implementations one by one.

### 1. Simply append string
This example declares an empty string and then starts appending the characters from the end, one by one.

#### Algorithm:
Let’s go through the approach to solve this problem first.

- 1. Step 1: Define a function that accepts a string as a parameter.
- 2. Step 2: Iterate over the input string and prepend the characters one by one to the resultant string.
- 3. Step 3: Return the resultant string.

#### Code:
Below is the code of the following way:

```go
package main

import (
    "fmt"
)

// approach 1
// function, which takes a string as
// argument and return the reversed string.
func reverse(s string) string {
    var str string
    for _, v := range s {
        str = string(v) + str
    }
    return str
}

func main() {
    s := "programmingeeksclub"
    fmt.Println("original string:", s)
    r := reverse(s)
    fmt.Println("reversed string:", r)
}
```

#### Explanation:

- Line 10–15: We created a reverse() function, The function accepts a string as parameter, iterates over it, and prepends each character to str variable which is type string. At the end of the reverse function, it returns the str variable with reversed string.
- Line 19: We declared a string variable named s inside the main() function.
- Line 20: We are printing the s variable which is not yet reversed.
- Line: 21: We called reverse() function and passed s variable to reverse() function and we stored the returned value from reverse() to r variable.
- Line 22: We output the result of the reversed string on the console.
Below is the output of the following code:

```bash
$ go run main.go
original string: programmingeeksclub
reversed string: bulcskeegnimmargorp
```

> Reversing a string by character is very similar to the process to reverse an array. The difference is that strings are immutable in Go. Therefore, we must first convert the string to a mutable array of runes ([]rune), perform the reverse operation on that, and then re-cast to a string and return back the reversed string.

### 2. Reverse a string — Rune by Rune
This example first appends the provided string to the rune variable and then declares another variable type rune to store the reversed characters one by one.

#### Algorithm:
Let’s go through the approach to solve this problem.
- Step 1: Define a function named reverse that accepts a string as a parameter.
- Step 2: Declare a variable type []rune and initialize the parameter value into []rune variable, like this []rune(parameter).
- Step 3: Declare another variable of type []rune, this variable will have our reversed characters and will be used to return reversed string.
- Step 4: Iterate over in reverse on the input runes(step 2) and append the characters one by one to the resultant rune variable(step 3).
- Step 5: Convert step 3 []rune to string and return the resultant as string.

#### Code:
Below is the code of the following way:

```go
package main

import (
    "fmt"
)

// approach 2
// function, which takes a string as
// argument and return the reversed string.
func reverse(s string) string {
    rune_arr := []rune(s)
    var rev []rune
    for i := len(rune_arr) - 1; i >= 0; i-- {
        rev = append(rev, rune_arr[i])
    }
    return string(rev)
}

func main() {
    s := "programmingeeksclub"
    fmt.Println("original string:", s)
    r := reverse(s)
    fmt.Println("reversed string:", r)
}
```

#### Explanation:

- Line 10–16: We created a function called reverse(), The function accepts a string as parameter(argument), then we declared a rune_arr type []rune variable and at the same time passed the value of parameter to rune_arr, in next step we declared rev variable of type []rune, iterates over rune_arr in reverse, and appends each character to rev variable which is of type rune. At the end of the reverse function, and before returns if converts the rev variable into string and then returns with reversed string.
- Line 20: We declared a string variable named s inside the main() function.
- Line 21: We are printing the s variable which is not yet reversed.
- Line: 22: We called reverse() function and passed s variable to reverse() function and we stored the returned value from reverse() to r variable.
- Line 23: We output the result of the reversed string on the console.

Below is the output of the following code:

```bash
$ go run main.go
original string: programmingeeksclub
reversed string: bulcskeegnimmargorp
```

### 3. Reverse a String — Swap Left Rune with Right
This example simply first appends the provided string to the rune variable and then iterates over the slice of rune and swaps each left index with right characters one by one and returns back the reversed rune as string.

#### Algorithm:
Let’s go through the approach to solve this problem.

- Step 1: Define a function named reverse that accepts a string as a parameter.
- Step 2: Declare a variable type []rune and initialize the parameter value into []rune variable, like this []rune(parameter).
- Step 3: Iterate over on the input runes(step 2) and swap the characters one by one with left to right.
- Step 4: Convert step 2 []rune to string and return the resultant as string.

#### Code:
Below is the code of the following way:

```go
package main

import (
    "fmt"
)

// approach 3
// function, which takes a string as
// argument and return the reverse of string.
func reverse(s string) string {
    rns := []rune(s)
    for i, j := 0, len(rns)-1; i < j; i, j = i+1, j-1 {
        rns[i], rns[j] = rns[j], rns[i]
    }
    return string(rns)
}

func main() {
    s := "https://programmingeeksclub.com/"
    fmt.Println("original string:", s)
    r := reverse(s)
    fmt.Println("reversed string:", r)
}
```

#### Explanation:

- Line 10–15: We created a reverse() function, The function accepts a string as parameter, declares a rns type []rune variable and at the same time passes the value of parameter to rns, iterates over it, and swaps characters one by one. At the end of the reverse function, it returns the rns variable, but before we’re converting a slice of rune back to string then returning with reversed string.
- Line 19: We declared a string variable named s inside the main() function.
- Line 20: We are printing the s variable which is not yet reversed.
- Line: 21: We called reverse() function and passed s variable to reverse() function and we stored the returned value from reverse() to r variable.
- Line 22: We output the result of the reversed string on the console.

Below is the output of the following code:

```bash
$ go run main.go
original string: https://programmingeeksclub.com/
reversed string: /moc.bulcskeegnimmargorp//:sptth
```

### 4. From right side
This example declares an empty string and then starts appending the characters from the last index, one by one.

#### Algorithm:
Let’s go through the approach to solve this problem first.

- Step 1: Define a function that accepts a string as a parameter.
- Step 2: Declare a string builder type variable to hold the reversed string.
- Step 3: Iterate over the input string and prepend the characters one by one from last index to first, into the resultant string.
- Step 4: Return the resultant string.

#### Code:
Below is the code of the following way:

```go
package main

import (
    "fmt"
    "strings"
)

// approach 4
// function, which takes a string as
// argument and return the reverse of string.
func reverse(s string) string {
    var str strings.Builder
    str.Grow(len(s) - 1)
    for idx := range s {
        str.Write(([]byte{s[(len(s)-1)-idx]}))
    }
    return str.String()
}

func main() {
    s := "https://dailynews.programmingeeksclub.com/"
    fmt.Println("original string:", s)
    r := reverse(s)
    fmt.Println("reversed string:", r)
}
```
Now one thing comes in mind why i used strings.Builder type here instead of string, well strings.Builder do concatenation faster than using += for string

#### Explanation:

- Line 11–17: We created a reverse() function, The function accepts a string as parameter, iterates over it, and appends each character to str variable which is type strings.Builder. At the end of the reverse function, it returns the str variable with reversed string.
- Line 21: We declared a string variable named s inside the main() function.
- Line 22: We are printing the s variable which is not yet reversed.
- Line: 23: We called reverse() function and passed s variable to reverse() function and we stored the returned value from reverse() to r variable.
- Line 24: We output the result of the reversed string on the console.

Below is the output of the following code:

```bash
$ go run main.go
original string: https://dailynews.programmingeeksclub.com/
reversed string: /moc.bulcskeegnimmargorp.swenyliad//:sptth
```
There are many more ways to reverse a string in Golang, I’ll leave other on you, write some code, you can send your code to us as well if you want your code to be feature in this article, what you have to do is just write your code and explain in the way I have done in this article.

Now let’s see some benchmark results of the mentioned ways which one is the fastest one to use in your production code.

### Benchmark
Create a file called main_test.go and paste the following code in it.

```go
package main

import (
    "strings"
    "testing"
)

func SimpleReverse(s string) string {
    var str string
    for _, v := range s {
        str = string(v) + str
    }
    return str
}

// Benchmark
// goos: windows
// goarch: amd64
// pkg: reverse_string
// cpu: Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz
// BenchmarkSimpleReverse-6                     636098          1727 ns/op        1088 B/op          42 allocs/op

func SwapReverse(s string) string {
    rns := []rune(s)
    for i, j := 0, len(rns)-1; i < j; i, j = i+1, j-1 {
        rns[i], rns[j] = rns[j], rns[i]
    }
    return string(rns)
}

// Benchmark
// goos: windows
// goarch: amd64
// pkg: reverse_string
// cpu: Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz
// BenchmarkSwapReverse-6                      3002754           401.2 ns/op         224 B/op           2 allocs/op

func UsingStrBuilderToReverse(s string) string {
    var str strings.Builder
    str.Grow(len(s) - 1)
    for idx := range s {
        str.Write(([]byte{s[(len(s)-1)-idx]}))
    }
    return str.String()
}

// Benchmark
// goos: windows
// goarch: amd64
// pkg: reverse_string
// cpu: Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz
// BenchmarkUsingStrBuilderToReverse-6         7319005           166.3 ns/op         144 B/op           2 allocs/op

func RunesReverse(s string) string {
    rune_arr := []rune(s)
    var rev []rune
    for i := len(rune_arr) - 1; i >= 0; i-- {
        rev = append(rev, rune_arr[i])
    }
    return string(rev)
}

// Benchmark
// goos: windows
// goarch: amd64
// pkg: reverse_string
// cpu: Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz
// BenchmarkRunesReverse-6                     1798329           677.3 ns/op         728 B/op           8 allocs/op

func ReadFromRightReverse(s string) string {
    r := make([]byte, len(s))
    for i := 0; i < len(s); i++ {
        r[i] = s[len(s)-1-i]
    }
    return string(r)
}

// Benchmark
// goos: windows
// goarch: amd64
// pkg: reverse_string
// cpu: Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz
// BenchmarkReadFromRightReverse-6            14868045            81.20 ns/op          96 B/op           2 allocs/op

func ReadFromRightBytesReverse(s string) string {
    var byte strings.Builder
    byte.Grow(len(s))
    for i := len(s) - 1; i >= 0; i-- {
        byte.WriteByte(s[i])
    }
    return byte.String()
}

// Benchmark
// goos: windows
// goarch: amd64
// pkg: reverse_string
// cpu: Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz
// BenchmarkReadFromRightBytesReverse-6       13467786            88.55 ns/op          48 B/op           1 allocs/op

func BenchmarkSimpleReverse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := "https://dailynews.programmingeeksclub.com/"
        SimpleReverse(s)
    }
}

func BenchmarkSwapReverse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := "https://dailynews.programmingeeksclub.com/"
        SwapReverse(s)
    }
}

func BenchmarkUsingStrBuilderToReverse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := "https://dailynews.programmingeeksclub.com/"
        UsingStrBuilderToReverse(s)
    }
}

func BenchmarkRunesReverse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := "https://dailynews.programmingeeksclub.com/"
        RunesReverse(s)
    }
}

func BenchmarkReadFromRightReverse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := "https://dailynews.programmingeeksclub.com/"
        ReadFromRightReverse(s)
    }
}

func BenchmarkReadFromRightBytesReverse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := "https://dailynews.programmingeeksclub.com/"
        ReadFromRightBytesReverse(s)
    }
}
```
Now run the go test -bench=. command.

![benchmark results of how to reverse a string in go](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/duixxlgcfm1igjhml7fv.png)

As you can see the fastest reverse string way took the 82.64 ns and while the lowest took 1742 ns.

#### Fastest Way
Below is the fastest way between all mentioned ways.

```go
func ReadFromRightReverse(s string) string {
    r := make([]byte, len(s))
    for i := 0; i < len(s); i++ {
        r[i] = s[len(s)-1-i]
    }
    return string(r)
}
```

_This article is originally posted on [programmingeeksclub.com](https://programmingeeksclub.com/how-to-reverse-a-string-in-golang/)_

_My Personal Blogging Website : [Programming Geeks Club](https://programmingeeksclub.com/)_
_My Facebook Page : [Programming Geeks Club](https://www.facebook.com/profile.php?id=100086258693659)_
_My Telegram Channel : [Programming Geeks Club](https://t.me/dpgcl)_
_My Twitter Account : [Kuldeep Singh](https://twitter.com/kusinghofficial)_
_My Youtube Channel: [Programming Geeks Club](https://youtube.com/@programmingeeksclub)_

{% embed https://programmingeeksclub.com/how-to-reverse-a-string-in-golang/ %}