4.Golang基础 -3 - 2

指针保存了值的内存地址
类型 *T 是指向T类型值的指针，其值为nil

var p *int
func main() {
	i:=10
	p = &i
	*p = -1
	fmt.Println(i) // -1
}

type Student struct{
	Name string
	Number string
}

func main(){
	student := Student{Name: "liyuan", Number: "20181001332"}
	//通过 . 来访问结构体字段
	student.Name = "-1"
	fmt.Println(student) //{-1 20181001332}

	//结构体指针：结构体字段可以通过结构体指针来访问
	// (*student).Name  <=> stduent.Name
	student2 := &student
	student2.Name = "-2"
	fmt.Println(student) //{-2 20181001332}

	//结构体文法
	v1 := Student{Name:"l1",Number:"num1"}
	v2 := Student{Name: "l2"}
	v3 := Student{Number: "num3"}
	v4 := &Student{"l4","num4"}   //创建一个*Student类型的结构体指针
}

	var a [2]string
	a[0] = "name1"
	a[1] = "name2"
	fmt.Println(a) //[name1 name2]

	//切片 -> 范围区间 [lo, hi)
	//语法类似python，但没有负数概念 如 nums[0:-3]
	var nums [10]int{0,1,2,3,4,5,6,7,8,9}
	var nums1 [int] = num[1:4] //[1 2 3]
	//切片共享底层数据
	nums[1] = -1
	fmt.Println(nums1) //[-1 2 3]
	//切片文法
	stus := []struct {
		Name   string
		Number string
	}{
		{Name: "liyuan1", Number: "0001"},
		{Name: "liyuan2", Number: "0002"},
		{Name: "liyuan3", Number: "0003"},
	}
	fmt.Println(stus)

	//切片默认取值 
	nums2 := nums[0:] //上界为切片的长度
	nums3:= nums[:5] //下界为0
	nums4:=nums[:]

	//有了切片的概念，就会产生切片实际长度以及其总容量的概念 ，类似ArrayList<>();初始化时容量默认为
	nums5:= nums[5:9]
	fmt.Println(nums5)		 //[5 6 7 8]
	fmt.Println(len(nums5))  //4
	fmt.Println(cap(nums5))  //5
 

//参考 ArrayList<>()实现可知，ArrayList<>()时长度为0

//当我们向其中添加元素时

//会重设容器的大小

//并设置默认大小为0，就是所谓的容量


// 经过这些操作，我们现在就获得了一个容量为10，但长度为1的容器

func  main(){
	//nil切片，切片的零值为nil， nil切片的长度和容量均为0，且无共享底层数组
	//使用make来创建数组
	a: = make([]int, 5)
	b:= make([]int,0,5)
	fmt.Println(b)  // []
	b = b[:cap(b)] 
	fmt.Println(b) // [0,0,0,0,0]
	b = b[1:]
	fmt.Println(b) // [0,0,0,0]

	//切片的切片
	nums:= []int{1,2,3,4,5,6,7,8,9,10}
	nums2 = nums[1,5] //[2 3 4 5]
	nums3 = nums2[1,2] //[3]

	//向切片添加元素
	// func append(s []T, vs ...T) []T
	//会产生一个新的数组
	nums4 := append(nums,11,12,13)

	// 切片遍历 index: 索引；value：值的副本
	for index,value :=range nums{
		fmt.Println(index,value)
	}
	//可通过 _ 来忽略参数
	for index, _ := range nums{
		...
	}

	for _, value := range nums{
		...
	}
	
}

打法和python如出一辙，其中nil表示没值,使用make进行初始化

var m map[int]string

type Stu struct{
	Name string
	Number string	
}

func main(){
	m = make(map[int]string)
	m[0] = "liyuan0"
	m[1] = "liyuan1"
	fmt.Println(m) //map[0:liyuan0 1:liyuan1]
	
	//结构体映射
	m1 := map[string]Stu {
		"0":{"liyuan0","0000"},
		"1":{"liyuan1","0001"},
	}
	//修改映射值
	m["0"] = {"liyuan2","0002"}
	delete(m,"0")
	//查找元素是否存在,若元素存在，则elem为该值，ok为true
	elem, ok :=m["2"]
}

函数本身也是值，我们可以像其他值一样传递它；
可用作函数的参数或返回值

//函数闭包，闭包是一个函数值，其引用了其他函数体之外的变量这些函数可以访问并赋予其引用的变量的值，一下为fibonacci闭包实现
func fibonacci() func() int {
	pre0 := 0
	pre1 := 1
	return func() int {
		tmp:=pre0 + pre1
		pre0 = pre1
		pre1 = tmp
		return tmp
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}