一、文件读取

1.1 一次性读取数据

Go 语言提供了多种方式来读取文件。以下是一种常见的方法：

首先，使用 os 包中的 Open 函数打开文件，并获取一个文件句柄。然后，通过文件句柄使用 Read 或 ReadString 等函数读取文件内容。最后，关闭文件以释放资源。

以下是一个简单的示例代码：

package main
import (
    "fmt"
    "os"
)
func main() {
    // 打开文件
    file, err := os.Open("example.txt")
    if err!= nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close() // 延迟关闭文件
    // 读取文件内容
    content, err := io.ReadAll(file)
    if err!= nil {
        fmt.Println("Error reading file:", err)
        return
    }
    // 打印文件内容
    fmt.Println("File content:", string(content))
}

在上述示例中，我们打开了一个名为 example.txt 的文件，并使用 io.ReadAll 函数读取文件的全部内容。然后，我们将内容转换为字符串并打印出来。

请确保将 example.txt 替换为你实际要读取的文件的路径。此外，还可以根据需要使用其他文件操作函数，如逐行读取、指定偏移量读取等。

通过ReadFile方法进行一次性读取

byteData, _ := os.ReadFile("example.txt")
fmt.Println(string(byteData))

1.2 分片读取

除了一次性读取整个文件的内容，Go 语言还允许我们以分片的方式读取文件。通过指定每次读取的字节数或行数，可以更灵活地处理大文件。

以下是一个示例，展示了如何分片读取文件：

package main
import (
    "fmt"
    "io"
    "os"
)
func main() {
    // 打开文件
    file, err := os.Open("example.txt")
    if err!= nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close() // 延迟关闭文件
    // 创建缓冲区
    buffer := make([]byte, 1024)
    for {
        // 读取分片内容到缓冲区
        n, err := file.Read(buffer)
        if err == io.EOF {
            break
        }
        if err!= nil {
            fmt.Println("Error reading file:", err)
            return
        }
        fmt.Printf("%s", buf)
    }
}

在上述示例中，我们使用一个固定大小的字节缓冲区 buffer 来分片读取文件。每次读取指定数量的字节，并根据需要进行处理。当达到文件末尾时，file.Read 函数会返回 io.EOF，此时可以结束读取过程。

通过分片读取，我们可以在处理大文件时避免一次性将所有内容加载到内存中，从而提高性能和资源利用率。根据实际需求，你可以调整缓冲区的大小和处理分片内容的方式。

1.3 带缓冲读

按行读取

file, _ := os.Open("example.txt")
buf := bufio.NewReader(file)
for {
  line, _, err := buf.ReadLine()
  fmt.Println(string(line))
  if err != nil {
    break
  }
}

指定分割符

file, _ := os.Open("example.txt")
scanner := bufio.NewScanner(file)
scanner.Split(bufio.ScanWords) // 按照单词读
//scanner.Split(bufio.ScanLines) // 按照行读
//scanner.Split(bufio.ScanRunes) // 按照中文字符读
//scanner.Split(bufio.ScanBytes) // 按照字节读读，中文会乱码

for scanner.Scan() {
  fmt.Println(scanner.Text())
}

二、文件写入

2.1 一次性写入

以下是一个示例，展示了如何一次性将内容写入文件：

data := "这是要写入文件的内容。"
file, err := os.Create("output.txt")
if err!= nil {
    fmt.Println("创建文件时出错:", err)
    return
}
_, err = file.WriteString(data)
if err!= nil {
    fmt.Println("写入文件时出错:", err)
    return
}
file.Close()

在这个示例中，我们首先创建一个名为 output.txt 的文件。然后，使用 file.WriteString 方法将指定的文本内容一次性写入文件。最后，关闭文件。

如果在创建文件或写入文件时发生错误，我们会打印出相应的错误信息。

请确保在写入文件后关闭文件，以释放相关资源并确保数据的完整性。

采用WriteFile进行一次性写入

err := os.WriteFile("output.txt", []byte("这是内容"), os.ModePerm)
fmt.Println(err)

文件的常见打开方式

// 如果文件不存在就创建
os.O_CREATE|os.O_WRONLY
// 追加写
os.O_APPEND|os.O_WRONLY
// 可读可写
os.O_RDWR

2.2 文件copy

以下是一个示例，展示了如何使用 io.Copy 函数来复制文件：

sourceFile, err := os.Open("source.txt")
if err!= nil {
    fmt.Println("打开源文件时出错:", err)
    return
}
destinationFile, err := os.Create("destination.txt")
if err!= nil {
    fmt.Println("创建目标文件时出错:", err)
    return
}
_, err = io.Copy(destinationFile, sourceFile)
if err!= nil {
    fmt.Println("复制文件时出错:", err)
    return
}
sourceFile.Close()
destinationFile.Close()

在这个示例中，我们打开源文件和目标文件，并使用 io.Copy 函数将源文件的内容复制到目标文件中。最后，关闭两个文件。

如果在打开文件或复制文件时发生错误，我们会打印出相应的错误信息。

通过使用 io.Copy，我们可以方便地进行文件复制操作，而无需手动处理文件读写的细节。

三、目录

3.1 目录操作

我们可以使用 os 包中的函数来进行目录操作，例如创建、删除、遍历目录等。以下是一些常见的目录操作示例：

创建目录：

err := os.Mkdir("new_directory", os.ModePerm)
if err!= nil {
    fmt.Println("创建目录时出错:", err)
    return
}

删除目录：

err := os.RemoveAll("directory_to_delete")
if err!= nil {
    fmt.Println("删除目录时出错:", err)
    return
}

遍历目录：

files, err := os.ReadDir("directory")
if err!= nil {
    fmt.Println("读取目录时出错:", err)
    return
}
for _, file := range files {
    fmt.Println(file.Name())
}

这些示例展示了一些基本的目录操作。在实际应用中，根据具体需求，可以使用更多的 os 函数来完成更复杂的目录操作。

3.2 获取当前go文件的路径

要获取当前 Go 代码文件的路径，可以使用 runtime 包中的 Caller 函数。以下是一个示例：

package main
import (
    "fmt"
    "runtime"
)
func getPath() {
    _, file, line, _ := runtime.Caller(0)
    path := fmt.Sprintf("%s:%d", file, line)
    fmt.Println("当前文件路径:", path)
}
func main() {
    getPath()
}

在上述代码中，定义了一个 getPath 函数，它使用 runtime.Caller(0) 获取调用该函数的代码的文件名和行号。然后，使用 fmt.Sprintf 格式化文件名和行号，并将结果打印出来。

在 main 函数中调用 getPath 函数，即可获取并打印出当前 Go 代码文件的路径。

请注意，Caller 函数返回的是调用者的信息，因此在调用 getPath 函数时，它会返回调用 getPath 函数的代码的文件路径。如果需要在其他函数中获取当前文件路径，可以在该函数中调用 getPath 函数。