Struct usage patterns in Go - Mini Project: Build & Apply

Struct usage patterns

📖 Scenario: You are building a simple program to manage information about books in a library. Each book has a title, author, and number of pages.

🎯 Goal: Create a Go program that uses a struct to store book information, then create an instance of the struct, update a field, and print the book details.

📋 What You'll Learn

Define a struct named Book with fields Title (string), Author (string), and Pages (int).

Create a variable myBook of type Book with specific values.

Update the Pages field of myBook.

Print the details of myBook using fmt.Println.

💡 Why This Matters

🌍 Real World

Structs are used in Go to model real-world objects like books, users, or products by grouping related information together.

💼 Career

Understanding structs is essential for Go programming jobs, especially when working with data models, APIs, or databases.

1

Define the Book struct

Define a struct named Book with these fields: Title of type string, Author of type string, and Pages of type int.

Go

package main

import "fmt"

type Book struct {
    // Define Title, Author, and Pages fields here
}

func main() {

    // Your code here
}

Hint

Use the type keyword to define a struct. Each field has a name and a type.

2

Create a Book variable

Inside the main function, create a variable named myBook of type Book with these values: Title set to "Go Programming", Author set to "Alice", and Pages set to 300.

Go

package main

import "fmt"

type Book struct {
    Title  string
    Author string
    Pages  int
}

func main() {
    // Create myBook variable with given values
    // Your code here
}

Hint

Use struct literal syntax with field names to create myBook.

3

Update the Pages field

Update the Pages field of myBook to 350 inside the main function.

Go

package main

import "fmt"

type Book struct {
    Title  string
    Author string
    Pages  int
}

func main() {
    myBook := Book{
        Title:  "Go Programming",
        Author: "Alice",
        Pages:  300,
    }
    // Update Pages field to 350
    // Your code here
}

Hint

Use dot notation to change the Pages field value.

4

Print the book details

Use fmt.Println to print the myBook variable inside the main function.

Go

package main

import "fmt"

type Book struct {
    Title  string
    Author string
    Pages  int
}

func main() {
    myBook := Book{
        Title:  "Go Programming",
        Author: "Alice",
        Pages:  300,
    }
    myBook.Pages = 350
    // Print myBook details
    // Your code here
}

Hint

Use fmt.Println(myBook) to print the struct values.

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