😋 大家好，我是YAy_17，是一枚爱好网安的小白。
本人水平有限，欢迎各位大佬指点，欢迎关注 😁，一起学习 💗 ，一起进步 ⭐ 。
⭐ 此后如竟没有炬火，我便是唯一的光。 ⭐

Go语言学习Day1

package main
//表示hello.go文件所在的包是main，在GO中每一个文件都归属于一个包
import "fmt"
//导入一个包，“fmt”，之后便可以使用fmt中的函数，例如"fmt.Println()"
func main() {//func是一个关键字，main是函数名，同时也是主函数，是整个程序的入口fmt.Println("hello world")//使用fmt包中的函数Println()来输出hello world
}

GO语言的两种执行流程

1. 先编译（go build *.go文件）生成可执行文件（*.exe），之后再运行可执行文件；（可以生成自己命名的可执行程序，go build -o myhello.exe hello.go）

2. 直接使用go run *.go文件，进行运行

两种执行流程的区别和优缺点：

3. 如果我们先编译生成可执行文件，再运行可执行文件，那么我们可以将生成的可执行文件移植到一台没有go开发环境的机器上进行执行

4. 如果我们是直接使用 go run *.go文件，那么就需要运行的机器必须具备go语言的开发环境

5. 在编译的时候，编译器会将程序运行所依赖的库文件全部包含到可执行文件中，因此生成的可执行文件比较大

Go语言的开发注意事项

Go语言常用的转义字符

// Go语言中的常用转移字符
package main
import "fmt"func main() {fmt.Println("hello\nworld!")fmt.Println("hello\tY4y17")fmt.Println("D:\\Microsoft VS Code\\GO\\Gocode\\src\\go_code")fmt.Println("Y4y17说\"Golang yyds\"")fmt.Println("小黑子露出鸡脚了吧\r我是ikun")
}

需要注意的是最后面的\r，其他的都比较的熟悉，\r代表着：输出当前行的内容，然后从\r后面开始的地方，覆盖掉最前面的内容

标识符、关键字和命名规则

标识符的组成

1. 标识符只能由数字、字母和下划线组成

2. 标识符的开头只能是字母和下划线

3. 标识符是区分大小写的

package main
import "fmt"
func main(){var name string 	//定义变量的时候要写上var 然后是变量的名字 最后是变量的类型var age int var _sys int
}

关键字

GO语言提供了25个关键字；

Golang变量声明

声明变量的语法：

var idetifier type
var：声明变量的关键字
identifier：变量的名称
type：变量的类型
PS：定义变量之后，必须要使用，不使用就会出错！

批量声明

package main
var(name stringage int b bool
)

尝试打印输出：

变量初始化

逐个变量进行初始化

func main() {var name string = "Y4y17"var age int = 21var b bool = truefmt.Printf("name:%v\n", name)fmt.Printf("age:%v\n", age)fmt.Printf("b:%v", b)
}

多个变量初始化

func main() {var name,age,b = "Y4y17",21,truefmt.Printf("name:%v\n", name)fmt.Printf("age:%v\n", age)fmt.Printf("b:%v", b)
}

类型推断

var name = "Y4y17"	//不需要后面的数据类型

短变量声明

在函数内部，可以使用：=运算符对变量进行声明和初始化

package main
func main(){name := "Y4y17"age := 21
}

这种方法只适合在函数内部，函数外部不能使用

匿名变量

package main
import "fmt"
func GetNameAndAge() (string, int) {return "Y4y17", 21
}func main() {name, age := GetNameAndAge()fmt.Printf("name:%v\tage:%v", name, age)
}package main
import "fmt"
func GetNameAndAge() (string, int) {return "Y4y17", 21
}func main() {name, age := GetNameAndAge()fmt.Printf("name:%v\tage:%v", name, age)
}//有的时候比如name没有用到，我们还可以用下划线替换掉name
func GetNameAndAge() (string, int) {return "Y4y17", 21
}func main() {_,age := GetNameAndAge()fmt.Printf("age:%v",age)
}

常量的初始化

有一个比较特殊的常量，他是可以更改值的，iota默认开始值为0，每调用一次加1，遇到const关键字的时候被重置为0

package mainimport ("fmt"
)
func main() {const (a1 = iotaa2 = iotaa3 = iota)fmt.Printf("a1: %v\n", a1)fmt.Printf("a2: %v\n", a2)fmt.Printf("a3: %v\n", a3)
}
//输出的结果为0 1 2

使用”_“来跳过某一些值

package mainimport ("fmt"
)
func main() {const (a1 = iota_a3 = iota)fmt.Printf("a1: %v\n", a1)fmt.Printf("a3: %v\n", a3)
}
//输出的结果为0  2

iota中间插队

package mainimport ("fmt"
)
func main() {const (a1 = iota_a3 = iota)fmt.Printf("a1: %v\n", a1)fmt.Printf("a3: %v\n", a3)
}
//输出的结果为0  2

Go语言的数据类型

package main
import ("fmt"
)func main() {var name string = "zhangsan"age := 20b := truefmt.Printf("%T\n%T\n%T\n", name, age, b)inter := &agefmt.Printf("%T\n", inter)a := [2]int{1, 2}efmt.Printf("%T\n", a)c := []int{1,2,3}fmt.Printf("%T\n",c)
}

分别输出：

最后面的c := []int{1,2,3} 他不是数组，它叫做切片，也是个动态的数组，就是当长度不指定的时候，便是切片；

数字类型：

Go语言字符串字面量

在Go语言中，字符串字面量使用双引号”“或者是反引号来创建。在Go语言中没有char类型，单行的字符串用双引号，多行的字符串用的是反引号；

package mainimport "fmt"func main() {var str string = "hello"str2 := `line 1line 2line 3`fmt.Printf("str: %v\n", str)fmt.Printf("str2: %v\n", str2)
}

字符串的连接

”+“号

package main
import ("fmt"
)
func main() {name := "Y4y17"age := "20"s := name + agefmt.Printf("s: %v\n", s)}

fmt.Sprintf()

package main
import ("fmt"
)
func main() {name := "Y4y17"age := "20"s1 := fmt.Sprintf("%v,%v", name, age)fmt.Printf("s1: %v\n", s1)
}

strings.Join()

package main
import ("fmt""strings"
)
func main() {name := "Y4y17"age := "20"s2 := strings.Join([]string{name, age}, ",")fmt.Printf("s2: %v\n", s2)
}
//strings.Join这种方式，两个参数，第一个参数是一个用来连接的空的数组，第二个参数是
//用来连接时的中间的分隔符

write.buffer

package mainimport ("bytes""fmt"
)func main() {var buffer bytes.Bufferbuffer.WriteString("Y4y17")buffer.WriteString(",")buffer.WriteString("20")fmt.Printf("buffer.String(): %v\n", buffer.String())
}

Go语言中的切片操作

package mainimport "fmt"
func main() {s := "hello world"n := 3m := 5fmt.Printf("s[n]: %v\n", s[n])fmt.Printf("s[n:m]: %v\n", s[n:m])		//前闭后开区间  [)fmt.Printf("s[n:]: %v\n", s[n:])fmt.Printf("s[:m]: %v\n", s[:m])
}

Go语言中的字符串函数

package mainimport ("fmt""strings"
)func main() {s := "hello World"//返回字符串的长度fmt.Printf("len(s): %v\n", len(s))//字符串的分割函数fmt.Printf("strings.Split(s, \" \"): %v\n", strings.Split(s, " "))//判断字符串中是否包含另一个字符串fmt.Printf("strings.Contains(s, \"hello\"): %v\n", strings.Contains(s, "hello"))//转换小写fmt.Printf("strings.ToLower(s): %v\n", strings.ToLower(s))//转化大写fmt.Printf("strings.ToUpper(s): %v\n", strings.ToUpper(s))//判断字符串中是否含有某个前缀fmt.Println(strings.CutPrefix(s, "hello"))//判断字符串中时候含有某个后缀fmt.Println(strings.CutSuffix(s, "World"))}

Go格式化输出

package mainimport "fmt"type website struct {name string
}func main() {site := website{name: "Y4y17.com"}fmt.Printf("site: %v\n", site)  //%v 代表的就是varfmt.Printf("site: %#v\n", site) //%#v 会将详细内容输出fmt.Printf("site: %T\n", site)  //%T代表的是type
}

Go语言的运算符

与其他的语言一样，+ - * / %的用法都是一样的，当然还有自增和自减的运算符（++ --）

package main
import "fmt"
func main() {a := 10b := 21fmt.Printf("a: %v\n", a)fmt.Printf("b: %v\n", b)fmt.Printf("(a + b): %v\n", (a + b))fmt.Printf("(a - b): %v\n", (a - b))fmt.Printf("(a / b): %v\n", (a / b))fmt.Printf("(a * b): %v\n", (a * b))//fmt.Printf("(b % a): %v\n", (b % a))c := b % 10fmt.Printf("c: %v\n", c)//++ --a++fmt.Printf("a: %v\n", a)b--fmt.Printf("b: %v\n", b)
}
/*
a: 10
b: 21
(a + b): 31
(a - b): -11
(a / b): 0
(a * b): 210
c: 1
a: 11
b: 20
*/

Golang中的选择结构

if else语句

package mainimport "fmt"func main() {a := 18if a > 18 {fmt.Println("成年")} else {fmt.Println("未成年")}
}

Go语言不同于其他的语言，它可以在if语句中定义变量：

package mainimport "fmt"func main() {if a := 18; a > 18 {fmt.Println("成年")} else {fmt.Println("未成年")}
}

if else if语句

package mainimport "fmt"func main() {if a := 18; a > 18 {fmt.Println("成年")} else if a < 18 {fmt.Println("未成年")} else {fmt.Println("18岁")    }
}

switch结构

package main
import "fmt"
func f1() {var day intfmt.Scan(&day)switch day {case 1, 2, 3, 4, 5:	//只要匹配到一个值就可以fmt.Println("work day")case 6, 7:fmt.Println("relax")default:fmt.Println("输入出错")}
}func main() {f1()
}
在Go语言中，不需要使用break
package mainimport "fmt"func f1() {score := 60//当switch后面什么都不写的时候，默认为trueswitch {case score >= 60:fmt.Println("及格")case score > 70 && score <= 100:fmt.Println("优秀")default:fmt.Println("不及格")}
}func main() {f1()
}

fallthrough(穿漏)

package mainimport "fmt"func f1() {score := 100switch score {case 100:fmt.Println("100")fallthrough		//加上fallthrough的时候，会继续向下执行case 200:fmt.Println("200")case 300:fmt.Println("300")}
}
func main() {f1()
}

Go语言中switch语句的注意事项

1. 支持多条件匹配

2. 不同的case之间不使用break分割，默认只会执行一个case

3. 如果想要执行多个case，需要使用fallthrough关键字，也可以用break终止

4. 分支还可以使用表达式，例如a>10

Go语言中的for循环

//格式还是和其他的语言是一样的，只不过不需要加上括号
package mainimport "fmt"func f1() {// i := 1// for i <= 10 {// 	fmt.Printf("i: %v\n", i)// 	i++// }for i := 1; i <= 10; i++ {fmt.Printf("i: %v\n", i)}
}
func main() {f1()
}

for range循环

Go语言中可以使用for range遍历数组、切片、字符串、map以及通道。通过for range遍历的返回值具有以下的规律:

1. 数组、切片、字符串返回索引和值

2. map返回键和值

3. 通道只返回通道内的值

package mainimport "fmt"func f() {var a = [...]int{1, 2, 3, 4, 5, 6}	//当[]内什么都不写的时候，就是切片// for i, v := range a {// 	fmt.Printf("i: %v\tv: %v\n", i, v)// }//还可以直接输入forr，快捷键for _, v := range a {fmt.Printf("v: %v\n", v)}
}
func main() {f()
}
package mainimport "fmt"func f() {m := make(map[string]string, 0)m["name"] = "Y4y17"m["age"] = "23"m["email"] = "Y4y17@email.com"for key, value := range m {fmt.Printf("key: %v\tvaule: %v\n", key, value)}
}
func main() {f()
}

Go语言中的跳转语句

break

break除了在switch 和 for循环中去使用，还可以在标签中使用：

package mainimport "fmt"func f() {
MYLABEL:for i := 0; i < 10; i++ {fmt.Printf("i: %v\n", i)if i >= 5 {break MYLABEL}}fmt.Println("END")
}func main() {f()
}

continue

package mainimport ("fmt"
)func f1() {for i := 0; i < 10; i++ {MYLABLE:for j := 0; j < 10; j++ {if i == 2 && j == 2 {	//跳过i=2 j=2的情况continue MYLABLE}fmt.Printf("%v:%v\n", i, j)}}
}
func f() {for i := 0; i < 10; i++ {if i == 2 {continue} else {fmt.Printf("i: %v\n", i)}}
}func main() {// f()f1()
}

goto

goto语句常用于跳出多层循环

package mainimport ("fmt"
)func f2() {for i := 0; i < 10; i++ {for j := 0; j < 10; j++ {if i == 2 && j == 2 {	//当i=2 j=2的时候，直接跳出两个循环，跳到END继续运行goto END}fmt.Printf("%v:%v\n", i, j)}}
END:fmt.Printf("end...")
}
func main() {f2()
}

Go语言中的数组

定义和初始化

package mainimport "fmt"func test1() {//数组的定义var a1 [2]intvar a2 [3]stringvar a3 [2]boolfmt.Printf("a1: %T\n", a1)fmt.Printf("a2: %T\n", a2)fmt.Printf("a3: %T\n", a3)//数组的初始化var a4 = [2]int{3, 4}var a5 = [2]string{"Y4y17", "hello"}var a6 = [2]bool{true, false}fmt.Printf("a4: %v\n", a4)fmt.Printf("a5: %v\n", a5)fmt.Printf("a6: %v\n", a6)var a7 = [...]int{7, 8, 9}fmt.Printf("len(a7): %v\n", len(a7))//根据索引进行赋值var a8 = []int{0: 1, 5: 9}var a9 = []string{1: "Y4y17", 8: "hello"}fmt.Printf("a8: %v\n", a8)fmt.Printf("a9: %v\n", a9)
}
func main() {test1()
}

数组的遍历

package mainimport "fmt"func test1() {var a = [5]int{1, 2, 3, 4, 6}for i := 0; i < len(a); i++ {fmt.Printf("a[%v]: %v\n", i, a[i])}
}
func test2() {var str = [4]string{"Y4y17", "hello", "world", "7777"}for i, v := range str {		//其中i代表的是索引值，v代表的就是str[i]//如果不想使用i（索引值），那么我们可以将i修改为下划线(_)fmt.Printf("str[%v]: %v\n", i, v)}
}
func main() {test1()fmt.Printf("-----------\n")test2()
}

输出结果如下：

Go语言中的切片

切片的声明

package mainimport "fmt"func test1() {//切片的声明var list1 []intfmt.Printf("list1: %v\n", list1)var list2 = make([]int, 2)fmt.Printf("list2: %v\n", list2)//切片的初始化var list3 = []int{1, 2, 3}fmt.Printf("list3[1]: %v\n", list3[1])//输出list2的长度和容量fmt.Printf("len(list2): %v\n", len(list2))fmt.Printf("cap(list2): %v\n", cap(list2))
}
func main() {test1()
}

切片的初始化

针对切片的切分遵循：左闭右开 即 [ )

package mainimport "fmt"func test1() {//第一种初始化var list1 = []int{1, 2, 3, 4}fmt.Printf("list1: %v\n", list1)//第二种初始化//利用数组进行初始化var a = [...]int{1, 2, 3, 4, 5, 6}list2 := a[2:5]fmt.Printf("list2: %v\n", list2)list3 := a[2:]fmt.Printf("list3: %v\n", list3)list4 := a[:]fmt.Printf("list4: %v\n", list4)list5 := a[:5]fmt.Printf("list5: %v\n", list5)
}
func main() {test1()
}

切片的遍历

同样切片的遍历和数组的遍历类似，存在两种遍历的方式：

package main
import "fmt"
func test1() {var list1 = []int{1, 2, 3, 4, 5, 6}for i := 0; i < len(list1); i++ {fmt.Printf("list1[%v]: %v\n", i, list1[i])}
}
func test2() {var list1 = []int{1, 2, 3, 4, 5, 6}for i, v := range list1 {fmt.Printf("i:%v v: %v\n", i, v)}
}
func main() {// test1()test2()
}

切片的增删改查

package mainimport "fmt"//add
func add() {var list = []int{1, 3, 2, 5, 99}list = append(list, 100)fmt.Printf("list: %v\n", list)
}//delete
func delete() {var list = []int{1, 2, 3, 4, 5, 6, 7}list = append(list[:3], list[4:]...) //删除索引为3的元素fmt.Printf("list: %v\n", list)
}//update
func update() {var list = []int{1, 2, 3, 4, 5, 6, 7}list[4] = 777fmt.Printf("list: %v\n", list)
}//query
func query() {var list = []int{1, 2, 3, 4, 5, 6, 7}key := 5for _, v := range list {if key == v {fmt.Printf("v: %v\n", v)}}
}//copy函数的用法
func test() {var list = []int{1, 2, 3, 4}var list2 = make([]int, 4)copy(list2, list)// fmt.Printf("list: %v\n", list)fmt.Printf("list2: %v\n", list2)}
func main() {//add()// delete()// update()//query()test()
}

Go语言中的map

map是一种无序的键值对的集合；最重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值；

两种定义map的方式：

1. 一种是通过内建函数make

2. 另一种是通过map关键字来定义Map

package mainimport "fmt"
func test2() {map1 := map[string]string{"name": "Y4y17", "age": "23", "email": "xxx.com"}for _, v := range map1 {fmt.Printf("v: %v\n", v)}
}
func test1() {//map的声明var map1 map[string]string//创建集合map1 = make(map[string]string)//map 插入key-value对map1["name"] = "Y4y17"map1["age"] = "23"map1["email"] = "xxx.com"//使用键来输出map值for site := range map1 {fmt.Println(site, "---->", map1[site])}v, ok := map1["name"]fmt.Printf("v: %v\n", v)fmt.Printf("ok: %v\n", ok)v, ok = map1["ages"]fmt.Printf("v: %v\n", v)fmt.Printf("ok: %v\n", ok)
}
func main() {test1()
}