I/O 读写 - Txt、Xml、Json、Gob、Bytes 文件读写 - 《golang》

Txt

import (
    "bufio"
    "fmt"
    "os"
)
func write() {
    filePath := "./output.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Printf("打开文件错误= %v \n", err)
        return
    }
    defer file.Close()
    str := "http://c.biancheng.net/golang/\n" // \n\r表示换行  txt文件要看到换行效果要用 \r\n
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 3; i++ {
        writer.WriteString(str)
    }
    //因为 writer 是带缓存的，因此在调用 WriterString 方法时，内容是先写入缓存的
    //所以要调用 flush方法，将缓存的数据真正写入到文件中。
    writer.Flush()
}
func read() {
    file, err := os.Open("./output.txt")
    if err != nil {
        fmt.Println("文件打开失败 = ", err)
    }
    defer file.Close()
    //创建一个 *Reader ， 是带缓冲的
    reader := bufio.NewReader(file)
    for {
        str, err := reader.ReadString('\n') //读到一个换行就结束
        if err == io.EOF {                  //io.EOF 表示文件的末尾
            break
        }
        fmt.Print(str)
    }
    fmt.Println("文件读取结束...")
}

Xml

XML（extensible Markup Language）格式被广泛用作一种数据交换格式。在 JSON 还未像现在这么广泛使用时，XML 的使用相当广泛。现在很多开放平台接口，基本都会支持 XML 格式。
Go语言内置的 encoding/xml 包可以用在结构体和 XML 格式之间进行编解码，其方式跟 encoding/json 包类似。然而与 JSON 相比 XML 的编码和解码在功能上更苛刻得多，这是由于 encoding/xml 包要求结构体的字段包含格式合理的标签，而 JSON 格式却不需要。 ``go import ( "encoding/xml" "fmt" "os" ) type Website struct { Name stringxml:”name,attr,omitempty”` Url string Course []string } func write() { info := Website{“C语言中文网”, “http://c.biancheng.net/golang/“, []string{“Go语言入门教程”, “Golang入门教程”}} f, err := os.Create(“./info.xml”) if err != nil {
```
 fmt.Println("文件创建失败", err.Error())
 return
```
} defer f.Close() //序列化到文件中 encoder := xml.NewEncoder(f) err = encoder.Encode(info) if err != nil {
```
 fmt.Println("编码错误：", err.Error())
 return
```
} else {
```
 fmt.Println("编码成功")
```
} }

func read() { file, err := os.Open(“./info.xml”) if err != nil { fmt.Printf(“文件打开失败：%v”, err) return } defer file.Close() info := Website{} //创建 xml 解码器 decoder := xml.NewDecoder(file) err = decoder.Decode(&info) if err != nil { fmt.Printf(“解码失败：%v”, err) return } else { fmt.Println(“解码成功”) fmt.Println(info) } }


1. xml 包还支持更为复杂的标签，包括嵌套：
   1. 具有 "chardata" 标签表示将该字段当做字符数据来写。
   1. 具有 "innerxml" 标签表示按照会原样写入，而不会经过正常的序列化过程。
   1. 具有 "comment" 标签表示将该字段当做 XML 注释。该字段内不能有"--"字符串。
   1. 具有 "omitempty" 标签的字段如果为空值会省略（空值为false、0、nil指针、nil接口、长度为0的数组、切片、映射）。
   1. 具有 "attr" 标签的字段会成为该XML元素的属性：
      1. 例1："name,attr"的字段会成为该XML元素的名为name的属性。
      1. 例2: ",attr"的字段会成为该XML元素的名为字段名的属性。
   6. 如果一个字段的标签为"a>b>c"，则元素c将会嵌套进其上层元素a和b中。如果该字段相邻的字段标签指定了同样的上层元素，则会放在同一个XML元素里。
      1. 例1：'xml:"Books>Author"' 产生的是 <Books><Author>content</Author></Books> 
   7. 匿名字段（其标签无效）会被处理为其字段是外层结构体的字段。
---
<a name="tMDtm"></a>
#### Json
1. JSON（[JavaScript](http://c.biancheng.net/js/) Object Notation）使用 UTF-8 编码的纯文本格式。是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。特别是在通过网络连接传送数据方面非常流行。
1. Go语言内建对 JSON 的支持，使用内置的 encoding/json 标准库。
```go
import (
    "encoding/json"
    "fmt"
    "os"
)
type Website struct {
    Name   string `json:"name"`
    Url    string
    Course []string
}
func write() {
    info := []Website{{"Golang", "http://c.biancheng.net/golang/", []string{"http://c.biancheng.net/cplus/", "http://c.biancheng.net/linux_tutorial/"}}, {"Java", "http://c.biancheng.net/java/", []string{"http://c.biancheng.net/socket/", "http://c.biancheng.net/python/"}}}
    filePtr, err := os.Create("info.json")
    if err != nil {
        fmt.Println("文件创建失败", err.Error())
        return
    }
    defer filePtr.Close()
    encoder := json.NewEncoder(filePtr)
    err = encoder.Encode(info)
    if err != nil {
        fmt.Println("编码错误", err.Error())
    } else {
        fmt.Println("编码成功")
    }
}
func read() {
    filePtr, err := os.Open("./info.json")
    if err != nil {
        fmt.Println("文件打开失败 [Err:%s]", err.Error())
        return
    }
    defer filePtr.Close()
    var info []Website
    decoder := json.NewDecoder(filePtr)
    err = decoder.Decode(&info)
    if err != nil {
        fmt.Println("解码失败", err.Error())
    } else {
        fmt.Println("解码成功")
        fmt.Println(info)
    }
}

// mesBase
type MesSign struct {
    Mold uint        `json:"m"`
    Type uint        `json:"t"`
    Data interface{} `json:"d,omitempty"`
}
jsonMessage, err := json.Marshal(&often.MesSign{Mold: mold, Type: t, Data: &data})
err = json.Unmarshal(data, &mes)

Gob

Gob（即 Go binary 的缩写）特定的用于纯 Go 的环境中，是Go语言自己以二进制形式序列化和反序列化程序数据的格式。类似于 Python 的“pickle”和 Java 的“Serialization”。
可以在 encoding 包中找到。通常用于远程方法调用参数和结果的传输，以及应用程序和机器之间的数据传输。例如两个用Go语言写的服务之间的通信。这样的话服务可以被实现得更加高效和优化。 ```go import ( “encoding/gob” “fmt” “os” ) func encode() { info := map[string]string{
```
 "name":    "C语言中文网",
 "website": "http://c.biancheng.net/golang/",
```
} name := “demo.gob” File, _ := os.OpenFile(name, os.O_RDWR|os.O_CREATE, 0777) defer File.Close()

enc := gob.NewEncoder(File) if err := enc.Encode(info); err != nil {
```
 fmt.Println(err)
```
} }

func decode() { var M map[string]string File, _ := os.Open(“demo.gob”) D := gob.NewDecoder(File) D.Decode(&M) fmt.Println(M) }

<a name="WNGUR"></a>
#### Bytes
Go语言的 encoding/binary 包中的 binary.Write() 函数使得以二进制格式写数据非常简单
```go
Write 函数可以将参数 data 的 binary 编码格式写入参数 w 中。
参数 order 指定写入数据的字节序，写入结构体时，名字中有_的字段会置为 0。
参数 data 必须是定长值、定长值的切片、定长值的指针。
func Write(w io.Writer, order ByteOrder, data interface{}) error

import (
    "bytes"
    "encoding/binary"
    "fmt"
    "os"
)
type Website struct {
    Url int32
}
func write() {
    file, err := os.Create("output.bin")
    for i := 1; i <= 10; i++ {
        info := Website{
            int32(i),
        }
        if err != nil {
            fmt.Println("文件创建失败 ", err.Error())
            return
        }
        defer file.Close()
        var bin_buf bytes.Buffer
        binary.Write(&bin_buf, binary.LittleEndian, info)
        b := bin_buf.Bytes()
        _, err = file.Write(b)
        if err != nil {
            fmt.Println("编码失败", err.Error())
            return
        }
    }
    fmt.Println("编码成功")
}
func read() {
    file, err := os.Open("output.bin")
    defer file.Close()
    if err != nil {
        fmt.Println("文件打开失败", err.Error())
        return
    }
    m := Website{}
    for i := 1; i <= 10; i++ {
        data := readNextBytes(file, 4)
        buffer := bytes.NewBuffer(data)
        err = binary.Read(buffer, binary.LittleEndian, &m)
        if err != nil {
            fmt.Println("二进制文件读取失败", err)
            return
        }
        fmt.Println("第", i, "个值为：", m)
    }
}
func readNextBytes(file *os.File, number int) []byte {
    bytes := make([]byte, number)
    _, err := file.Read(bytes)
    if err != nil {
        fmt.Println("解码失败", err)
    }
    return bytes
}

Go语言对二进制文件的支持还包括随机访问。这种情况下，我们必须使用 os.OpenFile() 函数来打开文件（而非 os.Open()），并给它传入合理的权限标志和模式（例如 os.O_RDWR 表示可读写）参数。然后，就可以使用 os.File.Seek() 方法来在文件中定位并读写，或者使用 os.File.ReadAt() 和 os.File.WriteAt() 方法来从特定的字节偏移中读取或者写入数据。
Go语言还提供了其他常用的方法，包括 os.File.Stat() 方法，它返回的 os.FileInfo 包含了文件大小、权限以及日期时间等细节信息。