Go Basics.txt

Go Basics


Getting Started
--------------------
go mod init <module_name>
  creates god mod file in project
  
go mod tidy

go get <package>
  fetches a 3rd party package and downloads it to $GOPATH/pkg/mod
  this MUST be done before "importing" the module and referencing in your project
  
go run main.go 
  runs the main.go file in the current directory

go build
  compiles project into a binary
  

 Variable Declaration
 ---------------------------
 
 var myString string // intialize to zero value
 myString  = "Low"
 x := "Hello World" // shorthand way to take the type or result on the right and assign it to the variable on the left
 
 deck := []string{"2 of Hearts", "Jack of Diamonds"} // slice
 
 fmt.Println("Hello World") // print to stdout
 
 
 colors := map[string]string {
		"red":   "#ff0000",
		"green": "#4bf765",
	}
  
  
 String Interpolation 
 ------------------------ 
 - the "f" stands for formatted string
 
   name := "Low"
   output := fmt.Sprintf(Hello my name is %a!, name)
   
   Errorf("Expected deck length of 16, but got %d!", len(d))
   
   


Value & Reference Types
-----------------------------------

[ Value Types ]
int 
float
string
bool structs

**Use pointers to change value types inside a function

[ Reference Types ]
slices
maps
channels
pointers
functions

**Don't need to worry about pointers for reference types; the language handles this

  
Pointers & Reference Syntax
--------------------------------------

When we call a function that takes an argument, that argument is copied to the function

func zero(x int) {
  x = 0
  
}
func main() {
  x := 5
  zero(x)
  fmt.Println(x) // x is still 5
}

In the instance above, I do not intend modify the original value of "x" in the main function

func zero(xPtr *int) {
  *xPtr = 0
}
func main() {
  x := 5
  zero(&x)
  fmt.Println(x) // x is 0
}

Pointers reference a location in memory where a value is stored rather than the value itself (they point to something else). By using a pointer (*int) the zero function is able to modify the original variable.

In Go a pointer is represented using the * (asterisk) character followed by the type of the stored value. In the zero function xPtr is a pointer to an int.

Finally we use the & operator to find the address of a variable. &x returns a *int (pointer to an int) because x is an int. This is what allows us to modify the original variable. &x in main and xPtr in zero refer to the same memory location.


  
Data Structures
--------------------

[ Arrays ] 
- discuss the difference between this and slices
- common methods

[ Slices ] 


[ Maps ] 
- similar to objects (javascript), dicitonaries (python)
- key/value pairs
- keys must be of the same type; values must be of the same type



[ Structs ] 
- talk about receivers


[ Interfaces ]


Functions
------------


Control Flow & Iteration
--------------------------------

func contains(vId string) ([]verse, bool) {

	var tempSlice []verse

	for _, item := range verses { // _ ignores the index value since we don't need it

		if item.ID == vId {
			tempSlice = append(tempSlice, item)
			return tempSlice, true
		}
	}

	return tempSlice, false
}


Error Handling Patterns
-------------------------------


Testing
---------
- files must have a _test in the name (e.g. deck_test.go)
- test are executed by running `go test`
  
  
  
Web Frameworks
------------------------
GIN


ORMs
---------