main.go
// Go语言·文件操作
package main
// 包的本质是创建不同的文件夹
// go的每一个文件都是属于一个包的
// go以包的形式管理项目和文件目录。
// import "包的路径"
import (
model "day26/model"
)
var content string = `
————————————————Go语言·文件操作————————————————————
一、文件基本介绍
1.数据源（保存数据数据的地方）
2.文件在程序中是以流的形式来操作。
3.流是数据在数据源(文件)和程序(内存)之间经历的路径
4.输入流:数据从数据源(文件)到程序(内存)的路径
文件------》Go程序（内存）：输入流[读文件]
5.输出流:数据从程序(内存)到数据源(文件)的路径
Go程序（内存）----》文件： 输出流[写文件]
package os.File
import "os"
type File struct{}
File打开的文件对象。或句柄
File说明：
1.文件对象
2.文件指针
3.文件句柄
func (f *File)Read(){}
二、读文件
第一种方式：读取文件，带缓冲，大小文件处理 ，逐行读取，一行一行的处理
import (
"os"
"bufio"
"io"
)
file,err := os.Open(filepath)
defer file.Close()
// *reader 带缓冲
reader := bufio.NewReader(file)
// 循环读取
for {
// 一行一行的读取
str,err := reader.ReadString('\n')
// io.EOF表示文件的末尾
fmt.Print(str)
if err == io.EOF {
break
}
}
第二种方式：一次性的将文件全部内容读取到内存，处理小文件
import "io/ioutil"
不需要显示的开启和关闭文件
文件的开启和关闭 被封装到ReadFile
file,err := ioutil.ReadFile(filepath)
file []byte 切片 string(file)
三、写文件
os.OpenFile(文件名，打开的模式，文件权限)
打开的模式：
os.O_WRONLY|os.O_CREATE 写|创建
os.O_WRONLY|os.O_TRUNC 写|覆盖
O_WRONLY|os.O_APPEND 写|追加
os.O_RDWR|os.O_APPEND 读写|追加
文件权限：
rwx 421
第一种方式：
file,err := os.OpenFile(filepath,os.O_WRONLY|os.O_CREATE,0666)
// 及时关闭句柄，否则会有内存泄漏
defer file.Close()
// *writer 使用带缓存的。
writer := bufio.NewWriter(file)
for i := 0; i < 5; i++ {
writer.WriteString(content)
}
// 将缓存中的数据，写入的文件
writer.Flush()
第二种方式：
var filepath = "D:/日常工作/go/src/day26/data/2.txt"
var newfilepath = "D:/日常工作/go/src/day26/data/3.txt"
data,err := ioutil.ReadFile(filepath)
if err != nil {
fmt.Println("ReadFile:",err)
return
}
err = ioutil.WriteFile(newfilepath, data, 0666)
if err != nil {
fmt.Println("WriteFile:",err)
return
}
三、判断文件或目录是否存在
func exists(path string) (bool, error) {
_, err := os.Stat(path)
if err == nil {
return true, nil
}
if os.IsNotExist(err) {
return false, nil
}
return false, err
}
四、拷贝文件[图片、电影、音频等]
import "io"
func Copy(dst Writer, src Reader) (written int64, err error)
五、统计文件
`
func main() {
model.Entry()
}
modle/FileHandle.go
package model
import (
"fmt"
"os"
"bufio"
"io"
"io/ioutil"
)
/**
* [Init 入口]
* @author Jhou Shuai
* @datetime 2019-05-18T11:58:33+0800
*/
func Entry() {
countFileHandle()
}
/**
* [openFileHandle 打开和关闭文件]
* @author Jhou Shuai
* @datetime 2019-06-10T09:04:52+0800
*/
func openFileHandle() {
// 打开一个文件 open
// file:
// 1.文件对象
// 2.文件指针
// 3.文件句柄
file,err := os.Open("D:\\日常工作\\go\\src\\day26\\data\\1.txt")
if err != nil {
fmt.Println(err)
}
fmt.Printf("file=%v",file)
// 关闭一个文件 close是结构体file的方法
err = file.Close()
if err != nil {
fmt.Println("close fail",err)
}
}
/**
* 读取文件，并显示终端，带缓冲
* 大小文件处理
* 逐行读取，一行一行的处理
*/
func readFileHandle() {
// 打开一个文件
file,err := os.Open("D:\\日常工作\\go\\src\\day26\\data\\1.txt")
if err != nil {
fmt.Println(err)
return
}
//关闭一个文件 ,及时关闭句柄，否则会有内存泄漏
//defer 相关知识，请参考：https://www.jianshu.com/p/2d6f4477a061
// defer 的使用
// 当执行到defer时，暂时不执行，会将defer后的语句压入到独立的栈（defer栈）
// 当函数执行完毕后。再从defer栈 按照先进后出的方式出栈，执行。
// defer最佳实践：
// 创建一个资源后（比如：打开咯一个文件句柄，一个数据连接，或者是锁资源）
// 可以马上执行defer resource.Close()
// 在defer后，任然可以继续使用该资源
// 当函数执行完毕后，系统会依次从defer栈中，取出语句，关闭资源
// 这种机制，非常简洁，不用再为何时关闭资源而烦恼
defer file.Close()
// *reader 带缓冲
reader := bufio.NewReader(file)
// 循环读取
for {
// 一行一行的读取
str,err := reader.ReadString('\n')
// io.EOF表示文件的末尾
fmt.Print(str)
if err == io.EOF {
break
}
}
}
// 一次性的将文件读取到内存
// 处理小文件
func readFileOnce(){
// 不需要显示的开启和关闭文件
// 文件的开启和关闭 被封装到ReadFile
var filename = "D:\\日常工作\\go\\src\\day26\\data\\1.txt"
file,err := ioutil.ReadFile(filename)
if err != nil {
fmt.Printf("err=%v",err)
}
// file []byte 切片 string(file)
fmt.Printf("%v", string(file))
// fmt.Printf("%s", file)
}
// 写文件
func writeFileHandle() {
//1.新建一个文件，写入内容
// var filepath = "D:/日常工作/go/src/day26/data/2.txt"
// os.O_WRONLY|os.O_CREATE
// file,err := os.OpenFile(filepath,os.O_WRONLY|os.O_CREATE,0666)
// if err != nil {
// fmt.Printf("err=%v \n",err)
// return
// }
// // 及时关闭句柄，否则会有内存泄漏
// defer file.Close()
// content := "Hello World\r\n"
// // *writer 使用带缓存的。
// writer := bufio.NewWriter(file)
// for i := 0; i < 5; i++ {
// writer.WriteString(content)
// }
// // 将缓存中的数据，写入的文件
// writer.Flush()
// 2.打开一个已经存在的文件，并覆盖原来的内容。
// var filepath = "D:/日常工作/go/src/day26/data/2.txt"
// // os.O_WRONLY|os.O_TRUNC
// file,err := os.OpenFile(filepath,os.O_WRONLY|os.O_TRUNC,0666)
// if err != nil {
// fmt.Printf("err=%v \n",err)
// return
// }
// // 及时关闭句柄，否则会有内存泄漏
// defer file.Close()
// content := "关闭句柄，否则会有内存泄漏\r\n"
// // *writer 使用带缓存的。
// writer := bufio.NewWriter(file)
// for i := 0; i < 5; i++ {
// writer.WriteString(content)
// }
// // 将缓存中的数据，写入的文件
// writer.Flush()
// 3.打开一个已经存在的文件，并在原来的基础上追加内容。
// var filepath = "D:/日常工作/go/src/day26/data/2.txt"
// // O_WRONLY|os.O_APPEND
// file,err := os.OpenFile(filepath,os.O_WRONLY|os.O_APPEND,0666)
// if err != nil {
// fmt.Printf("err=%v \n",err)
// return
// }
// // 及时关闭句柄，否则会有内存泄漏
// defer file.Close()
// content := "\t————帅哥哥\r\n"
// // *writer 使用带缓存的。
// writer := bufio.NewWriter(file)
// writer.WriteString(content)
// // 将缓存中的数据，写入的文件
// writer.Flush()
// 4.打开一个已经存在的文件，并在原来的基础上追加内容。并显示终端
// var filepath = "D:/日常工作/go/src/day26/data/2.txt"
// // os.O_RDWR|os.O_APPEND
// file,err := os.OpenFile(filepath,os.O_RDWR|os.O_APPEND,0666)
// if err != nil {
// fmt.Printf("err=%v \n",err)
// return
// }
// // 及时关闭句柄，否则会有内存泄漏
// defer file.Close()
// // 显示终端
// reader :=bufio.NewReader(file)
// for {
// str,err := reader.ReadString('\n')
// if err == io.EOF {
// break
// }
// fmt.Print(str)
// }
// // 追加新内容
// content := "\t————小美眉\r\n"
// // *writer 使用带缓存的。
// writer := bufio.NewWriter(file)
// writer.WriteString(content)
// // 将缓存中的数据，写入的文件
// writer.Flush()
var filepath = "D:/日常工作/go/src/day26/data/2.txt"
var newfilepath = "D:/日常工作/go/src/day26/data/3.txt"
data,err := ioutil.ReadFile(filepath)
if err != nil {
fmt.Println("ReadFile:",err)
return
}
err = ioutil.WriteFile(newfilepath, data, 0666)
if err != nil {
fmt.Println("WriteFile:",err)
return
}
}
/**
* [copyFileHandle 文件拷贝]
* @author Jhou Shuai
* @datetime 2019-06-10T12:26:37+0800
* func Copy(dst Writer, src Reader) (written int64, err error)
*/
func copyFileHandle() {
var dst string = "D:/日常工作/go/src/day26/data/帅.png"
var src string = "D:/生活娱乐/帅哥WIN10系统截图.png"
srcFile ,err := os.Open(src)
if err != nil {
fmt.Println("OPEN ERR:",err)
return
}
defer srcFile.Close()
reader := bufio.NewReader(srcFile)
dstFile,err := os.OpenFile(dst,os.O_WRONLY|os.O_CREATE,0666)
if err != nil {
fmt.Println("OpenFile ERR:",err)
return
}
defer dstFile.Close()
writer := bufio.NewWriter(dstFile)
if _, err = io.Copy(writer, reader); err != nil {
fmt.Println("Copy ERR:",err)
return
}
fmt.Println("拷贝成功！")
}
type charCount struct {
chCount int
NumCount int
SpaceCount int
OtherCount int
}
func countFileHandle() {
// 打开一个文件，创建一个reader
// 每读取一行，就去统计该行有多少英文、数字、空格和其他字符
// 然后将结果保存到一个结构体
var filepath = "D:/日常工作/go/src/day26/data/2.txt"
file,err := os.Open(filepath)
if err != nil {
fmt.Println("文件打不开，",err)
return
}
defer file.Close()
var count charCount
reader := bufio.NewReader(file)
for {
str, err := reader.ReadString('\n')
// 遍历str，进行统计
for _,val := range []rune(str){
switch {
case val >= 'a' && val <= 'z':
fallthrough
case val >= 'A' && val <= 'Z':
count.chCount++
case val == '\t' || val == ' ':
count.SpaceCount++
case val >='0' && val <= '9':
count.NumCount++
default:
count.OtherCount++
}
}
if err == io.EOF {
break;
}
}
fmt.Printf("字母：%v,空格：%v,数字：%v，其他：%v \n",
count.chCount,
count.SpaceCount,
count.NumCount,
count.OtherCount)
}
/**
* [exists 判断文件或目录是否存在]
* @author Jhou Shuai
* @datetime 2019-06-10T12:24:19+0800
*/
func exists(path string) (bool, error) {
_, err := os.Stat(path)
if err == nil {
return true, nil
}
if os.IsNotExist(err) {
return false, nil
}
return false, err
}
网友评论