Runes — Find the Bug¶

func truncateToN(s string, n int) string {
    if len(s) <= n { return s }  // BUG: len() is bytes, not characters
    return s[:n]                  // BUG: may cut mid-character
}

func main() {
    s := "Hello中文"
    fmt.Println(truncateToN(s, 7))  // May produce garbled output
}

s := "Hello中文"
lastChar := s[len(s)-1]  // BUG: last BYTE, not last character
fmt.Println(string(lastChar))  // garbage (partial multi-byte char)

func reverseBuggy(s string) string {
    bytes := []byte(s)
    for i, j := 0, len(bytes)-1; i < j; i, j = i+1, j-1 {
        bytes[i], bytes[j] = bytes[j], bytes[i]  // BUG: reverses bytes, not characters
    }
    return string(bytes)
}

fmt.Println(reverseBuggy("Hello中"))  // garbled output!

func containsNewline(s string) bool {
    for i := 0; i < len(s); i++ {
        if s[i] == '\n' {  // BUG: s[i] is byte, '\n' is rune (int32)
            // Actually: this compiles in Go because '\n' = 10 fits in uint8
            // But conceptually wrong — should use range
            return true
        }
    }
    return false
}
// This works by accident for ASCII — but wrong idiom

// BUG: string(65) does NOT produce "65" — it produces "A"!
n := 65
s := string(n)  // "A" (rune 65 = A), NOT "65"
fmt.Println(s)  // Expected "65", got "A"

func processInput(data []byte) string {
    return string(data)  // BUG: no UTF-8 validation
    // If data contains invalid UTF-8, processing may corrupt or misbehave
}

// BUG: assuming i is the character position, not byte position
s := "Hello中文"
for i, r := range s {
    fmt.Printf("character %d: %c\n", i, r)
    // Prints: character 0, 1, 2, 3, 4, 5, 8 — NOT 0,1,2,3,4,5,6!
}

r := 'A'
fmt.Println(r)  // BUG: prints 65, not "A"

// BUG: assuming all characters are 1 byte for Content-Length
body := "Hello, 中文"
contentLength := len([]rune(body))  // BUG: rune count, not bytes
// HTTP Content-Length must be byte count
w.Header().Set("Content-Length", strconv.Itoa(contentLength))

// BUG: using range to find index, then slicing with it
func firstNChars(s string, n int) string {
    idx := 0
    count := 0
    for i := range s {
        if count == n {
            idx = i
            break
        }
        count++
    }
    return s[:idx]  // BUG: works by accident — but intent is wrong
}
// The range index IS the byte offset, so s[:idx] works
// But: if count never reaches n (s has fewer than n chars), idx=0!

func classify(r rune) string {
    switch r {
    case "a", "e", "i", "o", "u":  // BUG: string literals, not rune literals
        return "vowel"
    default:
        return "consonant"
    }
}
// Compile error: cannot use "a" (string) as rune in switch

// BUG: loop over bytes, but checks rune count
func hasMinChars(s string, min int) bool {
    count := 0
    for i := 0; i < len(s); i++ {
        count++  // counting bytes, not characters
    }
    return count >= min
}

// "中文" has 2 characters but 6 bytes
// hasMinChars("中文", 5) returns true (6 bytes ≥ 5) — wrong!