go入门——流程控制、函数

if语句

var a int = 100
if a < 100 && a >= 90 {
   fmt.Println(a)
} else if a < 90 || a > 100 {
   fmt.Println(a)
} else {
   fmt.Println(a)
}

if语句还有一种写法，可以直接在if后面定义变量，这个变量只会在if语句中起作用，用;分号隔开判断条件

switch

var scrore int = 90
switch scrore {
case 90:
   fmt.Println()
case 80:
   fmt.Println()
case 50, 40:
   fmt.Println()
default:
   fmt.Println()
}

case穿透fallthrough

在switch中，只要匹配成功，程序进入其中一个case之后紧跟着的下一个case会跟着执行

for循环

语法上和java差不多，java能够省略的地方go也可以

for a := 1; a <= 10; a++ {
   fmt.Println(a)
}

break和continue

string字符串

len(str)//获得字符串的长度

一种使用rang的for循环

str := "hello"
//rang循环，一般用来遍历数组、切片等
for i, v := range str {
   fmt.Print(i)        //打印数组下标
   fmt.Printf("%c", v) //打印存在数组中的值
}

函数

函数声明如下，go的函数定义中可以存在多个返回值类型

func 函数名([参数列表]) [返回值类型] {
   c := a + b
   return c
}

func main() {
   //使用多个变量接收多个返回值函数返回的值
   x, y := swap("1", "2")
   fmt.Println(x, y)
}

// 多个返回值函数
func swap(x, y string) (string, string) {
   return y, x
}

可变长参数

func main() {
   getSum(1, 2, 3, 4, 5)
}

// 可边长参数
func getSum(arg ...int) {
   sum := 0
   for i := 0; i < len(arg); i++ {
      sum += arg[i]
   }
   fmt.Println(sum)
}

值传递和引用传递

go存在和c语言一样的形参和实参之间的值传递和引用传递。在go中结构体、数组、基本数据类型都是值传递，数组在使用值传递的时候，形参必须要和实参的大小一致才可以传递

定义数组

arr := [4]int{1,2,3,4}

定义切片

arr := []int{1,2,3,4}

切片是引用类型的数据，采用的是引用传递

递归函数

//求和递归函数
func main() {
   fmt.Println(sum(5))
}

func sum(n int) int {
   if n == 1 {
      return 1
   }
   return sum(n-1) + n
}

defer函数

defer关键字用来延迟一个函数的执行。当一个程序中定义了多个defer时，当函数执行到最后的时候，这些被延迟执行的语句就会按照逆序的顺序来执行。注意当函数传递形式参数的时候，只是函数被延迟执行了，程序跑到defer的时候，参数已经传递进去了。一般常见用来关闭资源，当打开一些资源的时候，使用defer来延迟关闭资源

函数的本质

函数的本质也是一种变量类型，这种类型就叫做func（）

匿名函数

func main() {

   //匿名函数赋值
   f3 := func() {
      fmt.Println("匿名函数，使用变量名执行")
   }
   f3()
   //匿名函数调用自己，只执行一次，也可以传递参数，也可以接收返回值
   func() {
      fmt.Println("匿名函数直接执行")
   }()

}

回调函数

高阶函数：接收其他函数作为参数

回调函数：作为其他函数的参数

闭包

在一个函数中，存在函数内定义了一个新的函数，这个函数本身就叫外层函数，新定义的函数叫做内层函数。外层函数的返回值就是内层函数，并且外层函数和内层函数都会调用外层函数定义好的局部变量，这种就叫做闭包结构。

闭包结构中的局部变量不会随着外层函数的销毁而跟着销毁，因为内层函数还在使用这个局部变量