funcmain() { fmt.Println("My favorite number is", rand.Intn(10)) }
// My favorite number is 1
導入
使用 import 關鍵字導入包,可以使用圓括號或編寫多個導入語句。
1 2 3 4 5 6 7 8 9 10 11
package main
import"fmt" import"math"
funcmain() { fmt.Printf("Now you have %g problems.", math.Nextafter(2, 3)) }
// Now you have 2.0000000000000004 problems.
導出名
導入一個包之後,可以用其導出的名稱來調用它,並以大寫字母調用包的函式。
1 2 3 4 5 6 7 8 9 10 11 12
package main
import ( "fmt" "math" )
funcmain() { fmt.Println(math.Pi) }
// 3.141592653589793
函式
函式可以接收參數,型別放在參數名稱之後。
1 2 3 4 5 6 7 8 9 10 11 12 13
package main
import"fmt"
funcadd(x int, y int)int { return x + y }
funcmain() { fmt.Println(add(42, 13)) }
// 55
若函式的每一個參數皆為相同型別,可簡寫為:
1 2 3 4 5 6 7 8 9 10 11 12 13
package main
import"fmt"
funcadd(x, y int)int { return x + y }
funcmain() { fmt.Println(add(42, 13)) }
// 55
多值返回
函式可以返回一個以上的值。
1 2 3 4 5 6 7 8 9 10 11 12 13 14
package main
import"fmt"
funcswap(x, y string) (string, string) { return y, x }
funcmain() { a, b := swap("hello", "world") fmt.Println(a, b) }
// world hello
命名返回值
函式所返回的值可以像變數一樣命名,並直接使用 return 語句,將當前的值返回。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
package main
import"fmt"
funcsplit(sum int) (x, y int) { x = sum * 4 / 9 y = sum - x return }
funcmain() { fmt.Println(split(17)) }
// 7 10
變數
使用 var 關鍵字宣告變數,型別放在參數名稱之後。
1 2 3 4 5 6 7 8 9 10 11 12
package main
import"fmt"
var i int var c, python, java bool
funcmain() { fmt.Println(i, c, python, java) }
// 0 false false false
宣告變數時,可以包含初始值,型別可以被省略。
1 2 3 4 5 6 7 8 9 10 11 12
package main
import"fmt"
var i, j int = 1, 2 var c, python, java = true, false, "no!"
funcmain() { fmt.Println(i, j, c, python, java) }
// 1 2 true false no!
使用 := 賦值語句宣告變數,作為 var 關鍵字的簡寫。
1 2 3 4 5 6 7 8 9 10 11 12 13
package main
import"fmt"
funcmain() { var i, j int = 1, 2 k := 3 c, python, java := true, false, "no!"
fmt.Println(i, j, k, c, python, java) }
// 1 2 3 true false no!
型別
Go 的基本型別有 bool、string、int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64、uintptr、byte(uint8 的別名)、rune(int32 的別名)、float32、float64、complex64、complex128。