go语言入门基础2

函数
map、slice、interface、channel数据类型本身就是指针，函数内修改可能影响外部数据结构值
1.函数可变参数

func f3 (args ...int){
	for _,v:=range args{
		fmt.Printf("%v",v)
	}
}
func main() {
	f3(1,3,3,4)
}

2.函数类型

func f3(a int,b int)int{
	return a+b
}
func main() {
	type f1 func(int,int)int
	var ff f1
	ff=f3
	r:=ff(1,2)
	fmt.Printf("%v", r)
}

3.函数作为参数

func sayHello(name string)  {
	fmt.Printf("hellO，%s", name)
}
func test(name string, f func(string))  {
	f(name)
}
func main() {
	test("tom",sayHello)
}

闭包
函数内引用函数外变量，数据持久化，容易内存泄漏

func add()func(y int)int{
	var x int
	return func (y int) int {
		x+=y
		return x
	}
}
func main() {
	f:=add()
	r:=f(10)
	fmt.Printf("r:%v\n",r)
	r=f(20)
	fmt.Printf("r:%v\n",r)
}

递归

func f1(i int)int{
	i++;
	if(i>=5){
		return 1
	}
	fmt.Printf("%v\n", i)
	return f1(i)
}
func main() {
	f1(1)
}

defer
defer 延迟处理，逆序

func main() {
	fmt.Println("start")
	defer fmt.Println("step1")
	defer fmt.Println("step2")
	defer fmt.Println("step3")
	fmt.Println("end")
}
执行结果
start end step3 step2 step1

init函数
初始化函数init 使用func init(){} 可以多个 不被其它函数调用
变量声明 =>init=>main 从前到后执行顺序

指针
&（取地址） *（根据地址取值）

var ip *int
fmt.Printf("%v\n", ip)  //nil
fmt.Printf("%T\n",ip) //*int
var i int=100
ip=&i
fmt.Printf("%v\n", ip)  //0xc0000120d0

数组指针

a:=[3]int{1,2,3}
var pa [3]*int
for i := 0; i < len(a); i++ {
	pa[i]=&a[i]
}
fmt.Printf("%v", pa)

类型定义

type MyInt int
var i MyInt
i=100
fmt.Printf("%T\n%v", i,i)

结构体
结构体传值（复制），不会修改原结构体值。传递的地址，修改会影响原结构体值
1.结构体基础用法

type Person struct{
    id,age int
    name,email string
}
var tom Person
tom =Person{
    15,20,"tom","78@qq.com",
}
fmt.Printf("%v",tom)

2.结构体指针

type Person struct{
    id,age int
    name,email string
}
tom :=Person{
    15,20,"tom","78@qq.com",
}
var p_person *Person
p_person=&tom
fmt.Printf("%v",p_person)

3.结构体做参数

type Person struct{
    id int
    name string
}
func f1(per Person){
    per.id=101
    per.name="tom"
    fmt.Printf("%v",per)
}
func main() {
    tom:=Person{
        id:100,
        name:"tom",
    }
    f1(tom)
}

4.结构体嵌套

type Dog struct{
    name,color string
    age int
}
type Person struct{
    dog Dog
    name string
    age int
}
dog :=Dog{
    "花花","black",3,
}
person :=Person{
    dog,"tom",15,
}

5.结构体方法

type Person struct{
    name string
}
//(per Person) 接收者  receriver
func (per Person) eat()  {
    fmt.Println("%v,eat",per.name)
}

func main() {
    tom:=Person{
        "tom",
    }
    tom.eat()
}