How to Create and Use Custom Packages in Go

Introduction
Prerequisites
Creating Custom Packages
Using Custom Packages
Conclusion

Introduction

In Go, packages are used to organize and reuse code. They provide a way to encapsulate related functionalities into separate modules, making the codebase more manageable and maintainable. In this tutorial, we will learn how to create and use custom packages in Go. By the end of this tutorial, you will be able to modularize your code by creating your own packages and utilize them in your projects.

Prerequisites

Before proceeding with this tutorial, make sure you have the following prerequisites:

Basic knowledge of Go syntax and basics
Go programming environment set up on your machine

Creating Custom Packages

To create a custom package in Go, follow these steps:

Create a new directory for your package. The name of the directory should match the package name.
Inside the package directory, create a new Go source file with a .go extension. This file will contain the code for your package.
Begin the file with the package statement followed by the name of the package. For example, package mypackage.
Define your package-level variables, constants, types, and functions within the file.
Make sure to comment your code, providing an overview and explanation of each component.
Repeat these steps for any additional files within the package directory.

Let’s create a simple math package as an example:
Create a directory called mymath:
```
 $ mkdir mymath
```
Navigate to the mymath directory and create a file called math.go:
```
 $ cd mymath
 $ touch math.go
```

Open math.go in a text editor and add the following content:

 package mymath
    
 import "math"
    
 // Add returns the sum of two integers.
 func Add(a, b int) int {
     return a + b
 }
    
 // Subtract returns the difference between two integers.
 func Subtract(a, b int) int {
     return a - b
 }
    
 // Power returns the result of raising a number to the power of exponent.
 func Power(base, exponent float64) float64 {
     return math.Pow(base, exponent)
 }

Save the file.

Congratulations! You have created your first custom package. The mymath package contains three functions: Add, Subtract, and Power.

Using Custom Packages

Now that we have created our custom package, let’s see how we can use it in our Go programs.

Create a new directory called main:
```
 $ mkdir main
```
Navigate to the main directory and create a file called main.go:
```
 $ cd main
 $ touch main.go
```

Open main.go in a text editor and add the following content:

 package main
    
 import (
     "fmt"
     "mypackage/mymath"
 )
    
 func main() {
     sum := mymath.Add(5, 3)
     fmt.Println("Sum:", sum)
    
     difference := mymath.Subtract(7, 4)
     fmt.Println("Difference:", difference)
    
     result := mymath.Power(2, 3)
     fmt.Println("Result:", result)
 }

Save the file.

In the main.go file, we import our custom package mypackage/mymath using the relative path. We can now use the functions from the mymath package in our main function.
Run the program:
```
 $ go run main.go
```
You should see the following output:
```
 Sum: 8
 Difference: 3
 Result: 8
```
The program successfully uses the functions from our custom package.

Conclusion

In this tutorial, we have learned how to create and use custom packages in Go. By creating custom packages, you can organize and reuse your code, making your projects more modular and maintainable. We have covered the steps to create a custom package and demonstrated how to use it in a Go program. Now you can leverage the power of packages to enhance your Go projects.

You can explore more advanced concepts related to custom packages, such as handling exported and unexported identifiers, utilizing sub-packages, and using package documentation to provide guidelines on using your custom packages effectively. Practice creating your own packages and consider using them in your future Go projects.

Published: 30 September 2022