Go学习第二天

news2024/9/22 11:30:54

Defer语句调用顺序

package main

import "fmt"

func main() {
	defer fmt.Println("main end1  先进后出")
	defer fmt.Println("main end2  后进先出")

	fmt.Println("main hello go 1")
	fmt.Println("main hello go 2")
}

重点：
Defer执行顺序，类似于压栈出栈的方式，先进后出的形式
可用于关闭工作流之类的


package main

import "fmt"

func deferFunc() int {
	fmt.Println("defer func called ...")
	return 0
}

func returnFunc() int {
	fmt.Println("return func called ...")
	return 0
}

func returnAndDefer() int{
	defer deferFunc();
	return returnFunc();
}
func main() {
	//defer fmt.Println("main end1  先进后出")
	//defer fmt.Println("main end2  后进先出")
	//
	//fmt.Println("main hello go 1")
	//fmt.Println("main hello go 2")

	returnAndDefer();
}

Stack栈

如果defer和return在一个方法中同时存在，那么return之后的语句先执行，defer后的语句后执行。

Golang中的数组与动态数组的区别

slice 切片，动态数组的类型

package main

import "fmt"

func printArray(myArray1 [10]int)  {
	// 值拷贝
	for index, value := range myArray1 {
		fmt.Println("index = ", index, "value = ", value)
	}
}
func main() {
	// 固定长度的数组
	var myArray1 [10]int

	// 固定长度的数组，带初始化数据
	myArray2 := [10]int{1, 2, 3, 4, 5, 6, 7, 8}

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

	for index, value := range myArray2 {
		fmt.Println("index = ", index, "value = ", value)
	}

	// 查看数组的数据类型
	fmt.Printf("myArray1 type is %T\n",myArray1)
	fmt.Printf("myArray2 type is %T\n",myArray2)

	printArray(myArray2)
}

请添加图片描述

package main

import (
	"fmt"
)

func printArray2(myArray []int) {
	// 引用传递
	// _ 表示匿名的变量
	for _, value := range myArray {
		fmt.Println("value = ", value)
	}
	// 重新赋值
	myArray[0] = 100
	myArray[1] = 199
}

func main() {
	myArray := []int{1, 2, 3, 4, 5} // 动态数组，切片slice
	fmt.Printf("myArray type is %T \n", myArray)

	printArray2(myArray)

	fmt.Println("======================")

	for index, value := range myArray {
		fmt.Println("index = ", index, "value = ", value)
	}
}

请添加图片描述

Go中slice切片的4种声明方式

方式一：声明一个变量，默认值是0
var a int
fmt.Println("a = ", a)
fmt.Printf("type of a = %T \n", a)

方式二：声明一个变量，初始化一个值
var b int = 100
fmt.Println("b = ", b)
fmt.Printf("type of b= %T \n", b)

方式三：再初始化的时候，可以省去数据类型，通过值自动匹配当前的变量的数据类型
var c = 100
fmt.Println("c = ", c)
fmt.Printf("type of c= %T \n", c)

方式四： 直接变量后面:=，省去var关键字，直接自动匹配

d :=100
fmt.Println("d = ", d)
fmt.Printf("type of d= %T \n”, d)



声明多个变量：
方式一：多个值同属一种数据类型
var xx, yy int = 100, 200
fmt.Println("xx = ", xx)
fmt.Println("yy = ", yy)

方式二：多个值不同的数据类型，就不声明具体类型，自动反向推导出数据类型
var kk, ll = 100, "hello"
fmt.Println("kk = ", kk)
fmt.Println("ll = ", ll)

多行的多变量声明：不写具体类型，自动反向推导出数据类型
var(
	vv int = 100
	uu bool = true
)
fmt.Println("vv = ", vv, ", uu = ", uu)