关键字
25个关键字
关键字就以下 25 个
36 个标识符
标识符有 36 个
基础语法
以下为一个简单的结构, 只要用于展示注释以及变量常量的基础使用
// 基础结构, 此处为单行注释
package main
// 模块的导入编辑器会自动导入
import "fmt"
// 定义常量建议是大写
const NAME = "yang_tuo_tuo"
// 定义变量, 在 main 函数外定义的变量为全局变量
var nameMain = "yang_tuo"
/*
这样是多行注释
*/
func main() {
fmt.Println("hello world")
fmt.Println(nameMain)
fmt.Println(NAME)
}基础结构
基础结构主要用于展示 结构体, 函数, 以及接口等的定义
// package 每个 go 文件必须存在, 且必须第一行
// 用于标明此文件的所属包
package main
// 导入依赖包, 不可重复导入, 导入的形式有多种方式
import "fmt"
// 定义常量建议是大写, 后面可以跟类型, 不跟类型也可以自动识别
const NAME string = "yang_tuo_tuo"
const CODE = "yang_tuo_tuo"
// 定义变量, 在 main 函数外定义的变量为全局变量
// 变量定义也可以跟类型或不跟
var nameMain = "yang_tuo"
//一般类型声明
type age int
// 结构体声明
type Map struct {
}
// 接口声明, 前面带个 I 一般习惯
type Imap interface {
}
// 函数定义
func GetMap() {
fmt.Println("123")
}
// 入口函数, 并非所有文件都必须, 但是对于生成可执行文件则必须
func main() {
GetMap()
}Package
定义
- package 作为 go 中的基本分发单位, 以及依赖关系的体现
- 每个go语言的文件都必须要求在源码开头有个 package 的声明来标明自己的所属于代码包
- 要生成 go 的可执行程序, 必须要有main 的 package 包, 再main 包下还必须要有 main() 函数
- 同一个路径下只能存在一个 package, 一个 package 可以拆分成多个源文件组成
验证
做个简单的验证, 如果在package 前做别的会直接报错, package 必须放在最前面
再做个简单的验证, main 包下如果不存在 main 函数也会报错
再验证一下同一个路径下存在多个包的场景, IDE 里面都会直接报错
如果一个包下存在多个文件都指向这个包名则是可以的, 也就是映照了 一个 package 可以拆分成多个源文件组成 的定义
ps:
package 包尽量与目录名称保持一致, 倘若不一致容易导致混淆
Import
定义
用于导入 源文件所依赖的 package 包
不能导入未使用到的包, 否则编译器会直接报错,
不能重复导入, 也会报错
导入的格式有两种, 可以一行一行导入, 也可以一次括号内导入
原理
如果一个文件中导入了其他的包, 这些包会被顺序的导入
如果导入的包存在依赖, 会首先导入被依赖的包之后初始化包中的常量, 变量, 最后包中的 init() 函数也会被执行(如果存在的话)
所有的导入完成后才会对 main 包中的进行常量变量的初始化, init() (如果存在), 最后才会执行 main()
如果一个包被导入多次, 这个包只会被导入一次
比如下图中, 在 main 那里 导入了 pkg1 之后再导入一次 pkg2
pkg1导入的时候已经先把 pkg2导入了, 再次导入是不会再导入的
别名
ps:
用下滑线导入的包是无法直接使用的, 也不能使用这个包里面的函数
只是执行到了这个包的 init()
别名的示例
"." 示例
go 数据类型
| 序号 | 类型和描述 |
|---|---|
| 1 | 布尔型 布尔型的值只可以是常量 true 或者 false (1, 0 之类的是不行的)。一个简单的例子：var b bool = true |
| 2 | 数字类型 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。 |
| 3 | 字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 |
| 4 | 派生类型: 包括：
|
数字类型
整形
整形的和浮点型的区别是在前加了个 u 这样进行区分
| 序号 | 类型和描述 |
|---|---|
| 1 | uint8 无符号 8 位整型 (0 到 255) |
| 2 | uint16 无符号 16 位整型 (0 到 65535) |
| 3 | uint32 无符号 32 位整型 (0 到 4294967295) |
| 4 | uint64 无符号 64 位整型 (0 到 18446744073709551615) |
| 5 | int8 有符号 8 位整型 (-128 到 127) |
| 6 | int16 有符号 16 位整型 (-32768 到 32767) |
| 7 | int32 有符号 32 位整型 (-2147483648 到 2147483647) |
| 8 | int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) |
浮点型
| 序号 | 类型和描述 |
|---|---|
| 1 | float32 IEEE-754 32位浮点型数 |
| 2 | float64 IEEE-754 64位浮点型数 |
| 3 | complex64 32 位实数和虚数 |
| 4 | complex128 64 位实数和虚数 |
其他类型
| 序号 | 类型和描述 |
|---|---|
| 1 | byte 类似 uint8 |
| 2 | rune 类似 int32 |
| 3 | uint 32 或 64 位 |
| 4 | int 与 uint 一样大小 |
| 5 | uintptr 无符号整型，用于存放一个指针 |
类型零值
类型零值不是空值, 是变量声明后的默认赋值
值类型为 0, 字符串为空, bool 为 false
类型存储大小
派生类型
常量与变量
声明和赋值
单变量
多变量
ps:
_ 作为垃圾桶一样的存在, 被丢进去 _ 的数据是无法操作的
变量被声明后就一定要被使用, 不使用也会导致报错
类型转换
代码示例
: 代替声明
package main
import . "fmt"
func main() {
var a, b, c int = 1, 2, 3
// 只能写在函数内, 可以简写 去掉 var 以及类型 用 : 代替
d, e, f := 1, 2, 3
Println(a, b, c)
Println(d, e, f)
}格式转换
package main
import . "fmt"
func main() {
var a float64 = 1.09
b := int(a)
Println(b) // 1
}变量可见性
常量
定义形式
代码示例
一下定义方式皆可, 注意自定义的函数是无法用在常量的定义中的
package main
const name = "yangtuo"
const yang string = "tuo"
const (
cat string = "猫"
dog = "狗"
)
const a, b = 1, 2
const c, d string = "1", "2"
const e, f = 1, "1"
const alen = len(f)
func main() {
}特殊常量 iota
ps: iota 只能在全局使用, 如果在函数体内使用会报错
代码示例
每当遇到 const 就会被重置为 0
package main
import "fmt"
const a = iota
const b = iota
func main() {
fmt.Println(a) // 0
fmt.Println(b) // 0
}
在组合里面每新增一行会加1, 这种中间插入一个其他的不使用 iota 的形式也叫插队使用法
package main
import "fmt"
const (
a = iota
b = 1
c = iota
)
func main() {
fmt.Println(a) // 0
fmt.Println(c) // 2
}
利用上面的特性, 再使用 _ 的机制可以实现跳值赋值法
package main
import "fmt"
const (
a = iota
b = 1
_
c = iota
)
func main() {
fmt.Println(a) // 0
fmt.Println(c) // 3
}
表达式隐式使用法, 当下面不显示的赋值 iota 的时候, 会默认继承上面的计算方式
因此配合 iota 每行+1的性质实现此效果
package main
import "fmt"
const (
a = iota * 2
b
c
)
func main() {
fmt.Println(a) // 0
fmt.Println(b) // 2
fmt.Println(c) // 4
}
单行赋值法里面也有个特性, 下面的隐式继承的时候也是会根据顺应位置的继承
下面的示例中, c 是继承了 a , d 是继承了 b
package main
import "fmt"
const (
a, b = iota, iota + 3
c, d
)
func main() {
fmt.Println(a) // 0
fmt.Println(b) // 3
fmt.Println(c) // 1
fmt.Println(d) // 4
}
而且如果想要使用隐式继承上一轮, 必须完全对应
就是 上面是两个变量的单行, 下面也必须是两个变量的继承保持数量一致
倘若想要继续使用iota , 在下面在 e = iota 恢复计数即可
package main
import "fmt"
const (
a, b = iota, iota + 3
c, d
e = iota
)
func main() {
fmt.Println(a) // 0
fmt.Println(b) // 3
fmt.Println(c) // 1
fmt.Println(d) // 4
fmt.Println(e) // 2
}
算数运算符
关系判断符
逻辑运算符
按位运算法
赋值运算符
控制语句
流程图
代码