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 }