Go语言学习之7 接口实例、终端文件读写、异常处理

本节主要内容：

1. 终端读写
2. 文件读写
3. 命令行参数
4. Json
5. 自定义错误

1. 终端读写

   操作终端相关文件句柄常量
    os.Stdin：标准输入
    os.Stdout：标准输出
    os.Stderr：标准错误输出

package main

import (
    "fmt"
)

var (
    firstName, lastName, s string
    i                      int
    f                      float32
    input                  = "56.12 / 5212 / Go"
    format                = "%f / %d / %s"
)

func main() {
    fmt.Println("Please enter your full name: ") //Chris Naegels
    fmt.Scanln(&firstName, &lastName) //和下面等价
    // fmt.Scanf("%s %s", &firstName, &lastName)
    fmt.Printf("Hi %s %s!
", firstName, lastName) // Hi Chris Naegels!
    fmt.Sscanf(input, format, &f, &i, &s)
    fmt.Println("From the string we read: ", f, i, s) //From the string we read:  56.12 5212 Go
}

package main 

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    fmt.Println("Input string >>")
    reader := bufio.NewReader(os.Stdin)
    res, err := reader.ReadString('
')
    if err != nil {
        fmt.Println("Read failed, Error: ", err)
    }
    fmt.Printf("Read success, content: ", res)
}

package main 

import (
    "fmt"
    "os"
    "bufio"
)

func main() {
    // fmt.Fprintf(os.Stdout, "%s
", "hello world")

    buf := bufio.NewWriter(os.Stdout)
    fmt.Fprintf(buf, "%s
", "hello world")
    buf.Flush()
}

2. 文件读写

   （1）文件读取

    bufio模块通过对io模块的封装，提供了数据缓冲功能，能够一定程度减少大块数据读写带来的开销。
    实际上在bufio各个组件内部都维护了一个缓冲区，数据读写操作都直接通过缓存区进行。当发起一次读写操作时，会首先尝试从缓冲区获取数据；只有当缓冲区没有数据  时，才会从数据源获取数据更新缓冲。

package main 

import (
    "os"
    "fmt"
    "bufio"
)

func main() {
    var input *bufio.Reader
    var str string
    var err error

    input = bufio.NewReader(os.Stdin)
    str, err = input.ReadString('
') //注意：ReadString会返回读取的字符串(包括分隔符'
')
    if err != nil {
        fmt.Println("Read failed")
    }
    fmt.Println("Read success, content: ", str)
}

练习: 从终端读取一行字符串，统计英文、数字、空格以及其他字符的数量。

package main 

import (
    "fmt"
    "os"
    "bufio"
    "strings"
)

type CharCount struct {
    ChCount int
    NumCount int
    SpaceCount int
    OtherCount int
}

func Count(str string, cc *CharCount) {
    runeArr := []rune(str)
    for _, v := range runeArr {
        fmt.Printf("--%v
",v)
        switch {
        case v >= 'A' && v <= 'Z':
            fallthrough
        case v >= 'a' && v <= 'z':
            cc.ChCount++
        case v >= '0' && v <= '9':
            cc.NumCount++
        case v == ' ':
            cc.SpaceCount++
        default:
            cc.OtherCount++
        }
    }
}

func main() {
    var cc CharCount

    fmt.Println("Input string >>")
    reader := bufio.NewReader(os.Stdin)
    str, err := reader.ReadString('
')
    if err != nil {
        fmt.Println("Read failed")
    }

    str = strings.Trim(string(str), "
") //去掉末尾的
，否则OtherCount会多加2

    Count(string(str), &cc)
    fmt.Println(cc)
}

     os.File封装所有文件相关操作，之前讲的 os.Stdin,os.Stdout, os.Stderr都是*os.File
     a. 打开一个文件进行读操作： os.Open(name string) (*File, error)
     b. 关闭一个文件：File.Close()

     1）将整个文件读取到内存

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    fileName := "F:\Go\project\src\go_dev\day7\test.txt"
    data, err := ioutil.ReadFile(fileName)
    if err != nil {
    fmt.Println("File reading error", err)
    return
    }
    fmt.Println("Contents of file: ", string(data))
}

    2）分块读取文件
         在前面的章节，我们学习了如何把整个文件读取到内存。当文件非常大时，尤其在 RAM 存储量不足的情况下，把整个文件都读入内存是没有意义的。更好的方法是分块读取文件。这可以使用 bufio 包来完成。

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "io"
)

func EmptyArray(arr []byte) {
    for i := 0; i < len(arr); i++ {
        arr[i] = 0
    }
}

func main() {
    fileName := "F:\Go\project\src\go_dev\day7\test.txt"

    f, err := os.Open(fileName)
    if err != nil {
        log.Fatal(err)
    }

    defer func() {
        if err = f.Close(); err != nil {
            log.Fatal(err)
        }
    }()

    var str string
    r := bufio.NewReader(f)
    b := make([]byte, 3)  //每次读取3个字节

    for {
        EmptyArray(b)

        _, err := r.Read(b)
        if err == io.EOF {
            fmt.Println("Read finish")
            break
        }

        if err != nil {
            fmt.Println("Error reading file: ", err)
            break
        }
        str = string(b)
        fmt.Printf("%s", str)
    }
}

    3）逐行读取文件

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
)

func main() {
    fileName := "F:\Go\project\src\go_dev\day7\test.txt"

    f, err := os.Open(fileName)
    if err != nil {
        log.Fatal(err)
    }

    defer func() {
        if err = f.Close(); err != nil {
        log.Fatal(err)
    }
    }()

    s := bufio.NewScanner(f)
    for s.Scan() {
        fmt.Println(s.Text())
    }
    
    if err = s.Err(); err != nil {
        log.Fatal(err)
    }
}

练习：读取压缩文件（zip）

package main

// 引入所需包
import (
    "os"
    "compress/gzip"
    "io/ioutil"
    "fmt"
)

// gzip文件


func main() {
    fileName := "F:\Go\project\src\go_dev\day7\test.zip"
    // 打开本地gz格式压缩包
    fr, err := os.Open(fileName)
    if err != nil {
        panic(err)
    } else {
        println("open file success!")
    }

    // defer: 在函数退出时,执行关闭文件
    defer fr.Close()

    // 创建gzip文件读取对象
    gr, err := gzip.NewReader(fr)
    if err != nil {
            panic(err)
        }

    // defer: 在函数退出时,执行关闭gzip对象
    defer gr.Close()

    // 读取gzip对象内容
    rBuf, err := ioutil.ReadAll(gr)
    if err != nil {
        fmt.Println("[read gzip data err]: ", err)
    }

    // 以文本形式输出
    fmt.Printf("%s
", rBuf)
}

   （2）文件写入

           os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)

第二个参数：文件打开模式：
1. os.O_WRONLY：只写
2. os.O_CREATE：创建文件
3. os.O_RDONLY：只读
4. os.O_RDWR：读写
5. os.O_TRUNC ：清空
第三个参数：权限控制：
r ——> 004
w ——> 002
x ——> 001

package main 

import (
    "fmt"
    "os"
    "bufio"
)

func main() {
    filePath := "F:\Go\project\src\go_dev\day7\write_test.txt"
    outFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Println("Failed to write file")
        return
    }
    defer outFile.Close()

    outWrite := bufio.NewWriter(outFile)
    des := "hello world!
"
    for i := 0; i < 10; i++ {
        outWrite.WriteString(des)
    }
    outWrite.Flush()
}

    （3）拷贝文件

package main 

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

//A successful Copy returns err == nil, not err == EOF
func CopyFile(destName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        panic(err)
    }
    defer src.Close()

    dest, err := os.OpenFile(destName, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        panic(err)
    }
    defer dest.Close()

    return io.Copy(dest, src)
}

func main() {
    srcName := "F:\Go\project\src\go_dev\day7\write_test.txt"
    destName := "F:\Go\project\src\go_dev\day7\dest_test.txt"

    wByte, err := CopyFile(destName, srcName)
    if err != nil {
        fmt.Println("Copy failed")
    } else {
        fmt.Printf("Copy %d byte from src to dest
", wByte)
    }
}

3. 命令行参数

    os.Args是一个string的切片，用来存储所有的命令行参数
    flag包的使用，用来解析命令行参数：

flag.BoolVar(&test, "b", false, "print on newline")
flag.StringVar(&str, "s", "", "print on newline")
flag.IntVar(&count, "c", 1001, "print on newline")

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Printf("len of args:%d
", len(os.Args))
    for i, v := range os.Args {
        fmt.Printf("args[%d]=%s
", i, v)
    }
}

//输入：
//go run main7.go hello world
// 输出：
// len of args:3
// args[0]=C:UsersADMINI~1AppDataLocalTempgo-build596136718command-line-argu
// ments\_objexemain7.exe
// args[1]=hello
// args[2]=world

package main

import (
    "fmt"
    "flag"
)

func main() {
    var configPath string
    var logLevel int

    flag.StringVar(&configPath, "c", "", "Please config path")
    flag.IntVar(&logLevel, "d", 10, "Please log level")

    flag.Parse()

    fmt.Println("configPath: ", configPath)
    fmt.Println("logLevel: ", logLevel)
}

4. Json数据协议

func Marshal(v interface{}) ([]byte, error)
func Unmarshal(data []byte, v interface{}) error

导入包：import "encoding/json"
序列化: json.Marshal(data interface{})
反序列化: json.UnMarshal(data []byte, v interface{})

练习：json序列化结构体

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    UserName string `json:"username"`
    NickName string `json:"nickname"`
    Age      int
    Birthday string
    Sex      string
    Email    string
    Phone    string
}

func testStruct() {
    user1 := &User{
        UserName: "user1",
        NickName: "上课看似",
        Age:      18,
        Birthday: "2008/8/8",
        Sex:      "男",
        Email:    "mahuateng@qq.com",
        Phone:    "110",
    }

    data, err := json.Marshal(user1)
    if err != nil {
        fmt.Printf("json.marshal failed, err:", err)
        return
    }

    fmt.Printf("%s
", string(data))
}

func testInt() {
    var age = 100
    data, err := json.Marshal(age)
    if err != nil {
        fmt.Printf("json.marshal failed, err:", err)
        return
    }

    fmt.Printf("%s
", string(data))
}

func testMap() {
    var m map[string]interface{}
    m = make(map[string]interface{})
    m["username"] = "user1"
    m["age"] = 18
    m["sex"] = "man"

    data, err := json.Marshal(m)
    if err != nil {
        fmt.Printf("json.marshal failed, err:", err)
        return
    }

    fmt.Printf("%s
", string(data))
}

func testSlice() {
    var m map[string]interface{}
    var s []map[string]interface{}
    m = make(map[string]interface{})
    m["username"] = "user1"
    m["age"] = 18
    m["sex"] = "man"

    s = append(s, m)

    m = make(map[string]interface{})
    m["username"] = "user2"
    m["age"] = 29
    m["sex"] = "female"
    s = append(s, m)

    data, err := json.Marshal(s)
    if err != nil {
        fmt.Printf("json.marshal failed, err:", err)
        return
    }

    //[{"age":18,"sex":"man","username":"user1"},{"age":29,"sex":"female","username":"user2"}]
    fmt.Printf("%s
", string(data))
}

func main() {
    //testStruct()
    //testInt()
    //testMap()
    testSlice()
}

练习：json序列化map

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    UserName string `json:"username"`
    NickName string `json:"nickname"`
    Age      int
    Birthday string
    Sex      string
    Email    string
    Phone    string
}

func testStruct() (ret string, err error) {
    user1 := &User{
        UserName: "user1",
        NickName: "上课看似",
        Age:      18,
        Birthday: "2008/8/8",
        Sex:      "男",
        Email:    "mahuateng@qq.com",
        Phone:    "110",
    }

    data, err := json.Marshal(user1)
    if err != nil {
        err = fmt.Errorf("json.marshal failed, err:", err)
        return
    }

    ret = string(data)
    return
}

func testMap() (ret string, err error) {
    var m map[string]interface{}
    m = make(map[string]interface{})
    m["username"] = "user1"
    m["age"] = 18
    m["sex"] = "man"

    data, err := json.Marshal(m)
    if err != nil {
        err = fmt.Errorf("json.marshal failed, err:", err)
        return
    }

    ret = string(data)
    return
}

func test2() {
    data, err := testMap()
    if err != nil {
        fmt.Println("test map failed, ", err)
        return
    }

    var m map[string]interface{}
    err = json.Unmarshal([]byte(data), &m)
    if err != nil {
        fmt.Println("Unmarshal failed, ", err)
        return
    }
    fmt.Println(m)
}

func test() {
    data, err := testStruct()
    if err != nil {
        fmt.Println("test struct failed, ", err)
        return
    }

    var user1 User
    err = json.Unmarshal([]byte(data), &user1)
    if err != nil {
        fmt.Println("Unmarshal failed, ", err)
        return
    }
    fmt.Println(user1)
}

func main() {
    test()
    test2()
}

5. 自定义错误

type error interface { 
     Error() string 
} 

package main

import (
    "errors"
    "fmt"
)

var errNotFound error = errors.New("Not found error")

func main() {
    fmt.Printf("error: %v", errNotFound)
}

package main
import (
    "fmt"
)
type PathError struct {
    Op   string
    Path string
    Err string
}

func (e *PathError) Error() string {
    return e.Op + " " + e.Path + ": " + e.Err
}

func test() error {
    return &PathError{
        Op:   "op",
        Path: "path",
        Err:  "err",
    }
}
func main() {
    if err := test(); err != nil {
        fmt.Println(err)  //op path: err
    }
}

如何判断自定义错误?

switch err := err.(type) {
    case ParseError:
        PrintParseError(err)
    case PathError:
        PrintPathError(err)
    default: 
        ...
} 

package main

import (
    "fmt"
    "os"
    "time"
)

type PathError struct {
    path       string
    op         string
    createTime string
    message    string
}

func (p *PathError) Error() string {
    return fmt.Sprintf("path=%s op=%s createTime=%s message=%s", p.path,
        p.op, p.createTime, p.message)
}

func Open(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return &PathError{
            path:       filename,
            op:         "read",
            message:    err.Error(), //注意这块的Error是系统的error定义的接口Error()
            createTime: fmt.Sprintf("%v", time.Now()),
        }
    }

    defer file.Close()
    return nil
}

func main() {
    err := Open("C:/sdklflakfljdsafjs.txt")
    switch v := err.(type) {
    case *PathError:
        fmt.Println("get path error,", v) //v.Error() 类似于打印fmt.Println(err)，其实内部实现fmt.Println(err.Error())
    default:

    }

}

Panic&Recover

package main

import (
    "fmt"
)

func badCall() {
    panic("bad end")
}

func test() {
    defer func() {
        if e := recover(); e != nil { //在这块通过recover捕获panic错误并处理
            fmt.Printf("Panicking %s
", e)
        }
    }()

    badCall()
    fmt.Printf("After bad call
")
}

func main() {
    fmt.Printf("Calling test
")
    test()
    fmt.Printf("Test completed
")
}

图书管理系统v3：
    实现一个图书管理系统v3，具有以下功能：
     a. 增加持久化存储的功能
     b. 增加日志记录的功能

参考文献：

• https://studygolang.com/articles/14669