Code Packages and Package Imports

Introduction of Package Import

package main

import "fmt"

func main() {
	fmt.Println("Go has", 25, "keywords.")
}

• The first line specifies the name of the package containing the source file simple-import-demo.go. The main entry function of a program must be put in a package named main.
• The third line imports the fmt standard package by using the import keyword. The identifier fmt is the package name. It is also used as the import name of, and represents, this standard package in the scope of containing source file. (Import names will be explained a below section.) There are many format functions declared in this standard package for other packages to use. The Println function is one of them. It will print the string representations of an arbitrary number of arguments to the standard output.
• The sixth line calls the Println function. Note that the function name is prefixed with a fmt. in the call, where fmt is the name of the package which contains the called function. The form aImportName.AnExportedIdentifier is called a qualified identifier. AnExportedIdentifier is called an unqualified identifier.
• A fmt.Println function call has no requirements for its arguments, so in this program, its three arguments will be deduced as values of their respective default types, string, int and string.
• For each fmt.Println call, a space character is inserted between each two consecutive string representations and a newline character is printed at the end.

$ go run simple-import-demo.go
Go has 25 keywords.

package main

import "fmt"
import "math/rand"

func main() {
	fmt.Printf("Next pseudo-random number is %v.\n", rand.Uint32())
}

• In this example, the package name rand is used as the import name of the imported math/rand standard package. A rand.Uint32() call will return a random uint32 integer number.
• Printf is another commonly used function in the fmt standard package. A call to the Printf function must take at least one argument. The first argument of a Printf function call must be a string value, which specifies the format of the printed result. The %v in the first argument is called a format verb, it will be replaced with the string representation of the second argument. As we have learned in the article basic types and their literals, the \n in a double-quoted string literal will be escaped as a newline character.

Next pseudo-random number is 2596996162.

package main

// Multiple packages can be imported together.
import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	// Set the random seed (only needed before Go 1.20).
	rand.Seed(time.Now().UnixNano())
	fmt.Printf("Next pseudo-random number is %v.\n", rand.Uint32())
}

• this example imports one more package, the time standard package, which provides many time related utilities.
• function time.Now() returns the current time, as a value of type time.Time.
• UnixNano is a method of the time.Time type. The method call aTime.UnixNano() returns the number of nanoseconds elapsed since January 1, 1970 UTC to the time denoted by aTime. The return result is a value of type int64, which is also the parameter type of the rand.Seed function (note: the rand.Seed function has been deprecated since Go 1.20). Methods are special functions. We can learn methods in the article methods in Go for details later.

More About fmt.Printf Format Verbs

• %v, which will be replaced with the general string representation of the corresponding argument.
• %T, which will be replaced with the type name or type literal of the corresponding argument.
• %x, which will be replaced with the hex string representation of the corresponding argument. Note, the hex string representations for values of some kinds of types are not defined. Generally, the corresponding arguments of %x should be strings, integers, integer arrays or integer slices (arrays and slices will be explained in a later article).
• %s, which will be replaced with the string representation of the corresponding argument. The corresponding argument should be a string or byte slice.
• Format verb %% represents a percent sign.

package main

import "fmt"

func main() {
	a, b := 123, "Go"
	fmt.Printf("a == %v == 0x%x, b == %s\n", a, a, b)
	fmt.Printf("type of a: %T, type of b: %T\n", a, b)
	fmt.Printf("1%% 50%% 99%%\n")
}

a == 123 == 0x7b, b == Go
type of a: int, type of b: string
1% 50% 99%

Package Folder, Package Import Path and Package Dependencies

The init Functions

package main

import "fmt"

func init() {
	fmt.Println("hi,", bob)
}

func main() {
	fmt.Println("bye")
}

func init() {
	fmt.Println("hello,", smith)
}

func titledName(who string) string {
	return "Mr. " + who
}

var bob, smith = titledName("Bob"), titledName("Smith")

hi, Mr. Bob
hello, Mr. Smith
bye

Resource Initialization Order

func f() int {
	return z + y
}

func g() int {
	return y/2
}

var (
	w       = x
	x, y, z = f(), 123, g()
)

Full Package Import Forms

import importname "path/to/package"

import fmt "fmt"        // <=> import "fmt"
import rand "math/rand" // <=> import "math/rand"
import time "time"      // <=> import "time"

package main

import (
	format "fmt"
	random "math/rand"
	"time"
)

func main() {
	random.Seed(time.Now().UnixNano())
	format.Print("A random number: ", random.Uint32(), "\n")

	// The following line fails to compile,
	// for "rand" is not identified.
	/*
	fmt.Print("A random number: ", rand.Uint32(), "\n")
	*/
}

• we must use format and random as the prefix token in qualified identifiers, instead of the real package names fmt and rand.
• Print is another function in the fmt standard package. Like Println function calls, a Print function call can take an arbitrary number of arguments. It will print the string representations of the passed arguments, one by one. If two consecutive arguments are both not string values, then a space character will be automatically inserted between them in the print result.

package main

import (
	. "fmt"
	. "time"
)

func main() {
	Println("Current time:", Now())
}

package main

import _ "net/http/pprof"

func main() {
	... // do some things
}

Each Non-Anonymous Import Must Be Used at Least Once

package main

import (
	"net/http" // error: imported and not used
	. "time"   // error: imported and not used
)

import (
	format "fmt"  // okay: it is used once below
	_ "math/rand" // okay: it is not required to be used
)

func main() {
	format.Println() // use the imported "fmt" package
}

Modules