How does the go fmt command differ from go vet?

  • go fmt checks code formatting only.
  • go vet checks for syntax errors.
  • go fmt checks for unused variables.
  • go vet checks for race conditions.
The go fmt command is used for formatting Go source code to adhere to the Go programming style guidelines. It focuses solely on code formatting, such as indentation, spacing, and line breaks. On the other hand, go vet is used for checking for suspicious constructs in your code, like potential bugs, dead code, or suspicious variable usage. It primarily checks for code correctness and doesn't address code formatting issues.

What is the purpose of the len and cap functions in Go when working with slices?

  • len returns the capacity of a slice, and cap returns the length.
  • len returns the length of a slice, and cap returns the capacity.
  • len returns the number of elements, and cap returns the address.
  • len and cap are not used with slices.
In Go, the len function returns the length (the number of elements) of a slice, while the cap function returns the capacity (the maximum number of elements the slice can hold without resizing). These functions are crucial when working with slices because they allow you to determine the current size of a slice and its capacity for future growth. Understanding how to use len and cap helps you manage and manipulate slices effectively in your Go programs.

The Marshal and Unmarshal functions in Go are part of the _____ package.

  • encoding/json
  • fmt
  • net/http
  • encoding/xml
The Marshal and Unmarshal functions in Go are part of the encoding/json package. These functions are used to encode Go data structures into JSON format and decode JSON data into Go data structures, respectively. The encoding/json package provides the necessary functions and types for working with JSON data in Go, making it an essential package for handling JSON encoding and decoding operations in the language.

What is the significance of the t.Fatal function in testing?

  • It marks a test as successful.
  • It terminates the test immediately and reports it as a failure.
  • It skips the current test and moves to the next one.
  • It pauses the test execution.
In Go testing, the t.Fatal function is used to terminate the current test immediately and report it as a failure. This function is typically used when a critical condition is not met during the test execution, and you want to indicate that the test cannot proceed successfully. It helps in identifying and diagnosing issues more precisely by stopping the test as soon as a problem is encountered, rather than continuing to execute the subsequent test code.

Explain how you would read from a file in Go line by line.

  • Use the ioutil.ReadFile function to read the entire file into memory at once and then split it into lines.
  • Use the os.Open function to open the file, create a Scanner to read line by line, and loop through the file.
  • Use the fmt.Scanln function to read lines from the file one by one.
  • Use the bufio.NewReader function to create a buffered reader for the file and then use the ReadString method to read lines.
In Go, to read from a file line by line, you typically use the os.Open function to open the file, creating a *os.File object. Then, you create a Scanner using bufio.NewScanner(file) and use a loop to iterate over the lines using the scanner.Scan() method. This method reads one line at a time, and you can access the text of the line using scanner.Text(). This approach is memory-efficient as it doesn't load the entire file into memory.

Explain the concept of a higher-order function in Go.

  • A function that returns an integer.
  • A function that takes a function as an argument and/or returns a function as a result.
  • A function that can be called only from within the same package.
  • A function that cannot be tested.
In Go, a higher-order function is a function that takes one or more functions as arguments and/or returns a function as its result. This concept enables functional programming paradigms in Go, allowing you to write more flexible and reusable code. Higher-order functions are often used to implement functional constructs like map, reduce, and filter, which operate on collections of data. They promote code modularity and make it easier to reason about and test your code.

How do you check for errors when working with files in Go?

  • if err != nil { log.Fatal(err) }
  • if error != nil { panic(error) }
  • if error != nil { return error }
  • if err { return err }
When working with files in Go, you should check for errors by using conditional statements. The correct option is if err != nil { log.Fatal(err) }. This checks if the err variable (commonly used for error handling) is not nil and, if not, logs the error and exits the program using log.Fatal(). Proper error handling is essential when dealing with file operations in Go.

Go has a special statement called defer, which schedules a function to be called _____ the surrounding function returns.

  • after
  • before
  • during
  • instead of
In Go, the defer statement schedules a function to be called after the surrounding function returns. This is often used for tasks like closing files, releasing resources, or ensuring cleanup operations happen even in the presence of errors. When defer is used, the function call is deferred until the end of the enclosing function's scope, ensuring it runs just before that function returns.

Imagine you are building a Go program to manage a library's book inventory. Which data structure would you use to store information about each book and why?

  • Array
  • Map
  • Slice
  • Struct
In this scenario, you would prefer to use a Struct in Go to store information about each book. A Struct allows you to define a custom data type with fields to represent attributes of a book (e.g., title, author, ISBN). It provides a way to encapsulate related data and behaviors into a single unit, making it ideal for representing individual books in the library's inventory. Using a Struct allows you to access book properties using dot notation, making your code more organized and readable.

In Go, to encode a data structure into JSON, the fields in the data structure need to be exported, meaning they need to start with a _____ letter.

  • lowercase
  • uppercase
  • capital
  • special
The correct answer is uppercase. In Go, when you encode a data structure into JSON using the encoding/json package, the fields in the data structure need to be exported, which means they need to start with an uppercase letter. Exported fields are those that are accessible from outside the package, and they are the only fields that the encoding/json package can encode into JSON. This convention is important for proper JSON encoding and decoding in Go.