Go 1.19.4 路径和目录-Day 15

1. 路径介绍

存储设备保存着数据，但是得有一种方便的模式让用户可以定位资源位置，操作系统采用一种路径字符 串的表达方式，这是一棵倒置的层级目录树，从根开始。

• 相对路径：不是以根目录开始的路径，例如 a/b 、 a/b/c 、 . 、 ../a/b 、 ./a/b/c
• 绝对路径：以斜杆开始的路径，例如 /a/b 、 /a/b/c 、 /t/../a/b ，window需要盘符 e:\a\b\c
• 路径分隔符：windows为 \ ，但是也支持 / ；Linux系统等为 /

2. 路径处理包

为了方便处理，Go语言标准库提供path包和更加方便的path/filepath包，使用filepath即可。

3. 路径拼接（filepath.Join）

作用：

        由于路径是字符串，直接使用字符串拼接就可以了，也可以使用filepath.Join方法。

        推荐使用filepath.Join，这个函数会将多个字符串参数组合成一个路径，并且会根据操作系统的要求，自动插入正确的路径分隔符。

语法：

        func filepath.Join(elem ...string) string

参数：

        elem ...string：相对路径或者绝对路径。

返回值：

        string：合并后的完整路径。

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	p1 := "/a/b" + "/" + "c/d" + "/" + "f"

    // 就算写错了分隔符，filepath.Join也会自动处理为正确的
	p2 := filepath.Join("a/b", "c/d", "f") // 相对路径
    p3 := filepath.Join("/a", "b", "c") // 绝对路径

	fmt.Println(p1)
	fmt.Println(p2)

}
=============调试结果=============
/a/b/c/d/f
a\b\c\d\f
\a\b\c

4. 路径分解

就是提取完整路径中的某一部分。

4.1 提取目录（filepath.Dir）

作用：

        filepath.Dir 函数用于从完整的文件路径中提取目录部分。这个函数会返回给定路径中，文件名之前的目录路径。

语法：

        func filepath.Dir(path string) string

参数：

        表示完整的文件路径。

返回值：

        string：成功提取的目录部分。

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	// 注意a前面没有/，所以是个相对路径
	fmt.Println("======filepath.Join======")
	p1 := filepath.Join("a/b", "c/d", "f", "mysql.ini")
	fmt.Printf("p1的类型=%T\np1的值=%+[1]v\n", p1)
	fmt.Println("======filepath.Dir======")
	dir := filepath.Dir(p1) // 提取目录
	fmt.Printf("dir=%s\n", dir)
}
======filepath.Join======
p1的类型=string
p1的值=a\b\c\d\f\mysql.ini
======filepath.Dir======
dir=a\b\c\d\f

4.2 提取文件扩展名（filepath.Ext）

作用：

        Ext返回path使用的文件扩展名。扩展是path的最后一个元素的最后一个点开始的后缀;如果没有点，则为空。

语法：

        func filepath.Ext(path string) string

参数：

      path string：文件路径变量。

返回值：

          string：返回截取到的文件扩展名。

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	// 注意a前面没有/，所以是个相对路径
	fmt.Println("======filepath.Join======")
	p1 := filepath.Join("a/b", "c/d", "f", "mysql.ini")
	fmt.Printf("p1的类型=%T\np1的值=%+[1]v\n", p1)
	fmt.Println("======filepath.Ext======")
	dir := filepath.Ext(p1)
	fmt.Printf("dir=%s", dir)
}
======filepath.Join======
p1的类型=string
p1的值=a\b\c\d\f\mysql.ini
======filepath.Ext======
dir=.ini

4.3 提取文件名（filepath.Base）

作用：

        filepath.Base 函数用于从完整的文件路径中提取文件名部分。这个函数会返回给定路径中的最后一个元素，即文件名或目录名。

语法：

        func filepath.Base(path string) string

参数：

        path string：完整的文件路径。

返回值：

        string：表示从给定路径中提取的最后一个元素，即文件名或目录名。

import (
	"fmt"
	"path/filepath"
)

func main() {
	// 提取文件名
	base := filepath.Base("path/to/the/file.txt")
	fmt.Println(base) // 输出: file.txt

	// 处理绝对路径
	baseAbsolute := filepath.Base("/home/user/file.txt")
	fmt.Println(baseAbsolute) // 输出: file.txt

	// 处理只有目录没有文件名的路径
	baseDir := filepath.Base("path/to/")
	fmt.Println(baseDir) // 输出: (空字符串，因为路径以斜杠结尾)

	// 处理根目录
	baseRoot := filepath.Base("/home")
	fmt.Println(baseRoot) // 输出: home

	// 处理没有目录的文件名
	baseNoDir := filepath.Base("file.txt")
	fmt.Println(baseNoDir) // 输出: file.txt

	// 处理隐藏文件
	baseHidden := filepath.Base(".hiddenfile")
	fmt.Println(baseHidden) // 输出: .hiddenfile
}

5. 目录

5.1 获取当前工作目录（os.Getwd）

作用：

        Getwd返回与当前目录对应的根路径名（注意是程序的运行目录）。如果当前目录可以通过多个路径到达(由于符号链接)，Getwd可能返回其中的任何一个。

语法：

        func os.Getwd() (dir string, err error)

返回值：

        dir string：表示当前工作目录的路径。

        err error：如果发生错误，返回错误对象；否则返回 nil。

package main

import (
	"fmt"
	"os"
)

func main() {
	dir, err := os.Getwd()
	if err != nil {
		panic(err)
	} else {
		fmt.Printf("当前工作目录=%s", dir) 
	}
}
=======调试结果=======
当前工作目录=d:\个人\GO开发\20240624

5.2 获取当前登录用户的家目录（os.UserHomeDir）

作用：

        os.UserHomeDir 函数用于获取当前用户的主目录路径。

        os.UserHomeDir 在不同的操作系统上都能正常工作，它会根据操作系统的环境变量（如 HOME 在 Unix 系统上，USERPROFILE 或 HOMEPATH 在 Windows 系统上）来确定用户的主目录。
 

语法：

        func UserHomeDir() (string, error)

返回值：

        string：表示当前用户的主目录路径。

        error：如果发生错误，返回错误对象；否则返回 nil。

package main

import (
	"fmt"
	"os"
)

func main() {
	s, err := os.UserHomeDir()
	if err != nil {
		panic(err)
	} else {
		fmt.Printf("当前登录用户家目录=%s", s)
	}
}
=======调试结果=======
当前登录用户家目录=C:\Users\123456

6. 绝对路径

6.1 判断绝对路径（filepath.IsAbs）

作用：

        filepath.IsAbs 函数用于检查给定的路径是否是绝对路径。

语法：

        func filepath.IsAbs(path string) (b bool)

参数：

      path string：  表示要检查的文件路径。

返回值：

        b bool：如果路径是绝对路径，则返回 true；否则返回 false。

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	p1 := filepath.Join("a/b", "c/d", "f", "mysql.ini")
	fmt.Printf("p1的路径=%s\n", p1)

	path := filepath.IsAbs(p1)
	fmt.Printf("p1是否为绝对路径=%v", path)
}
=====调试结果=====
p1的路径=a\b\c\d\f\mysql.ini
p1是否为绝对路径=false

6.2 将相对路径转换为绝对路径（filepath.Abs）

作用：

        filepath.Abs 函数用于将相对路径转换为绝对路径。

        它根据当前工作目录（程序运行目录）和提供的相对路径来计算绝对路径。

语法：

        func filepath.Abs(path string) (string, error)

参数：

        path string：表示要转换的相对文件路径。

返回值：

        string：表示转换后的绝对路径。

        error：如果发生错误，返回错误对象；否则返回 nil。

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	p1 := filepath.Join("a/b", "c/d", "f", "mysql.ini")
	fmt.Printf("p1的路径=%s\n", p1)

	abs, err := filepath.Abs(p1)
	if err != nil {
		panic(err)
	} else {
		fmt.Printf("Abs处理后的绝对路径=%s", abs)
	}
}
=====调试结果=====
p1的路径=a\b\c\d\f\mysql.ini
Abs处理后的绝对路径=d:\个人\GO开发\20240624\a\b\c\d\f\mysql.ini

7. 存在性检测

7.1 获取文件或目录信息（os.Stat）

作用：

        os.Stat 函数用于获取文件或目录的状态信息。这个函数是 os 包的一部分，它返回一个 fs.FileInfo 接口，该接口提供了文件的大小、修改时间、权限等信息。

语法：

        func os.Stat(name string) (fs.FileInfo, error)

参数：

    name string：表示要获取状态信息的文件或目录的路径。

返回值：

        fs.FileInfo：一个实现了 FileInfo 接口的对象，包含了文件或目录的详细信息。

        error：如果发生错误，返回错误对象；否则返回 nil。

package main

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

func main() {
	p1 := filepath.Join("a/b", "c/d", "f", "mysql.ini")
	fmt.Printf("p1的路径=%s\n", p1)

	fi, err := os.Stat(p1)
	if err != nil {
		fmt.Println("获取文件信息异常:", err)
	} else {
		fmt.Println(fi)
	}
}
=====调试结果=====
p1的路径=a\b\c\d\f\mysql.ini
获取文件信息异常: CreateFile a\b\c\d\f\mysql.ini: The system cannot find the path specified.

7.2 检测文件或目录是否存在

7.2.1 os.IsNotExist

作用：

        os.IsNotExist 函数用于检查一个错误是否表示文件或目录不存在的错误。

语法：

        func os.IsNotExist(err error) bool

参数：

        err error：表示要检查的错误对象。

返回值：

        bool：如果错误表示文件已存在，则返回 true；否则返回 false。

package main

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

func main() {
	fmt.Println("==========调试结果==========")

	p1 := filepath.Join("a/b", "c/d", "f", "mysql.ini")
	fmt.Printf("p1的路径=%s\n", p1)

	fi, err := os.Stat(p1)
	if err != nil {
		fmt.Printf("获取文件信息异常：%s\n文件不存在：%v\n", err, os.IsNotExist(err))
	} else {
		fmt.Println(fi)
	}
}
==========调试结果==========
p1的路径=a\b\c\d\f\mysql.ini
获取文件信息异常：CreateFile a\b\c\d\f\mysql.ini: The system cannot find the path specified.
文件不存在：true

8. 创建目录和文件

8.1 创建目录

创建目录主要有这3个函数：

1. os.Mkdir
   创建一个新的子目录，父目录必须存在，否则报错。
2. os.MkdirAll
   递归创建一个目录路径。
3. os.MkdirTemp
   创建一个临时目录。

8.1.1 os.MkdirAll

作用：

        os.MkdirAll 函数是 Go 语言标准库 os 包中的一个函数，用于递归创建一个目录路径，包括任何必要的中间目录。这个函数非常适合在需要确保整个目录结构都存在时使用，例如在创建文件之前。

        创建时，如果用的是相对路径，则会在程序所在目录下创建。

        目录已存在，创建也不会报错。

语法：

        func os.MkdirAll(path string, perm fs.FileMode) error

参数：

        path string：要创建的目录路径，可以包含多级目录。

        perm fs.FileMode：设置目录的权限。fs.FileMode 是一个类型，通常使用常量如 fs.ModePerm来表示权限，也可以手动指定权限如0755

返回值：

        error：如果所有目录都成功创建，则返回 nil；如果发生错误（例如，权限不足），则返回错误对象。

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("==========调试结果==========")
	
	err := os.MkdirAll("d:/个人/学习/Go/文件与目录操作/创建测试", os.ModePerm) // os.ModePerm默认权限为511
    // err := os.MkdirAll("创建测试", os.ModePerm)// 如果是相对路径，则会在程序所在目录下创建
	if err != nil {
		fmt.Println("目录创建失败:", err)
	} else {
		fmt.Println("递归创建目录成功！")
	}
}
==========调试结果==========
递归创建目录成功！

8.2 创建文件

创建文件可以使用os包中的两个函数：

• os.Create
  注意：如果文件已经存在了，该函数会先清空文件中原本的内容，再创建。
• os.OpenFile
  OpenFile能够更细粒度的去控制文件的权限。

8.2.1 os.Create

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("==========调试结果==========")

	f, err := os.Create("d:/个人/学习/Go/文件与目录操作/创建测试/create-test.txt")
	if err != nil {
		panic(err)
	}
	fmt.Println("文件创建成功!")
	defer f.Close()
}
==========调试结果==========
文件创建成功!

9. 获取文件或目录元数据信息（Stat）

除了利用stat来判断文件是否存在，还可以检测文件元数据，如判断是否为目录、是否为文件、文件权限、大小、修改时间等。

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("==========调试结果==========")

	p1 := "d:/个人/学习/Go/文件与目录操作/创建测试/create-test.txt"
	fi, err := os.Stat(p1)
	if err != nil {
		panic(err)
	} else {
		fmt.Printf("文件名=%s\n是否为目录=%v\n文件的权限=%v\n文件的大小=%d\n文件的修改时间=%s\n", fi.Name(), fi.IsDir(), fi.Mode(), fi.Size(), fi.ModTime())
	}
}
==========调试结果==========
文件名=create-test.txt
是否为目录=false
文件的权限=-rw-rw-rw-
文件的大小=0
文件的修改时间=2024-09-04 15:44:45.291237 +0800 CST

10. 遍历目录

10.1 os.ReadDir（非递归遍历）

作用：

        读取指定目录下的所有条目（包括文件和子目录），非递归。

语法：

        func os.ReadDir(name string) ([]fs.DirEntry, error)

参数：

        name string：要读取的目录的路径。

返回值：

        []fs.DirEntry：一个包含 fs.DirEntry 接口的切片，每个条目代表目录中的一个文件或子目录。

        error：如果读取目录过程中发生错误，则返回错误对象；否则返回 nil。

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("==========调试结果==========")

	de, err := os.ReadDir("D:/个人/学习/Go/文件与目录操作")
	if err != nil {
		panic(err)
	}
	fmt.Println(de)
	for i, v := range de {
		fmt.Println(i, v, v.Name(), v.Type(), v.IsDir())
	}
}
==========调试结果==========
[{0xc00010a000} {0xc00010a070}]
0 {0xc00010a000} test.txt ---------- false
1 {0xc00010a070} 创建测试 d--------- true

10.2 filepath.WalkDir（递归遍历）

作用：

        用于递归遍历一个目录及其所有子目录中的文件和子目录。

语法：

        func filepath.WalkDir(root string, fn fs.WalkDirFunc) error

参数：

        root string：要遍历的根目录的路径。

        fn fs.WalkDirFunc：一个回调函数，用于处理每个文件和目录。它接收三个参数：当前遍历到的路径、一个 fs.DirEntry 对象（包含文件或目录的信息），以及在读取目录时可能发生的错误。

返回值：

        error：如果遍历过程中发生错误，则返回错误对象；否则返回 nil。

package main

import (
	"fmt"
	"io/fs"
	"path/filepath"
)

func main() {
	fmt.Println("==========调试结果==========")
	
	filepath.WalkDir(
		"D:/个人/学习/Go/文件与目录操作",
		func(path string, d fs.DirEntry, err error) error {
			fmt.Println(path, d.Name(), d.IsDir())
			return err
		}) // path string，就是遍历过程中遍历到的文件或目录
}
==========调试结果==========
D:/个人/学习/Go/文件与目录操作 文件与目录操作 true
D:\个人\学习\Go\文件与目录操作\test.txt test.txt false
D:\个人\学习\Go\文件与目录操作\创建测试 创建测试 true
D:\个人\学习\Go\文件与目录操作\创建测试\create-test.txt create-test.txt false