Module initialization in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the init function in Go?

The init function is used to initialize variables or state before the main program runs. It runs automatically when the package is loaded, without being called explicitly.

intermediate

How many init functions can a single Go package have?

A Go package can have multiple init functions, even within the same file or across different files in the package. All will run in the order the compiler decides.

beginner

When exactly are init functions executed in a Go program?

They run automatically after all package-level variables are initialized and before the main function starts.

beginner

Can you call an init function explicitly in Go code?

No, init functions cannot be called explicitly. They are called automatically by the Go runtime during program startup.

intermediate

What happens if multiple packages have init functions?

All init functions in imported packages run first, in the order of imports, before the init functions in the main package run.

What is the correct way to define an init function in Go?

A func init() { /* code */ }

B func initialize() { /* code */ }

C func Init() { /* code */ }

D func start() { /* code */ }

The init function must be named exactly init with no parameters or return values.

When does the init function run in a Go program?

A Before package-level variables are initialized

B After the <code>main</code> function runs

C Only when called explicitly

D After package-level variables are initialized and before <code>main</code>

The init function runs automatically after package variables are set and before main.

Can you have more than one init function in a single Go package?

A No, only one is allowed

B Yes, multiple are allowed

C Only one per file

D Only if they have different names

Multiple init functions can exist in the same package and will all run.

What happens if you try to call init() explicitly in your code?

A It is ignored

B It runs normally

C It causes a compile error

D It runs but only once

init functions cannot be called explicitly; attempting to do so causes a compile error.

If package A imports package B, when does package B's init run?

A Before package A's <code>init</code>

B After package A's <code>init</code>

C At the same time as package A's <code>init</code>

D Only if package B is used in <code>main</code>

Imported packages' init functions run before the importing package's init.

Explain the role and behavior of the init function in Go module initialization.

Think about what happens before your program starts running main.

Describe how Go handles multiple init functions across different packages during program startup.

Consider the sequence of package loading.

Practice

1. What is the main purpose of the init function in a Go module?

easy

A. To run setup code automatically before main starts

B. To define the main entry point of the program

C. To declare global variables

D. To handle user input during runtime

Solution

1. Step 1: Understand the role of init in Go

   The init function is designed to run automatically before the main function starts.

2. Step 2: Differentiate from other functions

   Unlike main, init is used for setup tasks, not for program entry or input handling.

3. Final Answer:

   To run setup code automatically before main starts -> Option A

4. Quick Check:

   init runs before main [OK]

Hint: Remember: init runs before main automatically [OK]

Common Mistakes:

• Confusing init with main
• Thinking init handles user input
• Assuming init must be called manually

2. Which of the following is the correct syntax to declare an init function in Go?

easy

A. init func() {}

B. func init() {}

C. function init() {}

D. func Init() {}

Solution

1. Step 1: Recall Go function syntax

   In Go, functions start with the keyword func, followed by the function name and parentheses.

2. Step 2: Check init function naming rules

   The init function must be lowercase and have no parameters or return values.

3. Final Answer:

   func init() {} -> Option B

4. Quick Check:

   Correct init syntax = func init() {} [OK]

Hint: Use lowercase init with empty parentheses [OK]

Common Mistakes:

• Capitalizing Init instead of init
• Using wrong keywords like function
• Adding parameters or return types to init

3. What will be the output of this Go program?

package main
import "fmt"
func init() {
    fmt.Println("Init 1")
}
func init() {
    fmt.Println("Init 2")
}
func main() {
    fmt.Println("Main")
}

medium

A. Init 2
Init 1
Main

B. Main
Init 1
Init 2

C. Init 1
Init 2
Main

D. Init 1
Main
Init 2

Solution

1. Step 1: Understand multiple init functions execution order

   All init functions run automatically before main, in the order they appear in the source file.

2. Step 2: Trace the output sequence

   First, "Init 1" prints, then "Init 2", and finally "Main" from the main function.

3. Final Answer:

   Init 1 Init 2 Main -> Option C

4. Quick Check:

   Multiple init run in order before main [OK]

Hint: Multiple init run top to bottom before main [OK]

Common Mistakes:

• Assuming main runs before init
• Thinking init functions run in random order
• Confusing output order of init functions

4. Identify the error in this Go code snippet related to init function:

package main
func init() {
    fmt.Println("Starting")
}
func main() {
    fmt.Println("Running")
}

medium

A. main function must be named Main

B. init function cannot print output

C. Multiple init functions are required

D. Missing import of the fmt package

Solution

1. Step 1: Check for required imports

   The code uses fmt.Println but does not import the fmt package, causing a compile error.

2. Step 2: Validate other code parts

   init can print output, multiple init are optional, and main must be lowercase.

3. Final Answer:

   Missing import of the fmt package -> Option D

4. Quick Check:

   Use import "fmt" to fix [OK]

Hint: Always import packages before using their functions [OK]

Common Mistakes:

• Forgetting to import fmt
• Thinking init cannot print
• Misnaming main function

5. You want to initialize a configuration map before your Go program runs. Which approach correctly uses init to do this?

var config map[string]string

func init() {
    // What should go here?
}

hard

A. config = make(map[string]string)
config["env"] = "production"

B. config := map[string]string{"env": "production"}

C. var config = map[string]string{"env": "production"}

D. config = nil

Solution

1. Step 1: Understand map initialization in init

   The global config variable must be assigned a new map using make before adding keys.

2. Step 2: Check each option

   config = make(map[string]string) config["env"] = "production" correctly initializes and sets a key. config := map[string]string{"env": "production"} uses := which creates a new local variable, not affecting the global. var config = map[string]string{"env": "production"} declares a local config inside init, not affecting the global. config = nil sets config to nil, which is not useful.

3. Final Answer:

   config = make(map[string]string) config["env"] = "production" -> Option A

4. Quick Check:

   Use make to initialize maps before use [OK]

Hint: Use make to initialize maps before adding keys [OK]

Common Mistakes:

• Using := inside init creates local variable
• Not initializing map before assignment
• Setting map to nil instead of a new map