go build / run / test

// Compile and generate an executable.
// go build                   // Build the current package.
// go build -o myapp main.go  // Specify the output file name.
// go build ./...             // Build all packages.

// Run directly without building first (useful during development).
// go run main.go
// go run .

// Run tests.
// go test ./...         // Run all tests.
// go test -v ./...      // Run with verbose output.
// go test -run TestXxx  // Run only a specific test.
// go test -cover        // Measure test coverage.

// Format code (follows gofmt conventions).
// go fmt ./...

// Detect issues with static analysis.
// go vet ./...

// --- File: main.go ---

package main

import "fmt"

// Add returns the sum of two integers.
func Add(a, b int) int {
    return a + b
}

// Greet returns a greeting string.
func Greet(name string) string {
    return "Hello, " + name + "!"
}

func main() {
    fmt.Println(Add(3, 4))
    fmt.Println(Greet("Go"))
}

// --- File: main_test.go ---
// Test files must have names ending in _test.go.

/*
package main

import "testing"

// TestAdd tests the Add function.
func TestAdd(t *testing.T) {
    got := Add(3, 4)
    want := 7
    if got != want {
        t.Errorf("Add(3, 4) = %d, want %d", got, want)
    }
}

// TestGreet tests the Greet function.
func TestGreet(t *testing.T) {
    got := Greet("Go")
    want := "Hello, Go!"
    if got != want {
        t.Errorf("Greet(%q) = %q, want %q", "Go", got, want)
    }
}
*/

// --- Build and run examples ---

// Run directly with: go run main.go
// Output: 7
//         Hello, Go!

// Build with: go build -o myapp
// Run with: ./myapp

// Run tests with: go test -v
// --- PASS: TestAdd (0.00s)
// --- PASS: TestGreet (0.00s)
// PASS

// Check coverage with: go test -cover
// PASS    coverage: 100.0% of statements

Go test functions must start with Test and take *testing.T as their argument. Test files must have names ending in _test.go.

go fmt applies a consistent code style across the entire project. In Go, the standard format is used universally — there is no need to debate code style with teammates or AI tools.

go vet detects code that compiles but is likely to cause runtime bugs, such as mismatched printf format verbs. It is recommended to integrate it into your CI pipeline.

For module management, see Go Modules.