golang--IO操作

1、IO操作

package main

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

func ReadForm(reader io.Reader,num int)([]byte,error){
	buf := make([]byte,num)
	n,err := reader.Read(buf)
	if n>0 {
		return buf[:n],nil
	}
	return buf,err
}

// 字符串读取
func StringReadForm(){
	data, err := ReadForm(strings.NewReader("hello world"),20)
	if err != nil{
		fmt.Println(err)
	}
	fmt.Println(string(data))
}

// 终端读取
func ItermReadForm(){
	fmt.Println("请输入：")
	data,err := ReadForm(os.Stdin,20)
	if err != nil{
		fmt.Println(err)
	}
	fmt.Println(string(data))
}

// 文件读取
func FileReadForm(){
	file,err := os.OpenFile("main.go",os.O_RDONLY,666)
	defer file.Close()
	if err != nil{
		fmt.Println(err)
	}
	data,err := ReadForm(file,20)
	fmt.Println(string(data))
}

func main(){
	// StringReadForm()
	// ItermReadForm()
	FileReadForm()
}

2、缓存IO操作

package main

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

func main(){
	// 读取字符串，将字符串的内容写入bufio
	strReader := strings.NewReader("hello world")
	bufReader := bufio.NewReader(strReader)
	// 偏移量，不会真正的读取buf中的数据
	data,err :=bufReader.Peek(3)
	if err != nil{
		fmt.Println(err)
	}
	// bufReader.Buffered()缓冲区剩余数据长度
	fmt.Println(string(data),bufReader.Buffered())

	// 读取buf中的数据,读取到哪里结束
	strData,err := bufReader.ReadString('w')
	fmt.Println(strData,bufReader.Buffered())

	// 写入到buf
	writer := bufio.NewWriter(os.Stdout)

	//写入到文件，终端也是一个文件
	fmt.Fprint(writer,"hello world")
	writer.Flush()
}

3、读取文件行数

package main

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

// 计算行数

func main(){
	if len(os.Args) < 2{
		fmt.Println("文件名不能为空")
		return
	}
	fileName := os.Args[1]
	file,err := os.Open(fileName)
	if err != nil{
		fmt.Println(err)
	}
	// 使用buf去读取文件
	bufReader := bufio.NewReader(file)
	var lines int
	for {
		_,isPrefix,err := bufReader.ReadLine()
		if err != nil{
			break
		}
		if !isPrefix{
			lines++
		}
	}
	fmt.Println(lines)
}

4、读取文件内容

一次读取

func ReadAll(filePth string) ([]byte, error) {
 f, err := os.Open(filePth)
 if err != nil {
  return nil, err
 }
 

 return ioutil.ReadAll(f)
}

分块读取

package main
 import (

 "bufio"
 "io"
 "os"
)

func processBlock(line []byte) {
 os.Stdout.Write(line)
}

func ReadBlock(filePth string, bufSize int, hookfn func([]byte)) error {
 f, err := os.Open(filePth)
 if err != nil {
  return err
 }
 defer f.Close()

 buf := make([]byte, bufSize) //一次读取多少个字节
 bfRd := bufio.NewReader(f)
 for {
  n, err := bfRd.Read(buf)
  hookfn(buf[:n]) // n 是成功读取字节数

  if err != nil { //遇到任何错误立即返回，并忽略 EOF 错误信息
   if err == io.EOF {
    return nil
   }
   return err
  }
 }

 return nil
}

func main() {
 ReadBlock("test.txt", 10000, processBlock)
}

逐行读取

package main
 

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

func processLine(line []byte) {
 os.Stdout.Write(line)
}

func ReadLine(filePth string, hookfn func([]byte)) error {
 f, err := os.Open(filePth)
 if err != nil {
  return err
 }
 defer f.Close()

 bfRd := bufio.NewReader(f)
 for {
  line, err := bfRd.ReadBytes('\n')
  hookfn(line) //放在错误处理前面，即使发生错误，也会处理已经读取到的数据。
  if err != nil { //遇到任何错误立即返回，并忽略 EOF 错误信息
   if err == io.EOF {
    return nil
   }
   return err
  }
 }
 return nil
}

func main() {
 ReadLine("test.txt", processLine)
}

https://www.cnblogs.com/mafeng/p/7680451.html