五、go语言特性--go语言笔记

defer

defer:调用一个被 defer 的函数时在函数刚要返回之前延迟执行，当函数无论怎样返回，某资源必须释放时，可用这种与众不同、但有效的处理方式。传统的例子包括解锁互斥或关闭文件。

这样延迟一个函数有双重优势：一是你永远不会忘记关闭文件，此错误在你事后编辑函数添加一个返回路径时常常发生。二是关闭和打开靠在一起，比放在函数尾要清晰很多。

package main

import "log"

func main() {

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

/* func myDefer() func() {
    defer log.Println("log")
    if a := 1; a == 1 {
        return func() { fmt.Println("1") }()
    }
    return func() { fmt.Println("end") }()
}*/

error处理

package main

import (
    "fmt"
)

type dualError struct {
    Num     int
    problem string
}

func (e dualError) Error() string {
    return fmt.Sprintf("输入不正确，因为\"%d\"不是偶数", e.Num)

}
func requireDual(n int) (int, error) {
    if n%2 == 1 {
        return -1, dualError{Num: n}

    }
    return n, nil

}
func main() {
    if result, err := requireDual(7); err != nil {
        fmt.Println("错误：", err)

    } else {
        fmt.Println("正确：", result)

    }

}

for 循环

package main

import "fmt"

func main() {

    arrayI := [...]int{1, 2, 3}
    for i := 0; i < len(arrayI); i++ {
        fmt.Println(arrayI[i])
    }
    sliceI := []int{4, 5} //slice
    for i, _ := range arrayI {
        fmt.Println(i)
    }
    fmt.Println("After range []arr", arrayI)

    for i, v := range &arrayI {
        v *= 100
        fmt.Println(i, v)

    }
    fmt.Println("After range *[]arr", arrayI)
    for i, v := range sliceI {
        v *= 10
        fmt.Println(i, v)
    }
    fmt.Println("After range []slice", sliceI)

}

if

package main

import "fmt"

func main() {
    if i := 10; i == 10 {
        fmt.Println("o ye")
    }
    fmt.Println(i)   //undefine i
}

nocopy

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    var src, dst *os.File
    src, _ = os.Open("defer.go")
    defer func() {
        src.Close()
        dst.Close()
    }()

    dst, _ = os.OpenFile("defer2.go", os.O_WRONLY|os.O_CREATE, 0644)
    //_, err := io.Copy(dst, src)
    //fmt.Println(err)
    buf := make([]byte, 1024)
    for {
        nr, er := src.Read(buf)
        if nr > 0 {
            nw, _ := dst.Write(buf[0:nr])
            fmt.Println("write size:", nw)
        }
        if er == io.EOF {
            break
        }
    }

}

switch 经典用法

package main

import (
    "fmt"
    "reflect"
)

type myStruct struct {
    F float64 //capital
    B bool
    I int
}

func main() {
    var ms = &myStruct{0.1, false, 1}
    val := reflect.ValueOf(ms).Elem()
    for i := 0; i < val.NumField(); i++ {
        f := val.Field(i)
        switch f.Interface().(type) {
        case int:
            fmt.Println("case int")
        case float64:
            fmt.Println("case float64")
        case bool:
            fmt.Println("case bool")
        }

    }
}

func (l *Logger) Output(calldepth int, s string) error  
// 真正负责日志打印的方法，其它级别的打印方法都将会调用它 
func (l *Logger) Println(v ...interface{}) { 
// 一般信息打印方法，相当于JAVA中log的info级别 l.Output(2, fmt.Sprintln(v...)) 
} 
func (l *Logger) Panicln(v ...interface{}) { 
// 业务异常时使用的方法，该方法会抛出异常，调用方可以用recover捕获
s := fmt.Sprintln(v...) l.Output(2, s) panic(s) // 通过panic抛出异常
}
func (l *Logger) Fatalln(v ...interface{}) { 
l.Output(2, fmt.Sprintln(v...)) os.Exit(1) // 调用该方法会中止应用程序并直接退出
 }

error

error :
实际上是抽象了 Error() 方法的 error 接口golang 使用该接口进行标准的错误处理
一般情况下，如果函数需要返回错误，就将 error 作为多个返回值中的最后一个（但这并非是强制要求）