Accessing struct fields in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of accessing struct fields

What is the output of this Go program?

Go

package main
import "fmt"
type Person struct {
    Name string
    Age  int
}
func main() {
    p := Person{Name: "Alice", Age: 30}
    fmt.Println(p.Name, p.Age)
}

A 30 Alice

B Person{Name: "Alice", Age: 30}

C Name: Alice, Age: 30

D Alice 30

💡 Hint

Remember how to access fields of a struct using dot notation.

The struct fields are accessed using dot notation. fmt.Println prints the values of Name and Age separated by space.

❓ Predict Output

intermediate

Output when accessing nested struct fields

What will this Go program print?

Go

package main
import "fmt"
type Address struct {
    City string
}
type Person struct {
    Name    string
    Address Address
}
func main() {
    p := Person{Name: "Bob", Address: Address{City: "Paris"}}
    fmt.Println(p.Address.City)
}

A Paris

B Bob

C Address{City: "Paris"}

D City: Paris

💡 Hint

Access nested struct fields by chaining dot notation.

The field City is inside Address, which is inside Person. Access it as p.Address.City.

❓ Predict Output

advanced

Output when accessing pointer to struct fields

What is the output of this Go program?

Go

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

A &{Toyota}

B Toyota

C Brand: Toyota

D Compilation error

💡 Hint

Go lets you access struct fields through pointers directly.

In Go, you can access fields of a struct through a pointer using dot notation without explicit dereferencing.

❓ Predict Output

advanced

Output when accessing uninitialized struct fields

What will this Go program print?

Go

package main
import "fmt"
type User struct {
    Username string
    Active   bool
}
func main() {
    var u User
    fmt.Println(u.Username, u.Active)
}

A nil false

B Compilation error

C "" false

D Username Active

💡 Hint

Uninitialized struct fields have zero values.

String zero value is empty string "" and bool zero value is false.

🧠 Conceptual

expert

Understanding field promotion in embedded structs

Given the following Go code, what is the output of the program?

Go

package main
import "fmt"
type Animal struct {
    Name string
}
type Dog struct {
    Animal
    Breed string
}
func main() {
    d := Dog{Animal: Animal{Name: "Buddy"}, Breed: "Beagle"}
    fmt.Println(d.Name)
}

A Buddy

B Dog{Name: "Buddy", Breed: "Beagle"}

C Beagle

D Compilation error: ambiguous field

💡 Hint

Embedded structs promote their fields to the outer struct.

The embedded struct Animal's field Name is promoted to Dog, so d.Name accesses Animal.Name.

Practice

1.

Which of the following is the correct way to access the Age field of a struct variable person in Go?

easy

A. person.Age()

B. person->Age

C. person["Age"]

D. person.Age

Solution

1. Step 1: Understand struct field access syntax in Go

   In Go, struct fields are accessed using dot notation: structVariable.fieldName.

2. Step 2: Apply to the given variable and field

   For variable person and field Age, the correct access is person.Age.

3. Final Answer:

   person.Age -> Option D

4. Quick Check:

   Use dot notation for struct fields = person.Age [OK]

Hint: Use dot (.) to access struct fields in Go [OK]

Common Mistakes:

• Using arrow (->) like in C/C++
• Trying to access fields like map keys
• Calling field as a function with ()

2.

Which of the following code snippets correctly accesses the Title field of a struct book?

type Book struct {
    Title string
    Author string
}

var book Book
// Access Title here

easy

A. book.Title

B. book->Title

C. book["Title"]

D. book.Title()

Solution

1. Step 1: Recall Go struct field access syntax

   Fields in Go structs are accessed using dot notation without parentheses or brackets.

2. Step 2: Apply to the book variable and Title field

   The correct syntax is book.Title.

3. Final Answer:

   book.Title -> Option A

4. Quick Check:

   Dot notation accesses struct fields = book.Title [OK]

Hint: Remember: struct fields use dot, not brackets or arrows [OK]

Common Mistakes:

• Using brackets like a map
• Using arrow operator (->)
• Calling field as a method

3.

What will be the output of the following Go program?

package main
import "fmt"

type Person struct {
    Name string
    Age  int
}

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

medium

A. Alice

B. 30

C. Name

D. Compilation error

Solution

1. Step 1: Understand struct initialization and field access

   The struct Person is initialized with Name: "Alice" and Age: 30. The variable p holds this struct.

2. Step 2: Identify the printed field

   The code prints p.Age, which is 30.

3. Final Answer:

   30 -> Option B

4. Quick Check:

   Print struct field Age = 30 [OK]

Hint: Print struct.field to get that field's value [OK]

Common Mistakes:

• Printing the Name field instead of Age
• Expecting field name as output
• Thinking code causes error

4.

Identify the error in the following Go code and choose the correct fix:

package main
import "fmt"

type Car struct {
    Model string
    Year  int
}

func main() {
    c := Car{Model: "Tesla", Year: 2022}
    fmt.Println(c->Model)
}

medium

A. Add parentheses: c.Model()

B. Change c->Model to c["Model"]

C. Change c->Model to c.Model

D. No error, code is correct

Solution

1. Step 1: Identify incorrect field access operator

   The code uses c->Model, which is invalid in Go. Go uses dot notation for struct fields.

2. Step 2: Correct the field access syntax

   Replace c->Model with c.Model to fix the error.

3. Final Answer:

   Change c->Model to c.Model -> Option C

4. Quick Check:

   Use dot (.) not arrow (->) for struct fields [OK]

Hint: Use dot (.) for struct fields, not arrow (->) [OK]

Common Mistakes:

• Using arrow operator like in C/C++
• Trying to access fields like map keys
• Calling field as a function

5.

Given the struct and code below, what will be the output?

package main
import "fmt"

type Employee struct {
    ID    int
    Name  string
    Title string
}

func main() {
    e := Employee{ID: 101, Name: "Bob", Title: "Developer"}
    e.Title = "Senior Developer"
    fmt.Println(e.Title)
}

hard

A. Senior Developer

B. Developer

C. Title

D. Compilation error

Solution

1. Step 1: Understand struct field update

   The struct Employee is created with Title: "Developer". Then the field Title is updated to "Senior Developer".

2. Step 2: Identify printed value

   The code prints e.Title after update, so output is Senior Developer.

3. Final Answer:

   Senior Developer -> Option A

4. Quick Check:

   Updated struct field prints new value [OK]

Hint: Assign new value with dot, then print updated field [OK]

Common Mistakes:

• Expecting original value instead of updated
• Thinking field cannot be changed
• Confusing field name with value