Strings

Strings are sequences of characters used to represent text. In this lesson, you'll learn how Go handles strings, understand UTF-8 encoding, work with runes, and master common string operations.

String Basics

In Go, strings are immutable sequences of bytes. They're typically UTF-8 encoded, which means they can represent any Unicode character:

Click Run to execute your code

String Literals

// Interpreted string (with escape sequences)
s1 := "Hello\nWorld"  // \n is newline

// Raw string (no escape sequences)
s2 := `Hello\nWorld`  // \n is literal text

// Multi-line raw string
s3 := `This is a
multi-line
string`

Common String Operations

The strings package provides many useful functions for working with strings:

String Concatenation

// Using + operator
greeting := "Hello" + " " + "World"

// Using fmt.Sprintf
name := "Alice"
message := fmt.Sprintf("Hello, %s!", name)

// Using strings.Builder (efficient for loops)
var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(" ")
builder.WriteString("World")
result := builder.String()

Runes and UTF-8

Go strings are UTF-8 encoded. A rune represents a single Unicode code point:

Click Run to execute your code

Why This Matters

s := "Hello, 世界"
fmt.Println(len(s))           // 13 bytes (not 9 characters!)

// Counting actual characters
count := 0
for range s {
    count++
}
fmt.Println(count)            // 9 characters

// Or use utf8.RuneCountInString
fmt.Println(utf8.RuneCountInString(s))  // 9

String Indexing and Slicing

s := "Hello"

// Indexing gives you bytes
fmt.Println(s[0])     // 72 (byte value of 'H')
fmt.Printf("%c\n", s[0])  // H (character)

// Slicing
fmt.Println(s[0:2])   // "He"
fmt.Println(s[2:])    // "llo"
fmt.Println(s[:3])    // "Hel"

// ⚠️ Be careful with multi-byte characters!
s2 := "世界"
fmt.Println(s2[0:3])  // "世" (one character, 3 bytes)

Common Mistakes

// ❌ Wrong - strings are immutable
s := "Hello"
s[0] = 'h'  // Error: cannot assign to s[0]

// ✅ Correct - create a new string
s := "Hello"
s = "h" + s[1:]  // "hello"

// Or convert to []rune, modify, convert back
runes := []rune(s)
runes[0] = 'h'
s = string(runes)

// ❌ Wrong assumption
s := "Hello, 世界"
if len(s) == 9 {  // False! len(s) is 13
    fmt.Println("9 characters")
}

// ✅ Correct - count runes
import "unicode/utf8"

if utf8.RuneCountInString(s) == 9 {
    fmt.Println("9 characters")  // True!
}

// ❌ Inefficient - creates many temporary strings
result := ""
for i := 0; i < 1000; i++ {
    result += "x"  // Slow!
}

// ✅ Efficient - use strings.Builder
var builder strings.Builder
for i := 0; i < 1000; i++ {
    builder.WriteString("x")
}
result := builder.String()

Exercise: Word Counter

package main

import (
    "fmt"
    "strings"
)

func main() {
    sentence := "Go is simple and powerful"
    
    // Original
    fmt.Println("Original:", sentence)
    
    // Word count
    words := strings.Split(sentence, " ")
    fmt.Println("Word count:", len(words))
    
    // Uppercase
    upper := strings.ToUpper(sentence)
    fmt.Println("Uppercase:", upper)
    
    // Replace
    replaced := strings.Replace(sentence, "simple", "elegant", 1)
    fmt.Println("Replaced:", replaced)
    
    // Bonus: Check if contains
    if strings.Contains(sentence, "Go") {
        fmt.Println("Contains 'Go': true")
    }
    
    // Bonus: Character count
    fmt.Println("Character count:", len(sentence))
    fmt.Println("Rune count:", len([]rune(sentence)))
}

Summary

What's Next?

Congratulations on completing the Basics module! You now understand variables, types, constants, operators, and strings. Next, you'll learn about Control Flow with if statements and switch expressions to make decisions in your programs.