这几天学了Go语言的结构体、切片、映射、数组、函数闭包。接下来分类进行总结，自己做总结，也希望能帮助到那些想学go的同学。
1.结构体通用格式：
type 结构体名 struct{
数据 数据类型
}
示例代码：
//学习结构体
package main
import "fmt"
//结构体格式 type Structname struct{data}
type Vertex struct {
X int
Y int
}
//输出结构体
func main() {
fmt.Println(Vertex{1,3})
}2.结构体指针 ：
结构体指针有点类似于C++的指针类型，表示地址。但是一个很重要的区别在于：Go语言的结构体指针连接的形式采用的是.进行连接，而非->形式或者（*）.形式。
示例代码：
//结构体指针
package main
import (
"fmt"
)
type Vertex struct{
X int
Y int
}
//指针的重点在于，直接用p.X 而非p->x 或者(*p).X形式，这点要记住
func main(){
v:=Vertex{1,3}
p:=&v //传递地址给p
p.X = 1e9
fmt.Println(p.X)
}
3.结构体地址返回
用&可以返回结构体地址，但是一个重点在于结构体取地址不返回具体的地址。
示例代码：
package main
import "fmt"
type Vertex struct {
X,Y int
}
//设置变量
var(
v1 = Vertex{1,2}
v2 = Vertex{X:1} //Y就被隐性赋值为0
v3 = Vertex{}
p = &Vertex{1,2} //p为该结构体地址
m = 1
f = &v1
)
//结构体不返回具体的地址
func main(){
fmt.Println(v1,p,f)
}
4.结构体内的值修改
可以直接修改里面的值，用取地址的形式和.的形式都可以
示例代码：
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main(){
//可以修改结构体的值，类似于c++
v:=Vertex{1,2}
v.X = 3
fmt.Println(v.X)
}结构体方面暂时先总结到这，等后续应用到再总结。
二、切片1.切片格式：
[切片元素个数]切片类型{
具体数据
}
示例代码：
//go语言
package main
import "fmt"
func main(){
//数组参数中间需要加,
names := [4]string{
"Jons",
"Paud",
"ss",
"dd",
}
fmt.Println(names)
}
2.切片文法：
切片文法的数据在于它的数据类型可以支持多种，包括int、bool、struct等多种类型
示例代码：
//切片文法
package main
import "fmt"
func main(){
q:=[]int{2,3,1,4,4} //他会自动识别
fmt.Println(q)
r:=[]bool{true,false,true,true,false}
fmt.Println(r)
//可以用结构体作为它的数据类型
s:=[]struct{
i int
b bool
}{
{2, true},
{3, false},
{5, true},
{7, true},
{11, false},
{13, true},
}
fmt.Println(s)
}3.求切片长度、容量
切片长度即为有包含数据的长度，切片容量指的是切片的大小。
切片长度只跟初始位置相关。其中切片长度和容量均为0时，则该切片==nil
示例代码：
//切片的长度于容量
package main
import "fmt"
func printSlice(s[]int){
fmt.Printf("len = %d cap=%d %v\n",len(s),cap(s),s)
}
func main(){
s:=[]int{2,3,5,7,11,13}
printSlice(s)
s=s[:0]
printSlice(s)
s = s[:4]
printSlice(s)
s = s[3:]
printSlice(s)
}
4.range用法：
切片中的range有点类似于for的遍历，主要作用在于遍历切片中的每个数据
示例代码：
package main
import "fmt"
var pow = []int{1,2,4,56,6}
//range循环切片映射时，返回值param1:下标，2：下表对应参数
func main(){
for i,v:=range pow{
fmt.Printf("%d:%d\n",i,v)
}
}range返回值第二个值时可以省略的
示例代码：
package main
import (
"fmt"
)
func main(){
pow:=make([]int,10)
for i:=range pow{
pow[i] = 1 << uint(i) //2的0次方啥的，类似于二进制表达
}
for _, value := range pow {
fmt.Printf("%d\n", value)
}
}
1.表达形式：
go指针的表达形式通常为&数据。表达数据的地址，这点如果学了C++的应该会更有理解。
*相当于取该地址的值，适用于大部分数据类型，结构体有点特殊，上面代码有讲到。
示例代码：
//学习go指针
package main
import "fmt"
func main(){
i,j:=42,2701
p:=&i //把i的地址赋给p
fmt.Println(*p)
*p = 21
fmt.Println(i)
p = &j
*p = *p/37
fmt.Println(j)
}四、数组
1.数组格式：
var 数组名[数组个数]数据类型={具体数据}
示例代码：
//学习数组
package main
import "fmt"
func main() {
var a[2]string
a[0] = "Hello World"
a[1] = "Bing"
fmt.Println(a[1])
fmt.Println(a) //直接返回数组的形式 中间没有句号
primes := [7]int{2, 3, 5, 7, 11, 13} //后半部分中[7]表示数组的长度，如果后面数据低于这个，自动赋值0
fmt.Println(primes)
}
2.make用法：
make主要用来创建数组的：语法： a:=make([]int,5) //表示创建长度为5的类型为int的数组
示例代码：
package main
import "fmt"
func main(){
a:=make([]int,5) //create a array that length = 5
printSlice("a",a)
b:=make([]int,0,5)
printSlice("b",b)
c:=b[:2]
printSlice("c",c)
d:= c[2:5]
printSlice("d",d)
}
func printSlice(s string,x[]int){
fmt.Printf("%s len=%d cap = %d %v \n",s,len(x),cap(x),x)
}
映射有点类似于C++的字典。
1.语法：var m map[string]int //表示的是 创建一个映射名为m的 key类型为string val类型为int的数据集
示例代码：
//学习映射
package main
import "fmt"
type Vertex struct {
Lat,Long float64
}
var m map[string]Vertex
func main() {
m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{
49.22,-888,
}
fmt.Println(m["Bell Labs"])
}
函数可以以另一个函数作为返回值：
示例代码：
package main
import (
"fmt"
"math"
)
func compute(fn func(float64,float64) float64)float64{
return fn(3,4)
}
func main() {
hypot := func(x,y float64)float64 {
return math.Sqrt(x*x + y*y)
}
fmt.Println(hypot(5,12))
fmt.Println(hypot(5,12))
fmt.Println(compute(hypot))
fmt.Println(compute(math.Pow))
}
剩余的有一块关于闭包函数的 本人还未完全理解，待理解之后补上，总体的基础基本上讲解完毕，希望对大家有用，当然也有不足，毕竟我也是刚学习几天。