Go Language learning repository
(c) Cleuton Sampaio 2018
To modularize a source code is to divide it into different abstraction layers. We have a higher level layer and one or more lower level layers, containing functions or classes.
A function may or may not take arguments and may or may not return a value. Non-returning value functions are known as side-effect functions because they change the program’s state.
func delta(a float64, b float64, c float64) float64 {
return math.Pow(float64(b), 2) - 4*a*c
}
The delta function takes 3 float arguments (float64) and returns a float value (float64). It can be invoked like this:
vDelta := delta(coefA, coefB, coefC)
Sample function.go demonstrates the use of functions:
package main
import (
"fmt"
"log"
"math"
"os"
"strconv"
)
func delta(a float64, b float64, c float64) float64 {
return math.Pow(float64(b), 2) - 4*a*c
}
func readFromArgs(a []string, p int) float64 {
f, err := strconv.ParseFloat(a[p], 64)
if err != nil {
log.Fatal(err)
}
return f
}
func main() {
clArguments := os.Args[1:] // We got command line arguments
coefA := readFromArgs(clArguments, 0)
coefB := readFromArgs(clArguments, 1)
coefC := readFromArgs(clArguments, 2)
vDelta := delta(coefA, coefB, coefC)
fmt.Println(vDelta)
}
Reading command line arguments
We use the os package to read command line arguments. The readFromArgs() function does it:
clArguments := os.Args[1:]
...
f, err := strconv.ParseFloat(a[p], 64)
The strconv object converts data to strings and vice versa. The ParseFloat method converts strings to floats, and we can specify the precision, in this case 64 bits. We get from the os.Args[] vector a slice from the second position (os.Args [1:]), to avoid taking the program name, which is always the first argument. Going forward, we will have a slice starting at zero, with each argument passed after the program name.
Another interesting thing to note is the exponentiation, provided by the Pow() method of the math object. This method requires the variables to be float64 and that is why I am using this data type.
Error Handling
Go do not use SEH (Structured Exception Handling) as in C ++, Java or Python (try). We simply test if there were any errors in the function. And functions can return multiple values, for example:
func f() (int, int) {
return 1, 2
}
...
a, b := f()
Some functions also return errors. Here’s how I test the string to float conversion error:
f, err := strconv.ParseFloat(a[p], 64)
if err != nil {
log.Fatal(err)
}
Method ParseFloat() has the signature:
func ParseFloat(s string, bitSize int) (float64, error)
Therefore, it may return an error. I can test if the error is nil, (ie null). However, if there is an error, I use the log method Fatal() which displays the message and paralyzes execution.
To execute the sample code:
go run function.go 1 -5 6
However, to run this code, you will need to have Go installed, as [MyCompiler] (https://www.mycompiler.io/) does not allow us to pass command line arguments.
[Installing Go] (https://golang.org/doc/install) is very simple. Do it according to your operating system. Here, I am using Ubuntu:
Download the [package] (https://golang.org/dl/) and extract it into /usr/local, create a tree in /usr/local/go. For example:
tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz
Choose the appropriate package for your installation. For example, if you are installing Go 1.2.1, for Linux x86 64-bit, the package is go1.2.1.linux-amd64.tar.gz.
(These commands must be executed with sudo)
Add /usr/local/go/bin to the PATH environment variable.
If you use Windows or MacOS [see instructions] (https://golang.org/doc/install).
Open a terminal and execute Go:
go
...
$ go
Go is a tool for managing Go source code.
Usage:
go <command> [arguments]
The commands are:
bug start a bug report
build compile packages and dependencies
clean remove object files and cached files
doc show documentation for package or symbol
env print Go environment information
fix update packages to use new APIs
fmt gofmt (reformat) package sources
generate generate Go files by processing source
get add dependencies to current module and install them
install compile and install packages and dependencies
list list packages or modules
mod module maintenance
run compile and run Go program
test test packages
tool run specified go tool
version print Go version
vet report likely mistakes in packages
Use "go help <command>" for more information about a command.
Additional help topics:
buildmode build modes
c calling between Go and C
cache build and test caching
environment environment variables
filetype file types
go.mod the go.mod file
gopath GOPATH environment variable
gopath-get legacy GOPATH go get
goproxy module proxy protocol
importpath import path syntax
modules modules, module versions, and more
module-get module-aware go get
module-auth module authentication using go.sum
module-private module configuration for non-public modules
packages package lists and patterns
testflag testing flags
testfunc testing functions
Use "go help <topic>" for more information about that topic.
The two basic options are: build
and run
. To run the example code, [function.go] (./code/function.go), open the folder in a terminal and type:
go run function.go 1 -5 6
...
1
Complete the program by creating a function that calculates the roots of the quadratic equation. Remember that the delta value is crucial to this!
Tip: Use math.Inf to return infinity (if you know how to solve quadratic equations, you know this could happen)