go学习总结（五）

1.格式化输出

格式化指令	含义
%%	%字面量
%b	一个二进制整数，将一个整数格式转化为二进制的表达方式
%c	一个Unicode的字符
%d	十进制整数
%o	八进制整数
%x	小写的十六进制数值
%X	大写的十六进制数值
%U	一个Unicode表示法表示的整型码值
%s	输出以原生的UTF8字节表示的字符，如果console不支持utf8编码，则会乱码
%t	以true或者false的方式输出布尔值
%v	使用默认格式输出值，或者如果方法存在，则使用类性值的String()方法输出自定义值
%T	输出值的类型

package main

import (
	"fmt"
)

func main() {
	a:="str"
	fmt.Printf("%%  \n",a)
	fmt.Printf("%b  \n",5)
	fmt.Printf("%c  \n",0x4E2D)
	fmt.Printf("%d  \n",0x12)
	fmt.Printf("%o  \n",10)
	fmt.Printf("%x  \n",16)
	fmt.Printf("%X  \n",16)
	fmt.Printf("%U  \n",0x4E2D)
	fmt.Printf("%s  \n",1)
	fmt.Printf("%t  \n",a)
	fmt.Print("%+v  \n",a)
	fmt.Printf("%T  \n",a)
}

%  
%!(EXTRA string=str)101  
中  
18  
12  
10  
10  
U+4E2D  
%!s(int=1)  
%!t(string=str)  
%+v  
strstring

2.循环与函数

实现平方根函数
package main

import (
	"fmt"
)

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

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

3.switch

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

}


Go runs on windows.

When's Saturday?
Tomorrow.

4.无条件Switch

没有条件的 switch 同 switch true 一样。 
package main

import (
	"fmt"
	"time"
)

func main() {
	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.")
	}
}

5.defer延迟

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

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

package main

import "fmt"

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

	fmt.Println("hello")
}

6.defer栈

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

import "fmt"

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

	for i := 0; i < 10; i++ {
		defer fmt.Println(i)
	}

	fmt.Println("done")
}

counting
done
9
8
7
6
5
4
3
2
1
0