Go Language

Public and Private Packages & Functions in Golang

When the name begins with a capital letter, it indicates that the modifier is public. And conversely, if it starts with a lowercase letter, it means private.

Aspiring Data Engineer, SAS Certified Base Programmer

Published · Nov 18 2019

I knew that naming, specifically as it relates to capitalization, was how we control exports in Golang.

It was not until I was using the language for a couple weeks that I realized the implications behind this.
. . .

Public & Private Packages
Project folders in addition to containing files .go can also contain folders. In Go language, each folder or subfolder is a package, the files in it must have a package name that is different from the files in other folders.

In a package, we usually write very many components, whether it's functions, structs, variables, or others. These components can be freely used in the same package. 

Examples are as simple as the programs we have practiced in previous chapters, in the package mainthere are many that are defined: functions, variables, closures, structs, and others; all of which can be directly utilized.

If in one program there are more than 1 package, or there are other packages besides main, the components in the other package cannot be accessed freely main, because each component has access rights.
There are 2 types of access rights:
Public Access, indicating the component is allowed to be accessed from another different package
Private Access, means that components can only be accessed in the same package, can be in one file or in several files that are still 1 folder.
Determining the right of access rights for each component is very important.
In Go, how to determine the level of access or modifier is very easy, the marker is the character case, the first character of the name of the function, struct, variable, or others. When the name begins with a capital letter, it indicates that the modifier is public. And conversely, if it starts with a lowercase letter, it means private.
. . .

Use of Public & Private Packages, Imports, and Modifiers
To be more easily understood, then we just practice.

First create a new project folder named  public-private-package in the folder $GOPATH/src,  inside it create a new file named main.go,  set the package file name as main .

Next create a new folder named library in the new folder that was created earlier. In it for a new file library.go, set the name of the package library .

Open the file library.go and then fill in the following code.
package library

import "fmt"

func SayHello() {
    fmt.Println("hello")
}

func introduce(name string) {
    fmt.Println("Hello", name)
}


The file library.go that has been created is determined by the package name library(according to the folder name), contains two functions, SayHello()and introduce().
Functions SayHello(), their access level is public, are indicated by the name of the function beginning with an uppercase letter.
Functions introduce()with a private access level, are indicated by lowercase letters at the beginning of the function name.

Then we test whether the function that modifies private in the package librarycannot be accessed from another package.

Open the file main.go, then write the following code.
package main

import "public-private-package/library"

func main() {
    library.SayHello()
    library.introduce("Mike")
}

It can be seen that the package library that was created earlier, is imported into the package main.

The main folder or root folder in the project being worked on is public-private-package so for importing other packages that are subfolders, the folder path must be written in full, such as "public-private-package/library".

The root folder marker is, the file in the folder is the package main, and the file is run using go run.

Consider the following code.
library.SayHello()
library.introduce("ethan")

How to call a function that is in another package is to write the name of the target package followed by the name of the function using dot notation or a dot, like 
library.SayHello() or library.introduce("ethan")

OK, now try running the code that has been prepared above, the result is an error.

  

The above error is caused because the function introduce()in the package libraryhas a private access level , this function cannot be accessed from other packages (in this case main). To be accessible, the solution can be to make it public, or change the way it is called. Here we use the 2nd way.

Add parameters nameto the function SayHello(), then call the function introduce() by inserting parameters name from within the function SayHello().
func SayHello(name string) {
    fmt.Println("hello")
    introduce(name)
}

In main, just call the function SayHello(), insert a string as a parameter.
func main() {
    library.SayHello("ethan")
}

Try running again.

  

My simple observation is that you can use whatever is exported, and everything else is blackbox to importing packages.

Not a very technical conclusion, but I think that basically sums it up, and the way that functionality is enforced in Go does seem pretty sensible and logical to me.