本文已参与「新人创作礼」活动，一起开启掘金创作之路。

昨天我们初步了解了Go语言的变量、常量和运算符，今天我们继续学习

Go的条件语句

package main

import "fmt"

func main() { //Go没有三目运算符，不支持?:形式的条件判断
   var a int = 10

   // if语句
   if a < 20 {
      fmt.Printf("a 小于 20\n")
   }
   fmt.Printf("a 的值为：%d\n", a)

   // if...else语句
   a = 30

   if a < 20 {
      fmt.Printf("a 小于 20\n")
   } else {
      fmt.Printf("a 不小于 20\n")
   }
   fmt.Printf("a 的值为：%d\n", a)

   // if嵌套语句
   var b int = 10
   var c int = 20

   if b == 10 {
      if c == 20 {
         fmt.Printf("a的值为10， b的值为20\n")
      }
   }
   fmt.Printf("b 的值为：%d\n", b)
   fmt.Printf("c 的值为：%d\n", c)

   // switch语句
   var grade string = "B"
   var marks int = 90

   switch marks {
   case 100:
      grade = "A"
   case 90:
      grade = "B"
   case 70, 80:
      grade = "C"
   case 60:
      grade = "D"
   default:
      grade = "E"
   }

   switch {
   case grade == "A":
      fmt.Printf("优秀！\n")
   case grade == "B", grade == "C":
      fmt.Printf("良好\n")
   case grade == "D":
      fmt.Printf("及格！\n")
   case grade == "E":
      fmt.Printf("不及格！\n")
   default:
      fmt.Printf("叉出去！\n")
   }

   /*
      如果有多个case可以运行，select会随即公平地选出一个执行。其他不会执行
      否则，如果有default子句，则执行该子句
      若没有default子句，select将阻塞，知道某个通信可以运行；
      Go不会重新对channel或值进行求值
   */
   var c1, c2, c3 chan int
   var i1, i2 int

   select {
   case i1 = <-c1:
      fmt.Printf("received ", i1, "from c1\n")
   case c2 <- i2:
      fmt.Printf("sent ", i2, "to c2\n")

   case i3, ok := (<-c3):
      if ok {
         fmt.Printf("received ", i3, "from c3\n")
      } else {
         fmt.Printf("c3 is closed\n")
      }
   default:
      fmt.Printf("no communication\n")

   }
   //select 会循环检测条件，如果有满足则执行并退出，否则一直循环检测。
}

Go的循环语句

package main

import (
   "fmt"
)

func main() {
   //for循环
   sum := 0
   // for init; condition; post { }
   /*
      init：一般为赋值表达式，给控制变量赋初值
      condition：关系表达式或逻辑表达式，循环控制条件
      post：一般为赋值表达式，给控制变量增量或减量
   */
   for i := 0; i <= 10; i++ {
      sum += i
   }
   fmt.Println(sum)

   //init和post参数是可选的，我们直接省略，类似while语句
   sum = 1
   for sum <= 10 {
      sum += sum
   }
   fmt.Println(sum)

   //和上面一样，只是更简洁，也更像while语句
   for sum <= 10 {
      sum += sum
   }
   fmt.Println(sum)

   // For-each range 循环
   //对字符串、数组、切片等进行迭代输出元素

   string := []string{"Tom", "Jerry"}
   for i, s := range string {
      fmt.Println(i, s)
   }

   numbers := [6]int{1, 2, 3, 5, 8}
   for i, x := range numbers {
      fmt.Printf("第 %d 位 x 的值为 %d\n", i, x)
   }

   //循环嵌套
   //判断100以内的素数
   var i, j int
   for i = 2; i < 100; i++ {
      for j = 2; j <= (i / j); j++ {
         if i%j == 0 {
            break
         }
      }
      if j > (i / j) {
         fmt.Printf("%d 是素数\n", i)
      }
   }

   //九九乘法表
   for m := 1; m < 10; m++ {
      for n := 1; n <= m; n++ {
         fmt.Printf("%d x %d = %d\t", n, m, n*m)
      }
      fmt.Println("")
   }

   //循环控制语句

   //break语句：用于中断当前for循环或跳出switch语句
   var x int = 10
   for x < 20 {
      fmt.Printf("x 的值为：%d\n", x)
      x++
      if x > 15 {
         break
      }
   }

   //continue语句：跳过当前循环的剩余语句，继续下一轮循环
   var y int = 10

   for y < 20 {
      if y == 15 {
         // 跳过此次循环
         y = y + 1
         continue
      }
      fmt.Printf("y 的值为 : %d\n", y)
      y++
   }

   //goto语句：将控制转移到被标记的语句
   var z int = 10
   //在变量 a 等于 15 的时候跳过本次循环并回到循环的开始语句 LOOP 处
LOOP:
   for z < 20 {
      if z == 15 {
         z = z + 1
         goto LOOP
      }
      fmt.Printf("z的值为：%d\n", z)
      z++
   }
}

Go语言函数

/*
package main

import "fmt"

func main() {
   var a int = 100
   var b int = 200
   var res int

   res = max(a, b)
   fmt.Printf("最大值是:%d\n", res)

   x, y := swap("Tom", "Jerry")
   fmt.Println(x, y)
}

func max(num1, num2 int) int {
   var result int
   if num1 > num2 {
      result = num1
   } else {
      result = num2
   }
   return result
}

func swap(x, y string) (string, string) {
   return y, x
}
*/

//函数参数：值传递和引用传递
//package main
//
//import "fmt"
//
////值传递
///*
//func swap(x, y int) int {
// var temp int
// temp = x
// x = y
// y = temp
//
// return temp
//}
//*/
//
////引用传递
//func swap(x *int, y *int) {
// var temp int
// temp = *x
// *x = *y
// *y = temp
//}
//
//func main() {
// var a int = 100
// var b int = 200
//
// //值传递
// /*
//    fmt.Printf("交换前a = %d， b = %d\n", a, b)
//    swap(a, b)
//    fmt.Printf("交换后a = %d， b = %d\n", a, b)
// */
//
// fmt.Printf("交换前a = %d， b = %d\n", a, b)
// swap(&a, &b)
// fmt.Printf("交换后a = %d， b = %d\n", a, b)
//}

//Go语言函数作为实参
//package main
//
//import (
// "fmt"
// "math"
//)
//
//func main() {
// getSqrtNum := func(x float64) float64 {
//    return math.Sqrt(x)
// }
//
// fmt.Println(getSqrtNum(9))
//}

/*
Go语言支持匿名函数，可作为闭包
匿名函数是一个内联语句或表达式
匿名函数的优越性在于可以直接使用函数中的变量
我们创建了getSequnce()，返回另一个函数
目的：在闭包中递增i变量
*/
//package main
//
//import "fmt"
//
//func getSequnce() func() int {
// i := 0
// return func() int {
//    i += 1
//    return i
// }
//}
//
//func main() {
// nextNum := getSequnce()
//
// //调用nextNum函数
// fmt.Println(nextNum())
// fmt.Println(nextNum())
// fmt.Println(nextNum())
//
// //创建新的函数
// nextNum1 := getSequnce()
// fmt.Println(nextNum1())
// fmt.Println(nextNum1())
// fmt.Println(nextNum1())
//
//}

/*
Go语言中同时有函数和方法
一个方法就是一个包含了接收者的函数
接收者可以是命名类型或结构体类型的一个值或指针
所有给定类型的方法属于该类型的方法集
Go没有面向对象这一特性
在Go里面，这个this指针需要明确申明出来
*/
package main

import "fmt"

//定义一个结构体
type Circle struct {
   radius float64
}

func (c Circle) getArea() float64 {
   //属性：c.radius
   return 3.14 * c.radius * c.radius
}

func main() {
   var c1 Circle
   c1.radius = 10.0
   fmt.Println("圆的面积 = ", c1.getArea())
}