How to do string reversal using Golang

In Golang program development, string is a very common data type. They are everywhere, whether you are reading content from the network or reading text from a file, strings are almost always involved. The reversal of strings is also a problem that often needs to be dealt with. This article will explore how to use Golang for string reversal.

1. Basics of string reversal

In Golang, a string is composed of one or more characters, and each character is represented by a Unicode code point. Strings in Golang are immutable, which means that when you try to modify a character in a string, you actually create a new string instead of changing the original string. The reversal of a string is no exception, and a new string needs to be created to store the reversed result.

The basic string reversal code is as follows:

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

The above code converts the string into a rune slice by using the []rune type so that the string can be accessed directly characters in . Use double pointers (i and j) to iterate over characters while swapping the i-th character to the j-th position.

2. Advanced string reversal

The above code implements basic string reversal, but it is not efficient enough in some cases. Because string reversal creates a new string, creating and filling the new string may take more time than reversing the characters directly.

Advanced string reversal can be optimized by using byte arrays. The length of the byte array is equal to the length of the original string, and can be reversed directly in the original byte array, avoiding the time and space cost of creating a new string. When doing string reversal, the string needs to be converted to a byte array, but since strings in Go can contain multiple byte sequences, the encoding needs to be determined before conversion. The following example shows how to reverse a UTF-8 string:

func ReverseString(s string) string {
    b := []byte(s)
    n := len(b)
    for i := 0; i < n/2; i++ {
        b[i], b[n-i-1] = b[n-i-1], b[i]
    }
    return string(b)
}

Among them, the []byte type is used to convert the string to a byte array. Use double pointers (i and n-i-1) to iterate over the byte array, swapping the i-th byte to the n-i-1th position.

3. Benchmark test

In order to measure the performance of two different string reversal methods, the following will conduct a benchmark test:

func BenchmarkReverseString(b *testing.B) {
    s := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    for i := 0; i < b.N; i++ {
        ReverseString(s)
    }
}

func BenchmarkReverseString2(b *testing.B) {
    s := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    for i := 0; i < b.N; i++ {
        ReverseString2(s)
    }
}

In Golang program development, benchmark Testing is an important means of testing performance. A series of test functions are provided in the testing package for us to use. Two functions ReverseString and ReverseString2 are used here to benchmark the reversal of UTF-8 strings. The test string is a string of 26 lowercase letters and 26 uppercase letters.

After executing the benchmark test and comparing the results:

go test -bench=.

BenchmarkReverseString-8     3509301               331 ns/op
BenchmarkReverseString2-8    45815326                25.2 ns/op

The results show that the method of using byte arrays for string reversal is significantly better than the method of using rune slices for string reversal More efficient.

4. Summary

In this article, we introduced two methods for string reversal in Golang. One uses rune slicing and the other uses words. Array of sections. We also provide short but executable benchmark code to measure the performance of both methods. If the string that needs to be processed is smaller, then we can reverse the string using basic methods. However, for longer strings or when efficient reverse operations are required, we should reverse the string using advanced byte array-based methods.

The above is the detailed content of How to do string reversal using Golang. For more information, please follow other related articles on the PHP Chinese website!