Creating struct values in Go - Quick Revision & Summary

Recall & Review

beginner

What is a struct in Go?

A struct in Go is a collection of fields grouped together to form a single data type. It is used to represent a record or an object with multiple properties.

beginner

How do you create a struct value using a struct literal?

You create a struct value by specifying the struct type followed by curly braces containing field values, like: Person{Name: "Alice", Age: 30}.

intermediate

What is the difference between named fields and positional fields when creating a struct value?

Named fields specify the field names explicitly (e.g., Person{Name: "Bob", Age: 25}), while positional fields provide values in the order of declaration without naming (e.g., Person{"Bob", 25}). Named fields improve readability and safety.

beginner

How do you create a pointer to a struct value?

You can create a pointer to a struct by using the address operator & before a struct literal, like: p := &Person{Name: "Eve", Age: 28}.

intermediate

What happens if you omit some fields when creating a struct value with named fields?

Omitted fields are set to their zero values automatically. For example, if you omit an int field, it becomes 0; if you omit a string field, it becomes an empty string.

How do you create a struct value with named fields in Go?

A Person{Name: "John", Age: 40}

B Person("John", 40)

C new Person("John", 40)

D Person->Name = "John"

Named fields require specifying the field names inside the struct literal, like Person{Name: "John", Age: 40}.

What is the zero value of an omitted int field in a struct?

A "" (empty string)

B nil

C undefined

D 0

The zero value for int fields is 0 when omitted in a struct literal.

How do you create a pointer to a struct value in Go?

A Person&{Name: "Anna", Age: 22}

B *Person{Name: "Anna", Age: 22}

C &Person{Name: "Anna", Age: 22}

D new Person{Name: "Anna", Age: 22}

Using the & operator before a struct literal creates a pointer to that struct.

Which of these is a valid way to create a struct value using positional fields?

A Person{"Mike", 35}

B Person{Name: "Mike", Age: 35}

C Person(Age: 35, Name: "Mike")

D Person["Mike", 35]

Positional fields provide values in order without naming, like Person{"Mike", 35}.

What is the benefit of using named fields over positional fields when creating struct values?

A Makes the code run faster

B Improves readability and reduces errors

C Allows omitting required fields

D Automatically initializes pointers

Named fields make the code easier to read and help avoid mistakes by explicitly naming each field.

Explain how to create a struct value in Go using named fields and what happens if some fields are omitted.

Think about how you write the field names and what default values Go uses.

Describe how to create a pointer to a struct value and why you might want to use a pointer.

Pointers let you work with the original data without copying.

Practice

1. What is the correct way to create a struct value with fields Name as "Alice" and Age as 30 in Go?

easy

A. person := Person("Alice", 30)

B. person := Person{30, "Alice"}

C. person := Person{Name: "Alice", Age: 30}

D. person := Person{Name = "Alice", Age = 30}

Solution

1. Step 1: Understand struct literal syntax

   In Go, struct values are created using the syntax StructType{FieldName: value, ...} for clarity and correctness.

2. Step 2: Match the syntax with the given options

   person := Person{Name: "Alice", Age: 30} uses the correct syntax with field names and values. Options A and C use positional values without field names, which is allowed but less clear and can cause errors if order changes. person := Person{Name = "Alice", Age = 30} uses '=' which is invalid in struct literals.

3. Final Answer:

   person := Person{Name: "Alice", Age: 30} -> Option C

4. Quick Check:

   Use field names with colons in struct literals = B [OK]

Hint: Use field names with colons to create structs clearly [OK]

Common Mistakes:

• Using parentheses instead of braces
• Using '=' instead of ':' in struct literals
• Mixing field order without names causing confusion

2. Which of the following is the correct syntax to create a struct value with zero values for all fields in Go?

easy

A. p := Person{}

B. p := Person()

C. p := new(Person)

D. p := Person(nil)

Solution

1. Step 1: Recall zero value struct creation

   In Go, creating a struct with zero values for all fields is done by using empty braces after the struct type: StructType{}.

2. Step 2: Evaluate options

   p := Person{} uses Person{} which creates a struct with zero values. p := Person() uses parentheses which is invalid syntax. p := new(Person) uses new(Person) which returns a pointer, not a struct value. p := Person(nil) uses nil which is invalid for struct values.

3. Final Answer:

   p := Person{} -> Option A

4. Quick Check:

   Empty braces create zero-value struct = C [OK]

Hint: Use empty braces {} to create zero-value struct [OK]

Common Mistakes:

• Using parentheses instead of braces
• Confusing new() pointer with struct value
• Passing nil to struct literal

3. Given the struct and code below, what will be printed?

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Bob", Age: 25}
    p.Age = 26
    fmt.Println(p)
}

medium

A. {Bob 25}

B. {Bob 26}

C. Person{Name: "Bob", Age: 26}

D. Syntax error

Solution

1. Step 1: Create struct and modify field

   The struct Person is created with Name "Bob" and Age 25. Then the Age field is updated to 26.

2. Step 2: Print the struct value

   Printing the struct with fmt.Println shows the field values in braces. Since Age was updated to 26, the output is {Bob 26}.

3. Final Answer:

   {Bob 26} -> Option B

4. Quick Check:

   Updated field value shows in output = D [OK]

Hint: Changing a field after creation updates printed struct [OK]

Common Mistakes:

• Assuming original Age remains unchanged
• Expecting struct type name in print output
• Confusing syntax error with valid code

4. What is wrong with the following code snippet?

type Person struct {
    Name string
    Age  int
}

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

medium

A. Age field has wrong type value

B. Missing parentheses in struct creation

C. Name field is not initialized

D. fmt.Println cannot print structs

Solution

1. Step 1: Check field types in struct literal

   The struct Person has Age as int type, but the code assigns "30" which is a string, causing a type mismatch error.

2. Step 2: Identify the error cause

   Assigning a string to an int field is invalid in Go and causes a compile-time error.

3. Final Answer:

   Age field has wrong type value -> Option A

4. Quick Check:

   Field types must match exactly = A [OK]

Hint: Match field types exactly when creating struct values [OK]

Common Mistakes:

• Assigning string to int field
• Confusing struct literal syntax errors
• Thinking fmt.Println can't print structs

5. How can you create a slice of struct values representing three people with names "Anna", "Ben", "Cara" and ages 22, 28, 31 respectively in Go?

hard

A. people := []Person{Person("Anna", 22), Person("Ben", 28), Person("Cara", 31)}

B. people := [Person]{Name: "Anna", Age: 22, Name: "Ben", Age: 28, Name: "Cara", Age: 31}

C. people := []Person{Name: "Anna", Age: 22, Name: "Ben", Age: 28, Name: "Cara", Age: 31}

D. people := []Person{{Name: "Anna", Age: 22}, {Name: "Ben", Age: 28}, {Name: "Cara", Age: 31}}

Solution

1. Step 1: Understand slice of structs syntax

   A slice of structs is created using []StructType{...} with each element as a struct literal.

2. Step 2: Check each option for correct syntax

   people := []Person{{Name: "Anna", Age: 22}, {Name: "Ben", Age: 28}, {Name: "Cara", Age: 31}} correctly creates a slice with three struct literals using field names. people := [Person]{Name: "Anna", Age: 22, Name: "Ben", Age: 28, Name: "Cara", Age: 31} uses array syntax but incorrect literal format. people := []Person{Name: "Anna", Age: 22, Name: "Ben", Age: 28, Name: "Cara", Age: 31} tries to create slice but misses braces for each struct. people := []Person{Person("Anna", 22), Person("Ben", 28), Person("Cara", 31)} uses parentheses which is invalid for struct literals.

3. Final Answer:

   people := []Person{{Name: "Anna", Age: 22}, {Name: "Ben", Age: 28}, {Name: "Cara", Age: 31}} -> Option D

4. Quick Check:

   Slice of structs uses []Type{{...}, {...}} = A [OK]

Hint: Use double braces for slice of struct literals [OK]

Common Mistakes:

• Using parentheses instead of braces for structs
• Missing braces around each struct in slice
• Confusing array and slice syntax