package main declaration is the first thing in a go file and its meant to tell go what is the workspace/project/package the file is part of.
The reason we have called main is because go has two types of packages, executable and resusable.
Executable:
Is when the code that is compiled and bundled as executable file. Must have a func called main.
Reusable:
Are packages that are used as dependencies and not generated as executable. One way to differ a resusable from executable is the by the package main declaration.
import is used to get code/access defined in another package
We will always find this file pattern in go files.
// package declaration
package main
// import required/needed packages
import ("fmt")
// functions and whatnots to do things
func main() {}
Let's say we have an instance of a struct called person which we have the field name with the value as "jon doe" and we try to change this value like so:
p := person{
name: "jon doe"
}
p.name = "new name"The above code won't work because at the time of the instantiation we are saving/allocating in memory the person object with name and value, and then when trying to change the name although go won't through any errors we won't be changing the values/data in the original allocation of the person object.
For that we need to use pointer operators:
& Get the memory address where originally saved, example pPointer := &p
* Get the value of the memory address is pointing to, example *pPointer
That being said, Go will allow to omit the & when the receiver is a pointer "type".
When to think about the pointers being passed arround? when using value types such as int, float, string, bool and structs
Channels are a way to communicate between go routines, first we need to make a channel and pass the type of the messages (which can also be channels) c := make(chan string) then we need to pass the channel to the function that uses the go routine go doSomethingFoo(c) and finally use the channels by sending c <- "some message" and receiving <- c