爱谁谁

package main

import "errors"
import "fmt"

// 按照惯例，错误一般作为最后一个返回值，并且是内置的error类型
// errors.New创建一个以给定字符串为值的error
func f1(arg int) (int, error) {
    if arg == 42 {
        return -1, errors.New("Can't work with 42")
    }

    // nil标识没有错误返回
    return arg + 3, nil
}

// 也可以通过定义一个实现了Error方法的类型作为error类型
// 该Error方法会打印出struct的两个变量
type argError struct {
    arg int
    prob string
}
func (e *argError) Error() string {
    return fmt.Spintf("%d - %s", e.arg, e.prob)
}

// 使用&argError构造一个struct，作为error类型值返回
func f2(arg int) (int, error) {
    if arg == 42 {
        return -1, &argError{arg, "can't work with it"}
    }

    return arg + 3, nil
}

func main() {
    // 下面的两个循环测试了两个会返回error值的函数
    for _, i := range []int{7, 42} {
        if r, e := f1(i); e != nil {
            fmt.Println("f1 failed: ", e)
        } else {
            fmt.Println("f1 worked:", r)
        }
    }
    for _, i := range []int{7, 42} {
        if r, e := f2(i); e != nil {
            fmt.Println("f2 failed:", e)
        } else {
            fmt.Println("f2 worked:", r)
        }
    }

    // 如果要使用返回的自定义error数据，你需用断言的方式判断该返回值是自定义error的一个实例
    _, e := f2(42)
    if ae, ok := e.(*argError); ok {
        fmt.Println(ae.arg)
        fmt.Println(ae.prob)
    }
}

package main

import "fmt"
import "math"

// 定义一个基本几何图形的接口
type geometry interface {
    area() float64
    perim() float64
}

// 定义两个结构体 rect和circle 实现这个接口
type rect struct {
    width, height float64
}

type circle struct {
    radius float64
}

// golang中实现一个接口类型，只需实现该接口所有的方法
func (r rect) area() float64 {
    return r.width * r.height
}

func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}

func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

// 如果一个变量实现了一个接口类型，则该变量可以调用接口所有的方法
func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    measure(r)
    measure(c)
}

package main

import "fmt"

type rect struct {
    width, height int
}

// 在rect的引用类型上定义一个area方法
func (r *rect) area() int {
    return 2*r.width * 2*r.height
}

// 也可以将方法定义在结构体上
funv (r rect) perim() int {
    return 2*r.width + 2*r.height
}

func main() {
    r := rect{width: 10, height: 5}

    // 直接使用结构体来调用两个方法
    fmt.Println("area: ", r.area())
    fmt.Println("perim: ", r.perim())

    rp := &r
    
    // golang会在方法调用时在结构体和引用之间自动转换，你可能希望使用指针来避免方法调用时的值传递，并且可以在方法内修改传入的结构体的值
    fmt.Println("area: ", rp.area())
    fmt.Println("perim: ", rp.perim())
}

package main

import "fmt"

// 定义一个结构体，含有name和age两个字段
type person struct {
    name string
    age int
}

func main() {
    // 实例化一个person结构体
    fmt.Println(person{"Bob", 20})

    // 也可以指定字段名赋值进行实例化
    fmt.Println(person{name: "Alice", age: 30})
    
    // 实例化为赋值的元素默认为零值
    fmt.Println(person{name: "Fred"})

    // 打印一个指向结构体的指针
    fmt.Println(&person{name: "Ann", age: 40})

    // 使用.操作符来操作结构体的字段
    s := person{name: "Sean", age: 50}
    fmt.Println(s.name)
    
    // 也可以使用.操作符操作结构体指针的字段，此时指针会自动取消引用转化为结构体本身
    sp := &s
    fmt.Println(sp.age)

    // 结构体的值是可变的
    sp.age = 51
    fmt.Println(sp.age)
}

package main

import "fmt"

// 接收一个int类型参数。
// 对ival的赋值不会影响外部变量的值。
func zeroval(ival int) {
    ival = 0
}

// 接收一个int指针类型的参数。
// 对*iptr的赋值操作会直接修改到iptr指针所指向内存的地址。
func zeroptr(iptr *int) {
    *iptr = 0
}

func main() {
    i := 1
    fmt.Println("initial:", i)

    // 传值。
    zeroval(i)
    fmt.Println("zeroval:", i)
    
    // 传引用。
    zeroptr(&i)
    fmt.Println("zeroptr:", i)
    
    // 打印指针指向的内存地址。
    fmt.Println("pointer:", &i)
}

package main

import "fmt"

// 定义一个函数fact递归调用自己直到参数变为0。
func fact(n int) int {
    if n == 0 {
        return 1
    }

    return n * fact(n-1)
}

func main() {
    fmt.Println(fact(7))
}

package main

import "fmt"

// 定义一个函数intSeq返回内部定义的一个匿名函数。
// 返回的函数通过返回变量i来结束并构建闭包。
func intSeq() func() int {
    i := 0
    return func() int {
        i += 1
        return i
    }
}

func main() {
    // 调用函数intSeq，并将其返回给变量nextInt。
    // 该函数值使用自己拥有的变量i，i在我们调用nextInt时都会更新。
    nextInt := intSeq()

    // 调用nextInt函数
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    
    // 变量i的值独立于每个intSeq函数调用。
    nextInts := intSeq()
    fmt.Println(nextInts())
}

package main

import "fmt"

// 定义一个函数，可以接受任意数量的int值作为参数。
func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

func main() {
    // 使用独立的参数调用。
    sum(1, 2)
    sum(1, 2, 3)
    
    // 使用相应类型的slice调用可变参数函数。func(slice...)。
    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

package main

import "fmt"

// (int, int)标识函数会返回两个int值
func vals() (int, int) {
    return 3, 7
}

func main() {
    // 使用两个变量接收两个返回值
    a, b := vals()
    fmt.Println(a)
    fmt.Println(b)

    // 使用‘_’可以忽略掉该返回值
    _, c := vals()
    fmt.Println(c)
}

package main

import "fmt"

// 接收两个int类型的参数，并返回两者之和。
// golang的函数需要显式的return。
func plus(a int, b int) int {
    return a + b
}

// 多个同样类型的参数简便的定义。
func plusPlus(a, b, c int) int {
    return a + b + c
}

func main() {
    res := plus(1, 2)
    fmt.Println("1+2=", res)

    res = plusPlus(1, 2, 3)
    fmt.Println("1+2+3=", res)
}