go 文件操作

1.

package main

import (
    "fmt"
    "os"
)

func main(){
//file指针
    file,err:=os.Open("d:/test.txt")
    if err!=nil{
        fmt.Println("open file err=",err)
    }
    //输出文件
    fmt.Printf("file=%v",file)
    err=file.Close()
    if err!=nil{
        fmt.Println("close file err=",err)
    }
}

2.逐行读取

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)
//逐行读取
func main() {
    file, err := os.Open("d:/test.txt")
    if err != nil {
        fmt.Println("open file err=", err)
    }
    defer file.Close()
    const
    (
        defaultltBufSize = 4096 //默认缓冲区为4096
    )

    reader := bufio.NewReader(file)
    //循环读取文件的内容
    for {
        str, err := reader.ReadString('
') //读取到一个换行就结束
        fmt.Print(str)
        if err == io.EOF {
            break
        }

    }

}

3.一次性读取所有，不适用大文件

package main

import (
    "fmt"
    "io/ioutil"
)

func main(){
    //使用ioutil.ReadFile,一次性将文件读取到位
    file:="d:/test.txt"
    content,err:=ioutil.ReadFile(file)
if err!=nil{
    fmt.Printf("read file err=%v",err)
}
fmt.Printf("%v",string(content))
}

4.创建文件并写入

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main(){
    //创建文件并写入
    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
",err)
        return
    }


    defer file.Close()
    str:="hello gardon
"
    writer:=bufio.NewWriter(file)
    for i:=0;i<5;i++{
        writer.WriteString(str)
    }
    writer.Flush()
}

5.对文件覆写

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main(){
    //覆盖文件内容
    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
",err)
        return
    }


    defer file.Close()
    str:="hello kitty
"
    writer:=bufio.NewWriter(file)
    for i:=0;i<5;i++{
        writer.WriteString(str)
    }
    writer.Flush()
}

6.追加内容

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main(){
    //追加文件内容
    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
",err)
        return
    }


    defer file.Close()
    str:="我是追加内容
"
    writer:=bufio.NewWriter(file)
    for i:=0;i<5;i++{
        writer.WriteString(str)
    }
    writer.Flush()
}

7.读取后追加内容

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main(){
    //先读取后追加文件内容
    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
",err)
        return
    }


    defer file.Close()
    str:="我是读取后追加内容
"
    writer:=bufio.NewWriter(file)
    for i:=0;i<5;i++{
        writer.WriteString(str)
    }
    writer.Flush()
}

8.将一个文件的内容写入到另一个文件

package main

import (
    "fmt"
    "io/ioutil"
)

func main(){

    //将一个文件的内容写入另外一个文件
    filepath:="d:/abc.txt"
    filepath2:="d:/kkk.txt"
    data,err:=ioutil.ReadFile(filepath)
    if err!=nil{
        fmt.Printf("read file err=%v",err)
        return
    }
    err=ioutil.WriteFile(filepath2,data,0666)
    if err!=nil{
        fmt.Printf("write file err=%v
",err)
    }

}

9.判断文件，文件夹是否存在

package main

import (
    "fmt"
    "os"
)

func main() {
fmt.Println(PathExists("d:/"))
}

//判断文件.或文件夹是否存在
func PathExists(path string) (bool, error) {
    _, err := os.Stat(path)
    if err == nil {
        return true, nil
    }
    if os.IsNotExist(err) {
        return false, nil
    }
    return false, nil
}

10.文件拷贝

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

//文件拷贝
func CopyFile(dstFileName string, srcFileName string) (written int64, err error) {
    srcFile, err := os.Open(srcFileName)
    if err != nil {
        fmt.Printf("open file err=%v
", err)
    }
    defer srcFile.Close()
    reader := bufio.NewReader(srcFile)
    dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Printf("open file err=%v
", err)
        return
    }
    writer := bufio.NewWriter(dstFile)
    defer dstFile.Close()
    return io.Copy(writer, reader)
}

func main() {
    srcFile:="d:/flower.jpg"
    dstFile:="e:/abc.jpg"
    _,err:=CopyFile(dstFile,srcFile)
    if err==nil{
        fmt.Print("拷贝完成
")
    }else{
        fmt.Printf("拷贝错误err=%v",err)
    }
}

11.统计字符个数

package main
import (
    "fmt"
    "os"
    "io"
    "bufio"
)

//定义一个结构体，用于保存统计结果
type CharCount struct {
    ChCount int // 记录英文个数
    NumCount int // 记录数字的个数
    SpaceCount int // 记录空格的个数
    OtherCount int // 记录其它字符的个数
}

func main() {

    //思路: 打开一个文件, 创一个Reader
    //每读取一行，就去统计该行有多少个 英文、数字、空格和其他字符
    //然后将结果保存到一个结构体
    fileName := "d:/abc.txt"
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Printf("open file err=%v
", err)
        return
    }
    defer file.Close()
    //定义个CharCount 实例
    var count CharCount
    //创建一个Reader
    reader := bufio.NewReader(file)

    //开始循环的读取fileName的内容
    for {
        str, err := reader.ReadString('
')
        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 == '	':
                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)


}

 12.文件信息

package main

import (
    "fmt"
    "os"
)

func main() {
    //绝对路径
    path := "D:\15.jpg"
    printMessage(path)
}
func printMessage(filepath string) {
    //
    fileInfo, err := os.Stat(filepath)
    if err != nil {
        fmt.Println("err:", err.Error())
    } else {
        fmt.Printf("数据类型是:%T
", fileInfo)
        fmt.Println("文件名：", fileInfo.Name())
        fmt.Println("是否为目录:", fileInfo.IsDir())
        fmt.Println("大小:", fileInfo.Size())
        fmt.Println("文件权限：", fileInfo.Mode())
        fmt.Println("文件最后修改时间：", fileInfo.ModTime())
    }
}

13.文件路径

//文件路径相关方法
func pathIn(){
    //绝对路径
    filePath1:="D:\goproj\src\go_code\test\file_1\15.jpg"
    //项目根目录
    filePath2:="test\file_1\15.jpg"
    pathInfo1,_:=os.Stat(filePath1)
    pathInfo2,_:=os.Stat(filePath2)
    fmt.Println(pathInfo1.Name())
    fmt.Println(pathInfo2.Name())
fmt.Println(filepath.IsAbs(filePath1))
fmt.Println(filepath.IsAbs(filePath2))
    //获取相对路径
fmt.Println(filepath.Rel("D:\goproj\src\go_code",filePath1))
    //获取绝对路径
fmt.Println(filepath.Abs(filePath1))
fmt.Println(filepath.Abs(filePath2))
//拼接路径
fmt.Println(filepath.Join(filePath2,".."))
fmt.Println(filepath.Join("D:\goproj\src\go_code\",filePath2))

}

 创建目录

//目录操作
func dirOpte(){
fileName1:="d:/test1"
//创建目录一层
err:=os.Mkdir(fileName1,os.ModePerm)
if err!=nil{
    fmt.Println(err)
}
//创建多级目录
fileName2:="d:/tt/aa/bb"
err=os.MkdirAll(fileName2,os.ModePerm)
    if err!=nil{
        fmt.Println(err)
    }
}

 ioutil

//ioutil使用
func main() {
    fileName1 := "D:/tt/a.txt"
    fileName2 := "D:/tt/c.txt"
    //打开文件
    data, err := ioutil.ReadFile(fileName1)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(string(data))
    s1 := "Steven教你学区块链"
    ioutil.WriteFile(fileName1, []byte(s1), os.ModePerm)
    //文件复制
    ioutil.WriteFile(fileName2, data, os.ModePerm)
    //遍历目录
    dirName := "D:/tt/"
    fileInfos, err := ioutil.ReadDir(dirName)
    if err != nil {
        fmt.Println(err)
    }
    for _, v := range fileInfos {
        fmt.Printf("name=%v,size=%v,isdir=%v,permod=%v
", v.Name(), v.Size(), v.IsDir(), v.Mode())
    }
    //创建目录,名字会被补充随机字符串
    filename, _ := ioutil.TempDir(dirName, "aa")
    fmt.Println(filename)

    //创建文件,名字会被补充随机字符串
    ioutil.TempFile(dirName, "te")
}

bufio

func testReader() {
    fileName1 := "D:/tt/a.txt"
    //判断文件是否存在
    fi, err := os.Stat(fileName1)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(fi)
    //打开文件
    file1, err := os.Open(fileName1)
    if err != nil {
        fmt.Println(err)
    }
    //创建缓存区
    reader1 := bufio.NewReader(file1)
    fmt.Printf("%T
", reader1)

    for {
        //以
分隔读取
        s1, err := reader1.ReadString('
')
        fmt.Println(s1)
        if err != nil {
            fmt.Println("读取完毕")
            break
        }
    }
}
//内容复制
func testWriter() {
    fileName2 := "D:/tt/a.txt"
    //打开文件
    file2, _ := os.Open(fileName2)
    //创建读取缓存区
    reader2 := bufio.NewReader(file2)
    fileName3 := "D:/tt/c.txt"
    //打开文件
    file3, _ := os.OpenFile(fileName3, os.O_WRONLY|os.O_CREATE, os.ModePerm)
    //创建写缓存区
    writer1:=bufio.NewWriter(file3)
    for {
        //将读取到的数据写入另一个文件
        bs, err := reader2.ReadBytes(' ')
        writer1.Write(bs)
        writer1.Flush()
        if err == io.EOF {
            fmt.Println("文件读取完毕")
            break
        }
    }
    file2.Close()
    file3.Close()
}

 scanner

//scanner使用
//读取数据
func scantest() {
    //创建Scanner对象
    reader1 := bufio.NewReader(strings.NewReader("abcdefg 1000phone blockchain ready go"))
    //创建scanner对
    scanner := bufio.NewScanner(reader1)
    //指定分隔方法，按照空格进行拆分
    scanner.Split(bufio.ScanWords)
    //循环读取
    for scanner.Scan() {
        fmt.Println(scanner.Text())
        if scanner.Text() == "q!" {
            break
        }
    }
}

...