一、Path包

import "path"

path实现了对斜杠分隔的路径进行操作的函数。

• func IsAbs(path string) bool // 判断是否是一个绝对路径

• func Split(path string) (dir, file string) // 将路径分割为路径和文件名

• func Join(elem …string) string // 将多个字符串合并为一个路径

• func Ext(path string) string // 返回路径中扩展部分

• func Base(path string) string // 返回路径的最后一个元素

• func Dir(path string) string // 返回路径中目录部分

• func Clean(path string) string // 返回同目录的最短路径

• func Match(pattern, name string) (matched bool, err error) // 正则是否匹配路径（shell 文件名匹配）

示例代码

func main() {
pt := "E:/go"

// 判断是否是一个绝对路径  
is\_abs := path.IsAbs(pt)  
fmt.Println(is\_abs) // false linux中以/开头为根路径

// 将路径分割为路径和文件名  
pf := "E:/go/project/src/go\_dev/go\_path/main.go"  
dir, file := path.Split(pf)  
fmt.Println(dir, file) // E:/go/project/src/go\_dev/go\_path/ main.go

// 将多个字符串合并为一个路径  
dir\_join := path.Join("E:/go", "project", "src")  
fmt.Println(dir\_join) // E:/go/project/src

// 返回路径中扩展  
file\_ext := path.Ext(pf)  
fmt.Println(file\_ext) // .go

// 返回路径的最后一个元素  
dir\_base := path.Base(pf)  
fmt.Println(dir\_base) // main.go

// 返回路径中目录部分  
dir = path.Dir(pf)  
fmt.Println(dir) // E:/go/project/src/go\_dev/go\_path

// 返回同目录的最短路径  
dir\_a := "/usr/../etc/../etc/ssh"  
fmt.Println(path.Clean(dir\_a)) // /etc/ssh

// 正则是否匹配路径  
is\_match, err := path.Match("\*.xml", "a.xml")  
fmt.Println(is\_match, err) // true <nil>  

}

二、filepath

import "path/filepath"

filepath 包实现了兼容各操作系统的文件路径操作函数。

• filepath.Separator // 预定义变量，表示路径分隔符 /

• filepath.ListSeparator // 预定义变量，表示环境变量分隔符 :

• func Abs(path string) (string, error) // 返回path 相对当前路径的绝对路径

• func Clean(path string) string // 返回path 的最短路径

• func Rel(basepath, targpath string) (string, error) // 返回targpath 相对 basepath路径

• func EvalSymlinks(path string) (string, error) // 返回软链指向的路径

• func VolumeName(path string) string // 返回路径最前面的卷名

• func ToSlash(path string) string // 路径分隔符替换为 /

• func FromSlash(path string) string // / 替换为路径分隔符

• func SplitList(path string) []string // 分隔环境变量里面的路径

• func Walk(root string, walkFn WalkFunc) error // 遍历 root 目录下的文件树，并调用 walkF

示例代码

func main() {
// 预定义变量
fmt.Println(string(filepath.Separator), string(filepath.ListSeparator)) // \ ;

// 返回path 相对当前路径的绝对路径  
dir := "~/gocode/src/go\_note/package/filepath"  
real\_dir, err := filepath.Abs(dir)  
fmt.Println(real\_dir, err)  
// E:\\go\\project\\src\\go\_dev\\~\\gocode\\src\\go\_note\\package\\filepath <nil>

// 返回path 的最短路径  
dir = "/usr/../etc/../tmp"  
clear\_dir := filepath.Clean(dir)  
fmt.Println(clear\_dir) // \\tmp

// 返回targpath 相对 basepath路径  
basepath, targpath := "/usr/local", "/usr/local/go/bin"  
rel\_dir, err := filepath.Rel(basepath, targpath)  
fmt.Println(rel\_dir, err) // go/bin <nil>

// 返回软链指向的路径  
symlink := "/usr/local"  
real\_dir, err = filepath.EvalSymlinks(symlink)  
fmt.Println(real\_dir, err) // /usr/local <nil>

// 返回路径最前面的卷名  
root := "/usr/local/go"  
vol := filepath.VolumeName(root)  
fmt.Println(vol) // ''

// 路径分隔符替换为 \`/\`  
slash\_dir := filepath.ToSlash(root)  
fmt.Println(slash\_dir) // /usr/local/go

//  \`/\` 替换为路径分隔符  
from\_slash := filepath.FromSlash(slash\_dir)  
fmt.Println(from\_slash) // \\usr\\local\\go

// 分隔环境变量里面的路径  
env\_path := "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/usr/local/go/bin"  
env\_slice := filepath.SplitList(env\_path)  
for k, v := range env\_slice {  
    fmt.Println(k, v)  
}  
// 0 /usr/local/bin  
// 1 /usr/bin  
// 2 /bin  
// 3 /usr/sbin  
// 4 /sbin  
// 5 /opt/X11/bin  
// 6 /usr/local/go/bin

// 遍历 root 目录下的文件树，并调用 walkFn  
root\_dir, err := os.Getwd()  
err = filepath.Walk(root\_dir, pathName)  
fmt.Println(err)  

}