Go Language

Learn Go: How To Create & Share Packages in Go #16

This tutorial will guide you through writing Go packages for use within other programming files.

Lets go!!

Published · Jan 21 2020

Previous Tutorial: How to Import & Use packages in Golang #15

A package is made up of Go files that live in the same directory and have the same package statement at the beginning. You can include additional functionality from packages to make your programs more sophisticated. 

Some packages are available through the Go Standard Library and are therefore installed with your Go installation. Others can be installed with Go’s go get command. 

You can also build your own Go packages by creating Go files in the same directory across which you want to share code by using the necessary package statement.

  
This tutorial will guide you through writing Go packages for use within other programming files.
. . .
Writing and Importing Packages
Writing a package is just like writing any other Go file. Packages can contain definitions of functions, types, and variables that can then be used in other Go programs.

Before we create a new package, we need to be in our Go workspace. This is typically under our gopath. For the example, in this tutorial we will call the package greet. 

To do this, we’ve created a directory called greet in our gopath under our project space. If our organization were golang-book, and we wanted to create the math package under the organization while using Github as our code repository, then our directory would look like this:
└── $GOPATH
    └── src
        └── github.com
            └── jochasinga
               └── golang-book
                  └── chapter11
                    └── math"

Finally, we can add the first file in our directory. It is considered common practice that the primary or entry point file in a package is named after the name of the directory. In this case, we would create a file called greet.go inside the greet directory:
└── $GOPATH
    └── src
        └── github.com
            └── jochasinga
               └── golang-book
                  └── chapter11
                    └── math
                      └── math.go

With the file created, we can begin to write our code that we want to reuse or share across projects. In this case, we will create a function called Hello that prints out Hello World.

Open your math.go file in your text editor and add the following code:
package math

// Finds the average of a series of numbers
func Average(xs []float64) float64 {
	total := float64(0)
	for _, x := range xs {
		total += x
	}
	return total / float64(len(xs))
}

Let’s break this first file down. The first line of each file needs the name of the package that you are working in. Since you’re in the greet package, you use the package keyword followed by the name of the package:
package math

This will tell the compiler to treat everything in the file as being part of the math package.

Next you declare any other packages you need to use with the import statement. You’re only using one in this file—the fmt package:
import "fmt"

Lastly, you create the function Average. It will find the average of a series of numbers
func Average(xs []float64) float64 {
	total := float64(0)
	for _, x := range xs {
		total += x
	}
	return total / float64(len(xs))
}

In your text editor, open main.go and add the following code to call the math package:
package main

import "fmt"
import "github.com/jochasinga/golang-book/chapter11/math"

func main() {
  xs := []float64{1,2,3,4}
  avg := math.Average(xs)
  fmt.Println(avg)
}


Because you’re importing a package, you need to call the function by referencing the package name in dot notation. Dot notation is the practice of putting a period. between the name of the package you are using and the resource within that package that you want to use. 

For instance, in your greet package, you have the Hello function as a resource. If you want to call that resource, you use the dot notation of math.Average().

. . .

Exported Names
We capitalised the function Average in the math package. This has a special meaning in Go.

Any variable or function which starts with a capital letter are exported names in go. Only exported functions and variables can be accessed from other packages. In this case we need to access Average function from the main package. Hence they are capitalised.
. . .
Conclusion
Writing a Go package is the same as writing any other Go file, but placing it in another directory allows you to isolate the code to be reused elsewhere. 

This tutorial covered how to write definitions within a package, demonstrated how to make use of those definitions within another Go programming file, and explained the options for where to keep the package in order to access it.
. . .
Next Tutorial: An Introduction to Arrays in Golang #17

Golang Tutorial Series:  Learn Go: Beginners Guide to Learn Golang from Scratch!
. . .