Packages
每个 Go 程序都是由包组成的。
程序运行的入口是包 `main`。
这个程序使用并导入了包 "fmt" 和 `"math/rand"`。
按照惯例，包名与导入路径的最后一个目录一致。例如，`"math/rand"` 包由 package rand 语句开始。
注意： 这个程序的运行环境是固定的，因此 rand.Intn 总是会返回相同的数字。 （为了得到不同的数字，需要生成不同的种子数，参阅 rand.Seed。）
package main
import (
"fmt"
"math/rand"
)
func main() {
fmt.Println("My favorite number is", rand.Intn(10))
}
导入
这个代码用圆括号组合了导入，这是“factored”导入语句。同样可以编写多个导入语句，例如：
import "fmt" import "math"
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("Now you have %g problems.",
math.Nextafter(2, 3))
}
导出名
在导入了一个包之后，就可以用其导出的名称来调用它。
在 Go 中，首字母大写的名称是被导出的。
Foo 和 FOO 都是被导出的名称。名称 foo 是不会被导出的。
执行代码。然后将 math.pi 改名为 math.Pi 再试着执行一下。
package main
import (
"fmt"
"math"
)
func main() {
fmt.Println(math.pi)
}
函数
函数可以没有参数或接受多个参数。
在这个例子中，`add` 接受两个 int 类型的参数。
注意类型在变量名 _之后_。
（参考 这篇关于 Go 语法定义的文章了解类型以这种形式出现的原因。）
package main
import "fmt"
func add(x int, y int) int {
return x + y
}
func main() {
fmt.Println(add(42, 13))
}
函数（续）
当两个或多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他都可以省略。
在这个例子中 ，
x int, y int
被缩写为
x, y int
package main
import "fmt"
func add(x, y int) 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)
}
命名返回值
函数接受参数。在 Go 中，函数可以返回多个“结果参数”，而不仅仅是一个值。它们可以像变量那样命名和使用。
如果命名了返回值参数，一个没有参数的 return 语句，会将当前的值作为返回值返回。
package main
import "fmt"
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
func main() {
fmt.Println(split(17))
}
变量
var 语句定义了一个变量的列表；跟函数的参数列表一样，类型在后面。
package main
import "fmt"
var i int
var c, python, java bool
func main() {
fmt.Println(i, c, python, java)
}
初始化变量
变量定义可以包含初始值，每个变量对应一个。
如果初始化是使用表达式，则可以省略类型；变量从初始值中获得类型。
package main
import "fmt"
var i, j int = 1, 2
var c, python, java = true, false, "no!"
func main() {
fmt.Println(i, j, c, python, java)
}
短声明变量
在函数中，`:=` 简洁赋值语句在明确类型的地方，可以用于替代 var 定义。
函数外的每个语法块都必须以关键字开始（`var`、`func`、等等），`:=` 结构不能使用在函数外。
package main
import "fmt"
func main() {
var i, j int = 1, 2
k := 3
c, python, java := true, false, "no!"
fmt.Println(i, j, k, c, python, java)
}
基本类型
Go 的基本类型有Basic types
bool string int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr byte // uint8 的别名 rune // int32 的别名 // 代表一个Unicode码 float32 float64 complex64 complex128
package main
import (
"fmt"
"math/cmplx"
)
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
z complex128 = cmplx.Sqrt(-5 + 12i)
)
func main() {
const f = "%T(%v)
"
fmt.Printf(f, ToBe, ToBe)
fmt.Printf(f, MaxInt, MaxInt)
fmt.Printf(f, z, z)
}
类型转换
表达式 T(v) 将值 v 转换为类型 `T`。
一些关于数值的转换：
var i int = 42 var f float64 = float64(i) var u uint = uint(f)
或者，更加简单的形式：
i := 42 f := float64(i) u := uint(f)
与 C 不同的是 Go 的在不同类型之间的项目赋值时需要显式转换。 试着移除例子中float64 或 int 的转换看看会发生什么。
package main
import (
"fmt"
"math"
)
func main() {
var x, y int = 3, 4
var f float64 = math.Sqrt(float64(x*x + y*y))
var z int = int(f)
fmt.Println(x, y, z)
}
常量
常量的定义与变量类似，只不过使用 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) 吧。
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))
fmt.Println(needFloat(Small))
fmt.Println(needFloat(Big))
}