Beginner

go version

package main

import "fmt"

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

go run hello.go

package main

import "fmt"

func main() {
	// Explicit type declaration
	var name string = "Alice"
	var age int = 30

	// Type inference
	var city = "Jakarta"

	// Short declaration (inside functions only)
	country := "Indonesia"

	// Multiple declarations
	var (
		x int = 10
		y int = 20
		z     = 30  // type inferred
	)

	// Constants
	const Pi = 3.14159
	const MaxRetries = 3

	fmt.Println(name, age, city, country, x, y, z, Pi, MaxRetries)
	// Output: Alice 30 Jakarta Indonesia 10 20 30 3.14159 3
}

package main

import "fmt"

func main() {
	// Integers
	var i int = 42           // Platform dependent (32 or 64 bit)
	var i8 int8 = 127        // -128 to 127
	var i16 int16 = 32767    // -32768 to 32767
	var i32 int32 = 2147483647
	var i64 int64 = 9223372036854775807

	var u uint = 42          // Unsigned, platform dependent
	var u8 uint8 = 255       // 0 to 255 (also called byte)
	var u16 uint16 = 65535
	var u32 uint32 = 4294967295
	var u64 uint64 = 18446744073709551615

	// Floating point
	var f32 float32 = 3.14
	var f64 float64 = 3.14159265359

	// Boolean
	var isActive bool = true

	// String
	var message string = "Hello, Go!"

	// Rune (Unicode code point, alias for int32)
	var r rune = '€'

	// Demonstrate types
	fmt.Printf("int: %d, int8: %d, int16: %d\n", i, i8, i16)
	// Output: int: 42, int8: 127, int16: 32767

	fmt.Printf("float32: %.2f, float64: %.10f\n", f32, f64)
	// Output: float32: 3.14, float64: 3.1415926536

	fmt.Printf("bool: %t, string: %s, rune: %c\n", isActive, message, r)
	// Output: bool: true, string: Hello, Go!, rune: €
}

package main

import "fmt"

func main() {
	var i int       // 0
	var f float64   // 0.0
	var b bool      // false
	var s string    // "" (empty string)
	var p *int      // nil

	fmt.Printf("int: %d, float64: %.1f, bool: %t\n", i, f, b)
	// Output: int: 0, float64: 0.0, bool: false

	fmt.Printf("string: '%s', pointer: %v\n", s, p)
	// Output: string: '', pointer: <nil>
}

package main

import "fmt"

func main() {
	age := 18

	// Basic if
	if age >= 18 {
		fmt.Println("Adult") // Output: Adult
	}

	// If with else
	if age >= 18 {
		fmt.Println("Adult") // Output: Adult
	} else {
		fmt.Println("Minor")
	}

	// If with initialization statement
	if score := 85; score >= 90 {
		fmt.Println("Grade: A")
	} else if score >= 80 {
		fmt.Println("Grade: B") // Output: Grade: B
	} else {
		fmt.Println("Grade: C")
	}
	// Note: 'score' is only in scope within the if/else block
}

package main

import (
	"fmt"
	"time"
)

func main() {
	// Basic switch
	day := "Monday"
	switch day {
	case "Monday":
		fmt.Println("Start of work week") // Output: Start of work week
	case "Friday":
		fmt.Println("TGIF!")
	case "Saturday", "Sunday":
		fmt.Println("Weekend!")
	default:
		fmt.Println("Midweek")
	}

	// Switch with no condition (like if-else chain)
	hour := time.Now().Hour()
	switch {
	case hour < 12:
		fmt.Println("Good morning") // Output depends on current time
	case hour < 17:
		fmt.Println("Good afternoon")
	default:
		fmt.Println("Good evening")
	}

	// Type switch
	var i interface{} = "hello"
	switch v := i.(type) {
	case int:
		fmt.Printf("Integer: %d\n", v)
	case string:
		fmt.Printf("String: %s\n", v) // Output: String: hello
	default:
		fmt.Printf("Unknown type: %T\n", v)
	}
}

package main

import "fmt"

func main() {
	// Traditional for loop
	for i := 0; i < 5; i++ {
		fmt.Println(i) // Output: 0, 1, 2, 3, 4 (on separate lines)
	}

	// While-style loop
	count := 0
	for count < 3 {
		fmt.Println("Count:", count) // Output: Count: 0, Count: 1, Count: 2
		count++
	}

	// Infinite loop
	// for {
	//     fmt.Println("Forever")
	//     // Use break to exit
	// }

	// Range over slice
	numbers := []int{10, 20, 30, 40}
	for index, value := range numbers {
		fmt.Printf("Index: %d, Value: %d\n", index, value)
		// Output: Index: 0, Value: 10
		//         Index: 1, Value: 20
		//         Index: 2, Value: 30
		//         Index: 3, Value: 40
	}

	// Ignore index with _
	for _, value := range numbers {
		fmt.Println(value) // Output: 10, 20, 30, 40 (on separate lines)
	}

	// Range over map
	scores := map[string]int{"Alice": 90, "Bob": 85}
	for name, score := range scores {
		fmt.Printf("%s scored %d\n", name, score)
		// Output: Alice scored 90
		//         Bob scored 85
		// Note: map iteration order is not guaranteed
	}

	// Range over string (iterates over runes)
	for index, char := range "Hello" {
		fmt.Printf("%d: %c\n", index, char)
		// Output: 0: H
		//         1: e
		//         2: l
		//         3: l
		//         4: o
	}
}

package main

import "fmt"

func main() {
	// Declare array
	var arr [5]int
	arr[0] = 10
	arr[1] = 20

	// Array literal
	primes := [5]int{2, 3, 5, 7, 11}

	// Let compiler count length
	days := [...]string{"Mon", "Tue", "Wed", "Thu", "Fri"}

	fmt.Println(arr)    // [10 20 0 0 0]
	fmt.Println(primes) // [2 3 5 7 11]
	fmt.Println(days)   // [Mon Tue Wed Thu Fri]
	fmt.Println(len(days)) // 5
}

package main

import "fmt"

func main() {
	// Create slice from array
	arr := [5]int{1, 2, 3, 4, 5}
	slice := arr[1:4] // [2 3 4] - from index 1 to 3

	// Slice literals
	numbers := []int{10, 20, 30, 40}

	// Make slice with make()
	s := make([]int, 5)      // length 5, capacity 5
	s2 := make([]int, 3, 10) // length 3, capacity 10

	// Append to slice
	numbers = append(numbers, 50)
	numbers = append(numbers, 60, 70, 80)

	// Copy slice
	dest := make([]int, len(numbers))
	copy(dest, numbers)

	// Slicing operations
	fmt.Println(numbers[:3])  // Output: [10 20 30] - First 3 elements
	fmt.Println(numbers[2:])  // Output: [30 40 50 60 70 80] - From index 2 to end
	fmt.Println(numbers[1:4]) // Output: [20 30 40] - From index 1 to 3

	fmt.Println("Length:", len(numbers))     // Output: Length: 7
	fmt.Println("Capacity:", cap(numbers))   // Output: Capacity: 8 (or higher, depends on growth)
}

package main

import "fmt"

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

	// Map literal
	scores := map[string]int{
		"Alice": 90,
		"Bob":   85,
		"Carol": 95,
	}

	// Access value
	fmt.Println(scores["Alice"]) // 90

	// Check if key exists
	score, exists := scores["David"]
	if exists {
		fmt.Println("David's score:", score)
	} else {
		fmt.Println("David not found") // Output: David not found
	}

	// Delete key
	delete(scores, "Bob")

	// Iterate over map
	for name, score := range scores {
		fmt.Printf("%s: %d\n", name, score)
		// Output: Alice: 90
		//         Carol: 95
		// Note: map iteration order is not guaranteed
	}
}

package main

import "fmt"

// Define struct
type Person struct {
	Name string
	Age  int
	City string
}

// Struct with tags (for JSON, etc.)
type User struct {
	ID       int    `json:"id"`
	Username string `json:"username"`
	Email    string `json:"email"`
}

func main() {
	// Create struct instance
	p1 := Person{
		Name: "Alice",
		Age:  30,
		City: "Jakarta",
	}

	// Positional initialization (not recommended)
	p2 := Person{"Bob", 25, "Bandung"}

	// Partial initialization
	p3 := Person{Name: "Carol"}

	// Access fields
	fmt.Println(p1.Name) // Alice

	// Modify fields
	p1.Age = 31

	// Pointer to struct
	p4 := &Person{Name: "David", Age: 35}
	p4.City = "Surabaya" // Automatic dereferencing

	// Anonymous struct
	config := struct {
		Host string
		Port int
	}{
		Host: "localhost",
		Port: 8080,
	}

	fmt.Println(p1, p2, p3, p4, config)
	// Output: {Alice 31 Jakarta} {Bob 25 Bandung} {Carol 0 } &{David 35 Surabaya} {localhost 8080}
}

package main

import "fmt"

// Simple function
func greet(name string) {
	fmt.Println("Hello,", name)
}

// Function with return value
func add(a int, b int) int {
	return a + b
}

// Shortened parameter syntax (same type)
func multiply(a, b int) int {
	return a * b
}

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

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

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

func main() {
	greet("Alice") // Output: Hello, Alice

	result := add(10, 20)
	fmt.Println("Add:", result) // Output: Add: 30

	quotient, err := divide(10, 2)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Quotient:", quotient) // Output: Quotient: 5
	}

	x, y := split(17)
	fmt.Println("Split:", x, y) // Output: Split: 7 10

	total := sum(1, 2, 3, 4, 5)
	fmt.Println("Sum:", total) // Output: Sum: 15
}

package main

import "fmt"

func main() {
	// Defer executes in LIFO order
	defer fmt.Println("World")
	defer fmt.Println("Beautiful")
	defer fmt.Println("Hello")

	fmt.Println("Start")
	// Output:
	// Start
	// Hello
	// Beautiful
	// World
}

// Common use: cleanup resources
import "os"

func readFile(filename string) error {
	file, err := os.Open(filename)
	if err != nil {
		return err
	}
	defer file.Close() // Ensures file is closed when function returns

	// Read file operations...
	return nil
}

package main

import "fmt"

func main() {
	// Anonymous function
	func() {
		fmt.Println("Anonymous function") // Output: Anonymous function
	}()

	// Assign to variable
	add := func(a, b int) int {
		return a + b
	}
	fmt.Println(add(5, 3)) // Output: 8

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

	fmt.Println(counter()) // 1
	fmt.Println(counter()) // 2
	fmt.Println(counter()) // 3
}

package main

import (
	"fmt"
	"math"
)

type Rectangle struct {
	Width  float64
	Height float64
}

type Circle struct {
	Radius float64
}

// Method with value receiver
func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

// Method with pointer receiver (can modify struct)
func (r *Rectangle) Scale(factor float64) {
	r.Width *= factor
	r.Height *= factor
}

// Method on Circle
func (c Circle) Area() float64 {
	return math.Pi * c.Radius * c.Radius
}

func main() {
	rect := Rectangle{Width: 10, Height: 5}
	fmt.Println("Area:", rect.Area()) // 50

	rect.Scale(2)
	fmt.Println("Scaled area:", rect.Area()) // 200

	circle := Circle{Radius: 5}
	fmt.Println("Circle area:", circle.Area()) // Output: Circle area: 78.53981633974483
}

package main

import (
	"fmt"
	"math"
)

// Interface definition
type Shape interface {
	Area() float64
	Perimeter() float64
}

type Rectangle struct {
	Width, Height float64
}

type Circle struct {
	Radius float64
}

// Rectangle implements Shape interface
func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
	return 2 * (r.Width + r.Height)
}

// Circle implements Shape interface
func (c Circle) Area() float64 {
	return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
	return 2 * math.Pi * c.Radius
}

// Function that accepts any Shape
func printShapeInfo(s Shape) {
	fmt.Printf("Area: %.2f, Perimeter: %.2f\n", s.Area(), s.Perimeter())
}

func main() {
	rect := Rectangle{Width: 10, Height: 5}
	circle := Circle{Radius: 5}

	printShapeInfo(rect)   // Output: Area: 50.00, Perimeter: 30.00
	printShapeInfo(circle) // Output: Area: 78.54, Perimeter: 31.42

	// Empty interface (interface{}) accepts any type
	var anything interface{}
	anything = 42
	anything = "hello"
	anything = rect

	// 'any' is an alias for interface{} (Go 1.18+)
	var something any
	something = []int{1, 2, 3}
	something = map[string]int{"key": 42}

	fmt.Println(anything, something) // Output: {10 5} map[key:42]
}

package main

import "fmt"

func describe(i interface{}) {
	// Type assertion
	if s, ok := i.(string); ok {
		fmt.Printf("String of length %d: %s\n", len(s), s)
		return
	}

	// Type switch
	switch v := i.(type) {
	case int:
		fmt.Printf("Integer: %d\n", v)
	case float64:
		fmt.Printf("Float: %.2f\n", v)
	case bool:
		fmt.Printf("Boolean: %t\n", v)
	default:
		fmt.Printf("Unknown type: %T\n", v)
	}
}

func main() {
	describe(42)
	// Output: Integer: 42

	describe(3.14)
	// Output: Float: 3.14

	describe("hello")
	// Output: String of length 5: hello

	describe(true)
	// Output: Boolean: true
}

package main

import "fmt"

func main() {
	// Declare variable
	x := 42

	// & creates pointer to variable
	p := &x

	fmt.Println("Value of x:", x)   // 42
	fmt.Println("Address of x:", p) // 0xc0000...
	fmt.Println("Value at p:", *p)  // 42 (dereferencing)

	// Modify value through pointer
	*p = 100
	fmt.Println("New value of x:", x) // 100

	// Pass by value vs pointer
	changeValue(x)
	fmt.Println("After changeValue:", x) // 100 (unchanged)

	changePointer(&x)
	fmt.Println("After changePointer:", x) // 200 (changed)
}

func changeValue(val int) {
	val = 500
}

func changePointer(ptr *int) {
	*ptr = 200
}

package main

import (
	"errors"
	"fmt"
)

// Return error
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("division by zero")
	}
	return a / b, nil
}

// Custom error with formatting
func validateAge(age int) error {
	if age < 0 {
		return fmt.Errorf("invalid age: %d (must be non-negative)", age)
	}
	if age < 18 {
		return fmt.Errorf("age %d is below minimum (18)", age)
	}
	return nil
}

// Custom error type
type ValidationError struct {
	Field   string
	Message string
}

func (e *ValidationError) Error() string {
	return fmt.Sprintf("validation error on %s: %s", e.Field, e.Message)
}

func validateUser(username string) error {
	if len(username) < 3 {
		return &ValidationError{
			Field:   "username",
			Message: "must be at least 3 characters",
		}
	}
	return nil
}

func main() {
	// Handle errors with if
	result, err := divide(10, 0)
	if err != nil {
		fmt.Println("Error:", err)
		// Output: Error: division by zero
	} else {
		fmt.Println("Result:", result)
	}

	// Check and use error
	if err := validateAge(15); err != nil {
		fmt.Println(err)
		// Output: age 15 is below minimum (18)
	}

	// Type assertion on custom error
	if err := validateUser("ab"); err != nil {
		if ve, ok := err.(*ValidationError); ok {
			fmt.Printf("Field: %s, Message: %s\n", ve.Field, ve.Message)
			// Output: Field: username, Message: must be at least 3 characters
		}
	}

	// Panic and recover (use sparingly!)
	safeDivide(10, 0)
	// Output: Recovered from panic: division by zero!
}

func safeDivide(a, b int) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered from panic:", r)
		}
	}()

	if b == 0 {
		panic("division by zero!")
	}
	fmt.Println(a / b)
}

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 3; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	// Run in goroutine
	go say("world")

	// Run in main goroutine
	say("hello")
	// Output (interleaved, non-deterministic):
	// hello
	// world
	// hello
	// world
	// hello
	// world

	// Without sleep/wait, main might exit before goroutines finish
	time.Sleep(1 * time.Second)
}

package main

import "fmt"

func main() {
	// Create channel
	ch := make(chan int)

	// Send and receive in different goroutines
	go func() {
		ch <- 42 // Send to channel
	}()

	value := <-ch // Receive from channel
	fmt.Println(value) // Output: 42

	// Buffered channel
	buffered := make(chan string, 2)
	buffered <- "hello"
	buffered <- "world"
	// No blocking until buffer is full

	fmt.Println(<-buffered) // Output: hello
	fmt.Println(<-buffered) // Output: world
}

package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan string)
	ch2 := make(chan string)

	go func() {
		time.Sleep(1 * time.Second)
		ch1 <- "one"
	}()

	go func() {
		time.Sleep(2 * time.Second)
		ch2 <- "two"
	}()

	// Wait for both channels
	for i := 0; i < 2; i++ {
		select {
		case msg1 := <-ch1:
			fmt.Println("Received from ch1:", msg1)
			// Output (first iteration, after 1 second): Received from ch1: one
		case msg2 := <-ch2:
			fmt.Println("Received from ch2:", msg2)
			// Output (second iteration, after 2 seconds): Received from ch2: two
		case <-time.After(3 * time.Second):
			fmt.Println("Timeout!")
		}
	}
	// Complete output:
	// Received from ch1: one
	// Received from ch2: two
}

package main

import "fmt"

// Generic function with type parameter
func Print[T any](value T) {
	fmt.Println(value)
}

// Generic function with type constraint
func Min[T int | float64](a, b T) T {
	if a < b {
		return a
	}
	return b
}

// Generic function with comparable constraint
func Contains[T comparable](slice []T, value T) bool {
	for _, item := range slice {
		if item == value {
			return true
		}
	}
	return false
}

func main() {
	// Type inference
	Print(42)      // Output: 42
	Print("hello") // Output: hello
	Print(3.14)    // Output: 3.14

	// Explicit type arguments
	Print[int](100) // Output: 100

	// Generic Min function
	fmt.Println(Min(10, 20))       // int
	fmt.Println(Min(3.14, 2.71))   // float64

	// Generic Contains function
	numbers := []int{1, 2, 3, 4, 5}
	fmt.Println(Contains(numbers, 3))  // true
	fmt.Println(Contains(numbers, 10)) // false

	words := []string{"go", "rust", "python"}
	fmt.Println(Contains(words, "go")) // true
}