go语言基础（4）

闭包的体现形式，能常就是用函数返回另一个函数

package main

import "fmt"

//函数在调用结束会从内存中销毁
func test1(a int){
	a++
	fmt.Println(a)
}

func main0201() {
	a:=0
	for i:=0;i<10 ;i++  {
		test1(a)
	}
}

//可以通过匿名函数和闭包 实现函数在栈区的本地化
func test2() func() int{
	var a int

	return func()  int{
		a++
		return a
	}
}
func main(){
	//将test2函数类型赋值给f
	//f:=test2
	//函数调用 将test2的返回值给f
	f:=test2()
	//var a int
	//f:=func()  int{
	//	a++
	//	return a
	//}
	for i:=0;i<10 ;i++  {
		fmt.Println(f())
	}
	//fmt.Printf("%T",f)
}

在函数定义时调用函数本身 递归函数
死递归

func test(a int){
	//在递归函数中一个要有出口  return
	if a==0{
		return
	}
	a--
	fmt.Println(a)
	test(a)
}

func main() {

	test(10)
}

package main

import "fmt"

func main01() {

	//var 变量名 数据类型

	//数组定义和使用
	//var 数组名 [元素个数]数据类型
	//var arr [10]int
	//
	数组名[下标]=值
	//
	//arr[0]=123
	//arr[1]=10

	//数组下标是从0开始的  到数组下标的最大值为数组元素个数
	var arr [10]int = [10]int{1,2,3,4,5,6,7,8,9,10}

	打印数组名可以显示所有元素
	//fmt.Println(arr)

	//打印数组信息
	//for i:=0;i<10;i++{
	//	fmt.Println(arr[i])
	//}

	//len(string) 获取字符串有效长度
	//len(...int) 获取不定参函数参数个数
	//len([10]int) 计算数组元素个数

	//fmt.Println(len(arr))
	//for i := 0; i < len(arr); i++ {
	//	fmt.Println(arr[i])
	//}


	//range 遍历集合信息
	//返回值为 下标  值
	for _,v:=range arr  {
		fmt.Println(v)
	}
}

func main02(){
	//数组在定义时 可以初始化部分元素的值
	//var arr [10]int=[10]int{1,2,3,4,5}
	//使用自动类型推导创建数组
	//arr:=[10]int{1,2,3,4,5,6,7,8,9,10}

	//使用自动类型推导 可以根据元素个数创建数组
	arr:=[...]int{1,2,3}

	for _,v:=range arr  {
		fmt.Println(v)
	}
	fmt.Printf("%T",arr)
}

func main03(){
	//arr:=[5]int{1,2,3,4,5}
	//在定义时 叫元素个数
	var arr [5]int=[5]int{1,2,3,4,5}
	//在数组使用时叫下标 （0~len(arr)-1）
	//arr[5]=100//数组下标越界
	//arr[-1]=20//数组下标越界
	//数组在定义后 元素个数就已经固定 不能添加
	//fmt.Println(arr)
	//数组是一个常量 不允许赋值 数组名代表整个数组
	//arr=10//err
	//数组名也可以表示数组的首地址
	fmt.Printf("%p\n",&arr)
	fmt.Printf("%p\n",&arr[0])
	fmt.Printf("%p\n",&arr[1])
}