包，变量和函数

包

每个 Go 程序都是由包构成的。

按照约定，包名与导入路径的最后一个元素一致。例如，"math/rand" 包中的源码均以 package rand 语句开始。

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	fmt.Println("My favorite number is", rand.Intn(1))
}

导入

import (
	"fmt"
	"math"
)

圆括号组合了导入，这是“分组”形式的导入语句。

当然你也可以编写多个导入语句，例如：

import "fmt"
import "math"

不过使用分组导入语句是更好的形式。

导出名

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。

在导入一个包时，你只能引用其中已导出的名字。任何“未导出”的名字在该包外均无法访问。

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(math.Pi)
}

例如：math.pi, p 是小写，是 "未导出" 的，因此你无法访问

函数

函数可以没有参数或接受多个参数。

在本例中，add 接受两个 int 类型的参数。

注意类型在变量名之后。

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))
}

多值返回

函数可以返回任意数量的返回值。

swap 函数返回了两个字符串。

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 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。

就像在这个例子中看到的一样，var 语句可以出现在包或函数级别。

package main

import "fmt"

var c, python, java bool

func main() {
	var i int
	fmt.Println(i, c, python, java)
}

变量初始化

变量声明可以包含初始值，每个变量对应一个。

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。

var i, j int = 1, 2

var c, python, java = true, false, "no!"

短变量声明

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

函数外的每个语句都必须以关键字开始（var, func 等等），因此 := 结构不能在函数外使用。

var i, j int = 1, 2
k := 3
c, python, java := true, false, "no!"

基本类型

Go 的基本类型有

bool (1byte)
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte （uint8 的别名）
rune （int32 的别名，表示一个 Unicode 码点）
float32 float64 （单精度，双精度）
complex64 complex128 （复数）

32 位实数和 32 位虚数，64 位实数和 64 位虚数（其中实数和虚数都是浮点数）

本例展示了几种类型的变量。同导入语句一样，变量声明也可以“分组”成一个语法块。

int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型

字符和串

字符串是一串固定长度的字符连接起来的字符序列。golang 没有专门的存储字符类型，如果要存储单个字符，用 byte 来保存。go 的字符串是由单个字节连接起来的，它与传统的字符串是由字符组成的不同。

package main

import (
    "fmt"
)

func main() {
    var c1 byte = 'a'
    fmt.Println(c1)
}

当我们直接输出字符 c1,，得到的是它的 ascII 值：97。要用格式化输出：fmt.Printf("%c",c1)。而当我们要存储中文时，此时不能够用 byte 类型了，即 ASCII 值大于 255 时，会显示溢出，我们要用 int 来存储：

TIP

格式化输出代表含义：

%d：输出整型
%f：输出浮点型
%c：输出字符型
%v：输出原变量值
%T：输出变量的数据类型
%t：输出布尔值
%q：输出带双引号的字符串

字符类型使用细节：

字符常量使用单引号括起来的单个字符；
go 中允许使用转义字符''来将其后的字符转变为特殊字符型常量，例如 var c int = '\n'；
字符使用 utf-8 编码；
go 中，字符的本质是一个整数，直接输出时，会输出它对应的 UTF-8 编码的值；
可以直接给变量赋予某个数字，然后格式化输出%c，会输出该数字对应的 unicode 字符；
字符类型是可以进行运算的，相当于一个整数，因为它都对应 unicode 码；

字符串的使用细节：

go 语言的字符串的字节使用 utf-8 编码；
与 python 一样，一旦字符串赋值了，就不能被更改；
两种表示形式
1. 双引号，会识别转义字符；　　2. 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击，输出源代码等

package main

import (
    "fmt"
)

func main() {
    var c = "abc\nabc"
    var d = `abc\nabc`
    fmt.Println(c)
    fmt.Println(d)
}

字符串的拼接，当我们要拼接多行字符串时，要将加号留在每行末尾：（注意单个字符进行拼接是指对 unicode 值进行相加）

零值

没有明确初始值的变量声明会被赋予它们的零值。

零值是：

数值类型为 0，布尔类型为 false，字符串为 ""（空字符串）。

类型转换

表达式 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 或 uint 的转换看看会发生什么。

类型推导

在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 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 关键字。

常量可以是字符、字符串、布尔值或数值。

常量不能用 := 语法声明。

const Pi = 3.14

数值常量

数值常量是高精度的值。

一个未指定类型的常量由上下文来决定其类型。

（int 类型最大可以存储一个 64 位的整数，有时会更小。）

（int 可以存放最大 64 位的整数，根据平台不同有时会更少。）

package main

import "fmt"

const (
	// 将 1 左移 100 位来创建一个非常大的数字
	// 即这个数的二进制是 1 后面跟着 100 个 0
	Big = 1 << 100
	// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2
	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))
}

补充：符号

运算符：基本与 c 的符号一样，除了自增减符号(++)

Go 中的自增减不是一种表达式，而是语句，这意味着它不能被写到其它语句里

即：

cnt := 0

a := ++ cnt //错误

cnt ++ // 正确
a := cnt

WARNING

++ cnt 的写法也是错误的，++只能写在右边

# 包，变量和函数

# 包

# 导入

# 导出名

# 函数

# 多值返回

# 命名返回值

# 变量

# 变量初始化

# 短变量声明

# 基本类型

# 字符和串

# 零值

# 类型转换

# 类型推导

# 常量

# 数值常量

# 补充：符号