苏呆呆的博客 苏呆呆的博客
首页
  • C++
  • Java
  • Go
  • 面向对象
  • 设计模式
  • 领域驱动设计
  • Spring
常用工具
  • 本站

    • 分类
    • 标签
    • 归档
  • 我的

    • 关于
    • 收藏
GitHub (opens new window)

苏呆呆

一个向往美好生活的笨人。
首页
  • C++
  • Java
  • Go
  • 面向对象
  • 设计模式
  • 领域驱动设计
  • Spring
常用工具
  • 本站

    • 分类
    • 标签
    • 归档
  • 我的

    • 关于
    • 收藏
GitHub (opens new window)
  • HelloWorld
  • 基础
  • 控制流
    • for
    • for(续)
    • for 是 Go 中的 “while”
    • 无限循环
    • if
    • if 的简短语句
    • if 和 else
    • 练习:循环与函数
    • switch
    • switch 的求值顺序
    • 没有条件的 switch
    • defer
    • defer 栈
  • 更多类型
  • 方法
  • 并发
  • 编程语言--golang
su-dd
2023-03-13
目录

控制流

# for

Go 只有一种循环结构:for 循环。

基本的 for 循环由三部分组成,它们用分号隔开:

初始化语句:在第一次迭代前执行 条件表达式:在每次迭代前求值 后置语句:在每次迭代的结尾执行 初始化语句通常为一句短变量声明,该变量声明仅在 for 语句的作用域中可见。

一旦条件表达式的布尔值为 false,循环迭代就会终止。

注意:和 C、Java、JavaScript 之类的语言不同,Go 的 for 语句后面的三个构成部分外没有小括号, 大括号 { } 则是必须的。

package main

import "fmt"

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

1
2
3
4
5
6
7
8
9
10
11
12

# for(续)

初始化语句和后置语句是可选的。

package main

import "fmt"

func main() {
	sum := 1
	for ; sum < 1000; {
		sum += sum
	}
	fmt.Println(sum)
}

1
2
3
4
5
6
7
8
9
10
11
12

# for 是 Go 中的 “while”

此时你可以去掉分号,因为 C 的 while 在 Go 中叫做 for。

package main

import "fmt"

func main() {
	sum := 1
	for sum < 1000 {
		sum += sum
	}
	fmt.Println(sum)
}

1
2
3
4
5
6
7
8
9
10
11
12

# 无限循环

如果省略循环条件,该循环就不会结束,因此无限循环可以写得很紧凑。

package main

func main() {
	for {
	}
}

1
2
3
4
5
6
7

# 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))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# if 的简短语句

同 for 一样, if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 if 之内。

(在最后的 return 语句处使用 v 看看。)

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),
	)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# if 和 else

在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。

(在 main 的 fmt.Println 调用开始前,两次对 pow 的调用均已执行并返回其各自的结果。)

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)
	}
	// 这里开始就不能使用 v 了
	return lim
}

func main() {
	fmt.Println(
		pow(3, 2, 10),
		pow(3, 3, 20),
	)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 练习:循环与函数

为了练习函数与循环,我们来实现一个平方根函数:用牛顿法实现平方根函数。

计算机通常使用循环来计算 x 的平方根。从某个猜测的值 z 开始,我们可以根据 z² 与 x 的近似度来调整 z,产生一个更好的猜测:

z -= (zz - x) / (2z) 重复调整的过程,猜测的结果会越来越精确,得到的答案也会尽可能接近实际的平方根。

在提供的 func Sqrt 中实现它。无论输入是什么,对 z 的一个恰当的猜测为 1。 要开始,请重复计算 10 次并随之打印每次的 z 值。观察对于不同的值 x(1、2、3 ...), 你得到的答案是如何逼近结果的,猜测提升的速度有多快。

提示:用类型转换或浮点数语法来声明并初始化一个浮点数值:

z := 1.0 z := float64(1) 然后,修改循环条件,使得当值停止改变(或改变非常小)的时候退出循环。观察迭代次数大于还是小于 10。 尝试改变 z 的初始猜测,如 x 或 x/2。你的函数结果与标准库中的 math.Sqrt 接近吗?

(注: 如果你对该算法的细节感兴趣,上面的 z² − x 是 z² 到它所要到达的值(即 x)的距离, 除以的 2z 为 z² 的导数,我们通过 z² 的变化速度来改变 z 的调整量。 这种通用方法叫做牛顿法。 它对很多函数,特别是平方根而言非常有效。)

package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) (float64, int) {
	z := 0.0
	y := x / 2
	i := 0

	for i = 0; math.Abs(z-y) > 0.01; i++ {
		z = y
		y -= (z*z - x) / (2 * z)
		fmt.Println(y, math.Abs(z-y))
	}

	return z, i
}

func main() {
	fmt.Println(Sqrt(20))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# switch

switch 是编写一连串 if - else 语句的简便方法。它运行第一个值等于条件表达式的 case 语句。

Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的,不过 Go 只运行选定的 case,而非之后所有的 case。 实际上,Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。 除非以 fallthrough 语句结束,否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量,且取值不必为整数。

package main

import (
	"fmt"
	"runtime"
)

func main() {
	fmt.Print("Go runs on ")
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.\n", os)
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# switch 的求值顺序

switch 的 case 语句从上到下顺次执行,直到匹配成功时停止。

(例如,

switch i {
case 0:
case f():
}

在 i==0 时 f 不会被调用。)

注意: Go 练习场中的时间总是从 2009-11-10 23:00:00 UTC 开始,该值的意义留给读者去发现。

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("When's Saturday?")
	today := time.Now().Weekday()
	switch time.Saturday {
	case today + 0:
		fmt.Println("Today.")
	case today + 1:
		fmt.Println("Tomorrow.")
	case today + 2:
		fmt.Println("In two days.")
	default:
		fmt.Println("Too far away.")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 没有条件的 switch

没有条件的 switch 同 switch true 一样。

这种形式能将一长串 if-then-else 写得更加清晰。

package main

import (
	"fmt"
	"time"
)

func main() {
	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值,但直到外层函数返回前该函数都不会被调用。

package main

import "fmt"

func main() {
	defer fmt.Println("world")

	fmt.Println("hello")
}

1
2
3
4
5
6
7
8
9
10

# defer 栈

推迟的函数调用会被压入一个栈中。当外层函数返回时,被推迟的函数会按照后进先出的顺序调用。

更多关于 defer 语句的信息,请阅读此博文。

package main

import "fmt"

func main() {
	fmt.Println("counting")

	for i := 0; i < 10; i++ {
		defer fmt.Println(i)
	}

	fmt.Println("done")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
编辑 (opens new window)
上次更新: 2023/03/16, 14:24:48
基础
更多类型

← 基础 更多类型→

最近更新
01
并发
03-16
02
Qt原子操作
03-15
03
方法
03-13
更多文章>
Theme by Vdoing | Copyright © 2022-2023 daidai | 皖ICP备2023000523号-1
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式