var a struct{}

func main() {
    var b struct{}

    fmt.Printf("&a: %p\n", &a)
    fmt.Printf("&b: %p\n", &b)

    fmt.Println("&a == &b:", &a == &b)
}

&a: 0x58e360
&b: 0x58e360
&a == &b: false

Две различные переменные нулевого размера могут иметь одинаковый адрес в памяти

package main

type S struct {
    N int
}

func (s *S) PointerRcv() {
}

func (s S) ValueRcv() {
}

func main() {
    var s *S // s равно nil
    s.PointerRcv()
    s.ValueRcv()
}

package main

type S struct {
    N int
}

func PointerFunc(s *S) {
}

func ValueFunc(s S) {
}

func main() {
    var s *S 

    PointerFunc(s)
    ValueFunc(*s)
}

caddy reverse-proxy --from myserver.localhost --to :9000

myapp.localhost {
    reverse-proxy :9000
}

myhugoblog.localhost {
    reverse-proxy :1313
}

switch a {
    case 1: 
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Println("default")
}

switch a {
    case 1: 
        fmt.Println("1")
    case 2, 3, 4:
        fmt.Println("2, 3 или 4")
//  case 1,2:  // ошибка: дублирование case 1, дублирование case 2
//      fmt.Println("1 или 2")
}

switch a := f(); a {
    case 1: 
        fmt.Println("1")
    case 2:
        fmt.Println("2")
}

switch {
    case a == 1: 
        fmt.Println("1")
    case a >=2 && a <= 4:
        fmt.Println("2")
    case a <= 5:
        fmt.Println("3")
}

switch v := a.(type) {
    case int: 
        fmt.Println("a — это int:", v)
    case string, []byte:
        fmt.Println("a — это string:", v)
}

func do[T comparable](a any) {
    switch v := a.(type) {
    case int:
        fmt.Println("a — это int:", v)
    case T:
        fmt.Printf("a — это %T: %v", v, v)
    case []T:
        fmt.Println("a — это срез:", v)
    case []byte:
        fmt.Println("a — это срез байт:", v)
    }
}

func main() {
    do[bool](a)
    do[bool](true)
    do[int]([]int{1, 2, 3})
}

go test -cpu=4,5