🔥 🚀

Author: henriquehorbovyi

collections.go

@@ -0,0 +1,82 @@
+package main
+
+import "fmt"
+
+func main() {
+	maps()
+}
+
+func slices() {
+	names := make([]string, 10)
+	fmt.Println(names)
+
+	names[0] = "João"
+	names[1] = "Pedro"
+	names[3] = "Miguel"
+	names[4] = "Maria"
+	names[5] = "José"
+	fmt.Println(names)
+
+	twoNames := names[0:2]
+	allNames := names[:len(names)]
+
+	fmt.Println(twoNames)
+	fmt.Println(allNames)
+
+	names = append(names, "Fernando")
+
+	fmt.Println("New names ", names)
+}
+
+func theMatrix() {
+	var matrix [3][3]int
+	for i := 0; i < len(matrix); i++ {
+		for j := 0; j < len(matrix); j++ {
+			matrix[i][j] = j + i
+		}
+	}
+	fmt.Println("matrix", matrix)
+}
+
+func simpleLists() {
+	var ids [5]int
+	ages := [10]int{23, 22, 20}
+
+	fmt.Println("array:", ids, "\nlength:", len(ids))
+	fmt.Println("Ages", ages)
+}
+
+func playingWithRange() {
+
+	var ids = []int{1, 2, 3, 4, 5}
+
+	for range ids {
+		println("I'm inside the range :D")
+	}
+
+	println("------- With Index and Value -------")
+
+	for index, value := range ids {
+		println("Index >>", index, "Value >>", value)
+	}
+}
+
+// A lat, lng struct
+type Coordinate struct {
+	lat, lng float64
+}
+
+func maps() {
+	var places = map[string]Coordinate{
+		"Bell Labs": Coordinate{40.68433, -74.39967},
+		"Google":    Coordinate{37.42202, -122.08408},
+	}
+
+	places["Another place"] = Coordinate{
+		lat: 30.68433,
+		lng: -54.39967,
+	}
+
+	fmt.Println(places)
+	fmt.Println(places["Bell Labs"])
+}

data.txt

@@ -0,0 +1 @@
+hello, this is a sample text

files.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+func main() {
+	readFromFile()
+}
+
+func readFromFile() {
+	// .:.:.: IO Util makes it easy :.:.:.
+	// fileName := "data.txt"
+	// bytes, _ := ioutil.ReadFile(fileName)
+	// fmt.Println(string(bytes))
+
+	// .:.:.: Reading to a byte array :.:.:.
+	file, _ := os.Open("data.txt")
+	fileInfo, _ := file.Stat()
+
+	// With the [FileInfo.Size()] I create a byte array with this file's size
+	bytesData := make([]byte, fileInfo.Size())
+	length, _ := file.Read(bytesData)
+
+	fmt.Println(string(bytesData[:length]))
+}
+
+func reader() {
+	reader := strings.NewReader("Hello world")
+	bytes := make([]byte, 3)
+
+	for {
+		length, err := reader.Read(bytes)
+		fmt.Printf("byte = %s\n", bytes[:length])
+		if err == io.EOF {
+			break
+		}
+	}
+}

hello.go

@@ -0,0 +1,189 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/cmplx"
+	"math/rand"
+	"runtime"
+	"time"
+)
+
+type number int
+
+func (n number) isPositive() bool {
+	return n > 0
+}
+
+func main() {
+
+	// var age number = -42
+	// fmt.Println(age.isPositive())
+
+	// b := make([]int, 2)
+	// fmt.Println(b)
+
+	// sum := add(21, 21)
+	// fmt.Println("Sum is", sum)
+
+	// a, b := swap("world", "hello")
+	// fmt.Println(a, b)
+
+	// x, y := split(2)
+	// fmt.Println(x, y)
+
+	// variables()
+
+	// loops()
+
+	// ifStatements()
+
+	// switchSamples()
+
+	// deferSamples()
+}
+
+func helloWorld() {
+	fmt.Printf("Hello World\n")
+}
+
+func mathStuff() {
+	fmt.Println("That's a random number: ", rand.Intn(10))
+	fmt.Println("PI is: ", math.Pi)
+}
+
+func whatTimeIsIt() {
+	fmt.Println("Current time: ", time.Now())
+}
+
+// When you have two consecutive variables with the same type
+// into your function you can write the type only in the last variable
+func add(x int, y int) int {
+	return x + y
+}
+
+// in Go you can have many returns
+func swap(s1, s2 string) (string, string) {
+	return s2, s1
+}
+
+// returns in Go can be named :O
+func split(sum int) (x, y int) {
+	x = sum * 4 / 9
+	y = sum - x
+	return
+}
+
+func variables() {
+	// var defines a variable that can be assigned later
+	var x int
+	fmt.Println(x) // default value for an int unassigned is 0 :D
+
+	x = 2
+	fmt.Println(x)
+	x = 1
+	fmt.Println(x)
+	x = 0
+	fmt.Println(x)
+
+	// Inside a function, the := short
+	// assignment statement can be used in
+	// place of a var declaration with implicit type.
+	y := 21
+	y = 42
+	fmt.Println(y)
+
+	// You can create variables inline
+	var c, python, java = true, false, "no! :D"
+	fmt.Println(c, python, java)
+
+	var (
+		isAvailable bool       = false
+		z           complex128 = cmplx.Sqrt(-5 + 12i)
+	)
+
+	fmt.Printf("Type: %T | Value: %v\n", isAvailable, isAvailable)
+	fmt.Printf("Type: %T | Value: %v\n", z, z)
+
+	const (
+		Big = 1 << 2
+	)
+	a := float32(Big)
+	fmt.Println(a)
+}
+
+func loops() {
+	// for
+	sum := 0
+	for i := 0; i < 10; i++ {
+		sum += i
+	}
+	fmt.Println("Sum is:", sum)
+
+	// "while"
+	for sum < 0 {
+		sum = sum - 1
+	}
+	fmt.Println("Now sum is:", sum)
+
+	// Infinity loop
+	// for { }
+}
+
+func ifStatements() {
+	age := 17
+	if age >= 18 {
+		fmt.Println("Yes")
+	} else {
+		fmt.Println("No")
+	}
+}
+
+func switchSamples() {
+	fmt.Print("Go runs on ")
+
+	switch os := runtime.GOOS; os {
+	case "darwin":
+		fmt.Print("OS X\n")
+	case "linux":
+		fmt.Print("Linux\n")
+	default:
+		fmt.Print(os, "\n")
+	}
+
+	fmt.Println("\nWhen's Saturday?")
+	today := time.Now().Weekday()
+	switch time.Saturday {
+	case today + 0:
+		fmt.Println("Today.")
+	case today + 1:
+		fmt.Println("Tomorrow.")
+	case today + 2:
+		fmt.Println("In two days.")
+	default:
+		fmt.Println("Too far away.")
+	}
+
+	// Switch with conditions
+	hour := time.Now().Hour()
+	switch {
+	case hour < 12:
+		fmt.Println("Good morning!")
+	case hour < 17:
+		fmt.Println("Good afternoon.")
+	default:
+		fmt.Println("Good evening.")
+	}
+}
+
+func deferSamples() {
+	fmt.Println("counting...")
+
+	i := 0
+	for i < 10 {
+		defer fmt.Println(i)
+		i++
+	}
+
+	fmt.Println("done")
+}

interfaces.go

@@ -0,0 +1,41 @@
+package main
+
+import "fmt"
+
+// I interface is a simple contract
+type I interface {
+	M()
+}
+
+// T is a struct which has a property S which is a string
+type T struct {
+	S string
+}
+
+// M is the implementation of I.M() but
+// implementing inside T
+func (t T) M() {
+	fmt.Println(t.S)
+}
+
+func main() {
+	// var i I = T{"hello! :)"}
+	// i.M()
+
+	theEmptyInterface()
+}
+
+func theEmptyInterface() {
+	var i interface{}
+	describe(i)
+
+	i = 42
+	describe(i)
+
+	i = "hello"
+	describe(i)
+}
+
+func describe(i interface{}) {
+	fmt.Printf("(%v, %T)\n", i, i)
+}