Nil Values and String Initialization

Go strings cannot hold nil directly. The zero value for a string is an empty string (""). Attempting to assign nil results in a compilation error:

func main() {
    var data string
    data = nil // Compilation error: cannot assign nil to string
}

To represent absence of value, use a pointer to string:

func main() {
    var ptr *string
    fmt.Println(ptr) // Output: <nil>
}

Pointer usage requires careful dereferencing and null checks:

func main() {
    value := "sample"
    ptr := &value
    fmt.Printf("Value: %s, Address: %p\n", *ptr, ptr)
}

Immutability of Strings

String characters cannot be modified directly. Any attempt to change individual bytes fails at compile time:

func main() {
    text := "example"
    text[0] = 'X' // Error: cannot assign to text[0]
}

Converting to byte slices for modification risks corrupting multi-byte UTF-8 characters:

func main() {
    chinese := "中文"
    bytes := []byte(chinese)
    bytes[0] = 'A'
    fmt.Println(string(bytes)) // Output: A文
}

Byte Count vs. Character Count

len() returns byte count, not character count. For accurate rune counting, use utf8.RuneCountInString():

func main() {
    currency := "€"
    fmt.Printf("Bytes: %d, Runes: %d\n", len(currency), utf8.RuneCountInString(currency))
    // Output: Bytes: 3, Runes: 1
}

Some characters span multiple runes due to Unicode composition:

func main() {
    emoji := "👍🏻"
    fmt.Printf("Bytes: %d, Runes: %d\n", len(emoji), utf8.RuneCountInString(emoji))
    // Output: Bytes: 8, Runes: 2
}

String Indexing and Iteration

Indexing returns raw byte values, while range iterates over runes:

func main() {
    sample := "Hello, 世界"
    fmt.Printf("Byte at 0: %T, %d\n", sample[0], sample[0])
    for i, r := range sample {
        fmt.Printf("Index %d: %T, %c\n", i, r, r)
    }
}

Output shows byte values for indexing and rune values for iteration:

Byte at 0: uint8, 72
Index 0: int32, H
Index 1: int32, e
...
Index 7: int32, 世

Unicode-Aware String Comparison

Direct == comparison may fail for logically equal Unicode strings. Normalize before comparing:

import "golang.org/x/text/unicode/norm"

func main() {
    a := "café"
    b := "cafe\u0301"
    fmt.Println(a == b) // false
    normalizedA := norm.NFC.String(a)
    normalizedB := norm.NFC.String(b)
    fmt.Println(normalizedA == normalizedB) // true
}

Efficient String Building

Using + for repeated concatenation creates unnecessary intermediate strings. Use strings.Builder for optimal performance:

func main() {
    builder := strings.Builder{}
    for i := 0; i < 5000; i++ {
        builder.WriteString("data ")
    }
    result := builder.String()
}

This approach minimizes memory allocations and improves execution speed compared to string concatenation.

Key Insights

• Strings default to empty string (""), not nil
• Always use utf8.RuneCountInString() for character counting
• Modify strings via rune slices to safely handle multi-byte characters
• Normalize Unicode before comparing strings for correctness
• Prefer strings.Builder for constructing large strings