1 Basic Structure of a Go Program

A Go program starts with the declaration of a package, followed by the import of required packages, package-level variable, constant, and type declarations, and finally the functions contained within the package. Taking "Hello World" as an example, the following is a typical basic structure of a Go program:

package main // Declare the main package, indicating an independently executable program

import "fmt" // Import the fmt package, which contains input and output functions

// main function, the entry point of the program
func main() {
    fmt.Println("Hello, World!") // Output Hello World to the terminal
}

Concept and Purpose of Packages

In Go language, a package is a collection of multiple Go source files and serves as a high-level code reuse mechanism. Each file in Go belongs to a package, and the package name should be the same as the directory name where it resides.

Naming Rules for Source Code Files

The naming of Go source files generally follows lowercase letters and does not contain spaces or special characters, such as hello_world.go. The source file name does not need to be consistent with the package name, but the package declaration statements in all files within the same package should have consistent package names.

Use of Comments in the Program

In Go language, comments come in two forms: single-line comments starting with // and multi-line comments starting with /* and ending with */. The content of comments is ignored by the compiler.

// This is a single-line comment

/*
This is a multi-line comment
which spans over multiple
lines.
*/

2 The main Function and Entry Point of the Program

In a Go program, the main function is specially designed as the entry point of the program. The Go runtime automatically calls the main function within the main package to start the program execution.

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

The main function takes no arguments and has no return values. After the execution of the main function, the program automatically terminates. If a status code is required to be returned when the program exits, the os.Exit function should be used.

3 Building and Running the Program

Using the go build Command

Running the go build command will compile the source code file and generate an executable file. In the terminal, navigate to the directory where the source file is located, and then enter the following command:

go build hello_world.go

Upon successful execution, you will see an executable file named hello_world (or hello_world.exe on Windows) in the current directory.

Using the go run Command

The go run command compiles and runs the Go program, which is very convenient for quick testing and development. To run the Hello World program, you can enter:

go run hello_world.go

After executing this command, you should immediately see the output "Hello, World!" in the terminal.

4. Program Output

In a Go program, the Println function provided by the fmt package can be used to output information to the terminal. The following is a code example that outputs "Hello, World!" to the terminal:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!") // Output to the terminal
}

After executing the program, the output can be directly viewed in the command-line terminal. Additionally, more complex output requirements can be achieved using the log package or by directly manipulating the standard output stream os.Stdout.

import "os"
os.Stdout.WriteString("Hello, World!\n") // Directly manipulate standard output stream

import "log"
log.Println("Hello, World!") // Using the log package for output, which includes date and time information

These basic output methods are important means of interacting with users and are commonly used for debugging programs to print critical information.