Blank Import

A blank import in Go is a package import declaration that uses the blank identifier (_) as an explicit package alias. This mechanism instructs the Go compiler to include the package in the compiled binary and execute its initialization logic, even if none of its exported identifiers (functions, types, or variables) are explicitly referenced in the importing source file.

import (
    "fmt"
    _ "github.com/lib/pq"
    _ "image/png"
)

Compiler Behavior and Side Effects

By design, the Go compiler enforces a strict “no unused imports” rule. If a standard import is declared but its namespace is never accessed, the compiler throws an imported and not used error, halting the build process.

Assigning the blank identifier to the import acts as a namespace sink. It satisfies the compiler’s usage requirement by explicitly discarding the package’s namespace binding. Consequently, the imported package’s namespace is not exposed to the importing file; attempting to call a function or reference a type from the blank-imported package will result in an undefined compiler error.

The primary purpose of a blank import is to import a package solely for its side effects. By forcing the compiler to include the package, developers trigger the package’s internal setup routines. Common real-world use cases include registering database drivers (e.g., _ "github.com/lib/pq"), registering image decoders (e.g., _ "image/png"), or attaching pprof profiling handlers to the default HTTP multiplexer (e.g., _ "net/http/pprof") via their respective init() functions.

Initialization Sequence

Dependency resolution and the determination of initialization order are performed by the Go compiler at compile time, not by the runtime. The Go runtime simply executes the statically compiled sequence of initialization calls exactly once per package during the program’s startup phase, before the main() function begins.

The execution flow follows these steps:

1. Dependency Initialization: The runtime executes the initialization sequence for any transitive dependencies of the blank-imported package, starting from the bottom of the dependency graph.
2. Variable Initialization: All package-level variables declared within the blank-imported package are evaluated and initialized.
3. init() Execution: Every init() function defined within the blank-imported package is executed.
   • If multiple init() functions are defined within the same file, they are executed strictly in declaration order.
   • Across multiple files within the same package, init() functions are executed in the order the source files are presented to the compiler by the go tool.

Master Go with Deep Grasping Methodology!

Learn More