Go语言中循环与判断的语法、用法与最佳实践

2026-04-10 08:35:04 作者：XMYX-0

本文详细介绍了Go语言的if条件判断、for循环和switch语句的用法,包括基本语法、高级用法和实战技巧,并指出了一些常见的错误和最佳实践,通过本文,读者可以掌握Go语言中的循环和条件判断的核心用法,需要的朋友可以参考下

在 Go（Golang）中，循环和条件判断设计得非常简洁，没有冗余语法，但却足够强大。相比其他语言（如 Java、Python），Go 在这方面有不少“反直觉但优雅”的设计。

本文将带你系统掌握：

Go 的 if 条件判断
Go 的 for 循环（唯一循环关键字）
switch 的高级用法
实战技巧与常见坑

条件判断：if

基本语法

if 条件 {
    // 执行代码
}

示例：

package main

import "fmt"

func main() {
	age := 30
	if age >= 18 {
		fmt.Println("成年人")
	}
}

明显30大于18
输出：

成年人

if-else

if 条件 {
    // 执行
} else {
    // 执行
}

package main

import "fmt"

func main() {
	score := 90
	if score >= 60 {
		fmt.Println("及格")
	} else {
		fmt.Println("不及格")
	}
}

输出：

及格

if-else if-else

package main

import "fmt"

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

输出：

优秀

if 的“增强写法”（非常重要）

Go 支持在 if 中写初始化语句：

if 变量 := 表达式; 条件 {
    // 使用变量
}

示例：

package main

func main() {
	if num := 10; num > 5 {
		println("大于5")
	}
}

输出：

大于5

特点：

num 只在 if 作用域内有效
常用于错误处理

常见错误（新手必踩）

错误写法（Go 不允许）：

if (age > 18) {  // ❌ Go 不需要括号
}

正确写法：

if age > 18 {
}

循环：for（Go 只有这一种循环）

Go 没有 while、do-while，全部用 for 实现。

标准 for 循环

for 初始化; 条件; 递增 {
    // 循环体
}

示例：

package main

import "fmt"

func main() {
	for i := 0; i < 5; i++ {
		fmt.Println(i)
	}
}

输出：

类 while 循环

for 条件 {
    // 循环体
}

示例：

package main

import "fmt"

func main() {
	i := 0
	for i < 5 {
		fmt.Println(i)
		i++
	}
}

输出：

等价于其他语言的 while

无限循环

for {
    println("死循环")
}

常用于：

服务监听
goroutine 任务循环

break 和 continue

break：跳出循环

package main

import "fmt"

func main() {
	// 跳出循环
	for i := 0; i < 10; i++ {
		if i == 5 {
			break
		}
		fmt.Println(i)
	}
}

输出：

continue：跳过当前循环

package main

func main() {
	for i := 0; i < 5; i++ {
		if i == 2 {
			continue
		}
		println(i)
	}
}

输出：

for-range（超常用）

用于遍历：

数组
切片
map
字符串

遍历切片

package main

import "fmt"

func main() {
	num := []int{1, 2, 3, 4, 5}
	for key, value := range num {
		fmt.Println(key, value)
	}
}

输出：

忽略变量

package main

import "fmt"

func main() {
	num := []int{1, 2, 3, 4, 5}
	for _, value := range num {
		fmt.Println(value)
	}
}

输出：

遍历 map

package main

func main() {
	m := map[string]int{"a": 1, "b": 2}
	for key, value := range m {
		println(key, value)
	}
}

输出：

a 1
b 2

遍历字符串（Unicode 注意）

package main

import "fmt"

func main() {
	str := "你好Golang!"
	for k, v := range str {
		fmt.Println(k, v)
	}
}

输出：

注意：

v 是 Unicode（rune）
不是 byte

条件分支：switch（比你想的更强）

基本用法

package main

import "fmt"

func main() {
	day := 3

	switch day {
	case 1:
		fmt.Println("周一")
	case 2:
		fmt.Println("周二")
	default:
		fmt.Println("其他")
	}
}

输出：

其他

自动 break（重点）

Go 的 switch 默认自带 break！

不需要写：

break

package main

import "fmt"

func main() {
	day := 3

	switch {
	case day >= 1:
		fmt.Println("周一")
	case day >= 2:
		fmt.Println("周二")
	case day >= 3:
		fmt.Println("周三")
	default:
		fmt.Println("其他")
	}
}

输出：

周一

多条件匹配

package main

import "fmt"

func main() {
	day := 1
	switch day {
	case 1, 2, 3:
		fmt.Println("工作日")
	case 6, 7:
		fmt.Println("周末")
	}
}

输出：

工作日

无表达式 switch（非常强）

package main

import "fmt"

func main() {
	score := 85

	switch {
	case score >= 90:
		fmt.Println("优秀")
	case score >= 60:
		fmt.Println("及格")
	default:
		fmt.Println("不及格")
	}
}

输出：

及格

相当于 if-else 的高级版

fallthrough（慎用）

Go 的 fallthrough 是“强制继续执行下一个 case”，不会再判断条件！

package main

import "fmt"

func main() {
	score := 85

	switch {
	case score >= 90:
		fmt.Println("优秀")
		fallthrough
	case score >= 60:
		fmt.Println("及格")
		fallthrough
	default:
		fmt.Println("不及格")
	}
}

输出：

及格
不及格

实战案例

打印九九乘法表

package main

import "fmt"

func main() {
	for i := 1; i <= 9; i++ {
		for j := 1; j <= 9; j++ {
			fmt.Printf("%d*%d=%d\t", j, i, j*i)
		}
		fmt.Println()
	}
}

输出：

1*1=1	2*1=2	3*1=3	4*1=4	5*1=5	6*1=6	7*1=7	8*1=8	9*1=9	
1*2=2	2*2=4	3*2=6	4*2=8	5*2=10	6*2=12	7*2=14	8*2=16	9*2=18	
1*3=3	2*3=6	3*3=9	4*3=12	5*3=15	6*3=18	7*3=21	8*3=24	9*3=27	
1*4=4	2*4=8	3*4=12	4*4=16	5*4=20	6*4=24	7*4=28	8*4=32	9*4=36	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	6*5=30	7*5=35	8*5=40	9*5=45	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	7*6=42	8*6=48	9*6=54	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	8*7=56	9*7=63	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	9*8=72	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

查找数组中的某个值

package main

import "fmt"

func main() {
	nums := []int{1, 2, 3, 4, 5}
	target := 3

	fount := false
	for _, v := range nums {
		if v == target {
			fount = true
			break
		}
	}
	if fount {
		fmt.Println("yes")
	} else {
		fmt.Println("no")
	}
}

输出：

yes

最佳实践总结（面试常问）

优先使用 for-range

✔ 简洁
✔ 不容易出错

if 初始化语句要熟练

package main

import "fmt"

func main() {
	// 错误处理
	doSomething := func() error {
		return fmt.Errorf("出错1")
	}
	fmt.Println(doSomething())
	if err := doSomething(); err != nil {
		fmt.Println("出错2")
	}
}

出错1
出错2

Go 标准写法

switch 优于多层 if

✔ 更清晰
✔ 更易维护

避免死循环

for {
    // 一定要有退出条件！
}

总结

Go 的循环与判断设计哲学：

简洁 > 花哨
一种结构解决多种问题

核心记住：

if：支持初始化语句
for：唯一循环关键字（代替 while）
range：遍历神器
switch：比 if 更强大

以上就是Go语言中循环与判断的语法、用法与最佳实践的详细内容，更多关于Go循环与判断的资料请关注脚本之家其它相关文章！