go语言练习（一）

fmt格式输出，格式转化：

package main
import "fmt"
func main() {
	t := float64(3) / float64(2)
	fmt.Printf("test:  %t \n", t == (float64(3)/2)) //true
	fmt.Printf("test1: %.1f \n", t/2)               //0.8 (四舍五入)
	t = t/2 + t
	fmt.Printf("test2: %f \n", t) //2.25
	t = float64(3 / 2)
	fmt.Printf("test3: %f \n", t) //1
	t = t/2 + t
	fmt.Printf("test4: %f \n", t) //1.5
}

1、斐波那契数列：

package main
import "fmt"
func fibonacci() func(n int) int {
	var fib = []int{0, 1, 1}
	var fibFuc func(n int) int
	fibFuc = func(n int) int {
		switch n {
		case 0:
			return fib[0]
		case 1:
			return fib[1]
		case 2:
			return fib[2]
		default:
			return fibFuc(n-1) + fibFuc(n-2)
		}
	}
	return fibFuc
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f(i))
	}
}

2、接口实现，fmt里有Stringer的接口，其中

// Stringer is implemented by any value that has a String method,
// which defines the ``native'' format for that value.
// The String method is used to print values passed as an operand
// to any format that accepts a string or to an unformatted printer
// such as Print.
type Stringer interface {
	String() string
}

自定义IP的byte数组结构，然后实现Stringer，使得打印输出型如“0.0.0.0”

package main
import (
	"fmt"
	"strconv"
)

type IPAddr [4]byte
func main() {
	addrs := map[string]IPAddr{
		"loopback":  {127, 0, 0, 1},
		"googleDNS": {8, 8, 8, 8},
	}
	for n, a := range addrs {
		fmt.Printf("%v: %v\n", n, a)
	}
}

func (ip IPAddr) String() string {
	str := ""
	for i, v := range ip {
		str = str + strconv.FormatInt(int64(v), 10)
		if i < len(ip)-1 {
			str = str + "."
		}
	}
	return str
}

练习：错误

练习 Sqrt 函数，二分法开方，自设精度。并修改使其返回 error 值。

Sqrt 接收到一个负数时，应当返回一个非 nil 的错误值。复数同样也不被支持。

创建一个新类型 type ErrNegativeSqrt float64 为其实现 func (e ErrNegativeSqrt) Error() string
使其成为一个 error， 该方法就可以让 ErrNegativeSqrt(-2).Error() 返回 "cannot Sqrt negative number: -2"。

注意： 在 Error 方法内调用 fmt.Sprint(e) 将会让程序陷入死循环。可以通过先转换 e 来避免这个问题：fmt.Sprint(float64(e))。请思考这是为什么呢？

修改 Sqrt 函数，使其接受一个负数时，返回 ErrNegativeSqrt 值。

package main

import (
	"fmt"
	"math"
)

type ErrNagtiveSqrt float64

func (err ErrNagtiveSqrt) Error() string {
	return fmt.Sprintf("cannot Sqrt negative number: %d", float64(err))
}

// 开方函数
func Sqrt(n float64) (float64, error) {
	if n < 0 {
		if err := error(ErrNagtiveSqrt(n)); err != nil {
			return 0, err
		}
	}

	precision := 0.00001 //精度
	max := n / 2         //区间最大边界
	min := float64(0)    //区间最小边界
	mid := max           //当前测试的中点值
	i := 0
	// 2分法找临近的值
	for {
		i++
		oMid := mid
		if mid*mid > n {
			max = (max-min)/2 + min
			mid = min
		} else if mid*mid < n {
			max = (max-min)/2 + max
			min = mid
			mid = max
		} else {
			break
		}
		//fmt.Printf("num : %f,   max : %f,   min : %f  \n", mid, max, min)
		if param := math.Max(math.Abs(oMid-mid), precision); param == precision {
			break
		}
	}
	//fmt.Printf("circulation times : %d  \n", i)
	return mid, nil
}

func main() {
	fmt.Println(Sqrt(3))
	fmt.Println(math.Sqrt(3))
	fmt.Println(Sqrt(-2))
}