How to Reverse a String in Go (Unicode-Safe)

To reverse a string in Go while preserving Unicode characters, you must iterate over rune values instead of byte values, as Go strings are UTF-8 encoded and a single character can span multiple bytes. Simply reversing the byte slice will corrupt multi-byte characters like emojis or non-ASCII letters.

Here is the standard approach using a rune slice:

package main

import (
	"fmt"
	"unicode/utf8"
)

func reverseString(s string) string {
	// Convert string to a slice of runes to handle multi-byte characters
	runes := []rune(s)
	
	// Reverse the rune slice in place
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	
	return string(runes)
}

func main() {
	// Test with ASCII and Unicode (emoji, Chinese characters)
	input := "Hello 世界 🌍"
	fmt.Println("Original:", input)
	fmt.Println("Reversed:", reverseString(input))
}

If you prefer a more explicit iteration without converting the whole string to a slice first (though the slice method is generally more idiomatic and performant for this specific task), you can use utf8.DecodeRuneInString, but the slice conversion is the most robust and readable pattern.

Output:

Original: Hello 世界 🌍
Reversed: 🌍 界世 olleH

Key Considerations:

1. Memory Allocation: Converting to []rune allocates a new slice. For extremely large strings where memory is critical, you might need a more complex in-place byte manipulation strategy, but for 99% of use cases, the rune slice approach is the correct trade-off for safety and simplicity.
2. Normalization: This method reverses the grapheme clusters as represented by the input runes. If your string contains combining characters (e.g., e + ´ = é), Go treats them as separate runes. Reversing them might separate the base character from its accent. For complex text processing involving combining marks, you would need the golang.org/x/text/transform package with unicode/norm to handle grapheme clusters correctly, but for standard string reversal, the rune slice is sufficient.

Avoid using bytes.Reverse or manual byte indexing, as these will split multi-byte UTF-8 sequences and result in invalid UTF-8 strings (often displaying as replacement characters �). Always work with rune types when character semantics matter.

Reversing a string in Go (Unicode-Safe) splits the text into individual characters, including complex symbols like emojis or Chinese characters, flips their order, and puts them back together. It matters because standard byte-reversal breaks these multi-byte characters, resulting in garbled text. Think of it like reversing a sentence of Lego bricks rather than individual plastic pellets.