Iterating Strings — Find the Bug¶

package main

import "fmt"

func displayName(name string) {
    if len(name) > 20 {
        fmt.Println("Name too long!")
        return
    }
    fmt.Println("Hello,", name)
}

func main() {
    displayName("Alice")        // OK
    displayName("山田太郎")      // prints "Name too long!" for a 4-char name!
}

package main

import "fmt"

func getInitial(name string) string {
    return string(name[0]) // get first character
}

func main() {
    fmt.Println(getInitial("Alice"))  // "A" — correct
    fmt.Println(getInitial("Étienne")) // "Ã" — wrong! é is U+00C9, first byte is 0xC3
}

package main

import "fmt"

func preview(s string, n int) string {
    if len(s) <= n {
        return s
    }
    return s[:n] + "..."
}

func main() {
    fmt.Println(preview("Hello, World!", 7)) // "Hello, ..." — correct
    fmt.Println(preview("Hello, 世界!", 8))   // garbled! — 世 starts at byte 7, 8 bytes in
}

package main

import "fmt"

func reverseString(s string) string {
    b := []byte(s)
    for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
        b[i], b[j] = b[j], b[i]
    }
    return string(b)
}

func main() {
    fmt.Println(reverseString("Hello"))  // "olleH" — OK for ASCII
    fmt.Println(reverseString("世界"))   // garbled! bytes reversed, not runes
}

package main

import "fmt"

func splitAt(s string, pos int) (string, string) {
    // Split string at character position pos
    return s[:pos], s[pos:]
}

func main() {
    s := "Hello, 世界"
    left, right := splitAt(s, 7)
    fmt.Println(left)  // expected "Hello, "
    fmt.Println(right) // expected "世界"
    // But with pos=7, s[7] is the start of '世' (correct only by luck!)
    // Try with pos=8: crashes mid-rune or produces garbled output
    left2, right2 := splitAt(s, 8) // panic or garbled
    fmt.Println(left2, right2)
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func processRunes(s string) {
    i := 0
    for i < len(s) {
        r, size := utf8.DecodeRuneInString(s[i:])
        if r == utf8.RuneError && size == 0 {
            break // WRONG: size==0 only when s[i:] is empty
            // For invalid UTF-8: size==1, not 0!
        }
        fmt.Printf("%c", r)
        i += size
    }
}

func main() {
    processRunes("A\xffB") // \xff is invalid UTF-8
    // Expected: A?B
    // Actual: A (then infinite loop because break condition is wrong)
}

package main

import "fmt"

func removeSpaces(s string) string {
    result := ""
    for _, r := range s {
        if r != ' ' {
            result += string(r) // O(n) per concatenation!
        }
    }
    return result
}

func main() {
    long := "This is a very long string with many spaces in it " +
        "and it goes on and on " +
        "making this O(n^2)"
    fmt.Println(len(removeSpaces(long)))
}

package main

import "fmt"

func containsNonASCII(s string) bool {
    for _, r := range s {
        if r > 127 { // checking rune value
            return true
        }
    }
    return false
}

// This function looks correct... but consider:
func filterASCII(s string) string {
    result := ""
    for _, b := range []byte(s) { // iterates BYTES not runes
        if b <= 127 {
            result += string(b) // BUG: b is a byte, not a rune
        }
    }
    return result
}

func main() {
    s := "Héllo"
    fmt.Println(filterASCII(s)) // may produce "H?llo" or similar
}

package main

import "fmt"

var cache []string

func processLargeFiles(filePaths []string) {
    for _, path := range filePaths {
        content := readFile(path) // reads ~100MB file into string
        header := content[:1024]  // extract first 1024 bytes
        cache = append(cache, header)
        // BUG: header shares backing array with 100MB content!
        // content can't be GC'd as long as header is in cache!
    }
}

func readFile(path string) string { return string(make([]byte, 100*1024*1024)) }

func main() {
    processLargeFiles([]string{"a", "b", "c"})
    fmt.Println("Cache entries:", len(cache))
    // 300MB of file data still in memory!
}

package main

import "fmt"

func splitOnDelimiter(s string, delim string) []string {
    var parts []string
    start := 0
    for i, r := range s {
        if r == delim { // BUG: r is rune, delim is string — compile error!
            parts = append(parts, s[start:i])
            start = i + len(delim)
        }
    }
    parts = append(parts, s[start:])
    return parts
}

func main() {
    fmt.Println(splitOnDelimiter("a,b,,c", ","))
}

package main

import (
    "fmt"
    "io"
    "strings"
    "time"
)

func asyncProcess(s string, result chan<- rune) {
    r := strings.NewReader(s)
    go func() {
        for {
            ch, _, err := r.ReadRune()
            if err == io.EOF {
                close(result)
                return
            }
            result <- ch
        }
    }()
}

func main() {
    result := make(chan rune, 10)
    asyncProcess("Hello", result)
    // Only read first 3 runes, then stop
    for i, r := range result {
        if i >= 3 { break }
        fmt.Println(string(r))
    }
    time.Sleep(time.Second)
    // Goroutine is blocked trying to send to full channel — LEAKED!
}

package main

import "fmt"

// Replace first occurrence of target rune with replacement string
func replaceFirst(s string, target rune, replacement string) string {
    for i, r := range s {
        if r == target {
            // Take everything before i, add replacement, add everything after i
            return s[:i] + replacement + s[i+1:] // BUG: i+1 is wrong for multi-byte!
        }
    }
    return s
}

func main() {
    fmt.Println(replaceFirst("Hello", 'l', "L"))     // "HeLlo" — seems correct
    fmt.Println(replaceFirst("Hello, 世界", '世', "WORLD"))
    // BUG: 世 is 3 bytes, but we skip only 1 byte with s[i+1:]
    // s[i+1:] starts at byte i+1, which is inside '世'!
}