配置GO环境
https://www.cnblogs.com/xiugeng/p/17228372.html(教程)
来源——休耕博客园
1.Hello World！
程序员的仪式感——学习一个语言后与世界打声招呼
package main #包声明
import "fmt" #想要实现输入输出功能必须导入fmt包
func main() {
fmt.Println("Hello World！") #print输出，ln自动换行
}
2.变量
GO定义变量要使用var关键字声明变量，并指定其类型
var num int //整型
var num float //浮点型
var str string //字符型
var flag bool //布尔型,只有true，false(默认值)两个值，一般用于判断
package main
import "fmt"
var str1 string = "Hello World!"
func main() {
fmt.Println(str1)
}定义多个变量(go中变量无需赋初值)
var(
num1 int
num2 float
str string
) GO语言中 := 可以识别变量类型
package main
import "fmt"
func main() {
str := "Hello World!"
num := 18
fmt.Println(str, num)
}GO中可以直接交换变量
package main import "fmt" func main() { a := 1 b := 2 a, b = b, a fmt.Println(a, b) }
3.常量
GO定义常量要使用const关键字声明常量，并指定其类型
const PI float32 = 3.14特性基本与变量一致
常量计数器
iota (go内置变量，从0开始，同一个const内)
4.运算符
与C语言几乎一致
5.循环
其他与C语言一致
for循环
package main
func main() {
count := 10
for i := 0; i < count; i++ {
println(i)
}
}
6.函数
与C语言一致
可变参数函数调用
package main
import "fmt"
func getsum(nums ...int) int {
sum := 0
for i := 0; i < len(nums); i++ {
sum += nums[i]
}
return sum
}
func main() {
fmt.Println(getsum(1, 2))
}
匿名函数
匿名函数可以自己调用自己，也可以赋值到其他函数上(func本身就是一个函数类型)
package main
import (
"fmt"
)
func main() {
fmt.Println(1)
f3 := func() {
fmt.Println(3)
}
func() {
fmt.Println(2)
}()
f3()
}
回调函数
在函数调用中调用函数
package main
import (
"fmt"
)
func main() {
a := 1
b := 2
r := com(a, b, sum)
fmt.Println(r)
r1 := com(a, b, sub)
fmt.Println(r1)
}
func com(a int, b int, fun func(int, int) int) int {
r := fun(a, b)
return r
}
func sum(a int, b int) int {
r := a + b
return r
}
func sub(a int, b int) int {
r := a - b
return r
}
闭包函数
当闭包函数被再次调用时，会重新开启循环，但不会忘记上次循环
package main
import (
"fmt"
)
func main() {
r1 := fun1()
r2 := fun1()
fmt.Println(r1())
fmt.Println(r1())
fmt.Printf("%d\t", r1())
fmt.Println(r2())
fmt.Printf("%d\t", r1())
fmt.Println(r2())
}
func fun1() func() int {
i := 0
fun := func() int {
i++
return i
}
return fun
}
输出
Type 'dlv help' for list of commands.
1
2
3 1
4 2
Process 37876 has exited with status 0
Detaching
defer延迟执行
将函数延迟到最后输出，多个defer会逆序输出
package main
import (
"fmt"
)
func main() {
fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
fmt.Println(4)
fmt.Println(5)
}
7.数组
定义长度初始化
package main
import (
"fmt"
)
func main() {
arr1 := [5]int{1, 2, 3, 4, 5}
fmt.Println(arr1)
}
自动识别长度初始化
package main
import (
"fmt"
)
func main() {
arr1 := [...]int{1, 2, 3, 4, 5}
fmt.Println(arr1)
}
指定下标数
package main
import (
"fmt"
)
func main() {
arr1 := [...]int{1: 2, 2: 3}
fmt.Println(arr1)
}
/*
输出
DAP server listening at: 127.0.0.1:61048
Type 'dlv help' for list of commands.
[0 2 3]
Process 34424 has exited with status 0
Detaching
*/8.map
无序的集合，类似于python中的字典
/*基础格式*/
package main
import (
"fmt"
)
var map1 map[string]int{"GO": 1, "java": 3}
func main() {
map2 := map[string]int{"GO": 2, "java": 4}
fmt.Println(map1)
fmt.Println(map2)
}
/*输出
map[GO:1 java:3]
map[GO:2 java:4]
*/
取map与判断map中是否有这个下标
package main
import (
"fmt"
)
var map1 = map[string]int{"GO": 1, "java": 3}
func main() {
map2 := map[string]int{"GO": 2, "java": 4}
fmt.Println(map1)
value, ok := map2["GO"]
if ok {
fmt.Println(value)
}
}删除map中的数据
package main
import (
"fmt"
)
func main() {
map2 := map[string]int{"GO": 2, "java": 4}
fmt.Println(map2)
delete(map2, "GO")
fmt.Println(map2)
}
遍历map中的数据
package main
import (
"fmt"
)
func main() {
map2 := map[string]int{"GO": 2, "java": 4}
fmt.Println(map2)
for _, v := range map2 {
fmt.Println(v)
}
fmt.Println(map2)
}
9.结构体
结构体：自定义的type
package main
import (
"fmt"
)
type User struct {
name string
age int
sex string
}
func main() {
var koniaoer User
fmt.Println(koniaoer)
koniaoer.name = "口鸟人"
koniaoer.age = 18
koniaoer.sex = "男"
fmt.Println(koniaoer)
}
结构体中父类的继承
package main
import (
"fmt"
)
type User struct {
name string
age int
sex string
} //父类
type student struct {
User //继承父类
school string
} //子类
func main() {
var koniaoer student
fmt.Println(koniaoer)
koniaoer.name = "口鸟人"
koniaoer.age = 18
koniaoer.sex = "男"
koniaoer.school = "高中"
fmt.Println(koniaoer)
}
接口的调用
package main
import "fmt"
type AA struct {
text1 string
} //父类
type BB struct {
AA //继承父类
text2 string
} //子类
type CC struct {
AA
BB
text3 string
}
func main() {
c := CC{
AA: AA{text1: "1"},
BB: BB{AA: AA{text1: "2"}, text2: "2b"}, // 注意这里我们不需要重复设置AA的text1，因为BB已经包含了AA
text3: "3",
}
fmt.Println(c.text1)
}
7.GO中错误的处理
GO语言错误处理是通过返回错误值（通常是一个实现了error接口的值）来完成的。error接口是一个内建接口
package main
import (
"fmt"
"os"
)
/*在查询执行中，我们应该提前想到所有错误*/
func main() {
file, err := os.Open("koniaoer.txt")
/*
进行打开一个文件的操作
1.文件不存在
2.文件被占用
3.文件被损耗
*/
if err != nil {
fmt.Println(err)
return
}
fmt.Println(file.Name())
}GO语言希望通过显式的方式鼓励对错误的处理，而不是抛出这个问题
简单判断年龄是否合法
package main // 声明这个程序属于main包，即程序的入口点
import ( // 导入程序所需的包
"bufio" // 用于提供缓冲的I/O操作
"errors" // 用于创建和操作错误值
"fmt" // 提供格式化I/O功能
"os" // 提供操作系统相关的功能，如与文件系统的交互
"strconv" // 提供基本数据类型和其字符串表示之间的转换
"strings" // 提供字符串操作功能
)
/*
在查询执行中，我们应该提前想到所有错误
这是一个注释，说明在编写程序时，特别是执行可能出错的操作时，应该考虑并处理所有可能的错误情况。
*/
func main() { // 程序的入口点
reader := bufio.NewReader(os.Stdin) // 创建一个新的bufio.Reader，用于从标准输入（通常是键盘）读取数据
fmt.Print("输入年龄: ") // 在控制台上打印提示，让用户输入年龄
// 使用reader.ReadString('\n')从标准输入读取一行数据（直到遇到换行符'\n'）
// 这里注意：这里并没有处理ReadString可能返回的错误，这是一个潜在的改进点
text, _ := reader.ReadString('\n')
// 使用strings.TrimSpace去除文本字符串两端的空白字符（如空格、制表符、换行符等）
text = strings.TrimSpace(text)
// 使用strconv.Atoi将字符串转换为整数。如果字符串不能转换为整数，会返回一个错误
age, err := strconv.Atoi(text)
if err != nil { // 如果转换出错（例如，输入的不是数字）
fmt.Println(err) // 打印错误信息
return // 结束main函数，程序退出
}
// 调用自定义的age_err函数检查年龄是否在合理范围内
if err := age_err(age); err != nil {
fmt.Println(err) // 如果年龄不合法，打印错误信息
return // 结束main函数，程序退出
}
// 如果年龄合法，打印年龄
fmt.Println(age)
}
// age_err是一个自定义函数，用于检查给定的年龄是否在合理范围内（0到100之间）
func age_err(age int) error {
if age < 0 || age > 100 { // 如果年龄小于0或大于100
return errors.New("年龄不合法") // 返回一个错误，表示年龄不合法
}
return nil // 如果年龄合法，返回nil表示没有错误
}xun'huan
评论区