Features of Golang:
- Compiled language. So, you can measure performance and do memory profile. It generates machine code that will run on the processor.
- Garbage collected. Usually system level langauges are not garbage collected, but Go is. Also note that, Go garbage collector is latency free. So, garbage collector runs without any speed bumps.
- Language level support for concurrency strategy known as communicating sequential processes aka Actor model.
- It’s not a C derivative language. It’s a static language but with the ease of dynamic language
Interesting notes
- Like Swift playground in Xcode, you can try out go code in https://play.golang.org/
- Go doesn’t have method overloading.
- Function name starts with Uppercase are going to be exported (public)
- Go packages can be directly imported from URL inside code
- You can’t write curly braces in separate line, like C#. Yey!
Installation
Install Go and make sure to define GOROOT and GOPATH
export GOROOT="/usr/local/go" export GOPATH="/Users/USERNAME/GoWorkspace/"
First Program
package main
import (
"fmt"
)
func main() {
fmt.Println("Hello, playground")
}
#1. package declaration is required and it is called module. “main” package denotes entry point
#7. You have to maintain the signature
func main() {
}
as it is the execution point
To run,
go run main.go
To build and make executable file,
go build main.go
Variable
package main
import "fmt"
func main() {
// declare multiple variable
var a, b int
// initialize multiple variable
var c, d int = 1, 2
// omit data type
var e, f = 4, 5
// infer type
var g, h = 6, false
// declare and init together
message := "Hello"
// by default, un-initialized value is 0
fmt.Println(a, b, c, d, e, f, g, h, message)
}
/*
Output:
0 0 1 2 4 5 6 false Hello
*/
Constant
package main
import (
"fmt"
)
const (
FIRST_CONSTANT = "Hello"
)
var (
globalVar = 5
)
func main() {
fmt.Println(FIRST_CONSTANT)
fmt.Println(globalVar)
}
/*
Output
Hello
5
*/
Init function
If you write init function it will run the first time the module is referenced. It will run before the main function and after all the instance variable is initialized.
package main
import (
"fmt"
)
var (
globalVar = 5
)
func init() {
globalVar = 6
}
func main() {
fmt.Println(globalVar)
}
/*
Output
6
*/
Unused imports
Unused imports will give you error. For example, if you declare “fmt” package but do not use it, you will get error,
package main
import (
"fmt"
)
var (
globalVar = 5
)
func main() {
println(globalVar)
}
// tmp/sandbox540429761/main.go:4: imported and not used: "fmt"
Installation
Download and install Go from here, https://golang.org/
Update your .bash_profile in MacOS or .bash_rc in Linux
export GOROOT="/usr/local/go/bin/go" export GOPATH="/Users/<username>/GoWorkspace" export PATH=$PATH:$GOROOT
Install Sublime and then Sublime package control,
https://packagecontrol.io/installation
Install GoSublime
https://github.com/DisposaBoy/GoSublime
Verify installation
Create a file named main.go
package main
func main() {
println("Hello Go")
}
Open terminal and go to the file directory and run
~$ go run main.go Hello Go
Data types
package main
func main() {
var anInt int = 5
// witout the . (dot) value will be inferred as int
var aFloat float32 = 3.
// shorthand to declare and initialize
aString := "Hello there"
println(anInt)
println(aFloat)
println(aString)
}
Constants again
package main
const (
first = iota // auto incrementing number
second
third
)
func main() {
println(first)
println(second)
println(third)
}
/*
0
1
2
*/
package main
const (
first = 1 << iota
second
third
)
func main() {
println(first)
println(second)
println(third)
}
/*
1
2
4
*/
Collections: Array
package main
import (
"fmt"
)
func main() {
anArray := [...]int{3, 6, 9, 12}
fmt.Println(anArray)
fmt.Println(len(anArray))
}
/*
[3 6 9 12]
4
*/
Collections: Slice
package main
import (
"fmt"
)
func main() {
anArray := [...]int{3, 6, 9, 12}
aSlice := anArray[:] // all elements
aSlice = anArray[1:] // except first element
aSlice = append(aSlice, 15) // appending 15
fmt.Println(aSlice)
fmt.Println(len(aSlice))
newSlice := []float32{1., 2., 3.}
fmt.Println(newSlice)
anotherSlice := make([]int, 20)
anotherSlice[0] = 5
anotherSlice[1] = 10
fmt.Println(anotherSlice)
}
/*
[6 9 12 15]
4
[1 2 3]
[5 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
*/
Loop
package main
func main() {
for i := 0; i < 5; i++ { } hello := 0 for { hello++ if hello > 5 {
break
}
}
list := []string{"hello", "world", "go"}
for index, value := range list {
println(index, value)
}
}
Functions
package main
func main() {
param := "Hello there"
helloGo(¶m)
println(param)
}
func helloGo(param *string) {
*param = "Hello Go"
}
func helloGo2(params ...string) {
// variable argument function aka variadic parameter
}
Multiple return values
package main
func main() {
result := add(1, 2, 3, 4)
println(result)
a, b := andAndLen(1, 2, 3, 4)
println(a, b)
len, sum := andAndLen2(1, 2, 3, 4)
println(len, sum)
}
func add(nums ...int) int {
ret := 0
for _, num := range nums {
ret += num
}
return ret
}
func andAndLen(nums ...int) (int, int) {
ret := 0
for _, num := range nums {
ret += num
}
return len(nums), ret
}
func andAndLen2(nums ...int) (length int, sum int) {
for _, num := range nums {
sum += num
}
length = len(nums)
return
}
Struct
package main
import (
"fmt"
)
func main() {
aVar := aStruct{}
aVar.aField = "hello"
anotherVar := aStruct{"hi"}
println(anotherVar.aField)
// creates the object in heap
yetAnotherVar := new(aStruct)
yetAnotherVar.aField = "hola"
fmt.Println(aVar)
}
type aStruct struct {
aField string
}
/*
hi
{hello}
*/
Constructor
package main
import (
"fmt"
)
func main() {
aVar := newAStruct()
aVar.aMap["foo"] = "bar"
fmt.Println(aVar)
}
type aStruct struct {
aMap map[string]string
}
func newAStruct() *aStruct {
ret := aStruct{}
ret.aMap = map[string]string{}
return &ret
}
Method
package main
func main() {
mp := msgPrinter{"foo"}
mp.printMsg()
}
type msgPrinter struct {
msg string
}
func (mp *msgPrinter) printMsg() {
println(mp.msg)
}
Go routine
package main
import (
"runtime"
"time"
)
func main() {
runtime.GOMAXPROCS(4)
go printMsg()
println("after all print")
time.Sleep(100 * time.Millisecond)
}
func printMsg() {
for i := byte('a'); i <= byte('z'); i++ {
go println(string(i))
}
}
Advertisements
