Golang 基础

第一节课：编译

创建文件的时候需要初始化当前目录，那么需要在当前目录执行如下：

1
go mod init [文件名]/[Github]

常规编译

1
2
3
4
go build

或
go run main.go

go run不会生成程序，build会。

跨平台编译

直接编译:

1
go build -ldflags="-s -w " -trimpath

mac下编译Linux和windows平台64位可执行程序：

1
2
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build

Linux下编译mac和windows平台64位可执行程序：

1
2
CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build

windows下编译mac和Linux平台64位可执行程序：

1
2
3
4
SET CGO_ENABLESD=0
SET GOO S=darwin
SET GOARCH=amd64
go build

第二节课：基础语法

  • 一行代码标识一条语句的结束后续不需要添加分号。
  • 花括号只能是跟在里面用，例如：func main() {
  • 变量赋值语句只能写在mian里
  • 变量声明没使用也会促发错误
  • go里自带自动化格式化代码攻击，仅需执行:go fmt main.go
  • 推荐使用驼峰命名法

有意思的问题

1
2
3
1、fmt.Println()和fmt.Printf()的区别
答：针对转义符的处理不同，printf()函数会将输入参数中的%d类型的值进行带入。

第三节课：变量和常量

标识符

只能以字母数字组成，不能数字开头，只能说是字母或”_”开头。

关键词

在go语言中有25个关键词

1
break、default、func、interface、select、case、defer、go、map、struct、chan、else、goto、package、switch、const、fallthrough、if、range、type、continue、for、import、returen、var

此外还有三十七个保留字

变量

标准声明变量格式

1
var 变量名 变量类型

变量声明以关键词var开头，变量类型放在变量的后面，行尾无需分毫，举个例子：

1
2
3
var name string
var age ing
var isOk false

批量声明

1
2
3
4
5
var(
  a string
  b string
  c int
)

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {
	//标准声明格式
	var name string
	var age int
	fmt.Println(name, age)
	//批量声明变量
	var (
		a int
		b int
		c string = "this is c" //给c设置初始值
	)
	fmt.Println(a, b, c)     //由于连默认会输出两个0和this is c
	var x1, x2 = "hello", 29 //两个变量同时赋值
	fmt.Println(x1, x2)
}

go支持类型推导，也就是会根据你赋值的值然后判断变量的类型，例如如下：

1
var name = "helloworld"//这个就没写类型，是因为自动进行了类型推导。

短变量声明

如下代码，自动声明一个变量，默认值为10

1
m:=10

匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用“匿名变量（Anonymous variable）”匿名变量用一个下划线_表示，匿名变量不占用命名空间，不会分批内存，不存在重复声明。

_ 多用于占位，表示忽略值。

案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import (
	"fmt"
)

// var x int
// var y string

func foo() (int, string) {
	return 10, "hell world"
}
func main() {
	//标准声明格式
	x, _ := foo()
	_, y := foo()
	fmt.Println("x = ", x)
	fmt.Println("y = ", y)
}

需要注意的是

  • 函数外的每个语句都必须以关键词开始(var、const、func等)
  • :=不能使用在函数外
  • _多用于占位，表示忽略值

常量

相对变量，常量是恒定不变，由关键词var换成了const,在定义的时候必须赋值。多用于配置项，不会变化的值。

和变量一样可以单个生成也可以多个生成

1
2
3
4
5
6
7
8
9
10
11
12
package main
import "fmt"
//批量定义常量
const (
	n1 = 100
	n2 = 200
)

func main() {
	const a = "admin"
	fmt.Println(n1)
}

iota

iota只能在常量表达式中使用，iota遇到const关键词的时候默认值为0，const中每新增一行常量声明将iota计数一次。

举个例子：

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

const (
	n1 = iota
	n2 = iota
)

func main() {
	fmt.Println(n2)//这时候输出的n2就是为1，n1为0，那如果还有n3,n3就为2，枚举的时候很有用
}

如果要跳过某个值那么可以结合匿名变量。如下所示：

1
2
3
4
5
6
7
8
9
const (
	n1 = iota
	_  = iota
	n3 = iota
)

func main() {
	fmt.Println(n1, n3)//输出的值就为：0 2，因为1已经被匿名变量忽略了。
}

iota中间插队

1
2
3
4
5
6
7
8
9
10
11
const (
	n1 = iota
	n2 = 200
	n3 = iota
)

const n4 = iota

func main() {
	fmt.Println(n1, n2, n3, n4)//输出内容为：0 200 2 0,为n3输出的是2不是201呢，因为是次数相加，不是值相加。
}

第四节课：数据类型

go语言中，数据类型除了基本的整型、浮点型、布尔型、字符串以外还有数组、切片、结构体、函数、map、通道(channel)、等。

整型

进制转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import "fmt"

func main() {

	n := 10
	fmt.Printf("%d\n", n) //十进制转换八进制
	fmt.Printf("%b\n", n) //十进制转换二进制
	fmt.Printf("%x\n", n) //十进制转换十六进制

	m := 0777777
	fmt.Printf("%d\n", m) //八进制转换为十进制
	fmt.Printf("%b\n", m) //八进制转换为二进制

	p := 000111111111111111111
	fmt.Printf("%d\n", p) //二进制转换为十进制

	x := 0x270f
	fmt.Printf("%d\n", x) //十六进制转十进制
}

主要是记住如下这几个：

1
2
3
4
%b 表示二进制
%o 表示八进制
%d 表示十进制
%x 表示十六进制

浮点数

fmt.Pringln(math.MaxFloat32)

fmt.Pringln(math.MaxFloat64)

复数

布尔值

  • 默认为false
  • 不允许将整型转换为布尔型，例如1不能表示true，0不能表示false
  • 布尔值无法参与数值运算，也无法与其他类型进行转换。

字符串转义符

go语言里的字符串内部使用utf-8编码，字符串的值为双引号中的内容，可以在go语言的源码中直接添加非ascii字符串，例如：

1
2
s1 := "hello"
s2 := "你好"

go语言的字符串常见转义符包括回车、换行、但双引号、制表符等，如下表所示：

转义符 含义
\r 回车符（返回行首）
\n 换行符（直接跳到下一行的同列位置）
\t 制表符
\' 单引号
\" 双引号
\\ 反斜杠
%T 1

多行字符串

1
2
3
4
5
6
7
8
9

func main() {

	s1 := `
	NIHAO
	hello world
	`
	fmt.Println(s1)
}

字符串常用操作

1
2
3
4
5
6
7
8
9
10
11
12
13
len 求字符串长度

+或fmt.Sprintf

strings.Split 分割

Strings.consains 判断是否包含

Strings.HasPrefix,strings.HasSubffx 前缀、后缀判断

strings.index(),strings.LastIndex() 子串出现的位置

Strings.join(a[]string,sep string) jion操作

演示代码案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func main() {

	s1 := "ni"
	s2 := "hao"
	fmt.Printf(s1 + s2) //字符串拼接
	s3 := "how are you ."
	//字符串分割
	fmt.Printf(strings.Split(s3, " ")[0])
	//是否包含x
	fmt.Println(strings.Contains(s1, "x"))
	//判断是否x开头
	fmt.Println(strings.HasPrefix(s1, "x"))
	//判断是否i结尾
	fmt.Println(strings.HasSuffix(s1, "i"))
	//检索出现的位置
	fmt.Println(strings.Index(s3, "are"))
	//join
	s4 := []string{"how", "do", "you", "do"}
	fmt.Println(strings.Join(s4, "-"))
}

byte和runne类型

  • uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
  • rune类型，代表一个 UTF-8字符。
  • Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。
1
2
3
4
5
6
7
8
9
func main() {
	s := "nihao帅哥"
	for i := 0; i < len(s); i++ {//byte
		fmt.Printf("%c\n", s[i])
	}
	for _, r := range s {//rune
		fmt.Printf("%c\n", r)
	}
}

第五节课：运算符

Go 语言内置的运算符有：

  1. 算术运算符
  2. 关系运算符
  3. 逻辑运算符
  4. 位运算符
  5. 赋值运算符

算术运算符

运算符 描述
+ 相加
- 相减
* 相乘
/ 相除
% 求余

关系运算符

运算符 描述
== 检查两个值是否相等，如果相等返回 True 否则返回 False。
!= 检查两个值是否不相等，如果不相等返回 True 否则返回 False。
> 检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
< 检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

逻辑运算符

运算符 描述
&& 逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
|| 逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
! 逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。

位运算符

位运算符对整数在内存中的二进制位进行操作。

运算符 描述
& 参与运算的两数各对应的二进位相与。 （两位均为1才为1）
| 参与运算的两数各对应的二进位相或。 （两位有一个为1就为1）
^ 参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 （两位不一样则为1）
<< 左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
>> 右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。

赋值运算符

运算符 描述
= 简单的赋值运算符，将一个表达式的值赋给一个左值
+= 相加后再赋值
-= 相减后再赋值
*= 相乘后再赋值
/= 相除后再赋值
%= 求余后再赋值
<<= 左移后赋值
>>= 右移后赋值
&= 按位与后赋值
|= 按位或后赋值
^= 按位异或后赋值

第六节课：流程控制语句

if else(分支结构)

1
2
3
4
5
6
7
if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

for(循环结构)

1
2
3
for 初始语句;条件表达式;结束语句{
    循环体语句
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
	a := 10
	if a >= 10 {
		fmt.Println("hello")
	}
	// for a := 0; a < 10; a++ {
	// 	fmt.Println("hello world")
	// }
}

switch case

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func switchDemo1() {
	finger := 3
	switch finger {
	case 1:
		fmt.Println("大拇指")
	case 2:
		fmt.Println("食指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("无名指")
	case 5:
		fmt.Println("小拇指")
	default:
		fmt.Println("无效的输入！")
	}
}

案例：

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
package main

func main() {
	// if 语句
	// a := 10
	// if a >= 10 {
	// 	fmt.Println("hello")
	// }
	// for 循环语句
	// for a := 0; a < 10; a++ {
	// 	fmt.Println("hello world")
	// }
	// switch 循环语句
	// finger := 1
	// switch finger {
	// case 1:
	// 	fmt.Println("this is 1111")
	// case 2:
	// 	fmt.Println("this is 2222")
	// }
	// break跳出循环
	// for i := 0; i < 10; i++ {
	// 	if i == 2 {
	// 		// 设置退出标签
	// 		break
	// 	}
	// 	fmt.Println(i)
	// }

}

第七节课：数组

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
33
34
35
36
37
38
package main

func main() {
	//数组初始化值
	// var intArray = [3]int{}
	// fmt.Println(intArray)
	//编译器推导数组长度
	//var cityArray = [...]string{"北京", "上海", "山东"}
	// fmt.Println(len(cityArray))
	// fmt.Println(cityArray)
	//使用for遍历数组
	// var cityArray = [...]string{"北京", "上海", "山东"}
	// for i := 0; i < len(cityArray); i++ {
	// 	fmt.Println(cityArray[i])
	// }
	//使用for range遍历数组
	// var cityArray = [...]string{"北京", "上海", "山东"}
	// for _, v1 := range cityArray {
	// 	fmt.Println(v1)
	// }
	// 二维数组
	// cityArray := [3][2]string{
	// 	{"name", "admin"},
	// 	{"password", "123456"},
	// }
	// fmt.Println(cityArray[0][0])
	// 二维数组遍历
	// cityArray := [2][2]string{
	// 	{"name", "admin"},
	// 	{"password", "123456"},
	// }
	// for _, v1 := range cityArray {
	// 	fmt.Println(v1)
	// 	for _, v2 := range v1 {
	// 		fmt.Println(v2)
	// 	}
	// }
}

第八节课：函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

// 函数格式
/*
func function_name( [parameter list] ) [return_types] {
   函数体
}

// init函数（该函数会在main之前执行，用以初始化值）
func init(a int) int{
	return 
}
// 函数存在多个返回值的情况下
func swap(x, y string) (string, string) {函数体}

// 参数名的多种声明
func init(a int,b int)也可以func inti(a,b init)这样默认两个参数都是int型。

匿名函数

顾名思义，就是没有名字的函数，只能调用一次。不占用内存空间。

1
2
3
4
5
6
7
8
9
10
11
12
13
func test() {
	res1 := func(n1, n2 int) int {//可以在这里看到这个函数名并没有名字
		return n1 + n2
	}(100, 2000)//这里赋值
	fmt.Println(res1)
}
// 其实在这个时候res1已经是一个函数类型了，调用也可以直接通过
func test() {
	res1 := func(n1, n2 int) int {
		return n1 + n2
	}
	fmt.Println(res1(100, 2000))
}

第九节课：闭包

内部函数引用外部函数的变量就叫闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func AddUpper() func(int) int {
	var n = 10
	return func(x int) int {
		n = n + x
		return n
	}
}

func main() {
	data := AddUpper()
	fmt.Println(data(1))
	fmt.Println(data(1))
	fmt.Println(data(1))
}
// 输出结果如下所示：
11
12
13
// 每调用一次在之前的基础中再加data的值。

闭包案例：判断是否存在jpg，如果存则直接输出，否则则加上jpg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func makeSuffix() func(string) string {
	var Suffix = ".jpg"
	return func(Filename string) string {
		if strings.HasSuffix(Filename, "jpg") {
			return Filename
		} else {
			return Filename + Suffix
		}
	}
}

func main() {
	data := makeSuffix()
	fmt.Println(data("xxx.jpg"))
	fmt.Println(data("xxx.php"))
	fmt.Println(data("xxx.jsp"))

}

第十节课：defer

资源释放，有点像面对对象里的构析方法。

1、先入后出规则（如下代码第二第三行，先入defer栈的是第二行的hello1，然后再是hello2）

2、在return后执行defer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func test(n1, n2 int) int {
	defer fmt.Println("this is hello1")
	defer fmt.Println("this is hello2")
	fmt.Println(n1 + n2)
	return n1 + n2//这个是没输出的，所以在输出的时候没有体现。输出的300是Println的。
}

func main() {
	test(100, 200)
}
// 输出如下所示
/*
300
this is hello2
this is hello1
*/

第十一节课：切片

切片与数组

​ 数组是固定长度，可以容纳相同数据类型的元素集合。当长度固定的时候使用带来一些限制，例如：申请长度太大浪费内存，申请太小不够用。

​ 切片长度可变，底层也是基于数组实现的，增加了自动扩容功能。切片（Slice）是一个拥有相同类型元素的可变长度的序列。

切片声明

1
2
//格式
var identifier []type

切片是应用类型，可以使用make函数来创建切片：

1
2
3
var slice1 []type = ([]type,len)
//也可以简写成
slice1 := make([]type,len)

代码案例：

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
33
34
35
36
37
38
39
40
41
42
43
44
package main

import (
	"fmt"
)

func test() {
	// 常规切片声明
	var s1 []string //不赋值的情况不需要空格
	var s2 = []string{"你好", "彦祖"}
	fmt.Println(s1, s2)
}
func test1() {
	var d1 = []string{"admin", "password", "hello world"}
	fmt.Printf("切片长度：%v\n", len(d1))
	fmt.Printf("cap长度：%v\n", cap(d1))
	fmt.Printf("d1[2]长度：%v\n", d1[2])

}
func test2() {
	// 切片的初始化
	// 1、直接初始化
	var f1 = []string{"你好", "我不好", "真烦啊"}
	// 2、使用数组初始化
	var f2 string
	fmt.Println(f2)
	// 3、分段切片
	f3 := f1[0:3]
	fmt.Println(f3)
	f4 := f1[3:]
	fmt.Println(f4)
}
func test3() {
	//数组（其实想对比切片就是少了几个...）
	var q1 = [...]string{"我", "肚", "子", "饿了"}
	fmt.Println(q1[1:4])
}
func main() {
	test()
	test1()
	test2()
	test3()
}

切片的添加删除及遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
// 切片遍历及添加删除
func slice_add() {
	var a = []int{1, 2, 3, 4, 5, 6, 7}
	a = append(a, 8, 9, 10, 11)   //切片添加
	for i := 0; i < len(a); i++ { //切片遍历
		fmt.Println(a[i])
	}
	fmt.Println(a)
	//公式:append(a[:index],[index+1:]...)
	a = append(a[:3], a[5:]...) //提取0-3,5-∞的值，换言之即为删除5,第二个参数取的闭区间，4、5去除。
	fmt.Println("删除后的结果：", a)

}

第十二节课：map

map是一种key:values键值对的数据容器，内部实现是hash表，map最重要的是通过key来建立快速索引数据，map是引用类型的。

声明及使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
	m1 := map[string]string{
		"username": "admin",
		"password": "123456",
	}
	m1["age"] = "22"//第二种赋值方法

	fmt.Println(m1["age"])

}

map遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

func main() {
	m1 := map[string]string{
		"username": "admin",
		"password": "123456",
	}
	m1["age"] = "22"

	/// 判断key是否存在
	// if _, ok := m1["ax"]; ok {
	// 	fmt.Println("key存在")
	// 	return
	// } else {
	// 	fmt.Println("不存在")
	// }
	// map遍历
	for k, v := range m1 {
		fmt.Println(k, v)
	}
}

第十三节课：init函数

init函数在main函数之前执行，实现包级别的一些初始化操作。

init主要的一些特点

  • init函数优于main函数自动执行，不能被其他函数调用；
  • init函数没有输入参数、返回值；
  • 每个包可以有多个init函数；
  • 包的每个源文件也可以有多个init函数,这点比较特殊；
  • 同一个包的init执行顺序，golang没有明确定义，编程时要注意程序不要依赖这个执行顺序。
  • 不通报的init函数按照包倒入的依赖关系决定执行顺序。

Golang初始化顺序

初始化循序：变量初始化->init()->main()

实例:

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func init() {
	fmt.Println("init...")
}
func main() {
	fmt.Println("main")
}
// 首先调用init
赏

祝老板天天开心

支付宝

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

资深废物,安服菜鸡<br/>常年内网迷路者<br/>非知名网络黑客<br/>专业端茶倒水选手<br/>