Golang Basic 2

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

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

package main

import "fmt"

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

for 是 Go 中的 “while”

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

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

if 的简短语句

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

该语句声明的变量作用域仅在 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

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

练习：循环与函数

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

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

z -= (z*z - x) / (2*z)

重复调整的过程，猜测的结果会越来越精确，得到的答案也会尽可能接近实际的平方根。

在提供的 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 {
    z := 1.0
    delta := (z*z - x) / (2 * z)
    for math.Abs(delta) > 0.0000001 {
        z -= delta
        delta = (z*z - x) / (2 * z)
    }

    return z
}

func main() {
    fmt.Println(Sqrt(2))
}

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:
            fmt.Println("%s.\n", os)
    }
}

没有条件的switch

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

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

defer

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

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

package main

import "fmt"

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

defer 栈

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

package main

import "fmt"

func main() {
    fmt.Println("counting")
    
    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }
    
    fmt.Println("done")
}