What is the difference between Go's runes and bytes for representing strings as arrays of characters?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Go, strings are sequences of characters represented using different types: runes and bytes. Both are used to manipulate and process strings, but they differ in how they handle character encoding and memory representation. Understanding the difference between runes and bytes is crucial for working with string data in Go, especially when dealing with Unicode or multi-byte characters.
Differences Between Go's Runes and Bytes
 Bytes: Handling Raw Data

Definition: A byte in Go is an alias for uint8. It represents a single 8-bit value and is primarily used to handle raw data or ASCII characters. Since Go strings are UTF-8 encoded by default, a string can be treated as a slice of bytes ([]byte).

Usage: Bytes are suitable for tasks that involve low-level data manipulation, like working with binary data, performing I/O operations, or handling ASCII text where each character is represented by a single byte.

Example: Accessing bytes in a string.
package main

import (
    "fmt"
)

func main() {
    str := "Hello"
    bytes := []byte(str)
    
    fmt.Println(bytes) // Output: [72 101 108 108 111]
    
    for i := 0; i &#x3C; len(bytes); i++ {
        fmt.Printf("%c ", bytes[i]) // Output: H e l l o
    }
}

Characteristics:

Fast and efficient for ASCII strings.
Directly represents each character as a single byte.
Not suitable for multi-byte characters or non-ASCII text.

. Runes: Handling Unicode Characters

Definition: A rune in Go is an alias for int32 and represents a single Unicode code point. Since a code point may require more than one byte, a rune provides the capacity to store multi-byte characters.

Usage: Runes are essential for handling UTF-8 encoded text containing multi-byte Unicode characters, such as characters from non-Latin scripts (Chinese, Arabic, etc.), emojis, or symbols. Using runes allows for safe and accurate manipulation of Unicode strings.

Example: Iterating over runes in a string.
package main

import (
    "fmt"
)

func main() {
    str := "Hello, 世界"
    runes := []rune(str)
    
    fmt.Println(runes) // Output: [72 101 108 108 111 44 32 19990 30028]
    
    for i := 0; i &#x3C; len(runes); i++ {
        fmt.Printf("%c ", runes[i]) // Output: H e l l o ,   世 界
    }
}

Characteristics:

Handles multi-byte Unicode characters correctly.
Suitable for internationalization (i18n) and localization (l10n).
Slightly more memory-intensive compared to bytes, as each rune is 4 bytes.

Practical Examples
Example : Counting Characters in a String
When counting characters, using bytes might not yield the correct result for UTF-8 strings containing multi-byte characters.
package main

import (
    "fmt"
)

func main() {
    str := "Hello, 世界"
    
    fmt.Println("Byte count:", len(str))                 // Output: Byte count: 13
    fmt.Println("Character count:", len([]rune(str)))    // Output: Character count: 9
}

Example : Reversing a String
To reverse a string correctly, especially when dealing with multi-byte characters, it's necessary to use runes rather than bytes.
package main

import (
    "fmt"
)

func main() {
    str := "Hello, 世界"
    runes := []rune(str)
    
    for i, j := 0, len(runes)-1; i &#x3C; j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    
    reversed := string(runes)
    fmt.Println(reversed) // Output: 界世 ,olleH
}

Conclusion
In Go, bytes and runes serve different purposes for handling strings. Bytes (uint8) are ideal for manipulating raw data and ASCII text, providing fast and efficient processing. Runes (int32), on the other hand, are essential for handling Unicode characters and multi-byte characters accurately. Understanding when to use bytes versus runes is critical for effective string manipulation, especially in applications that require internationalization and proper handling of diverse character sets.

What is the difference between Go's runes and bytes for representing strings as arrays of characters?

Similar Questions