go 文件操作 io

package main
import (
    "fmt"
    "os"
)
func main() {
    //打开文件
    //概念说明: file 的叫法
    //1. file 叫 file对象
    //2. file 叫 file指针
    //3. file 叫 file 文件句柄
    file , err := os.Open("d:/test.txt")
    if err != nil {
        fmt.Println("open file err=", err)
    }
    //输出下文件，看看文件是什么, 看出file 就是一个指针 *File
    fmt.Printf("file=%v", file)
    //关闭文件
    err = file.Close()
    if err != nil {
        fmt.Println("close file err=", err)
    }
}

package main
import (
    "fmt"
    "os"
    "bufio"
    "io"
)
func main() {
    //打开文件
    //概念说明: file 的叫法
    //1. file 叫 file对象
    //2. file 叫 file指针
    //3. file 叫 file 文件句柄
    file , err := os.Open("d:/test.txt")
    if err != nil {
        fmt.Println("open file err=", err)
    }
 
    //当函数退出时，要及时的关闭file
    defer file.Close() //要及时关闭file句柄，否则会有内存泄漏.
 
    // 创建一个 *Reader  ，是带缓冲的
    /*
    const (
    defaultBufSize = 4096 //默认的缓冲区为4096
    )
    */
    reader := bufio.NewReader(file)
    //循环的读取文件的内容
    for {
        str, err := reader.ReadString('\n') // 读到一个换行就结束
        if err == io.EOF { // io.EOF表示文件的末尾
            break
        }
        //输出内容
        fmt.Printf(str)
    }
 
    fmt.Println("文件读取结束...")
}

package main
import (
	"fmt"
	"io/ioutil"
)
func main() {
 
	//使用ioutil.ReadFile一次性将文件读取到位
	file := "d:/test.txt"
	content, err := ioutil.ReadFile(file)
	if err != nil {
		fmt.Printf("read file err=%v", err)
	}
	//把读取到的内容显示到终端
	//fmt.Printf("%v", content) // []byte
	fmt.Printf("%v", string(content)) // []byte
 
	//我们没有显式的Open文件，因此也不需要显式的Close文件
	//因为，文件的Open和Close被封装到 ReadFile 函数内部
}

　　

package main
import (
	"fmt"
	"bufio"
	"os"
)
func main() {
	//创建一个新文件，写入内容 5句 "hello, Gardon"
	//1 .打开文件 d:/abc.txt
	filePath := "d:/abc.txt"
	file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_CREATE, 0666)
	if err != nil {
		fmt.Printf("open file err=%v\n", err)
		return
	}
	//及时关闭file句柄
	defer file.Close()
	//准备写入5句 "hello, Gardon"
	str := "hello,Gardon\r\n" // \r\n 表示换行
	//写入时，使用带缓存的 *Writer
	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.WriteString(str)
	}
	//因为writer是带缓存，因此在调用WriterString方法时，其实
	//内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
	//真正写入到文件中， 否则文件中会没有数据!!!
	writer.Flush()
}

　　

file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_TRUNC, 0666)

package main
import (
    "fmt"
    "bufio"
    "os"
)
 
func main() {
    //打开一个存在的文件中，将原来的内容覆盖成新的内容10句 "你好，尚硅谷!"
 
    //创建一个新文件，写入内容 5句 "hello, Gardon"
    //1 .打开文件已经存在文件, d:/abc.txt
    filePath := "d:/abc.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_TRUNC, )
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return
    }
    //及时关闭file句柄
    defer file.Close()
    //准备写入5句 "你好,尚硅谷!"
    str := "你好,尚硅谷!\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := ; i < ; i++ {
        writer.WriteString(str)
    }
    //因为writer是带缓存，因此在调用WriterString方法时，其实
    //内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.Flush()
 
}

file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_APPEND, 0666)

package main
import (
    "fmt"
    "bufio"
    "os"
)
 
func main() {
 
    //打开一个存在的文件，在原来的内容追加内容 'ABC! ENGLISH!'
    //1 .打开文件已经存在文件, d:/abc.txt
    filePath := "d:/abc.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY | os.O_APPEND, )
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return
    }
    //及时关闭file句柄
    defer file.Close()
    //准备写入5句 "你好,尚硅谷!"
    str := "ABC,ENGLISH!\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := ; i < ; i++ {
        writer.WriteString(str)
    }
    //因为writer是带缓存，因此在调用WriterString方法时，其实
    //内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.Flush()
 
}

package main
import (
    "fmt"
    "bufio"
    "os"
    "io"
)
 
func main() {
 
    //打开一个存在的文件，将原来的内容读出显示在终端，并且追加5句"hello,北京!"
    //1 .打开文件已经存在文件, d:/abc.txt
    filePath := "d:/abc.txt"
    file, err := os.OpenFile(filePath, os.O_RDWR | os.O_APPEND, )
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return
    }
    //及时关闭file句柄
    defer file.Close()
 
    //先读取原来文件的内容，并显示在终端.
    reader := bufio.NewReader(file)
    for {
        str, err := reader.ReadString('\n')
        if err == io.EOF { //如果读取到文件的末尾
            break
        }
        //显示到终端
        fmt.Print(str)
    }
 
    //准备写入5句 "你好,尚硅谷!"
    str := "hello,北京!\r\n" // \r\n 表示换行
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := ; i < ; i++ {
        writer.WriteString(str)
    }
    //因为writer是带缓存，因此在调用WriterString方法时，其实
    //内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
    //真正写入到文件中， 否则文件中会没有数据!!!
    writer.Flush()
 
}

package main
import (
    "fmt"
    "io/ioutil"
)
func main() {
    //将d:/abc.txt 文件内容导入到  e:/kkk.txt
    //1. 首先将  d:/abc.txt 内容读取到内存
    //2. 将读取到的内容写入 e:/kkk.txt
    file1Path := "d:/abc.txt"
    file2Path := "e:/kkk.txt"
    data, err := ioutil.ReadFile(file1Path)
    if err != nil {
        //说明读取文件有错误
        fmt.Printf("read file err=%v\n", err)
        return
    }
    err = ioutil.WriteFile(file2Path, data, )
    if err != nil {
        fmt.Printf("write file error=%v\n", err)
    }
}

package main
import (
    "fmt"
    "os"
    "io"
    "bufio"
)
 
//自己编写一个函数，接收两个文件路径 srcFileName dstFileName
func CopyFile(dstFileName string, srcFileName string) (written int64, err error) {
 
    srcFile, err := os.Open(srcFileName)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
    }
    defer srcFile.Close()
    //通过srcfile ,获取到 Reader
    reader := bufio.NewReader(srcFile)
 
    //打开dstFileName
    dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, )
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return
    }
 
    //通过dstFile, 获取到 Writer
    writer := bufio.NewWriter(dstFile)
    defer dstFile.Close()
 
    return io.Copy(writer, reader)
 
}
 
func main() {
 
    //将d:/flower.jpg 文件拷贝到 e:/abc.jpg
 
    //调用CopyFile 完成文件拷贝
    srcFile := "d:/flower.jpg"
    dstFile := "e:/abc.jpg"
    _, err := CopyFile(dstFile, srcFile)
    if err == nil {
        fmt.Printf("拷贝完成\n")
    } else {
        fmt.Printf("拷贝错误 err=%v\n", err)
    }
 
}

package main
import (
    "fmt"
    "os"
    "io"
    "bufio"
)
 
//定义一个结构体，用于保存统计结果
type CharCount struct {
    ChCount int // 记录英文个数
    NumCount int // 记录数字的个数
    SpaceCount int // 记录空格的个数
    OtherCount int // 记录其它字符的个数
}
 
func main() {
 
    //思路: 打开一个文件, 创一个Reader
    //每读取一行，就去统计该行有多少个 英文、数字、空格和其他字符
    //然后将结果保存到一个结构体
    fileName := "e:/abc.txt"
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Printf("open file err=%v\n", err)
        return
    }
    defer file.Close()
    //定义个CharCount 实例
    var count CharCount
    //创建一个Reader
    reader := bufio.NewReader(file)
 
    //开始循环的读取fileName的内容
    for {
        str, err := reader.ReadString('\n')
        if err == io.EOF { //读到文件末尾就退出
            break
        }
        //遍历 str ，进行统计
        for _, v := range str {
 
            switch {
                case v >= 'a' && v <= 'z':
                        fallthrough //穿透
                case v >= 'A' && v <= 'Z':
                        count.ChCount++
                case v == ' ' || v == '\t':
                        count.SpaceCount++
                case v >= '' && v <= '':
                        count.NumCount++
                default :
                        count.OtherCount++
            }
        }
    }
 
    //输出统计的结果看看是否正确
    fmt.Printf("字符的个数为=%v 数字的个数为=%v 空格的个数为=%v 其它字符个数=%v",
        count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)
 
}

package main
 
import (
    "bytes"
    "os"
)
 
func main(){
    var myname bytes.Buffer
    myname.Write([]byte("sunlong"))
    myname.WriteTo(os.Stdout)
}
 
...
sunlong
Process finished with exit code
...

缓冲区，只有当内存达到一定数量后才会写入