go语言基础知识
go语言基础知识
基础于c，具有部署简单、并发号、执行性能好的特点。与java相比，没有类和继承，相比java更加高效，相比c更加简单易编译。go对多核心优化好，可让程序员调用硬件更多性能。在很多语法现象上有从c语言简化，同时为了降低歧义和程序员语言风格对代码功能的影响，对代码书写方式和工程文件结构等做了规定。
hello world
1
2
3
4
5
6
7
| package main // 声明 main 包，main包是唯一的，是入口。
import (
"fmt" // 导入 fmt 包，打印字符串是需要用到
)
func main() { // 声明 main 主函数，所以函数以func开头。func 函数名 (参数列表) (返回值列表)
fmt.Println("Hello World!") // 打印 Hello World!
}
|
go语言以包为管理单位，每个go源文件需要声明其所属包，一目录下同级文件属于同一个包。
数据类型和变量生成
数据类型
- bool 布尔
- string 字符串
- int、int8、int16、int32、int64 整型（分别8进制、16进制、32进制等）
- uint、uint8、uint16、uint32、uint64、uintptr
- byte // uint8 的别名
- float32、float64 实型
变量赋值方式
var name type 变量声明方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| var ( //批量变量
a int =3 //不需要“；”
b string
c []float32
d func() bool
e struct {
x int
}
)
a,s:=1, "abc"//简化申明和赋值
c:=a+a
ptr := &v //指针变量
var a,b *int //指针变量
var q [3]int = [3]int{1, 2, 3} //数组同时赋值
|
全局变量在主函数之外进行声明。
GO语言容器
数组遍历
1
2
3
4
5
6
7
| var team [3]string
team[0] = "hammer"
team[1] = "soldier"
team[2] = "mum"
for k, v := range team { //k如计数器，从0开始。v作为桥梁，获取数组team的值
fmt.Println(k, v)
}
|
切片
1
2
3
4
5
| fmt.Println(team[1:2]) //输出数组第二和第三个的内容。相当于生成切片。
b := make([]int, 2, 10) //使用make函数，预分配10个内存空间，但使用2个元素
var a []int
a = append(a, 1, 2, 3) // append追加多个元素, 手写解包方式。还有copy复制切片等
|
map概念（python中的字典）
map是一种特殊的数据结构，是由key（索引）和value（值）两个元素组合成的无序集合。map的容量是动态的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| package main
import "fmt"
func main() {
var mapLit map[string]int //分别是map名、map结合值中的key的类型以及map的值的类型
mapLit = map[string]int{"one": 1, "two": 2}
mapCreated := make(map[string]int)
mapCreated["key1"] = 4.5
mapCreated["key2"] = 3.14159
fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])
fmt.Printf("Map created at \"key2\" is: %f\n", mapCreated["key2"])
}
scene := make(map[string]int)
scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960
delete(scene, "brazil") //删除一组值
for k, v := range scene { //遍历
fmt.Println(k, v)
}
|
go语言程序结构
判断
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| if condition1 {
// do something
} else if condition2 {
// do something else
}else {
// catch-all or default
}
var s = "hello"
switch {
case s == "hello": //case 判断表达式
fmt.Println("hello")
fallthrough
case s != "world":
fmt.Println("world")
}
|
循环
只支持for循环
1
2
3
4
5
6
7
8
| sum := 0
for i := 0; i < 10; i++ {
sum += i
}
for key, val := range coll { //常用语遍历的循环模式，其中key作为递增。val是只读传递数值
...
}
|
break退出本次循环。 goto可以直接跳出多层循环到标签处。
1
2
3
4
| goto breakHere
breakHere:
fmt.Println("done")
|
函数
一般函数声明
1
2
3
4
5
6
7
8
| func typedTwoValues() (int, int) {
return 1, 2
}
func main() {
a, b := typedTwoValues()
fmt.Println(a, b)
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
| package main
import (
"fmt"
)
func fire() {
fmt.Println("fire")
}
func main() {
var f func() //将func函数当做一种类型，定义一个f变量
f = fire //调用变量，相当于无传入的函数
f()
}
|
结构体
go语言没有类的概念,结构体与c语言类似。（不过我感觉c和go的结构体和java的类挺相似，因为都可以属性继承等。）
1
2
3
4
5
6
7
8
| type Point struct { //结构体定义
X int
Y string
}
var p Point //实例化
p.X = 10 //调用
|
接口概念
虽然go没有类和继承的概念，但其通过接口的概念实现面对对象的特性（一种抽象的存在）。
1
2
3
4
| type writer interface{ //定义接口名，interface是定义接口关键词。接口类型由数个方法构成，默认在接口名后面加er以便于区分
Write([]byte) error
方法名（参数列表） 返回值
}
|
