Golang on My Notes

Getting started

Mon, 01 Jan 0001 00:00:00 +0000

Go Introduction#

Golang’s popularity is skyrocketing. The thriving of Docker and Kubernetes push the Golang to a higher level.

Go is easy to become functional with and appropriate for junior developers to work on. Also, having a language that encourages readability and comprehension is extremely useful. The mixture of duck typing (via interfaces) and convenience features such as “:=” for short variable declarations give Go the feel of a dynamically typed language while retaining the positives of a strongly typed one.

Map, Function & Closure

Mon, 01 Jan 0001 00:00:00 +0000

Map#

Maps are a special kind of data structure: an unordered collection of pairs of items, where one element of the pair is the key, and the other element, associated with the key, is the data or the value, hence they are also called associative arrays or dictionaries.
The key type can be any type for which the operations == and != are defined, like string, int, float. The value type can be any type.

Struct & Interface

Mon, 01 Jan 0001 00:00:00 +0000

Struct#

Go supports user-defined or custom types in the form of alias types or structs. A struct tries to represent a real-world entity with its properties. Structs are composite types, to use when you want to define a type which consist of a number of properties, each having their own type and value, grouping pieces of data together.

Struct with tags#

A field in a struct can, apart from a name and a type, also optionally have a tag: this is a string attached to the field, which could be documentation or some other important label. The tag-content cannot be used in normal programming, only the package reflect can access it.

IO, Json & XML

Mon, 01 Jan 0001 00:00:00 +0000

IO - Read & Write#

Read from user input#

var (
 firstName, lastName, s string
 i int
 f float32
 input = "56.12 / 5212 / Go"
 format = "%f / %d / %s"
)

func main() {
 fmt.Println("Please enter your full name: ")
 fmt.Scanln(&firstName, &lastName)
 // fmt.Scanf("%s %s", &firstName, &lastName)
 fmt.Printf("Hi %s %s!\n", firstName, lastName) // Hi Chris Naegels
 fmt.Sscanf(input, format, &f, &i, &s)
 fmt.Println("From the string we read: ", f, i, s)
 // ouwtput: From the string we read: 56.12 5212 Go
}

Read command-line argument#

func main() {
 who := "Harry "
 if len(os.Args) > 1 {
 who += strings.Join(os.Args[1:], " ")
 }
 fmt.Println("Good Morning", who)
}

Read from file#

Read by lines

func main() {
 inputFile, inputError := os.Open("hello.go")
 if inputError != nil {
 fmt.Printf("An error occurred on opening the inputfile\n" +
 "Does the file exist?\n" +
 "Have you got acces to it?\n")
 return // exit the function on error
 }
 defer inputFile.Close() // Close file before exits the main func
 inputReader := bufio.NewReader(inputFile)
 for {
 inputString, readerError := inputReader.ReadString('\n')
 if readerError == io.EOF {
 return
 }
 fmt.Printf("The input was: %s", inputString)
 }
}

NOTE: The End-of-line characters of text-files in Unix end on \n, but in Windows this is \r\n. By using the method ReadString or ReadBytes with \n as a delimiter you don’t have to worry about this.

Error handling

Mon, 01 Jan 0001 00:00:00 +0000

Error handling#

Go does not have an exception mechanism, like the try/catch in Java or .NET for instance: you cannot throw exceptions. Instead it has a defer-panic-and-recover mechanism.
The Go way to handle errors is for functions and methods to return an error object as their only or last return value—or nil if no error occurred—and for calling functions to always check the error they receive.
Handle the errors and return from the function in which the error occurred with an error message to the user: that way if something does go wrong, your program will continue to function and the user will be notified. The purpose of panic-and-recover is to deal with genuinely exceptional (so unexpected) problems and not with normal errors.

Goroutine & Channel - 1

Mon, 01 Jan 0001 00:00:00 +0000

Goroutine#

A goroutine is implemented as a function or method (this can also be an anonymous or lambda function) and called (invoked) with the keyword go. This starts the function running in parallel with the current computation but in the same address space and with its own stack.
Go’s concurrency primitives provide the basis for a good concurrency program design: expressing program structure so as to represent independently executing actions; so Go’s emphasis is not in the 1 st place on parallelism: concurrent programs may or may not be parallel. Parallelism is the ability to make things run quickly by using multiple processors. But it turns out most often that a well designed concurrent program also has excellent performing parallel capabilities.

Goroutine & Channel - 2

Mon, 01 Jan 0001 00:00:00 +0000

Channel directionality#

A channel type may be annotated to specify that it may only send or only receive

 var send_only chan<- int // channel can only receive data
 var recv_only <-chan int // channel can only send data

Receive-only channels ( <-chan T ) cannot be closed, because closing a channel is intended as a way for a sender to signal that no more values will be sent to the channel, so it has no meaning for receive-only channels.

Packaging

Mon, 01 Jan 0001 00:00:00 +0000

Package#

Package is a way to structure code: a program is constructed as a “package” (often abbreviated as pkg), which may use facilities from other packages. Every go-file belongs to one (and only one) package (like a library or namespace in other languages). Many different .go files can belong to one package, so the filename(s) and package name are generally not the same.
The package to which the code-file belongs must be indicated on the first line, e.g.: package main . A standalone executable belongs to package main. Each Go application contains one package called main. An application can consist of different packages, but even if you use only package main, you don’t have to stuff all code in 1 big file: you can make a number of smaller files each having package main as 1 st codeline. If you compile a source file with a package name other than main, like pack1, the object file is stored in pack1.a; a package name is written in lowercase letters.

Pitfalls

Mon, 01 Jan 0001 00:00:00 +0000

Shadowing#

Hiding (shadowing) a variable by misusing short declaration.

Such mistakes occur mostly inside the if-body or for-loop

var remember bool = false
 if something {
 remember := true // Wrong.
 }
// use remember

func shadow() (err error) {
 x, err := check1() // x is created; err is assigned to
 if err != nil {
 return // err correctly returned
 }

 if y, err := check2(x); err != nil { // y and inner err are created
 return // inner err shadows outer err so nil is wrongly returned!
 } else {
 fmt.Println(y)
 }
 return
}

Misusing strings#

String concatenations of the kind a += b are inefficient, especially when performed inside a loop.

Template

Mon, 01 Jan 0001 00:00:00 +0000

Template#

Package template implements data-driven templates for generating textual output.
Templates are executed by applying them to a data structure. Annotations in the template refer to elements of the data structure (typically a field of a struct or a key in a map) to control execution and derive values to be displayed. Execution of the template walks the structure and sets the cursor, represented by a period ‘.’ and called “dot”, to the value at the current location in the structure as execution proceeds.

Good practice - 1

Mon, 01 Jan 0001 00:00:00 +0000

Strings#

Change a character#

How to change a character in a string

str:="hello"
c:=[]byte(s)
c[0]=’c’
s2:= string(c) // s2 == "cello"

Substring#

How to take a part(substring) of a string str

substr := str[n:m]

for-loop#

How to loop over a string str with for or for-range:

// gives only the bytes:
for i:=0; i < len(str); i++ {
 … = str[i]
}
// gives the Unicode characters:
for ix, ch := range str {
 // …
}

bytes of str#

Number of bytes in a string str

Good practice - 2

Mon, 01 Jan 0001 00:00:00 +0000

Goroutines and channels#

Performance advice:

A rule of thumb if you use parallelism to gain efficiency over serial computation: the amount of work done inside goroutine has to be much higher than the costs associated with creating goroutines and sending data back and forth between them.

Using buffered channels#

Using buffered channels for performance:

A buffered channel can easily double its throughput, depending on the context the performance gain can be 10x or more. You can further try to optimize by adjusting the capacity of the channel.

Good practice - 3

Mon, 01 Jan 0001 00:00:00 +0000

Error#

How to stop a program when an error occurs:

if err != nil {
 fmt.Printf("Program stopping with error %v", err)
 os.Exit(1)
}
// OR :
if err != nil {
 panic("ERROR occurred: " + err.Error())
}

Performance best practices and advice#

Use the initializing declaration form := wherever possible (in functions).
Use bytes if possible instead of strings
Use slices instead of arrays.
Use arrays or slices instead of a map where possible (see ref. 15)
Use for range over a slice if you only need the value and not the index; this is slightly faster than having to do a slice lookup for every element.
When the array is sparse (containing many 0 or nil-values), using a map can result in lower memory consumption.
Specify an initial capacity for maps.
When defining methods: use a pointer to a type (struct) as a receiver.
Use constants or flags to extract constant values from the code.
Use caching whenever possible when large amounts of memory are being allocated.
Use template caching

Golang snippets

Mon, 01 Jan 0001 00:00:00 +0000

Convenient logging methods#

Stringer#

package main

import (
 "fmt"
)

// Animal has a Name and an Age to represent an animal.
type Animal struct {
 Name string
 Age uint
}

// String makes Animal satisfy the Stringer interface.
func (a Animal) String() string {
 return fmt.Sprintf("%v (%d)", a.Name, a.Age)
}

func main() {
 a := Animal{
 Name: "Gopher",
 Age: 2,
 }
 fmt.Println(a) // Gopher (2)
}

GoStringer#

package main

import (
 "fmt"
)

// Address has a City, State and a Country.
type Address struct {
 City string
 State string
 Country string
}

// Person has a Name, Age and Address.
type Person struct {
 Name string
 Age uint
 Addr *Address
}

// GoString makes Person satisfy the GoStringer interface.
// The return value is valid Go code that can be used to reproduce the Person struct.
func (p Person) GoString() string {
 if p.Addr != nil {
 return fmt.Sprintf(
 "Person{Name: %q, Age: %d, Addr: &Address{City: %q, State: %q, Country: %q}}", 
 p.Name, int(p.Age), p.Addr.City, p.Addr.State, p.Addr.Country)
 }
 return fmt.Sprintf("Person{Name: %q, Age: %d}", p.Name, int(p.Age))
}

func main() {
 p1 := Person{
 Name: "Warren",
 Age: 31,
 Addr: &Address{
 City: "Denver",
 State: "CO",
 Country: "U.S.A.",
 },
 }
 // If GoString() wasn't implemented, the output of `fmt.Printf("%#v", p1)` would be similar to
 // Person{Name:"Warren", Age:0x1f, Addr:(*main.Address)(0x10448240)}
 fmt.Printf("%#v\n", p1)

 p2 := Person{
 Name: "Theia",
 Age: 4,
 }
 // If GoString() wasn't implemented, the output of `fmt.Printf("%#v", p2)` would be similar to
 // Person{Name:"Theia", Age:0x4, Addr:(*main.Address)(nil)}
 fmt.Printf("%#v\n", p2)

}

// ----- Output ------
// Person{Name: "Warren", Age: 31, Addr: &Address{City: "Denver", State: "CO", Country: "U.S.A."}}
// Person{Name: "Theia", Age: 4}

File#

Read file#

func main() {
 file, err := os.Open("input.dat")

 if err != nil {
 fmt.Printf("An error occurred on opening the input file\n" +
 "Does the file exist?\n" +
 "Have you got acces to it?\n")
 return
 }
 defer file.Close()
 iReader := bufio.NewReader(file)
 for {
 str, err := iReader.ReadString('\n')
 if err != nil {
 return // error or EOF
 }
 fmt.Printf("The input was: %s", str)
 }
}

Read & Write with sliced buffer#

func cat(f *os.File) {
 const NBUF = 512
 var buf [NBUF]byte
 for {
 switch nr, er := f.Read(buf[:]); true {
 case nr < 0:
 fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", f, er)
 os.Exit(1)
 case nr == 0: // EOF
 return
 case nr > 0:
 if nw, ew := os.Stdout.Write(buf[0:nr]); nw != nr {
 fmt.Fprintf(os.Stderr, "cat: error writing from %s: %s\n", f, ew)
 }
 }
 }
}

TCP Client/Sever#

Client#

func main() {
 arguments := os.Args
 if len(arguments) == 1 {
 fmt.Println("Please provide host:port.")
 return
 }

 CONNECT := arguments[1]
 c, err := net.Dial("tcp", CONNECT)
 if err != nil {
 fmt.Println(err)
 return
 }

 for {
 reader := bufio.NewReader(os.Stdin)
 fmt.Print(">> ")
 text, _ := reader.ReadString('\n')
 fmt.Fprintf(c, text+"\n")

 message, _ := bufio.NewReader(c).ReadString('\n')
 fmt.Print("->: " + message)
 if strings.TrimSpace(string(text)) == "STOP" {
 fmt.Println("TCP client exiting...")
 return
 }
 }
}

Server#

func main() {
 arguments := os.Args
 if len(arguments) == 1 {
 fmt.Println("Please provide port number")
 return
 }

 PORT := ":" + arguments[1]
 l, err := net.Listen("tcp", PORT)
 if err != nil {
 fmt.Println(err)
 return
 }
 defer l.Close()

 c, err := l.Accept()
 if err != nil {
 fmt.Println(err)
 return
 }

 for {
 netData, err := bufio.NewReader(c).ReadString('\n')
 if err != nil {
 fmt.Println(err)
 return
 }
 if strings.TrimSpace(string(netData)) == "STOP" {
 fmt.Println("Exiting TCP server!")
 return
 }

 fmt.Print("-> ", string(netData))
 t := time.Now()
 myTime := t.Format(time.RFC3339) + "\n"
 c.Write([]byte(myTime))
 }
}