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.