Struct Basics

🏗️ Building with Blueprints: Go Structs Basics

Imagine you’re building with LEGO®. Before you snap pieces together, you need a plan—a blueprint that says “this goes here, that goes there.” In Go, that blueprint is called a Struct.

🎯 The Big Picture

A struct (short for “structure”) is like a recipe card or a form you fill out. It groups related information together under one name.

Real-life example:

• Your ID card has: Name, Photo, Birthday, Address
• A struct does the same thing for your code!

graph TD
    A["🪪 ID Card"] --> B["Name: Alex"]
    A --> C["Age: 10"]
    A --> D["School: Maple Elementary"]

📦 1. Struct Declaration — Creating Your Blueprint

What is it?

A struct declaration is like drawing up a plan. You’re telling Go: “I want to group these pieces of information together.”

The Recipe

type Person struct {
    Name string
    Age  int
}

Breaking it down:

• type — “I’m creating a new type”
• Person — The name of your blueprint
• struct — “It’s a structure”
• { } — Everything inside is part of the plan

🧒 Think of it like this:

You’re creating a form template. The form has blank spaces for “Name” and “Age”. You haven’t filled it in yet—you just designed the form!

🏷️ 2. Struct Fields — The Blank Spaces

What are fields?

Fields are the individual pieces of information inside your struct. They’re like the blank lines on a form.

type Dog struct {
    Name   string  // Field 1
    Breed  string  // Field 2
    Age    int     // Field 3
    Fluffy bool    // Field 4
}

Each field has:

1. A name — What to call it (Name, Breed)
2. A type — What kind of info it holds (string, int, bool)

🎨 Visual:

┌─────────────────────────┐
│     DOG FORM            │
├─────────────────────────┤
│ Name:   ____________    │
│ Breed:  ____________    │
│ Age:    ____________    │
│ Fluffy: □ Yes  □ No     │
└─────────────────────────┘

🖊️ 3. Struct Initialization — Filling Out the Form

Now the fun part! You have your blueprint—let’s fill it in!

Method 1: Named Fields (Clear & Safe) ✅

myDog := Dog{
    Name:   "Buddy",
    Breed:  "Golden",
    Age:    3,
    Fluffy: true,
}

Method 2: Ordered Values (Quick but risky) ⚠️

myDog := Dog{"Buddy", "Golden", 3, true}

Order must match exactly!

Method 3: Start Empty, Fill Later

var myDog Dog
myDog.Name = "Buddy"
myDog.Age = 3

Method 4: Zero Values (Empty Form)

var emptyDog Dog
// Name = "" (empty string)
// Age = 0
// Fluffy = false

🍰 Like ordering a cake:

• Named fields: “I want chocolate flavor, vanilla frosting, 2 layers”
• Ordered values: “Chocolate, vanilla, 2” (hope you remember the order!)

📋 4. Struct Copy Behavior — The Photocopier Rule

⚡ The Surprise:

When you copy a struct, Go makes a complete photocopy. Changing the copy does NOT change the original!

original := Dog{Name: "Max", Age: 5}
copy := original      // Full photocopy!
copy.Name = "Rocky"   // Only copy changes

// original.Name is still "Max"!
// copy.Name is "Rocky"

graph LR
    A["📄 Original<br/>Name: Max"] -->|Copy| B["📄 Copy<br/>Name: Max"]
    B -->|Change| C["📄 Copy<br/>Name: Rocky"]
    A -.->|Unchanged!| A

🖨️ Think of it like:

You photocopy a homework sheet. Your friend writes on their copy. Your original is still clean!

Why does this matter?

func birthday(d Dog) {
    d.Age = d.Age + 1  // This changes
}                       // the COPY only!

myDog := Dog{Name: "Luna", Age: 2}
birthday(myDog)
// myDog.Age is still 2! 😱

The function got a photocopy, not the real thing!

🎭 5. Anonymous Structs — Quick & Disposable

What are they?

Sometimes you need a quick struct for ONE thing. No need to name it—just use it!

Example 1: One-time data

point := struct {
    X int
    Y int
}{10, 20}

Example 2: Quick configuration

config := struct {
    Debug   bool
    Version string
}{
    Debug:   true,
    Version: "1.0",
}

🥡 Think of it like:

• Named struct: A reusable plastic container with a label
• Anonymous struct: A paper plate—use once and done!

When to use:

✅ Quick tests ✅ One-time data grouping ✅ Simple configurations ❌ Don’t use if you need it more than once!

🎉 Quick Recap

🚀 Your First Complete Example

package main

import "fmt"

// 1. Declaration
type Student struct {
    Name  string
    Grade int
    Pass  bool
}

func main() {
    // 3. Initialization
    alex := Student{
        Name:  "Alex",
        Grade: 95,
        Pass:  true,
    }

    // 4. Copy behavior
    backup := alex
    backup.Grade = 100

    fmt.Println(alex.Grade)   // 95
    fmt.Println(backup.Grade) // 100

    // 5. Anonymous struct
    temp := struct {
        X, Y int
    }{5, 10}

    fmt.Println(temp.X) // 5
}

💡 Remember This!

Structs are like ID cards for your data. They keep related information together, neat and organized. And when you copy them, you get a whole new card—not just a reference to the same one!

You’ve got this! 🎯