Struct usage patterns in Go - Step-by-Step Execution

Concept Flow - Struct usage patterns

Define struct type

↓

Create struct instance

↓

Access or modify fields

↓

Use struct in functions or methods

↓

Pass struct by value or pointer

↓

Update or read fields

↓

End or reuse struct

This flow shows how to define a struct, create instances, access fields, and use structs in functions or methods, including passing by value or pointer.

Execution Sample

Go

package main

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    p.Age = 31
}

Defines a Person struct, creates an instance, and updates the Age field.

Execution Table

Step	Action	Code Line	Variable State	Output/Result
1	Define struct type Person	type Person struct {...}	Person type created	No output
2	Create instance p with Name 'Alice' and Age 30	p := Person{Name: "Alice", Age: 30}	p = {Name: "Alice", Age: 30}	No output
3	Access and modify p.Age to 31	p.Age = 31	p = {Name: "Alice", Age: 31}	No output
4	End of main function	}	p = {Name: "Alice", Age: 31}	Program ends

💡 Program ends after main function completes

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
p	undefined	{Name: "Alice", Age: 30}	{Name: "Alice", Age: 31}	{Name: "Alice", Age: 31}

Key Moments - 2 Insights

Why do we use pointers to structs instead of values sometimes?

Using pointers allows functions to modify the original struct fields, as shown in the flow where passing by pointer lets changes persist outside the function. Value passing copies the struct, so changes inside functions don't affect the original.

Can we access struct fields directly after creating an instance?

Yes, as shown in step 3 of the execution_table, you can access and modify fields directly using dot notation like p.Age.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of p after step 2?

A {Name: "Alice", Age: 30}

B {Name: "Alice", Age: 31}

C undefined

D nil

💡 Hint

Check the 'Variable State' column for step 2 in execution_table

At which step does the Age field of p change?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Variable State' columns in execution_table

If we passed p by value to a function and modified Age inside, what would happen?

A Original p.Age changes

B Original p.Age stays the same

C Program crashes

D Age field is deleted

💡 Hint

Refer to key_moments about pointer vs value passing

Concept Snapshot

Struct usage patterns in Go:
- Define struct with type keyword
- Create instances with field names
- Access/modify fields with dot notation
- Pass structs by value or pointer
- Pointer passing allows modifying original
- Value passing copies struct, no original change

Full Transcript

This visual execution shows how to use structs in Go. First, we define a struct type named Person with fields Name and Age. Then, we create an instance p with Name 'Alice' and Age 30. Next, we access and modify the Age field to 31 using dot notation. The variable tracker shows how p changes from undefined to the new values. Key moments clarify why pointers are used to modify structs in functions and confirm direct field access. The quiz tests understanding of variable states and passing behavior. The snapshot summarizes the main points for quick review.

Practice

1. What is the primary purpose of using a struct in Go?

easy

A. To group related data with named fields

B. To perform arithmetic operations

C. To create loops

D. To handle errors

Solution

1. Step 1: Understand the role of structs

   Structs are used to group related data together in one unit with named fields.

2. Step 2: Compare with other options

   Arithmetic, loops, and error handling are not the main purposes of structs.

3. Final Answer:

   To group related data with named fields -> Option A

4. Quick Check:

   Structs = Group related data [OK]

Hint: Structs group data fields logically [OK]

Common Mistakes:

• Thinking structs are for control flow
• Confusing structs with functions
• Assuming structs handle errors

2. Which of the following is the correct way to declare a struct type named Person with fields Name (string) and Age (int)?

easy

A. Person := struct { Name string; Age int }

B. struct Person { Name string; Age int }

C. var Person struct Name string; Age int

D. type Person struct { Name string; Age int }

Solution

1. Step 1: Recall Go struct declaration syntax

   In Go, a struct type is declared with the keyword type, followed by the name, then struct and fields inside braces.

2. Step 2: Check each option

   type Person struct { Name string; Age int } matches the correct syntax. struct Person { Name string; Age int } misses type. Person := struct { Name string; Age int } uses := which is for variables, not type declaration. var Person struct Name string; Age int is invalid syntax.

3. Final Answer:

   type Person struct { Name string; Age int } -> Option D

4. Quick Check:

   Struct declaration uses 'type Name struct { fields }' [OK]

Hint: Use 'type Name struct { fields }' to declare structs [OK]

Common Mistakes:

• Omitting 'type' keyword
• Using := for type declaration
• Incorrect field syntax

3. What will be the output of the following Go code?

type Point struct {
  X int
  Y int
}

func main() {
  p := Point{X: 3, Y: 4}
  p.X = 10
  fmt.Println(p.X, p.Y)
}

medium

A. 10 4

B. 3 4

C. 10 0

D. 0 4

Solution

1. Step 1: Understand struct initialization and modification

   The struct Point is initialized with X=3 and Y=4. Then p.X is changed to 10.

2. Step 2: Determine printed values

   After modification, p.X is 10 and p.Y remains 4. So printing p.X and p.Y outputs '10 4'.

3. Final Answer:

   10 4 -> Option A

4. Quick Check:

   Modified field prints updated value [OK]

Hint: Changing struct fields updates their values [OK]

Common Mistakes:

• Assuming original values stay after assignment
• Confusing field names
• Forgetting to import fmt (not shown here)

4. Identify the error in the following Go code snippet:

type Car struct {
  Brand string
  Year  int
}

func main() {
  c := Car{Brand: "Toyota", Year: "2020"}
  fmt.Println(c)
}

medium

A. Missing semicolon after struct declaration

B. Year field assigned a string instead of int

C. Incorrect struct name capitalization

D. fmt.Println cannot print structs

Solution

1. Step 1: Check field types in struct literal

   The struct Car has Year as int, but the code assigns "2020" (a string) to Year.

2. Step 2: Verify other options

   Semicolons are optional in Go. Struct name capitalization is fine. fmt.Println can print structs.

3. Final Answer:

   Year field assigned a string instead of int -> Option B

4. Quick Check:

   Field types must match assigned values [OK]

Hint: Match struct field types exactly when assigning [OK]

Common Mistakes:

• Assigning wrong data types to fields
• Thinking semicolons are mandatory
• Assuming fmt.Println can't print structs

5. Given a struct type Employee with fields Name (string), Salary (int), and Active (bool), which code snippet correctly creates a slice of active employees with salary over 50000 from a given slice emps?

hard

A. filtered := make([]Employee, 0)
for _, e := range emps {
if e.Active || e.Salary > 50000 {
filtered = append(filtered, e)
}
}

B. filtered := []Employee{}
for i := 0; i < len(emps); i++ {
if emps[i].Salary > 50000 {
filtered = append(filtered, emps[i])
}
}

C. var filtered []Employee
for _, e := range emps {
if e.Active && e.Salary > 50000 {
filtered = append(filtered, e)
}
}

D. filtered := []Employee{}
for _, e := range emps {
if e.Active && e.Salary < 50000 {
filtered = append(filtered, e)
}
}

Solution

1. Step 1: Understand filtering conditions

   We want employees who are active AND have salary greater than 50000.

2. Step 2: Analyze each option's condition

   var filtered []Employee for _, e := range emps { if e.Active && e.Salary > 50000 { filtered = append(filtered, e) } } uses correct AND condition. filtered := []Employee{} for i := 0; i < len(emps); i++ { if emps[i].Salary > 50000 { filtered = append(filtered, emps[i]) } } misses Active check. filtered := make([]Employee, 0) for _, e := range emps { if e.Active || e.Salary > 50000 { filtered = append(filtered, e) } } uses OR instead of AND. filtered := []Employee{} for _, e := range emps { if e.Active && e.Salary < 50000 { filtered = append(filtered, e) } } uses salary less than 50000, which is wrong.

3. Final Answer:

   var filtered []Employee for _, e := range emps { if e.Active && e.Salary > 50000 { filtered = append(filtered, e) } } -> Option C

4. Quick Check:

   Use AND (&&) for combined conditions [OK]

Hint: Use && to combine multiple filter conditions [OK]

Common Mistakes:

• Using || instead of && for filtering
• Ignoring one of the filter conditions
• Filtering with wrong comparison operators