GO语言学习三（流程控制语句）

一、For循环

Go 只有一种循环结构—— 

for

 循环

for循环包含三个由分号分开的组成部分：

初始化语句 ： 第一次循环执行前被执行     可选

循环条件表达式 ： 每次迭代开始前被求值：false or true  必须

后置语句：每次迭代后执行   可选

样例一 常用循环：

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

样例三 死循环：
package main

func main() {
for {
}
}


DEMO :

package main

import "fmt"

func main() {
var i, j int
//计算100以内的素数
for i = 2; i < 100; i++ {
for j = 2; j <= i/j; j++ {
if i%j == 0 {
break // 如果发现因子，则不是素数
}
}
if j > (i / j) {
fmt.Printf("%d 是素数\n", i)
}
}

//字符串反转
str := "hello world"

arr := []rune(str)

for i,j := 0,len(arr)-1;i<len(arr)/2;i,j = i+1,j-1{
arr[i],arr[j] = arr[j],arr[i]
}
fmt.Println(string(arr))

}


二、if

条件表达式

可以在条件之前执行一个简单语句，这个语句定义的变量的作用域仅在if范围之内

样例：

package main

import (
"fmt"

"math"
)

func main() {
/* 定义局部变量 */
var a int = 10

/* 使用 if 语句判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n")
}
fmt.Printf("a 的值为 : %d\n", a)

fmt.Println(pow(2, 3, 10))
fmt.Println(pow(3, 3, 20))

}

func pow(x, n, lim float64) float64 {
//if 语句可以在条件之前执行一个简单语句
if v := math.Pow(x, n); v < lim {
return v
} else {
//在if的便捷语句定义的变量同样可以在任何对应的else块中使用
fmt.Printf("%g >= %g\n", v, lim)
}
//这个地方就无法使用if中定义的变量v
return lim
}
DEMO：利用牛顿法 计算平方根   


     简化后  z = z/2 + x/2*z

/**
练习：循环和函数
作为练习函数和循环的简单途径，用牛顿法实现开方函数
*/
package main

import (
"fmt"
)

func Sqrt(x float64) float64 {
z := float64(1)
for i := 0; i < 1e+5; i++ {
z = z/2 + x/(2*z)
}
return z
}

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


三、switch

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

没有条件的 switch 同 

switch
true

 一样 相当于if-then-else

样例一：

package main

import (
"fmt"
"runtime"
)

func main() {

/* 定义局部变量 */
var grade string = "B"
var marks int = 90

switch marks {
case 90:
grade = "A"
case 80:
grade = "B"
case 50, 60, 70:
grade = "C"
default:
grade = "D"
}

switch {
case grade == "A":
fmt.Printf("优秀!\n")
case grade == "B", grade == "C":
fmt.Printf("良好\n")
case grade == "D":
fmt.Printf("及格\n")
case grade == "F":
fmt.Printf("不及格\n")
default:
fmt.Printf("差\n")
}
fmt.Printf("你的等级是 %s\n", grade)

fmt.Println(runtime.GOOS)

switch os := runtime.GOOS; os {

case "windows":
fmt.Println("system is " + os)
case "linux":
fmt.Println("Linux.")
default:
fmt.Printf("%s.", os)
}

}

样例二：

package main

import (
"fmt"
"time"
)

func main() {
var x interface{}
//switch 自上而下执行，当匹配成功的时候停止
switch i := x.(type) {
case nil:
fmt.Printf(" x 的类型 :%T", i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型")
default:
fmt.Printf("未知型")
}

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

//没有条件的switch 相当于if-then-else链
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.")
}
}
四、defer延时 

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

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

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

样例：

package main

import "fmt"

func main() {
//defer语句会延时函数的执行知道上层函数返回。

defer fmt.Println("world")
fmt.Println("hello")

i := 1
//延时调用的参数会立刻生成，但是在上层函数返回前函数都不会被调用
//延时的函数调用被压入一个栈中。当函数返回时，会按照后进先出的顺序调用被延迟的函数调用
defer fmt.Println(i)
i++
fmt.Println(i)
}