文件是存儲在外部介質上的數據集合

文件分類：文本文件和二進制文件

文本文件可讀性好，占用的數據空間大

二進制文件，可讀性差，占用的數據空間小

文件存取方式：隨機存取和順序存放

隨機存?。翰僮魉俣嚷?，對磁盤的消耗大

順序存放：操作數據塊，對磁盤的消耗小

golang中的文件操作

只讀的方法打開

初級方法

import (
    "fmt"
    "os"
)

func test1() {
    //只讀方法
    inputFile, err := os.Open("./main.go")
    if err != nil {
        fmt.Printf("open file faild,err:%s\n", err)
    }
    defer inputFile.Close()
}

高級方法

func test2() {
    //只讀方法
    inputFile, err := os.Open("./main.go")
    if err != nil {
        fmt.Printf("open file faild,err:%s\n", err)
        return
    }
    var content []byte
    var buf [128]byte
    for {
        n, err := inputFile.Read(buf[:])
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Printf("open file faild,err:%s\n", err)
            return
        }
        content = append(content, buf[:n]...)
    }
    fmt.Println(string(content))

    defer inputFile.Close()
}

bufio原理

在程序和文件之間，添加一個緩沖區(qū)，每次程序讀取文件內容的時候，先去緩沖區(qū)查看，如果需要的內容，直接獲取，如果沒有再去文件中獲取

由于緩沖是在內存當中的，和程序的交互返回速度會非?？?，這樣可以大大提高程序的性能和速度

缺點：有的數據是只在緩沖中存儲的，如果在緩沖釋放之前，沒有將數據實例化落盤，會導致數據的丟失

實例

按行操作文件對象

func test3() {
    //只讀方法
    inputFile, err := os.Open("./main.go")
    if err != nil {
        fmt.Printf("open file faild,err:%s\n", err)
        return
    }
    defer inputFile.Close()
    reader := bufio.NewReader(inputFile)
    for {
        line, err := reader.ReadString('\n')
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Printf("open file faild,err:%s\n", err)
            return
        }
        fmt.Println(line)
    }

}

使用ioutil工具讀取文件

將之前的file方法封裝起來，可以更加方便的使用

func test4() {
    content, err := ioutil.ReadFile("./main.go")
    if err != nil {
        fmt.Printf("open file faild,err:%s\n", err)
        return
    }
    fmt.Println(string(content))

}

讀取壓縮文件

使用gzip.NewReader(文件句柄)，來操作壓縮文件

func test5() {
    file, err := os.Open("./tar.sh.gz")
    if err != nil {
        fmt.Printf("open file faild , Err:%s\n", err)
        return
    }
    defer file.Close()
    reader, err := gzip.NewReader(file)
    if err != nil {
        fmt.Printf("gzip new reader faild , Err:%s\n", err)
        return
    }
    var content []byte // 保存內容的切片
    var buf [128]byte  // 每次讀取128字節(jié)的切片
    for {
        n, err := reader.Read(buf[:])
        if err == io.EOF {
            if n != 0 {
                content = append(content, buf[:n]...)
            }
            break
        }
        if err != nil {
            fmt.Println("read file:", err)
            return
        }
        content = append(content, buf[:n]...)
    }
    fmt.Println(string(content))  // 將內容輸出

}

文件的寫入：os.OpenFile() 用法

示例： file,err := os.OpenFile("main.go", os.O_WRONLY|os.O_WRONLY, 0666)

三個參數，

• 第一個是文件路徑，當前目錄下，可以直接是文件名稱
• 第二個是文件的操作方法
  • os.O_WRONLY：只寫
  • os.O_CREATE：創(chuàng)建文件
  • os.O_RDONLY：只讀
  • os.O_RDWR：讀寫
  • os.O_TRUNC ：清空
  • os. O_APPEND：追加
• 第三個是文件的權限，r ——> 004 w——> 002 x——> 001

文件操作方法，需要注意不能沖突

文件寫入示例

func test6() {
    file, err := os.OpenFile("text.txt", os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Printf("An error occurred with file creation \n")
        return
    }
    str := "hello world,test"
    file.Write([]byte(str))
    defer file.Close()
}

操作完成后，當前目錄出現一個text.txt 文件，內容是：hello world,test

這里可以可以考慮使用buffio來實現

COPY和CAT命令實現

copy

package main

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

func main() {
    _, err := CopyFile("target.txt", "copy.go")
    if err != nil {
        fmt.Printf("copy  failed,err:%v\n", err)
        return
    }
    fmt.Println("Copy done!\n")
}
func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        fmt.Printf("open source file %s failed,err:%v\n", srcName, err)
        return
    }
    defer src.Close()
    dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
    if err != nil {
        fmt.Printf("open dest file %s failed,err:%v\n", srcName, err)
        return
    }
    defer dst.Close()
    return io.Copy(dst, src)
}

cat

package main

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

var (
    num int
)

func cat(r *bufio.Reader, number int) {
    if number == 0 {
        for {
            buf, err := r.ReadBytes('\n')
            if err == io.EOF {
                break
            }
            fmt.Fprintf(os.Stdout, "%s", buf)
        }
    } else {
        for i := 0; i <= number; i++ {
            buf, err := r.ReadBytes('\n')
            if err == io.EOF {
                break
            }
            fmt.Fprintf(os.Stdout, "%s", buf)
        }
        return
    }
}
func main() {
    flag.IntVar(&num, "n", 0, "輸入行數")
    flag.Parse()
    if flag.NArg() == 0 {
        cat(bufio.NewReader(os.Stdin), num)
    }
    for i := 0; i < flag.NArg(); i++ {
        f, err := os.Open(flag.Arg(i))
        if err != nil {
            fmt.Fprintf(os.Stderr, "%s:error reading from %s: %s\n",
                os.Args[0], flag.Arg(i), err.Error())
            continue
        }
        cat(bufio.NewReader(f), num)
    }
}