最近初接触了go这门语言,为了更加深入学习,完成了一个项目。将一个c语言实现的linux读取文件行命令程序修改为go语言实现。以下是项目地址:  
原项目:https://www.ibm.com/developerworks/cn/linux/shell/clutil/index.html
go实现的项目:https://github.com/kangbb/go-learning/tree/master/selpg
  
  当然,项目做完后觉得很简单,不过,过程中还是遇到了不少麻烦,尤其是读写文件的时候。所以,对这方面的内容做了一下总结。

Go如何打开文件

  主要有下面两个函数:

import "os"
//1
func Open(name string) (file *File, err error)

//2
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)

  其实两个函数差不多,一般来说,使用第一个就可以完成正常的读写。当然,更加推荐使用第二个,尤其是在linux下,有时候perm是必需的(例如创建文件的时候)。name是文件的地址及文件名,flag是一些打开文件选项的常量,perm是文件操作权限 。更多请参考:
flag: https://go-zh.org/pkg/os/
perm:https://go-zh.org/pkg/os/#FileMode

Go如何按行读取文件

  go按行读取文件主要有三种方式。前两种相对简单,第三种会比较难一些,但是我觉得用途更见广泛,用起来更见自由。

第一种方式:

import (
"bufio"
"fmt"
)

func useNewReader(filename string) {
    var count int = 0

    fin, error := os.OpenFile(filename, os.O_RDONLY, 0)
    if error != nil {
        panic(error)
    }
    defer fin.Close()

    /*create a Reader*/
    rd := bufio.NewReader(fin)

    /*read the file and stop when meet err or EOF*/
    for {
        line, err := rd.ReadString('\n')
        if err != nil || err == io.EOF {
            break
        }
        count++
        /*for each line, process it.
          if you want it ouput format in command-line, you need clean the '\f'*/
        line = strings.Replace(line, "\f", "", -1)
        fmt.Printf("the line %d: %s", count, line)
    }
}

第二种方式:

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

func useNewScanner(filename string) {
    var count int = 0

    fin, error := os.OpenFile(filename, os.O_RDONLY, 0)
    if error != nil {
        panic(error)
    }
    defer fin.Close()

    sc := bufio.NewScanner(fin)
    /*default split the file use '\n'*/
    for sc.Scan() {
        count++
        fmt.Printf("the line %d: %s\n", count, sc.Text())
    }
    if err := sc.Err(); err != nil{
        fmt.Prinfln("An error has hippened")
    }
}

第三种方式:

import(
  "fmt"
  "os"
  "bufio"
)
var LineSplit = func(data []byte, atEOF bool) (advance int, token []byte, err error) {
    /*read some*/
    if atEOF && len(data) == 0 {
        return 0, nil, nil
    }

    /*find the index of the byte '\n'
      and find another line begin i+1
      default token doesn't include '\n'*/
    if i := bytes.IndexByte(data, '\n'); i > 0 {
        return i + 1, dropCR(data[0:i]), nil
    }

    /*at EOF, we have a final, non-terminal line*/
    if atEOF {
        return len(data), dropCR(data), nil
    }

    /*read some more*/
    return 0, nil, nil
}

func dropCR(data []byte) []byte {
    /*drop the '\f'
      if you don't need, you can delete it*/
    if i := bytes.IndexByte(data, '\f'); i >= 0 {
        tmp := [][]byte{data[0:i], data[(i + 1):]}
        sep := []byte("")
        data = bytes.Join(tmp, sep)
    }
    if len(data) > 0 && data[len(data)-1] == '\r' {
        return data[0 : len(data)-1]
    }
    return data
}

func useSplit(filename string) {
    var count int = 0

    fin, error := os.OpenFile(filename, os.O_RDONLY, 0)
    if error != nil {
        panic(error)
    }
    defer fin.Close()

    sc := bufio.NewScanner(fin)
    /*Specifies the matching function, default read by lines*/
    sc.Split(LineSplit)
    /*begin scan*/
    for sc.Scan() {
        count++
        fmt.Printf("the line %d: %s\n", count, sc.Text())
    }
    if err := sc.Err(); err != nil{
        fmt.Prinfln("An error has hippened")
    }
}

  整体看起来,第二种方法可能更加简单。因为它的代码最少。实际上,第三种和第二种一样,不过过换了一种写法。因为Scanner.Scan()默认按行读取,所以第二种方法中省略了:

  sc.Split(bufio.ScanLines)

  如果你认真看过源码,你会发现,我的第三种方式实现的按行读取的LineSplit函数,实际上来自go的bufio.go包,以下是地址:
  
bufio.go:https://go-zh.org/src/bufio/bufio.go

这里之所以列出来,是希望能够着重强调一下如何使用Scanner.Split()函数和Scanner.Scan()函数搭配来读取文件,或者分割字符串并输出。当然,这些也可以通过strings包来实现,相对来说,它的功能更加全面一些。需要向大家强调一点:当你不会使用go语言函数时,可以多看看官方提供的文档以及包中的源代码。

Go如何按页读取文件

   既然按行读取已经实现,那么按页读取也很简单啦。只需要稍微修改依稀代码即可实现。
  
对于第一种方式:

page, err := rd.ReadString('\f')

当然,这样一般情况下就可以了。但是,对于Reader.ReadString()函数来说,假如入它找不到分隔符’\f’,会再多读一些字节数据进去;假如再找不到,会再读一些,直到缓存区满,才返回已经读取的字节数据;但是,假如一直到遇到EOF都没有’\f’,并且缓存去足够大,这时候,如果按照刚刚的修改,就再屏幕上看不到输出了,所以,还需要修改:

if err != nil || err == io.EOF {
    /*if it has no '\f' behind the last line*/
    if err == io.EOF && len(page) != 0 {
        count++
        fmt.Printf("the page %d:\n%s\n", count, page)
    }
    break
}

对于第三种方式:

var LineSplit = func(data []byte, atEOF bool) 
    (advance int, token []byte, err error) {
    /*read some*/
    if atEOF && len(data) == 0 {
        return 0, nil, nil
    }

    /*find the index of the byte '\f'
      and find another line begin i+1
      default token doesn't include '\n'*/
    if i := bytes.IndexByte(data, '\f'); i > 0 {
        return i + 1, dropCR(data[0:i]), nil
    }

    /*at EOF, we have a final, non-terminal line*/
    if atEOF {
        return len(data), dropCR(data), nil
    }

    /*read some more*/
    return 0, nil, nil
}

func dropCR(data []byte) []byte {
    /*drop the '\f'
      if you don't need, you can delete it*/
    if i := bytes.IndexByte(data, '\f'); i >= 0 {
        tmp := [][]byte{data[0:i], data[(i + 1):]}
        sep := []byte("")
        data = bytes.Join(tmp, sep)
    }
    return data
}

  以上便是对这次学习的总结,也希望对大家有所帮助。