每个Go程序都是由包组成的。
程序从main包开始运行。
本程序通过导入路径"fmt"和"math/rand" 来使用这两个包。
package main
import (
"fmt"
"math/rand"
)
func main() {
fmt.Println("My favorite number is", rand.Intn(10))
}
导入
此代码用圆括号组合了导入，这是“分组”形式的导入语句。
当然你可以编写多个导入语句，例如：
import "fmt"
import "math"
导出名
在Go中，如果一个名字以答谢字母开头，那么它就是已导出的。
函数
函数可以没有参数或接受多个参数。
注意，类型在变量名之后
package main
import "fmt"
func add(x,y int) {
return x + y
}
func main() {
fmt.Println(add(42, 13))
}
多值返回
函数可以返回任意数量的返回值
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("hello", "world")
fmt.Println(a, b)
}
命名返回值
package main
import "fmt"
func split(sum int) (x,y int) {
x = sum * 4 / 9
y = sum - x
return
}
变量
var语句用于声明一个变量列表，跟函数的参数类型一样，类型在后面
var语句可以出现在包或者函数级别
package main
import "fmt"
var c, python, java bool
func main() {
var i int
fmt.Println(i, c, python, java)
}
变量的初始化
变量声明可以包含初始值，每个变量对应一个。
如果初始值已存在，则可以忽略类型；变量会从初始值中获得类型。
package main
import "fmt"
var i, j int = 1, 2
func main() {
var c, python, java = true, false, "no!"
fmt.Println(i, j, c, python, java)
}
短变量声明
在函数中，简洁赋值语句:= 可在类型明确的地方代替var声明。
函数外的每个语句都必须以关键字开始（var 、func等等），因此 := 结构不能再函数外使用。
基本类型
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
rune // int32 的别名
// 表示一个Unicode码点
float32 float64
complex64 complex128
int / uint / uintptr 在32位系统上为32位宽，在64位系统上则为64位宽
零值
数字类型为 0
布尔类型为 false
字符串为 ""
类型转换
表达式T(v) 将值v 转换成类型T
Go 在不同类型之间需要 显式转换
var i int = 42
var f float64 = float64(i)
var u uint = uint(f)
// 更简单的方式
i := 42
f := float64(i)
u := uint(f)
类型退到
在声明一个类型而不指定其类型时（即使用不带类型的:=语法或var =表达式语法），变量的类型由右值退到得出。
当右值声明了类型是，新变量的类型与其相同
var i int
j := i // j 也是一个 int
不过当右边包含未指明类型的数值常量时，新变量的类型就有可能是 int, float64 或complex128了，这取决于常量的精度。
i := 42 // int
f := 3.142 // float64
g := 0.867 + 0.5i // complex128
常量
常量的声明与变量类似，只不过是使用const关键字。
常量可以是字符、字符串、布尔值或数值、
常量不能用 := 语法声明。
package main
import "fmt"
const Pi = 3.14
func main() {
const World = "世界"
fmt.Println("Hello", World)
fmt.Println("Happy", Pi, "Day")
const Truth = true
fmt.Println("Go Rules?", Truth)
}
数值常量
数值常量是高精度的值。
一个未指定类型的常量由上下文来决定其类型。
在尝试输出一下needInt(Big)吧。
（int 类型最大可以存储一个64位的整数，有时会更小。）
package main
import "fmt"
const (
Big = 1 << 100
Small = Big >> 99
)
func needInt(x int) int {return x * 10 + 1}
func needFloat(x float64) float64 {
return x * 0.1
}
func main() {
fmt.Println(needInt(small)) // 21
fmt.Println(needFloat(Small)) // 0.2
fmt.Println(needFloat(Big)) // 1.2676506002282295e+29
}