for 循环
Go 只有一种循环结构：for 循环。
基本的 for 循环由三部分组成，它们用分号隔开：
初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行
初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。
一旦条件表达式求值为 false，循环迭代就会终止。
package main
import "fmt"
func main() {
sum := 0
for i := 0; i < 10; i++ {
sum += i
}
fmt.Println(sum)
}
初始化语句和后置语句是可选的。
package main
import "fmt"
func main() {
sum := 1
for ; sum < 1000; {
sum += sum
}
fmt.Println(sum)
}
去掉分号，假装while
package main
import "fmt"
func main() {
sum := 1
for sum < 1000 {
sum += sum
}
fmt.Println(sum)
}
无限循环
package main
func main() {
for {
}
}
if判断
Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( )，而大括号 { } 则是必须的。
package main
import (
"fmt"
"math"
)
func sqrt(x float64) string {
if x < 0 {
return sqrt(-x) + "i"
}
return fmt.Sprint(math.Sqrt(x))
}
func main() {
fmt.Println(sqrt(2), sqrt(-4))
}
和 for 一样，if 语句可以在条件表达式前执行一个简短语句。
package main
import (
"fmt"
"math"
)
func pow(x, n, lim float64) float64 {
if v := math.Pow(x, n); v < lim {
return v
}
return lim
}
func main() {
fmt.Println(
pow(3, 2, 10),
pow(3, 3, 20),
)
}
if else
package main
import (
"fmt"
"math"
)
func pow(x, n, lim float64) float64 {
if v := math.Pow(x, n); v < lim {
return v
} else {
fmt.Printf("%g >= %g\n", v, lim)
}
// can't use v here, though
return lim
}
func main() {
fmt.Println(
pow(3, 2, 10),
pow(3, 3, 20),
)
}switch
switch 语句是编写一连串 if - else 语句的简便方法。它运行第一个 case 值 值等于条件表达式的子句。
Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的，不过 Go 只会运行选定的 case，而非之后所有的 case。 在效果上，Go 的做法相当于这些语言中为每个 case 后面自动添加了所需的 break 语句。在 Go 中，除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不限于整数。
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Print("Go 运行的系统环境：")
switch os := runtime.GOOS; os {
case "darwin":
fmt.Println("macOS.")
case "linux":
fmt.Println("Linux.")
default:
// freebsd, openbsd,
// plan9, windows...
fmt.Printf("%s.\n", os)
}
}
在 Go 语言中，fallthrough 关键字用于在 switch 语句中继续执行下一个 case 分支的代码。即使下一个 case 条件不匹配，也会继续执行。这在需要多个 case 执行相同或相似代码时会非常有用
package main
import (
"fmt"
)
func main() {
i := 2
fmt.Print("Go 语言中的 fallthrough 示例：")
switch i {
case 0:
fmt.Println("i == 0")
case 1:
fmt.Println("i == 1")
case 2:
fmt.Println("i == 2")
fallthrough
case 3:
fmt.Println("i == 3")
fallthrough
case 4:
fmt.Println("i == 4")
default:
fmt.Println("default case")
}
}
switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("周六是哪天？")
today := time.Now().Weekday()
switch time.Saturday {
case today + 0:
fmt.Println("今天。")
case today + 1:
fmt.Println("明天。")
case today + 2:
fmt.Println("后天。")
default:
fmt.Println("很多天后。")
}
}
无条件switch
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("早上好！")
case t.Hour() < 17:
fmt.Println("下午好！")
default:
fmt.Println("晚上好！")
}
}
defer
defer会将函数推迟到外层函数返回之后执行，推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用
package main
import "fmt"
func main() {
defer fmt.Println("world")
fmt.Println("hello")
}defer栈：推迟调用的函数会被压入栈中，外层返回，按照后进先出的顺序调用
ackage main
import "fmt"
func main() {
fmt.Println("counting")
for i := 0; i < 10; i++ {
defer fmt.Println(i)
}
fmt.Println("done")
}
评论区