一文搞懂Go语言中条件语句的使用

目录
  • if语句
  • if...else 语句
  • if 语句嵌套
  • switch 语句
    • Type Switch
    • fallthrough
  • select 语句

条件语句需要开发者通过指定一个或多个条件,并通过测试条件是否为 true 来决定是否执行指定语句,并在条件为 false 的情况在执行另外的语句。

Go 语言提供了以下几种条件判断语句:

语句 描述
if 语句 if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
if...else 语句 if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行
if 嵌套语句 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句 switch 语句用于基于不同条件执行不同动作。
select 语句 select 语句类似于 switch 语句,但是select会随机执行一个可运行的case。如果没有case可运行,它将阻塞,直到有case可运行。

if语句

if 语句由布尔表达式后紧跟一个或多个语句组成。

语法

Go 编程语言中 if 语句的语法如下:

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

If 在布尔表达式为 true 时,其后紧跟的语句块执行,如果为 false 则不执行。

实例

使用 if 判断一个数变量的大小:

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* 使用 if 语句判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" )
   }
   fmt.Printf("a 的值为 : %d\n", a)
}

以上代码执行结果为:

a 小于 20 a 的值为 : 10

if...else 语句

if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。

语法

Go 编程语言中 if...else 语句的语法如下:

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

If 在布尔表达式为 true 时,其后紧跟的语句块执行,如果为 false 则执行 else 语句块。

实例

使用 if else 判断一个数的大小:

package main

import "fmt"

func main() {
   /* 局部变量定义 */
   var a int = 100;

   /* 判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" );
   } else {
       /* 如果条件为 false 则执行以下语句 */
       fmt.Printf("a 不小于 20\n" );
   }
   fmt.Printf("a 的值为 : %d\n", a);

}

以上代码执行结果为:

a 不小于 20 a 的值为 : 100

if 语句嵌套

你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。

语法

Go 编程语言中 if...else 语句的语法如下:

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

你可以以同样的方式在 if 语句中嵌套 else if...else 语句

实例

嵌套使用 if 语句:

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int = 200

   /* 判断条件 */
   if a == 100 {
       /* if 条件语句为 true 执行 */
       if b == 200 {
          /* if 条件语句为 true 执行 */
          fmt.Printf("a 的值为 100 , b 的值为 200\n" );
       }
   }
   fmt.Printf("a 值为 : %d\n", a );
   fmt.Printf("b 值为 : %d\n", b );
}

以上代码执行结果为:

a 的值为 100 , b 的值为 200 a 值为 : 100 b 值为 : 200

switch 语句

switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是唯一的,从上至下逐一测试,直到匹配为止。

switch 语句执行的过程从上至下,直到找到匹配项,匹配项后面也不需要再加 break。

switch 默认情况下 case 最后自带 break 语句,匹配成功后就不会执行其他 case,如果我们需要执行后面的 case,可以使用 fallthrough 。

语法

Go 编程语言中 switch 语句的语法如下:

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

变量 var1 可以是任何类型,而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数,但必须是相同的类型;或者最终结果为相同类型的表达式。

您可以同时测试多个可能符合条件的值,使用逗号分割它们,例如:case val1, val2, val3。

流程图:

实例

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var grade string = "B"
   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.Printf("优秀!\n" )
      case grade == "B", grade == "C" :
         fmt.Printf("良好\n" )
      case grade == "D" :
         fmt.Printf("及格\n" )
      case grade == "F":
         fmt.Printf("不及格\n" )
      default:
         fmt.Printf("差\n" );
   }
   fmt.Printf("你的等级是 %s\n", grade );
}

以上代码执行结果为:

优秀! 你的等级是 A

Type Switch

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

Type Switch 语法格式如下:

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

实例

package main

import "fmt"

func main() {
   var x interface{}

   switch i := x.(type) {
      case nil:
         fmt.Printf(" x 的类型 :%T",i)
      case int:
         fmt.Printf("x 是 int 型")
      case float64:
         fmt.Printf("x 是 float64 型")
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )
      default:
         fmt.Printf("未知型")
   }
}

以上代码执行结果为:

x 的类型 :<nil>

fallthrough

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

实例

package main

import "fmt"

func main() {

    switch {
    case false:
            fmt.Println("1、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("2、case 条件语句为 true")
            fallthrough
    case false:
            fmt.Println("3、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("4、case 条件语句为 true")
    case false:
            fmt.Println("5、case 条件语句为 false")
            fallthrough
    default:
            fmt.Println("6、默认 case")
    }
}

以上代码执行结果为:

2、case 条件语句为 true 3、case 条件语句为 false 4、case 条件语句为 true

从以上代码输出的结果可以看出:switch 从第一个判断表达式为 true 的 case 开始执行,如果 case 带有 fallthrough,程序会继续执行下一条 case,且它不会去判断下一个 case 的表达式是否为 true。

select 语句

select 是 Go 中的一个控制结构,类似于用于通信的 switch 语句。每个 case 必须是一个通信操作,要么是发送要么是接收。

select 随机执行一个可运行的 case。如果没有 case 可运行,它将阻塞,直到有 case 可运行。一个默认的子句应该总是可运行的。

语法

Go 编程语言中 select 语句的语法如下:

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

以下描述了 select 语句的语法:

  • 每个 case 都必须是一个通信
  • 所有 channel 表达式都会被求值
  • 所有被发送的表达式都会被求值
  • 如果任意某个通信可以进行,它就执行,其他被忽略。
  • 如果有多个 case 都可以运行,Select 会随机公平地选出一个执行。其他不会执行。

否则:

  • 如果有 default 子句,则执行该语句。

    如果没有 default 子句,select 将阻塞,直到某个通信可以运行;Go 不会重新对 channel 或值进行求值。

实例

select 语句应用演示:

package main

import "fmt"

func main() {
   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):  // same as: 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")
   }
}

以上代码执行结果为:

no communication

校内举办跑步比赛,10s内进去比赛,分性别,进入男子组,女子组

package main

import "fmt"

//if语句嵌套
//校内举办跑步比赛,10s内进去比赛,分性别,进入男子组,女子组
func main() {
    var (
        a = 9
        b = "男"
    )
    if a < 10 && b == "男" {
        fmt.Println("进去决赛")
        fmt.Println("进入男子")
    }
    if a < 10 && b == "女" {
        fmt.Println("进去决赛")
        fmt.Println("进入女子组")
    }
    if a > 10 {
        fmt.Println("滚")
    }

    /*
        if a < 10 {
            fmt.Println("进去决赛")

            if b == "男" {
                fmt.Println("进入男子")
            } else {
                fmt.Println("进入女子")
            }
        } else {
            fmt.Println("滚")
        }*/
}

//switch语句,对学生成绩进行考评,90-100:优秀,80-89:良好,60-79及格,60以下,不及格
package main

import "fmt"

func main() {

    var vaule = 1

    switch vaule {
    case 1:
        fmt.Println("1")

    case 2:
        fmt.Println("2")

    case 3:
        fmt.Println("3")
    default:
        fmt.Println("滚犊子")
    }

    /*
        var a = 77
        //等效于if else 语句
        switch {
        case a >= 90 && a <= 100:
            fmt.Println("好")
        case a >= 80 && a <= 89:
            fmt.Println("还行")
        case a >= 60 && a <= 79:
            fmt.Println("合格")
        default:
            fmt.Println("不合格")
        }*/
}

以上就是一文搞懂Go语言中条件语句的使用的详细内容,更多关于Go语言条件语句的资料请关注我们其它相关文章!

(0)

相关推荐

  • Go语言基础if条件语句用法及示例详解

    目录 概述 语法 格式规则 概述 条件语句需要开发者通过指定一个或多个条件 并通过测试条件是否为 true 来决定是否执行指定语句 并在条件为 false 的情况再执行另外的语句. 语法 package main func main() { //第一种格式 if 条件表达式 { 语句1 } //第二种格式 if 初始化表达式; 条件表达式 { 语句1 } //第三种格式 if 初始化表达式; 条件表达式 { 语句1 }else{ 语句2 } //第四种格式 if 初始化表达式; 条件表达式 {

  • Go语言中的if条件语句使用详解

    if语句 if语句包含一个布尔表达式后跟一个或多个语句. 语法 if语句在Go编程语言的语法是: 复制代码 代码如下: if(boolean_expression) {    /* statement(s) will execute if the boolean expression is true */ } 如果布尔表达式的值为 true,那么if语句里面代码块将被执行.如果if语句的结束(右大括号后)布尔表达式的值为false,那么语句之后第一行代码会被执行. 流程图: 例子: 复制代码 代

  • Go语言基础switch条件语句基本用法及示例详解

    目录 概述 语法 第一种[switch 带上表达式] 第二种[switch 不带表达式] 第三种[switch 初始化,表达式] 注意 示例一[根据今天的日期打印今天星期几] 示例二[根据分数打印A,B,C,D] 示例三[算数] 概述 传入条件的不同,会执行不同的语句 每一个case分支都是唯一的,从上到下逐一测试,直到匹配为止. 语法 第一种[switch 带上表达式] switch 表达式 { case 表达式1,表达式2, ... : 语句块1 case 表达式3, 表达式4, ... :

  • Go中的条件语句Switch示例详解

    Switch简介 Go的switch的基本功能和C.Java类似: switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是唯一的,从上至下逐一测试,直到匹配为止. 匹配项后面也不需要再加 break. 特点: switch 默认情况下 case 最后自带 break 语句,匹配成功后就不会执行其他 case 重点介绍Go当中的Switch的两个特别点:** 表达式判断为true还需要执行后面的 case,可以使用 fallthrough type-switch 来判断某个 i

  • Go语言学习之条件语句使用详解

    目录 1.if...else判断语法 2.if嵌套语法 3.switch语句 4.类型switch语句 5.fallthrough关键字使用 小结 1.if...else判断语法 语法的使用和其他语言没啥区别. 样例代码如下: // 判断语句 func panduan(a int) { if a > 50 { fmt.Println("a > 50") } else if a < 30 { fmt.Println("a < 30") } el

  • 一文搞懂Go语言中条件语句的使用

    目录 if语句 if...else 语句 if 语句嵌套 switch 语句 Type Switch fallthrough select 语句 条件语句需要开发者通过指定一个或多个条件,并通过测试条件是否为 true 来决定是否执行指定语句,并在条件为 false 的情况在执行另外的语句. Go 语言提供了以下几种条件判断语句: 语句 描述 if 语句 if 语句 由一个布尔表达式后紧跟一个或多个语句组成. if...else 语句 if 语句 后可以使用可选的 else 语句, else 语

  • 一文搞懂Go语言中文件的读写与创建

    目录 1. 文件的打开与关闭 1.1 os.open 1.2 os.OpenFile() 指定模式打开文件 2. 文件的读取 2.1 打开文件的方式读取文件中的数据 2.2 使用 bufio 整行读取文件 3. 写入文件操作 3.1 file.Write 与 file.WriteString 3.2 bufio.NewWriter 3.3 ioUtil 工具类 1. 文件的打开与关闭 1.1 os.open os.open 函数能打开一个文件 调用 close() 方法 关闭文件 //打开文件

  • 一文搞懂C语言static关键字的三个作用

    目录 static修饰局部变量 static 修饰全局变量 static 修饰函数 总结 static修饰局部变量 图一:test 函数里面定义的 a 是局部变量,局部变量在栈区上开辟空间,栈区的使用特点是进入变量的生命周期时自动为其开辟空间,离开变量的生命周期时自动销毁对应空间,所以这里每次调用 test 函数时 a 都会被重新定义并初始化为0,所以屏幕上打印的是10个1: 图二:我们把 a 用 static 修饰后发现屏幕打印的是1到10,就好像每次调用完 test 函数后 a 并没有被销毁

  • 一文搞懂Go语言操作Redis的方法

    目录 前言 安装依赖包 连接redis redis连接池 总结 前言 Redis是一个开源的内存数据库,在项目开发中redis的使用也比较频繁,本文介绍了Go语言中go-redis库的基本使用.感兴趣的小伙伴们可以参考借鉴,希望对大家能有所帮助. 安装依赖包 Go语言中使用第三方库go-redis go-redis支持连接哨兵及集群模式的Redis. 使用以下命令下载并安装: go get -u github.com/go-redis/redis/v8 连接redis 新建go文件,在项目中引入

  • 一文搞懂Java JDBC中的SQL注入问题

    目录 SQL注入 什么是SQL注入 SQL注入的效果的演示 SQL注入代码 SQL注入效果 如何避免SQL注入 PrepareStatement解决SQL注入 PreparedStatement的应用 参数标记 动态参数绑定 综合案例 PreparedStatement总结 必须使用Statement的情况 SQL注入 什么是SQL注入 在用户输入的数据中有SQL关键字或语法,并且关键字或语法参与了SQL语句的编译.导致SQL语句编译后的条件为true,一直得到正确的结果.这种现象就是SQL注入

  • 一文搞懂JMeter engine中HashTree的配置问题

    目录 一.前言 二.HashTree的用法 三.JMeter源码导出jmx脚本文件介绍 四.自定义HashTree生成JMeter脚本 一.前言 之前介绍了JMeter engine启动原理,但是里面涉及到HashTree这个类结构没有给大家详细介绍,这边文章就详细介绍JMeter engine里面的HashTree结构具体用来做什么 大家看到下面是JMeter控制台配置截图,是一个标准的菜单形式:菜单形式其实就类似于"树型"的数据结构,而HashTree其实就是一个树型数据结构 我们

  • 一文搞懂Spring Bean中的作用域和生命周期

    目录 一.Spring Bean 作用域 singleton(单例) prototype(原型) 小结 二.Spring Bean生命周期 如何关闭容器 生命周期回调 通过接口设置生命周期 通过xml设置生命周期 一.Spring Bean 作用域 常规的 Spring IoC 容器中Bean的作用域有两种:singleton(单例)和prototype(非单例) 注:基于Web的容器还有其他种作用域,在这就不赘述了. singleton(单例) singleton是Spring默认的作用域.当

  • 一文搞懂Vue3.2中setup语法糖使用

    目录 前言 一.如何使用setup语法糖 二.data数据的使用 三.method方法的使用 四.watchEffect的使用 五.watch的使用 六.computed计算属性的使用 七.props父子传值的使用 八.emit子父传值的使用 九.获取子组件ref变量和defineExpose暴露 十.路由useRoute和useRouter的使用 十一.store仓库的使用 十二.await 的支持 十三.provide 和 inject 祖孙传值 前言 提示:Vue3.2 版本开始才能使用语

  • 一文搞懂Java项目中枚举的定义与使用

    目录 什么是枚举 为什么需要枚举类 枚举类的定义和使用 什么是枚举 最近写新项目!有很多数据字典常量需要定义和使用.就顺便记录一下.什么是枚举类呢?就是用enum修饰是一种Java特殊的类,枚举是class.底层是继承了java.lang.Enum类的实体类.使用枚举可以很方便的定义数据常量.方便清晰我们使用 为什么需要枚举类 下面就举例说明一下吧 1)出于类型安全考虑,没用枚举类之前,常用静态常量来表示. 比如对于性别的表示: public static final int WOMAN = 0

  • 一文搞懂 React 18 中的 useTransition() 与 useDeferredValue()

    目录 前言 什么是Concurrent React? 设置项目 实现 useTransition() isPending 是做什么的? 前言 React 18 引入了一个关键的新概念,称为“Concurrent”. 并发涉及同时执行多个状态更新,这可以说是 React 18 中最重要的特性.除了并发之外,React 18 还引入了两个新的钩子,称为 useTransition() 和 useDeferredValue() 钩子. 它们都有助于降低状态更新的优先级,但问题是,何时应该使用它们? 什

随机推荐