Slice Basics

🍕 Go Slices: Your Magical Stretchy Pizza Box

Imagine you have a pizza box. But this isn’t any ordinary box—it’s magical! It can grow bigger when you need more pizza slices, and it can show you just part of the pizza if you want. That’s what a slice is in Go!

🎯 What is a Slice?

A slice is like a window into a pizza box (array). You can see some slices, add more, or peek at different parts. Unlike a regular array (a box with a fixed number of slots), a slice can grow and shrink.

graph TD
    A["🍕 Array: Fixed Box<br/>5 slots forever"] --> B["📦 Slice: Magic Window<br/>Can grow!"]
    B --> C["Length: How many slices you see"]
    B --> D["Capacity: How many CAN fit"]

📝 Slice Declaration

The Empty Pizza Box

When you declare a slice without giving it anything, it’s like having an empty pizza box ready to fill.

var pizzas []string
// pizzas is nil (no box yet!)
// Length: 0, Capacity: 0

What’s happening?

• []string means “a slice of strings”
• No number inside [] = slice (not array!)
• It starts as nil (no box created yet)

Think of it like: You told someone “I want a pizza box” but haven’t gotten one yet.

🏭 The make Function

Building Your Pizza Box

The make function is like ordering a custom pizza box. You decide:

1. What goes in it (type)
2. How many slots to start with (length)
3. How big the box could get (capacity)

// Make a slice with 3 slots
pizzas := make([]string, 3)
// Length: 3, Capacity: 3

// Make a slice with 3 slots,
// but box can hold 10!
bigBox := make([]string, 3, 10)
// Length: 3, Capacity: 10

graph TD
    A["make#40;[]string, 3#41;"] --> B["📦 Box with 3 slots"]
    C["make#40;[]string, 3, 10#41;"] --> D["📦 3 slots now<br/>Room for 10 total!"]

Why use make?

• You get a real box (not nil)
• You control the starting size
• You can plan for growth!

🍕 Slice from Array

Cutting a Window into the Pizza

You can create a slice by pointing to part of an array. It’s like cutting a window in cardboard to see some pizza slices!

// Our full pizza (array)
fullPizza := [5]string{
    "Cheese",
    "Pepperoni",
    "Veggie",
    "BBQ",
    "Hawaiian",
}

// Get slices 1, 2, 3 (index 1 to 3)
mySlice := fullPizza[1:4]
// ["Pepperoni", "Veggie", "BBQ"]

The Magic Formula: array[start:end]

• start = where to begin (included)
• end = where to stop (NOT included)

graph LR
    A["[0]Cheese"] --- B["[1]Pepperoni"]
    B --- C["[2]Veggie"]
    C --- D["[3]BBQ"]
    D --- E["[4]Hawaiian"]

    style B fill:#90EE90
    style C fill:#90EE90
    style D fill:#90EE90

Shortcut Tricks! ✨

// From start to index 3
first3 := fullPizza[:3]
// ["Cheese", "Pepperoni", "Veggie"]

// From index 2 to end
last3 := fullPizza[2:]
// ["Veggie", "BBQ", "Hawaiian"]

// Copy everything!
all := fullPizza[:]
// All 5 slices!

📋 Slice Literals

Making Pizza and Box Together!

A slice literal is the easiest way to create a slice. You list what you want, and Go makes the box for you!

// Create slice directly!
favoritePizzas := []string{
    "Margherita",
    "Pepperoni",
    "Supreme",
}
// Length: 3, Capacity: 3

Notice: No number in the brackets []!

• [3]string{...} = Array (fixed)
• []string{...} = Slice (flexible)

Numbers Work Too!

scores := []int{95, 87, 92, 78}
// A slice of 4 numbers

prices := []float64{9.99, 12.50, 8.75}
// A slice of 3 prices

Think of it like: Walking into a store and saying “Give me a box with these exact pizzas!” The store makes the perfect-sized box automatically.

📏 Length and Capacity

The Two Magic Numbers

Every slice has two important numbers:

// Check with built-in functions
pizzas := make([]string, 3, 5)

len(pizzas)  // 3 (current items)
cap(pizzas)  // 5 (max possible)

graph TD
    A["📦 Your Slice"] --> B["len#40;#41; = 3<br/>🍕🍕🍕"]
    A --> C["cap#40;#41; = 5<br/>🍕🍕🍕⬜⬜"]

Why Does Capacity Matter?

When you add items and exceed capacity, Go has to:

1. Build a bigger box
2. Move everything over
3. This takes time!

small := make([]int, 2, 2)
// Adding a 3rd item = new box needed!

smart := make([]int, 2, 100)
// Room to grow! No new box needed.

🌟 Quick Summary

🎉 You Did It!

Now you understand Go slices! They’re like magical pizza boxes that:

• ✅ Can grow when you need more space
• ✅ Let you see just part of an array
• ✅ Track how full they are AND how big they could get

Remember: Arrays are like regular boxes (fixed size). Slices are like magic boxes (flexible)!

Next time you see [] in Go, you’ll know—that’s a slice, ready to grow with your data! 🚀