go基础

关键字

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	派生类型: 包括： (a) 指针类型（Pointer） (b) 数组类型 (c) 结构化类型(struct) (d) Channel 类型 (e) 函数类型 (f) 切片类型 (g) 接口类型（interface） (h) Map 类型

数字类型

整形

整形的和浮点型的区别是在前加了个 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
}

算数运算符

关系判断符

逻辑运算符

按位运算法

赋值运算符

控制语句

流程图

代码