go基础笔记-程序流程控制

单分支控制
if 条件表达式 {
　　执行代码块
}

案例：
package main

import (
    "fmt"
)

func main() {
    var age int = 19
    if age > 18 {
        fmt.Println("大于18")
    }
}


案例：声明两个float64型变量并赋值，判断如果第一个数大于10.0，并且第2个数小于20.0，就打印两个数之和。
package main

import (
    "fmt"
)

func main() {
    var n3 float64 = 11.0
    var n4 float64 = 17.0
    if n3 > 10.0 && n4 < 20.0 {
        fmt.Println("和=",(n3+n4))
    }
}


案例：判断一个年份是否是闰年，闰年的判断条件是符合下面二者之一：
（1）年份能被4整除，但不能被100整除；
（2）年份能被400整除。

package main

import (
    "fmt"
)

func main() {
    var year int = 2020
    if (year % 4 == 0 && year % 100 !=0 ) || year % 400 == 0{
        fmt.Println(year,"是闰年")
    }
}


双分支控制
if 条件表达式 {
　　执行代码块1
} else {
　　执行代码块2
}

案例：
package main

import (
    "fmt"
)

func main() {
    var age int = 17
    if age > 18 {
        fmt.Println("大于18")
    } else {
        fmt.Println("小于18")
    }
}


多分支控制
if 条件表达式 {
　　执行代码块1
} else if {
　　执行代码块2
} else {
　　执行代码块3
}

案例：
package main

import (
    "fmt"
)

func main() {
    var score int = 99
    if score == 100 {
        fmt.Println("=100")
    } else if score > 80 && score <= 99 {
        fmt.Println(">80&&<=90")
    } else if score >=60 && score <= 80 {
        fmt.Println(">=60 && <=80")
    } else {
        fmt.Println("<=60")
    }
}

案例：下面的案例是错误的写法，因为只会输出 ">9" 
package main

import (
    "fmt"
)

func main() {
    var n int = 10
    if n >  9 {
        fmt.Println(">9")
    } else if n > 6 && n <= 9 {
        fmt.Println(">6&&<=9")
    } else if n >=3 && n <= 6 {
        fmt.Println(">=3 && <=6")
    } else {
        fmt.Println("<=3")
    }
}


嵌套分支基本语法

if 条件表达式 {
    if 条件表达式 {
    执行代码块1
    } else {
    执行代码块2
    }

}

案例：出票系统：根据淡旺季的月份和年龄，打印票价
4-10月 旺季：
  成人（18-60）：60
  儿童（<18）：半价
  老人（>60）：1/3
淡季：
  成人：40
  其他：20

package main

import (
    "fmt"
)
 
func main() {
  var month byte
  var age byte
  var price float64 = 60.0
  
  fmt.Println("请输入月份")
  fmt.Scanln(&month)
  fmt.Println("请输入年龄")
  fmt.Scanln(&age)
 
  if month >=4 && month <=10 {
    if age > 60 {
      fmt.Printf("%v月 票价 %v 年龄 %v ",month,price / 3 ,age)
    } else if age >=18 {
      fmt.Printf("%v月 票价 %v 年龄 %v ",month,price,age)
    } else {
      fmt.Printf("%v月 票价 %v 年龄 %v ",month,price / 2,age)
    }
  } else {
    if age >=18 && age < 60 {
      fmt.Println("淡季成人票价40")
    } else {
      fmt.Println("淡季儿童和老人票价20")
    }
  }
}



switch语句基本语法
switch 表达式{
    case 表达式1,表达式2,...:
        语句块1
        
    case 表达式3,表达式4,...:
        语句块2
        
    // 这里可以有多个case语句

    defaut:
        语句块    
    
}


switch快速入门案例：
请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f,g  
a表示星期一，b表示星期二，...根据用户的输入显示相应的信息

package main

import (
    "fmt"
)

func main() {
    var key byte
    fmt.Println("请输入一个字符 a,b,c,d,e,f,g")
    fmt.Scanf("%c",&key)
    
    switch key {
        case 'a':
            fmt.Println("周一")
        case 'b':
            fmt.Println("周二")
        case 'c':
            fmt.Println("周三")
        case 'd':
            fmt.Println("周四")
        case 'e':
            fmt.Println("周五")
        case 'f':
            fmt.Println("周六")
        case 'g':
            fmt.Println("周日")
        default:
            fmt.Println("输入有误...")            
    }
}
 
 
案例：根据用户指定月份，打印该月份所属的季节：
3,4,5春季   6,7,8 夏季   9,10,11 秋季  12,1,2 冬季

package main

import (
    "fmt"
)
  
func main() {
    var month byte
    fmt.Println("请输入月份")
    fmt.Scanln(&month)
    
    switch month {
        case 3, 4, 5 :
            fmt.Println("春季")
        case 6, 7, 8 :
            fmt.Println("夏季")
        case 9, 10, 11 :
            fmt.Println("秋季")
        case 12, 1, 2 :
            fmt.Println("冬季")
        default:
            fmt.Println("输入有误...")            
    }
}


 
switch语句用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上到下逐一测试，直到匹配为止。
如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用switch语句。
如果区间判断和结果为bool类型的判断，使用if语句。


swith使用细节：
（1）case后面是一个表达式（即：常量值、变量、一个有返回值的函数都可以）


（2）case后的各表达式的值的数据类型必须和swith表达式数据类型一致；
var n1 int32 =20
var n2 int64 =20 
switch n1 {
    case n2 :  // 错误：原因是n1和n2数据类型不一致
        fmt.Println("xxx")

（3）case后面可以带多个表达式，使用逗号间隔，比如case 表达式1,表达式2
var n1 int32 =20
var n2 int32 =20 
switch n1 {
    case n2,10,5 :  // case 后面可以有多个表达式
        fmt.Println("xxx")

（4）case后面的表达式如果是常量值，即要求不能重复；
var n1 int32 =20
var n2 int32 =20 
switch n1 {
    case n2,10,5 :   
        fmt.Println("xxx")
    case 5 :  // 错误，因为前面已经有常量5，因此重复报错
        fmt.Println("xxx")
         
（5）case后面不需要带break；

（6）defaut语句不是必须的；

（7）swith后面可以不带表达式，类似if else分支来使用；

（8）swith后面也可以直接申明定义一个变量，分号结束，不推荐；

（9）switch之fallthrough（穿透）也就是执行某个case后，还会再执行它接下来的一个case

（10）Type switch ：swich语句还可以被用于type-switch来判断某个Interface变量中实际指向的变量类型；



循环控制 

（1）循环控制第二种使用方式
for 循环变量初始化;循环条件;循环变量迭代 { 
    循环执行语句
}

案例：
package main

import (
    "fmt"
)
   
func main() {
    for i:=1;i<=10;i++{
        fmt.Println("hello ",i)
    }
}


（2）循环控制第二种使用方式
for 循环条件 {
    循环操作
} 

案例：    
package main

import (
    "fmt"
)
   
func main() {
    j := 1 
    for j<=10 {
        fmt.Println("hello ",j)
        j++
    }
}
    
（3）循环控制三种使用方式
for {
    循环操作
    break
   }

上面的写法等价于   for ;; {}  是一个无限循环，通常需要配合 break 语句使用

package main

import (
    "fmt"
)
   
func main() {
    k := 1 
    for {
        if k<=10 {
        fmt.Println("hello ",k)
        } else {
            break
        }
        k++
    }
}

    
golang提供for-range方式，可以方便的遍历字符串和数组；（是按照字符来遍历的，而不是字节）

字符串遍历方式1 ==> 传统方式

package main

import (
    "fmt"
)
   
func main() {
    var str string = "abcde,fghijkkk"
    for i := 0; i< len(str); i++ {
        fmt.Printf("%c 
",str[i]) 
    }
}



字符串遍历方式2 ==> for-range方式

package main

import (
    "fmt"
)
   
func main() {
    var str string = "abcde,fghijkkk"
    for i := 0; i< len(str); i++ {
        fmt.Printf("%c 
",str[i]) 
    }
}


如果字符串含有中文，那么传统遍历字符串方式就会出现乱码，原因是传统的对字符串的遍历是按照字节来遍历。
如何解决？需要将 str 转换成 []rune 切片 

package main

import (
    "fmt"
)
   
func main() {
    var str string = "ab好人de,fghi理查德kkkk"
    str2 := []rune(str)
    for i := 0; i< len(str2); i++ {
        fmt.Printf("%c 
",str2[i]) 
    }
}

如果字符串含有中文，那么 for-range方式也是可以的。



跳转控制语句-break
break语句用于终止某个语句块的执行，用于中断当前for循环或跳出switch语句。
案例：编写一个无限循环控制，然后不停的随机生成树，当生成了99时，就退出这个无限循环
package main

import (
    "fmt"
    "math/rand"
    "time"
)
   
func main() {
    var count int = 0 
    for {
        rand.Seed(time.Now().UnixNano())
        n := rand.Intn(100)+1
        fmt.Println("n=",n)
        count++
        if (n == 99) {
        break
        }
    } 
}
 

跳转控制语句-continue
continue语句用于结束本次循环，继续执行下一次循环

案例：
package main

import (
    "fmt"
)
   
func main() {
    for i:= 0;i < 4 ;i++ {
        for j:= 0;j<10;j++{
            if j==2{
            continue
            }
            fmt.Println("j= ", j)
        } 
    } 
}

案例：打印 1-100之间的奇数
package main

import (
    "fmt"
)
   
func main() {
    for i:= 0;i < 100 ;i++ {
        if i % 2 == 0 {
            continue
        }
        fmt.Println("奇数是: ",i)
    } 
}



跳转控制语句goto

goto语句可以无条件地转移到程序中指定的行；
goto语句通常与条件语句配合使用。可用来实现条件转移，跳出循环体等功能；
在go程序设计中一般不主张使用goto语句，以避免造成程序流程的混乱；

案例： 

import (
    "fmt"
)
   
func main() {
    var n int = 30 
    fmt.Println("ok1")
    if n > 20{
        goto label1
        }
    fmt.Println("ok2")
    label1:
    fmt.Println("ok3")
}


跳转控制语句return
表示跳出所在的方法或函数；
如果return是在普通的函数，则表示跳出该函数。
如果return是在main函数，表示终止main函数,也就是终止程序。