Defining structs in Go - Step-by-Step Execution

Concept Flow - Defining structs

Start

↓

Define struct type

↓

Create struct variable

↓

Assign values to fields

↓

Use struct variable

↓

End

This flow shows how you define a struct type, create a variable of that type, assign values to its fields, and then use it.

Execution Sample

Go

package main

type Person struct {
    Name string
    Age  int
}

func main() {
    var p Person
    p.Name = "Alice"
    p.Age = 30
}

Defines a struct Person with fields Name and Age, creates a variable p, and assigns values to its fields.

Execution Table

Step	Action	Evaluation	Result
1	Define struct type Person	Person struct with fields Name(string), Age(int)	Type Person created
2	Declare variable p of type Person	p is zero-valued Person	p.Name = "", p.Age = 0
3	Assign p.Name = "Alice"	Set field Name	p.Name = "Alice"
4	Assign p.Age = 30	Set field Age	p.Age = 30
5	Use p (e.g., print)	Access fields	Outputs: Name: Alice, Age: 30

💡 All steps completed, struct variable p fully initialized and used

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
p.Name	""	""	"Alice"	"Alice"	"Alice"
p.Age	0	0	0	30	30

Key Moments - 3 Insights

Why does p.Name start as an empty string before assignment?

In step 2 of the execution_table, p is declared but not assigned, so Go sets string fields to their zero value, which is an empty string.

Can I assign values to struct fields before declaring the variable?

No, as shown in step 3 and 4, you must declare the variable (step 2) before assigning values to its fields.

What happens if I forget to assign a field value?

That field keeps its zero value, like p.Age would stay 0 if not assigned, as seen in step 2.

Visual Quiz - 3 Questions

Look at the variable_tracker, what is the value of p.Age after Step 3?

A 30

B 0

C "Alice"

D undefined

💡 Hint

Check the 'After Step 3' column for p.Age in variable_tracker

At which step in execution_table is the struct variable p declared?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look for 'Declare variable p' action in execution_table

If you skip assigning p.Name, what would be its final value according to variable_tracker?

A "" (empty string)

B "Alice"

C nil

D 0

💡 Hint

See the 'Start' and 'After Step 2' values for p.Name in variable_tracker

Concept Snapshot

Defining structs in Go:
- Use 'type Name struct { fields }' to define
- Declare variable: 'var v Name'
- Fields have zero values initially
- Assign fields: 'v.Field = value'
- Use struct variable after assignment

Full Transcript

This example shows how to define a struct type named Person with two fields: Name and Age. First, the struct type is created. Then, a variable p of type Person is declared, which initializes its fields to zero values (empty string for Name, 0 for Age). Next, values are assigned to the fields: p.Name is set to "Alice" and p.Age to 30. Finally, the struct variable p can be used, for example, printed to show its field values. The variable tracker shows how p.Name and p.Age change step by step. Key moments clarify why fields start with zero values and the order of declaration and assignment. The quiz tests understanding of variable values at different steps and the effect of skipping assignments.

Practice

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

easy

A. To create a new function

B. To group related data fields into a single unit

C. To declare a package

D. To import external libraries

Solution

1. Step 1: Understand the role of structs

   Structs are used to group related data fields together in one unit, like a blueprint for an object.

2. Step 2: Compare with other options

   Functions, packages, and imports serve different purposes unrelated to grouping data.

3. Final Answer:

   To group related data fields into a single unit -> Option B

4. Quick Check:

   Struct = grouped data [OK]

Hint: Structs bundle related info like a real-world object [OK]

Common Mistakes:

• Confusing structs with functions
• Thinking structs declare packages
• Mixing structs with imports

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

easy

A. type Person { Name string; Age int }

B. struct Person { Name string; Age int }

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

D. Person struct { Name string; Age int }

Solution

1. Step 1: Recall Go struct syntax

   In Go, structs are defined using the syntax: type Name struct { fields }.

2. Step 2: Check each option

   type Person struct { Name string; Age int } matches the correct syntax. Options A, B, and C miss the 'type' keyword or 'struct' keyword placement.

3. Final Answer:

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

4. Quick Check:

   Correct struct syntax = type Person struct { Name string; Age int } [OK]

Hint: Remember: 'type Name struct { fields }' [OK]

Common Mistakes:

• Omitting 'type' keyword
• Missing 'struct' keyword
• Incorrect order of keywords

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

package main
import "fmt"
type Car struct {
  Brand string
  Year  int
}
func main() {
  c := Car{Brand: "Toyota", Year: 2020}
  fmt.Println(c.Brand)
}

medium

A. Car{Brand: "Toyota", Year: 2020}

B. 2020

C. Compilation error

D. Toyota

Solution

1. Step 1: Understand struct initialization

   The struct Car is initialized with Brand="Toyota" and Year=2020.

2. Step 2: Identify printed field

   The code prints c.Brand, which is "Toyota".

3. Final Answer:

   Toyota -> Option D

4. Quick Check:

   Print c.Brand = Toyota [OK]

Hint: Print field with dot: variable.FieldName [OK]

Common Mistakes:

• Printing the whole struct instead of a field
• Confusing field names
• Expecting Year instead of Brand

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

package main
import "fmt"
type Book struct {
  Title string
  Pages int
}

func main() {
  b := Book{Title: "Go Guide", Pages: "300"}
  fmt.Println(b)
}

medium

A. Pages field has wrong type, should be int not string

B. Missing import for fmt package

C. Struct fields must be lowercase

D. Cannot print struct directly

Solution

1. Step 1: Check field types in struct initialization

   The Pages field is declared as int but assigned a string "300" which is a type mismatch.

2. Step 2: Verify other possible errors

   Import for fmt package is present. Struct fields can be uppercase. Printing structs directly is allowed.

3. Final Answer:

   Pages field has wrong type, should be int not string -> Option A

4. Quick Check:

   Type mismatch in struct field assignment [OK]

Hint: Match field types exactly when initializing structs [OK]

Common Mistakes:

• Assigning string to int field
• Expecting compilation error from printing struct
• Thinking struct fields must be lowercase

5. Given the struct definition:

type Employee struct {
  Name   string
  Salary int
  Active bool
}

Which of the following code snippets correctly creates a slice of Employee structs with only active employees having salary above 50000?

hard

A. emps := []Employee{{"Alice", 60000, true}, {"Bob", 45000, true}, {"Carol", 70000, false}}
var filtered []Employee
for _, e := range emps {
if e.Active && e.Salary > 50000 {
filtered = append(filtered, e)
}
}

B. emps := []Employee{{"Alice", 60000, true}, {"Bob", 45000, true}, {"Carol", 70000, false}}
filtered := []Employee{}
for i := range emps {
if emps[i].Salary > 50000 {
filtered = append(filtered, emps[i])
}
}

C. emps := []Employee{{"Alice", 60000, true}, {"Bob", 45000, true}, {"Carol", 70000, false}}
filtered := []Employee{}
for _, e := range emps {
if e.Active || e.Salary > 50000 {
filtered = append(filtered, e)
}
}

D. emps := []Employee{{"Alice", 60000, true}, {"Bob", 45000, true}, {"Carol", 70000, false}}
filtered := []Employee{}
for _, e := range emps {
if e.Active && e.Salary < 50000 {
filtered = append(filtered, e)
}
}

Solution

1. Step 1: Understand filtering criteria

   We want only employees who are active and have salary above 50000.

2. Step 2: Check each code snippet logic

   emps := []Employee{{"Alice", 60000, true}, {"Bob", 45000, true}, {"Carol", 70000, false}} var filtered []Employee for _, e := range emps { if e.Active && e.Salary > 50000 { filtered = append(filtered, e) } } uses 'e.Active && e.Salary > 50000' which matches criteria. emps := []Employee{{"Alice", 60000, true}, {"Bob", 45000, true}, {"Carol", 70000, false}} filtered := []Employee{} for i := range emps { if emps[i].Salary > 50000 { filtered = append(filtered, emps[i]) } } misses active check. emps := []Employee{{"Alice", 60000, true}, {"Bob", 45000, true}, {"Carol", 70000, false}} filtered := []Employee{} for _, e := range emps { if e.Active || e.Salary > 50000 { filtered = append(filtered, e) } } uses '||' which includes inactive employees. emps := []Employee{{"Alice", 60000, true}, {"Bob", 45000, true}, {"Carol", 70000, false}} filtered := []Employee{} for _, e := range emps { if e.Active && e.Salary < 50000 { filtered = append(filtered, e) } } uses salary < 50000 which is wrong.

3. Final Answer:

   The code that filters using e.Active && e.Salary > 50000 -> Option A

4. Quick Check:

   Filter with '&&' for both conditions [OK]

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

Common Mistakes:

• Using || instead of && for filtering
• Ignoring the Active field in filter
• Using wrong salary comparison operator