计算机的文件是存储再外部介质（硬盘）上的数据集合，文件分为文本文件和二进制文件
1. 打开和关闭文件
os.open()函数能够打开一个文件，返回一个*File和一个err，对得到的文件示例close()方法能够关闭文件
close()可以释放内存空间
示例：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package main
import ( "fmt" "os" )
func main() { //系统打开文件并赋予文件实体 file, err := os.Open("./abc.txt") if err != nil { fmt.Println("文件打开失败", err) } else { fmt.Println("文件打开成功") file.Close() fmt.Println("文件关闭成功") } } |
输出结果如下
文件打开失败 open ./abc.txt: The system cannot find the file specified.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package main
import "fmt"
func hello() { defer fmt.Println("执行defer") //延迟处理，函数关闭前执行 for i := 0; i < 10; i++ { fmt.Println(i) if i == 8 { //手动宕机处理，立马关闭当前程序，并释放内存空间 panic("程序宕机") //阈值 } } }
func main() { hello() } |
2. 读取文件
接收一个字节切片，返回读取的字节数和可能的具体错误，读到文件末尾时会返回0 和 io.EOF
|
1 |
func (f *File) Read(b []byte) (n int,err error) |
2.1 defer 语句
示例：
defer—般用于资源的释放和异常的捕捉。;
defer语句会将其后面跟随的语句进行延迟处理；跟在defer后面的语言将会在程序进行最后的return之后再执行
在defer归属的函数即将返回时，将延迟处理的语句按defer的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被 defer的语句，最先被执行。
|
1 2 3 4 5 6 7 8 9 10 |
package main
import "fmt"
func main() { defer fmt.Println("执行defer语句") //延迟处理，函数关闭前执行 for i := 0; i < 5; i++ { fmt.Println(i) } } |
输出结果如下
0
1
2
3
4
执行defer语句
2.2 手动宕机处理
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package main
import "fmt"
func hello() { defer fmt.Println("执行defer") //延迟处理，函数关闭前执行 for i := 0; i < 10; i++ { fmt.Println(i) if i == 8 { //手动宕机处理，立马关闭当前程序，并释放内存空间 panic("程序宕机") } } }
func main() { hello() } |
2.3 打开文件并获取内容
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
package main
import ( "fmt" "io" "os" )
func main() { //读取文件 file, err := os.Open("./abc.txt") if err != nil { fmt.Println("文件打开失败", err) return } defer file.Close() //main函数结束前执行文件资源释放 fmt.Println("文件打开成功") //定义参数切片 var result [128]byte n, err := file.Read(result[:]) //以切片的形式读取 //文件读取完成，进行判断 if err == io.EOF { fmt.Println("文件读取完毕", err) return } //读取过程中出现异常 if err != nil { fmt.Println("文件读取失败", err) return } fmt.Printf("字节数: %d 个\n", n) fmt.Printf("获取的内容是: %s", string(result[:])) } |
2.4 bufio 读取文件
使用bufio读取，bufio 在 file 的基础上封装了一层API，支持更多的功能
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
package main
import ( "bufio" "fmt" "io" "os" )
func main() { //读取文件 file, err := os.Open("./abc.txt") if err != nil { fmt.Println("文件打开失败", err) return } //main函数结束前执行文件资源释放 defer file.Close() //bufio缓冲区读取 reader := bufio.NewReader(file) //循环读取内存，输出到程序中 for { str, err := reader.ReadString('\n') //按行读取，值赋予给str if err == io.EOF { fmt.Print(str) //要输出，否则不显示最后一行 // fmt.Println("文件读取完毕") return } if err != nil { fmt.Println("文件读取异常", err) return } fmt.Print(str) //取消ln文件中自带换行 } } |
2.5 ioutil 读取文件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main
import ( "fmt" "io/ioutil" )
func ReaderFile(path string) { content, err := ioutil.ReadFile(path) if err != nil { fmt.Println("文件读取异常") return } fmt.Println(string(content)) //转换string格式并输出 }
func main() { ReaderFile("./abc.txt") } |
2.6 读取奇偶行内容
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
package main
import ( "bufio" "fmt" "io" "os" )
func main() { //读取文件 file, err := os.Open("./abc.txt") if err != nil { fmt.Println("文件打开失败", err) return } //main函数结束前执行文件资源释放 defer file.Close() //bufio缓冲区读取 reader := bufio.NewReader(file) //计数奇偶行 count := 0 for { str, _, err := reader.ReadLine() count++ if err == io.EOF { // fmt.Println("文件读取完毕") return } if err != nil { fmt.Println("文件读取异常", err) return } if count%2 == 1 { fmt.Println(string(str)) } } } |
登录并判断用户名是否存在
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
package main
import ( "bufio" "fmt" "io" "os" )
//读取文件 func main() { //var doing bool var name string fmt.Print("请输入用户名:") fmt.Scan(&name) //defer fmt.Println("用户不存在") file, err := os.Open("./abc.txt") if err != nil { fmt.Println("文件打开失败", err) return } //main函数结束前，执行文件资源释放 defer file.Close()
//利用bufio缓冲区读取文件 reader := bufio.NewReader(file) //建立缓冲区,将文件内容放入到缓冲区 //计数奇偶行 a := 0 for { str, _, err := reader.ReadLine() //每次读取，a+1 a++ if err == io.EOF { fmt.Println("文件读取完毕") //如果文件读取完，也没有返回，则说明用户不存在 fmt.Println("用户不存在") return } if err != nil { fmt.Println("文件读取错误") return } if a%2 == 1 { if name == string(str) { fmt.Println("登录成功") return } } } } |
3. 写入文件
3.1 os.OpenFile() 函数
os.OpenFile()函数能够以指定模式打开文件，从而实现文件写入相关功能。
语法格式如下：
func OpenFile(name string,flag int,perm FileMode)(*File,error) {
...
}
name:要打开的文件名
flag:打开文件的模式
模式种类:
模式|含义|
- |os.O_WRONLY|只写|
- |os.O_CREATE|创建文件|
- |os.O_RDONLY|只读|
- |os.O_RDWR|读写|
- |os.O_TRUNC|清空|
- |os.O_APPEND|追加|
perm:文件权限，一个八进制数。r(读)04，W(写)02，x(执行)01
3.2 Write 和 WriteString 方式写入
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
package main
import ( "fmt" "os" )
//使用write和writestring写入 func main() { //写入方式打开文件，创建新文件，开启只写模式，文件权限644 file, err := os.OpenFile("abc.txt", os.O_CREATE|os.O_WRONLY, 0644) if err != nil { fmt.Println("文件打开失败", err) return } //字节切片写入 file.Write([]byte("this is byte write\n")) //字符串写入 str := "this is string write" file.WriteString(str) } |
3.3 bufio.NewWriter 方式写入
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
package main
import ( "bufio" "fmt" "os" )
//bufio写入 func main() { file, err := os.OpenFile("tmp.txt", os.O_CREATE|os.O_WRONLY, 0666) //WRONLY，清空 if err != nil { fmt.Println("文件打开失败", err) return } defer file.Close()
//文件写入缓冲区 write := bufio.NewWriter(file) for i := 0; i < 5; i++ { //内容写入缓冲区 write.WriteString("this is bufio write\n") } //缓冲区数据提交写入文件 write.Flush() } |
3.4 ioutil.WriteFile 方式写入
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package main
import ( "fmt" "io/ioutil" )
func main() { str := "this is ioutil write\nthis is test content" //iotuil方式直接写入，字符串转换成字节数组写入 err := ioutil.WriteFile("./tmp.txt", []byte(str), 0666) if err != nil { fmt.Println("文件写入失败", err) return } } |
