Add files via upload

Author: JohnLins

Array/array.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	//Arrays & slices
+
+	//Static Array
+	numsstatic := [3]int{97, 85, 93}
+
+	//Unspecified
+	var wordsunspecified [3]string
+	wordsunspecified[1] = "John"
+
+	var mulitiseg [3][3]int = [3][3]int{ 
+	[3]int{1, 0, 0}, 
+	[3]int{0, 1, 0},
+	[3]int{0, 0, 1}}
+
+	//Slice
+		a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		b := a[:]
+		c := a[3:]
+		d := a[:6]
+		e := a[3:6]
+
+		fmt.Println(a, "   ", b, "   ", c, "   ", d, "   ", e)
+
+
+
+	fmt.Println(numsstatic[1])
+	fmt.Println(wordsunspecified[1])
+	fmt.Println(mulitiseg)
+
+	for i := 0; i <= 2; i++ {
+		fmt.Println(numsstatic[i])
+	}
+
+
+	//A DYNAMIC ARRAY:
+
+	arr := [...]int{1, 2, 3}
+	fmt.Println(arr)
+}
+

Channels/channle.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+var wg = sync.WaitGroup{}
+
+func main() {
+	//Channel Example
+	ch := make(chan int)
+	wg.Add(2) //Add 2 channels
+	go func() { //Receiving Goroutine
+		i := <- ch //i is receiving the data sent through ch
+		fmt.Println(i)
+		wg.Done()
+	}()
+	go func() { //Sending Goroutine
+		ch <- 42 //The input 42, is being submitted to the channel through "ch" using the syntax "<-"
+		wg.Done()
+	}()
+	wg.Wait()
+}

Composition/composition.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+)
+
+type Animal struct {
+	Name string
+	Origin string
+}
+
+type Bird struct {
+	Animal //Bird is inherating from Animal
+	SpeedKPH  float32
+	CanFly bool
+}
+
+func main() {
+	b := Bird{
+		Animal: Animal{
+			Name:    "Emu",
+			Origin:  "Australia",
+		},
+		SpeedKPH:     48,
+		CanFly:       false,
+	}
+	fmt.Println(b.Name)
+}

ConvertToASCII/converttoASCII.go

@@ -0,0 +1,9 @@
+package main
+
+import "fmt"
+
+func main() {
+	letter := 'a'
+	ascii := int(letter)
+	fmt.Println(ascii)
+}

Defer/defer.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println("Start")
+	defer fmt.Println("Middle") //A defer function will run once the main func is complete!
+	fmt.Println("End")
+
+
+	//A DEFER FUNCTION
+	defer func() {
+		if err := recover(); err != nil {
+			log.Println("Error", err)
+		}
+	}()
+	
+}
+//DEFER PLAYS HERE
+
+

Functions/function.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	myFunc("hi")
+	twoArgsWithSameType("hi", "hello")
+
+	//PASSING POINTERS
+	name := "jeff"
+	funcWithPointers(&name)
+
+	//VARIADIC PARAMETER
+	sum(1, 2, 3, 4, 5)
+
+	//Func with return value
+	myFuncReturn(2, 6)
+
+	//Func returns pointer
+	myFuncReturnAsPointer(6)
+
+	//Result before end
+	funcResult(7)
+
+	//Returns two values             
+	d, err := divide(5.0, 3.0)
+	if err != nil {
+		fmt.Println(err)
+		return            //^ Basic error checking ^
+	}
+	fmt.Println(d)
+
+
+	//Anonymous Func example
+	var j int = 7
+	for i := 0; i <= 5; i++ {
+		func(j, i int) {
+			fmt.Println(i + j)
+		}(i, j)
+	}
+
+	//Anonymous Func as VAR example
+	f := func(input string) {
+		fmt.Println(input)
+	}
+
+	f("hi")  //Call on func
+
+	//Method example
+	g := greeter {
+		greeting: "hello",
+		name: "go",
+	}
+	g.greet()
+}
+
+func myFunc(msg string) {
+	fmt.Println(msg)
+}
+
+func twoArgsWithSameType(greeting, name string) { //(greeting, name string) NOT (greeting string, name string)
+	fmt.Println(greeting, name)
+}
+
+//Func with pointers
+func funcWithPointers(yourName *string) {
+	*yourName = "John"
+	fmt.Println(*yourName)
+}
+
+//VARIADIC PARAMETER
+func sum(values ...int) {
+	fmt.Println(values)
+	result := 0
+	for _, v := range values {
+		result += v
+	}
+	fmt.Println("The sum is: ", result)
+}
+
+//Func return value           //Return type
+func myFuncReturn(num1, num2 int) int{
+	var result int = num1 + num2
+	return result
+}
+
+//Func return value AS POINTER     //Return type
+func myFuncReturnAsPointer(num int) *int {
+	result := num * 2
+	return &result
+}
+
+//Return declaired before using RESULT
+func funcResult(num int) (result int) {
+	result = num
+	return 
+}
+
+//This func return 2 values
+func divide(a, b float64) (float64, error) {
+	if b == 0.0 {
+		return 0.0, fmt.Errorf("Cannot divide by zero")
+	}
+	return a / b, nil
+}
+
+
+//Method
+type greeter struct {
+	greeting string
+	name string
+}
+
+func (g greeter) greet() {
+	fmt.Println(g.greeting, g.name)
+}

Goroutines/goroutine.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+var wg = sync.WaitGroup{}
+
+func main() {
+	//Basic Goroutine
+	var mess = "hello"
+	wg.Add(1)
+	go func(msg string) {
+		fmt.Println(msg)
+		wg.Done()
+	}(mess)
+	mess = "Goodbye"
+	wg.Wait()
+}

Goroutines/multGoroutines.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"sync"
+)
+
+var wg = sync.WaitGroup{}
+var counter = 0
+var m = sync.RWMutex{}
+
+func main() {
+	runtime.GOMAXPROCS(10) //In this case we are using 10 threads
+	for i := 0; i <= 10; i++ {
+		wg.Add(2)
+		m.RLock() //So its one at a time
+		go sayHello()
+		m.Lock() //So it is one at a time
+		go increment()
+	}
+	wg.Wait()
+}
+
+func sayHello() {
+	fmt.Println("Hello", counter)
+	m.RUnlock()
+	wg.Done()
+}
+
+func increment() {
+	counter++
+	m.Unlock()
+	wg.Done()
+}
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+var wg = sync.WaitGroup{}
+var counter = 0
+
+func main() {
+	for i := 0; i <= 10; i++ {
+		wg.Add(2)
+		go sayHello()
+		go increment()
+	}
+	wg.Wait()
+}
+
+func sayHello() {
+	fmt.Println("Hello", counter)
+	wg.Done()
+}
+
+func increment() {
+	counter++
+	wg.Done()
+}
+*/