Please enable JavaScript.

Coggle requires JavaScript to display documents.

Learn GO - Coggle Diagram

- - - - We can then define functions which accept a Receiver : every type of the receiver type will get access to the defined function
        
        we can now call "deck.print()"
        
        a receiver can be thought of being like the "this" of JS or "self" of python
        
        by convention, a receiver is defined with one/two/three letters abbreviations
        
        a receiver sets up methods on types that we create
  - - - The error type is an interface type. An error variable represents any value that can describe itself as a string
    - - Repetitive error handling (example for HTTP handler)
        
        Define app handler type
        
        Change function signature to return an error
        
        Handle error at higher level
  - - - might be needed to set go module resolution if no module is defined: go env -w GO111MODULE=auto
  - - - it will copy the whole value in memory and pass it to functions / receiver functions - by default any update will be done on the copy passed to the function call and not on the original data
    - - Pointers' zero value is nil
      - a star (*) in front of a type means something different of a star (*) in front of a value
        
        :warning: In this case * is not an operator!
    - - if the receiver expects a pointer to a type, GO will automatically turn the value of that type to a pointer to the type expected by receiver
    - - The Slice example
        
        Slices get modified if passed by value - even if we are not using pointers
        
        whenever creating a slice, GO creates two data structures in memory
        
        whenever passing the slice to a function, go is still creating a copy of the slice, but the pointer to the original array in memory will not change!
      - Value vs Reference Types
        
        other types behave exactly as the slice
  - - - An interface type is defined as a set of method signatures.
        A value of interface type can hold any value that implements those methods.
        
        Every type / struct having all of the methods defined by the interface can be treated as being of the interface type
  - - - whenever compiling/executing a go program we are creating a main go routine
        
        in case of blocking calls (like http.Get) the main go routine is frozen until the block is released
      - we can span new go routines with the keyword go
      - Go scheduler
        
        Multiple CPU cores
        
        One CPU core
        
        By default the Go scheduler will run on one CPU core and at any given time only one GO routine will run. When the scheduler detects a blocking call the scheduler will pick a go routine to execute (or continue to execute)
        
        execution goes back and forth between go routines
      - Go routine we spawn are not treated as the main go routine
        
        If the main routine terminates or exits, also the other running go routines terminate
        
        Channels
        
        Channels are the pipes that connect concurrent go routines. You can send values into channels from one goroutine and receive those values into another goroutine.
        
        channels are typed variables which can be created in our programs
        
        Declare a channel
        
        Receiving messages on a channel generates a blocking call
        
        how do we wait for all go routines to complete?
        
        2 more items...
        
        :warning:the main routine can hang if waiting for a message which will never come!
      - Put a Go routine to sleep
        
        :warning: Do not accidentally sleep the main routine!
        
        Usually not appropriate to put the sleep code inside the routine code as a routine can be thought of as a worker thread and must not worry about putting itself to sleep
- - - - Alternative initialization with automatic type infer
        
        used only for variable creation - to re-assign a variable just use "="
      - :warning:variable can be declared both inside and outside functions' body but they can only be assigned within functions' body
    - - Swap
  - - - Arrays
        
        Array: fixed length
        
        Slice: array that can grow or shrink
        
        Defining and using a slice
        
        append returns a new slice with the new element added to it
        
        access a slice: cars[i]
        
        access a sub-slice: "cars[start_included:end_exluded] " => first two cars: cars[0:2]
        
        all the way to the end => cars[2:]
        
        from beginning up to an index => cars[:2]
        
        all elements must be of same type
      - Maps
        
        Declaring a map
        
        Accessing/Assigning
        
        Deleting an entry
        
        Looping over a map
  - - - Files in the same package can freely call functions defined in other files.
      - Functions can return multiple values
    - - :warning:Mind the variables which are captured by the Function Literal's scope!
        
        especially in for loops otherwise the function literal might reference outdated loop variables
  - - - if index is not needed replace it with an underscore "_"
      - Go has no "while" - for is also go's while
      - Infinite loop
  - - - Generate a seed for the pseudo random generator based on current time
      - Create a new pseudo random generator using the created seed and use it to generate numbers within a range
- - - - convert a type into a byte[] (byte slice)
- - - - :warning:the name of the package tells whether it is an executable or a reusable package
        
        package main
        
        using package main automatically makes an executable package after build
        
        the main entry point of the main package must contain a "main" function inside
        
        using any package name other than "main" will create a reusable package
      - generate files which can be run
    - - code libraries
      - many reusable packages from the go standard lib: fmt, io math, etc.
      - reusable packages must be explicitly imported otherwise won't be added to the final build
      - Multiple imports