Go/Beginner-8uiZC0l4Ajw

Author: Programmer-RD-AI

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_1/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, World!")
+}

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_10/main.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+	var intSlice = []int{1, 2, 3}
+	fmt.Println(sumSlice[int](intSlice))
+
+	var float32Slice = []float32{1, 2, 3}
+	fmt.Println(sumSlice[float32](float32Slice))
+}
+
+func sumSlice[T int | float32 | float64](slice []T) T {
+	var sum T
+	for _, v := range slice {
+		sum += v
+	}
+	return sum
+}

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_2/main.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"fmt"
+	"unicode/utf8"
+)
+
+// uint = only positive integer
+
+func main(){
+	var intNum uint = 32767;
+	intNum = intNum + 1;
+	fmt.Println(intNum);
+	// var floatNum float64;
+	// fmt.Println(floatNum)
+	var floatNum float32 = 10.1;
+	var intNum32 int32 = 2;
+	var result float32 = floatNum + float32(intNum32)
+	fmt.Println(result)
+
+	var intNum1 int = 3
+	var intNum2 int = 2
+	fmt.Println(intNum1/intNum2)
+	fmt.Println(intNum1%intNum2)
+
+	var myString string = "Hello World"
+	fmt.Println(myString)
+
+	var testString = `
+	Multi Line Strings type shi
+	`
+	fmt.Println(testString)
+
+  /* 
+	so here we have to do this since when we call the len() function in go it provides us the number of bytes 
+	(and in scenario where we get weird aaa characters then it does not exactly work per say yk?)
+	*/
+	fmt.Println(utf8.RuneCountInString("weird sigma symbol type shi"))
+
+	var myRune rune = 'a';
+	fmt.Println(myRune)
+
+	var myBoolean bool = false
+	fmt.Println(myBoolean)
+
+	var intNum3 int
+	fmt.Println(intNum3)
+
+	// var myVar = "text"
+	// same as:
+	myVar := "text"
+	fmt.Println(myVar)
+
+	var var1, var2 = 1, 2
+	fmt.Println(var1, var2)
+
+	const myConst string = "const value"
+	fmt.Println(myConst)
+
+	const pi float32 = 3.1415
+}

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_3/main.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+func main() {
+	var printValue string = "Hello Word"
+	printMe(printValue)
+
+	var numerator int = 11
+	var denominator int = 2
+	var result, remainder, err = intDivision(numerator, denominator)
+	// if err!= nil {
+	// 	fmt.Println(err.Error())
+	// } else if remainder == 0{
+	// 	fmt.Printf("the result of the integer division is %v", result)
+	// } else {
+	// fmt.Printf("The result of the integer divison is %v and the remainder is %v", result, remainder)
+	// }
+	switch {
+	case err != nil:
+		fmt.Printf(err.Error())
+	case remainder == 0:
+		fmt.Printf("the result of the intger divison is %v", result)
+	default:
+		fmt.Printf("the result of the integer division is %v with remainder %v", result, remainder)
+	}
+
+	switch remainder {
+	case 0:
+		fmt.Printf("the division was exact")
+	case 1, 2:
+		fmt.Printf("the division was close")
+	default:
+		fmt.Printf("the division was not close")
+	}
+}
+
+func printMe(printValue string) {
+	fmt.Println(printValue)
+}
+
+func intDivision(numerator int, denominator int) (int, int, error) {
+	var err error
+	if denominator == 0 {
+		err = errors.New("cannot divide by zero")
+		return 0, 0, err
+	}
+	var result int = numerator / denominator
+	var remainder int = numerator % denominator
+	return result, remainder, err
+}
+
+// if 1==1 && or || 2==2

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_4/main.go

@@ -0,0 +1,64 @@
+package main
+
+import "fmt"
+
+func main() {
+	var intArr [3]int32
+	intArr[1] = 123
+	fmt.Println(intArr[0])
+
+	// Continuous Memory, So that each of the elements are next to each other so that we know the locations yk?
+	fmt.Println(&intArr[0])
+
+	// var intArry [3]int32 = [3]int32{1, 2, 3}
+	intArry := [...]int32{1, 2, 3}
+	fmt.Println(intArry)
+
+	var intSlice []int32 = []int32{4, 5, 6}
+	fmt.Println(intSlice)
+	intSlice = append(intSlice, 7)
+	fmt.Println(intSlice)
+
+	var intSlice2 []int32 = []int32{8, 9}
+	intSlice = append(intSlice, intSlice2...)
+	fmt.Println(intSlice)
+
+	var intSlice3 []int32 = make([]int32, 3, 8)
+	fmt.Println(intSlice3)
+
+	var myMap map[string]uint8 = make(map[string]uint8)
+	fmt.Println(myMap)
+
+	var myMap2 = map[string]uint8{"Adam": 23, "Sarah": 45}
+	fmt.Println(myMap2["Adam"])
+	var age, ageExist = myMap2["Jason"]
+	// delete(myMap2, "Adam")
+	if ageExist {
+		fmt.Printf("the age is %v", age)
+	} else {
+		fmt.Println("invalid key brh1")
+	}
+
+	for name, age := range myMap2 {
+		fmt.Printf("Name %v, age %v", name, age)
+	}
+
+	for i, v := range intArr {
+		fmt.Printf("Index %v, Value %v", i, v)
+	}
+	var i int = 0
+	// for i > 10 {
+	// 	fmt.Println(i)
+	// 	i += 1
+	// }
+	for {
+		if i > 10 {
+			break
+		}
+		fmt.Println(i)
+		i += 1
+	}
+	for i := 0; i < 10; i++ {
+		fmt.Println(i)
+	}
+}

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_5/main.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	var myString = "résumé"
+	var myRunes = []rune("résumé")
+	var indexed = myString[0]
+	fmt.Println(myRunes)
+	fmt.Println(indexed)
+	fmt.Println(myString)
+
+	var strSlice = []string{"s", "u", "b", "s", "c", "r", "i", "b", "e"}
+	var strBuilder strings.Builder
+	for i := range strSlice {
+		strBuilder.WriteString(strSlice[i])
+	}
+	var catStr = strBuilder.String()
+	fmt.Printf("%v", catStr)
+}
+
+/*
+so in fmt.Printf()
+
+we can use %T to get the type of a specific value
+
+var value int = 1;
+fmt.Printf("%v %T", value, value)
+*/
+
+/*
+so in the string setup its a bit complicated ig but not that bad, here is how it goes
+
+golang uses utf 8 which is a dynamic byte setup where a specific character might take up 8 or 16 or continued no. of bits, we dont really know
+so in turn it is really hard for us to manage it right, so because of that when we index for example we get the uint no. of that specific byte, but the thing is 1 character can have more than 1 byte so its a bit of a tricky situation, you can go through the for loop and get it as well but still too complicated.
+
+the easiest way it seems is to pretty much just use runes since they will auto calculate the uint of a character since its represented individually
+*/

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_6/main.go

@@ -0,0 +1,70 @@
+package main
+
+import "fmt"
+
+type gasEngine struct {
+	mpg     uint8
+	gallons uint8
+}
+type electricEngine struct {
+	mpkwh uint8
+	kwh   uint8
+}
+
+func (e gasEngine) milesLeft() uint8 {
+	return e.gallons * e.mpg
+}
+func (e electricEngine) milesLeft() uint8 {
+	return e.kwh * e.mpkwh
+}
+
+type engine interface {
+	milesLeft() uint8
+}
+
+func canMakeIt(e engine, miles uint8) bool {
+	return miles <= e.milesLeft()
+}
+func main() {
+	var myEngine gasEngine = gasEngine{mpg: 25, gallons: 15}
+	myEngine.mpg = 28
+	fmt.Println(myEngine)
+	fmt.Printf("total miles left %v \n", myEngine.milesLeft())
+	fmt.Printf("chat, can i make it? %v", canMakeIt(myEngine, 10))
+}
+
+/*
+type gasEngine struct {
+	mpg     uint8
+	gallons uint8
+	owner   owner
+}
+this will have like
+{
+mpg: smthn
+gallons: smthn
+owner: {
+name: "Alex"
+}
+}
+
+
+type gasEngine struct {
+	mpg     uint8
+	gallons uint8
+	owner
+}
+this will have like{
+mpg: smthn
+gallons: smthn
+name: "Alex"
+}
+*/
+
+/*
+var myEngine2 = struct {
+		mpg     uint8
+		gallons uint8
+	}{25, 15}
+	// the myEngine2 is a way to create a temp struct but that specific structure cant really be reused per say yk?
+*/

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_7/main.go

@@ -0,0 +1,27 @@
+package main
+
+import "fmt"
+
+//	func main() {
+//		var p *int32 = new(int32)
+//		var i int32
+//		fmt.Printf("the value p points to is: %v", *p)
+//		fmt.Printf("the value if i is: %v", i)
+//		*p = 10 // so when we do new() have a memory location we point to right, we update the memory within that, the variable p still refers to the original memory location which has the memory location of the new() variable
+//		p = &i  // now p and i both refer to the same spot in memory
+//		*p = 1
+//	}
+func main() {
+	var thing1 = [5]float64{1, 2, 3, 4, 5}
+	fmt.Printf("\n the memory location of the thing1 array is: %p", &thing1)
+	var result [5]float64 = square(&thing1)
+	fmt.Printf("\n the result is: %v", result)
+	fmt.Printf("\n the value of thing1 is: %v", thing1)
+}
+
+func square(thing2 *[5]float64) [5]float64 {
+	for i := range thing2 {
+		thing2[i] = thing2[i] * thing2[i]
+	}
+	return *thing2
+}

Go/Beginner-8uiZC0l4Ajw/cmd/tutorial_8/main.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+	"time"
+)
+
+// RWMutex is specifically for Reading and Writing, Mutex is just general purpose, and this provides functions like RLock(), etc...
+var m = sync.RWMutex{}
+var wg = sync.WaitGroup{}
+var dbData = []string{"id1", "id2", "id3", "id4", "id5"}
+var results = []string{}
+
+func main() {
+	t0 := time.Now()
+	for i := 0; i < len(dbData); i++ {
+		wg.Add(1)
+		go dbCall(i)
+	}
+	wg.Wait()
+	fmt.Printf("total execution time: %v", time.Since(t0))
+}
+func dbCall(i int) {
+	var delay float32 = 2000
+	time.Sleep(time.Duration(delay) * time.Millisecond)
+	var result string = dbData[i]
+	save(result)
+	log()
+	wg.Done()
+}
+
+func save(result string) {
+	m.Lock()
+	results = append(results, result)
+	m.Unlock()
+}
+
+func log() {
+	m.RLock()
+	fmt.Println("the results from the database is: ", results)
+	m.RUnlock()
+}