Go¶

package main

import (
    "fmt"
    "time"
)

// Variables (type after name)
var name string = "Go"          // Explicit type
var version = 1.23              // Type inference
const maxConnections = 100      // Constant  // (1)!

// Short declaration (inside functions only)
func main() {
    message := "Hello, World"   // := declares and assigns
    count := 42

    // Multiple assignment
    x, y := 10, 20
    a, b, c := 1, "two", 3.0    // Different types
}

// Functions (return type after params)
func add(x int, y int) int {
    return x + y
}

// Multiple return values (common for error handling)
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}  // (2)!

// Named return values
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return  // Naked return (uses named values)
}

// Structs (data structures)
type User struct {
    ID    int
    Name  string
    Email string
    Age   int
}

func (u User) Greet() string {
    return fmt.Sprintf("Hello, %s", u.Name)
}  // (3)!

// Pointer receivers (modify struct)
func (u *User) Birthday() {
    u.Age++
}

// Interfaces (behavior contracts)
type Greeter interface {
    Greet() string
}  // (4)!

// Arrays and slices
var arr [5]int              // Array (fixed size)
slice := []int{1, 2, 3}     // Slice (dynamic)
slice = append(slice, 4)    // Add to slice

// Maps (hash tables)
ages := make(map[string]int)
ages["Alice"] = 30
ages["Bob"] = 25

// Or literal syntax
scores := map[string]int{
    "Alice": 95,
    "Bob":   87,
}

// Control flow
if x > 10 {
    fmt.Println("x is large")
} else if x > 5 {
    fmt.Println("x is medium")
} else {
    fmt.Println("x is small")
}

// If with initialization
if v := compute(); v < 10 {
    fmt.Println(v)
}  // (5)!

// For loop (only loop keyword in Go)
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// While-style loop
for count < 100 {
    count++
}

// Infinite loop
for {
    // Break condition
    if done {
        break
    }
}

// Range (iterate over slice, map, channel)
for index, value := range slice {
    fmt.Printf("%d: %d\n", index, value)
}

for key, value := range scores {
    fmt.Printf("%s: %d\n", key, value)
}

// Switch (no fallthrough by default)
switch day {
case "Monday":
    fmt.Println("Start of week")
case "Friday":
    fmt.Println("TGIF")
default:
    fmt.Println("Regular day")
}  // (6)!

// Error handling (explicit, no exceptions)
result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)  // Handle error
}
fmt.Println(result)  // Use result

// HTTP server (standard library)
package main

import (
    "encoding/json"
    "log"
    "net/http"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}  // (1)!

func getUsers(w http.ResponseWriter, r *http.Request) {
    users := []User{
        {ID: 1, Name: "Alice"},
        {ID: 2, Name: "Bob"},
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}  // (2)!

func main() {
    http.HandleFunc("/api/users", getUsers)
    log.Println("Server running on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// Goroutines (concurrency)
func fetchURL(url string) {
    resp, err := http.Get(url)
    if err != nil {
        log.Printf("Error fetching %s: %v", url, err)
        return
    }
    defer resp.Body.Close()
    fmt.Printf("Fetched %s: %s\n", url, resp.Status)
}

func main() {
    urls := []string{
        "https://example.com",
        "https://example.org",
        "https://example.net",
    }

    for _, url := range urls {
        go fetchURL(url)  // Launch goroutine
    }

    time.Sleep(5 * time.Second)  // Wait (better: use WaitGroup)
}  // (3)!

// Channels (goroutine communication)
func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
        time.Sleep(time.Second)
        results <- job * 2  // Send result
    }
}  // (4)!

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // Start workers
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // Send jobs
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    // Collect results
    for a := 1; a <= 5; a++ {
        <-results
    }
}

// WaitGroup (better synchronization)
import "sync"

func process(id int, wg *sync.WaitGroup) {
    defer wg.Done()  // Decrement counter when done
    fmt.Printf("Processing %d\n", id)
    time.Sleep(time.Second)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)  // Increment counter
        go process(i, &wg)
    }

    wg.Wait()  // Block until counter is zero
}  // (5)!

// Database operations (PostgreSQL)
import (
    "database/sql"
    _ "github.com/lib/pq"
)

func main() {
    db, err := sql.Open("postgres",
        "postgres://user:pass@localhost/dbname?sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Query
    rows, err := db.Query("SELECT id, name FROM users WHERE age > $1", 18)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    for rows.Next() {
        var id int
        var name string
        if err := rows.Scan(&id, &name); err != nil {
            log.Fatal(err)
        }
        fmt.Printf("ID: %d, Name: %s\n", id, name)
    }
}  // (6)!

// Context (cancellation, timeouts)
import "context"

func fetchWithTimeout(ctx context.Context, url string) error {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return err
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    return nil
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    if err := fetchWithTimeout(ctx, "https://example.com"); err != nil {
        log.Fatal(err)
    }
}  // (7)!

// Testing (built-in)
// math.go
func Add(a, b int) int {
    return a + b
}

// math_test.go
import "testing"

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

// Table-driven tests (idiomatic)
func TestAddTable(t *testing.T) {
    tests := []struct {
        name string
        a, b int
        want int
    }{
        {"positive", 2, 3, 5},
        {"negative", -1, 1, 0},
        {"zero", 0, 0, 0},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Add(tt.a, tt.b)
            if got != tt.want {
                t.Errorf("got %d, want %d", got, tt.want)
            }
        })
    }
}  // (8)!

// JSON handling
type Config struct {
    Host string `json:"host"`
    Port int    `json:"port"`
}

// Marshal (struct to JSON)
config := Config{Host: "localhost", Port: 8080}
jsonData, err := json.Marshal(config)
// {"host":"localhost","port":8080}

// Unmarshal (JSON to struct)
var c Config
err = json.Unmarshal(jsonData, &c)