-
Go (Golang)
-
Compile and Execute
- go mod
- go run
- go build
-
Basics:
- hello.go
- packages.go
- imports.go
- exported-name.go
- functions.go
- multiple-results.go
- variables.go
- variables-with-initializers.go
- short-variable-declaration.go
- basic-types.go
- zero-value.go
- type-conversions.go
- type-inference.go
- constants.go
-
Flowcontrol:
- for.go
- for-continued.go
- while.go
- forever.go
- if.go
- if-with-a-short-declartion.go
- switch.go
- functions.go
- defer.go
- stacking.defers.go
- blank-indentifier.go
- for.go
- "Golang" is a nickname. "Go" is the official name.
- Designed at Google by Robert Griesemore, Rob Pike and Ken Thompson.
- Statically typed.
- Compiled
- Syntactically "similar" to C.
- Memory safety, garbage collection.
- Concurrency.
- "Go is the most pythonic language" By Guido van Rossum (Inventor of Python)
Multiple tools are coming with Go's installation. Here are just a couple of them that will be required to start to work with Go source code:
go mod init
The go mod init command creates a go.mod file to track your code's dependencies. Initially the file includes only the name of your module and the Go version your code supports. But as you add dependencies, the go.mod file will list the versions your code depends on.
C:\Users\aleescob\code\go\src\github.com\rabocse\go-intro-1\1-basics\0.0-hello
λ go mod init
go: creating new go.mod: module github.com/rabocse/go-intro-1/1-basics/0.0-hello
go: to add module requirements and sums:
go mod tidy
Notice that go.mod was created.
λ ls
go.mod hello.go
"Official doc: Create a Module"
"Youtube: Everything about Go Modules"
"Official doc: Modules Are On by Default"
go build
The go build command compiles and creates an executable file based on the specified source code.
C:\Users\aleescob\code\go\src\github.com\rabocse\go-intro-1\1-basics\0.0-hello
λ go build hello.go
λ ls
go.mod hello.exe* hello.go
Then, the created file can be executed.
λ .\hello.exe
Hello, World
go run
The go run command compiles and executes based on the specified source code.
C:\Users\aleescob\code\go\src\github.com\rabocse\go-intro-1\1-basics\0.0-hello
λ ls
go.mod hello.go
Unlike go build an executable is not created.
λ go run hello.go
Hello, World
hello.go
package main
import "fmt"
func main() {
fmt.Println("Hello, World")
}
packages.go
package main
import (
"fmt"
"math/rand"
)
func main() {
fmt.Println("My favorite number is", rand.Intn(10))
}
- A package is a collection of code that all does similar things like formatting strings or drawing images.
- The package clause gives the name of the package that this code will become a part of.
- The package main is required if this code is going to be run from terminal.
imports.go
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("Now you have %g problems. \n ", math.Sqrt(16))
}
- package name vs Import path.
- Example below shows that the import path reveals the directory path where "rand" package is located.
exported-name.go
package main
import (
"fmt"
"math"
)
func main() {
fmt.Println(math.Pi)
}
- Notice how all the first letters from the constants are capitalized in const.go.
- If changed to "pi" (instead of "Pi"), the constant would become unexported.
functions.go
package main
import (
"fmt"
)
func add(x int, y int) int {
return x + y
}
func main() {
fmt.Println(add(3, 15))
}
multiple-results.go
package main
import "fmt"
func calc(x int, y int) (a int, b string) {
a = x + y
if a > 0 {
b = "The result is a positive number"
return a, b
} else if a < 0 {
b = "The result is a negative number"
return a, b
} else {
b = "The result is zero"
return a, b
}
}
func main() {
total, info := calc(-5, 5)
fmt.Println("========================================")
fmt.Printf("The result was: %v \n", total)
fmt.Println("========================================")
fmt.Println(info)
}
-
The blank identifier could be used in case of wanting to ignore one return value:
total, _ := calc(-5, 5)
variables.go
package main
import "fmt"
// Variables are declared but not manually initialized (nothing was assigned)
var NumberOfApples int
var NumberOfOranges int
var tempKrakow float32
var tempLisbon float32
var carColor string
var wallColor string
var CiscoRocks bool
var KrakowRocks bool
func main() {
var NumberOfPears int
var tempBrussels float32
var bloodColor string
var LisbonRocks bool
fmt.Println("============= Apples and Oranges =============================")
fmt.Println(NumberOfApples)
fmt.Println(NumberOfOranges)
fmt.Println("============= Temp. Krakow and Lisbon =========================")
fmt.Println(tempKrakow)
fmt.Println(tempLisbon)
fmt.Println("============= Car and Wall Color =============================")
fmt.Println(carColor)
fmt.Println(wallColor)
fmt.Println("============= Do they rock ? ===================================")
fmt.Println(CiscoRocks)
fmt.Println(KrakowRocks)
fmt.Println("============= Fruit ===========================================")
fmt.Println(NumberOfPears)
fmt.Println("============= Temp ============================================")
fmt.Println(tempBrussels)
fmt.Println("============= Color ===========================================")
fmt.Println(bloodColor)
fmt.Println("============= Do they rock ? ===================================")
fmt.Print(LisbonRocks)
}
variable-with-initializers.go
package main
import "fmt"
// Variables are declared and initialized.
var NumberOfApples int = 5
var NumberOfOranges int = 10
var tempKrakow float32 = 32.5
var tempLisbon float32 = 25.7
var carColor string = "White"
var wallColor string = "Green"
var CiscoRocks bool = true
var KrakowRocks bool = false
func main() {
var NumberOfPears int = 7
var tempBrussels float32 = 21.3
var bloodColor string = "Red"
var LisbonRocks bool = false
fmt.Println("============= Apples and Oranges =============================")
fmt.Println(NumberOfApples)
fmt.Println(NumberOfOranges)
fmt.Println("============= Temp. Krakow and Lisbon ========================")
fmt.Println(tempKrakow)
fmt.Println(tempLisbon)
fmt.Println("============= Car and Wall Color =============================")
fmt.Println(carColor)
fmt.Println(wallColor)
fmt.Println("============= Cisco & Krakow. Do they rock ? =================")
fmt.Println(CiscoRocks)
fmt.Println(KrakowRocks)
fmt.Println("============= Pears ==========================================")
fmt.Println(NumberOfPears)
fmt.Println("============= Temp. Brussels ==================================")
fmt.Println(tempBrussels)
fmt.Println("============= Blood Color =====================================")
fmt.Println(bloodColor)
fmt.Println("============= Lisbon rocks ? ==================================")
fmt.Print(LisbonRocks)
}
zero-values.go
package main
import (
"fmt"
)
func main() {
var i int
var f float64
var b bool
var s string
fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
short-variable-declaration.go
package main
import "fmt"
// NumberOfCars := 2
func main() {
// short-declaration notation ( := ) is used instead of "var" keyword.
NumberOfApples := 5
NumberOfOranges := 10
tempKrakow := 32.5
tempLisbon := 25.7
carColor := "White"
wallColor := "Green"
CiscoRocks := true
KrakowRocks := false
NumberOfPears := 7
tempBrussels := 21.3
bloodColor := "Red"
LisbonRocks := false
fmt.Println("============= Apples and Oranges =============================")
fmt.Println(NumberOfApples)
fmt.Println(NumberOfOranges)
fmt.Println("============= Temp. Krakow and Lisbon ========================")
fmt.Println(tempKrakow)
fmt.Println(tempLisbon)
fmt.Println("============= Car and Wall Color =============================")
fmt.Println(carColor)
fmt.Println(wallColor)
fmt.Println("============= Cisco & Krakow. Do they rock ? =================")
fmt.Println(CiscoRocks)
fmt.Println(KrakowRocks)
fmt.Println("============= Pears ==========================================")
fmt.Println(NumberOfPears)
fmt.Println("============= Temp. Brussels ==================================")
fmt.Println(tempBrussels)
fmt.Println("============= Blood Color =====================================")
fmt.Println(bloodColor)
fmt.Println("============= Lisbon rocks ? ===================================")
fmt.Print(LisbonRocks)
}
type-inference.go
package main
import (
"fmt"
)
func main() {
value := 29 // change me !
fmt.Printf("The variable \"value\" is of type: %T \n", value)
}
basic-types.go
package main
import (
"fmt"
)
// Boolean
var summerRocks bool = true
var winterRocks bool = false
var (
// Integers (Signed Integers)
value1 int = 1990
value2 int8 = 127
value3 int16 = 1990
value4 int32 = 1990
value5 int64 = 1990
// Integers (Unsigned Integers)
value6 uint = 255
value7 uint8 = 255
value8 uint16 = 255
value9 uint32 = 255
value10 uint64 = 1<<64 - 1
value11 uintptr = 255
// Floats
value12 float32 = 37.5
value13 float64 = 37.5
// Byte and Rune are aliases for uint8 and int32 respectively.
value14 byte = 255
value15 rune = 'k'
// Complex numbers
value16 complex64 = 2 + 0.5i
value17 complex128 = 2 + 0.7i
)
func main() {
fmt.Println(" ")
fmt.Println("=============== Booleans =========================================")
fmt.Printf("VALUE: %v TYPE: %T \n", summerRocks, summerRocks)
fmt.Printf("VALUE: %v TYPE: %T \n", winterRocks, winterRocks)
fmt.Println(" ")
fmt.Println("=============== Integers (Signed Integers) =======================")
fmt.Printf("VALUE: %v TYPE: %T \n", value1, value1)
fmt.Printf("VALUE: %v TYPE: %T \n", value2, value2)
fmt.Printf("VALUE: %v TYPE: %T \n", value3, value3)
fmt.Printf("VALUE: %v TYPE: %T \n", value4, value4)
fmt.Printf("VALUE: %v TYPE: %T \n", value5, value5)
fmt.Println(" ")
fmt.Println("============== Integers (Unsigned Integers ) ======================")
fmt.Printf("VALUE: %v TYPE: %T \n", value6, value6)
fmt.Printf("VALUE: %v TYPE: %T \n", value7, value7)
fmt.Printf("VALUE: %v TYPE: %T \n", value8, value8)
fmt.Printf("VALUE: %v TYPE: %T \n", value9, value9)
fmt.Printf("VALUE: %v TYPE: %T \n", value10, value10)
fmt.Printf("VALUE: %v TYPE: %T \n", value11, value11)
fmt.Println(" ")
fmt.Println("============== Floats ==============================================")
fmt.Printf("VALUE: %v TYPE: %T \n", value12, value12)
fmt.Printf("VALUE: %v TYPE: %T \n", value13, value13)
fmt.Println(" ")
fmt.Println("============== Byte and Rune =======================================")
fmt.Printf("VALUE: %v TYPE: %T \n", value14, value14)
fmt.Printf("VALUE: %v TYPE: %T \n", value15, value15)
fmt.Println(" ")
fmt.Println("============== Complex Numbers =====================================")
fmt.Printf("VALUE: %v TYPE: %T \n", value16, value16)
fmt.Printf("VALUE: %v TYPE: %T \n", value17, value17)
}
type-conversions.go
package main
import (
"fmt"
)
func main() {
var value1 int = 150
var value2 int = 30
var value3 float32 = 30.5
result1 := value1 + value2
result2 := float32(value1) + value3 // Remove the conversion for value3 and the program will not compile.
fmt.Println(result1)
fmt.Println(result2)
}
constants.go
package main
import "fmt"
func main() {
const myAge = 31
const Pi = 3.14
const ciscoRocks = true
fmt.Printf("I am %v years old\n", myAge)
fmt.Printf("This is the value of Pi: %v\n", Pi)
fmt.Println("Cisco rocks ?", ciscoRocks)
}
for.go
package main
import "fmt"
func main() {
fmt.Println("=============== COUNT ===========================")
sum := 0
for number := 0; number < 10; number++ {
fmt.Println(number)
sum = sum + number // sum += number
}
fmt.Println("=============== SUM ============================")
fmt.Println(sum)
}
For Structure:
for INIT ; CONDITION; POST
-
INIT: Executed before the first iteration
-
CONDITION: Evaluated before every iteration
-
POST: Executed at the end of every iteration
Inside the loop:
- sum = 0 + 1
- sum = 1 + 2
- sum = 3 + 3
- sum = 6 + 4
- sum = 10 + 5
- sum = 15 + 6
- sum = 21 + 7
- sum = 28 + 8
- sum = 36 + 9
- sum = 45
for-continued.go - More about the "for" loop
package main
import "fmt"
func main() {
fmt.Println("======================= LOOPING... ===========================")
sum := 1
for sum < 10 {
sum += sum // sum = sum + sum
fmt.Println(sum)
}
fmt.Println("======================= TOTAL =================================")
fmt.Println(sum)
}
Inside the loop:
- sum = 1 + 1 = 2
- sum = 2 + 2 = 4
- sum = 4 + 4 = 8
- sum = 8 + 8 = 16
while.go - There is no "while" keyword in Go !
package main
import "fmt"
func main() {
sum := 1
for sum < 10 { // "while" sum < 10, then ...
sum += sum
}
fmt.Println(sum)
}
forever.go
package main
import "fmt"
func main() {
for {
fmt.Println("Looping forever ... !!! XD ")
}
}
if.go
package main
import (
"fmt"
)
func main() {
num := 0
if num < 0 {
fmt.Println("It is a negative number")
} else if num > 0 {
fmt.Println("it is a positive number")
} else {
fmt.Println("The number is zero !")
}
}
if-with-a-short-declaration.go
package main
import "fmt"
// printB4 returns a "delimiter string" ( =================================== )
func printB4() string {
y := "=========================="
return y
}
func main() {
var num int = 50 // Change the value to play with the condition num > 100
if delimiter := printB4(); num > 100 {
fmt.Println(delimiter) // Only reason why we can print "delimiter" is because is executed before the condition (x > 100). In other words, it does not depend on it.
fmt.Println("Condition was \"TRUE\"")
} else {
fmt.Println(delimiter)
fmt.Println("Condition was \"FALSE\"")
}
// fmt.Println(delimiter) // Variables declared by the statement are only in scope until the end of the if.
}
switch.go
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println(" ")
fmt.Println("============================= 1- Switch ==================================")
// Switch case
num := 1
fmt.Print("Write ", num, " as ")
switch num {
case 1:
fmt.Println("\"one\"")
case 2:
fmt.Println("\"two\"")
case 3:
fmt.Println("three")
}
fmt.Println(" ")
fmt.Println("================= 2.1- Switch with no condition =======================")
// Switch with no condition = switch true
number := 500
switch true {
case number < 100:
fmt.Println("The number is less than 100")
case number > 100:
fmt.Println("The number is higher than 100")
default:
fmt.Println("The number is 100")
}
fmt.Println(" ")
fmt.Println("=========== 2.2- Switch with no condition =============================")
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("Good morning!")
case t.Hour() < 17:
fmt.Println("Good afternoon.")
default:
fmt.Println("Good evening.")
}
}
functions.go
package main
import (
"fmt"
)
// 1- Function with return.
func double(x float32) float32 {
return x * 2
}
// 2- Function without return.
func doublePrint(x float32) {
fmt.Println(x * 2)
}
// 3- Func with two arguments and one return
func sum(a float32, b float32) float32 {
return a + b
}
// 4- func with two arguments and no return
func sub(a float32, b float32) {
fmt.Println(a - b)
}
func main() {
fmt.Println("============================ 1- double ============================")
y := double(3.5)
fmt.Println(y)
fmt.Println("============================ 2- doublePrint ======================")
doublePrint(10)
fmt.Println("============================ 3- sum ==============================")
totalSum := sum(35, 67)
fmt.Println(totalSum)
fmt.Println("============================ 4- sub ==============================")
sub(100, 10)
}
function-with_mult-return.go
package main
import "fmt"
func display(a float32, b float32) (c, d float32) {
item1 := a
item2 := b
return item1, item2
}
func main() {
fmt.Println("============ Getting both results ====================")
fmt.Println(" ")
result1, result2 := display(29, 31)
fmt.Println(result1)
fmt.Println(result2)
fmt.Println("============ Ignoring one result ====================")
fmt.Println(" ")
result3, _ := display(37, 75)
fmt.Println(result3)
// fmt.Println(result4)
}
defer.go
package main
import "fmt"
func main() {
defer fmt.Println("World")
fmt.Println("Hello")
}
stacking_defers.go
package main
import "fmt"
func main() {
fmt.Println("Counting...")
for num := 1; num < 10; num++ {
defer fmt.Println(num)
}
fmt.Println("Done")
}
blank-Identifier.go
package main
import "fmt"
func display(a float32, b float32) (c, d float32) {
item1 := a
item2 := b
return item1, item2
}
func main() {
fmt.Println("============ Getting both results ====================")
fmt.Println(" ")
result1, result2 := display(29, 31)
fmt.Println(result1)
fmt.Println(result2)
fmt.Println("============ Ignoring one result ====================")
fmt.Println(" ")
result3, _ := display(37, 75)
fmt.Println(result3)
// fmt.Println(result4)
//
}