7.笔记go语言——if,switch,defer

7.笔记go语言——if,switch,defer

if

if 语句除了没有了 `( )` 之外（甚至强制不能使用它们），看起来跟 C 或者 Java 中的一样，而 `{ }` 是必须的。

package main

import (

           "fmt"

           "math"

)

func sqrt(x float64) string {

           if x< 0 {

                     returnsqrt(-x) + "i"

           }

           returnfmt.Sprint(math.Sqrt(x))

}

func main() {

           fmt.Println(sqrt(2),sqrt(-4))

}

执行：

1.4142135623730951 2i

跟 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 {

                     returnv

           }

           returnlim

}

func main() {

           fmt.Println(

                     pow(3,2, 10),

                     pow(3,3, 20),

           )

}

执行结果如下：

           920

在 if 的便捷语句定义的变量同样可以在任何对应的 else 块中使用。

package main

import (

           "fmt"

           "math"

)

func pow(x, n, lim float64) float64 {

           if v:= math.Pow(x, n); v < lim {

                     returnv

           }else {

                     fmt.Printf("%g>= %g\n", v, lim)

           }

           // 这里开始就不能使用 v了

           returnlim

}

func main() {

           fmt.Println(

                     pow(3,2, 10),

                     pow(3,3, 20),

           )

}

执行结果：

           27>= 20

           920

switch

一个结构体（`struct`）就是一个字段的集合。

除非以 fallthrough 语句结束，否则分支会自动终止。

执行：

package main

import (

           "fmt"

           "runtime"

)

func main() {

           fmt.Print("Goruns on ")

           switchos := runtime.GOOS; os {

           case"darwin":

                     fmt.Println("OSX.")

           case"linux":

                     fmt.Println("Linux.")

           default:

                     //freebsd, openbsd,

                     //plan9, windows...

                     fmt.Printf("%s.",os)

           }

}

结果：

           Goruns on windows.

switch 的执行顺序

switch 的条件从上到下的执行，当匹配成功的时候停止。

（例如，

switch i {

case 0:

case f():

}

当 i==0 时不会调用 `f`。）

代码：

package main

import (

           "fmt"

           "time"

)

func main() {

           fmt.Println("When'sSaturday?")

           today:= time.Now().Weekday()

           switchtime.Saturday {

           casetoday + 0:

                     fmt.Println("Today.")

           casetoday + 1:

                     fmt.Println("Tomorrow.")

           casetoday + 2:

                     fmt.Println("Intwo days.")

           default:

                     fmt.Println("Toofar away.")

           }

}

执行：

           When'sSaturday?

           Toofar away.

没有条件的 switch

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

这一构造使得可以用更清晰的形式来编写长的 if-then-else 链。

package main

import (

           "fmt"

           "time"

)

func main() {

           t :=time.Now()

           switch{

           caset.Hour() < 12:

                     fmt.Println("Goodmorning!")

           caset.Hour() < 17:

                     fmt.Println("Goodafternoon.")

           default:

                     fmt.Println("Goodevening.")

           }

}

执行：

           Goodevening.

defer

defer 语句会延迟函数的执行直到上层函数返回。

延迟调用的参数会立刻生成，但是在上层函数返回前函数都不会被调用。

代码：

package main

import "fmt"

func main() {

           deferfmt.Println("world")

 

           fmt.Println("hello")

}

执行如下：

           hello

           world

defer 栈

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

代码：

package main

import "fmt"

func main() {

           fmt.Println("counting")

           for i:= 0; i < 10; i++ {

                     deferfmt.Println(i)

           }

           fmt.Println("done")

}

执行：

counting

           done

           9

           8

           7

           6

           5

           4

           3

           2

           1

           0