Golang-Study

Golang-Study-Note

参考教程视频:狂神说

https://www.bilibili.com/video/BV1ae41157o9?p=1&vd_source=7936683721e7dee1c207a6374e8dfb72

---

一、Golang语言发展史

1.Golang语言的诞生

2.版本发布

3.Go语言使用场景

---

二、Go语言开发环境搭建

1.下载和安装GO-SDK

Go语言官网：https://golang.org/

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

安装GO-SDK(SDK即：Software Development Kit 软件开发工具包)，Windows系统下可以选择msi（图形界面安装包，根据图形界面提示进行选择和安装），或者zip（编译后的压缩包，解压缩即可使用，需要手动配置环境变量）

2.环境配置

（1）GOROOT

创建GOROOT环境变量存放GO-SDK的安装目录地址

（2）GOPATH

GOPATH存放Go语言项目代码，需要在GOPATH目录下创建src、pkg、bin三个目录

（3）path

在环境变量path中添加%GOROOT%\bin，即GO语言的开发工具（GO-SDK）安装目录下的bin目录，bin目录存放了Go语言的编译工具等。

（4）检查配置是否生效

打开cmd（Win+R），在任意目录下使用go version命令查看GO-SDK的版本，正确输出安装版本即表示环境配置成功。

go version

查看GO-SDK配置的环境

go env

3.下载和安装GoLand

GoLand官网：https://www.jetbrains.com/go/

安装

---

三、第一个Go语言程序

1.记事本编写GO语言程序并运行

（1）创建一个hello.go文件，使用记事本打开，编写第一个GO语言程序

package main
import "fmt" //导入系统资源包
func main() {
	fmt.Printf("Hello World!")  //输出指定字符串
}

（2）运行hello.go

在hello.go文件所在目录下打开cmd(在目录地址栏直接输入cmd并enter)，使用go run 命令运行GO程序

go run hello.go

（3）运行结果

2.GoLand编写hello.go程序并运行

(1)新建一个GO语言程序

(2)编写hello.go程序

// package Hello_Golang
package main
import "fmt" //导入系统资源包
func main() {
	fmt.Printf("Hello World! Hello Golang!")  //输出指定字符串
}

运行结果

四、Golang基本语法

1.注释

(1)单行注释

//注释内容

(2)多行注释

/*
注释内容
*/

2.变量

（1）变量的定义

1）标准变量定义

//1.定义变量使用var关键字，注意GO语言的语句不需要分号结尾（这与java和c语言不同）
//2.定义变量的基本格式：var 变量名 变量类型
var name String

2)批量定义多个变量

//批量定义多个变量使用var关键字和大括号
var（
    name String
    age int
）

3）简短变量的定义

/*

格式化输出使用fmt.Printf()

格式化输出符号：%T数据类型、%t数据值、%s字符串类型、%d数值型

*/

（2）变量交换

GO语言可以直接进行变量值的交换，不需要定义中间变量来暂存变量值。

（3）匿名变量

（4）变量的作用域

（5）常量

常量的定义使用关键字const，GO语言程序中有两种常量定义方式显式定义和隐式定义，隐式定义常量不需要给出常量的数据类型，编译器会自动推到其数据类型。

特殊常量iota

3.数据类型

基本数据类型：

(1)布尔型:bool

其值只能是true或者false

(2)整型：byte、int、int8、int16、int32、int64、uint、uintptr、uint8、uint16、uint32、uint64

int表示有符号，uint表示无符号

int8取值范围：-（2^7）~（27-1）,即 -128 ~ 127

uint8取值范围：0 ~ （2^8-1）,即 0 ~ 255

int16、int32、int64、uint16、uint32、uint64...依此类推

(3)浮点型：float32、float64、complex64、complex128

(4)字符串类型：string（注意string的首字母是小写的）

字符使用单引号括起来，字符的类型是int32

字符串使用双引号括起来，字符串类型是string

数据类型转换

GO语言中的数据类型转换必须是显示定义的

派生数据类型：

(1)指针(pointer)

(2)数组(array)

(3)结构体(struct)

(4)通道(channel)

(5)切片(slice)

(6)函数(function func)

(7)接口(interface)

(8)Map

4.运算符

（1）算数运算符

（2）关系运算符

（3）逻辑运算符

（4）位运算符

位运算符是操作二进制数的，与逻辑运算符容易混淆，需要注意

查看二进制数值，控制输出使用符号 %b

（5）赋值运算符

（6）其他运算符

5.获取键盘输入

6.命名规范

7.流程控制语句（程序结构）

（1）顺序结构

（2）分支结构

1）if语句

package main
import "fmt"
// 使用if语句实现学生分数评级
func main() {
	fmt.Println("请输入分数：")
	var score float32
	fmt.Scan(&score)
	if score <= 100 && score > 90 {
		fmt.Println("A")
	} else if score <= 90 && score > 80 {
		fmt.Println("B")
	} else if score <= 80 && score > 70 {
		fmt.Println("C")
	} else if score <= 70 && score > 60 {
		fmt.Println("D")
	} else if score <= 60 && score > 0 {
		fmt.Println("不及格")
	} else {
		fmt.Println("输入的格式不正确！")
	}
}

if语句的嵌套

2）switch语句

package main
import (
	"fmt"
)
// switch语句,匹配的条件是基本数据类型（整型、浮点型、字符串类型和布尔类型）
func main() {
	//调用自定义函数
	//switch1()
	switch2()
}
// 1.switch语句
func switch1() {
	fmt.Println("请输入姓名：")
	var name string
	fmt.Scan(&name)
	switch name {
	case "John":
		fmt.Printf("I am %s\n", "John")
	case "Lucy":
		fmt.Printf("I am %s\n", "Lucy")
	case "Lily":
		fmt.Printf("I am %s\n", "Lily")
	default:
		fmt.Println("不在学生名单中！")
	}
}
// 2.fallthrough实现case穿透
func switch2() {
	flag := false
	switch flag {
	case false:
		fmt.Println("条件为false")
		fallthrough //fallthrough实现case穿透
	case true:
		//break阻止case穿透
		if flag == false {
			break
		}
		fmt.Println("条件为true")
	default:
		fmt.Println("均不满足条件！")
	}
}

（3）循环结构

break和continue

循环结构demo

package main
import "fmt"
/*
GO语言流程控制
1.顺序结构:存续执行代码
2.分支结构（选择结构）:if语句、switch语句
3.循环结构:for语句
*/
// for语句
func main() {
	//调用自定义函数
	//for1()  //累计求和
	//for2()  //打印方阵
	//for3() //打印九九乘法表
	for4() //break和continue
}
func for1() {
	/*
		累计求和
	*/
	var sum int
	for i := 1; i <= 10; i++ {
		sum += i //即sum = sum + i
		fmt.Println(sum)
	}
	fmt.Printf("sum=%d\n", sum)
}
func for2() {
	/*
		打印一个5*8的方阵
	*/
	for i := 1; i <= 5; i++ {
		for j := 1; j <= 8; j++ {
			fmt.Printf(" * ") //打印输出*
		}
		fmt.Println() //换行
	}
}
func for3() {
	/*
		打印九九乘法表
	*/
	for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d*%d=%d ", j, i, i*j)
		}
		fmt.Println() //换行
	}
}
func for4() {
	/*break和continue
	1.break：跳出循环
	2.continue:结束本次循环，继续执行下一次循环
	*/
	for i := 0; i <= 5; i++ {
		if i == 3 {
			break //跳出循环
		}
		fmt.Println(i)
	}
	fmt.Println("================ 分隔线 ================")
	for i := 0; i <= 5; i++ {
		if i == 3 {
			continue //跳出本次循环，继续执行下一次循环
		}
		fmt.Println(i)
	}
}

（4）string

字符串相关操作demo

package main
import "fmt"
//字符串相关操作
func main() {
	//定义一个字符串str
	str := "Hello,World!"
	//1.获取字符串长度：使用len函数
	fmt.Println(len(str))
	fmt.Println("====================================")
	//2.获取字符串中的单个字符,下标从0开始计算
	fmt.Println(str[6])        //单个字符会打印其在ASCII编码表对应的值
	fmt.Printf("%c\n", str[6]) //格式化输出,单个字符使用符号%c
	fmt.Println("====================================")
	//3.for语句遍历输出字符串的每个字符
	for i, v := range str {
		fmt.Printf("%d %c\n", i, v) //格式化输出,打印下标和下标对应的字符
	}
	fmt.Println("====================================")
	for i := range str {
		fmt.Printf("%c ", str[i])
	}
}

8.函数

（1）函数的定义和使用

（2）可变参数 ...

1.函数的参数类型确定，但是参数个数不确定的情况下可以使用可变参数。

2.可变参数一般放在参数列表的最后，一个函数最多只能有一个可变参数。

（3）参数的传递

1.数值型的参数：值传递，即操作数据本身，值传递的是参数值的副本，对原有数据不产生影响。

2.引用型的参数：内存地址的传递，即直接操作在内存地址上，会对该地址的值产生影响。

数组的定义

数组，即

/*
	数组的定义格式:
	数组名 := [数组长度] 数组类型 {value1，value2...value}
*/

切片的定义

切片（slice）是可扩容的数组

/*
	切片的定义格式:切片的长度可变，所以不用设置切片的长度
	切片名 := [] 切片类型 {value1，value2...value}
*/

（4）变量的作用域

（5）递归函数

1.函数调用本身即为递归，递归函数需要一个出口，避免死循环。

2.一般情况下建议尽可能减少使用递归函数，因为递归会占用较多的内存空间，会降低性能。

（6）defer关键字：延迟执行

多个defer关键字，采用先进后出（栈）的模式

9.函数的高级应用

（1）函数的数据类型

1.函数本身就是一种数据类型，使用格式化输出符号%T可以查看数据类型。

注意：不能带上括号，带上括号时就会调用函数，直接使用函数名即可

2.不带上括号，单个函数名可以看作变量，即可以定义一个函数类型的变量并进行赋值

（2）匿名函数

匿名函数，即没有函数名的函数，一般匿名函数只会执行一次

（3）回调函数和函数的闭包

1.回调函数:将函数作为其他函数的参数，做参乎上的函数称为回调函数

2.函数的闭包:将函数作为其他函数的返回值，形成函数的闭包

高阶函数和回调函数

1.高阶函数：接收其他函数作为参数的函数称为高阶函数

2.回调函数：把自身作为参数的函数称为回调函数

package main
import "fmt"
/*
函数的高级应用：
4.回调函数，即将匿名函数作为函数的参数
*/
func main() {
	//3.调用高阶函数,将自定义的函数作为参数传递
	oper(20, 30, addNum)
	oper(200, 130, subNum)
	//4.也可以将匿名函数直接作为参数
	oper(99, 0, func(a, b int) int {
		if b == 0 {
			fmt.Println("除数不能为0！")
			return 0
		}
		return a / b
	})
}
// 1.定义一个高阶函数：接收其他函数作为参数的函数
func oper(a, b int, fun func(int, int) int) {
	res := fun(a, b)         //调用传递进来的函数，并将返回值赋值给变量res
	fmt.Println("res=", res) //输出res的变量值
}
// 2.自定义函数
func addNum(i, j int) int {
	return i + j
}
func subNum(i, j int) int {
	return i - j
}

函数的闭包

将函数作为其他函数的返回值，形成函数的闭包

package main
/*
函数的高级应用：
5.函数的闭包，即将匿名函数作为函数的返回值，形成函数的闭包结构
实际开发中尽量减少使用闭包结构，因为闭包结构容易造成代码阅读上的混淆，会增加代码维护的成本
*/
import "fmt"
func main() {
	//调用闭包结构的函数
	i := increment()
	fmt.Println(i) //2
}
// 定义一个闭包结构的函数
func increment() int {
	//1.定义局部变量i
	count := 1
	//2.定义一个匿名函数，实现自增，使用外层函数的局部变量作为参数并执行
	val := func(i int) int {
		return count + 1
	}(count) //3.内层匿名函数调用了外层函数的局部变量count
	//4.将内层函数的返回值返回给外层函数
	return val
}