How Can I Properly Use and Import Internal Packages in Go?

Understanding the Usage of Internal Packages in Go

When organizing Go code, internal packages offer a way to maintain modularity and encapsulation within a project. In the given code structure, an "internal" package is created within the "project" directory.

Excluding Internal Packages from External Imports

However, as mentioned, importing from an internal package outside of its parent directory is not possible. This is because internal packages are not exported and are only accessible from within the project's source tree. External imports from outside the project directory will only work for packages located in the $GOPATH/src tree.

Resolving Import Issues

To resolve the import issues, the project directory can be placed under $GOPATH/src. This ensures that the internal packages are accessible to the main package located at "project/main.go."

Module Support with Go v1.11 and Above

Alternatively, with the introduction of modules in Go v1.11 and later, you can define the module for your project by creating a go.mod file. This file specifies the location of each module within your project. Here's an example of how it would be set up:

project/
    go.mod
    main.go
    
    internal/
        bar/
            bar.go
            go.mod
        
        foo/
            foo.go
            go.mod

go.mod for project/internal/bar:

module bar

go 1.14

bar.go:

package bar

import "fmt"

// Bar prints "Hello from Bar"
func Bar() {
    fmt.Println("Hello from Bar")
}

go.mod for project/internal/foo:

module foo

go 1.14

foo.go:

package foo

import "fmt"

// Foo prints "Hello from Foo"
func Foo() {
    fmt.Println("Hello from Foo")
}

main.go:

package main

import (
    "project/internal/bar"
    "project/internal/foo"
)

func main() {
    bar.Bar()
    foo.Foo()
}

In this setup, the go.mod file defines the module path and dependency information for each internal package. The replace statement ensures that Go knows where to find the internal packages, even though they are outside the standard $GOPATH/src tree.

With this approach, you can easily organize your code using internal packages and access them seamlessly from the main package, providing both modularity and accessibility within your project.

The above is the detailed content of How Can I Properly Use and Import Internal Packages in Go?. For more information, please follow other related articles on the PHP Chinese website!