Packages Keep Projects Manageable

Overview

This chapter aims to demonstrate the importance of the use of packages in our Go programs. We will discuss how packages can be used to assist our code in being more maintainable, reusable, and modular. In this chapter, you will see how they can be used to bring structure and organization to our code. This will also be seen in our exercises, activities, and some examples from the Go standard library.

By the end of the chapter, you will be able to describe a package and its structure and declare a package. You will learn to evaluate exported and unexported names in a package, create your own package, and import your custom package. You will also be able to distinguish between executable packages and non-executable packages and create an alias for a package.

Technical requirements

For this chapter, you'll require Go version 1.21 or higher. The code for this chapter can be found at: https://github.com/PacktPublishing/Go-Programming-From-Beginner-to-Professional-Second-Edition-/tree/main/Chapter10.

Introduction

In the previous chapter, we looked at interfaces. We saw how we can use interfaces to describe the behavior of a type. We also discovered that we can pass different types to functions that accept an interface, as long as the type satisfies the interface’s method sets. We also saw how we can achieve polymorphism using interfaces.

In this chapter, we will look at how Go organizes its code into packages. We will see how we can hide or expose different Go constructs such as structs, interfaces, functions, and more, using packages. Our programs have been rather small in the number of lines of code and in complexity to a certain extent. Most of our programs have been contained in a single code file, often named main.go, and inside a single package named main. Later in this chapter, we will explore the significance of package main, so do not be worried at this juncture if you do not understand it. This will not always be the case when you are working on a development...

What is a package?

Go follows the Don’t Repeat Yourself (DRY) principle. This means that you should not write the same code twice. Refactoring your code into functions is the first step of the DRY principle. What if you had hundreds or even thousands of functions that you used regularly? How would you keep track of all those functions? Some of those functions might even have common characteristics. You could have a group of functions that perform math operations, string manipulations, printing, or file-based operations. You may be thinking of breaking them up into individual files:

Figure 10.3: Group functions by files

That could alleviate some of the issues. However, what if your string’s functionality started to grow further? You would then have a ton of string functions in one file or even multiple files. Every program you build would also have to include all of the code for string, math, and io. You would be copying code to every application...

Exported and unexported code

Go has a very simple way to determine whether code is exported or unexported. Exported means that variables, types, functions, and so on are visible from outside of the package. Unexported means it is only visible from inside the package. If a function, type, variable, and so on starts with an uppercase letter, it is exportable; if it starts with a lowercase letter, it is unexportable. There are no access modifiers to be concerned with in Go. If the function name is capitalized, then it is exported, and if it is lowercase, then it is unexported.

Note

It is good practice to only expose code that we want other packages to see. We should hide everything else that is not needed by external packages.

Let’s look at the following code snippet:

package main
import (
    "strings"
    "fmt"
)
func main() {
    str := "found me"
    if...

The init() function

As we have discussed, every Go program (executable) starts in the main package and the entry point is the main() function. There is another special function that we should be aware of, called init(). Each source file can have an init() function, but for now, we will look at the init() function in the context of the main package. When you start writing packages, you might need to provide some initialization (the init() function) for the package. The init() function is used to set up states or values. The init() function adds initialization logic for your package. Here are some examples of uses of the init() function:

• Setting database objects and connections
• The initialization of package variables
• Creating files
• Loading configuration data
• Verifying or repairing the program state

The init() function requires the following:

• Imported packages are initialized first
• Package-level variables are initialized
• The package’...

Summary

In this chapter, we looked at the importance of developing software that is maintainable, reusable, and modular. We discovered how Go’s packages play an important part in meeting those criteria for developing software. We looked at the overall structure of a package. It is made up of a directory, can contain one or more files, and has code that is related. A package is essentially a directory inside of your workspace that contains one or more files that are used for grouping code that is to perform a task. It exposes only the necessary parts to those using your package to get a job done. We discussed the importance of naming packages properly. We also learned how to name a package; that is, concisely, in lowercase, descriptively, using non-plural names, and avoiding generic names. Packages can be executable or non-executable. If a package is the main package, then it is an executable package. The main package must have a main() function, and that is where the entry point...