Merge remote-tracking branch 'source/go-basics'

go/01-basics/00-values.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	fmt.Println("go" + "lang")
+
+	fmt.Println("1+1 =", 1+1)
+	fmt.Println("7.0/3.0 =", 7.0/3.0)
+
+	fmt.Println(true && false)
+	fmt.Println(true || false)
+	fmt.Println(!true)
+}

go/01-basics/01-variables.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	var a = "initial"
+	fmt.Println(a)
+
+	var b, c int = 1, 2
+	fmt.Println(b, c)
+
+	var d = true
+	fmt.Println(d)
+
+	var e int
+	fmt.Println(e)
+
+	f := "apple"
+	fmt.Println(f)
+}

go/01-basics/02-constants.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+    "fmt"
+    "math"
+)
+
+const s string = "constant"
+
+func main() {
+    fmt.Println(s)
+
+    const n = 500000000
+
+    const d = 3e20 / n
+    fmt.Println(d)
+
+    fmt.Println(int64(d))
+
+    fmt.Println(math.Sin(n))
+}

go/01-basics/03-for.go

@@ -0,0 +1,32 @@
+package main
+
+import "fmt"
+
+func main() {
+
+    i := 1
+    for i <= 3 {
+        fmt.Println(i)
+        i = i + 1
+    }
+
+    for j := 0; j < 3; j++ {
+        fmt.Println(j)
+    }
+
+    for i := range 3 {
+        fmt.Println("range", i)
+    }
+
+    for {
+        fmt.Println("loop")
+        break
+    }
+
+    for n := range 6 {
+        if n%2 == 0 {
+            continue
+        }
+        fmt.Println(n)
+    }
+}

go/01-basics/04-if-else.go

@@ -0,0 +1,28 @@
+package main
+
+import "fmt"
+
+func main() {
+
+    if 7%2 == 0 {
+        fmt.Println("7 is even")
+    } else {
+        fmt.Println("7 is odd")
+    }
+
+    if 8%4 == 0 {
+        fmt.Println("8 is divisible by 4")
+    }
+
+    if 8%2 == 0 || 7%2 == 0 {
+        fmt.Println("either 8 or 7 are even")
+    }
+
+    if num := 9; num < 0 {
+        fmt.Println(num, "is negative")
+    } else if num < 10 {
+        fmt.Println(num, "has 1 digit")
+    } else {
+        fmt.Println(num, "has multiple digits")
+    }
+}

go/01-basics/05-switch.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+
+	i := 2
+	fmt.Print("Write ", i, " as ")
+	switch i {
+	case 1:
+		fmt.Println("one")
+	case 2:
+		fmt.Println("two")
+	case 3:
+		fmt.Println("three")
+	}
+
+	switch time.Now().Weekday() {
+	case time.Saturday, time.Sunday:
+		fmt.Println("It's the weekend")
+	default:
+		fmt.Println("It's a weekday")
+	}
+
+	t := time.Now()
+	switch {
+	case t.Hour() < 12:
+		fmt.Println("It's before noon")
+	default:
+		fmt.Println("It's after noon")
+	}
+
+	whatAmI := func(i interface{}) {
+		switch t := i.(type) {
+		case bool:
+			fmt.Println("I'm a bool")
+		case int:
+			fmt.Println("I'm an int")
+		default:
+			fmt.Printf("Don't know type %T\n", t)
+		}
+	}
+	whatAmI(true)
+	whatAmI(1)
+	whatAmI("hey")
+}

go/01-basics/06-arrays.go

@@ -0,0 +1,38 @@
+package main
+
+import "fmt"
+
+func main() {
+
+    var a [5]int
+    fmt.Println("emp:", a)
+
+    a[4] = 100
+    fmt.Println("set:", a)
+    fmt.Println("get:", a[4])
+
+    fmt.Println("len:", len(a))
+
+    b := [5]int{1, 2, 3, 4, 5}
+    fmt.Println("dcl:", b)
+
+    b = [...]int{1, 2, 3, 4, 5}
+    fmt.Println("dcl:", b)
+
+    b = [...]int{100, 3: 400, 500}
+    fmt.Println("idx:", b)
+
+    var twoD [2][3]int
+    for i := 0; i < 2; i++ {
+        for j := 0; j < 3; j++ {
+            twoD[i][j] = i + j
+        }
+    }
+    fmt.Println("2d: ", twoD)
+
+    twoD = [2][3]int{
+        {1, 2, 3},
+        {1, 2, 3},
+    }
+    fmt.Println("2d: ", twoD)
+}

go/01-basics/07-pointers.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func zeroval(ival int) {
+	ival = 0
+}
+
+func zeroptr(iptr *int) {
+	*iptr = 0
+}
+
+func main() {
+	i := 1
+	fmt.Println("initial:", i)
+
+	zeroval(i)
+	fmt.Println("zeroval:", i)
+
+	zeroptr(&i)
+	fmt.Println("zeroptr:", i)
+
+	fmt.Println("pointer:", &i)
+}

go/01-basics/08-slices.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+)
+
+func main() {
+
+	var s []string
+	fmt.Println("uninit:", s, s == nil, len(s) == 0)
+
+	s = make([]string, 3)
+	fmt.Println("emp:", s, "len:", len(s), "cap:", cap(s))
+
+	s[0] = "a"
+	s[1] = "b"
+	s[2] = "c"
+	fmt.Println("set:", s)
+	fmt.Println("get:", s[2])
+
+	fmt.Println("len:", len(s))
+
+	s = append(s, "d")
+	s = append(s, "e", "f")
+	fmt.Println("apd:", s)
+
+	c := make([]string, len(s))
+	copy(c, s)
+	fmt.Println("cpy:", c)
+
+	l := s[2:5]
+	fmt.Println("sl1:", l)
+
+	l = s[:5]
+	fmt.Println("sl2:", l)
+
+	l = s[2:]
+	fmt.Println("sl3:", l)
+
+	t := []string{"g", "h", "i"}
+	fmt.Println("dcl:", t)
+
+	t2 := []string{"g", "h", "i"}
+	if slices.Equal(t, t2) {
+		fmt.Println("t == t2")
+	}
+
+	twoD := make([][]int, 3)
+	for i := 0; i < 3; i++ {
+		innerLen := i + 1
+		twoD[i] = make([]int, innerLen)
+		for j := 0; j < innerLen; j++ {
+			twoD[i][j] = i + j
+		}
+	}
+	fmt.Println("2d: ", twoD)
+}

go/01-basics/09-maps.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+	"maps"
+)
+
+func main() {
+
+	m := make(map[string]int)
+
+	m["k1"] = 7
+	m["k2"] = 13
+
+	fmt.Println("map:", m)
+
+	v1 := m["k1"]
+	fmt.Println("v1:", v1)
+
+	v3 := m["k3"]
+	fmt.Println("v3:", v3)
+
+	fmt.Println("len:", len(m))
+
+	delete(m, "k2")
+	fmt.Println("map:", m)
+
+	clear(m)
+	fmt.Println("map:", m)
+
+	_, prs := m["k2"]
+	fmt.Println("prs:", prs)
+
+	n := map[string]int{"foo": 1, "bar": 2}
+	fmt.Println("map:", n)
+
+	n2 := map[string]int{"foo": 1, "bar": 2}
+	if maps.Equal(n, n2) {
+		fmt.Println("n == n2")
+	}
+}

go/01-basics/10-enums.go

@@ -0,0 +1,45 @@
+package main
+
+import "fmt"
+
+type ServerState int
+
+const (
+	StateIdle ServerState = iota
+	StateConnected
+	StateError
+	StateRetrying
+)
+
+var stateName = map[ServerState]string{
+	StateIdle:      "idle",
+	StateConnected: "connected",
+	StateError:     "error",
+	StateRetrying:  "retrying",
+}
+
+func (ss ServerState) String() string {
+	return stateName[ss]
+}
+
+func main() {
+	ns := transition(StateIdle)
+	fmt.Println(ns)
+
+	ns2 := transition(ns)
+	fmt.Println(ns2)
+}
+
+func transition(s ServerState) ServerState {
+	switch s {
+	case StateIdle:
+		return StateConnected
+	case StateConnected, StateRetrying:
+
+		return StateIdle
+	case StateError:
+		return StateError
+	default:
+		panic(fmt.Errorf("unknown state: %s", s))
+	}
+}

go/01-basics/11-functions.go

@@ -0,0 +1,36 @@
+package main
+
+import "fmt"
+
+func plus(a int, b int) int {
+	return a + b
+}
+
+func plusPlus(a, b, c int) int {
+	return a + b + c
+}
+
+func plusNamed(a, b int) (result int) {
+	result = a + b
+	return
+}
+
+func plusDescription(a int, b int) (int, string) {
+	result := a + b
+	return result, fmt.Sprintf("%d+%d = %d", a, b, result)
+}
+
+func main() {
+
+	res := plus(1, 2)
+	fmt.Println("1+2 =", res)
+
+	res = plusPlus(1, 2, 3)
+	fmt.Println("1+2+3 =", res)
+
+	res = plusNamed(1, 2)
+	fmt.Println("1+2 =", res)
+
+	_, desc := plusDescription(1, 2)
+	fmt.Println(desc)
+}

go/01-basics/12-structs.go

@@ -0,0 +1,46 @@
+package main
+
+import "fmt"
+
+type person struct {
+	name string
+	age  int
+}
+
+func newPerson(name string) *person {
+
+	p := person{name: name}
+	p.age = 42
+	return &p
+}
+
+func main() {
+
+	fmt.Println(person{"Bob", 20})
+
+	fmt.Println(person{name: "Alice", age: 30})
+
+	fmt.Println(person{name: "Fred"})
+
+	fmt.Println(&person{name: "Ann", age: 40})
+
+	fmt.Println(newPerson("Jon"))
+
+	s := person{name: "Sean", age: 50}
+	fmt.Println(s.name)
+
+	sp := &s
+	fmt.Println(sp.age)
+
+	sp.age = 51
+	fmt.Println(sp.age)
+
+	dog := struct {
+		name   string
+		isGood bool
+	}{
+		"Rex",
+		true,
+	}
+	fmt.Println(dog)
+}