1
2
3
4
5
6
7
8
package main

import "fmt"

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

1
2
3
4
5
6
7
8
package main           // Package declaration
import "fmt"           // Import statements

// Main function - entry point of the program
func main() {
    // Program logic
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Integers
var i int           // Platform-dependent integer (32 or 64 bit)
var i8 int8         // 8-bit signed integer
var i16 int16       // 16-bit signed integer
var i32 int32       // 32-bit signed integer (alias: rune)
var i64 int64       // 64-bit signed integer

// Unsigned Integers
var u uint          // Unsigned platform-dependent integer
var b byte          // Alias for uint8
var u16 uint16      // 16-bit unsigned integer
var uptr uintptr    // Unsigned integer large enough to hold a pointer

// Floating Point
var f32 float32     // 32-bit floating point
var f64 float64     // 64-bit floating point

// Complex Numbers
var c64 complex64   // Complex with float32 parts
var c128 complex128 // Complex with float64 parts

// Boolean
var boolean bool    // true or false (zero value: false)

// String
var text string     // Immutable UTF-8 string (zero value: "")

// Character (rune)
var char rune       // Unicode code point (alias for int32)

// Empty interface alias (Go 1.18+)
var a any           // Equivalent to interface{}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Arrays (Fixed Size)
var arr [5]int = [5]int{1, 2, 3, 4, 5}

// Slices (Dynamic Arrays)
slice := []int{1, 2, 3, 4, 5}
slice = append(slice, 6)

// Maps (Hash Tables/Dictionaries)
m := map[string]int{
    "apple":  1,
    "banana": 2,
}
m["orange"] = 3
clear(m) // Built-in clear (Go 1.21+)

// Struct
type Person struct {
    Name string
    Age  int
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Variable Declaration
var name string = "John"
age := 30           // Short declaration (type inferred)

// Multiple Variable Declaration
var x, y int = 10, 20

// Constants
const Pi = 3.14159
const (
    StatusOK = 200
    NotFound = 404
)

// Built-in helpers (Go 1.21+)
biggest  := max(1, 7, 3)   // 7
smallest := min(1, 7, 3)   // 1

1
2
3
4
5
6
7
8
a := 10
b := 3
sum  := a + b       // Addition
diff := a - b       // Subtraction
prod := a * b       // Multiplication
div  := a / b       // Division
mod  := a % b       // Modulus

1
2
3
4
5
6
7
a == b  // Equal
a != b  // Not Equal
a < b   // Less Than
a > b   // Greater Than
a <= b  // Less Than or Equal
a >= b  // Greater Than or Equal

1
2
3
4
true && false       // Logical AND
true || false       // Logical OR
!true               // Logical NOT

1
2
3
4
5
6
7
8
9
10
11
12
13
if x > 0 {
    fmt.Println("Positive")
} else if x < 0 {
    fmt.Println("Negative")
} else {
    fmt.Println("Zero")
}

// Compact if statement with initialization
if y := someFunction(); y > 10 {
    // Use y here
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
switch day {
case "Mon", "Tue", "Wed", "Thu", "Fri":
    fmt.Println("Weekday")
case "Sat", "Sun":
    fmt.Println("Weekend")
default:
    fmt.Println("Unknown")
}

// Type switch
switch v := value.(type) {
case int:
    fmt.Println("int:", v)
case string:
    fmt.Println("string:", v)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Traditional for loop
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// While-like loop
for x < 10 {
    x++
}

// Infinite loop
for {
    // Do something
    break  // Exit condition
}

// Range-based iteration
numbers := []int{1, 2, 3, 4, 5}
for index, value := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

// Range over an integer (Go 1.22+)
for i := range 5 {
    fmt.Println(i) // 0..4
}

// Note: since Go 1.22, each loop iteration creates fresh variables,
// so capturing the loop variable in a goroutine or closure is now safe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Basic Function
func add(a, b int) int {
    return a + b
}

// Multiple Return Values
func divideNumbers(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

// Variadic Functions
func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

// Function as a Variable
var operation func(int, int) int
operation = add

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Generic function with type parameter
func Map[T, U any](s []T, f func(T) U) []U {
    out := make([]U, len(s))
    for i, v := range s {
        out[i] = f(v)
    }
    return out
}

// Type constraints
type Ordered interface {
    ~int | ~int64 | ~float64 | ~string
}

func Min[T Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// Generic type
type Stack[T any] struct {
    items []T
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import "iter"

// Function-style iterator
func Count(n int) iter.Seq[int] {
    return func(yield func(int) bool) {
        for i := 0; i < n; i++ {
            if !yield(i) {
                return
            }
        }
    }
}

for v := range Count(5) {
    fmt.Println(v)
}

1
2
3
4
5
6
var x int = 10
var ptr *int = &x   // Pointer to x

*ptr = 20           // Dereferencing and modifying value
fmt.Println(x)      // Prints 20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
type Rectangle struct {
    width, height float64
}

// Value-receiver method
func (r Rectangle) Area() float64 {
    return r.width * r.height
}

// Pointer-receiver method (use for mutation or large structs)
func (r *Rectangle) Scale(factor float64) {
    r.width *= factor
    r.height *= factor
}

// Constructor-like function
func NewRectangle(w, h float64) *Rectangle {
    return &Rectangle{width: w, height: h}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
type Shape interface {
    Area() float64
}

// Implementing Interface (implicit; no "implements" keyword)
func (r Rectangle) Area() float64 {
    return r.width * r.height
}

// `any` is the preferred alias for the empty interface
func PrintAll(values ...any) {
    for _, v := range values {
        fmt.Println(v)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import "errors"

var ErrDivideByZero = errors.New("division by zero")

func divideNumbers(a, b int) (int, error) {
    if b == 0 {
        // %w wraps a sentinel error so callers can use errors.Is / errors.As
        return 0, fmt.Errorf("divideNumbers: %w", ErrDivideByZero)
    }
    return a / b, nil
}

result, err := divideNumbers(10, 0)
if err != nil {
    if errors.Is(err, ErrDivideByZero) {
        fmt.Println("cannot divide by zero")
    }
    fmt.Println("Error:", err)
}

1
2
3
4
5
6
func sayHello() {
    fmt.Println("Hello")
}

go sayHello()  // Runs concurrently

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
ch := make(chan int)        // Unbuffered channel
bch := make(chan int, 10)   // Buffered channel

go func() {
    ch <- 42                // Send value to channel
    close(ch)               // Signal no more sends
}()

value, ok := <-ch           // Receive; ok=false when closed and drained

// Select for multiplexing
select {
case v := <-ch:
    fmt.Println("got", v)
case bch <- 1:
    fmt.Println("sent")
default:
    fmt.Println("no comms ready")
}

1
2
3
4
5
6
7
8
9
10
11
12
import "sync"

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    // Concurrent work
}()
wg.Wait()  // Wait for goroutine to complete

// sync.Once / sync.Mutex / sync.RWMutex available for typical patterns

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import (
    "context"
    "time"
)

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

select {
case <-time.After(3 * time.Second):
    fmt.Println("work done")
case <-ctx.Done():
    fmt.Println("cancelled:", ctx.Err())
}

1
2
3
4
5
6
7
8
import "log/slog"

slog.Info("request handled",
    "method", "GET",
    "status", 200,
    "duration_ms", 42,
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import (
    "slices"
    "maps"
)

s := []int{3, 1, 2}
slices.Sort(s)              // [1 2 3]
i, found := slices.BinarySearch(s, 2)
s = slices.Delete(s, 0, 1)

m1 := map[string]int{"a": 1}
m2 := maps.Clone(m1)
keys := slices.Collect(maps.Keys(m1))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import (
    "log"
    "os"
)

// Reading File
data, err := os.ReadFile("example.txt")
if err != nil {
    log.Fatal(err)
}

// Writing File
err = os.WriteFile("output.txt", []byte("Hello"), 0644)
if err != nil {
    log.Fatal(err)
}

// Note: ioutil was deprecated in Go 1.16; use os and io instead.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Initialize a new module
go mod init example.com/myproject

# Add or update a dependency
go get example.com/some/package@latest

# Tidy up: add missing / remove unused dependencies
go mod tidy

# Show the module dependency graph
go mod graph

# Verify dependencies against go.sum
go mod verify

# Workspaces (Go 1.18+) for multi-module development
go work init ./moduleA ./moduleB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// example_test.go
import "testing"

func TestAdd(t *testing.T) {
    result := add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}

// Table-driven tests
func TestAddTable(t *testing.T) {
    cases := []struct {
        name     string
        a, b, want int
    }{
        {"positive", 2, 3, 5},
        {"zero", 0, 0, 0},
    }
    for _, c := range cases {
        t.Run(c.name, func(t *testing.T) {
            if got := add(c.a, c.b); got != c.want {
                t.Errorf("got %d, want %d", got, c.want)
            }
        })
    }
}

// Benchmarks
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        add(2, 3)
    }
}

// Fuzz tests (Go 1.18+)
func FuzzAdd(f *testing.F) {
    f.Add(1, 2)
    f.Fuzz(func(t *testing.T, a, b int) {
        _ = add(a, b)
    })
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
go build ./...        # Build everything in the module
go run ./cmd/app      # Compile and run a package
go test ./...         # Run all tests
go test -race ./...   # Run tests with the race detector
go test -cover ./...  # Test with coverage
go vet ./...          # Static analysis
gofmt -w .            # Format code (or `go fmt ./...`)
go doc fmt.Println    # View documentation
go install example.com/cmd@latest  # Install a binary

# tool directive (Go 1.24+) tracks developer tools in go.mod
go get -tool golang.org/x/tools/cmd/stringer@latest
go tool stringer ...