How to Import Packages in Go

When a Go project grows larger, it becomes necessary to access functions and variables from different packages. In Go, we can do this using the import statement. Project Structure Example Consider we have a project structure as below: MainFolder/ │── FolderA/ │── FolderB/ │── FolderC/ │── main.go │── go.mod │── go.sum FolderA has a function → FunctionA FolderB has a function → FunctionB FolderC has a function → FunctionC Importing a Package in main.go If we need to use FunctionA inside main.go, we import the package as follows: package main import ( "MainFolder/FolderA" // Importing FolderA package ) func main() { // Now we can access functions from FolderA FolderA.SampleFunction2() // ✅ This works because it starts with an uppercase letter FolderA.sampleFunction1() // ❌ Error: Unexported function (starts with lowercase) } This rule also applies to struct fields: type User struct { Name string // Exported age int // Unexported } Exported vs Unexported Functions Functions that start with an uppercase letter (SampleFunction2()) are exported and can be accessed from other packages. Functions that start with a lowercase letter (sampleFunction1()) are unexported and can only be accessed within the same package. Example: Correct Function Declarations in FolderA/a.go package FolderA // Package name should match the folder name // Exported function (accessible from other packages) func SampleFunction2() { // Function logic } // Unexported function (only accessible within the same package) func sampleFunction1() { // Function logic } Accessing Another Package from FolderA (Using FolderB's Function in FolderA) Now, let's say we need to call FunctionB from FolderB inside FolderA/a.go: Correct way to import and use FunctionB in FolderA/a.go package FolderA import "MainFolder/FolderB" func sampleFunction1() { FolderB.FunctionB() // ✅ Correct usage } Accessing Global Variables from Another Package If FolderC contains a global variable like DbPass, we can access it from FolderA as follows: Example: Using Global Variables from FolderC in FolderA/a.go package FolderA import ( "MainFolder/FolderB" "MainFolder/FolderC" ) func sampleFunction1() { FolderB.FunctionB() // ✅ Function call // Accessing a global variable from FolderC if FolderC.DbPass == "some value" { // ✅ Variable must start with an uppercase letter // Do something } } Key Takeaways Package Naming Conventions: The package name should match the folder name (e.g., package FolderA inside FolderA/). Exported Functions and Variables: Functions and variables that need to be accessed from other packages must start with an uppercase letter. Lowercase Functions and Variables: Functions and variables that start with lowercase letters are private to the package. Importing a Package: Use import "MainFolder/FolderX" to access other packages in the project. Calling a Function from Another Package: Use PackageName.FunctionName() syntax.

Mar 2, 2025 - 22:38

When a Go project grows larger, it becomes necessary to access functions and variables from different packages. In Go, we can do this using the import statement.

Project Structure Example

Consider we have a project structure as below:

MainFolder/ │── FolderA/ │── FolderB/ │── FolderC/ │── main.go │── go.mod │── go.sum

FolderA has a function → FunctionA

FolderB has a function → FunctionB

FolderC has a function → FunctionC

Importing a Package in main.go

If we need to use FunctionA inside main.go, we import the package as follows:

package main

import (
    "MainFolder/FolderA" // Importing FolderA package
)

func main() {
    // Now we can access functions from FolderA
    FolderA.SampleFunction2() // ✅ This works because it starts with an uppercase letter
    FolderA.sampleFunction1() // ❌ Error: Unexported function (starts with lowercase)
}

This rule also applies to struct fields:

type User struct {
    Name  string  // Exported
    age   int     // Unexported
}

*Exported vs Unexported Functions
*
Functions that start with an uppercase letter (SampleFunction2()) are exported and can be accessed from other packages.

Functions that start with a lowercase letter (sampleFunction1()) are unexported and can only be accessed within the same package.

*Example: Correct Function Declarations in FolderA/a.go
*

package FolderA // Package name should match the folder name

// Exported function (accessible from other packages)
func SampleFunction2() {
    // Function logic
}

// Unexported function (only accessible within the same package)
func sampleFunction1() {
    // Function logic
}

Accessing Another Package from FolderA (Using FolderB's Function in FolderA)

Now, let's say we need to call FunctionB from FolderB inside FolderA/a.go:

Correct way to import and use FunctionB in FolderA/a.go

package FolderA

import "MainFolder/FolderB"

func sampleFunction1() {
    FolderB.FunctionB() // ✅ Correct usage
}

*Accessing Global Variables from Another Package
*
If FolderC contains a global variable like DbPass, we can access it from FolderA as follows:

Example: Using Global Variables from FolderC in FolderA/a.go

package FolderA

import (
    "MainFolder/FolderB"
    "MainFolder/FolderC"
)

func sampleFunction1() {
    FolderB.FunctionB() // ✅ Function call

    // Accessing a global variable from FolderC
    if FolderC.DbPass == "some value" { // ✅ Variable must start with an uppercase letter
        // Do something
    }
}

Key Takeaways

Package Naming Conventions: The package name should match the folder name (e.g., package FolderA inside FolderA/).
Exported Functions and Variables: Functions and variables that need to be accessed from other packages must start with an uppercase letter.
Lowercase Functions and Variables: Functions and variables that start with lowercase letters are private to the package.
Importing a Package: Use import "MainFolder/FolderX" to access other packages in the project.
Calling a Function from Another Package: Use PackageName.FunctionName() syntax.