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