lesson2.slide

Go language fundamentals, the first part
Lesson 2
13 Sep 2019
Tags: golang, go

Pavel Tišnovský <ptisnovs@redhat.com>
Red Hat, Inc.
https://github.com/RedHatOfficial/GoCourse
@RedHat

* Gophers
#The Go gopher was designed by Renee French. (http://reneefrench.blogspot.com/)
#Source https://golang.org/doc/gopher/fiveyears.jpg
#The design and this image is licensed under the Creative Commons 3.0 Attributions license.
.image ./common/fiveyears.jpg _ 900



############################################################

* Lesson #2

Outline:

- defer statement
- structs (records)
- arrays
- slices
- pointers
- maps
- loops that use range
- user-defined data types



############################################################

* defer statement
- `defer` is a keyword in the Go programming language
- used to "remember" commands that will be called before `return` or exit
- based on LIFO (stack) of remembered commands
- parameters are evaluated when `defer` is declared (ie. in runtime)
- (not when the specified code is called)
- it is possible to change function return value(s) via `defer`



* Basic usage of defer statement
- function `on_finish()` is called before exit from `main()`
.play lesson2/01_defer_basic_usage.go



* Function declaration in defer statement
- usually the function definition is part of `defer` statement
- this function is anonymous - lambda, and usually it is a closure as well
- (we will talk about lambdas and closures in the next lesson)
.play lesson2/02_defer_func.go



* Function declaration in defer statement (cont.)
- parenthesis around lambda are not required
.play lesson2/02B_defer_func.go



* Function declaration with parameters in defer statement
- it is possible to specify arguments passed into function in `defer`
.play lesson2/03_defer_with_parameters.go



* More defer statements in one function
- ten `defer` statements
- LIFO behaviour
- (check in runtime how it works)
.play lesson2/04_more_defers.go



* Defer arguments evaluation
- one function can be used in more `defer` statements
- actual parameters are evaluated in runtime
- (check in runtime)



* Defer arguments evaluation (cont.)
.play lesson2/05_defer_arguments_evaluation.go



* Defer arguments evaluation (more complicated example)
- arrays are a bit tricky
- (call by value vs. call by reference)
- (check in runtime, again)



* Defer arguments evaluation (more complicated example, cont.)
.play lesson2/06_defer_arguments_evaluation.go



* Defer and (many) return statements
- `defer` is called even when more `return` statements are used



* Defer and (many) return statements
.play lesson2/07_defer_on_all_returns.go /^package main/,/^func main/



* Defer and (many) return statements (cont.)
.play lesson2/07_defer_on_all_returns.go /^func main/,/^}/



* Practical usage of defer
- how to use `defer` in an application to copy files
.play lesson2/08_defer_practical_usage.go /^package main/,/func copyFile/



* Practical usage of defer (cont.)
.play lesson2/08_defer_practical_usage.go /^func copyFile/,/^}/



* Practical usage of defer (cont.)
.play lesson2/08_defer_practical_usage.go /^func main/,/^}/



* Practical usage of defer
- previous example refactored
.play lesson2/09_defer_practical_usage.go /^package main/,/func copyFile/



* Practical usage of defer (cont.)
.play lesson2/09_defer_practical_usage.go /^func copyFile/,/^}/



* Practical usage of defer (cont.)
.play lesson2/09_defer_practical_usage.go /^func main/,/^}/



* Defer and return values
- it is possible to change function return value(s) via `defer`
- (works because function declared in defer is closure)
- function return values needs to be named!
- used in applications to set `err` return value



* Defer and return values
.play lesson2/10_defer_return_values.go



############################################################

* Structs (records)
- a.k.a. records
- user-defined data type (so called named structure)
- or anonymous structure
- dot operator to access struct members
- initialization using {}
- or by using named members (which is more explicit and better)
- structs are comparable
- pass to functions as value or via pointer (by reference)



* Structs and dot operator
.play lesson2/11_struct.go



* Initialization of struct members
- similar to C language initialization
- usage of {} parenthesis
- C-like initialization: order matters!



* Initialization of struct members (cont.)
.play lesson2/12_struct_init.go



* Better (more explicit) initialization of struct members
- struct members are explicitly specified by name
- better readability 
- preferred approach



* Better (more explicit) initialization of struct members (cont.)
.play lesson2/13_better_struct_init.go



* Comparison of whole structs is possible!
- `==` and `!=` operators
.play lesson2/14_struct_comparison.go /package main/,/^func main//



* Comparison of whole structs is possible! (cont.)
.play lesson2/14_struct_comparison.go /^func main/,/^}/



* Passing structs as values into functions
- by value
- by reference (via pointer)
.play lesson2/15_print_user.go /package main/,/^func main//



* Passing structs as values into functions (cont.)
.play lesson2/15_print_user.go /^func main/,/^}/



* Anonymous structure
- just declare new variable and specify its type to `struct` _something_

    var employee struct {  
            firstName, lastName string
            age int
    }



############################################################

* Arrays
- basic data type in the Go programming language
- all array items has the same type
- (well, you can use `interface{}` to allow _dynamic typing behaviour_)
- type of array is derived from type of items *and* array size
- (unlike slices)
- index in range 0..length-1
- items indexing via [] (as in most other languages)



* Basic operations with arrays
.play lesson2/16_arrays.go



* Matrix (two dimensional array)
.play lesson2/16B_arrays.go



* Array copy
- unlike slices, arrays can be copied
.play lesson2/17_array_copy.go



############################################################

* Slices
- proper data type in the Go programming language
- interface to sequences (better than arrays)
- slices are used more often than _plain_ _old_ _arrays_
- type of slice is derived from type of items
- slices has defined length and capacity (those numbers can be different)
- internaly a slice is triple: (pointer to the first element + `len` + `cap`)
- so called "slice operator" `[from:to]`
- `append` function to add a new element to slice (complicated internally)



* Usage of slices

.play lesson2/18_slices.go /package main/,/cont//



* Usage of slices (cont.)

.play lesson2/18_slices.go /cont/,/^}//



* Slices and arrays as data source for them

- slice can be created from any array
- but the slice does not contain any data, just a pointer to array element
- so any modify in slice element is reflected in an array as well

.play lesson2/19_slice_copy.go /package main/,/cont//



* Slices and arrays as data source for them (cont.)
- modify array elements
- then modify the same elements, but via slice

.play lesson2/19_slice_copy.go /cont/,/^}//



* Slice from slice
- "slicing" of another slice is possible
.play lesson2/20_slice_from_slice.go /package main/,/cont//



* Slice from slice (cont.)
.play lesson2/20_slice_from_slice.go /cont/,/^}//



* Append function
- the function `append` returns a new slice
- the capacity of new slice can be increased (realloc magic inside!)
.play lesson2/21_slice_append.go



############################################################

* Pointers
- always points to an element of some type
- ie. `void` pointers are not supported
- implicit pointer value is `nil`
- address of element can be retrieved using the `&` operator
- access via pointer (reference in some other languages) using the `*` operator



* Basic usage of pointers
- please note the usage of `*p_i++`

.play lesson2/22_pointer_to_int.go



* Pointer to structure

.play lesson2/23_pointer_to_struct.go /package main/,/func main//



* Pointer to structure (cont.)
- please note the possibility to write `p_u.id` instead of `(*p_u).id`
.play lesson2/23_pointer_to_struct.go /func main/,/^}//



* Pointer to structure item/member
.play lesson2/24_pointer_to_struct_item.go /package main/,/func main//



* Pointer to structure item/member (cont.)
.play lesson2/24_pointer_to_struct_item.go /func main/,/^}//



* Pointer to array item
.play lesson2/25_pointer_to_array.go /package main/,/cont//



* Pointer to array item (cont.)
.play lesson2/25_pointer_to_array.go /cont/,/^}//



############################################################

* Maps
- a.k.a. associative array or hash
- container for key-value pairs
- "nil map":
    var m1 map[int]string
- empty map:
    var m3 map[int]string = make(map[int]string)
    m1 := make(map[int]string)



* Maps
- three basic operations: add/put, get, and delete
- add/put items to a map:
    m3[0] = "zero"
    m3[1] = "one"
    m3[2] = "two"
- get item from a map:
    m3[2]
- delete from a map
    delete(m3, "zero")



* Unitialized map ("nil map")
.play lesson2/26_uninitialized_map.go



* Empty map
.play lesson2/27_initialized_map.go



* Empty map (shorter idiom)
.play lesson2/28_initialized_map.go



* Maps and struct
.play lesson2/29_map_and_struct.go /^package main/,/^func main/



* Maps and struct (cont.)
.play lesson2/29_map_and_struct.go /^func main/,/^}/



* Struct can be used as key as well
.play lesson2/30_map_and_struct_B.go /^package main/,/^func main/



* Struct can be used as key as well (cont.)
.play lesson2/30_map_and_struct_B.go /^func main/,/^}/



* Reading items from map
.play lesson2/31_reading_from_maps.go /^package main/,/cont/



* Nonexistent values
.play lesson2/31_map_nonexistent_values.go



* Reading items from map (cont.)
.play lesson2/31_reading_from_maps.go /cont/,/^}/



* Deleting items from map
.play lesson2/32_delete_from_map.go /^package main/,/^func main/



* Deleting items from map (cont.)
.play lesson2/32_delete_from_map.go /^func main/,/^}/



############################################################

* Loops and the range clause
- (see the 1st lesson for a `for` loop examples)
- `range` keyword used in `for` to loop over array items, map pairs etc.
- provides an item index as well (Java on the other side...)



* Iterating over an array
.play lesson2/33_for_range_1.go



* Index can be ignored
.play lesson2/34_for_range_2.go



* Iterating over slice
.play lesson2/35_for_range_3.go



* Iterating over Unicode glyphs
.play lesson2/36_for_range_4.go



* Iterating over map pairs (key+value)
.play lesson2/37_for_range_map.go



############################################################

* User-defined data types
- `type` keyword
- Go is very strict in typing (see examples)



* User-defined data types
.play lesson2/38_user_types.go



* User-defined data types (passing to function)
.play lesson2/39_type_func_params.go



############################################################

#last slide
* More Gophers
#The Go gopher was designed by Renee French. (http://reneefrench.blogspot.com/)
#Source https://golang.org/doc/gopher/bumper.png
#The design and this image is licensed under the Creative Commons 3.0 Attributions license.
.image ./common/bumper.png  _ 900