Go (Golang) Tutorial

# Create a project folder and a module
mkdir hello && cd hello
go mod init example.com/hello

# After creating main.go (below), run it or build a binary
go run .
go build -o hello . && ./hello

package main

import (
	"fmt"
	"time"
)

func main() {
	name := "Gopher"
	fmt.Printf("Hello, %s! Today is %s.\n", name, time.Now().Format("Monday"))
}

# Add a third-party dependency (recorded in go.mod and go.sum)
go get github.com/google/uuid@latest

# Remove unused dependencies and add missing ones
go mod tidy

package main

import "fmt"

type Weekday int

const (
	Sunday Weekday = iota // iota counts up: 0, 1, 2, ...
	Monday
	Tuesday
)

const Pi = 3.14159

func main() {
	var city string = "Bengaluru" // explicit type
	var population = 13_600_000   // type inferred as int
	rating := 4.7                 // short declaration inside functions
	var active bool               // zero value: false

	var count int     // zero value: 0
	var label string  // zero value: ""

	fmt.Println(city, population, rating, active, count, label == "")
	fmt.Println(Monday, Tuesday, Pi)

	// Conversions are always explicit
	items := 7
	avg := float64(items) / 2
	fmt.Printf("avg=%.1f type=%T\n", avg, avg)

	// Strings are immutable UTF-8 byte sequences; runes are Unicode code points
	word := "naïve"
	fmt.Println(len(word), len([]rune(word))) // 6 bytes, 5 runes
}

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Classic three-part loop
	for i := 1; i <= 3; i++ {
		fmt.Print(i, " ")
	}
	fmt.Println()

	// "while" loop
	n := 10
	for n > 1 {
		n /= 2
	}

	// range over an integer (Go 1.22+), a slice and a map
	for i := range 3 {
		fmt.Print(i, " ")
	}
	for idx, fruit := range []string{"apple", "mango"} {
		fmt.Println(idx, fruit)
	}

	// if with a short statement: the variable exists only inside the if/else
	if v, err := strconv.Atoi("42"); err == nil {
		fmt.Println("parsed", v)
	} else {
		fmt.Println("error:", err)
	}

	// switch: no fall-through by default, cases can list several values
	switch day := "sat"; day {
	case "sat", "sun":
		fmt.Println("Weekend")
	default:
		fmt.Println("Weekday")
	}

	// switch with no condition is a clean if/else chain
	score := 82
	switch {
	case score >= 90:
		fmt.Println("A")
	case score >= 75:
		fmt.Println("B")
	default:
		fmt.Println("C")
	}
}

package main

import (
	"errors"
	"fmt"
	"os"
)

var ErrInsufficientFunds = errors.New("insufficient funds") // a sentinel error

func withdraw(balance, amount float64) (float64, error) {
	if amount <= 0 {
		return balance, fmt.Errorf("invalid amount %.2f", amount)
	}
	if amount > balance {
		// %w wraps the sentinel so callers can detect it with errors.Is
		return balance, fmt.Errorf("withdraw %.2f: %w", amount, ErrInsufficientFunds)
	}
	return balance - amount, nil
}

func readConfig(path string) ([]byte, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, fmt.Errorf("open config: %w", err)
	}
	defer f.Close() // runs when readConfig returns, whatever path it takes

	buf := make([]byte, 512)
	n, err := f.Read(buf)
	if err != nil {
		return nil, fmt.Errorf("read config: %w", err)
	}
	return buf[:n], nil
}

func main() {
	balance, err := withdraw(100, 250)
	if errors.Is(err, ErrInsufficientFunds) {
		fmt.Println("Declined:", err)
	}
	fmt.Println("Balance:", balance)

	if _, err := readConfig("missing.yaml"); err != nil {
		fmt.Println(err) // open config: open missing.yaml: no such file or directory
	}

	// Functions are values; closures capture surrounding variables
	counter := func() func() int {
		c := 0
		return func() int { c++; return c }
	}()
	fmt.Println(counter(), counter(), counter()) // 1 2 3
}

package main

import (
	"fmt"
	"maps"
	"slices"
	"sort"
)

func main() {
	arr := [6]int{10, 20, 30, 40, 50, 60}
	s := arr[1:4]
	fmt.Println(s, len(s), cap(s)) // [20 30 40] 3 5

	s[0] = 99                       // shares memory with arr
	fmt.Println(arr[1])             // 99

	var tasks []string              // nil slice, ready to append to
	tasks = append(tasks, "write", "test", "deploy")
	fmt.Println(tasks, len(tasks))

	scores := make([]int, 0, 10)    // length 0, capacity 10: no reallocation for 10 appends
	scores = append(scores, 72, 95, 88)
	slices.Sort(scores)
	fmt.Println(scores, slices.Contains(scores, 95))

	copyOf := slices.Clone(scores)  // an independent copy
	copyOf[0] = 0
	fmt.Println(scores[0], copyOf[0])

	// Maps
	stock := map[string]int{"pen": 40, "eraser": 15}
	stock["notebook"] = 25
	delete(stock, "eraser")

	if qty, ok := stock["pencil"]; !ok { // "comma ok" tells missing from zero
		fmt.Println("no pencils, qty =", qty)
	}

	keys := slices.Collect(maps.Keys(stock))
	sort.Strings(keys)              // map iteration order is random; sort for stable output
	for _, k := range keys {
		fmt.Println(k, stock[k])
	}
}

package main

import (
	"encoding/json"
	"fmt"
	"time"
)

type Audit struct {
	CreatedAt time.Time `json:"created_at"`
}

func (a Audit) Age() time.Duration { return time.Since(a.CreatedAt) }

type Account struct {
	Audit                    // embedded: Account gets Audit's fields and methods
	Owner   string  `json:"owner"`
	Balance float64 `json:"balance"`
}

// Pointer receiver: the method can modify the account
func (a *Account) Deposit(amount float64) {
	a.Balance += amount
}

// Value receiver: works on a copy, fine for read-only methods
func (a Account) Summary() string {
	return fmt.Sprintf("%s has %.2f", a.Owner, a.Balance)
}

func NewAccount(owner string) *Account { // constructor function by convention
	return &Account{Audit: Audit{CreatedAt: time.Now()}, Owner: owner}
}

func main() {
	acc := NewAccount("Priya")
	acc.Deposit(1500)
	fmt.Println(acc.Summary())
	fmt.Println(acc.Age() < time.Second) // promoted method from Audit

	data, _ := json.Marshal(acc)          // struct tags control JSON field names
	fmt.Println(string(data))

	p := &acc.Balance                    // pointers: & takes an address, * dereferences
	*p += 100
	fmt.Println(acc.Balance)
}

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
	Name() string
}

type Circle struct{ R float64 }
type Rect struct{ W, H float64 }

func (c Circle) Area() float64 { return math.Pi * c.R * c.R }
func (c Circle) Name() string   { return "circle" }
func (r Rect) Area() float64    { return r.W * r.H }
func (r Rect) Name() string     { return "rectangle" }

// fmt.Stringer is a standard one-method interface
func (r Rect) String() string { return fmt.Sprintf("Rect(%gx%g)", r.W, r.H) }

func totalArea(shapes ...Shape) float64 {
	sum := 0.0
	for _, s := range shapes {
		sum += s.Area()
	}
	return sum
}

func main() {
	shapes := []Shape{Circle{1.5}, Rect{2, 3.5}}
	for _, s := range shapes {
		fmt.Printf("%-10s %.2f\n", s.Name(), s.Area())
	}
	fmt.Printf("total %.2f\n", totalArea(shapes...))

	// Type switch: act on the concrete type behind an interface value
	for _, s := range shapes {
		switch v := s.(type) {
		case Rect:
			fmt.Println("found", v) // uses String()
		case Circle:
			fmt.Println("circle with radius", v.R)
		}
	}
}

package main

import (
	"cmp"
	"fmt"
)

type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](values []T) T {
	var total T
	for _, v := range values {
		total += v
	}
	return total
}

func Map[T, U any](in []T, f func(T) U) []U {
	out := make([]U, 0, len(in))
	for _, v := range in {
		out = append(out, f(v))
	}
	return out
}

func MaxOf[T cmp.Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

// A generic type: a simple stack
type Stack[T any] struct{ items []T }

func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool) {
	var zero T
	if len(s.items) == 0 {
		return zero, false
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, true
}

func main() {
	fmt.Println(Sum([]int{1, 2, 3}), Sum([]float64{0.5, 1.25}))
	fmt.Println(Map([]int{1, 2, 3}, func(n int) string { return fmt.Sprint(n * n) }))
	fmt.Println(MaxOf("apple", "banana"), MaxOf(3, 7))

	var st Stack[string]
	st.Push("a")
	st.Push("b")
	top, _ := st.Pop()
	fmt.Println(top)
}

package main

import (
	"fmt"
	"sync"
	"time"
)

// A worker pool: 3 goroutines process jobs from one channel
func worker(id int, jobs <-chan int, results chan<- string, wg *sync.WaitGroup) {
	defer wg.Done()
	for n := range jobs { // loop ends when the jobs channel is closed
		time.Sleep(100 * time.Millisecond) // simulate work
		results <- fmt.Sprintf("worker %d: %d squared is %d", id, n, n*n)
	}
}

func main() {
	jobs := make(chan int, 10)
	results := make(chan string, 10)
	var wg sync.WaitGroup

	for id := 1; id <= 3; id++ {
		wg.Add(1)
		go worker(id, jobs, results, &wg)
	}

	for n := 1; n <= 6; n++ {
		jobs <- n
	}
	close(jobs) // no more jobs: workers exit their loops

	go func() {
		wg.Wait()      // wait for all workers ...
		close(results) // ... then close results so the loop below ends
	}()

	for r := range results {
		fmt.Println(r)
	}

	// select waits on several channel operations, here with a timeout
	slow := make(chan string)
	go func() { time.Sleep(2 * time.Second); slow <- "done" }()
	select {
	case msg := <-slow:
		fmt.Println(msg)
	case <-time.After(500 * time.Millisecond):
		fmt.Println("timed out")
	}
}

package main

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"time"
)

type Counter struct {
	mu   sync.Mutex
	hits map[string]int
}

func (c *Counter) Inc(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.hits[key]++
}

func fetchReport(ctx context.Context) (string, error) {
	select {
	case <-time.After(2 * time.Second): // pretend this is a slow database query
		return "report ready", nil
	case <-ctx.Done():
		return "", ctx.Err() // context.DeadlineExceeded or context.Canceled
	}
}

func main() {
	c := Counter{hits: map[string]int{}}
	var wg sync.WaitGroup
	for range 100 {
		wg.Add(1)
		go func() { defer wg.Done(); c.Inc("/home") }()
	}
	wg.Wait()
	fmt.Println("hits:", c.hits["/home"]) // always 100

	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()
	if _, err := fetchReport(ctx); errors.Is(err, context.DeadlineExceeded) {
		fmt.Println("gave up: report took too long")
	}
}

package main

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

type Book struct {
	ID     string `json:"id"`
	Title  string `json:"title"`
	Author string `json:"author"`
}

type Store struct {
	mu    sync.RWMutex
	books map[string]Book
}

func (s *Store) getBook(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id") // path parameter from the route pattern
	s.mu.RLock()
	book, ok := s.books[id]
	s.mu.RUnlock()
	if !ok {
		http.Error(w, "book not found", http.StatusNotFound)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(book)
}

func (s *Store) addBook(w http.ResponseWriter, r *http.Request) {
	var b Book
	if err := json.NewDecoder(r.Body).Decode(&b); err != nil || b.ID == "" {
		http.Error(w, "invalid book", http.StatusBadRequest)
		return
	}
	s.mu.Lock()
	s.books[b.ID] = b
	s.mu.Unlock()
	w.WriteHeader(http.StatusCreated)
}

func main() {
	store := &Store{books: map[string]Book{
		"1": {ID: "1", Title: "Learning Go", Author: "A. Gopher"},
	}}

	mux := http.NewServeMux()
	mux.HandleFunc("GET /books/{id}", store.getBook)
	mux.HandleFunc("POST /books", store.addBook)

	srv := &http.Server{
		Addr:         ":8080",
		Handler:      mux,
		ReadTimeout:  5 * time.Second, // always set timeouts in production
		WriteTimeout: 10 * time.Second,
	}
	log.Println("listening on http://localhost:8080")
	log.Fatal(srv.ListenAndServe())
}

package pricing

import "testing"

func ApplyDiscount(price, percent float64) float64 {
	if percent < 0 || percent > 100 {
		return price
	}
	return price * (1 - percent/100)
}

func TestApplyDiscount(t *testing.T) {
	tests := []struct {
		name           string
		price, percent float64
		want           float64
	}{
		{"ten percent", 100, 10, 90},
		{"no discount", 59.99, 0, 59.99},
		{"invalid percent", 80, 150, 80},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			if got := ApplyDiscount(tc.price, tc.percent); got != tc.want {
				t.Errorf("ApplyDiscount(%v, %v) = %v, want %v", tc.price, tc.percent, got, tc.want)
			}
		})
	}
}

func BenchmarkApplyDiscount(b *testing.B) {
	for b.Loop() { // Go 1.24+; older versions use: for i := 0; i < b.N; i++
		ApplyDiscount(100, 10)
	}
}