1. 文件介绍
2. 打开文件
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)
}
}
2.1 打开大文件
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("文件读取结束...")
}
2.2 打开小文件
package main
import (
"fmt"
"io/ioutil"
)
func main() {
//使用ioutil.ReadFile一次性将文件读取到位
file := "d:/abc.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))
//[104 101 108 108 111 44 71 97 114 100 111 110 13 10 104 101 108 108 111 44 71 97 114 100 111 110 13 10 104 101 108 108 111 44 71 97 114 100 111 110 13 10 104 101 108 108 111 44 71 97 114 100 111 110 13 10 104 101 108 108 111 44 71 97 114 100 111 110 13 10]hello,Gardon
//hello,Gardon
//hello,Gardon
//hello,Gardon
//hello,Gardon
//我们没有显式的Open文件，因此也不需要显式的Close文件
//因为，文件的Open和Close被封装到 ReadFile 函数内部
}
3. 写文件
3.1 不存在创建（Python中的w a）
package main
import (
"fmt"
"bufio"
"os"
_"syscall"
)
/*
const (
O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
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 // 如果可能，打开时清空文件
)
*/
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()
}
3.2 存在清空（Python中的w）
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, 0666)
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 := 0; i < 10; i++ {
writer.WriteString(str)
}
//因为writer是带缓存，因此在调用WriterString方法时，其实
//内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
//真正写入到文件中， 否则文件中会没有数据!!!
writer.Flush()
}
3.3 追加（python中的a）
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, 0666)
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 := 0; i < 10; i++ {
writer.WriteString(str)
}
//因为writer是带缓存，因此在调用WriterString方法时，其实
//内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
//真正写入到文件中， 否则文件中会没有数据!!!
writer.Flush()
}
3.4 显示并追加
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, 0666)
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 := 0; i < 5; i++ {
writer.WriteString(str)
}
//因为writer是带缓存，因此在调用WriterString方法时，其实
//内容是先写入到缓存的,所以需要调用Flush方法，将缓冲的数据
//真正写入到文件中， 否则文件中会没有数据!!!
writer.Flush()
}
3.5 文件内容复制
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, 0666)
if err != nil {
fmt.Printf("write file error=%v\n", err)
}
}
3.6 文件复制
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, 0666)
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)
}
}
3.7 统计不同类型的字符个数
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 >= '0' && v <= '9':
count.NumCount++
default :
count.OtherCount++
}
}
}
//输出统计的结果看看是否正确
fmt.Printf("字符的个数为=%v 数字的个数为=%v 空格的个数为=%v 其它字符个数=%v",
count.ChCount, count.NumCount, count.SpaceCount, count.OtherCount)
}