🧵 Go String Processing: The String Workshop

Imagine you have a magical workshop where words are like LEGO blocks. You can join them, break them apart, transform them, and even peek inside to see what makes them special!

🎯 What You’ll Learn

In this adventure, we’ll explore five powerful tools in Go’s string workshop:

1. String Operations — Basic tricks with words
2. strings.Builder — The super-fast word assembler
3. bytes Package — Working with raw building blocks
4. String Conversion — Transforming between types
5. Unicode Handling — Understanding magical symbols

🔧 1. String Operations

Think of strings like a necklace of beads. Each bead is a letter. Go gives you tools to work with these necklaces!

The strings Package — Your Toolbox

import "strings"

// Does this necklace contain a red bead?
found := strings.Contains("hello", "ell")
// found = true ✓

// How many times does "l" appear?
count := strings.Count("hello", "l")
// count = 2

// Does it start with "hel"?
yes := strings.HasPrefix("hello", "hel")
// yes = true ✓

Common String Operations

🌟 Real Example: Clean Up User Input

import "strings"

func cleanInput(s string) string {
    // Remove extra spaces
    s = strings.TrimSpace(s)
    // Make it lowercase
    s = strings.ToLower(s)
    // Remove bad words
    s = strings.ReplaceAll(s, "bad", "***")
    return s
}

result := cleanInput("  Hello BAD World  ")
// result = "hello *** world"

🏗️ 2. strings.Builder — The Speed Champion

The Problem with + (Glue)

Imagine you’re building a tower with LEGO blocks. Every time you add a block using +, you have to:

1. Build a completely new tower
2. Copy all the old blocks
3. Add the new block

This is SLOW when you have lots of blocks!

// ❌ SLOW way — rebuilds every time!
s := ""
for i := 0; i < 1000; i++ {
    s = s + "a"  // New string each time!
}

The Solution: strings.Builder

strings.Builder is like a magic expanding box. You just keep throwing blocks in, and it grows automatically!

import "strings"

// ✅ FAST way — uses Builder!
var builder strings.Builder

for i := 0; i < 1000; i++ {
    builder.WriteString("a")
}

result := builder.String()
// "aaaa...a" (1000 a's)

Builder Methods

var b strings.Builder

// Write a string
b.WriteString("Hello")

// Write a single letter (rune)
b.WriteRune(' ')

// Write raw bytes
b.Write([]byte("World"))

// Get the final string
result := b.String()
// result = "Hello World"

// How big is it?
size := b.Len()  // 11

// Start over
b.Reset()

📊 Speed Comparison

Method           | 1000 items | 10000 items
-----------------|------------|------------
Using +          | 1.5 ms     | 150 ms
Using Builder    | 0.02 ms    | 0.2 ms

🚀 Builder is 100x FASTER!

📦 3. bytes Package — Raw Building Blocks

What Are Bytes?

If strings are sentences, bytes are individual letters written in secret code (numbers).

Every letter has a number:

• 'A' = 65
• 'a' = 97
• '0' = 48

Working with []byte

// String to bytes
text := "Hello"
data := []byte(text)
// data = [72 101 108 108 111]

// Bytes back to string
back := string(data)
// back = "Hello"

bytes.Buffer — Like strings.Builder’s Twin

import "bytes"

var buf bytes.Buffer

buf.WriteString("Hello")
buf.WriteByte(' ')  // Single byte
buf.WriteString("World")

result := buf.String()
// result = "Hello World"

When to Use Which?

bytes Package Functions

import "bytes"

data := []byte("Hello World")

// Same as strings package!
bytes.Contains(data, []byte("World"))
bytes.Count(data, []byte("l"))
bytes.ToUpper(data)
bytes.Split(data, []byte(" "))

🔄 4. String Conversion — Shape Shifting

Converting Numbers ↔ Strings

import "strconv"

// Number → String
num := 42
str := strconv.Itoa(num)
// str = "42"

// String → Number
text := "123"
n, err := strconv.Atoi(text)
// n = 123

// Handle errors!
bad := "abc"
_, err := strconv.Atoi(bad)
// err = "invalid syntax"

More Conversions

import "strconv"

// Float → String
f := 3.14159
s := strconv.FormatFloat(f, 'f', 2, 64)
// s = "3.14"

// String → Float
text := "3.14"
val, _ := strconv.ParseFloat(text, 64)
// val = 3.14

// Bool → String
strconv.FormatBool(true)  // "true"

// String → Bool
strconv.ParseBool("true") // true, nil

The fmt Package — Easy Mode

import "fmt"

// Anything → String
s := fmt.Sprintf("%d", 42)      // "42"
s := fmt.Sprintf("%f", 3.14)    // "3.140000"
s := fmt.Sprintf("%.2f", 3.14)  // "3.14"
s := fmt.Sprintf("%v", true)    // "true"

🎯 Conversion Cheat Sheet

strconv.Itoa(42)      → "42"
strconv.Atoi("42")    → 42

fmt.Sprintf("%d", 42) → "42"
fmt.Sprintf("%s", x)  → any string

[]byte("hello")       → [104 101 108 108 111]
string([]byte{...})   → "hello"

🌍 5. Unicode Handling — World Languages

The Big Idea

Not all letters are created equal!

• 'A' = 1 byte
• 'é' = 2 bytes
• '中' = 3 bytes
• '🎉' = 4 bytes

Strings vs Runes

text := "Hello 世界"

// Length in BYTES (wrong for counting letters!)
len(text)  // 12 (not 8!)

// Length in CHARACTERS (runes)
import "unicode/utf8"
utf8.RuneCountInString(text)  // 8 ✓

What’s a Rune?

A rune is Go’s name for a single character — any character in any language!

// Rune = character = int32
var r rune = '世'  // Chinese character
fmt.Println(r)    // 19990 (its number)

// Loop through characters properly
for _, char := range "Hello 世界" {
    fmt.Printf("%c ", char)
}
// H e l l o   世 界

The unicode Package

import "unicode"

// Is it a letter?
unicode.IsLetter('A')  // true
unicode.IsLetter('5')  // false

// Is it a number?
unicode.IsDigit('5')   // true

// Is it uppercase?
unicode.IsUpper('A')   // true

// Convert case
unicode.ToUpper('a')   // 'A'
unicode.ToLower('A')   // 'a'

Safe String Processing

import "unicode/utf8"

text := "Café ☕"

// Check if valid UTF-8
utf8.ValidString(text)  // true

// Get first rune
r, size := utf8.DecodeRuneInString(text)
// r = 'C', size = 1

// Count runes (characters)
count := utf8.RuneCountInString(text)
// count = 6

🎨 Visual: Bytes vs Runes

String:  "Go 🚀"

Bytes:   [71] [111] [32] [240 159 154 128]
          G    o    space    🚀 (4 bytes!)

Runes:   [71] [111] [32] [128640]
          G    o   space   🚀

len() = 7 bytes
RuneCount = 4 characters

🧩 Putting It All Together

Here’s a real-world example combining everything:

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

// Clean and process user text
func processText(input string) string {
    var b strings.Builder

    // Remove extra whitespace
    input = strings.TrimSpace(input)

    // Process each character
    for _, r := range input {
        if unicode.IsLetter(r) {
            b.WriteRune(unicode.ToLower(r))
        } else if unicode.IsSpace(r) {
            b.WriteRune(' ')
        }
    }

    return b.String()
}

result := processText("  Hello 世界!  ")
// result = "hello 世界"

🗺️ The Big Picture

graph TD
    A[String] --> B[String Operations]
    A --> C[strings.Builder]
    A --> D[bytes Package]
    A --> E[Conversion]
    A --> F[Unicode]

    B --> B1[Contains/Split/Join]
    B --> B2[ToUpper/ToLower]
    B --> B3[Trim/Replace]

    C --> C1[Fast Building]
    C --> C2[WriteString]
    C --> C3[String Result]

    D --> D1[Raw Bytes]
    D --> D2[bytes.Buffer]
    D --> D3[File I/O]

    E --> E1[strconv Package]
    E --> E2[Atoi/Itoa]
    E --> E3[fmt.Sprintf]

    F --> F1[Runes]
    F --> F2[utf8 Package]
    F --> F3[unicode Package]

💡 Quick Tips

🎉 You Did It!

You now know how to:

• ✅ Manipulate strings with the strings package
• ✅ Build strings efficiently with strings.Builder
• ✅ Work with raw bytes using the bytes package
• ✅ Convert between strings and numbers
• ✅ Handle Unicode and international text

Go forth and process those strings! 🚀