[go language] 5.3.1 Go code organization and formatting

The Go language has a very strict set of code organization and formatting rules. These rules make Go code very easy to read and understand, while also ensuring code consistency.

1. Package

Go code is organized into packages. A package is a directory that contains some Go source files. Every source file begins with a package declaration:

package main

All Go source files in the same directory must belong to the same package.

2. Import

Go source files can import code from other packages. This is  import done with the statement:

import (
    "fmt"
    "math"
)

This statement imports  fmt packages and  math packages of the standard library.

3. Formatting

Go has a built-in tool  gofmtthat automatically formats Go code. gofmt The tool will adjust the indentation, spaces, line breaks, etc. of the code, making the code look very neat.

You can use the tool from the command line  gofmt :

gofmt -w yourfile.go

This command directly modifies  yourfile.go the file to conform to Go's formatting rules.

You can also configure the tool in your text editor or IDE  gofmt to automatically format code when saving files.

4. Best Practices

In addition to the above rules, Go has some programming best practices.

• Use as small functions and packages as possible. This makes the code easier to understand and test.
• Avoid global variables. Global variables can make the state of the code more difficult to understand.
• Use self-describing identifier names. Good names make the code self-explanatory.
• Use Go's error handling mechanisms instead of ignoring errors.

For example, here's a code sample that follows these best practices:

package main

import (
    "fmt"
    "math"
)

func main() {
    
    
    fmt.Println(calcCircleArea(10))
}

func calcCircleArea(radius float64) float64 {
    
    
    return math.Pi * math.Pow(radius, 2)
}

This code defines a  calcCircleArea function to calculate the area of ​​a circle. The function is small, doesn't use global variables, uses self-explanatory identifier names, and doesn't ignore errors (there's actually no possible errors for this function).

Overall, Go's code organization and formatting rules are designed to improve code readability and consistency. Following these rules and best practices will make your Go code easier to read, understand and maintain.