golang

Go basics covering variables, control flow, collections, functions, structs, error handling, and concurrency.

Basic Types & Variables

Core variable and constant declarations.

Declaring variables with type inference.

name := "Alice"

Declaring immutable constant values.

const Pi = 3.14

Controlling the execution of code.

Conditional execution.

if x > 0 {
    fmt.Println("Positive")
}

Iterating over sequences or conditions.

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

Multi-way conditional branching.

switch os {
case "linux":
    fmt.Println("Linux")
default:
    fmt.Println("Other")
}

Organizing multiple values in slices and maps.

Creating dynamic arrays.

numbers := []int{1, 2, 3}

Creating key-value lookup tables.

m := map[string]int{"a": 1}

Reusable blocks of code and multi-value returns.

Creating a function with return types.

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

Returning multiple values from a function.

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

Defining custom composite types and receivers.

Defining custom data structures.

type Person struct {
    Name string
    Age  int
}

Defining functions attached to a struct receiver.

func (p Person) Greet() {
    fmt.Println(p.Name)
}

Managing runtime errors explicitly.

Handling standard error returns.

result, err := doSomething()
if err != nil {
    log.Fatal(err)
}

Running lightweight concurrent threads and channels.

Spawning concurrent background tasks.

go processData()

Passing data safely between goroutines.

ch := make(chan string)
ch <- "message"
msg := <-ch