GO - 包接口说明
[io/ioutil]// io.Reader其实是一个包含Read方法的接口类型，而文件对象本身是实现了了Read方法的// 从一个io.Reader类型中读取内容直到返回错误或者EOF时返回读取的数据//读取文件内容，并返回[]byte数据func ReadFile(filename string) ([]byte, error)// ReadAll 源中读取数据直到EOF，其不会去从返回数据中去判断EOF来作为读取成功的依据func ReadAll(r io.Reader) ([]byte, error)// 读取目录，返回当前目录下的文件对象列表func ReadDir(dirname string) ([]os.FileInfo, error)/********** 写入 **********/// 写入[]byte类型的data到filename文件中，文件权限为 permfunc WriteFile(filename string, data []byte, perm os.FileMode) error[io][os]// 打开一个文件，返回的文件对象指针，默认的权限为O_RDONLY，也就是只对文件有只读权限func Open(name string) (*File, error)// 指定参数(os.O_APPEND|os.O_CREATE|os.O_WRONLY)以及文件权限(0666)来打开文件func OpenFile(name string, flag int, perm FileMode) (*File, error)[bufio] // 实现了缓存IO,它本身包装了io.Reader和io.Writer对象[strings][strconv]
// *File// 文件对象中读取长度为b的字节，返回当前读到的字节数以及错误信息// 需要先初始化一个符合内容大小的空的字节列表，读取到文件的末尾时，该方法返回0，io.EOFfunc (f *File) Read(b []byte) (n int, err error)// 文件off偏移量开始读取长度为b的字节，返回读取到字节数以及错误信息。// 读取到的字节数n , 小于想要读取字节的长度len(b)的时候，该方法将返回非空的 error// 当读到文件末尾时，err返回io.EOFfunc (f *File) ReadAt(b []byte, off int64) (n int, err error)//写入长度为b字节切片到文件f中，返回写入字节号和错误信息。当n不等于len(b)时，将返回非空的errfunc (f *File) Write(b []byte) (n int, err error)//在off偏移量出向文件f写入长度为b的字节func (f *File) WriteAt(b []byte, off int64) (n int, err error)//类似于Write方法，但是写入内容是字符串而不是字节切片// 使用WriteString()j进行文件写入发现经常新内容写入时无法正常覆盖全部新内容。(是因为字符串长度不一样)func (f *File) WriteString(s string) (n int, err error)
//
const (
O_RDONLY int = syscall.O_RDONLY // 只读打开文件和os.Open()同义
O_WRONLY int = syscall.O_WRONLY // 只写打开文件
O_RDWR int = syscall.O_RDWR // 读写方式打开文件
O_APPEND int = syscall.O_APPEND // 当写的时候使用追加模式到文件末尾
O_CREATE int = syscall.O_CREAT // 如果文件不存在，此案创建
O_EXCL int = syscall.O_EXCL // 和O_CREATE一起使用, 只有当文件不存在时才创建
O_SYNC int = syscall.O_SYNC // 以同步I/O方式打开文件，直接写入硬盘.
O_TRUNC int = syscall.O_TRUNC // 如果可以的话，当打开文件时先清空文件
)
// "io/ioutil" - func ReadFile(filename string) ([]byte, error)
fileName := "./go_spider/data/url.txt"
if contents, err := ioutil.ReadFile(fileName); err == nil {
// 因为contents是[]byte类型, 直接转换成string类型后会多一行空格
// 需要使用 strings.Replace 替换换行符
result := strings.Replace(string(contents), "\n", "", 1)
fmt.Println(result)
}
// "os"
// "io/ioutil"
fileName := "./go_spider/data/url.txt"
// 打开一个文件并返回一个文件对象
if file, err := os.Open(fileName); err == nil {
// os.OpenFile(fileName, os.O_RDONLY, 0644);
defer file.Close()
if contents, err := ioutil.ReadAll(file); err == nil {
result := strings.Replace(string(contents), "\n", "", 1)
fmt.Println(result)
}
}
// "os"
// "strconv"
fileName := "./go_spider/data/url.txt"
if file, err := os.Open(fileName); err == nil {
defer file.Close()
// 在定义空的byte列表时尽量大一些, 否则这种方式读取内容可能造成文件读取不完整
buf := make([]byte, 1024)
if n, err := file.Read(buf); err == nil {
fmt.Println("The number of bytes read:"+strconv.Itoa(n), "Buf length:"+strconv.Itoa(len(buf)))
result := strings.Replace(string(buf), "\n", "", 1)
fmt.Println("Use os.Open and File's Read method to read a file:", result)
}
}
// bufio
//首先定义了一个用来缓冲io.Reader对象的结构体，同时该结构体拥有以下相关的方法
type Reader struct {
}
// NewReader函数用来返回一个默认大小buffer的Reader对象(默认大小好像是4096)
// 等同于NewReaderSize(rd,4096)
func NewReader(rd io.Reader) *Reader
// 返回一个指定大小buffer(size最小为16)的Reader对象
// 如果 io.Reader参数已经是一个足够大的Reader，它将返回该Reader
func NewReaderSize(rd io.Reader, size int) *Reader
// 该方法返回从当前buffer中能被读到的字节数
func (b *Reader) Buffered() int
// Discard方法跳过后续的 n 个字节的数据，返回跳过的字节数
// 如果0 <= n <= b.Buffered(),该方法将不会从io.Reader中成功读取数据。
func (b *Reader) Discard(n int) (discarded int, err error)
// Peekf方法返回缓存的一个切片，该切片只包含缓存中的前n个字节的数据
func (b *Reader) Peek(n int) ([]byte, error)
// 把Reader缓存对象中的数据读入到[]byte类型的p中，并返回读取的字节数
func (b *Reader) Read(p []byte) (n int, err error)
// 返回单个字节，如果没有数据返回err
func (b *Reader) ReadByte() (byte, error)
// 该方法在b中读取delimz之前的所有数据，返回的切片是已读出的数据的引用
// 切片中的数据在下一次的读取操作之前是有效的。如果未找到delim，将返回查找结果并返回nil空值。
// 因为缓存的数据可能被下一次的读写操作修改，因此一般使用ReadBytes或者ReadString，
// 他们返回的都是数据拷贝
func (b *Reader) ReadSlice(delim byte) (line []byte, err error)
// 功能同ReadSlice，返回数据的拷贝
func (b *Reader) ReadBytes(delim byte) ([]byte, error)
// 功能同ReadBytes,返回字符串
func (b *Reader) ReadString(delim byte) (string, error)
// 该方法是一个低水平的读取方式，一般建议使用ReadBytes('\n') 或 ReadString('\n')，或者使用一个 Scanner来代替。ReadLine 通过调用 ReadSlice 方法实现，返回的也是缓存的切片，用于读取一行数据，不包括行尾标记（\n 或 \r\n）
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)
// 读取单个UTF-8字符并返回一个rune和字节大小
func (b *Reader) ReadRune() (r rune, size int, err error)
// "os"
// "strconv"
// "bufio"
fileName := "./go_spider/data/url.txt"
if file, err := os.Open(fileName); err == nil {
defer file.Close()
// 一个文件对象本身是实现了io.Reader的, 使用bufio.NewReader去初始化一个Reader对象, 存在buffer中的读取一次就会被清空
reader := bufio.NewReader(file)
// ReadString(delim byte) 来读取delim以及之前的数据并返回相关的字符串.
if result, err := reader.ReadString(byte('@')); err == nil {
fmt.Println("使用ReadSlince相关方法读取内容:", result)
}
//注意: 上述ReadString已经将buffer中的数据读取出来了，下面将不会输出内容
//需要注意的是，因为是将文件内容读取到[]byte中，因此需要对大小进行一定的把控
buf := make([]byte, 1024)
//读取Reader对象中的内容到[]byte类型的buf中
if n, err := reader.Read(buf); err == nil {
fmt.Println("The number of bytes read:" + strconv.Itoa(n))
//这里的buf是一个[]byte，因此如果需要只输出内容，仍然需要将文件内容的换行符替换掉
fmt.Println("Use bufio.NewReader and os.Open read file contents to a []byte:", string(buf))
}
}
实例
// "os"
// "io"
// "bufio"
// "io/ioutil"
// 读取文件的函数调用大多数都需要检查错误
func checkError(e error) {
if e != nil {
panic(e)
}
}
func main() {
fileName := "./go_spider/data/url.txt"
// 01 文件内容读取到内存 => ([]byte, error)
dat, err := ioutil.ReadFile(fileName)
checkError(err)
fmt.Print(string(dat))
// 02 控制读取部分文件内容 => (*File, error)
// `os.Open `打开文件获取 `os.File`对象
f, err := os.Open(fileName)
// 读取, 一定长度的字节数据 => 返回读取的字节数
b1 := make([]byte, 5)
n1, err := f.Read(b1)
checkError(err)
fmt.Printf("%d bytes: %s\n", n1, string(b1))
// `Seek` 设置读取指针 => (ret, error)
o2, err := f.Seek(6, 0)
checkError(err)
b2 := make([]byte, 2)
n2, err := f.Read(b2)
checkError(err)
fmt.Printf("%d bytes @ %d: %s\n", n2, o2, string(b2))
// 03 `io.ReadAtLeast` 读取数据 => (Reader, []byte, min) -> (n, error)
o3, err := f.Seek(6, 0)
checkError(err)
b3 := make([]byte, 2)
n3, err := io.ReadAtLeast(f, b3, 2)
checkError(err)
fmt.Printf("%d bytes @ %d: %s\n", n3, o3, string(b3))
// 04 rewind 设置 -> 使用`Seek(0,0)`来实现
_, err = f.Seek(0, 0)
checkError(err)
// 05 `bufio` 缓冲读取文件 => (io.Reader) -> *Reader
r4 := bufio.NewReader(f)
b4, err := r4.Peek(5)
checkError(err)
fmt.Printf("5 bytes: %s\n", string(b4))
// 最后关闭打开的文件, 一般在文件打开时使用defer来延迟关闭
f.Close()
}
// "io/ioutil"
func main() {
name := "./go_spider/test.txt"
content := "Hello, www.github.io!\n"
Write(name, content)
}
// ioutil.WriteFile 方式写入文件
// []byte内容写入文件, 如果content字符串中没有换行符的话, 默认就不会有换行符
func Write(name, content string) {
data := []byte(content)
if ioutil.WriteFile(name, data, 0644) == nil {
fmt.Println("写入文件成功:", content)
}
}
// "os"
func main() {
name := "./go_spider/test.txt"
Write(name, "testFileContent")
}
// os.OpenFile() 相关函数打开文件对象
// 并使用文件对象的相关方法进行文件写入操作
func Write(name, content string) {
file, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil {
fmt.Println("Failed to open the file", err.Error())
os.Exit(2)
}
defer file.Close()
if _, err := file.WriteString(content); err == nil {
fmt.Println("Successful writing to the file with os.OpenFile and *File.WriteString method.", content)
}
contents := []byte(content)
if _, err := file.Write(contents); err == nil {
fmt.Println("Successful writing to thr file with os.OpenFile and *File.Write method.", content)
}
}
// io
// 将字符串s写入w(可以是一个[]byte)，如果w实现了一个WriteString方法，它可以被直接调用
// 否则 w.Write会再一次被调用
func WriteString(w Writer, s string) (n int, err error)
// Writer对象的定义
type Writer interface {
Write(p []byte) (n int, err error)
}
// "os"
// "io"
// 使用io.WriteString()函数进行数据的写入
func WriteWithIo(name, content string) {
fileObj, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
fmt.Println("Failed to open the file", err.Error())
os.Exit(2)
}
if _, err := io.WriteString(fileObj, content); err == nil {
fmt.Println("Successful appending to the file with os.OpenFile and io.WriteString.", content)
}
}
// bufio
//Writer是一个空的结构体，一般需要使用NewWriter或者NewWriterSize来初始化一个结构体对象
type Writer struct {
// contains filtered or unexported fields
}
//NewWriterSize和NewWriter函数
//返回默认缓冲大小的Writer对象(默认是4096)
func NewWriter(w io.Writer) *Writer
//指定缓冲大小创建一个Writer对象
func NewWriterSize(w io.Writer, size int) *Writer
//Writer对象相关的写入数据的方法
//把p中的内容写入buffer,返回写入的字节数和错误信息。如果nn<len(p),返回错误信息中会包含为什么写入的数据比较短
func (b *Writer) Write(p []byte) (nn int, err error)
//将buffer中的数据写入 io.Writer
func (b *Writer) Flush() error
//以下三个方法可以直接写入到文件中
//写入单个字节
func (b *Writer) WriteByte(c byte) error
//写入单个Unicode指针返回写入字节数错误信息
func (b *Writer) WriteRune(r rune) (size int, err error)
//写入字符串并返回写入字节数和错误信息
func (b *Writer) WriteString(s string) (int, error)
// "os"
// "bufio"
//使用bufio包中Writer对象的相关方法进行数据的写入
func WriteWithBufio(name, content string) {
if fileObj, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644); err == nil {
defer fileObj.Close()
writeObj := bufio.NewWriterSize(fileObj, 4096)
//
if _, err := writeObj.WriteString(content); err == nil {
fmt.Println("Successful appending buffer and flush to file with bufio's Writer obj WriteString method", content)
}
//使用Write方法,需要使用Writer对象的Flush方法将buffer中的数据刷到磁盘
buf := []byte(content)
if _, err := writeObj.Write(buf); err == nil {
fmt.Println("Successful appending to the buffer with os.OpenFile and bufio's Writer obj Write method.", content)
if err := writeObj.Flush(); err != nil {
panic(err)
}
fmt.Println("Successful flush the buffer data to file ", content)
}
}
}
若有收获，就点个赞吧
0 人点赞
