it-ebooks - Golang 101 hacks
Here you can read online it-ebooks - Golang 101 hacks full text of the book (entire story) in english for free. Download pdf and epub, get meaning, cover and reviews about this ebook. year: 2018, publisher: iBooker it-ebooks, genre: Computer. Description of the work, (preface) as well as reviews are available. Best literature library LitArk.com created for fans of good reading and offers a wide selection of genres:
Romance novel
Science fiction
Adventure
Detective
Science
History
Home and family
Prose
Art
Politics
Computer
Non-fiction
Religion
Business
Children
Humor
Choose a favorite category and find really read worthwhile books. Enjoy immersion in the world of imagination, feel the emotions of the characters or learn something new for yourself, make an fascinating discovery.
Golang 101 hacks: summary, description and annotation
We offer to read an annotation, description, summary or preface (depends on what the author of the book "Golang 101 hacks" wrote himself). If you haven't found the necessary information about the book — write in the comments, we will try to find it.
it-ebooks: author's other books
Who wrote Golang 101 hacks? Find out the surname, the name of the author of the book and a list of all author's works by series.
Golang 101 hacks — read online for free the complete book (whole text) full work
Below is the text of the book, divided by pages. System saving the place of the last page read, allows you to conveniently read the book "Golang 101 hacks" online for free, without having to search again every time where you left off. Put a bookmark, and you can go to the page where you finished reading at any time.
Font size:
Interval:
Bookmark:
- Summary
- 1.1
- 1.2
- 1.3
- 1.4
- 1.5
- 1.6
- 1.7
- 1.8
- 1.9
- 1.10
- 1.11
- 1.12
- 1.13
- 1.14
- 1.15
- 1.16
- 1.17
- 1.18
- 1.19
- 1.20
- 1.21
- 1.22
- 1.23
- 1.24
- 1.25
- 1.26
- 1.27
- 1.28
- 1.29
- 1.30
- 1.31
- 1.32
- 1.33
- 1.34
- 1.35
- 1.36
- 1.37
- 1.38
- 1.39
- 1.40
- 1.41
- 1.42
- 1.43
- 1.44
Map is a reference type which points to a hash table, and you can use it to construct a "key-value" database which is very handy in practice programming. E.g., the following code will calculate the count of every element in a slice:
package mainimport ( "fmt")func main() { s := []int{1, 1, 2, 2, 3, 3, 3} m := make(map[int]int) for _, v := range s { m[v]++ } for key, value := range m { fmt.Printf("%d occurs %d times\n", key, value) }}The output is like this:
3 occurs 3 times1 occurs 2 times2 occurs 2 timesMoreover, according to Go spec: "A map is an unordered group of elements of one type, called the element type, indexed by a set of unique keys of another type, called the key type.". So if you run the above program another time, the output may be different:
2 occurs 2 times3 occurs 3 times1 occurs 2 timesYou must not presume the element order of a map.
The key type of the map must can be compared with "==" operator: the built-in types, such as int, string, etc, satisfy this requirement; while slice not. For struct type, if its members all can be compared by "==" operator, then this struct can also be used as key.
When you access a non-exist key of the map, the map will return the nil value of the element. I.e.:
package mainimport ( "fmt")func main() { m := make(map[int]bool) m[0] = false m[1] = true fmt.Println(m[0], m[1], m[2])}The output is:
false true falsethe value of m[0] and m[2] are both false, so you can't discriminate whether the key is really in map or not. The solution is to use comma ok method:
value, ok := map[key]if the key does exit, ok will be true; else ok will be false.
Sometimes, you may not care the values of the map, and use map just as a set. In this case, you can declare the value type as an empty struct: struct{}. An example is like this:
package mainimport ( "fmt")func check(m map[int]struct{}, k int) { if _, ok := m[k]; ok { fmt.Printf("%d is a valid key\n", k) }}func main() { m := make(map[int]struct{}) m[0] = struct{}{} m[1] = struct{}{} for i := 0; i <=2; i++ { check(m, i) }}The output is:
0 is a valid key1 is a valid keyUsing built-in delete function, you can remove an entry in the map, even the key doesn't exist:
delete(map, key)References:
Effective Go;
The Go Programming Language Specification;
The Go Programming Language.
In Go, the length is also a part of array type. So the following code declares an array:
var array [3]intwhile "var slice []int" defines a slice. Because of this characteristic, arrays with the same array element type but different length can't assign values each other. I.E.:
package mainimport "fmt"func main() { var a1 [2]int var a2 [3]int a2 = a1 fmt.Println(a2)}The compiler will complain:
cannot use a1 (type [2]int) as type [3]int in assignmentChanging "var a1 [2]int" to "var a1 [3]int" will make it work.
Another caveat you should pay attention to is the following code declares an array, not a slice:
array := [...]int {1, 2, 3}You can verify it by the following code:
package mainimport ( "fmt" "reflect")func main() { array := [...]int {1, 2, 3} slice := []int{1, 2, 3} fmt.Println(reflect.TypeOf(array), reflect.TypeOf(slice))}The output is:
[3]int []intAdditionally, since in Go, the function argument is passed by "value", so if you use an array as a function argument, the function just does the operations on the copy of the original copy. Check the following code:
package mainimport ( "fmt")func changeArray(array [3]int) { for i, _ := range array { array[i] = 1 } fmt.Printf("In changeArray function, array address is %p, value is %v\n", &array, array)}func main() { var array [3]int fmt.Printf("Original array address is %p, value is %v\n", &array, array) changeArray(array) fmt.Printf("Changed array address is %p, value is %v\n", &array, array)}The output is:
Original array address is 0xc082008680, value is [0 0 0]In changeArray function, array address is 0xc082008700, value is [1 1 1]Changed array address is 0xc082008680, value is [0 0 0]From the log, you can see the array's address in changeArray function is not the same with array's address in main function, so the content of original array will definitely not be modified. Furthermore, if the array is very large, copying them when passing argument to function may generate more overhead than you want, you should know about it.
bufio package provides buffered read functions. Let's see an example:
(1) Create a test.txt file first:
# cat test.txtabcdefghijklmnYou can see test.txt contains 4 lines.
(2) See the following program:
package mainimport ( "bufio" "fmt" "io" "log" "os")func main() { f, err := os.Open("test.txt") if err != nil { log.Fatal(err) } r := bufio.NewReader(f) for { if s, err := r.ReadSlice('\n'); err == nil || err == io.EOF { fmt.Printf("%s", s) if err == io.EOF { break } } else { log.Fatal(err) } }}(a)
f, err := os.Open("test.txt")Open test.txt file.
(b)
r := bufio.NewReader(f)bufio.NewReader(f) creates a bufio.Reader struct which implements buffered read function.
(c)
for { if s, err := r.ReadSlice('\n'); err == nil || err == io.EOF { fmt.Printf("%s", s) if err == io.EOF { break } } else { log.Fatal(err) }}Read and print each line.
The running result is here:
abcdefghijklmnWe can also use bufio.Scanner to implement above "print each line" function:
package mainimport ( "bufio" "fmt" "log" "os")func main() { f, err := os.Open("test.txt") if err != nil { log.Fatal(err) } s := bufio.NewScanner(f) for s.Scan() { fmt.Println(s.Text()) }}(a)
s := bufio.NewScanner(f)bufio.NewScanner(f) creates a new bufio.Scanner struct which splits the content by line by default.
(b)
for s.Scan() { fmt.Println(s.Text())}s.Scan() advances the bufio.Scanner to the next token (in this case, it is one optional carriage return followed by one mandatory newline), and we can use s.Text() function to get the content.
We can also customize SplitFunc function which doesn't separate content by line. Check the following code:
package mainimport ( "bufio" "fmt" "log" "os")func main() { f, err := os.Open("test.txt") if err != nil { log.Fatal(err) } s := bufio.NewScanner(f) split := func(data []byte, atEOF bool) (advance int, token []byte, err error) { for i := 0; i < len(data); i++ { if data[i] == 'h' { return i + 1, data[:i], nil } } return 0, data, bufio.ErrFinalToken } s.Split(split) for s.Scan() { fmt.Println(s.Text()) }}Font size:
Interval:
Bookmark:
Similar books «Golang 101 hacks»
Look at similar books to Golang 101 hacks. We have selected literature similar in name and meaning in the hope of providing readers with more options to find new, interesting, not yet read works.
Discussion, reviews of the book Golang 101 hacks and just readers' own opinions. Leave your comments, write what you think about the work, its meaning or the main characters. Specify what exactly you liked and what you didn't like, and why you think so.