Install
https://stackoverflow.com/questions/12843063/install-go-with-brew-and-running-the-gotour
https://golang.org/doc/install#install
Test
cd $HOME/go/src/hello
go build
package main
import "fmt"
func main() {
fmt.Printf("hello, world\n")
}
./hello
Declaration
Basic
package main
import "fmt"
func main() {
var message string
var a, b, c int = 1, 2, 3
message = "Hello all"
fmt.Printf(message, a, b, c)
}
and more idiomatically:
package main
import "fmt"
func main() {
message := string
a, b, c := 1, 2, 3
message = "Hello all"
fmt.Printf(message, a, b, c)
}
Pointers
var greeting *string = &message fmt.Printf(message, greeting)
*string => pointer to a string
&message => use the memory location of the variable message
so this returns
Hello all%!(EXTRA *string=0xc42007a1c0)
whereas this:
fmt.Printf(message, *greeting)
returns the value. i.e.
Hello all%!(EXTRA string=Hello all)
Basic User Types
type Salutation string
or a more complex example:
type Salutation struct {
name string
greeting string
}
func main() {
var a = Salutation{name: “Bob”, greeting: “Hi” }
fmt.Println(s.greeting, s.name)
}
Getters / Setters and Scope
There are no Getters / Setters.
A capitalised variable is publicly visible from a package. E.g. Salutation.
Lowercase is not visible.
Constants
package main
import "fmt"
type Salutation struct {
name string
greeting string
}
const (
PI = 3.14
Language = "Go"
A = iota
B = iota
C = iota
)
func main() {
var s = Salutation{name: "Bob", greeting: "Hi" }
fmt.Println(s.greeting, s.name)
fmt.Println(PI, Language, A, B, C)
}
Outputs:
Hi Bob 3.14 Go 2 3 4
Note on iota. This is used in const delarations to increment numbers.
https://github.com/golang/go/wiki/Iota
A better example of using iotais probably this:
package main
import "fmt"
type Salutation struct {
name string
greeting string
}
const (
PI = 3.14
Language = "Go"
)
type Weekday int
const (
Sunday Weekday = iota + 1
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
)
func main() {
var s = Salutation{name: "Bob", greeting: "Hi" }
fmt.Println(s.greeting, s.name)
fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)
}
Note the implicit iotain the const for subsequent Weekdays.
Functions
- Multiple return values
- Use like any other type
- Function literals
Note: function literals aka lambdas or closures are functions without a name.
https://programming.guide/go/anonymous-function-literal-lambda-closure.html
E.g. of function declaration:
package main
import "fmt"
type Salutation struct {
name string
greeting string
}
func Greet(salutation Salutation) {
fmt.Println(salutation.greeting)
fmt.Println(salutation.name)
}
func main() {
var s = Salutation{name: "Bob", greeting: "Hi" }
Greet(s)
}
Order of type and variable name
Note the typecomes after the variable name (i.e. opposite to C).
E.g.
func add(x int, y int) int {
return x + y
}
This is different to C . For why see https://blog.golang.org/gos-declaration-syntax
Also, if function parameters share a type you can leave the type to the end.
E.g.
func add(x, y int) int {
return x + y
}
Multiple return values
E.g.
func swap(x, y string) (string, string) {
return y, x
}
Exported names
Names are exported if they begin with a capital letter.
i.e. Pi would be exported but pi would not.
Variable declarations
Multiple declarations:
var i, j int = 1, 2
Here k has an implicit type of int.
k := 3
Zero values:
0 for numeric
false for Boolean
"" for strings
Type conversions
E.g.
i := 42
f := float64(i)
u := uint(f)
REPL
Handy online REPL here: