15 文件操作与终端读取

主要涉及的模块

1. os
2. bufio
3. ioutil

终端读取

终端读取我们可以使用os模块，分别是:

1. os.Stdin 标准输入
2. os.Stdout 标准输出
3. os.Stderr 标准错误输出

终端读例子：

fmt不带缓冲区 的读。

读取的话可以使用最简单的fmt模块。代码如下所示：

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: ")
    fmt.Scanln(&firstName, &lastName) // 从终端读取
    // fmt.Scanf("%s %s", &firstName, &lastName)
    fmt.Printf("Hi %s %s!\n", firstName, lastName) // Hi Chris Naegels
    fmt.Sscanf(input, format, &f, &i, &s)          //从终端读取，且能够被格式化成其他数据类型
    fmt.Println("From the string we read: ", f, i, s)
}

bufio带缓冲区的读

带缓冲区的读的话，可以减少IO的压力。

package main

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

var inputReader *bufio.Reader
var input string
var err error

func main() {
    inputReader = bufio.NewReader(os.Stdin)
    fmt.Println("Please enter some input: ")
    input, err = inputReader.ReadString('\n') // 也可以ReadLine
    if err == nil {
        fmt.Printf("The input was: %s\n", input)
    }
}

练手的例子：从终端读取一行字符串，统计英文、数字、空格以及其他字符的数量

如何统计英文数字以及空格呢?我们可以使用ascii码的大小来比较统计，我们for循环出来的都是一个一个的字符byte，所以可以很容易的找到这个ascii，比如判断字符 a<b,go会自动转为ascii码来对比，由于b比a的ascii码更大，所以是正确的。了解原因后，我们看看下面的代码，
代码如下：

package main

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

func main() {
    reader := bufio.NewReader(os.Stdin)

    var azNum int
    var intNum int
    var fuhaoNum int
    var otherNum int
    rawstring, _, _ := reader.ReadLine()

    result := []rune(string(rawstring))
    for _, key := range result {
        //fmt.Printf("%v %T\n", key, key)
        switch {
        case key >= 'a' && key <= 'z':
            fallthrough
        case key >= 'A' && key <= 'Z':
            azNum++
        case key >= '0' && key <= '9':
            intNum++
        case key == ' ' || key == '\t':
            fuhaoNum++
        default:
            otherNum++
        }
    }
    fmt.Println("azNum", azNum)
    fmt.Println("intNum", intNum)
    fmt.Println("fuhaoNum", fuhaoNum)
    fmt.Println("otherNum", otherNum)
}

文件的读写

os.File封装所有文件相关操作，之前讲的 os.Stdin,os.Stdout, os.Stderr都是*os.File

1. 打开一个文件进行读操作： os.Open(name string) (*File, error)
2. 关闭一个文件：File.Close()

文件的读

我们接下来看看文件操作的示例，文件打开的话我们使用os.Open方法来打开

package main

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

func main() {

    inputFile, err := os.Open("aaa.go")   // 打开一个文件
    if err != nil {
        fmt.Printf("open file err:%v\n", err)
        return
    }

    defer inputFile.Close()
    inputReader := bufio.NewReader(inputFile)
    for {
        inputString, readerError := inputReader.ReadString('\n')
        if readerError == io.EOF {
            return
        }
        fmt.Printf("The input was: %s", inputString)
    }
}

文件的写(ioutil.WriteFile)

文件写入我们可以使用os.OpenFile(),也可以使用ioutil.WriteFile()

1. ioutil.ReadFile和ioutil.WriteFile 是整读整取。
   代码如下：

// readFile_ioutil
package main

import (
    "fmt"
    "io/ioutil"
    "os"
)

func main() {
    inputFile := "d:/111.txt"
    outputFile := "d:/112.txt"
    buf, err := ioutil.ReadFile(inputFile)
    if err != nil {
        fmt.Fprintf(os.Stderr, "File error:%s", err)
    }
    fmt.Printf("%s\n", string(buf))
    err = ioutil.WriteFile(outputFile, buf, 0644)
    if err != nil {
        panic(err.Error())
    }
}

文件的写(bufio.NewWriter与os.OpenFile)

• 代码：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 ：清空

• 第三个参数：权限控制：

1. r ——> 004
2. w——> 002
3. x——> 001

我们使用os.OpenFile来打开一个文件，os.O_WRONLY|os.O_CREATE 表示是如果没有那么就创建新文件，只读写该文件，权限模式为0666，
完整代码如下：

// WriteToFile
package main

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

func main() {
    outputFile,err := os.OpenFile("output.txt",os.O_WRONLY|os.O_CREATE,0666)
    if err != nil {
        fmt.Printf("an error happend with fil crea\n")
        return
    }
    defer outputFile.Close()
    outputWriter := bufio.NewWriter(outputFile)
    outputString := "hello world!\n"
    for i:=0;i<10;i++ {
        outputWriter.WriteString(outputString)
    }
    outputFile.Flush()
}

利用读写来拷贝文件

我们这次实现拷贝文件通过边读边写的方式来实现文件的拷贝,主要是使用os.OpenFile和os.Open来时实现,代码如下：

// copyFile
package main

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

func copyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        fmt.Println("happend a error when opening", err)
    }
    defer src.Close()
    dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
    if err != nil {
        fmt.Println("happend a error when opening", err)
    }
    defer dst.Close()
    return io.Copy(dst, src)
}

func main() {
    copyFile("test.gz", "test.log.gz")
}