Go Reference - Quick Code Examples

Basics

Hello World

Basic Go program structure

package main

import "fmt"

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

Variables & Constants

Variable and constant declaration

// Variable declaration
var name string = "John"
age := 25 // Short declaration

// Constants
const Pi = 3.14159
const MaxRetries = 5

Type Conversion

Type conversion in Go

// Convert between types
var x int = 42
var f float64 = float64(x)
var i int = int(f)

// String conversion
str := strconv.Itoa(42)
num, err := strconv.Atoi("42")

Data Structures

Arrays & Slices

Working with arrays and slices

// Array (fixed size)
var arr [5]int = [5]int{1, 2, 3, 4, 5}

// Slice (dynamic size)
slice := []int{1, 2, 3}
slice = append(slice, 4, 5)

// Slice operations
subSlice := slice[1:3]  // [2, 3]
length := len(slice)
capacity := cap(slice)

Maps

Map operations and usage

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

// Map literal
scores := map[string]int{
    "math":    95,
    "english": 88,
}

// Check if key exists
age, exists := ages["Alice"]
delete(ages, "Bob")

Structs

Struct definition and usage

type Person struct {
    Name string
    Age  int
}

// Create instance
p1 := Person{Name: "Alice", Age: 30}
p2 := Person{"Bob", 25}

// Access fields
fmt.Println(p1.Name)
p1.Age = 31

Functions

Function Declaration

Function declaration patterns

// Basic function
func add(a, b int) int {
    return a + b
}

// Multiple returns
func swap(a, b string) (string, string) {
    return b, a
}

// Named returns
func divide(a, b float64) (result float64, err error) {
    if b == 0 {
        err = errors.New("division by zero")
        return
    }
    result = a / b
    return
}

Variadic Functions

Functions with variable arguments

func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

// Usage
result := sum(1, 2, 3, 4, 5)

Closures

Closures and higher-order functions

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

// Usage
next := counter()
fmt.Println(next()) // 1
fmt.Println(next()) // 2

Control Flow

If/Else

Conditional statements

// Basic if
if x > 10 {
    fmt.Println("Greater")
}

// If with initialization
if val := getValue(); val > 0 {
    fmt.Println("Positive:", val)
} else {
    fmt.Println("Non-positive")
}

For Loops

Different for loop patterns

// Traditional for loop
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// While-style loop
for x < 100 {
    x *= 2
}

// Infinite loop
for {
    // ...
    break
}

// Range loop
for i, val := range slice {
    fmt.Printf("Index: %d, Value: %d\n", i, val)
}

Switch

Switch statement patterns

// Basic switch
switch day {
case "Monday":
    fmt.Println("Start of week")
case "Friday":
    fmt.Println("Almost weekend")
default:
    fmt.Println("Midweek")
}

// Switch without expression
switch {
case score >= 90:
    grade = "A"
case score >= 80:
    grade = "B"
default:
    grade = "C"
}

Concurrency

Goroutines

Concurrent execution with goroutines

// Launch goroutine
go func() {
    fmt.Println("Running in goroutine")
}()

// With parameters
go processData(data)

// Wait for completion
var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    // Do work
}()
wg.Wait()

Channels

Channel communication

// Create channel
ch := make(chan int)

// Send and receive
go func() {
    ch <- 42  // Send
}()
value := <-ch // Receive

// Buffered channel
ch := make(chan int, 10)

// Close channel
close(ch)

// Range over channel
for val := range ch {
    fmt.Println(val)
}