Beginner Go test (Beginner)

Sample questions

5 sample questions from the Beginner Go test, with the answers. Samples are taken out of the live test, so you will not meet these when you sit it.

1. Which of the following is the correct syntax for a struct literal in Go?

   1. struct { Name string; Age int }{ Name: "Alice", Age: 30 }
   2. struct { Name string, Age int }{ Name: "Alice", Age: 30 }
   3. struct { Name string; Age int }(Name: "Alice", Age: 30)
   4. struct { Name string, Age int }(Name: "Alice", Age: 30)

   Answer: A. struct { Name string; Age int }{ Name: "Alice", Age: 30 }

   The correct syntax for a struct literal in Go uses curly braces and field names with colons to assign values. Option 0 follows this syntax correctly. Other options use incorrect syntax such as parentheses or missing field names.

2. Consider the following Go code snippet: `s := []int{1, 2}; s = append(s, 3); fmt.Println(len(s), s)`. What is the output of this code?

   1. The length of the slice is 4, and the slice contains [1, 2, 3, 0].
   2. The length of the slice is 3, and the slice contains [3, 2, 1].
   3. The length of the slice is 2, and the slice contains [1, 2].
   4. The length of the slice is 3, and the slice contains [1, 2, 3].

   Answer: D. The length of the slice is 3, and the slice contains [1, 2, 3].

   When using the `append` function on a slice, if the capacity is sufficient, the element is added to the existing slice. In the given example, the slice `s` is initially `[1, 2]` with a capacity of 2. After appending `3`, the slice's length increases to 3, and the slice becomes `[1, 2, 3]`. The `append` function returns the new slice, which is correctly assigned to `s`.

3. Which of the following is the correct way to unwrap a wrapped error in Go?

   1. Using errors.Is() to check for a specific error type
   2. Using errors.New() to create a new error
   3. Using errors.As() to assign an error to a variable
   4. Using errors.Unwrap() to retrieve the underlying error

   Answer: D. Using errors.Unwrap() to retrieve the underlying error

   In Go, when dealing with wrapped errors, the errors.Unwrap() function is used to retrieve the underlying error. This allows for inspecting the original error that was wrapped. Other options are incorrect because they either refer to non-existent functions or do not correctly address the mechanism for unwrapping errors.

4. Which of the following best describes the difference between maps and structs in Go?

   1. Maps are used for numerical data only, while structs are used for textual data.
   2. Maps are used for grouping related data with fixed fields, while structs are used for dynamic key-value associations.
   3. Maps are used when the keys are not known in advance and can vary dynamically, while structs are used when the data is fixed and related.
   4. Maps and structs are interchangeable and can be used in all scenarios.

   Answer: C. Maps are used when the keys are not known in advance and can vary dynamically, while structs are used when the data is fixed and related.

   Maps are ideal for scenarios where you need to associate values with keys that can change or are not known ahead of time. Structs, on the other hand, are used to group related data with fixed fields. This distinction helps in choosing the right data structure based on the use case.

5. Which statement correctly describes how to control the visibility of struct fields in Go?

   1. Use lowercase letters for all struct fields, as uppercase letters are reserved for method names only.
   2. Use uppercase letters for struct fields that need to be accessible outside the package, and lowercase letters for fields that should remain private within the package.
   3. Use a mix of uppercase and lowercase letters randomly, as Go automatically determines field visibility based on the field's position in the struct definition.
   4. Use uppercase letters for all struct fields, as lowercase letters are not allowed in Go struct definitions.

   Answer: B. Use uppercase letters for struct fields that need to be accessible outside the package, and lowercase letters for fields that should remain private within the package.

   In Go, struct field visibility is determined by the case of the first letter of the field name. Uppercase letters make the field exported (accessible outside the package), while lowercase letters make it unexported (private to the package). This rule applies to all identifiers in Go, including struct fields, methods, and variables.