Go Reference

package main

import "fmt"

func main() {
    // fmt.Println prints to STDOUT with a newline
    fmt.Println("Hello, World!")
}

# Compile to a binary using go build
go build main.go

# Run the generated binary
./main

# Compile and run in one step using go run
go run main.go

// Single-line comment for brief notes

/* Multi-line
   comment block for detailed explanations */

import (
    "fmt"
    "os"
    "net/http"
    m "math" // Aliasing a module for shorter access
)

import "os"

func main() {
    // Exit immediate with status code (non-zero indicates error)
    os.Exit(1) 
}

import (
    "errors"
    "fmt"
)

// Function returning an integer and an error
func doWork() (int, error) {
    return 0, errors.New("something went wrong")
}

func main() {
    val, err := doWork()
    // Explicitly check if error is not nil
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(val)
}

var a int = 1 // Explicit variable declaration with type
b := 2        // Short-hand declaration with type inference (only inside functions)
const C = 3   // Immutable constant value

i := 42
f := float64(i) // Convert int to float64
u := uint(f)    // Convert float64 to uint

import "os"

// Retrieve an environment variable
val := os.Getenv("PATH")
// Set an environment variable for the current process
os.Setenv("KEY", "VALUE")

import (
    "fmt"
    "time"
)

func main() {
    // High-resolution measurement
    start := time.Now()
    elapsed := time.Since(start)

    // Formatting using reference date: Mon Jan 2 15:04:05 MST 2006
    now := time.Now()
    fmt.Println(now.Format(time.RFC3339))
    fmt.Println(now.Format("2006-01-02 15:04:05"))
}

sum := 10 + 3 // Addition (13)
div := 10 / 3 // Integer division (3)
fDiv := 10.0 / 3.0 // Floating point division (3.33)
res := true && false // Logical AND (false)

import (
    "fmt"
    "regexp"
)

func main() {
    // Compile regex pattern
    re := regexp.MustCompile(`\$(\d+)`)
    // Find submatches in input string
    match := re.FindStringSubmatch("Price: $100")
    if len(match) > 1 {
        fmt.Println(match[1]) // Print first captured group: "100"
    }
}

import (
    "flag"
    "fmt"
)

func main() {
    // Define command-line flags
    verb := flag.Bool("v", false, "verbose mode")
    name := flag.String("name", "user", "target username")

    // Parse defined flags from os.Args[1:]
    flag.Parse()
    
    // Retrieve remaining positional arguments
    args := flag.Args()
    fmt.Printf("Verbose: %v, Name: %s\n", *verb, *name)
}

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

// Multi-return function
func swap(a, b int) (int, int) { return b, a }

// Named returns for clearer documentation
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // Returns current values of x and y
}

// Function accepting a pointer (*) to an integer
func increment(n *int) {
    *n++ // Dereference pointer to modify original value
}

func main() {
    x := 10
    increment(&x) // Pass memory address (&) of x
}

x := 10
if x > 5 {
    fmt.Println("Greater")
} else if x == 5 {
    fmt.Println("Equal")
} else {
    fmt.Println("Less")
}

val := 2
switch val {
case 1:
    fmt.Println("One")
case 2, 3:
    fmt.Println("Two or Three")
default:
    fmt.Println("Other")
}

// Standard C-style for loop
for i := 0; i < 3; i++ {
    fmt.Printf("for: %d\n", i)
}

x := 0
// While-style loop (condition only)
for x < 3 {
    fmt.Printf("while: %d\n", x)
    x++
}

for i := 0; i < 10; i++ {
    if i < 2 { continue } // Skip iteration
    if i == 5 { break }    // Exit loop
    fmt.Println(i)
}

// Slices iteration using range
for index, val := range []int{10, 20} {
    fmt.Printf("%d: %d\n", index, val)
}

// Maps iteration using range
m := map[string]int{"a": 1}
for key, val := range m {
    fmt.Printf("%s: %d\n", key, val)
}

import (
    "fmt"
    "strings"
)

func main() {
    s := " Hello "
    s = strings.TrimSpace(s) // "Hello"
    sub := s[0:2] // Slice substring "He"
    joined := strings.Join([]string{"a", "b"}, "-") // "a-b"
}

import (
    "fmt"
    "path/filepath"
)

func main() {
    // OS-agnostic path building
    p := filepath.Join("/", "usr", "bin")
    fmt.Println(p)
}

import (
    "os"
    "io"
)

func main() {
    f, _ := os.Open("file.bin")
    defer f.Close() // Ensure file is closed on exit
    buf := make([]byte, 4096) // 4KB buffer
    for {
        n, err := f.Read(buf)
        if err == io.EOF { break } // End of file
        // Process buf[:n]
    }
}

import "os"

func main() {
    // Read entire file content into a byte slice
    bytes, _ := os.ReadFile("file.txt")
}

import "encoding/binary"

func main() {
    buf := make([]byte, 4)
    // Pack 32-bit unsigned integer into buffer using Big-Endian
    binary.BigEndian.PutUint32(buf, 42)
}

res := 0b1010 & 0b1100 // Bitwise AND
res = 0b1010 | 0b1100  // Bitwise OR
res = 0b1010 ^ 0b1100  // Bitwise XOR
res = ^0b1010          // Bitwise NOT (complement)
res = 0b0001 << 2      // Bitwise Shift Left (0b0100)

import (
    "fmt"
    "strconv"
)

func main() {
    // Format integer as hex string
    s := fmt.Sprintf("%x", 255) // "ff"
    // Parse hex string back to integer (64-bit)
    val, _ := strconv.ParseInt("ff", 16, 64) // 255
}

// Slice (Dynamic List)
l := []int{1, 2}; l = append(l, 3) 
// Map (Key-Value pairs)
m := make(map[string]int); m["k"] = 1 
// Set behavior implemented using map with empty struct
s := make(map[int]struct{}); s[1] = struct{}{} 

import (
    "encoding/json"
    "fmt"
)

func main() {
    type User struct { ID int `json:"id"` }
    var u User
    // Unmarshal JSON byte slice into struct
    json.Unmarshal([]byte(`{"id":42}`), &u)
    fmt.Println(u.ID)
}

import (
    "fmt"
    "net"
)

func main() {
    // Listen for incoming TCP connections
    l, _ := net.Listen("tcp", ":8080")
    
    // Connect to a remote TCP server
    conn, _ := net.Dial("tcp", "example.com:80")
    // Write data to the connection
    fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
}

import "net"

func main() {
    // Connect via UDP
    conn, _ := net.Dial("udp", "127.0.0.1:8080")
    // Send datagram payload
    conn.Write([]byte("ping"))
}

import (
    "fmt"
    "time"
)

func main() {
    // Start a concurrent goroutine
    go func() {
        fmt.Println("Concurrent goroutine")
    }()
    time.Sleep(10 * time.Millisecond) // Give time for goroutine to execute
}

import (
    "fmt"
    "os/exec"
)

func main() {
    // Execute sqlite3 CLI command and capture output
    out, _ := exec.Command("sqlite3", ":memory:", "SELECT 42;").Output()
    fmt.Printf("%s", out)
}