Struct usage patterns in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a struct named Person.

Go

type Person [1] {
    Name string
    Age  int
}

Drag options to blanks, or click blank then click option'

Astruct

Bclass

Cinterface

Dpackage

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'class' instead of 'struct' which is not valid in Go.

Using 'interface' which defines behavior, not data structure.

In Go, structs are declared using the keyword struct.

2fill in blank

medium

Complete the code to create a new Person instance with Name "Alice" and Age 30.

Go

p := [1] Person{Name: "Alice", Age: 30}

Drag options to blanks, or click blank then click option'

Anew

B*

C&

Dvar

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'new' without assigning fields causes zero values.

Using '*' is for dereferencing, not creating.

Using & before a struct literal returns a pointer to the new struct.

3fill in blank

hard

Fix the error in the method receiver syntax to correctly define a method for Person.

Go

func (p [1] Person) Greet() string {
    return "Hello, " + p.Name
}

Drag options to blanks, or click blank then click option'

Afunc

B&

Cvar

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using '&' which is invalid syntax in method receivers.

Using 'var' or 'func' which are keywords, not receiver types.

Methods with pointer receivers use * before the type name.

4fill in blank

hard

Fill both blanks to create a map from string to Person struct and add an entry.

Go

people := make(map[1]Person)
people["bob"] = [2]{Name: "Bob", Age: 25}

Drag options to blanks, or click blank then click option'

A[string]

BPerson

Cstruct

Dmap

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'map' inside make's type brackets which is incorrect.

Using 'Person' instead of 'struct' for the literal when type is not declared.

The map key type is [string] and the value is a struct literal struct.

5fill in blank

hard

Fill all three blanks to define an anonymous struct, assign values, and print the Name field.

Go

user := [1] {
    Name: "Eve",
    Age:  28,
}
fmt.Println(user.[2])

var info [3] = user

Drag options to blanks, or click blank then click option'

Astruct

BName

Cstruct { Name string; Age int }

DPerson

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Person' type when anonymous struct is expected.

Trying to access a field not declared in the struct.

An anonymous struct is declared with struct { ... }. Access the Name field and assign the same struct type to info.

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