计算机的文件是存储再外部介质（硬盘）上的数据集合，文件分为文本文件和二进制文件
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
}
}
|
|
