go-文件操做

時間 2019-11-20

標籤文件简体版

原文原文鏈接

章文件操做

文件的基本介紹

文件的概念

文件,對咱們並不陌生,文件是數據源(保存數據的地方)的一種,好比你們常常使用的 word 文檔,txt 文
件,excel 文件...都是文件。文件最主要的做用就是保存數據,它既能夠保存一張圖片,也能夠保持視頻,聲
音...
輸入流和輸出流
os.File 封裝全部文件相關操做，File 是一個結構體編程

打開文件和關閉文件

使用的函數和方法json

package main
import (
    "fmt"
    "os" 
)
func main() {
    //打開文件
    //概念說明: file 的叫法
    //1. file 叫 file對象
    //2. file 叫 file指針
    //3. file 叫 file 文件句柄
    file , err := os.Open("d:/test.txt")
    if err != nil {
        fmt.Println("open file err=", err)
    }
    //輸出下文件，看看文件是什麼, 看出file 就是一個指針 *File
    fmt.Printf("file=%v", file)//若是文件不存在file=<nil>
    //關閉文件
    err = file.Close()
    if err != nil {
        fmt.Println("close file err=", err)
    }
}

讀文件操做應用實例

1) 讀取文件的內容並顯示在終端(帶緩衝區的方式)，使用 os.Open, file.Close, bufio.NewReader(),
reader.ReadString 函數和方法.緩存

package main
import (
    "fmt"
    "os"
    "bufio"
    "io" 
)
func main() {
    //打開文件
    //概念說明: file 的叫法
    //1. file 叫 file對象
    //2. file 叫 file指針
    //3. file 叫 file 文件句柄
    file , err := os.Open("d:/test.txt")
    if err != nil {
        fmt.Println("open file err=", err)
    }

    //當函數退出時，要及時的關閉file
    defer file.Close() //要及時關閉file句柄，不然會有內存泄漏.

    // 建立一個 *Reader  ，是帶緩衝的
    /*
    const (
    defaultBufSize = 4096 //默認的緩衝區爲4096
    )
    */
    reader := bufio.NewReader(file)
    //循環的讀取文件的內容
    for {
        str, err := reader.ReadString('\n') // 讀到一個換行就結束
        if err == io.EOF { // io.EOF表示文件的末尾
            break
        }
        //輸出內容
        fmt.Printf(str)
    }

    fmt.Println("文件讀取結束...")
}

2) 讀取文件的內容並顯示在終端(使用 ioutil 一次將整個文件讀入到內存中)，這種方式適用於文件
不大的狀況。相關方法和函數(ioutil.ReadFile)網絡

package main
import (
    "fmt"
    "io/ioutil" 
)
func main() {

    //使用ioutil.ReadFile一次性將文件讀取到位
    file := "d:/test.txt"
    content, err := ioutil.ReadFile(file)
    if err != nil {
        fmt.Printf("read file err=%v", err)
    }
    //把讀取到的內容顯示到終端
    //fmt.Printf("%v", content) // []byte
    fmt.Printf("%v", string(content)) // []byte
    
    //咱們沒有顯式的Open文件，所以也不須要顯式的Close文件
    //由於，文件的Open和Close被封裝到 ReadFile 函數內部
}

寫文件操做應用實例

基本介紹-os.OpenFile 函數

　基本應用實例-方式一

1) 建立一個新文件，寫入內容 5 句 "hello, Gardon"app

package main
import (
    "fmt"
    "bufio"
    "os" 
)
func main() {
    //建立一個新文件，寫入內容 5句 "hello, Gardon"
    //1 .打開文件 d:/abc.txt
    filePath := "d:/abcd.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_CREATE, 0666)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return 
    }
    //及時關閉file句柄
    defer file.Close()
    //準備寫入5句 "hello, Gardon"
    str := "hello,Gardon\r\n" // \r\n 表示換行
    //寫入時，使用帶緩存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 5; i++ {
        writer.WriteString(str)
    }
    //由於writer是帶緩存，所以在調用WriterString方法時，其實
    //內容是先寫入到緩存的,因此須要調用Flush方法，將緩衝的數據
    //真正寫入到文件中， 不然文件中會沒有數據!!!
    writer.Flush()
}

1) 打開一個存在的文件中，將原來的內容覆蓋成新的內容 10 句 "你好，ygj!"函數

package main
import (
    "fmt"
    "bufio"
    "os" 
)

func main() {
    //打開一個存在的文件中，將原來的內容覆蓋成新的內容10句 "你好，ygj!"

    //建立一個新文件，寫入內容 5句 "hello, Gardon"
    //1 .打開文件已經存在文件, d:/abc.txt
    filePath := "d:/abc.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_TRUNC, 0666)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return 
    }
    //及時關閉file句柄
    defer file.Close()
    //準備寫入5句 "你好,ygj!"
    str := "你好,ygj!\r\n" // \r\n 表示換行
    //寫入時，使用帶緩存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
        writer.WriteString(str)
    }
    //由於writer是帶緩存，所以在調用WriterString方法時，其實
    //內容是先寫入到緩存的,因此須要調用Flush方法，將緩衝的數據
    //真正寫入到文件中， 不然文件中會沒有數據!!!
    writer.Flush()

}

2) 打開一個存在的文件，在原來的內容容追加內容 'ABC! ENGLISH!'網站

package main
import (
    "fmt"
    "bufio"
    "os" 
)

func main() {
    

    //打開一個存在的文件，在原來的內容追加內容 'ABC! ENGLISH!'
    //1 .打開文件已經存在文件, d:/abc.txt
    filePath := "d:/abc.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_APPEND, 0666)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return 
    }
    //及時關閉file句柄
    defer file.Close()
    //準備寫入5句 "你好,ygj!"
    str := "ABC,ENGLISH!\r\n" // \r\n 表示換行
    //寫入時，使用帶緩存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
        writer.WriteString(str)
    }
    //由於writer是帶緩存，所以在調用WriterString方法時，其實
    //內容是先寫入到緩存的,因此須要調用Flush方法，將緩衝的數據
    //真正寫入到文件中， 不然文件中會沒有數據!!!
    writer.Flush()

}

3) 打開一個存在的文件，將原來的內容讀出顯示在終端，而且追加 5 句"hello,北京!"命令行

package main
import (
    "fmt"
    "bufio"
    "os"
    "io" 
)

func main() {
    
    //打開一個存在的文件，將原來的內容讀出顯示在終端，而且追加5句"hello,北京!"
    //1 .打開文件已經存在文件, d:/abc.txt
    filePath := "d:/abc.txt"
    file, err := os.OpenFile(filePath, os.O_RDWR | os.O_APPEND, 0666)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return 
    }
    //及時關閉file句柄
    defer file.Close()

    //先讀取原來文件的內容，並顯示在終端.
    reader := bufio.NewReader(file)
    for {
        str, err := reader.ReadString('\n')
        if err == io.EOF { //若是讀取到文件的末尾
            break
        }
        //顯示到終端
        fmt.Print(str)
    }


    //準備寫入5句 "你好,ygj!"
    str := "hello,北京!\r\n" // \r\n 表示換行
    //寫入時，使用帶緩存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 5; i++ {
        writer.WriteString(str)
    }
    //由於writer是帶緩存，所以在調用WriterString方法時，其實
    //內容是先寫入到緩存的,因此須要調用Flush方法，將緩衝的數據
    //真正寫入到文件中， 不然文件中會沒有數據!!!
    writer.Flush()

}

基本應用實例-方式二

編程一個程序，將一個文件的內容，寫入到另一個文件。注：這兩個文件已經存在了.
說明：使用 ioutil.ReadFile / ioutil.WriteFile 完成寫文件的任務.設計

package main
import (
    "fmt"
    "io/ioutil" 
)
func main() {
    //將d:/abc.txt 文件內容導入到  d:/abcd.txt
    //1. 首先將  d:/abc.txt 內容讀取到內存
    //2. 將讀取到的內容寫入 d:/abcd.txt
    file1Path := "d:/abc.txt" 
    file2Path := "d:/abcd.txt" 
    data, err := ioutil.ReadFile(file1Path)
    if err != nil {
        //說明讀取文件有錯誤
        fmt.Printf("read file err=%v\n", err)
        return
    }
    err = ioutil.WriteFile(file2Path, data, 0666)
    if err != nil {
        fmt.Printf("write file error=%v\n", err)
    }
}

文件編程應用實例

　拷貝文件

說明：將一張圖片/電影/mp3 拷貝到另一個文件 e:/abc.jpg io 包
func Copy(dst Writer, src Reader) (written int64, err error)
注意; Copy 函數是 io 包提供的.指針

package main
import (
    "fmt"
    "os"
    "io"
    "bufio" 
)

//本身編寫一個函數，接收兩個文件路徑 srcFileName dstFileName
func CopyFile(dstFileName string, srcFileName string) (written int64, err error) {

    srcFile, err := os.Open(srcFileName)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
    }
    defer srcFile.Close()
    //經過srcfile ,獲取到 Reader
    reader := bufio.NewReader(srcFile)

    //打開dstFileName
    dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return 
    }

    //經過dstFile, 獲取到 Writer
    writer := bufio.NewWriter(dstFile)
    defer dstFile.Close()

    return io.Copy(writer, reader)


}

func main() {

    //將d:/flower.jpg 文件拷貝到 e:/abc.jpg

    //調用CopyFile 完成文件拷貝
    srcFile := "d:/flower.jpg"
    dstFile := "e:/abc.jpg"
    _, err := CopyFile(dstFile, srcFile)
    if err == nil {
        fmt.Printf("拷貝完成\n")
    } else {
        fmt.Printf("拷貝錯誤 err=%v\n", err)
    }
    
}

統計英文、數字、空格和其餘字符數量

說明：統計一個文件中含有的英文、數字、空格及其它字符數量

package main
import (
    "fmt"
    "os"
    "io"
    "bufio" 
)

//定義一個結構體，用於保存統計結果
type CharCount struct {
    ChCount int // 記錄英文個數
    NumCount int // 記錄數字的個數
    SpaceCount int // 記錄空格的個數
    OtherCount int // 記錄其它字符的個數
}

func main() {

    //思路: 打開一個文件, 創一個Reader
    //每讀取一行，就去統計該行有多少個 英文、數字、空格和其餘字符
    //而後將結果保存到一個結構體
    fileName := "e:/abc.txt"
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return
    }
    defer file.Close()
    //定義個CharCount 實例
    var count CharCount
    //建立一個Reader
    reader := bufio.NewReader(file)

    //開始循環的讀取fileName的內容
    for {
        str, err := reader.ReadString('\n')
        if err == io.EOF { //讀到文件末尾就退出
            break
        }
        //遍歷 str ，進行統計
        for _, v := range str {
            
            switch {
                case v >= 'a' && v <= 'z':
                        fallthrough //穿透
                case v >= 'A' && v <= 'Z':
                        count.ChCount++
                case v == ' ' || v == '\t':
                        count.SpaceCount++
                case v >= '0' && v <= '9':
                        count.NumCount++
                default :
                        count.OtherCount++
            }
        }
    }

    //輸出統計的結果看看是否正確
    fmt.Printf("字符的個數爲=%v 數字的個數爲=%v 空格的個數爲=%v 其它字符個數=%v", 
        count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)


}

命令行參數

　看一個需求

咱們但願可以獲取到命令行輸入的各類參數，該如何處理? 如圖：=> 命令行參數
基本介紹
os.Args 是一個 string 的切片，用來存儲全部的命令行參數
參數加在go run main.go的後面便可；

package main
import (
    "fmt"
    "os"
)

func main() {

    fmt.Println("命令行的參數有", len(os.Args))
    //遍歷os.Args切片，就能夠獲得全部的命令行輸入參數值
    for i, v := range os.Args {
        fmt.Printf("args[%v]=%v\n", i, v)
    }
}

flag 包用來解析命令行參數

說明: 前面的方式是比較原生的方式，對解析參數不是特別的方便，特別是帶有指定參數形式的命
令行。
好比：cmd>main.exe -f c:/aaa.txt -p 200 -u root 這樣的形式命令行，go 設計者給咱們提供了 flag
包，能夠方便的解析命令行參數，並且參數順序能夠隨意
請編寫一段代碼，能夠獲取命令行各個參數.

package main
import (
    "fmt"
    "flag"
)

func main() {

    //定義幾個變量，用於接收命令行的參數值
    var user string
    var pwd string
    var host string
    var port int

    //&user 就是接收用戶命令行中輸入的 -u 後面的參數值
    //"u" ,就是 -u 指定參數
    //"" , 默認值
    //"用戶名,默認爲空" 說明
    flag.StringVar(&user, "u", "", "用戶名,默認爲空")
    flag.StringVar(&pwd, "pwd", "", "密碼,默認爲空")
    flag.StringVar(&host, "h", "localhost", "主機名,默認爲localhost")
    flag.IntVar(&port, "port", 3306, "端口號，默認爲3306")
    //這裏有一個很是重要的操做,轉換， 必須調用該方法
    flag.Parse()

    //輸出結果
    fmt.Printf("user=%v pwd=%v host=%v port=%v", 
        user, pwd, host, port)

}

json 基本介紹

json 數據格式說明

json 數據在線解析[https://www.json.cn/] 網站能夠驗證一個 json 格式的數據是否正確。尤爲是在咱們編寫比較複雜的
json 格式數據時，頗有用

json 的序列化

介紹
json 序列化是指，將有 key-value 結構的數據類型(好比結構體、map 、切片)序列化成 json 字符串的操做。
應用案例
這裏咱們介紹一下結構體、map 和切片的序列化，其它數據類型的序列化相似。

package main
import (
    "fmt"
    "encoding/json"
)

//定義一個結構體
type Monster struct {
    Name string `json:"monster_name"` //反射機制
    Age int `json:"monster_age"`
    Birthday string //....
    Sal float64
    Skill string
}



func testStruct() {
    //演示
    monster := Monster{
        Name :"牛魔王",
        Age : 500 ,
        Birthday : "2011-11-11",
        Sal : 8000.0,
        Skill : "牛魔拳",
    }

    //將monster 序列化
    data, err := json.Marshal(&monster) //..
    if err != nil {
        fmt.Printf("序列號錯誤 err=%v\n", err)
    }
    //輸出序列化後的結果
    fmt.Printf("monster序列化後=%v\n", string(data))

}

//將map進行序列化
func testMap() {
    //定義一個map
    var a map[string]interface{}
    //使用map,須要make
    a = make(map[string]interface{})
    a["name"] = "紅孩兒"
    a["age"] = 30
    a["address"] = "洪崖洞"

    //將a這個map進行序列化
    //將monster 序列化
    data, err := json.Marshal(a)
    if err != nil {
        fmt.Printf("序列化錯誤 err=%v\n", err)
    }
    //輸出序列化後的結果
    fmt.Printf("a map 序列化後=%v\n", string(data))

}

//演示對切片進行序列化, 咱們這個切片 []map[string]interface{}
func testSlice() {
    var slice []map[string]interface{}
    var m1 map[string]interface{}
    //使用map前，須要先make
    m1 = make(map[string]interface{})
    m1["name"] = "jack"
    m1["age"] = "7"
    m1["address"] = "北京"
    slice = append(slice, m1)

    var m2 map[string]interface{}
    //使用map前，須要先make
    m2 = make(map[string]interface{})
    m2["name"] = "tom"
    m2["age"] = "20"
    m2["address"] = [2]string{"墨西哥","夏威夷"}
    slice = append(slice, m2)

    //將切片進行序列化操做
    data, err := json.Marshal(slice)
    if err != nil {
        fmt.Printf("序列化錯誤 err=%v\n", err)
    }
    //輸出序列化後的結果
    fmt.Printf("slice 序列化後=%v\n", string(data))
    
}

//對基本數據類型序列化，對基本數據類型進行序列化意義不大
func testFloat64() {
    var num1 float64 = 2345.67

    //對num1進行序列化
    data, err := json.Marshal(num1)
    if err != nil {
        fmt.Printf("序列化錯誤 err=%v\n", err)
    }
    //輸出序列化後的結果
    fmt.Printf("num1 序列化後=%v\n", string(data))
}

func main() {
    //演示將結構體, map , 切片進行序列號
    testStruct()
    testMap()
    testSlice()//演示對切片的序列化
    testFloat64()//演示對基本數據類型的序列化
}

注意事項
對於結構體的序列化，若是咱們但願序列化後的key的名字，又咱們本身從新制定，那麼能夠給struct
指定一個 tag 標籤.

　json 的反序列化

基本介紹
json 反序列化是指，將 json 字符串反序列化成對應的數據類型(好比結構體、map、切片)的操做
應用案例
這裏咱們介紹一下將 json 字符串反序列化成結構體、map 和切片

package main
import (
    "fmt"
    "encoding/json"
)

//定義一個結構體
type Monster struct {
    Name string  
    Age int 
    Birthday string //....
    Sal float64
    Skill string
}


//演示將json字符串，反序列化成struct
func unmarshalStruct() {
    //說明str 在項目開發中，是經過網絡傳輸獲取到.. 或者是讀取文件獲取到
    str := "{\"Name\":\"牛魔王~~~\",\"Age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}"

    //定義一個Monster實例
    var monster Monster

    err := json.Unmarshal([]byte(str), &monster)
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }
    fmt.Printf("反序列化後 monster=%v monster.Name=%v \n", monster, monster.Name)

}
//將map進行序列化
func testMap() string {
    //定義一個map
    var a map[string]interface{}
    //使用map,須要make
    a = make(map[string]interface{})
    a["name"] = "紅孩兒~~~~~~"
    a["age"] = 30
    a["address"] = "洪崖洞"

    //將a這個map進行序列化
    //將monster 序列化
    data, err := json.Marshal(a)
    if err != nil {
        fmt.Printf("序列化錯誤 err=%v\n", err)
    }
    //輸出序列化後的結果
    //fmt.Printf("a map 序列化後=%v\n", string(data))
    return string(data)

}

//演示將json字符串，反序列化成map
func unmarshalMap() {
    //str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"紅孩兒\"}"
    str := testMap()
    //定義一個map
    var a map[string]interface{} 

    //反序列化
    //注意：反序列化map,不須要make,由於make操做被封裝到 Unmarshal函數
    err := json.Unmarshal([]byte(str), &a)
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }
    fmt.Printf("反序列化後 a=%v\n", a)

}

//演示將json字符串，反序列化成切片
func unmarshalSlice() {
    str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"jack\"}," + 
        "{\"address\":[\"墨西哥\",\"夏威夷\"],\"age\":\"20\",\"name\":\"tom\"}]"
    
    //定義一個slice
    var slice []map[string]interface{}
    //反序列化，不須要make,由於make操做被封裝到 Unmarshal函數
    err := json.Unmarshal([]byte(str), &slice)
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }
    fmt.Printf("反序列化後 slice=%v\n", slice)
}

func main() {

    unmarshalStruct()
    unmarshalMap()
    unmarshalSlice()
}

對上面代碼的小結說明 1) 在反序列化一個json字符串時，要確保反序列化後的數據類型和原來序列化前的數據類型一致。 2) 若是 json 字符串是經過程序獲取到的，則不須要再對「轉義處理。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。