Default variable:
var i int // 0
var a, b, c bool // false
i int
Assign value:
// Short define variable with starting value
a := 1
b := a + 1
// Standard style for define variable
var x string
x = "Hello world"
// or
var x string = "Hello World"
var x = "Hello World"
// Define multiple vars
var (
a = 5
b = 10
c = 15
)
// Error: syntax error: unexpected string at end of statement
x string
x = "Hello world"
// Error: undefined: x
x = "Hello World"
** Define function with pararam input and return
func swap(x, y int) int {}
func swap(x, y string) (string, string) {}
func swap(x, y string) (z string) {}
func slip(x, y int) (a, b int) {} // a, b is defined in the top of function, and return nothing.
for
// using as while, for
for i <= 10 {}
for i; i <= 10; i++ {}
for key, value := range anArray {}
// _ means not use _ variable in for scope.
for _, value := range anArray {}
// like while
for true {}
if // the same other languages
switch ... case // without break at end of case.
** Arrays
var x [5]int
x[0] = 1
....
x := [5]int{1,2,3,4,5};
x := [5]int{
1,
2,
3,
4,
5, // the comma is required.
};
Slices // A slice is a segment of an array. Like arrays slices are indexable and have a length. Unlike arrays this length is allowed to change.
var x []int // create a slices with length is 0
// create a slice with length is 2
x := make([]int, 2)
// min length 5, max length 10
x := make([]float64, 5, 10)
x := []int{1,2,3,4,5};
// Get list value of x from 0 to 3
a := x[0:3];
Slice Functions: append, copy
slice1 := []int{1,2,3}
slice2 := append(slice1, 4, 5)
fmt.Println(slice1, slice2) // [1 2 3] [1 2 3 4 5]
slice1 := []int{1,2,3}
slice2 := make([]int, 2)
copy(slice2, slice1)
fmt.Println(slice1, slice2) // [1 2 3] [1 2]
// Error: first argument to append must be slice; have [3]int
slice1 := [3]int{1,2,3}
slice2 := append(slice1, 4, 5) // Error here
Maps: A map is an unordered collection of key-value pairs.
// Not initialize, can not use.
var x map[string]int
x := make(map[string]int)
x["key"] = 10
fmt.Println(x["key"], len(x)) // 10 1
// Get length of map
len(x)
// Delete an item in map
delete(x, "key");
// get element not in map.
fmt.Println(x["unknow"]) // 0
// Check element in map.
if name, ok := x["key"]; ok {
fmt.Println(name, ok)
}
// Short initilize map
elements := map[string]string{
"H": "Hydrogen",
"He": "Helium",
}
// Map in map
elements := map[string]map[string]string{
"H": map[string]string{
"name":"Hydrogen",
"state":"gas",
},
"He": map[string]string{
"name":"Helium",
"state":"gas",
},
}
** Functions
// params type and output type
func sum(a int, b int) int { return a + b}
// return multiple value
func sum(a int, b int) (int, int) { return (a + b), (a - b)}
// get results
x, y := sum(1, 2);
// Variadic Functions: dynamic input
func add(args ...int) int {}
fmt.Println(add(1,2,3))
// Closure
func main() {
add := func(x, y int) int {
return x + y
}
fmt.Println(add(1,1))
}
// return a function.
func makeEvenGenerator() func() uint {
i := uint(0)
return func() (ret uint) {
ret = i
i += 2
return
}
}
nextEven := makeEvenGenerator()
fmt.Println(nextEven()) // 0
fmt.Println(nextEven()) // 2
fmt.Println(nextEven()) // 4
// Recursion
func factorial(x uint) uint {
if x == 0 {
return 1
}
return x * factorial(x-1)
}
Defer, Panic & Recover
// make sure after complete function, do the other function begining with "defer" keyword
f, _ := os.Open(filename)
defer f.Close() // must close file after Open, but when we've done to use file.
** Pointers
func zero(xPtr *int) {
*xPtr = 0
}
zero(&x);
// Or
x := new(int); // create a pointer
zero(x);
** Structs and Interfaces
Structs
type Circle struct {
x float64
y float64
r float64
}
type Circle struct {
x, y, r float64
}
** Initialization
var c Circle
// Or
c := new(Circle)
// Or
c := Circle{x: 0, y: 0, r: 5}
// Or
c := Circle{0, 0, 5}
// Access fields
fmt.Println(c.x, c.y, c.r)
c.x = 10
c.y = 5
** Method
func (c Circle) area() float64 {
return math.Pi * c.r*c.r
}
c.area();
** Embedded type
type Person struct {
Name string
}
func (p *Person) Talk() {
fmt.Println("Hi, my name is", p.Name)
}
type Android struct {
Person // embedded Person into Android. That means Android is Person
Model string
}
a := new(Android)
a.Talk();
** Interfaces
type Shape interface {
area() float64
}
// using as an input
func totalArea(shapes ...Shape) float64 {
var area float64
for _, s := range shapes {
area += s.area()
}
return area
}
// As a field
type MultiShape struct {
shapes []Shape
}