Go语言学习Part2：流程控制语句：for、if、else、switch 和 defer

for循环

• 初始化语句+条件语句+后置语句
  • 初始化语句一般为短变量声明
  • 条件语句在迭代前求值，false迭代就会中止
  • 后置语句在每次迭代结尾执行

//case 1
package main

import "fmt"

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

• 条件语句一般如果想要循环结束应该有，初始化语句和后置语句可有可无
  • 只有条件语句就可以（看起来像不像C里面的while）
  • 条件语句两侧加分号也可以
  • 省略条件语句，会变成无限循环

//case 2
package main

import "fmt"

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

//case 3
package main

import "fmt"

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

//case 4
package main

import "fmt"

func main() {

    for {
        fmt.Printf("hello")
    }
}

if语句

//case 5
//实现一个开根号的函数

package main

import (
    "fmt"
    "math"
)

func sqrtFloat(x float64) string {
    if x < 0 {
        return sqrtFloat(-x)+"i"
    } 
    return fmt.Sprint(math.Sqrt(x))
}

func main() {
	fmt.Println(sqrtFloat(-9), sqrtFloat(80))
    fmt.Println(sqrtFloat(5))
}

• if语句可以在表达式执行之前执行一个简单的语句

//case 6
// 写代码也考验记忆里hh，各种规则都要记住
// math.Pow()的参数是float64
package main    
import "fmt"
import "math"

func test(x, y, limit float64) float64{
    if v := math.Pow(x, y); v < limit {
        return v
    } else {
		 return limit
	}
       
}

func main() {
    fmt.Println(test(2,3, 6))
    fmt.Println(test(2,3, 10))
}

• if 简短语句声明的变量，else仍旧有效；出了if、else块变量就无效了

//case 7
// 写代码也考验记忆里hh，各种规则都要记住
// math.Pow()的参数是float64
package main    
import "fmt"
import "math"

func test(x, y, limit float64) float64{
    if v := math.Pow(x, y); v < limit {
        return v
    } else {
        fmt.Println("test else",v)
		 return limit
	}
       
}

func main() {
    fmt.Println(test(2,3, 6))
    fmt.Println(test(2,3, 10))
}

switch

• go的进入一个case，会自动退出；如果你想要强制执行下面的case：使用fallthrough
  • Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch, 但是可以使用fallthrough强制执行后面的所有case代码，包括default。见case8
  • 最后一个分支，不能使用fallthrough
• case 不用是int，任何类型都可以
• 写起来比if else 简单很多，见case9

//case 8
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)
	}
	
	s := "abcd"  // 匹配b，输出了234
	switch  s[1] {
	case 'a':
		fmt.Println("1")
		fallthrough
	case 'b':
		fmt.Println("2")
		fallthrough
	case 'e':
		fmt.Println("3")
		fallthrough
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("4")

	}
}

// case 9
package main

import (
	"fmt"
	"time"
)

func main() {
	// Go 练习场中的时间总是从 2009-11-10 23:00:00 UTC 语言发布的日子
	// https://tour.go-zh.org/
	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.")
	}
}

练习题目你敢信，考验我记忆的时候到了哈哈哈哈哈

• 一次成功hh，开平方这个找到了数学思维
• 牛顿迭代法求平方根，参考这篇，写的非常之好：https://blog.csdn.net/chenrenxiang/article/details/78286599
  • 主要的思路：平方根的结果是曲线和切线在y轴上的点重合，有一个不断逼近的迭代过程
  • case10:迭代法的变种
  • case11:迭代法的原型： x(n+1) = (x(n)*2+a)/2x(n) , a是平方数

// case 10
package main

import (
	"fmt"
)

func Sqrt(x float64) float64 {
	z := 1.0
	for i:=0; i< 100; i++ {
		z -= (z*z -x)/(2*z)
		fmt.Println(z)
	}
	return z
}

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

//case 11
package main

import (
	"fmt"
)

func Sqrt(x float64) float64 {
	xcur := 1.0;
	for i:=0; i< 100; i++ {
		xcur = (xcur*xcur +x)/(2*xcur)
		fmt.Println(xcur)
	}
	return xcur
}

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

runtime知多少

• runtime 调度器是个非常有用的东西，关于 runtime 包几个方法:
  • 以下来源该链接：https://www.jianshu.com/p/e45cea3e1723
  • Gosched：让当前线程让出 cpu 以让其它线程运行,它不会挂起当前线程，因此当前线程未来会继续执行
  • NumCPU：返回当前系统的 CPU 核数量
  • GOMAXPROCS：设置最大的可同时使用的 CPU 核数, 写在init函数里面
  • Goexit：退出当前 goroutine(但是defer语句会照常执行)
  • NumGoroutine：返回正在执行和排队的任务总数
  • GOOS：目标操作系统
• 以下例子里面有defer，会将函数推迟到外层函数返回后执行,见case 14
  • 推迟的函数会被押入栈中，这也太妙了吧hh，见case 15

//case 12
package main

import (
    "fmt"
    "runtime"
)

func init() {
    runtime.GOMAXPROCS(4)  //使用多核
}

func main() {
	fmt.Println(runtime.NumCPU())
    exit := make(chan int)
    go func() {
        defer close(exit)
        go func() {
            fmt.Println("b")
        }()
    }()

    for i := 0; i < 5; i++ {
        fmt.Println("a:", i)

        if i == 1 {
            runtime.Gosched()  //切换任务
        }
        if i == 3 {
            runtime.Gosched()  //切换任务
        }
    }
    <-exit
}

//case 14
package main

import "fmt"

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

	fmt.Println("hello")
}

//case 15
package main

import "fmt"

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

	for i := 10; i >= 0; i-- {
		defer fmt.Println(i)
	}

	fmt.Println("done")
}

函数知多少

• fmt.Printf()
  • 根据 format 参数生成格式化的字符串并写入标准输出
• fmt.Sprintf()
  • 根据 format 参数生成格式化的字符串并返回该字符串
• fmt.Fprintf()
  • 根据format 参数生成格式化的字符串并写入 io.Writer
• time.Now().Weekday()
  • time.Saturday

//case 13
package main

import (
	"fmt"
	"time"
)

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

一点点好东西

• https://golang.org/ref/spec