goland 文件操作

打开和关闭文件

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

简单打开一个文件

//简易方式打开一个文件,拿着一顿骚操作,一秒后关闭
package main

import (
    "fmt"
    "os"
    "time"
)

func main() {
    file, err := os.Open("C:/Go/test1.txt")
    if err == nil {
        fmt.Println("文件打开成功..")
    } else {
        fmt.Println("文件打开失败,失败内容是:", err)
        return
    }

    //defer关闭文件
    defer func() {
        file.Close()
        fmt.Println("文件已关闭..")
    }()

    //模拟文件操作
    time.Sleep(1 * time.Second)
    fmt.Println("文件是", file)

}

/*
文件打开成功..
文件是 &{0xc00006a780}
文件已关闭..

文件打开失败,失败内容是: open C:/Go/test1.txt: The system cannot find the file specified.
*/
一行一行读取完整文件内容

//以只读方式打开一个文件,创建其带缓冲的读取器,读取文件到末尾.
package main

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

func main() {
    //以只读方式,并且文件权限以666访问.
    file, err := os.OpenFile("C:/Go/test.txt", os.O_RDONLY, 0666)
    if err == nil {
        fmt.Println("文件打开成功")
    } else {
        fmt.Println("文件打开失败,err:", err)
        return
    }

    defer func() {
        file.Close()
        fmt.Println("文件已关闭")
    }()

    //创建其带缓冲的读取器
    reader := bufio.NewReader(file)

    //整体循环读取整个文件.
    for {
        str, err := reader.ReadString('\n') //一行一行的读取
        if err == nil {
            fmt.Println(str)
        } else {

            //如果错误是已到文件末尾,就输出信息
            if err == io.EOF {
                fmt.Println("已到文件末尾")
                break //读取完毕后 跳出循环,继续往下走.
            }

            fmt.Println("文件读取错误: ", err)
            return //异常错误,就退出
        }

    }
    fmt.Println("文件读取完毕.")
}

/*
文件打开成功
神龟虽寿，犹有竟时；

腾蛇乘雾，终为土灰。

老骥伏枥，志在千里；

烈士暮年，壮心不已。

盈缩之期，不但在天；

养怡之福，可得永年。

已到文件末尾
文件读取完毕.
文件已关闭
 */

使用ioutil包 便捷读入

//使用ioutil包对test.txt进行简易读取.
//自动会进行关闭.
package main

import (
    "fmt"
    "io/ioutil"
)

func main() {

    //读入指定文件的全部数据,返回[]byte类型的原始数据
    bytes, err := ioutil.ReadFile("C:/Go/test.txt")
    if err == nil {
        contentStr := string(bytes) //字节转换成字符串
        fmt.Println(contentStr)
    } else {
        fmt.Println("读取失败: ", err)
    }
}

/*
神龟虽寿，犹有竟时；
腾蛇乘雾，终为土灰。
老骥伏枥，志在千里；
烈士暮年，壮心不已。
盈缩之期，不但在天；
养怡之福，可得永年。
幸甚至哉，歌以咏志。
 */

缓冲式写出

//以创写追加或创写覆盖方法打开一个文件,缓冲式写出几行数据,倒干缓冲区后退出。
package main

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

func main() {
    //如果文件不存在,就创建|只能写不能读|数据追加 = 【创-写-追加 模式】
    file, err := os.OpenFile("C:/Go/test001.txt", os.O_CREATE|os.O_RDONLY|os.O_APPEND, 0666)

    //如果有异常,直接退出
    if err != nil {
        fmt.Println("文件打开失败: ", err)
        return
    }

    //延时关闭文件.
    defer func() {
        file.Close()
        fmt.Println("文件已关闭")
    }()

    //创建写出缓冲器
    writer := bufio.NewWriter(file)

    //分批次的写一些数据
    writer.WriteString("女人四大愿望\n")
    writer.WriteString("男人脑壳都坏掉\n")
    writer.WriteString("天天给我送钞票\n")
    writer.WriteString("还要排队等我挑\n")
    writer.WriteString("永远青春不变老\n")
    writer.WriteRune('你')
    writer.WriteByte(123)
    writer.Write([]byte{123, 124, 125})

    //倒干缓冲区
    writer.Flush()
    fmt.Println("写出完毕")
}

便捷写出
//这个是调用的os.openfile ,封装的。

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {

    //``保留原始格式
    dataStr := `窗前明月光
                疑是地上霜
                举头望明月`

    //字符串转为字节类型
    dataBytes := []byte(dataStr)

    err := ioutil.WriteFile("C:/Go/test001.txt", dataBytes, 0666)
    if err != nil {
        fmt.Println("发生了错误: ", err)
    } else {
        fmt.Println("写出成功")
    }
}

检测文件是否存在

package main

import (
    "fmt"
    "os"
)

func main() {

    info, err := os.Stat("C:/Go/test001.txt")

    //判断是否有错误
    if err != nil {
        fmt.Println("err:", err)

        //判断是否是 文件存在的错误
        if os.IsNotExist(err) {
            fmt.Println("文件不存在")
        }
    } else {
        fmt.Println("文件存在")
        fmt.Println(info.Name(),info.IsDir())
    }
}
/*
文件存在
test001.txt false
 */

简易文件拷贝

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

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

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    bytes, _ := ioutil.ReadFile("‪C:/Go/off.jpg")
    err := ioutil.WriteFile("‪C:/Go/off002.jpg", bytes, 0666)
    if err == nil {
        fmt.Println("拷贝成功")
    } else {
        fmt.Println("拷贝失败", err)
    }
}

使用io.Copy小文件拷贝

package main

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

func main() {

    //打开拷贝原文件,模式为只读模式。
    srcFile, _ := os.OpenFile("‪C:/Go/off.jpg", os.O_RDONLY, 0666)

    //打开要拷贝到的目标文件,模式为写和追加。
    dstFile, _ := os.OpenFile("‪C:/Go/off002.jpg", os.O_WRONLY|os.O_CREATE, 0666)

    //使用io.copy源文件到目标文件的copy
    written, err := io.Copy(dstFile, srcFile)
    if err == nil {
        fmt.Println("成功，字节数=", written)
    } else {
        fmt.Println("失败: ", err)
    }

}

超大文件copy 缓冲式拷贝

//使用缓冲1K的缓冲区 配合 缓冲读取器 进行大图片拷贝
package main

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

func main() {

    //打开拷贝原文件,模式为只读模式。
    srcFile, _ := os.OpenFile("‪C:/Users/chaoyang.xu/Desktop/0001.jpg", os.O_RDONLY, 0666)

    //打开目标文件
    dstFile, _ := os.OpenFile("‪C:/Users/chaoyang.xu/Desktop/0002.jpg", os.O_WRONLY|os.O_CREATE, 0666)

    //延时关闭文件
    defer func() {
        srcFile.Close()
        dstFile.Close()
        fmt.Println("文件全部关闭")
    }()

    //创建缓冲读取器
    reader := bufio.NewReader(srcFile)

    //创建目标文件写出器
    writer := bufio.NewWriter(dstFile)

    //创建小缓冲区 大小 1024
    buffer := make([]byte, 1024)

    //循环一桶一桶的读入数据到水桶（缓冲区）,直到io.EOF
    for {
        _, err := reader.Read(buffer)
        if err != nil {
            if err == io.EOF {
                fmt.Println("源文件读取完毕.")
                break
            } else {
                fmt.Println("读取文件发现错误: ", err)
                return
            }
        } else {
            //每桶数据写入到目标
            _, err := writer.Write(buffer)
            if err != nil {
                fmt.Println("写文件发现错误: ", err)
                return
            }
        }
    }

    fmt.Println("拷贝完毕.")

}

字符统计案例

//使用缓冲1K的缓冲区 配合 缓冲读取器 进行大图片拷贝
package main

import (
    "fmt"
    "io/ioutil"
)

func main() {

    bytes, _ := ioutil.ReadFile("C:/Go/test.txt")
    contentStr := string(bytes)
    fmt.Println(contentStr)

    var numCount, letterCount, spaceCount int

    //统计0-9,a-z,A-Z,特殊字符个数
    for _, c := range contentStr {
        if c >= '0' && c <= '9' {
            numCount ++
        } else if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') {
            letterCount++
        } else if c == '\n' || c == ' ' || c == '\r' || c == '\t' {
            spaceCount++
        }
    }
    fmt.Println("numCount= ", numCount)
    fmt.Println("numCount= ", letterCount)
    fmt.Println("numCount= ", spaceCount)

}
/*
神龟虽寿，犹有竟时；
腾蛇乘雾，终为土灰。
老骥伏枥，志在千里；
烈士暮年，壮心不已。
盈缩之期，不但在天；
养怡之福，可得永年。
幸甚至哉，歌以咏志。
12345
54321
abc
cba
numCount=  10
numCount=  6
numCount=  20
 */

赏 支付宝打赏 微信打赏

如果文章或资源对您有帮助，欢迎打赏作者。一路走来，感谢有您！