Go语言学习笔记（持续更新）

Go语言的诞生背景

为了解决当下编程语言对并发支持并不友好、编译速度慢、编程复杂这三个问题。

Go（Golang）= C + Python

网站汇总

官网（镜像）：https://golang.google.cn/

Go语言中文网：https://studygolang.com/

Go语言入门教程：http://c.biancheng.net/golang/

GoLang教程_Go语言教程：https://www.bilibili.com/video/BV14T4y1g7h9?p=1

Go语言教程|菜鸟教程：https://www.runoob.com/go/go-tutorial.html

安装与环境配置

下载Go：http://docscn.studygolang.com/dl/

默认安装目录（Windows）

C:\Go

查看Go版本：

go version

go version go1.15.6 windows/amd64

GOROOT和GOPATH

GOPATH ：将要建立go工程的路径
GOROOT ：Go的源码的安装路径

Hello world

helloworld.go

package main

import "fmt"

func main() {
	fmt.Println("Hello World！")
}

第1行定义一个包，包名为main，所有的Go源程序文件都必须有一个包声明语句，Go通过包来管理命名空间。

第3行引入一个外部包fmt，fmt是标准输入输出包。

第5行使用func关键字声明定义一个函数，函数名为main，main为Go程序的入口函数。

第6行调用fmt包中的Println方法，打印Hello World！。

编译

go build helloworld.go

运行

helloworld.exe

Go语言标识符

1. 必须以字母或下划线开头。
2. 包含字母、数字、下划线、Unicode字符等。
3. 严格区分大小写。
4. 不能与关键字同名。

变量命名规范

Go语言中变量命名一般采用驼峰命名法，当遇到特有名词（缩写或简称，如DNS）的时候，特有名词根据是否私有全部大写或小写。

任何需要对外暴露的名字必须以大写字母开头，不需要对外暴露的则应该以小写字母开头。

当命名以一个大写字母开头，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出；如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的。

Go语言关键字

序号	关键字	含义	备注
1	break	退出当前循环	for循环使用关键字
2	case	声明case子句	switch语句的关键字 每个case分支都是一个整体
3	chan	声明或创建通道类型
4	const	声明常量
5	continue	跳过本次循环	for循环使用关键字
6	default	声明default子句	switch语句的关键字
7	defer	延迟执行
	else	if else语句的关键字	if else语句
	fallthrough	switch语句中跨越case的一种方法	switch语句的关键字
	for	for循环关键字
	func	定义函数
	go	并发语法糖
	goto	跳转至标签
	if	if else语句的关键字	if else语句
	import	导入包名
	interface	定义接口
	map	声明或创建map类型
	package	定义包名
	range	for循环关键字
	return	函数返回值
	select
	struct	定义结构体
	switch	switch语句	switch语句的关键字
	type
	var	声明变量

内置数据类型

• 数值
  • 整型
    • byte
    • int
    • int8
    • int16
    • int32
    • int64
    • uint
    • uint8
    • uint16
    • uint32
    • uint64
    • uintptr
  • 浮点型
    • float32
    • float64
  • 复数型
    • complex64
    • complex128
• 字符和字符串
  • string
  • rune
• 接口
  • error
• 布尔
  • bool

常量标识符

• true
• false
• iota
• nil

空白标识符

• _：用来声明一个匿名的变量。

内置函数

• make
• new
• len
• cap
• append
• copy
• delete
• panic
• recover
• close
• complex
• real
• image
• print
• println

Go语言操作符

序号	操作符	含义	备注
1	+	相加
2	-	相减
3	*	相乘，指针变量
4	/	相除
5	%	求余
6	++	自增
7	–	自减
8	==	相等
9	!=	不相等
10	<	小于
11	>	大于
12	<=	小于等于
13	>=	大于等于
14	&&	逻辑与
15	||	逻辑或
16	!	逻辑非
17	&	按位与，返回变量存储地址
18	|	按位或
19	^	按位异或
20	<<	左移
21	>>	右移
22	=	赋值
23	+=	相加后赋值
24	-=	相减后赋值
25	*=	相乘后赋值
26	/=	相除后赋值
27	%=	求余后赋值
28	&=	按位与后赋值
29	|=	按位或后赋值
30	^=	按位亦或后赋值
31	<<=	左移后赋值
32	>>=	右移后赋值
	&^
	&^=
	<-
	:=
	…
	(
	）
	[
	]
	{
	}
	,
	;
	.
	:

1 变量

Go语言定义变量的三种方式

1.1 声明时未初始化（显示不完整声明）

package main

import "fmt"

func main() {
	var age0 int
	age0 = 12
	fmt.Println(age0)

	var name0 string
	name0 = "name0"
	fmt.Println(name0)
}

注：

1. 变量声明时必须指明变量类型。
2. 不指定初始值时，Go默认该变量初始化为对应类型的零值。
3. Go变量声明后会立即为其分配空间。

1.2 声明时初始化（显示完整声明）

package main

import "fmt"

func main() {
	var age1 int32 = 20
	fmt.Println(age1)

    var age3 = 40
	fmt.Println(age3)
    
	var name1 string = "name1"
	fmt.Println(name1)

	var name4 = "name4"
	fmt.Println(name4)
    
    var age4, age5, age6 = 12, 15, 17
	fmt.Println(age4, age5, age6)

	var age7, name10 = 12, "LiXiang"
	fmt.Println(age7, name10)
}

注：

1. 显示完整声明var varName dataType [ = value]
2. 若在声明时完成初始化，变量类型可以省略，该变量的类型为初始化值对应的类型。
3. Go支持多类型变量同时声明并赋值。

1.3 列表推导

package main

import "fmt"

func main() {
	age2 := 30
	fmt.Println(age2)

	name2 := "name2"
	fmt.Println(name2)
    
    name5, name6 := "LiuLi", "WanCai"
	fmt.Println(name5, name6)

	name7, name8, age8 := "A", "B", 36
	fmt.Println(name7, name8, age8)
}

注：

1. :=只能出现在函数 / 方法内。
2. Go编译器会自动对变量进行类型推导。
3. Go也可以使用这种方式对多类型多变量同时声明并赋值。

2 常量

2.1 定义常量

package main

import "fmt"

// 定义一个常量
const pi = 3.14		// pi = 3.14

// 定义多个常量
const (
	e    = 2.71323	// e = 2.71323
	age  = 20		// age = 20
	name = "LiMing"	// name = "LiMing"
	OK   = true		// OK = true
)

func main() {
	fmt.Println(pi)

	fmt.Println(e, age, name, OK)
}

1. Go中的常量分为布尔型、数值型、字符串型。
2. 常量定义之后不可修改。
3. 常量的类型由定义常量时指定的类型决定。

2.2 预声明标识符iota

package main

import "fmt"

const (
	c0 = iota	// c0 = 0
	c1 = iota	// c1 = 1
	c2 = iota	// c2 = 2
	c3 = iota	// c3 = 3
)

const (
	a1 = iota	// a1 = 0
	a2 = iota	// a2 = 1
	a3 = iota	// a3 = 2
)

func main() {
	fmt.Println(c0, c1, c2, c3)
	fmt.Println(a1, a2, a3)
}

注：

1. iota可以看做自增的枚举变量，专门用来初始化常量。
2. iota的初始值为0，一组多个常量同时声明时其值逐行增加。
3. 分开的const语句，iota每次都从0开始。

类型	类型标识符	取值范围	默认零值	备注
	byte			uint8的别名
	int		0
	int8		0
	int16		0
	int32		0
	int64		0
	uint
	uint8
	uint16
	uint32
	uint64
	uintptr
	float32
	float64
	complex64
	complex128
字符串	string
字符	rune
错误类型	error
布尔型	bool	true，false	false

3 条件分支

3.1 if else

package main

import "fmt"

func main() {
	var num int32
	fmt.Println("请输入考试成绩")
	fmt.Scanln(&num)

	if num > 90{
		if num == 100{
			fmt.Println("A+")
		}else {
			fmt.Println("A")
		}
	}else {
		if num > 80 {
			fmt.Println("B")
		}else {
			fmt.Println("D")
		}
	}
}

Go语言的if else条件分支丰富多样

单个if

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

单个if else

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

if else嵌套版

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}else{
	/* 在布尔表达式 1 为 false 时执行 */
    if 布尔表达式 3 {
      /* 在布尔表达式 3 为 true 时执行 */
   }
}

3.2 switch

基本写法

package main

import "fmt"

func main() {
	a := 426
	switch  {
	case a % 5 == 0:
		fmt.Println("a是5的倍数")
	case a % 4 == 0:
		fmt.Println("a是4的倍数")
	case a % 6 == 0:
		fmt.Println("a是6的倍数")
	case a % 2 == 0:
		fmt.Println("a是偶数")
	case a % 3 == 0:
		fmt.Println("a是3的倍数")
	default:
		fmt.Println("这个数太随便了")
	case a % 7 == 0:
		fmt.Println("a是7的倍数")
	case a % 8 == 0:
		fmt.Println("a是8的倍数")
	}
}

一分支多值

package main

import "fmt"

func main() {
	a := "hello"
	switch a {
	case "hello", "world":
		fmt.Println("hello 或 world")
	default:
		fmt.Println("其他内容")
	}
}

分支表达式

package main

import "fmt"

func main() {
	r := 15
	switch {
	case r > 10 && r < 20:
		fmt.Println("10-20之间")
	default:
		fmt.Println("大小越界")
	}
}

fallthrough（跨越case）

package main

import "fmt"

func main() {
	answer := "Y"
	switch {
	case answer == "Y":
		fmt.Println("Yes")
		fallthrough
	case answer == "y":
		fmt.Println("Yes")
	case answer == "N" || answer == "n":
		fmt.Println("No")
	default:
		fmt.Println("非法输入")
	}
}

利用type-switch来判断变量的类型

package main

import "fmt"

func main() {
	var x interface{}

	switch i := x.(type) {
	case int:
		fmt.Printf("%v是int型", i)
	case int8:
		fmt.Printf("%v是int8型", i)
	case int16:
		fmt.Printf("%v是int16型", i)
	case int32:
		fmt.Printf("%v是int32型", i)
	case uint:
		fmt.Printf("%v是uint型", i)
	case nil:
		fmt.Printf("是%T型", i, i)

	}
}

注：

1. Go的switch语句会根据传入的参数，对所有的case条件依次匹配，执行匹配到的第一个case代码块。
2. 在Go语言中 case 是一个独立的代码块，执行完毕后不会像C语言那样紧接着执行下一个 case。
3. 通过fallthrough语句可以强制执行下一个case子句（不判断下一个case子句的条件是否满足）。
4. default可以出现任意位置，并不影响switch的判断。
5. switch可以带一个可选的简单初始化语句。
6. switch后面没有表达式的话，则每一个case子句是一个布尔表达式。
7. switch条件表达式支持任意相等、比较运算的类型变量。

4 循环

Go语言只支持一种循环（for循环）

4.1 实现for循环

package main

import "fmt"

func main() {
    // 赋值表达式，给控制变量赋初值;关系表达式或逻辑表达式，循环控制条件;赋值表达式，给控制变量增量或减量
	for i := 1; i <= 10; i++ {
		fmt.Println(i)
	}
}

4.2 实现while循环

关系表达式或逻辑表达式控制循环

package main

import "fmt"

func main() {
	i := 1
	for i <= 10 {
		fmt.Println(i)
		i++
	}
}

4.3 无限循环

package main

import (
	"fmt"
	"time"
)

func main() {
	for {
		fmt.Printf("无限循环,当前时间：%v \n", time.Now())
	}
}

4.4 break

利用break退出当前循环

package main

import "fmt"

func main() {
	a := 22
	for a < 30 {
		a++
		if a == 25 {
			break
		}
        fmt.Println(a)
	}
}

4.5 continue

利用continue退出本次循环

package main

import "fmt"

func main() {
	a := 22
	for a < 30 {
		a++
		if a == 25 {
			continue
		}
		fmt.Println(a)
	}
}

4.6 goto

package main

import "fmt"

func main() {

	for a := 1; a <= 10; a++ {
		fmt.Println(a)
		if a == 5 {
			// 跳转至标签处，跳过迭代
			goto LOOK
		}
	}
	
// 定义标签
LOOK:
	fmt.Println("执行语句1")
	fmt.Println("执行语句2")
	fmt.Println("执行完毕")
}

参考链接：

https://zhuanlan.zhihu.com/p/216001587?utm_source=QQ_article_bottom

https://www.cnblogs.com/zhangyafei/p/12466162.html

http://c.biancheng.net/view/48.html

https://blog.csdn.net/zhangpengzp/article/details/88405762

https://blog.csdn.net/skh2015java/article/details/70051512