Go 基础语法
目录
导包
示例：工程结构如下
GOPATH 设置为工程根目录（E:\GO_PROJECT）
test1.go：
package package_test
import "fmt"
/*
定义函数
*/
func Func1（） {
fmt.Println（"test1 func1"）
}
test2.go：
package package_test
import "fmt"
func Func2（） {
fmt.Println（"test2 func2"）
}
testmain.go：
package main
import "dir1/dir2" // 导入的是【目录名】
func main（） {
package_test.Func1（） // 调用的是【包名】
}
运行：
// 方式一
go bulid testmain.go // 编译（生成可执行文件）
./ testmain // 运行（可执行文件）
//方式二
go run testmain.go // 编译+运行
导包结论：
- 一个 GO 程序中一定要有 main 包和 main 函数，这是 GO 程序执行的入口。
- 编译器会根据指定的相对路径去搜索包然后导入，这个相对路径是从 GOROOT 或 GOPATH（workspace）下的 src 下开始搜索：
- GOROOT
- 项目 GOPATH
- 全局 GOPATH
- Golang 和 Java 的区别是，在 GO 中 import 的是目录，而不是包名；并且 GO 没有强制要求包名和目录名需要一致，即包和目录是两个不同的概念。
import 导入的是源文件所在的目录名，而不是定义的包名。在代码中引用包内的成员时，使用定义的包名而不是目录名。- 在习惯上将包名和目录名保证一致，但这并不是强制规定。
在同一级目录中，所有源文件只能使用相同的包名。同一包名下的变量名、函数名等不能重复。- 多个目录下的相同包名，彼此无关。
- 包中的成员（如函数）以名称⾸字母⼤⼩写，决定其访问权限：
- ⾸字母⼤写，可被包外访问（即
public） - ⾸字母⼩写，仅包内成员可以访问（即
private）
- ⾸字母⼤写，可被包外访问（即
工程管理
为了更好的管理项目中的文件，GO 要求将文件都要放在相应的目录中，具体规定了以下目录：
src 目录：以代码包的形式组织并保存 GO 源码文件（比如 .go 文件、.c 文件、.h 文件、.s 文件等）pkg 目录：用于存放经由 go install 命令构建安装后的代码包（包含 GO 库源码文件）的 ".a" 归档文件。bin 目录：与 pkg 目录类似，在通过 go install 命令完成安装后，保存由 GO 命令源码文件生成的可执行文件。
以上目录称为工作区（Workspace），工作区其实就是一个对应于特定工程的目录。
src 目录用于包含所有的源代码，是 GO 命令行工具一个强制的规则；而 pkg 和 bin 则无需手动创建，GO 命令行工具在构建过程中会自动创建这些目录。
变量
变量声明
- 变量名必须以字母或下划线开头，后面可以跟任意数量的字母、数字或下划线。
- 变量的三种声明&初始化方式如下：
// 方式一：先声明（有默认值），后赋值
var a int
a = 10
var b, c string
b = "b"
c = "c"
// 方式二：声明+赋值
var a int = 10
// 方式三：自动推导类型（注意：这种方式只能在函数内使用）
a := 10
b, c := 11, 12
b, c = c, b // 值交换
// 匿名变量
_, i, _, j = 1, 2, 3, 4
格式化输出
| 格式 | 含义 |
|---|---|
| %% | 一个 % 字面量 |
| %b | 一个二进制整数值（基数为 2），或者是一个（高级的）用科学计数法表示的指数为 2 的浮点数 |
| %c | 字符型。可以把输入的数字按照 ASCII 码相应转换为对应的字符 |
| %d | 一个十进制数值（基数为 10） |
| %f | 以标准记数法表示的浮点数或者复数值 |
| %o | 一个以八进制表示的数字（基数为8） |
| %p | 以十六进制（基数为 16）表示的一个值的地址，前缀为 0x,字母使用小写的 a-f 表示 |
| %q | 使用 GO 语法以及必须时使用转义，以双引号括起来的字符串或者字节切片 []byte，或者是以单引号括起来的数字 |
| %s | 字符串。输出字符串中的字符直至字符串中的空字符（字符串以 '\0' 结尾，这个 '\0' 即空字符） |
| %t | 以 true 或者 false 输出的布尔值 |
| %T | 使用 GO 语法输出的值的类型 |
| %x | 以十六进制表示的整型值（基数为十六），数字 a-f 使用小写表示 |
| %X | 以十六进制表示的整型值（基数为十六），数字 A-F 使用小写表示 |
基本数据类型
| 类型 | 名称 | 长度 | 零值（默认值） | 说明 |
|---|---|---|---|---|
| bool | 布尔类型 | 1 | false | 其值不为真即为假，不可以用数字代表 true 或 false |
| byte | 字节型 | 1 | 0 | uint8 的别名 |
| int, uint | 整型 | - | 0 | 有符号 32 位或无符号 64 位 |
| int8 | 整型 | 1 | 0 | -128 ~ 127 |
| uint8 | 整型 | 1 | 0 | 0 ~ 255 |
| int16 | 整型 | 2 | 0 | -32768 ~ 32767 |
| uint16 | 整型 | 2 | 0 | 0 ~ 65535 |
| int32 | 整型 | 4 | 0 | -2147483648 到 2147483647 |
| rune | 整型 | 4 | 0 | int32 的别名 |
| uint32 | 整型 | 4 | 0 | 0 到 4294967295（42 亿） |
| int64 | 整型 | 8 | 0 | -9223372036854775808到 92233720368547758070 |
| uint64 | 整型 | 8 | 0 | 到 18446744073709551615（1844 京） |
| float32 | 浮点型 | 4 | 0.0 | 小数位精确到 7 位 |
| float64 | 浮点型 | 8 | 0.0 | 小数位精确到 15 位 |
| string | 字符串 | - | "" | utf-8 字符串 |
值的字面量（literal）是指代码中值的文字表示。一个值可能存在多种字面量表示。
表示基本类型值的文本称为基本字面量。基本字面量也被称为字面量常量或未命名常量。
示例：
func main() {
var ch byte = 97 // 声明字符类型
fmt.Printf("ch=%c", ch) // 输出 a
}
这里定义了 ch 是一个字符类型，赋值却是一个整数 97，打印的结果是小写字符 'a'。
原因是：计算机不能直接存储字符类型，只能转成数字存储，那为什么小写字符 'a' 对应的整数是 97 呢？因为计算机是根据 ASCII 码来存储的。
强制类型转换
package main
import "fmt"
func main() {
chinese := 97
math := 99
english := 96
fmt.Printf("总分是 %d，平均分(整数)是 %d, 平均分(浮点数)是 %f", chinese+math+english, (chinese+math+english)/3, float32(chinese+math+english)/3)
// 总分是 292，平均分(整数)是 97, 平均分(浮点数)是 97.333336
}
注意：
GO 语言中不允许隐式转换，所有类型转换必须显式声明（强制转换），而且转换只能发生在两种相互兼容的类型之间
var ch byte = 'c'
// var a int = ch // cannot use ch (type byte) as type int in assignment
var b int = int(ch) // 数据类型名(待转换的值)
- int 转 float 强制转换：多小数
- float 转 int 强制转换：丢精度
接收键盘输入
package main
import fmt
func main（） {
var age int
fmt.Println（"请输入年龄："）
fmt.Scanf（"%d", &age） // 将接收的值赋给age变量
fmt.Printf（"age=%d", age）
}
常量
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
常量声明
// 变量：程序运行期间，值可以改变，声明使用var
// 常量：程序运行期间，值不可以改变，声明使用const
const a int = 11 // 常量不可以使用:=
// 常量用作枚举
const (
Unknown = 0
Success = 1
Fail = 2
)
// 常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过
import "unsafe"
const (
a = "abc"
b = len(a) // 3
c = unsafe.Sizeof(a) // 16
iota 枚举
iota 常量生成器：用于生成一组递增的整型常量，减去了每行都要写一遍初始化表达式的繁琐。
func main() {
// 在一个 const 声明语句中，在第一个声明的常量所在的行，iota 将会被置为 0，然后在每一个有常量声明的行递增 1
const (
a = iota // 0
b = iota // 1
c = iota // 2
)
const d = iota // iota 遇到const，会被置为 0
// 可以只写一个iota
const (
e = iota // 0
f // 1
g
)
// 同一行值一样
const (
h = iota // 0
i, j, k = iota, iota, iota // 1
l = iota // 2
)
}
运算符
算术运算符
| 运算符 | 术语 |
|---|---|
| + | 加（既可以完成两个数字相加，又可以连接两个字符串） |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取模（取余） |
| ++ | 后自增（GO 语言中没有前自增） |
| -- | 后自减（GO 语言中没有前自减） |
赋值运算符
| 运算符 | 说明 | 示例 |
|---|---|---|
| = | 普通赋值 | c = a + b 将 a + b 表达式结果赋值给 c |
| += | 相加后再赋值 | c += a 等价于 c = c + a |
| -= | 相减后再赋值 | c -= a 等价于 c = c - a |
| *= | 相乘后再赋值 | c *= a 等价于 c = c * a |
| /= | 相除后再赋值 | c /= a 等价于 c = c / a |
| %= | 求余后再赋值 | c %= a 等价于 c = c % a |
关系运算符
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4 == 3 | false |
| != | 不等于 | 4 != 3 | true |
| < | 小于 | 4 < 3 | false |
| > | 大于 | 4 > 3 | true |
| <= | 小于等于 | 4 <= 3 | false |
| >= | 大于等于 | 4 >= 1 | true |
逻辑运算符
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| ! | 非 | !a | 如果 a 为假，则 !a 为真 如果 a 为真，则 !a 为假 |
| && | 与 | a && b | 如果 a 和 b 都为真，则结果为真，否则为假 |
| || | 或 | a || b | 如果 a 和 b 有一个为真，则结果为真，二者都为假时，结果为假 |
条件语句
if 语句
package main
import "fmt"
func main() {
var score int
fmt.Println("请输入成绩：")
fmt.Scanf("%d", &score)
// if 语句支持一个初始化语句+判断条件
if good_score := 90; score >= good_score {
fmt.Println("优秀")
} else if soso_score := 60; score >= soso_score {
fmt.Println("及格")
} else {
fmt.Println("需要努力")
}
}
switch 语句
注意：case 后面默认自带 break，如果想执行完成某个 case 后继续执行后面的 case，可以使用 fallthrough 关键字。
func main() {
bonus := 5000
var score string
finish := true
fmt.Println("请输入年终评级：")
switch fmt.Scanf("%s", &score); score {
case "A":
bonus += 1000
case "B":
bonus += 5000
case "C":
case "D":
bonus -= 1000
default:
finish = false
fmt.Println("输入有误，请输入正确的评级")
}
if finish {
fmt.Printf("您的年终奖为：%d", bonus)
}
}
循环语句
GO 中的 3 种循环方式：
package main
import "fmt"
func main() {
// 第1种方式
for i := 0; i < 5; i++ {
fmt.Printf("i=%d\n", i)
}
// 第2种方式：类似while循环
num := 1
for num < 5 {
fmt.Printf("num=%d\n", num)
num++
}
// 第3种方式
for {
fmt.Println("死循环")
}
}
函数
函数定义
函数就是将一堆代码进行封装，以便重用的一种机制。
func 函数名(){
函数体
}
参数列表
import "fmt"
func MyFunc(a int, b int, args ...int) { // 注意：不定长参数必须放在参数列表最后
fmt.Println("定长参数为：", a, b)
for i, data := range args { // 若不需要编号，则可使用 for _, data := range args
fmt.Println("编号为：", i)
fmt.Println("数据为：", data)
}
}
func main() {
MyFunc(1, 2, 3, 4, 5)
}
打印结果：
定长参数为： 1 2
编号为： 0
数据为： 3
编号为： 1
数据为： 4
编号为： 2
数据为： 5
函数返回值
// 定义返回值类型
func Add(a int, b int) int {
return a + b
}
// 给返回值命名
func Sub(a int, b int) (sub int) {
sub = a - b
return sub // 也可以只写 return
}
// 返回多个值
func Sub(a, b, c int) {
a, b, c = 1, 2, 3
return a, b, c // 也可以只写 return
}
函数类型
在 GO 语言中还有另外一种定义使用函数的方式，就是函数类型。
所谓的函数类型，就是将函数作为一种类型可以用来定义变量，基本使用如下：
func Test(a, b int) int {
return a + b
}
// 定义函数类型：即需要传递两个整型参数，有一个整型返回值的函数类型
type FuncType func(a int, b int) int // type关键字后面跟着类型的名字（FunType）
func main() {
var result FuncType // 类型是FuncType类型，即函数类型
result = Test
s := result(1, 2)
fmt.Printf("s=%d", s)
}
匿名函数
所谓匿名函数就是没有名字的函数。匿名函数最主要的功能就是实现了闭包。
匿名函数（即闭包）的优越性在于可以直接使用函数内的变量，不必申明，这样有时候可以使代码更简单，增强代码的可读性。
package main
import "fmt"
func main() {
num := 9
// 使用方式一：定义匿名函数并赋值给变量
f1 := func() {
// 在匿名函数中可以直接访问main()中定义的局部变量
// 并且在匿名函数中对变量的值进行了修改，最终会影响到整个main()函数中定义的变量值
num++
fmt.Println("匿名函数：", num)
}
f1() // 10
fmt.Println("main函数：", num) // 10
// 使用方式二：通过函数类型
type FuncType func() // 没有参数，没有返回值
var f2 FuncType = f1
f2()
// 使用方式三：直接调用
func(a, b int) {
fmt.Println("a + b =", a+b)
}(3, 6)
// 有参有返回值的匿名函数
min, max := func(a, b int) (min, max int) {
if a > b {
return b, a
} else {
return a, b
}
}(12, 13)
fmt.Printf("min=%d, max=%d\n", min, max)
}
递归函数
示例：阶乘
func Test(num int) int {
if num == 1 {
return 1
}
return num * Test(num-1)
}
func main() {
var num int
fmt.Println("请输入需要阶乘的数：")
fmt.Scanf("%d", &num)
fmt.Printf("%d的阶乘结果为：%d", num, Test(num))
}
