（一）数组
//数组定义：var variable_name [SIZE] variable_type
var arr [10] int
//以上为一维数组的定义方式。例如以下定义了数组 arr 长度为 10 类型为int：
//初始化数组：
var b = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
//初始化数组中 {} 中的元素个数不能大于 [] 中的数字。如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
b := []float32{1000.0, 2.0, 3.4, 7.0, 50.0}
（二）切片
定义：Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
//你可以声明一个未指定大小的数组来定义切片：
var identifier []type
使用make函数定义切片。或使用make()函数来创建切片:
var slice1 []type = make([]type, len) 简写为：slice1 := make([]type, len)
其中len代表长度，cap代表最长多少 例如：make([]T, length, capacity)
// 创建一个整型切片其长度和容量都是 10 个元素
slice := make([]int, 10)
创建一个整型切片其长度为 3 个元素，容量为 5 个元素
slice := make([]int, 3, 5)
//下边这个函数可以打印切片
func printfslic(x [] int) {
fmt.Printf("切片的长度为%d,最大为%d,slice为%v。。第二个参数为：%d
",len(x),cap(x),x)
}
//其中nil切片/空切片。切片扩容。/切片赋值-限制切片容量
具体以后整理下：
现在看下这个自己打印下。https://www.cnblogs.com/sparkdev/p/10704614.html
(三)结构体
Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：
type struct_variable_type struct {
member definition
member definition
...
member definition
}
一旦定义了结构体类型，它就能用于变量的声明，语法格式如下
variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}
例子：
package main
import "fmt"
type person struct{
name string
age int
ismarry bool
}
func main() {
tongtong := person{"张tongtong",25,false}
fmt.Println(tongtong)
tongtong1 := person{name:"张tongtong",age:27,ismarry:true}
fmt.Println(tongtong1)
}
(四)指针
Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
package main
import "fmt"
func main() {
a := 10
fmt.Printf("变量的地址: %x
", &a ) //打印出来a变量的地址
}
什么是指针？一个指针变量指向了一个值的内存地址。类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：
--在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。--
var var_name *var-type
func main() {
//var ip *int // 指向整型的空指针
//var fp *float32 // 指向浮点型的空指针
a := 10
var ip *int //定义一个指针变量
ip = &a //指向a的内存地址
fmt.Printf("a 变量的地址是: %x
", &a )
/* 指针变量的存储地址 */
fmt.Printf("ip 变量储存的指针地址: %x
", ip )
/* 使用指针访问值 */
fmt.Printf("*ip 变量的值: %d
", *ip )
}
//结果为
a 变量的地址是: c000014078
ip 变量储存的指针地址: c000014078
*ip 变量的值: 10
(五)范围range
package main
import "fmt"
type person struct{
name string
age int
ismarry bool
}
func main() {
numSlice := []int{1,3,2,3}
nums := 0
for _,val := range numSlice {
nums += val
}
fmt.Println("nums:", nums)
//这个是index
for i, num := range numSlice {
if num == 3 {
fmt.Println("index:", i)
}
}
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s
", k, v)
}
//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
for i, c := range "go" {
fmt.Println(i, c)
}
}
（六）接口
1. 什么是interface接口
interface 是GO语言的基础特性之一。可以理解为一种类型的规范或者约定。它跟java，C# 不太一样，不需要显示说明实现了某个接口，它没有继承或子类或“implements”关键字，只是通过约定的形式，隐式的实现interface 中的方法即可。因此，Golang 中的 interface 让编码更灵活、易扩展。
如何理解go 语言中的interface ？ 只需记住以下三点即可：
1. interface 是方法声明的集合
2. 任何类型的对象实现了在interface 接口中声明的全部方法，则表明该类型实现了该接口。
3. interface 可以作为一种数据类型，实现了该接口的任何对象都可以给对应的接口类型变量赋值。
注意：
a. interface 可以被任意对象实现，一个类型/对象也可以实现多个 interface
b. 方法不能重载，如 eat() eat(s string) 不能同时存在
package main
import "fmt"
type Person interface {
car()
}
type Women struct{}
func (women Women) car() {
fmt.Println("女人开车")
}
type Man struct{}
func (man Man) car() {
fmt.Println("男人开车")
}
func main() {
var person Person
person = new(Women)
person.car()
person = new(Man)
person.car()
}