「GO标准库」path/filepath 包的全面解析

path 包可以用来做什么？

path 包：这是一个标准库中的包，提供了一些基本的函数来处理文件路径，例如判断路径类型、分割路径、获取文件名等。它提供了一些基本的文件操作功能，可以满足大多数情况下的需求。

filepath 包可以用来做什么？

filepath 包：这个包是 path 包的扩展，提供了一些更高级的功能，例如使用操作系统特定的分隔符、处理符号链接等。与 path 包相比，filepath 包更加强大，但同时也更加复杂。它可以兼容不同操作系统的文件路径，并允许操作系统特定的细节被库抽象出来，这有助于实现代码的可移植性。

path 包和 filepath 包的区别

在 Go 语言中，path 包和 filepath 包都是用于处理文件路径的，但它们之间存在一些区别。

• path 包：这是一个标准库中的包，提供了一些基本的函数来处理文件路径，例如判断路径类型、分割路径、获取文件名等。它提供了一些基本的文件操作功能，可以满足大多数情况下的需求。
• filepath 包：这个包是 path 包的扩展，提供了一些更高级的功能，例如使用操作系统特定的分隔符、处理符号链接等。与 path 包相比，filepath 包更加强大，但同时也更加复杂。它可以兼容不同操作系统的文件路径，并允许操作系统特定的细节被库抽象出来，这有助于实现代码的可移植性。

总的来说，path、filepath 包是处理文件路径的重要工具，它们提供了一系列实用函数来帮助我们进行路径的解析和操作。

注意：path 包中的函数，部分在 filepath 中也可以直接使用哦

常用的 path 包函数

path.Base: 返回路径的最后一个元素

import (
    "fmt"
    "path"
)

func main() {
    fmt.Println(path.Base("/a/b"))
    fmt.Println(path.Base("/"))
    fmt.Println(path.Base(""))
    // Output:
    // b
    // /
    // .
}

path.Clean: 返回与路径等效的最短路径名：即会将.，..以及多余的/进行解析

import (
    "fmt"
    "path"
)

func main() {
    paths := []string{
       "a/c",
       "a//c",
       "a/c/.",
       "a/c/b/..",
       "/../a/c",
       "/../a/b/../././/c",
       "",
    }

    for _, p := range paths {
       fmt.Printf("Clean(%q) = %q\n", p, path.Clean(p))
    }

    // Output:
    // Clean("a/c") = "a/c"
    // Clean("a//c") = "a/c"
    // Clean("a/c/.") = "a/c"
    // Clean("a/c/b/..") = "a/c"
    // Clean("/../a/c") = "/a/c"
    // Clean("/../a/b/../././/c") = "/a/c"
    // Clean("") = "."
}

path.Split: 在最后一个斜杠之后立即拆分路径，返回一个目录路径和文件路径

import (
    "fmt"
    "path"
)

func main() {
    split := func(s string) {
       dir, file := path.Split(s)
       fmt.Printf("path.Split(%q) = dir: %q, file: %q\n", s, dir, file)
    }
    split("static/myfile.css")
    split("myfile.css")
    split("")
    // Output:
    // path.Split("static/myfile.css") = dir: "static/", file: "myfile.css"
    // path.Split("myfile.css") = dir: "", file: "myfile.css"
    // path.Split("") = dir: "", file: ""
}

path.Join: 将多个路径拼接成一个路径，并返回拼接后的结果

import (
    "fmt"
    "path"
)

func main() {
    fmt.Println(path.Join("a", "b", "c"))
    fmt.Println(path.Join("a", "b/c"))
    fmt.Println(path.Join("a/b", "c"))

    fmt.Println(path.Join("a/b", "../../../xyz"))

    fmt.Println(path.Join("", ""))
    fmt.Println(path.Join("a", ""))
    fmt.Println(path.Join("", "a"))

    // Output:
    // a/b/c
    // a/b/c
    // a/b/c
    // ../xyz
    //
    // a
    // a
}

path.Ext: 返回路径使用的文件扩展名

import (
    "fmt"
    "path"
)

func main() {
    fmt.Println(path.Ext("/a/b/c/bar.css"))
    fmt.Println(path.Ext("/"))
    fmt.Println(path.Ext(""))
    // Output:
    // .css
    //
    //
}

path.IsAbs: 报告路径是否为绝对路径

import (
    "fmt"
    "path"
)

func main() {
    fmt.Println(path.IsAbs("/dev/null"))
    // Output: true
}

path.Dir: 返回路径的最后一个元素以外的所有元素，通常是路径的目录

import (
    "fmt"
    "path"
)

func main() {
    fmt.Println(path.Dir("/a/b/c"))
    fmt.Println(path.Dir("a/b/c"))
    fmt.Println(path.Dir("/a/"))
    fmt.Println(path.Dir("a/"))
    fmt.Println(path.Dir("/"))
    fmt.Println(path.Dir(""))
    // Output:
    // /a/b
    // a/b
    // /a
    // a
    // /
    // .
}

path.Match: 用正则的方式用于路径的模式匹配

import (
    "fmt"
    "path"
)

func main() {
    split := func(s string) {
       dir, file := path.Split(s)
       fmt.Printf("path.Split(%q) = dir: %q, file: %q\n", s, dir, file)
    }
    split("static/myfile.css")
    split("myfile.css")
    split("")
    // Output:
    // path.Split("static/myfile.css") = dir: "static/", file: "myfile.css"
    // path.Split("myfile.css") = dir: "", file: "myfile.css"
    // path.Split("") = dir: "", file: ""
}

常用的 filepath 包函数

filepath.SplitList: 用于将一个路径按照指定的操作系统特定的路径列表分隔符进行分割，返回一个切片

import (
    "fmt"
    "path/filepath"
)

func main() {
    p := "/usr/local/bin/include/lib/clang"
    chunks := filepath.SplitList(p)
    fmt.Println(chunks) // ["", "usr", "local", "bin", "include", "lib", "clang"]
}

filepath.VolumeName: 获取文件路径中的卷名

package main

import (
    "fmt"
    "path/filepath"
)

func main() {
    path := "/mnt/data/test.txt"
    volumeName := filepath.VolumeName(path)
    fmt.Println(volumeName) // 输出： mnt
}

filepath.Walk: 用于遍历指定目录下的所有文件和子目录。它返回一个迭代器，每次迭代会返回一个包含当前路径、当前路径下的文件名列表和错误信息的元组

package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    err := filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if !info.IsDir() {
            fmt.Println(path)
        }
        return nil
    })

    if err != nil {
        fmt.Println(err)
    }
}

filepath.Glob: 用于匹配指定目录下的文件名。它返回一个字符串切片，包含所有匹配到的文件名

package main

import (
    "fmt"
    "log"
    "os"
    "path/filepath"
)

func main() {
    files, err := filepath.Glob("*.txt")
    if err != nil {
        log.Fatal(err)
    }

    for _, file := range files {
        content, err := os.ReadFile(file)
        if err != nil {
            log.Println(err)
            continue
        }
        fmt.Printf("文件名： %s, 内容： %s ", file, string(content))
    }
}

结束语

主要列举了 path、filepath 包常用的一些函数，还有一部分没有举例到，如果有遗漏的请自行翻查 Golang 源码进行查阅。