Go if 语句

在编程中,程序的执行流程可以分为以下 3 种基本结构:

  • 顺序结构:程序按照代码从上往下的顺序,一行一行依次执行。
  • 选择结构:根据条件是否成立,决定执行哪一段代码。
  • 循环结构:在满足条件的情况下,反复执行某一段代码。

前面我们写过的代码,默认都是从上往下依次执行的顺序结构。但在平时写程序时,我们经常需要根据不同情况做出判断,这时就要用到选择结构。在 Go 语言中,选择结构一般分为 2 种:一种是 if 语句,另一种是 switch 语句。这一节我们先来学习最常用的 if 语句。

单分支 if 语句

在 Go 语言中,单分支 if 语句的逻辑非常简单:只有当某个条件成立时,程序才会执行花括号里的代码;如果条件不成立,就直接跳过。

语法:

if 条件 {
    // 条件为 true 时执行的代码
}

说明:

if 后面的 “条件” 通常是由比较运算符或逻辑运算符组成的表达式,比如 age >= 18。当条件结果为 true 时,程序就会进入花括号 {} 执行里面的代码;当结果为 false 时,就会跳过 {} 直接往下运行。

另外,Go 语言规定 if 后面的条件外层不需要加小括号 (),写起来更加清爽。

示例 1:使用单分支 if 语句

package main

import "fmt"

func main() {
    age := 20
    if age >= 18 {
        fmt.Println("已成年")
    }
    fmt.Println("判断结束")
}

运行结果如下。

已成年
判断结束

分析:

在这个例子中,age >= 18 表示判断变量 age 的值是否大于或等于 18。因为 age 的值是 20,条件判断返回 true,所以程序会进入花括号内部输出 "已成年",随后继续往下输出外面的 "判断结束"。

对于这个例子来说,如果我们把 age := 20 改为 age := 15,此时运行结果如下。

判断结束

从结果可以看出,当 age 为 15 时,age >= 18 返回 false。此时程序直接跳过花括号内部的代码,只输出了外面的 "判断结束"。

这里小伙伴们要留意,Go 语言要求 if 后面的条件结果必须是布尔值(true 或 false),不能把整数或字符串直接拿来当条件。下面这种写法就是错误的。

n := 1
if n {
    fmt.Println("条件成立")
}

上面代码中,变量 n 是 int 类型而不是 bool 类型。编译时会直接报 non-bool n (variable of type int) used as if condition 错误,意思是非布尔类型的 n 不能用作 if 条件。

注意: 哪怕 if 分支内部只有一行代码,前后的花括号 {} 也不能省略,否则编译时会直接报错。

双分支 if...else 语句

单分支 if 语句只处理了条件成立的情况。如果条件成立和不成立时需要分别做不同的处理,我们就可以在 if 后面加上 else(否则),构成双分支选择。

语法:

if 条件 {
    // 条件为 true 时执行的代码
} else {
    // 条件为 false 时执行的代码
}

说明:

当条件返回 true 时,程序执行 if 后面 {} 中的代码;当条件返回 false 时,执行 else 后面 {} 中的代码。这两个分支是互斥的,程序每次必定且只会执行其中一个。

示例 2:判断奇偶数

package main

import "fmt"

func main() {
    num := 15
    if num%2 == 0 {
        fmt.Println("偶数")
    } else {
        fmt.Println("奇数")
    }
}

运行结果如下。

奇数

分析:

num%2 == 0 表示判断 num 除以 2 的余数是否等于 0。因为 15 除以 2 的余数是 1,条件返回 false,所以程序跳过了 if 分支,直接执行 else 分支输出 "奇数"。

在编写 if...else 语句时,我们要特别注意花括号和 else 的位置:左花括号 { 必须紧跟在 if 所在行的末尾,else 也必须紧跟在右花括号 } 后面写成 } else {,不能把 else 单独换到下一行。

// 正确方式
if num%2 == 0 {
    fmt.Println("偶数")
} else {
    fmt.Println("奇数")
}

// 错误方式
if num%2 == 0 {
    fmt.Println("偶数")
}
else {
    fmt.Println("奇数")
}

{ 与 else 的换行规则

有些学过其他编程语言的小伙伴习惯把左花括号 { 或 else 单独换到下一行写,为什么在 Go 语言中这样写一编译就报错呢?

这是因为 Go 代码每行末尾不需要手动写分号,编译器在扫描代码时会自动在特定行尾补上隐藏的分号(;)。如果我们把 else 单独换到下一行,编译器看到上一行以 } 结尾,就会自动补上分号,认为整个 if 语句已经结束了。

这样一来,下一行的 else 就成了没有 if 配对的孤立语句,编译时会直接报 syntax error: unexpected else(意外的 else)错误。

多分支 if...else if...else 语句

很多时候,程序里的判断并不是非黑即白的 “二选一”,而是存在 3 种甚至更多种情况。比如把考试成绩划分为优秀、良好、及格、不及格 4 个等级,这时我们就可以在双分支的基础上,使用 else if 增加多个判断分支。

语法:

if 条件1 {
    // 条件1为 true 时执行的代码
} else if 条件2 {
    // 条件2为 true 时执行的代码
} else {
    // 以上条件都为 false 时执行的代码
}

说明:

多分支选择看似复杂,其实只是在双分支的基础上多加了几个 else if 分支。程序会从第 1 个 if 条件开始依次往下判断,只要遇到某个条件返回 true,就会执行对应分支的代码并直接退出整个 if 结构,执行流程如下图所示。

Go 多分支 if 语句的执行流程

只有当前面的所有条件都不成立时,程序才会执行最后的 else 分支。如果不需要处理默认情况,最后的 else 分支也可以省略不写。

示例 3:多分支成绩等级判断

package main

import "fmt"

func main() {
    score := 85
    if score >= 90 {
        fmt.Println("优秀")
    } else if score >= 80 {
        fmt.Println("良好")
    } else if score >= 60 {
        fmt.Println("及格")
    } else {
        fmt.Println("不及格")
    }
}

运行结果如下。

良好

分析:

变量 score 的值为 85。程序先判断第 1 个条件 score >= 90,结果为 false。接着判断第 2 个条件 score >= 80,返回 true,于是输出 "良好" 并直接退出整个 if 结构,后面的分支不再执行。

可能有些小伙伴会问:“第 2 个条件为什么只写 score >= 80,而不用写成 score >= 80 && score < 90 呢?”

其实,程序之所以能走到第 2 个分支,本身就已经说明第 1 个条件 score >= 90 不成立。此时分数肯定小于 90,所以我们只需要继续判断是否大于或等于 80 就可以了。

也正因为程序是从上往下依次判断的,写 else if 时一定要注意条件的先后顺序。假如把最宽松的 score >= 60 放到第 1 个分支,当 score 为 85 时,程序一上来就会命中并输出 "及格" 退出,后面的 80 分和 90 分分支压根没机会执行。

因此,按数值划分区间时,小伙伴们记住一个规律就可以了:先写范围最严格的条件,再一步步往下放宽。

带初始化语句的 if 语句

在 Go 语言中,if 语句还支持一种非常实用的简练写法:我们可以在条件表达式前面加上一条简短的初始化语句,中间使用英文分号(;)隔开。

语法:

if 初始化语句; 条件 {
    // 条件为 true 时执行的代码
}

说明:

程序执行时,会先运行分号前面的 “初始化语句” 来定义临时变量,紧接着再判断分号后面的 “条件” 是否成立。

示例 4:在 if 中初始化变量

package main

import "fmt"

func main() {
    price := 40
    count := 3
    if total := price * count; total >= 100 {
        fmt.Printf("已满 100 元,总价为 %d 元\n", total)
    } else {
        fmt.Printf("未满 100 元,总价为 %d 元\n", total)
    }
}

运行结果如下。

已满 100 元,总价为 120 元

分析:

在这个例子中,if 开头先执行分号前面的 total := price * count 算出总价 120,紧接着判断分号后面的 total >= 100 是否成立。因为 120 大于 100,条件返回 true,程序便进入 if 分支输出了结果。

对于这个例子来说,下面 2 种方式在判断逻辑上是等价的。

// 方式 1(推荐)
if total := price * count; total >= 100 {
    fmt.Println(total)
}

// 方式 2
total := price * count
if total >= 100 {
    fmt.Println(total)
}

那这两种写法有什么区别呢?区别在于变量的有效范围,也就是后面章节会学到的变量作用域。在方式 1 中,临时变量 total 只在当前这一个 if...else 结构的花括号内部有效。

一旦离开这个 if...else 结构,变量 total 就会立即失效,如果在外面继续访问它,编译时会直接报 undefined: total(未定义的 total)错误。

这里还要提醒一个容易疏忽的细节:如果花括号外面本身已经定义了一个同名的变量 total,在 if 初始化语句里再写 total := ...,创建的是内部全新的临时变量,并不会修改外面那个 total 的值。平时起名时尽量错开,免得看花眼。

在实际开发中,如果某个临时变量只是为了配合当前的 if 判断、后面不再需要用到它,我们更推荐使用方式 1。这样可以让临时变量用完即释放,避免在外面留下多余的变量。

if 语句的嵌套

在一个 if 或 else 分支的花括号内部,我们还可以继续放入另一个 if 语句,这种结构叫做 if 语句的嵌套。当需要先满足一个大前提、再进一步细分判断时,嵌套写法就非常实用。

示例 5:if 语句的嵌套

package main

import "fmt"

func main() {
    hasTicket := true
    weight := 25
    if hasTicket {
        if weight <= 20 {
            fmt.Println("车票有效,行李免费进站")
        } else {
            fmt.Println("车票有效,行李超重需补运费")
        }
    } else {
        fmt.Println("请先购票后再进站")
    }
}

运行结果如下。

车票有效,行李超重需补运费

分析:

上面代码从外到内一层层判断:外层的 hasTicket 为 true,说明已经购票,于是进入外层花括号;接着判断内层的 weight <= 20 返回 false,最终执行内层 else 分支输出 "车票有效,行李超重需补运费"。

在实际开发中,为了保证代码清晰好读,建议大家把 if 的嵌套层数控制在 2~3 层以内。如果发现条件越套越深,可以把关联条件通过 && 合并到一起,或者先把不满足前提的情况提前处理掉,这样代码阅读起来会清爽不少。

常见问题

1. Go 语言的 if 条件外面需要加小括号 () 吗?加了会不会报错?

不需要。Go 语言为了简化语法、减少不必要的符号输入,规定 if 后面的条件最外层不用加小括号。

如果刚开始习惯性地写成了 if (age >= 18),编译时并不会报错,但在保存文件(Ctrl + S)时,编辑器自带的格式化工具会自动把最外层多余的小括号去掉。

不过,当条件中包含多个逻辑运算、需要改变运算符优先级时,局部加小括号依然是必要的,比如 if (a > 0 || b > 0) && c > 0。

2. 遇到多分支判断时,应该选择 if...else if 还是 switch?

如果判断条件涉及多个不同变量的组合,比如同时判断会员等级和消费金额,通常使用 if...else if;如果是拿同一个变量去匹配多个具体的固定值,使用 switch 语句会更加直观清爽。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号