How Can I Efficiently Access a Random Rune in a Go String?

Accessing Random Rune Element of a String Efficiently

In Go, strings are represented as a sequence of UTF-8 encoded bytes. To access a rune element at a specific index, one can iterate through the string using a for ... range loop. However, this method can be inefficient for frequent access.

The reason for this inefficiency is that Go's strings are not directly indexed over runes. To extract a rune, the UTF-8 byte sequence must be decoded. This decoding overhead becomes significant if the function is called multiple times.

To optimize performance, it is recommended to avoid using a string and instead use a []rune slice. Slices are efficiently indexed, allowing for direct access to runes. If the input type cannot be changed, a cache can be implemented to store decoded []rune representations of strings.

Here is a modified version of the provided function that utilizes a cache:

var cache = map[string][]rune{}

func RuneAt(s string, idx int) rune {
    rs := cache[s]
    if rs == nil {
        rs = []rune(s)
        cache[s] = []rune(s)
    }
    if idx >= len(rs) {
        return 0
    }
    return rs[idx]
}

The cache stores the decoded []rune representations of strings to avoid repetitive decoding. This approach can significantly improve performance if RuneAt() is called with a limited set of strings.

The above is the detailed content of How Can I Efficiently Access a Random Rune in a Go String?. For more information, please follow other related articles on the PHP Chinese website!