文件操作

打开和关闭文件

/*
简易方式打开一个文件,拿着一顿骚操作,一秒后关闭.
以只读方式打开一个文件,创建其带缓冲的读取器,读取文件到末尾.
使用ioutil包对test.txt进行简易读取.
以创写追加或创写覆盖方法打开一个文件,缓冲式写出几行数据,倒干缓冲区后退出。
使用os包的状态检测结合,os.ISnotExist(err)判断文件师父存在.
使用ioutil包进行简易文件写出.
 */

简单打开一个文件

 1 //简易方式打开一个文件,拿着一顿骚操作,一秒后关闭
 2 package main
 3 
 4 import (
 5     "fmt"
 6     "os"
 7     "time"
 8 )
 9 
10 func main() {
11     file, err := os.Open("C:/Go/test1.txt")
12     if err == nil {
13         fmt.Println("文件打开成功..")
14     } else {
15         fmt.Println("文件打开失败,失败内容是:", err)
16         return
17     }
18 
19     //defer关闭文件
20     defer func() {
21         file.Close()
22         fmt.Println("文件已关闭..")
23     }()
24 
25     //模拟文件操作
26     time.Sleep(1 * time.Second)
27     fmt.Println("文件是", file)
28 
29 }
30 
31 /*
32 文件打开成功..
33 文件是 &{0xc00006a780}
34 文件已关闭..
35 
36 
37 文件打开失败,失败内容是: open C:/Go/test1.txt: The system cannot find the file specified.
38  */

一行一行读取完整文件内容

 1 //以只读方式打开一个文件,创建其带缓冲的读取器,读取文件到末尾.
 2 package main
 3 
 4 import (
 5     "bufio"
 6     "fmt"
 7     "io"
 8     "os"
 9 )
10 
11 func main() {
12     //以只读方式,并且文件权限以666访问.
13     file, err := os.OpenFile("C:/Go/test.txt", os.O_RDONLY, 0666)
14     if err == nil {
15         fmt.Println("文件打开成功")
16     } else {
17         fmt.Println("文件打开失败,err:", err)
18         return
19     }
20 
21     defer func() {
22         file.Close()
23         fmt.Println("文件已关闭")
24     }()
25 
26     //创建其带缓冲的读取器
27     reader := bufio.NewReader(file)
28 
29     //整体循环读取整个文件.
30     for {
31         str, err := reader.ReadString('\n') //一行一行的读取
32         if err == nil {
33             fmt.Println(str)
34         } else {
35 
36             //如果错误是已到文件末尾,就输出信息
37             if err == io.EOF {
38                 fmt.Println("已到文件末尾")
39                 break //读取完毕后 跳出循环,继续往下走.
40             }
41 
42             fmt.Println("文件读取错误: ", err)
43             return //异常错误,就退出
44         }
45 
46     }
47     fmt.Println("文件读取完毕.")
48 }
49 
50 /*
51 文件打开成功
52 神龟虽寿，犹有竟时；
53 
54 腾蛇乘雾，终为土灰。
55 
56 老骥伏枥，志在千里；
57 
58 烈士暮年，壮心不已。
59 
60 盈缩之期，不但在天；
61 
62 养怡之福，可得永年。
63 
64 已到文件末尾
65 文件读取完毕.
66 文件已关闭
67  */

使用ioutil包便捷读入

 1 //使用ioutil包对test.txt进行简易读取.
 2 //自动会进行关闭.
 3 package main
 4 
 5 import (
 6     "fmt"
 7     "io/ioutil"
 8 )
 9 
10 func main() {
11 
12     //读入指定文件的全部数据,返回[]byte类型的原始数据
13     bytes, err := ioutil.ReadFile("C:/Go/test.txt")
14     if err == nil {
15         contentStr := string(bytes) //字节转换成字符串
16         fmt.Println(contentStr)
17     } else {
18         fmt.Println("读取失败: ", err)
19     }
20 }
21 
22 /*
23 神龟虽寿，犹有竟时；
24 腾蛇乘雾，终为土灰。
25 老骥伏枥，志在千里；
26 烈士暮年，壮心不已。
27 盈缩之期，不但在天；
28 养怡之福，可得永年。
29 幸甚至哉，歌以咏志。
30  */

缓冲式写出

 1 //以创写追加或创写覆盖方法打开一个文件,缓冲式写出几行数据,倒干缓冲区后退出。
 2 package main
 3 
 4 import (
 5     "bufio"
 6     "fmt"
 7     "os"
 8 )
 9 
10 func main() {
11     //如果文件不存在,就创建|只能写不能读|数据追加 = 【创-写-追加 模式】
12     file, err := os.OpenFile("C:/Go/test001.txt", os.O_CREATE|os.O_RDONLY|os.O_APPEND, 0666)
13 
14     //如果有异常,直接退出
15     if err != nil {
16         fmt.Println("文件打开失败: ", err)
17         return
18     }
19 
20     //延时关闭文件.
21     defer func() {
22         file.Close()
23         fmt.Println("文件已关闭")
24     }()
25 
26     //创建写出缓冲器
27     writer := bufio.NewWriter(file)
28 
29     //分批次的写一些数据
30     writer.WriteString("女人四大愿望\n")
31     writer.WriteString("男人脑壳都坏掉\n")
32     writer.WriteString("天天给我送钞票\n")
33     writer.WriteString("还要排队等我挑\n")
34     writer.WriteString("永远青春不变老\n")
35     writer.WriteRune('你')
36     writer.WriteByte(123)
37     writer.Write([]byte{123, 124, 125})
38 
39     //倒干缓冲区
40     writer.Flush()
41     fmt.Println("写出完毕")
42 }

便捷写出

 1 //这个是调用的os.openfile ,封装的。
 2 package main
 3 
 4 import (
 5     "fmt"
 6     "io/ioutil"
 7 )
 8 
 9 func main() {
10 
11     //``保留原始格式
12     dataStr := `窗前明月光
13                 疑是地上霜
14                 举头望明月`
15 
16     //字符串转为字节类型
17     dataBytes := []byte(dataStr)
18 
19     err := ioutil.WriteFile("C:/Go/test001.txt", dataBytes, 0666)
20     if err != nil {
21         fmt.Println("发生了错误: ", err)
22     } else {
23         fmt.Println("写出成功")
24     }
25 }

检测文件是否存在

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "os"
 6 )
 7 
 8 func main() {
 9 
10     info, err := os.Stat("C:/Go/test001.txt")
11 
12     //判断是否有错误
13     if err != nil {
14         fmt.Println("err:", err)
15 
16         //判断是否是 文件存在的错误
17         if os.IsNotExist(err) {
18             fmt.Println("文件不存在")
19         }
20     } else {
21         fmt.Println("文件存在")
22         fmt.Println(info.Name(),info.IsDir())
23     }
24 }
25 /*
26 文件存在
27 test001.txt false
28  */

简易文件拷贝

/*
使用ioutil包做一个傻瓜式拷贝
使用io.Copys实现文件拷贝
使用缓冲区配合缓冲读写器进行图片拷贝
 */

使用ioutil包做一个傻瓜式拷贝

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "io/ioutil"
 6 )
 7 
 8 func main() {
 9     bytes, _ := ioutil.ReadFile("‪C:/Go/off.jpg")
10     err := ioutil.WriteFile("‪C:/Go/off002.jpg", bytes, 0666)
11     if err == nil {
12         fmt.Println("拷贝成功")
13     } else {
14         fmt.Println("拷贝失败", err)
15     }
16 }

使用io.Copy小文件拷贝

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "io"
 6     "os"
 7 )
 8 
 9 func main() {
10 
11     //打开拷贝原文件,模式为只读模式。
12     srcFile, _ := os.OpenFile("‪C:/Go/off.jpg", os.O_RDONLY, 0666)
13 
14     //打开要拷贝到的目标文件,模式为写和追加。
15     dstFile, _ := os.OpenFile("‪C:/Go/off002.jpg", os.O_WRONLY|os.O_CREATE, 0666)
16 
17     //使用io.copy源文件到目标文件的copy
18     written, err := io.Copy(dstFile, srcFile)
19     if err == nil {
20         fmt.Println("成功，字节数=", written)
21     } else {
22         fmt.Println("失败: ", err)
23     }
24 
25 }

超大文件copy 缓冲式拷贝

 1 //使用缓冲1K的缓冲区 配合 缓冲读取器 进行大图片拷贝
 2 package main
 3 
 4 import (
 5     "bufio"
 6     "fmt"
 7     "io"
 8     "os"
 9 )
10 
11 func main() {
12 
13     //打开拷贝原文件,模式为只读模式。
14     srcFile, _ := os.OpenFile("‪C:/Users/chaoyang.xu/Desktop/0001.jpg", os.O_RDONLY, 0666)
15 
16     //打开目标文件
17     dstFile, _ := os.OpenFile("‪C:/Users/chaoyang.xu/Desktop/0002.jpg", os.O_WRONLY|os.O_CREATE, 0666)
18 
19     //延时关闭文件
20     defer func() {
21         srcFile.Close()
22         dstFile.Close()
23         fmt.Println("文件全部关闭")
24     }()
25 
26     //创建缓冲读取器
27     reader := bufio.NewReader(srcFile)
28 
29     //创建目标文件写出器
30     writer := bufio.NewWriter(dstFile)
31 
32     //创建小缓冲区 大小 1024
33     buffer := make([]byte, 1024)
34 
35     //循环一桶一桶的读入数据到水桶（缓冲区）,直到io.EOF
36     for {
37         _, err := reader.Read(buffer)
38         if err != nil {
39             if err == io.EOF {
40                 fmt.Println("源文件读取完毕.")
41                 break
42             } else {
43                 fmt.Println("读取文件发现错误: ", err)
44                 return
45             }
46         } else {
47             //每桶数据写入到目标
48             _, err := writer.Write(buffer)
49             if err != nil {
50                 fmt.Println("写文件发现错误: ", err)
51                 return
52             }
53         }
54     }
55 
56     fmt.Println("拷贝完毕.")
57 
58 }

字符统计案例

 1 //使用缓冲1K的缓冲区 配合 缓冲读取器 进行大图片拷贝
 2 package main
 3 
 4 import (
 5     "fmt"
 6     "io/ioutil"
 7 )
 8 
 9 func main() {
10 
11     bytes, _ := ioutil.ReadFile("C:/Go/test.txt")
12     contentStr := string(bytes)
13     fmt.Println(contentStr)
14 
15     var numCount, letterCount, spaceCount int
16 
17     //统计0-9,a-z,A-Z,特殊字符个数
18     for _, c := range contentStr {
19         if c >= '0' && c <= '9' {
20             numCount ++
21         } else if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') {
22             letterCount++
23         } else if c == '\n' || c == ' ' || c == '\r' || c == '\t' {
24             spaceCount++
25         }
26     }
27     fmt.Println("numCount= ", numCount)
28     fmt.Println("numCount= ", letterCount)
29     fmt.Println("numCount= ", spaceCount)
30 
31 }
32 /*
33 神龟虽寿，犹有竟时；
34 腾蛇乘雾，终为土灰。
35 老骥伏枥，志在千里；
36 烈士暮年，壮心不已。
37 盈缩之期，不但在天；
38 养怡之福，可得永年。
39 幸甚至哉，歌以咏志。
40 12345
41 54321
42 abc
43 cba
44 numCount=  10
45 numCount=  6
46 numCount=  20
47  */

posted @ 2019-11-28 12:54 chaoyangxu 阅读(217) 评论(0) 收藏举报

刷新页面返回顶部

chaoyang.xu

文件操作

打开和关闭文件

简单打开一个文件

一行一行读取完整文件内容

使用ioutil包 便捷读入

缓冲式写出

便捷写出

检测文件是否存在

简易文件拷贝

使用ioutil包做一个傻瓜式拷贝

使用io.Copy小文件拷贝

超大文件copy 缓冲式拷贝

字符统计案例

公告

使用ioutil包便捷读入