Go条件判断和循环

avatar 2020年4月18日23:39:05 评论 1,040 次浏览

go的条件判断

if 语句

条件判断就是对于一个或者多个条件，并判断条件是否为true，执行指定语句，并在为false的情况下执行另外一个语句，下面看一下条件语句的结构：

简单说一下就是，定义的事件，根据判断，是否符合某一个条件，符合执行符合的语句，不符合执行不符合的语句。

举个例子看看：

package main
import "fmt"
//if判断
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    var A int = 80
    if ( A > 90 ) {    //这里判断了条件A大于90，定义的A的值小于90，所以不执行下面的语句。
        fmt.Println("成绩大于90分，为优秀")
    }
    fmt.Println("成绩小于90分，位良好")
}

打印结果：

成绩小于90分，位良好

if...else语句

这是一个简单的if语句，一个布尔表达式后紧跟一个或多个语句组成。也可以在if语句后跟else语句，执行布尔表达式为false的条件。下面看个例子，

package main
import "fmt"
//if...else语句
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    var score = 90
    if (score >= 90){     //大于等于90的条件
        fmt.Println(score,"优秀")
    } else if (score >= 80) {   //大于等于80的条件
        fmt.Println(score,"良好")
    } else if (score >= 60) {     //大于等于60的条件
        fmt.Println(score,"合格")
    } else if (score < 60){      //小于60的条件
        fmt.Println(score,"不合格")
    }
}

打印结果：

90 优秀

if嵌套语句

if嵌套就是在if或者else if语句中嵌入一个或多个if或else if语句，下面看看嵌套语法：

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}

使用例子说明一下：

package main
import "fmt"
//if...else 嵌套语句
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    var A int = 92
    var B int = 60
    if ( A > 90 ) {  //判断A的值大于90
        fmt.Println("A的值大于90")
        if ( B == 60 ) {  //判断B的值等于60
            fmt.Println("如果A大于90，且B等于60")
        } else {  //判断A的值大于90，且不等于60
            fmt.Println("B的值不等于60")
        }
    } else {    //判断A的值小于90
        fmt.Println("A的值小于90")
    }
}

打印结果：

A的值大于90
如果A大于90，且B等于60

switch 语句

switch语句就是基于不同条件执行不同动作，每一个case分支都是唯一的，从上至下逐一测试，直到匹配为止。匹配后不需要执行break，默认情况下case自带break语句，匹配成功后不执行后面的case，可以使用fallthrough。

switch 语法：

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

变量var1可以是任何类型，而val1和val2则可以是相同类型的任意值。类型没有局限性，可以是常量也可以是整数，但必须是相同的类型；或者最终结果为相同类型的表达式。可以使用多个可能符号条件的值，使用逗号分割它们，例如：case val1，val2, val3.

流程图：

下面看一下例子：

package main
image "fmt"
// switch 语句
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    var grade string        //定义grade类型
    var marks int = 90       //定义成绩

    switch marks {  //定义等级条件
    case 90: grade = "A"
    case 80: grade = "B"
    case 50,60,70: grade = "C"
    default:
        grade = "D"
    }
    switch {           //判断等级
    case grade == "A" :
        fmt.Println("优秀")
    case grade == "B",grade == "C" :
        fmt.Println("良好")
    case grade == "D" :
        fmt.Println("及格")
    case grade == "F" :
        fmt.Println("不及格")
    default:
        fmt.Println("差")
    }
    fmt.Printf("你的等级是%s \n",grade)
}

执行结果：

优秀
你的等级是A

Type Switch

switch语句还可以用于type-switch来判断某个interface变量中实际存储的变量类型。

Type Switch语法如下：

witch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}

看看例子：

package main
import "fmt"
//Type Switch
// 吴老二 个人博客地址 http://www.wulaoer.org
type Bag struct {
    key string
}
type Bag1 struct {
    key int
}
func main()  {
     var b1 interface{}
     var b2 interface{}
     b1 = Bag{key: "1"}
     b2 = Bag1{key: 0}
     //获取interface{}中存放的数据类型
     //方法一：
     { //判断是否是Bag类型，若不是则置0
         b,ok := b1.(Bag)
         fmt.Println("Bag类型 : ",ok,"数据",b)
     }
     {//判断是否是Bag2类型，若不是则置0
         b,ok := b2.(Bag1)
         fmt.Println("Bag2类型 :",ok,"数据",b)
     }
     //方法二：
    switch v := b1.(type) {  //v表示b1接口转换成Bag对象的值
    case Bag:
        fmt.Println("b1.(type):", "Bag",v)
    case Bag1:
        fmt.Println("b1.(type):", "Bag1",v)
    default:
        fmt.Println("b1.(type):", "other",v)
    }
}

执行结果：

Bag类型 :  true 数据 {1}
Bag2类型 : true 数据 {0}
b1.(type): Bag {1}

fallthrough

使用fallthrough会强制执行后面的case语句，fallthrough不会判断下一条case的表达式结果是否为true。

package main
import "fmt"
//fallthrough
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    switch {
    case false:
        fmt.Println("1、case")
        fallthrough
    case true:
        fmt.Println("2、case")
        fallthrough
    case false:
        fmt.Println("3、case")
        fallthrough
    case true:
        fmt.Println("4、case")
    case false:
        fmt.Println("5、case")
        fallthrough
    default:
        fmt.Println("6、case")
    }
}

执行结果：

2、case
3、case
4、case

select 语句

select和switch语句类似，但是select会随机执行一个可运行的case，如果没有可运行的case，它会出现阻塞，直到case可运行。

语法：

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s); 
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

select语句的语法：

每个case都必须是一个通信
所有channel表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行，其他被忽略。
如果有多个case都可以运行，select会随机公平地选出一个执行，其他不会执行。否则： 1、如果有default子句，则执行该语句 2、如果没有default子句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。

select语句例子：

第一个例子：

package main
import "fmt"
//select
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    var c1,c2,c3 chan  int
    var i1,i2 int
    select {
    case i1 = <-c1:
        fmt.Println("received",i1,"from c1")
    case c2 <- i2:
        fmt.Println("sent",i2,"to c2")
    case i3,ok := (<-c3):
        if ok {
            fmt.Println("received",i3,"from c3")
        } else {
            fmt.Println("c3 is closed")
        }
    default:
        fmt.Println("no communication")
    }
}

打印结果：

no communication

第二个例子

package main
import (
"fmt"
"time"
)
// 吴老二 个人博客地址 http://www.wulaoer.org

func Chann(ch chan int, stopCh chan bool) {
    var i int
    i = 10
    for j := 0; j < 10; j++ {
        ch <- i
        time.Sleep(time.Second)
    }
    stopCh <- true
}
func main() {

    ch := make(chan int)
    c := 0
    stopCh := make(chan bool)
    go Chann(ch, stopCh)
    for {
        select {
        case c = <-ch:
            fmt.Println("Recvice", c)
            fmt.Println("channel")
        case s := <-ch:
            fmt.Println("Receive", s)
        case _ = <-stopCh:
            goto end
        }
    }
end:
}

打印结果：

Receive 10
Recvice 10
channel
Receive 10
Receive 10
Receive 10
Receive 10
Recvice 10
channel
Recvice 10
channel
Receive 10
Recvice 10
channel

扩展内容，写一个登录的脚本，判断输入的用户名和密码是否正确。

package main
import "fmt"
//用户登录
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    var name string
    var pass string
    fmt.Printf("请输入用户名：")
    fmt.Scan(&name)
    fmt.Printf("请输入密码：")
    fmt.Scan(&pass)
    if name == "wolf27w" && pass == "wolf27w" {
        fmt.Println("登录成功")
    } else {
        fmt.Println("账号或密码错误，登录失败")
    }
}

2、go的for循环语句

在程序中有很多重复性的操作，因此，为了减少这种操作需要用到for循环，执行某些语句。

流程如下：

for循环

下面先简单的说一下for循环的语法：

和C语言的for一样：

for init; condition; post { }

和C的while一样：

for condition { }

和C的for(;;)一样：

for { }

init: 一般赋值表达式，给控制变量赋初值；
condition: 关系表达式或逻辑表达式，循环控制条件;
post: 一般为赋值表达式，给控制变量增量或减量。

for语句执行过程如下：

1、先对表达式1赋初值；
2、判断肤质表达式init是否满足给定的条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行post，进入第二次循环，再判断condition；否则判断condition的值为假，不满足条件，就终止fot循环，执行循环外的语句。

for循环的range格式可以对slice、map、数组、字符串等进行迭代循环，格式如下：

for key, value := range oldMap {
    newMap[key] = value
}

流程语法如下图：

先写一个简单的循环

package main
import "fmt"
//for循环
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
    var b int = 15
    var a int
    numbers := [6]int{1, 2, 3, 5}  //数组的切片
    /* for 循环 */
    for a := 0; a < 10; a++ {   //a++自增
        fmt.Printf("a 的值为: %d\n", a)
    }
    for a < b {
        a++
        fmt.Printf("a 的值为: %d\n", a)
    }
    for i,x:= range numbers {
        fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
    }
}

打印结果：

a 的值为: 0
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 10
a 的值为: 11
a 的值为: 12
a 的值为: 13
a 的值为: 14
a 的值为: 15
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

嵌套for循环

嵌套for循环就是在for循环中增加一个或多个for循环，嵌套使用。

语法：

for [condition |  ( init; condition; increment ) | Range]
{
   for [condition |  ( init; condition; increment ) | Range]
   {
      statement(s);
   }
   statement(s);
}

举个例子：

找出2到100之间的所有素数：

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    var i,j int
    for i = 2; i < 100; i++ {
        for j = 2; j < 100; j++{ //也可以把j<100替换成j<(i/j)
            if (i%j== 0) {
                break
            }
        }
        if (j > (i/j)) {
            fmt.Printf("%d 是素数\n",i)
        }
    }

}

打印结果：

2 是素数
3 是素数
7 是素数
13 是素数
23 是素数
31 是素数
43 是素数
47 是素数
59 是素数
61 是素数
73 是素数
79 是素数
97 是素数

循环控制语句

在for循环的过程中，如果嵌套了if判断，那么if判断找到要找的值，就需要推出for循环了。在go中有三种控制语句，第一个就是推出不在循环(break)，第二种就是跳出本次循环，下一轮循环继续(contioue),第三种就是就需要控制的语句转移到被标记的语句。

先看一下第一个循环break

语法：

continue;

先看一下流程图：

写个例子，找出10以内大于5的数：

package main
image "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
    /* 定义局部变量 */
    var a int = 1
    /* for 循环 */
    for a < 10 {
        fmt.Printf("a 的值为 : %d\n", a);
        a++;
        if a > 5 {
            /* 使用 break 语句跳出循环 */
            break;
        }
    }
}

打印结果：

a 的值为 : 1
a 的值为 : 2
a 的值为 : 3
a 的值为 : 4
a 的值为 : 5

continue和break一样也是跳出循环，不过continue跳出的是本次循环，

流程图如下：

看下例子：

package main
image "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main()  {
    for i := 1;i <10;i++ {
        if i == 5 {
            continue
        }
        fmt.Printf("循环的值%d\n",i)
    }
}

打印结果：

循环的值1
循环的值2
循环的值3
循环的值4
循环的值6
循环的值7
循环的值8
循环的值9

goto可以无条件地转移到过程中指定的行。通常和条件配合使用，可以用来实现条件转移，构成循环，跳出循环体等功能。但是在结构话程序中不建议使用，以免造成流程的混乱，使理解和调试程序都产生困难。

语法：

goto label;
..
.
label: statement;

流程图如下：

在变量 a 等于 15 的时候跳过本次循环并回到循环的开始语句 LOOP 处：

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
   /* 定义局部变量 */
   var a int = 10
   /* 循环 */
   LOOP: for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++     
   }  
}

打印结果：

a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19

下面看一个99乘法表

func main() {
    print9x()
    //gotoTag()
}
// 吴老二 个人博客地址 http://www.wulaoer.org
//嵌套for循环打印九九乘法表
func print9x() {
    for m := 1; m < 10; m++ {
        for n := 1; n <= m; n++ {
            fmt.Printf("%dx%d=%d ",n,m,m*n)
        }
        fmt.Println("")
    }
}

//for循环配合goto打印九九乘法表
func gotoTag() {
    for m := 1; m < 10; m++ {
        n := 1
    LOOP: if n <= m {
        fmt.Printf("%dx%d=%d ",n,m,m*n)
        n++
        goto LOOP
    } else {
        fmt.Println("")
    }
        n++
    }
}

打印结果：

1x1=1 
2x1=2 2x2=4 
3x1=3 3x2=6 3x3=9 
4x1=4 4x2=8 4x3=12 4x4=16 
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81

以上就是真对Golang的if判断和for循环用法的基本操作，或者操作相关的知识点。虽然这个写的很多，但是知识点也就这几个，已经使用其他颜色标注了，可以自己看看标注的内容。今天的进步是对后天的牛逼攒下一点资本。努力吧，少年。

avatar

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: