Go 笔记

1
2
3
4
5
6
7
package main

import "fmt"

func main() {
fmt.Println("Hello, 世界")
}

Go笔记

Go 安装

Mac下,可使用HomeBrew
brew install go
然后就可以等待下载安装了。

然后我选择了 VSCode,插件安装中安装Go的开发工具。OK后就可以开始Go的学习了。

Go 的基本语法

Hello World

如果已经熟悉Swift了,那么Go的很多写法不会让人感觉不习惯。

以一个 HelloWorld.go 文件为例熟悉一下基本结构,

1
2
3
4
5
6
7
package main 

import "fmt"

func main() {
fmt.Print("Hi\n")
}
  • package : 是包名
  • import : 导入其他包
  • func : 函数

值得注意的几点:

  1. 函数的第一个左花括号必须与函数名同行
  2. 每行不用分好结尾,规范的代码,每行只会有一句代码
  3. 引入了包就必须使用,如果存在未使用的引入包,会编译报错
变量 & 常量 & ioda
  • 变量: var [name] [type] = [content] ==简化==> [name] := [content]
  • 变量创建后是必须使用的,不然报错
  • 常量: const [name] [type] = [content]
  • 常量可以创建后不使用
  • 变量和常量在使用过程中通常可以省略[type]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func main()  {

var item int = 1
var num float64 = 0.2

numShort := 0.4
itemShort := 2

fmt.Println("变量: ",item)
fmt.Println("变量: ",num)
fmt.Println("变量: ",itemShort)
fmt.Println("变量: ",numShort)


const numConst int = 100

fmt.Println("常量: ",numConst)
}

常量在使用常量组赋值的时候,第一个元素必须赋值

1
2
3
4
5
6
7
8
9
10
func main()  {

const (
a = 1
b
c
)

fmt.Println(a,b,b)
}

不然会报错,而且后面的值会等于前一个值,所以上面的例子中,会输出:三个1。

如果想赋值有序常量,可以使用 iota

iota 起始值为0,每次增加1

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

func main() {

const (
a = iota
b
c
)

fmt.Println(a,b,c)
}

// 输出: 0,1,2

func main() {

const (
a = iota << 2
b
c
)

fmt.Println(a,b,c)
}

// 输出0,2,4
string
1
2
var str string = "string"
str1 := "string1"

字符串操作:

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

func main() {

str := "string"

// 输出str
fmt.Println(str)

// 数组str的字节长度
fmt.Println(len(str))

// 字符截取,str[n:m] 的意思是截取 大于等于n 小于m 的子字符串
fmt.Println(str[1:3])
}
switch

和其他语言差不多:

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

item := 1

switch item {
case 0:
fmt.Println("0")
case 1:
fmt.Println("1")
default:
fmt.Println("default")
}
}

// 输出
数组 & 多维数组
  • 数组: 固定长度(内存中固定长度的内存空间)
  • 多维数组: 一个数组变量中每个元素又是一个数组变量

数组声明:

1
2
var list [3]int = [3]int{1,2,3}
arrayList := [3]int{4,5,6}

多维数组声明:

1
2
var list [2][2]int = [2][2]int{{1,2},{1,2}}
arrayList := [2][2]int{{1,2},{1,2}}
for 循环

go中只有这一种循环结构

1
2
3
for index := 0; index < 10; index++ {
fmt.Println(index)
}
goto

方便跳转:

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
func main()  {

for index := 0; index < 10; index++ {

if index == 5 {
goto testPrint
} else {
fmt.Println("go")
}

}

testPrint:
fmt.Println("hi")
}

/*
输出:
go
go
go
go
go
hi
*/
slice 切片

我将其理解成动态数组

1
2
var list []int = []int{1,2,3}
newList := []int{3,4,5}

不同于数组,slice是指针,在申请的时候并不会分配内存。

slice的增删改查

1
2
3
4
5
6
7
8
9
10
11
12
13
newList := []int{3,4,5}
fmt.Println(newList)

newList = append(newList, 1)
fmt.Println(newList)

newList = append(newList[:1],newList[2:]...)
fmt.Println(newList)

输出:
[3 4 5]
[3 4 5 1]
[3 5 1]

slice没有直接删除函数,增加和删除都是用append完成,删除本质上是slice的重组

slice可以直接copy

1
2
3
4
5
6
7
8
9
10
11
12
list1 := []int{1,2,3,4}
list2 := []int{5,6}

// 将list2的值在对应在list1的位置进行copy赋值
copy(list1,list2)

fmt.Println(list1)
fmt.Println(list2)

输出:
[5 6 3 4]
[5 6]
map

创建:

1
mapItem := map[string]string{"key":"value"}

增删:

1
2
3
4
5
6
7
8
mapItem := map[string]string{"key":"value","key1":"value2","key2":"value3"}
fmt.Println(mapItem)

delete(mapItem, "key")
fmt.Println(mapItem)

mapItem["key3"] = "value3"
fmt.Println(mapItem)
匿名函数
1
2
3
4
5
6
7
8
9
10
11
12
// 最后写一个 () 表示执行
func() {
fmt.Println("Hi")
}()

// 有参数和返回值
// 函数可以作为函数变量来赋值
testFnc := func(name string) string {
return "你的名字叫: " + name
}

fmt.Println(testFnc("Bob"))

大佬给的Go学习路线

SQL 小计 元素去重

Comments

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×