Go 基础知识
基础结构
在Go语言中，基础结构如下：
package main
// 当该文件作为一个可执行文件，而不是一个模块时，必须导入main
import "fmt"
// 入口函数外只能书写一些全局的变量、常量、函数名等标识符
func main(){
fmt.Println("HELLO,WORLD") // 所有的代码，都书写在main入口函数中
}
注释方式
在Go语言中，注释方式统一为//。
命名方式
在GO语言中，标识符的命名必须是字母，数字，下划线组成。
并且不能由数字开头。
GO语言更推荐使用小驼峰的命名方式 。
var userName string // 第一个单词首字母小写，其他单词首字母大写
关键字
不要使用关键字作为标识符。
关键字是指编程语言中预先定义好的具有特殊含义的标识符。 Go语言中有25个保留字。
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
保留字
不要使用保留字作为标识符。
Go语言中有37个保留字。
Constants: true false iota nil
Types: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
Functions: make len cap new append copy close delete
complex real imag
panic recover
声明方式
全局声明
在入口函数外声明的标识符即是全局声明。
全局声明的标识符可以在程序中不进行使用，这样并不会抛出什么异常。
package main
import "fmt"
var userName string // 全局声明
func main(){
fmt.Println("HELLO,WORLD")
}
局部声明
入口函数内声明的标识符都是局部声明。
局部声明的标识符必须进行使用，如果不使用则会抛出异常。
这是为了防止编译后的可执行文件体积过大的问题。
package main
import "fmt"
func main(){
var userName string // 局部声明
// .\t1.go:6:6: userName declared but not used
fmt.Println("HELLO,WORLD")
}
变量相关
声明一个变量使用关键字var
标准声明
标准声明的声明格式如下：
var 变量名 变量类型
如下，声明一个userName的变量，类型为string。
var userName string
批量声明
可以使用批量声明来进行多个变量的声明。
如下进行批量声明。
package main
import "fmt"
var (
userName string
userAge int8
userGender bool
)
func main() {
fmt.Println("HELLO,WORLD")
}
变量定值
可以在声明的时候，对变量进行赋值。
package main
import "fmt"
var (
userName string = "云崖先生"
)
func main() {
fmt.Println(userName)
}
类型推导
可以不指定类型，让=后面的变量值来决定变量的类型。
package main
import "fmt"
var (
userName = "云崖先生"
)
func main() {
fmt.Printf("变量类型：%T\n变量值：%v", userName, userName)
// 变量类型：string
// 变量值：云崖先生
}
短变量
可以不写var，使用:=来进行简便写法。
注意：短变量声明的写法，只能放在局部进行声明
package main
import "fmt"
func main() {
userName := "云崖先生"
fmt.Printf("变量类型：%T\n变量值：%v", userName, userName)
// 变量类型：string
// 变量值：云崖先生
}
匿名变量
由于局部声明的变量必须使用，但有的时候我们对于一些变量并不想使用。
如解构赋值出了函数的多个返回值，其中有一个变量没什么用，那么这个时候我们可以使用_将其作为匿名变量。
也就是说，匿名变量在局部即使定义后不使用，也不会抛出异常。
package main
import "fmt"
func f1() (string, string) {
return "返回值1", "无用的返回值"
}
func main() {
v1, _ := f1()
fmt.Println(v1)
}
重复定义
在同一个作用域下，禁止重复定义一个相同的变量。
package main
import "fmt"
func f1() (string, string) {
return "返回值1", "无用的返回值"
}
func main() {
v1 := "值1"
var v1 string = "值2"
fmt.Println(v1)
// # command-line-arguments
// .\t1.go:11:6: v1 redeclared in this block
// previous declaration at .\t1.go:10:2
}
常量相关
声明一个常量使用关键字const，常量中的值禁止再次更改，一经定义不允许修改。
并且，常量在定义时必须赋值！否则就会抛出异常
标准定义
标准声明的声明格式如下：
const 常量名 常量类型 = 常量值
如下，声明一个userName的变量，类型为string。
const pi float64 = 3.1415926535897
批量定义
可以使用批量定义来进行多个常量的声明定义。
如下进行批量定义
package main
import "fmt"
const (
pi float64 = 3.1415926535879
height int32 = 122
age int8 = 18
)
func main() {
fmt.Println("hello,world")
}
省值定义
在使用批量定义常量时，如果只有第一个产量给定了值而其他常量都没有给值。
后面的常量将自动引用前面常量的值。
package main
import "fmt"
const (
v1 = 100
v2
v3
)
func main() {
fmt.Println(v1) // 100
fmt.Println(v2) // 100
fmt.Println(v3) // 100
}
iota
iota是Go语言中的常量计数器，只能在定义常量时使用。
iota在const关键字出现时将被重置为0。
const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。
使用iota能简化定义，在定义枚举时很有用。
package main
import "fmt"
const (
v1 = iota
v2
v3
)
func main() {
fmt.Println(v1) // 0
fmt.Println(v2) // 1
fmt.Println(v3) // 2
}
面试题
使用_跳过某些值
package main
import "fmt"
const (
v1 = iota
_
v2
v3
)
func main() {
fmt.Println(v1) // 0
fmt.Println(v2) // 2
fmt.Println(v3) // 3
}
iota声明中间插队
package main
import "fmt"
const (
v1 = iota
v2
v3
)
const v4 = 100 // 再次出现const iota清零
const v5 = iota
func main() {
fmt.Println(v1) // 0
fmt.Println(v2) // 1
fmt.Println(v3) // 2
fmt.Println(v4) // 100
fmt.Println(v5) // 0
}
多个iota定义在一行时，不会增加iota，只有当新增一行代码时（不为空）才会增加iota。
const (
a, b = iota + 1, iota + 2 //1,2
c, d //2,3
e, f //3,4
)
定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）
const (
_ = iota
KB = 1 << (10 * iota)
MB = 1 << (10 * iota)
GB = 1 << (10 * iota)
TB = 1 << (10 * iota)
PB = 1 << (10 * iota)
)
fmt基础
fmt包中关于打印有三种。
Print只会进行打印，并不会进行换行，也不能进行格式化。
package main
import "fmt"
func main() {
fmt.Print("hello,")
fmt.Print("world!")
// hello,world!
}
Printf
Printf可以进行格式化，并不会进行换行。
package main
import "fmt"
func main() {
number := 100
fmt.Printf("八进制:%o", number)
fmt.Printf("十进制:%0x", number)
// 八进制:144十进制:64
}
Println
Println可以进行换行，但不能进行格式化。
package main
import "fmt"
func main() {
fmt.Println("hello")
fmt.Println("world")
// hello
// world
}
打印格式
以下举例出一些常用的Go语言中的打印格式，关于其他打印格式在另外的编程语言分类中已有介绍。
| 占位符 | 说明 |
|---|---|
| %v | 值的默认格式表示 |
| %+v | 类似%v，但输出结构体时会添加字段名 |
| %#v | 值的Go语法表示 |
| %T | 打印值的类型 |
| %% | 百分号 |
| %p | 打印指针内存地址 |
其他内容
其他内容会在后续文章，fmt标准库中进行详细罗列。
