for-range over Strings — Specification¶

// Short variable declaration forms
for i, r := range s { }   // i = byte index (int), r = rune value (rune)
for i := range s { }      // i = byte index only
for range s { }            // no iteration variables (count runes or side-effects)

// Assignment forms (variables must already be declared)
for i, r = range s { }    // assign byte index and rune to existing variables
for i = range s { }       // assign byte index to existing variable

// Blank identifier forms
for _, r := range s { }   // discard byte index, receive rune only
for _, _ = range s { }    // valid but prefer: for range s { }

s := "Go" // 2 bytes, 2 runes
// Range produces 2 iterations

s2 := "Go世界" // 2 + 3 + 3 = 8 bytes, 4 runes
// Range produces 4 iterations, NOT 8

s := "aB世界"
// Iteration 0: i=0, r='a'  (1 byte)
// Iteration 1: i=1, r='B'  (1 byte)
// Iteration 2: i=2, r='世' (3 bytes, starts at byte 2)
// Iteration 3: i=5, r='界' (3 bytes, starts at byte 5)

for _, r := range "A世" {
    fmt.Printf("%T %d %c\n", r, r, r)
    // int32 65 A
    // int32 19990 世
}

s := "\xff\xfe" // two invalid UTF-8 bytes
for i, r := range s {
    fmt.Printf("i=%d r=U+%04X\n", i, r)
    // i=0 r=U+FFFD
    // i=1 r=U+FFFD
}

s := "hello"
for i, r := range s {
    if i == 0 {
        s = "world" // does NOT change what the loop iterates over
    }
    fmt.Printf("%c", r) // prints: h e l l o
}

// Valid: exact type match
var idx int
var ch rune
for idx, ch = range "hello" {
    _ = idx
    _ = ch
}

// Valid: rune is alias for int32, so int32 works
var bytePos int
var codePoint int32
for bytePos, codePoint = range "hello" {
    _ = bytePos
    _ = codePoint
}

// Valid: assignable to interface{}
var a, b any
for a, b = range "hello" {
    _ = a
    _ = b
}

for i, r := range "hello" {
    // i is inferred as int
    // r is inferred as rune (int32)
    fmt.Printf("i: %T, r: %T\n", i, r) // i: int, r: int32
}

type Name string

var n Name = "hello"
for i, r := range n { // valid: underlying type of Name is string
    _ = i
    _ = r
}

package main

import "fmt"

func main() {
    s := "Hello"
    for i, r := range s {
        fmt.Printf("byte[%d] = '%c' (U+%04X)\n", i, r, r)
    }
}

package main

import "fmt"

func main() {
    s := "Go世界!" // 2 ASCII + 2 CJK (3 bytes each) + 1 ASCII = 9 bytes, 5 runes
    fmt.Printf("len(s) = %d bytes\n", len(s))

    for i, r := range s {
        fmt.Printf("byte[%d] rune='%c' U+%04X (size=%d bytes)\n",
            i, r, r, runeByteWidth(r))
    }
}

func runeByteWidth(r rune) int {
    switch {
    case r <= 0x7F:
        return 1
    case r <= 0x7FF:
        return 2
    case r <= 0xFFFF:
        return 3
    default:
        return 4
    }
}

package main

import "fmt"

func main() {
    // A = 1 byte, n = 2 bytes, 中 = 3 bytes, U+1F600 (grinning face) = 4 bytes
    s := "A\u00F1\u4E2D\U0001F600"
    fmt.Printf("string: %s\nlen: %d bytes\n\n", s, len(s))

    for i, r := range s {
        fmt.Printf("byte[%2d] rune=U+%04X '%c'\n", i, r, r)
    }
}

package main

import "fmt"

func main() {
    // Construct a string with invalid UTF-8 bytes
    s := "a\xc0\xaf\xfeb" // \xc0\xaf is overlong encoding, \xfe is never valid
    fmt.Printf("len: %d bytes\n\n", len(s))

    for i, r := range s {
        if r == '\uFFFD' {
            fmt.Printf("byte[%d] INVALID UTF-8 -> U+FFFD (replacement char)\n", i)
        } else {
            fmt.Printf("byte[%d] rune=U+%04X '%c'\n", i, r, r)
        }
    }
}

package main

import "fmt"

func main() {
    s := "Go世界"

    fmt.Println("=== for-range (rune iteration) ===")
    count := 0
    for i, r := range s {
        fmt.Printf("  i=%d r='%c' (U+%04X)\n", i, r, r)
        count++
    }
    fmt.Printf("  iterations: %d\n\n", count) // 4

    fmt.Println("=== byte-indexed loop ===")
    for i := 0; i < len(s); i++ {
        fmt.Printf("  i=%d byte=0x%02X\n", i, s[i])
    }
    fmt.Printf("  iterations: %d\n", len(s)) // 8
}

package main

import "fmt"

func main() {
    s := ""
    count := 0
    for range s {
        count++
    }
    fmt.Println("iterations:", count) // 0

    // The loop body never executes
    for i, r := range s {
        fmt.Println(i, r) // never reached
    }
    fmt.Println("done") // prints immediately
}

package main

import "fmt"

func main() {
    // Every byte is invalid UTF-8
    s := "\x80\x81\xfe\xff"
    fmt.Printf("len: %d bytes\n", len(s))

    for i, r := range s {
        fmt.Printf("byte[%d] = U+%04X (FFFD=%v)\n", i, r, r == '\uFFFD')
    }
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Hello, 世界"

    // WRONG: byte index is not rune index
    runeIndex := 0
    for i, r := range s {
        fmt.Printf("byte_index=%d  rune_index=%d  rune='%c'\n", i, runeIndex, r)
        runeIndex++
    }

    fmt.Println()

    // To get the Nth rune, you cannot use s[n] — that gives a byte
    fmt.Printf("s[7] = 0x%02X (byte, NOT a rune)\n", s[7])

    // Correct: use utf8.DecodeRuneInString or []rune conversion
    runes := []rune(s)
    fmt.Printf("rune[7] = '%c' (U+%04X)\n", runes[7], runes[7])
    fmt.Printf("rune count = %d\n", utf8.RuneCountInString(s))
}

package main

import "fmt"

func main() {
    s := "a世b"
    indices := []int{}
    for i := range s {
        indices = append(indices, i)
    }
    fmt.Println("byte indices:", indices) // [0 1 4]
    // Index jumps from 1 to 4 because '世' occupies bytes 1, 2, 3
}

func countRunes(s string) int {
    n := 0
    for range s {
        n++
    }
    return n
}

package main

import "fmt"

func main() {
    // '世' is E4 B8 96 in UTF-8 — here we truncate after 2 bytes
    s := "a\xe4\xb8" // 'a' + first 2 bytes of '世' (missing third byte)

    for i, r := range s {
        fmt.Printf("byte[%d] = U+%04X '%c'\n", i, r, r)
    }
}

package main

import "fmt"

func main() {
    // Valid U+FFFD encoded in UTF-8
    valid := "\uFFFD"
    // Invalid byte that will be decoded as U+FFFD
    invalid := "\xff"

    for _, r := range valid {
        fmt.Printf("valid:   U+%04X\n", r) // U+FFFD
    }
    for _, r := range invalid {
        fmt.Printf("invalid: U+%04X\n", r) // U+FFFD
    }
    // Both produce the same rune value — they are indistinguishable
    // To distinguish them, use unicode/utf8.DecodeRuneInString and check the size
}

package main

import "fmt"

func main() {
    s := "a\x00b\x00c"
    fmt.Printf("len: %d\n", len(s)) // 5

    for i, r := range s {
        fmt.Printf("byte[%d] = U+%04X\n", i, r)
    }
    // byte[0] = U+0061  ('a')
    // byte[1] = U+0000  (NUL)
    // byte[2] = U+0062  ('b')
    // byte[3] = U+0000  (NUL)
    // byte[4] = U+0063  ('c')
}

package main

import "fmt"

func main() {
    s := "abc"
    for i, r := range s {
        if i == 0 {
            s = "xyz" // does NOT change iteration
        }
        fmt.Printf("%c ", r) // prints: a b c (NOT x y z)
    }
    fmt.Println()
    fmt.Println("s is now:", s) // s is now: xyz
}

// Conceptual desugaring (not actual compiler output):
for i := 0; i < len(s); {
    r, size := utf8.DecodeRuneInString(s[i:])
    // ... loop body with i and r ...
    i += size
}

import "unicode/utf8"

// These two loops produce identical (i, r) pairs:
// Loop 1: for-range
for i, r := range s { /* ... */ }

// Loop 2: manual decoding
for i := 0; i < len(s); {
    r, size := utf8.DecodeRuneInString(s[i:])
    // ... same i and r as loop 1 ...
    i += size
}

package main

import "fmt"

func main() {
    s := "Hello, Go!"

    fmt.Println("=== Rune iteration with for-range ===")
    fmt.Printf("String: %q\n", s)
    fmt.Printf("Byte length: %d\n", len(s))
    fmt.Println()

    for i, r := range s {
        fmt.Printf("  byte[%2d] -> rune '%c' (U+%04X)\n", i, r, r)
    }

    // For ASCII strings, byte index == rune index
    // and len(s) == number of runes
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Hello, 世界! Salom, Dunyo!"

    fmt.Printf("String:     %s\n", s)
    fmt.Printf("Byte len:   %d\n", len(s))
    fmt.Printf("Rune count: %d\n", utf8.RuneCountInString(s))
    fmt.Println()

    fmt.Println("=== for-range (rune-by-rune) ===")
    runeIdx := 0
    for byteIdx, r := range s {
        width := utf8.RuneLen(r)
        fmt.Printf("  rune[%2d] byte[%2d] -> '%c' U+%04X (%d byte%s)\n",
            runeIdx, byteIdx, r, r, width, plural(width))
        runeIdx++
    }
}

func plural(n int) string {
    if n == 1 {
        return ""
    }
    return "s"
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    // Build a string with a mix of valid and invalid UTF-8:
    // 'G' (valid, 1 byte)
    // 'o' (valid, 1 byte)
    // 0xFF (invalid byte)
    // '世' (valid, 3 bytes: E4 B8 96)
    // 0xC0 0x80 (overlong NUL — invalid)
    // '!' (valid, 1 byte)
    s := "Go\xff\xe4\xb8\x96\xc0\x80!"

    fmt.Printf("Raw bytes (%d): ", len(s))
    for i := 0; i < len(s); i++ {
        fmt.Printf("%02X ", s[i])
    }
    fmt.Println()
    fmt.Printf("Valid UTF-8: %v\n", utf8.ValidString(s))
    fmt.Println()

    fmt.Println("=== for-range iteration ===")
    for i, r := range s {
        if r == utf8.RuneError {
            fmt.Printf("  byte[%d] -> U+FFFD (INVALID UTF-8 byte: 0x%02X)\n", i, s[i])
        } else {
            fmt.Printf("  byte[%d] -> '%c' (U+%04X)\n", i, r, r)
        }
    }
}

package main

import (
    "fmt"
    "unicode"
)

// Count the number of Unicode letters in a string
func countLetters(s string) int {
    count := 0
    for _, r := range s {
        if unicode.IsLetter(r) {
            count++
        }
    }
    return count
}

// Find the byte position of the first non-ASCII rune
func firstNonASCII(s string) int {
    for i, r := range s {
        if r > 127 {
            return i // returns byte position
        }
    }
    return -1
}

// Reverse a string correctly (rune-aware, not byte-aware)
func reverseString(s string) string {
    runes := []rune(s)
    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() {
    s := "Hello, 世界!"

    fmt.Println("Letters:", countLetters(s))          // 7
    fmt.Println("First non-ASCII at byte:", firstNonASCII(s)) // 7
    fmt.Println("Reversed:", reverseString(s))         // !界世 ,olleH
}

package main

import (
    "fmt"
    "strings"
    "unicode/utf8"
)

func main() {
    s := "cafe\u0301" // 'cafe' + combining acute accent (U+0301)
    // This is "cafe" followed by a combining character, visually: cafe

    fmt.Printf("String:       %s\n", s)
    fmt.Printf("Byte length:  %d\n", len(s))
    fmt.Printf("Rune count:   %d\n", utf8.RuneCountInString(s))
    fmt.Println()

    // Demonstrate that byte index != rune index
    fmt.Println("Byte Index | Rune Index | Rune    | Unicode   | Bytes")
    fmt.Println(strings.Repeat("-", 60))

    runePos := 0
    for bytePos, r := range s {
        runeSize := utf8.RuneLen(r)
        fmt.Printf("    %2d     |     %2d     |   '%c'   | U+%04X    |   %d\n",
            bytePos, runePos, r, r, runeSize)
        runePos++
    }

    fmt.Println()
    fmt.Println("Key insight: byte index 4 corresponds to rune index 4,")
    fmt.Println("but the combining accent at rune index 4 is 2 bytes (U+0301).")
    fmt.Println("If there were more characters after, byte indices would diverge.")
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func analyzeString(label, s string) {
    fmt.Printf("--- %s ---\n", label)
    fmt.Printf("  Bytes: %d, Runes: %d, Valid UTF-8: %v\n",
        len(s), utf8.RuneCountInString(s), utf8.ValidString(s))

    replacements := 0
    for _, r := range s {
        if r == utf8.RuneError {
            replacements++
        }
    }
    fmt.Printf("  Replacement characters (U+FFFD): %d\n\n", replacements)
}

func main() {
    analyzeString("Pure ASCII", "Hello")
    analyzeString("Valid UTF-8", "Hello, 世界")
    analyzeString("Invalid byte", "Hello\xffWorld")
    analyzeString("All invalid", "\x80\x81\x82\x83")
    analyzeString("Mixed valid/invalid", "a\xc0b\xe4\xb8\x96c\xffd")
    analyzeString("Empty string", "")
}