1
2
3
4
5
6
7
8
package main

import "fmt"

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

1
2
3
4
5
6
7
8
package main           // Package declaration
import "fmt"           // Import statements

// Main function - entry point of the program
func main() {
    // Program logic
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Integers
var integer int     // Platform-dependent integer
var int8 int8       // 8-bit signed integer
var int16 int16     // 16-bit signed integer
var int32 int32     // 32-bit signed integer
var int64 int64     // 64-bit signed integer

// Unsigned Integers
var uint uint       // Unsigned platform-dependent integer
var byte uint8      // Alias for uint8
var uint16 uint16   // 16-bit unsigned integer

// Floating Point
var float32 float32 // 32-bit floating point
var float64 float64 // 64-bit floating point

// Boolean
var boolean bool    // true or false

// String
var text string     // Immutable string type

// Character (rune)
var char rune       // Unicode code point

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Arrays (Fixed Size)
var arr [5]int = [5]int{1, 2, 3, 4, 5}

// Slices (Dynamic Arrays)
slice := []int{1, 2, 3, 4, 5}
slice = append(slice, 6)

// Maps (Hash Tables/Dictionaries)
m := map[string]int{
    "apple": 1,
    "banana": 2,
}
m["orange"] = 3

// Struct
type Person struct {
    Name string
    Age  int
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Variable Declaration
var name string = "John"
age := 30           // Short declaration (type inferred)

// Multiple Variable Declaration
var x, y int = 10, 20

// Constants
const Pi = 3.14159
const (
    StatusOK = 200
    NotFound = 404
)

1
2
3
4
5
6
7
8
a := 10
b := 3
sum := a + b        // Addition
diff := a - b       // Subtraction
prod := a * b       // Multiplication
div := a / b        // Division
mod := a % b        // Modulus

1
2
3
4
5
6
7
a == b  // Equal
a != b  // Not Equal
a < b   // Less Than
a > b   // Greater Than
a <= b  // Less Than or Equal
a >= b  // Greater Than or Equal

1
2
3
4
true && false       // Logical AND
true || false       // Logical OR
!true               // Logical NOT

1
2
3
4
5
6
7
8
9
10
11
12
13
if x > 0 {
    fmt.Println("Positive")
} else if x < 0 {
    fmt.Println("Negative")
} else {
    fmt.Println("Zero")
}

// Compact if statement with initialization
if y := someFunction(); y > 10 {
    // Use y here
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Traditional for loop
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// While-like loop
for x < 10 {
    x++
}

// Infinite loop
for {
    // Do something
    break  // Exit condition
}

// Range-based iteration
numbers := []int{1, 2, 3, 4, 5}
for index, value := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Basic Function
func add(a, b int) int {
    return a + b
}

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

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

// Function as a Variable
var operation func(int, int) int
operation = add

1
2
3
4
5
6
var x int = 10
var ptr *int = &x   // Pointer to x

*ptr = 20           // Dereferencing and modifying value
fmt.Println(x)      // Prints 20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type Rectangle struct {
    width, height float64
}

// Method on struct
func (r Rectangle) area() float64 {
    return r.width * r.height
}

// Struct with Constructor-like Function
func newRectangle(w, h float64) Rectangle {
    return Rectangle{width: w, height: h}
}

1
2
3
4
5
6
7
8
9
type Shape interface {
    area() float64
}

// Implementing Interface
func (r Rectangle) area() float64 {
    return r.width * r.height
}

1
2
3
4
5
6
7
8
9
10
11
12
func divideNumbers(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

result, err := divideNumbers(10, 0)
if err != nil {
    fmt.Println("Error:", err)
}

1
2
3
4
5
6
func sayHello() {
    fmt.Println("Hello")
}

go sayHello()  // Runs concurrently

1
2
3
4
5
6
ch := make(chan int)  // Unbuffered channel
go func() {
    ch <- 42           // Send value to channel
}()
value := <-ch          // Receive value from channel

1
2
3
4
5
6
7
8
var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    // Concurrent work
}()
wg.Wait()  // Wait for goroutine to complete

1
2
3
4
5
6
7
8
9
10
11
12
// Reading File
data, err := os.ReadFile("example.txt")
if err != nil {
    log.Fatal(err)
}

// Writing File
err = os.WriteFile("output.txt", []byte("Hello"), 0644)
if err != nil {
    log.Fatal(err)
}

1
2
3
4
5
6
7
8
9
# Initialize a new module
go mod init myproject

# Add a dependency
go get github.com/some/package

# Update dependencies
go mod tidy

1
2
3
4
5
6
7
8
// example_test.go
func TestAdd(t *testing.T) {
    result := add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}