go语言的魔幻旅程23-os包

百川东到海，何时复西归

程序员这个行业，在外人看来是能挣w，但不是每个从事这个行业的人员都能挣到令自己满意的w，工作的前几年，每一次的跳槽超不多都能涨个30%以上的工资，但是与实际的工作强度相比，实际上还不如一些行业的性价比，1-3年是技术实力的积累期，积累的好大概能挣30w，强点的大概能有50w，因此前三年可以说是耕耘期，之后的3-5年，基本上是价值黄金期，工作机会多，待遇也相对较好，但是超过５年之后，大部分人可能会遇到瓶颈期，这个时候可能就会有转管理和深耕技术的抉择点，这一点上因人而异。不过对于大部分从事这个行业的穷人家的孩子而言，程序员这个行业还是性价比极高的。

go语言的os包

go语言的os包主要是一些设计操作系统底层相关的函数和方法，其中也涉及一些文件及流的相关操作，总的来讲内容还是比较多的,下面讲针对这些函数和方法展开讲解。

package main

/*********************************************************************/
/**************** golang中os包相关API讲解 **************************/
/********************************************************************/

/*
Constants
Variables
func Chdir(dir string) error
func Chmod(name string, mode FileMode) error
func Chown(name string, uid, gid int) error
func Chtimes(name string, atime time.Time, mtime time.Time) error
func Clearenv()
func DirFS(dir string) fs.FS
func Environ() []string
func Executable() (string, error)
func Exit(code int)
func Expand(s string, mapping func(string) string) string
func ExpandEnv(s string) string
func Getegid() int
func Getenv(key string) string
func Geteuid() int
func Getgid() int
func Getgroups() ([]int, error)
func Getpagesize() int
func Getpid() int
func Getppid() int
func Getuid() int
func Getwd() (dir string, err error)
func Hostname() (name string, err error)
func IsExist(err error) bool
func IsNotExist(err error) bool
func IsPathSeparator(c uint8) bool
func IsPermission(err error) bool
func IsTimeout(err error) bool
func Lchown(name string, uid, gid int) error
func Link(oldname, newname string) error
func LookupEnv(key string) (string, bool)
func Mkdir(name string, perm FileMode) error
func MkdirAll(path string, perm FileMode) error
func MkdirTemp(dir, pattern string) (string, error)
func NewSyscallError(syscall string, err error) error
func Pipe() (r *File, w *File, err error)
func ReadFile(name string) ([]byte, error)
func Readlink(name string) (string, error)
func Remove(name string) error
func RemoveAll(path string) error
func Rename(oldpath, newpath string) error
func SameFile(fi1, fi2 FileInfo) bool
func Setenv(key, value string) error
func Symlink(oldname, newname string) error
func TempDir() string
func Truncate(name string, size int64) error
func Unsetenv(key string) error
func UserCacheDir() (string, error)
func UserConfigDir() (string, error)
func UserHomeDir() (string, error)
func WriteFile(name string, data []byte, perm FileMode) error
type DirEntry
	func ReadDir(name string) ([]DirEntry, error)
type File
	func Create(name string) (*File, error)
	func CreateTemp(dir, pattern string) (*File, error)
	func NewFile(fd uintptr, name string) *File
	func Open(name string) (*File, error)
	func OpenFile(name string, flag int, perm FileMode) (*File, error)
	func (f *File) Chdir() error
	func (f *File) Chmod(mode FileMode) error
	func (f *File) Chown(uid, gid int) error
	func (f *File) Close() error
	func (f *File) Fd() uintptr
	func (f *File) Name() string
	func (f *File) Read(b []byte) (n int, err error)
	func (f *File) ReadAt(b []byte, off int64) (n int, err error)
	func (f *File) ReadDir(n int) ([]DirEntry, error)
	func (f *File) ReadFrom(r io.Reader) (n int64, err error)
	func (f *File) Readdir(n int) ([]FileInfo, error)
	func (f *File) Readdirnames(n int) (names []string, err error)
	func (f *File) Seek(offset int64, whence int) (ret int64, err error)
	func (f *File) SetDeadline(t time.Time) error
	func (f *File) SetReadDeadline(t time.Time) error
	func (f *File) SetWriteDeadline(t time.Time) error
	func (f *File) Stat() (FileInfo, error)
	func (f *File) Sync() error
	func (f *File) SyscallConn() (syscall.RawConn, error)
	func (f *File) Truncate(size int64) error
	func (f *File) Write(b []byte) (n int, err error)
	func (f *File) WriteAt(b []byte, off int64) (n int, err error)
	func (f *File) WriteString(s string) (n int, err error)
type FileInfo
	func Lstat(name string) (FileInfo, error)
	func Stat(name string) (FileInfo, error)
type FileMode
type LinkError
	func (e *LinkError) Error() string
	func (e *LinkError) Unwrap() error
type PathError
type ProcAttr
type Process
	func FindProcess(pid int) (*Process, error)
	func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)
	func (p *Process) Kill() error
	func (p *Process) Release() error
	func (p *Process) Signal(sig Signal) error
	func (p *Process) Wait() (*ProcessState, error)
type ProcessState
	func (p *ProcessState) ExitCode() int
	func (p *ProcessState) Exited() bool
	func (p *ProcessState) Pid() int
	func (p *ProcessState) String() string
	func (p *ProcessState) Success() bool
	func (p *ProcessState) Sys() interface{}
	func (p *ProcessState) SysUsage() interface{}
	func (p *ProcessState) SystemTime() time.Duration
	func (p *ProcessState) UserTime() time.Duration
type Signal
type SyscallError
	func (e *SyscallError) Error() string
	func (e *SyscallError) Timeout() bool
	func (e *SyscallError) Unwrap() error
*/

func main() {

	/**
	*Chdir将当前工作目录更改为指定的目录。如果有错误，它将是*PathError类型。
	*func Chdir(dir string) error
	*/

	/*
	beforeDir, _ := os.Getwd()
	fmt.Println(beforeDir)
	err := os.Chdir("sdk/test")
	fmt.Println(err)
	latestDir, _ := os.Getwd()
	fmt.Println(latestDir)
	*/


	/**
	*Chmod 将指定文件的模式更改为模式。如果文件是符号链接，它将更改链接目标的模式。
	*如果有错误，它将是 * PathError 类型, 取决于操作系统，使用模式位的不同子集。
	*在 Unix 上，使用模式的权限位 ModeSetuid，ModeSetgid 和 ModeSticky。
	*在 Windows 上，模式必须是非零的，否则只能使用0200位（所有者可写）模式;
	*它控制文件的只读属性是设置还是清除。属性。其他位当前未使用。对于只读文件使用
	*模式0400，对于可读+可写文件使用0600
	*func Chmod(name string, mode FileMode) error
	*/

	/*
	if err := os.Chmod("sdk/test.txt", 0644); err != nil {
		log.Fatal(err)
	}
	*/


	/**
	*Chown 更改指定文件的数字 uid 和 gid 。如果该文件是符号链接，它会更改链接目标的
	*uid 和 gid 。如果有错误，它将是 * PathError 类型,在 Windows 上，它总是返回
	*包装在 * PathError 中的 syscall.EWINDOWS 错误。
	*func Chown(name string, uid, gid int) error
	*/

	/*
	if err := os.Lchown(FilePath, 501, 20); err != nil {
		log.Fatal(err)
	}
	*/


	/**
	*Chtimes 更改指定文件的访问和修改时间，类似于 Unix utime（） 或 utimes（)函数。
	*底层文件系统可能会将值截断或舍入到不太精确的时间单位。如果有错误，它将是*PathError类型。
	*func Chtimes(name string, atime time.Time, mtime time.Time) error
	*/

	/*
	mtime := time.Date(2006, time.February, 1, 3, 4, 5, 0, time.UTC)
	atime := time.Date(2007, time.March, 2, 4, 5, 6, 0, time.UTC)
	if err := os.Chtimes("some-filename", atime, mtime); err != nil {
		log.Fatal(err)
	}
	*/


	/**
	*Clearenv 删除所有环境变量。
	*func Clearenv()
	*/

	/*
	os.Clearenv()
	*/


	/**
	*返回文件系统操作对象
	*func DirFS(dir string) fs.FS
	*/

	/*
	f := os.DirFS("sdk")
	fmt.Println(f)
	*/

	/**
	*Environ 以 “key = value” 的形式返回表示环境的字符串的副本。
	*func Environ() []string
	*/

	/*
	fmt.Println(os.Environ())
	*/

	/**
	*可执行文件返回启动当前进程的可执行文件的路径名称。不能保证路径仍然
	*指向正确的可执行文件。如果使用符号链接来启动进程，则根据操作系统的
	*不同，结果可能是符号链接或它指向的路径。如果需要稳定的结果，path/
	*filepath.EvalSymlinks 可能会有所帮助。
	*func Executable() (string, error)
	*/

	/*
	s, err := os.Executable()
	fmt.Println(s, err)
	*/


	/**
	*退出时会导致当前程序退出并显示给定的状态码。通常，代码0表示成功，错误不为零。
	*该程序立即终止; 延迟功能不运行。
	*func Exit(code int)
	*/

	/*
	os.Exit(404)
	*/

	/**
	*Expand根据映射函数替换字符串中的${var}或$var。例如，os.ExpandEnv(s)
	*等效于os.Expand(s，os.Getenv)。
	*func Expand(s string, mapping func(string) string) string
	*/

	/*
	mapper := func(placeholderName string) string {
		switch placeholderName {
		case "DAY_PART":
			return "morning"
		case "NAME":
			return "Gopher"
		}
		return ""
	}
	fmt.Println(os.Expand("Good ${DAY_PART}, $NAME!", mapper))
	*/


	/**
	*ExpandEnv根据当前环境变量的值替换字符串中的${var}或$var。未定义变量的引用将替换为空字符串。
	*func ExpandEnv(s string) string
	*/

	/*
	os.Setenv("NAME", "gopher")
	os.Setenv("BURROW", "/usr/gopher")
	fmt.Println(os.ExpandEnv("$NAME lives in ${BURROW}."))
	*/

	/**
	*Getegid 返回调用者的数字有效组 ID 。
	*func Getegid() int
	*/

	/*
	fmt.Println(os.Getegid())
	*/

	/**
	*Getenv检索由键命名的环境变量的值。它返回值，如果不存在该变量，则该值为空。
	*要区分空值和未设置值，请使用LookupEnv。
	*func Getenv(key string) string
	*/

	/*
	os.Setenv("NAME", "gopher")
	os.Setenv("BURROW", "/usr/gopher")
	fmt.Printf("%s lives in %s.\n", os.Getenv("NAME"), os.Getenv("BURROW"))
	*/

	/**
	*Geteuid 返回调用者的数字有效用户标识。
	*func Geteuid() int
	*/

	/*
	fmt.Println(os.Getuid())
	*/

	/**
	*Getgid返回调用者的数字组ID。
	*func Getgid() int
	*/

	/*
	fmt.Println(os.Getgid())
	*/

	/**
	* Getgroups 返回调用者所属组的数字 ID 列表。在 Windows 上，它返回 syscall.EWINDOWS
	*func Getgroups() ([]int, error)
	*/

	/*
	fmt.Println(os.Getgroups())
	*/

	/**
	*Getpagesize 返回底层系统的内存页面大小。
	*func Getpagesize() int
	*/

	/*
	fmt.Println("agesize:", os.Getpagesize())
	*/

	/**
	*返回调用者所在进程的进程ID
	*func Getpid() int
	*/

	/*
	fmt.Println("pid:", os.Getpid())
	*/

	/**
	*返回调用者所在进程的父进程的进程ID
	*func Getppid() int
	*/

	/*
	fmt.Println("ppid:",os.Getppid())
	*/


	/**
	*返回调用者的用户ID
	*func Getuid() int
	*/

	/*
	fmt.Println("uid:", os.Getuid())
	*/

	/**
	*Getwd 返回与当前目录对应的根路径名称。如果当前目录可以通过多个路径到达
	*（由于符号链接），Getwd 可以返回其中任何一个。
	*func Getwd() (dir string, err error)
	*/

	/*
	fmt.Println(os.Getwd())
	*/


	/**
	*返回内核提供的主机名
	*func Hostname() (name string, err error)
	*/

	/*
	fmt.Println(os.Hostname())
	*/

	/**
	*IsExist 返回一个布尔值，指示是否已知错误报告文件或目录已存在。它由 ErrExist
	*满足以及一些系统调用错误
	*func IsExist(err error) bool
	*/

	/*
	fmt.Println(os.IsExist(nil))
	*/

	/**
	*IsNotExist返回一个布尔值，该布尔值指示是否已知该错误以报告文件或目录不存在。
	*ErrNotExist以及一些系统调用错误都可以满足要求。此函数可早于错误。它仅支持os
	*包返回的错误。新代码应使用errors.Is(err，os.ErrNotExist)。
	*func IsNotExist(err error) bool
	*/

	/*
	filename := "a-nonexistent-file"
	if _, err := os.Stat(filename); os.IsNotExist(err) {
		fmt.Println("file does not exist")
	}
	*/

	/**
	*IsPathSeparator 报告 c 是否是目录分隔符。
	*func IsPathSeparator(c uint8) bool
	*/

	/*
	fmt.Println(os.IsPathSeparator('/'))
	*/

	/**
	*IsPermission 返回一个布尔值，指示是否已知错误报告许可被拒绝。它由 ErrPermission
	*以及一些系统调用错误满足。
	*func IsPermission(err error) bool
	*/

	/*
	fmt.Println(os.IsPermission(nil))
	*/

	/**
	*判断是否超时
	*func IsTimeout(err error) bool
	*/

	/*
	fmt.Println(os.IsTimeout(nil))
	*/

	/**
	*Lchown 更改指定文件的数字 uid 和 gid 。如果该文件是符号链接，它会更改链接本身的 uid 和 gid。
	*如果有错误，它将是 * PathError 类型。在 Windows 上，它总是返回包装在 * PathError 中的
	*syscall.EWINDOWS 错误。
	*func Lchown(name string, uid, gid int) error
	*/

	/*
	if err := os.Lchown(FilePath, 501, 20); err != nil {
		log.Fatal(err)
	}
	*/

	/**
	*链接创建新名称作为旧名称文件的硬链接。如果有错误，它将是 * LinkError 类型。
	*func Link(oldname, newname string) error
	*/

	/*
	os.Link(FilePath, NewFilePath)
	*/

	/**
	*检索并返回名为key的环境变量的值 和 是否存在的bool值。如果不存在布尔值为false
	*func LookupEnv(key string) (string, bool)
	*/

	/*
	fmt.Println(os.LookupEnv("NAME"))
	*/

	/**
	*使用指定的权限和名称创建一个目录。如果出错，会返回*PathError底层类型的错误
	*func Mkdir(name string, perm FileMode) error
	*/

	/*
	if err := os.Mkdir(DirPath, os.ModePerm); err != nil {
		log.Fatal(err)
	}
	*/


	/**
	*MkdirAll 会创建一个名为 path 的目录以及任何必要的父项，并返回 nil ，否则返回错误。
	*许可位 perm 用于 MkdirAll 创建的所有目录。如果 path 已经是一个目录，MkdirAll
	*什么也不做，并返回 nil 。
	*func MkdirAll(path string, perm FileMode) error
	*/

	/*
	if err := os.MkdirAll(DirPath, os.ModePerm); err != nil {
		log.Fatal(err)
	}
	*/


	/**
	*创建临时的文件夹
	*func MkdirTemp(dir, pattern string) (string, error)
	*/

	/*
	if err := os.MkdirTemp(DirPath, "xxx"); err != nil {
		log.Fatal(err)
	}
	*/


	/**
	*NewSyscallError 返回一个新的 SyscallError 作为错误，并给出系统调用名称和错误详细信息。
	*为方便起见，如果 err 为零，则 NewSyscallError 返回 nil 。
	*func NewSyscallError(syscall string, err error) error
	*/

	/*
	a := os.NewSyscallError("mkdir", errors.New("bad error"))
	fmt.Println(a)
	*/


	/**
	*管道返回一对连接的文件; 从写入w的r个返回字节中读取。它返回文件和错误（如果有的话）
	*func Pipe() (r *File, w *File, err error)
	*/

	/*
	r, w, _ := os.Pipe()
	w.WriteString("hello,world!")
	var s = make([]byte, 20)
	n, _ := r.Read(s)
	fmt.Println(string(s[:n]))
	*/

	/**
	*ReadFile读取命名的文件并返回内容。成功调用将返回err == nil，而不是err == EOF。
	*由于ReadFile读取整个文件，因此不会将Read中的EOF视为要报告的错误。
	*func ReadFile(name string) ([]byte, error)
	*/

	/*
	data, err := os.ReadFile("sdk/test.txt")
	if err != nil {
		log.Fatal(err)
	}
	os.Stdout.Write(data)
	*/

	/**
	*获取指定的软链接文件指向的文件的路径。如果出错，会返回*PathError底层类型的错误
	*func Readlink(name string) (string, error)
	*/

	/*
	fmt.Println(os.Readlink(linkFilePath))
	*/

	/**
	* 删除指定的文件或目录。如果出错，会返回*PathError底层类型的错误
	*func Remove(name string) error
	*/

	/*
	os.Remove(FilePath)
	*/

	/**
	*删除path指定的文件，或目录及它包含的任何下级对象。它会尝试删除所有东西，
	*除非遇到错误并返回。如果path指定的对象不存在，会返回nil而不返回错误
	*func RemoveAll(path string) error
	*/

	/*
	os.RemoveAll(FilePath)
	*/


	/**
	*重命名（移动）旧路径到新路径。如果 newpath 已经存在并且不是目录，则重命名将替换它。
	*当oldpath和newpath位于不同的目录中时，可能会应用OS特定的限制。如果有错误，它将是
	* *LinkError 类型。
	*func Rename(oldpath, newpath string) error
	*/

	/*
	fmt.Println(os.Rename(oldPath, newPath))
	*/


	/**
	*SameFile 报告 fi1 和 fi2 是否描述相同的文件。例如，在 Unix 上，这意味着两个基础结构的设备和
	inode 字段是相同的; 在其他系统上，决策可以基于路径名称。 SameFile 仅适用于此包的统计信息返回的
	*结果。在其他情况下它返回 false 。
	*func SameFile(fi1, fi2 FileInfo) bool
	*/


	/**
	*设置名为key的环境变量（临时）。如果出错会返回该错误
	*func Setenv(key, value string) error
	*/

	/*
	if err := os.Setenv("NAME", "Gopher"); err != nil {
		log.Fatal(err)
	}
	*/

	/**
	*符号链接创建新名称作为旧名称的符号链接。如果有错误，它将是 * LinkError 类型。
	*func Symlink(oldname, newname string) error
	*/

	/*
	fmt.Println(os.Symlink(oldName, newName))
	*/

	/**
	* TempDir 返回用于临时文件的默认目录。
	*func TempDir() string
	*/

	/*
	fmt.Println(os.TempDir())
	*/

	/**
	*改变文件的大小，它不会改变I/O的当前位置。 如果截断文件，多出的部分就会被丢弃。如果出错，
	*错误底层类型是*PathError
	*func Truncate(name string, size int64) error
	*/

	/*
	fmt.Println(os.Truncate(FilePath, 1024))
	*/


	/**
	*取消设置单个环境变量
	*func Unsetenv(key string) error
	*/

	/*
	if err := os.Unsetenv("NAME"); err != nil {
		log.Fatal(err)
	}
	*/

	/**
	*返回缓存目录路径
	*func UserCacheDir() (string, error)
	*/

	/*
	fmt.Println(os.UserCacheDir())
	*/

	/**
	*返回配置目录路径
	*func UserConfigDir() (string, error)
	*/

	/*
	fmt.Println(os.UserConfigDir())
	*/

	/**
	*用户文件夹路径
	*func UserHomeDir() (string, error)
	*/

	/*
	fmt.Println(os.UserHomeDir())
	*/

	/**
	*用户文件夹路径
	*func WriteFile(name string, data []byte, perm FileMode) error
	*/

	/*
	err := os.WriteFile("sdk/hello", []byte("Hello, Gophers!"), 0666)
	if err != nil {
		log.Fatal(err)
	}
	*/



	/*********************************************************************/
	/**************** DirEntry中相关方法讲解 ****************************/
	/********************************************************************/

	/**
	*ReadDir读取命名目录，返回按文件名排序的所有目录条目。如果在读取目录时发生错误，
	*则ReadDir会返回错误之前能够读取的条目以及错误。
	*func ReadDir(name string) ([]DirEntry, error)
	*/

	/*
	files, err := os.ReadDir(".")
	if err != nil {
		log.Fatal(err)
	}

	for _, file := range files {
		fmt.Println(file.Name())
	}
	*/


	/*********************************************************************/
	/******************** File中相关方法讲解 *****************************/
	/********************************************************************/


	/**
	*以读写方式打开文件，并且清空原始内容，如果文件不存在以0666操作模式创建文件
	*func Create(name string) (*File, error)
	*/

	/*
	file, err := os.Create("sdk/tmp.txt")
	fmt.Println(file, err)
	*/

	/**
	*CreateTemp在目录dir中创建一个新的临时文件，打开该文件进行读写，然后返回结果文件.
	*func CreateTemp(dir, pattern string) (*File, error)
	*/

	/*
	 f, err := os.CreateTemp("", "example")
	    if err != nil {
	        log.Fatal(err)
	    }
	    defer os.Remove(f.Name()) // clean up

	    if _, err := f.Write([]byte("content")); err != nil {
	        log.Fatal(err)
	    }
	    if err := f.Close(); err != nil {
	        log.Fatal(err)
	    }
	*/

	/**
	*
	*func NewFile(fd uintptr, name string) *File
	*/


	/**
	*打开打开指定文件以供阅读。如果成功，返回文件上的方法可用于读取; 关联的文件描述符具有
	*模式 O_RDONLY 。如果有错误，它将是 * PathError 类型。
	*func Open(name string) (*File, error)
	*/

	/*
	file, err := os.Open("sdk/hello")
	fmt.Println(file.Name(), err)
	*/

	/**
	*以读写方式打开文件，并且内容写入方式为添加，如果文件不存在以0755操作模式创建文件
	*func OpenFile(name string, flag int, perm FileMode) (*File, error)
	*/

	/*
	f, err := os.OpenFile(FilePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0755)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	if _, err := f.Write([]byte("appended some data\n")); err != nil {
		log.Fatal(err)
	}
	*/

	/**
	*Chdir 将当前工作目录更改为文件，该文件必须是目录。如果有错误，它将是 * PathError 类型
	*func (f *File) Chdir() error
	*/


	/*
	dir, _ := os.Getwd()
	fmt.Println(dir)
	f, _ := os.Open("tmp.txt")
	err := f.Chdir()
	if err != nil {
		fmt.Println(err)
	}
	f, _ = os.Open("develop")
	err = f.Chdir()
	if err != nil {
		fmt.Println(err)
	}
	dir1, _ := os.Getwd()
	fmt.Println(dir1)
	*/

	/**
	*更改文件权限，其等价与os.Chmod(name string,mode FileMode)error
	*func (f *File) Chmod(mode FileMode) error
	*/

	/*
	f, _ := os.Open("develop")
	f.Chmod(os.ModePerm)
	*/

	/**
	*更改文件权所有者、群组权限
	* func (f *File) Chown(uid, gid int) error
	*/

	/*
	f, _ := os.Open("develop")
	f.Chown(1000, 1000)
	*/

	/**
	*关闭文件
	*func (f *File) Close() error
	*/

	/*
	f, _ := os.Open("develop")
	f.Close()
	*/

	/**
	*Fd 返回引用打开文件的整数 Unix 文件描述符。文件描述符仅在 f.Close
	*被调用或f被垃圾收集之前有效。
	*func (f *File) Fd() uintptr
	*/

	/*
	f, _ := os.Open("develop")
	fmt.Println(f.Fd())
	*/

	/**
	*返回文件的名称
	*func (f *File) Name() string
	*/

	/*
	f, _ := os.Open("sdk/hello")
	fmt.Println(f.Name())
	*/

	/**
	*读取文件
	*func (f *File) Read(b []byte) (n int, err error)
	*/

	/*
	f, _ := os.Open("sdk/hello")
	n, err := f.Read([]byte("hello world"))
	fmt.Println(n, err)
	*/

	/**
	*ReadAt 从文件开始以字节偏移关闭读取 len（b） 个字节。它返回读取的字节数和错误
	*（如果有的话）。当 n <len（b） 时， ReadAt 总是返回非零错误。在文件结尾处,该
	*错误是 io.EOF 。
	*func (f *File) ReadAt(b []byte, off int64) (n int, err error)
	*/

	/*
	f, _ := os.Open("sdk/hello")
	n, err := f.ReadAt([]byte("hello"), 1)
	fmt.Println(n, err)
	*/

	/**
	*Readdir 读取与文件关联的目录的内容，并以目录顺序返回最多 n 个 FileInfo 值的片段，
	*Lstat 将返回该片段。随后对相同文件的调用将产生更多的 FileInfos 。
	*func (f *File) ReadDir(n int) ([]DirEntry, error)
	*/

	/*
	f, _ := os.Open("sdk")
	fmt.Println(f.ReadDir(2))
	*/

	/**
	*
	*func (f *File) ReadFrom(r io.Reader) (n int64, err error)
	*/

	/*
	f, _ := os.Open("sdk/hello")
    fmt.Println(f.ReadFrom(strings.NewReader("hello")))
	*/


	/**
	*读取file指定的目录的内容，然后返回一个切片，它最多包含n个FileInfo值，这些值可能是按照
	*目录顺序的Lstat返回的。接下来调用相同的文件会产生更多的FileInfos。
	*func (f *File) Readdir(n int) ([]FileInfo, error)
	*/

	/*
	f, _ := os.Open(".")
	fmt.Println(f.Readdir(2))
	*/

	/**
	*Readdirnames读取并返回目录f里面的文件的名字切片,如果n>0，Readdirnames返回最多n个名字。
	*在这种情况下，如果Readdirnames返回一个空的切片，它会返回一个非空的错误来解释原因,在目录
	*的结尾，错误为EOF。如果n<0，Readdirnames返回目录下所有的文件的名字，用一个切片表示。
	*在这种情况下，如果用一个切片表示成功（读取直到目录结尾），它返回切片和一个空的错误。
	*如果在目录结尾之前遇到了一个错误，Readdirnames返回直到当前所读到的names和一个非空的错误。
	*func (f *File) Readdirnames(n int) (names []string, err error)
	*/

	/*
	file, err := os.Open("sdk")
	if err != nil {
		fmt.Println(err)
	}
	fileslice, err := file.Readdir(5)
	if err != nil {
		fmt.Println(err)
	}
	for _, f := range fileslice {
		fmt.Println(f.Name())
	}

	filename, err := file.Readdirnames(-1)
	if err != nil {
		fmt.Println(err)
	}
	for _, f := range filename {
		fmt.Println(f)
	}
	*/


	/**
	*Seek设置下一次读或写操作的偏移量offset，根据whence来解析：0意味着相对于文件的原始位置，
	*1意味着相对于当前偏移量，2意味着相对于文件结尾。它返回新的偏移量和错误（如果存在）。
	*func (f *File) Seek(offset int64, whence int) (ret int64, err error)
	*/

	/*
	s := make([]byte, 10)
	file, _ := os.Open("tmp.txt")
	defer file.Close()
	file.Seek(-12, 2)        // 从离最后位置12的地方开始
	n, _ := file.Read(s)
	fmt.Println(string(s[:n]))
	*/

	/**
	*设置文件读取和写入时间，超时返回错误
	*func (f *File) SetDeadline(t time.Time) error
	*/

	/*
	file, _ := os.Open("tmp.txt")
	file.SetDeadline(time.Now())
	*/

	/**
	*设置文件读取时间
	*func (f *File) SetReadDeadline(t time.Time) error
	*/

	/*
	file, _ := os.Open("tmp.txt")
	file.SetReadDeadline(time.Now())
	*/

	/**
	*设置文件写入时间
	*func (f *File) SetWriteDeadline(t time.Time) error
	*/

	/*
	file, _ := os.Open("tmp.txt")
	file.SetWriteDeadline(time.Now())
	*/

	/**
	*Stat返回描述文件f的FileInfo类型值。如果出错，错误底层类型是*PathError。
	*func (f *File) Stat() (FileInfo, error)
	*/

	/*
	file, _ := os.Open("tmp.txt")
	fmt.Println(file.Stat())
	*/

	/**
	*Sync递交文件的当前内容进行稳定的存储。一般来说，这表示将文件系统的最近写入的数据
	*在内存中的拷贝刷新到硬盘中稳定保存。
	*func (f *File) Sync() error
	*/

	/*
	file, _ := os.Open("tmp.txt")
	err := file.Sync()
	fmt.Println(err)
	*/

	/**
	*
	*func (f *File) SyscallConn() (syscall.RawConn, error)
	*/


	/**
	*截断更改指定文件的大小。如果文件是符号链接，它将更改链接目标的大小。如果有错误，它将
	*是 * PathError 类型。
	*func (f *File) Truncate(size int64) error
	*/

	/*
	os.Truncate(FilePath, 1024)
	*/


	/**
	*写入内容（向文件内添加内容）
	*func (f *File) Write(b []byte) (n int, err error)
	*/

	/*
	if _, err := f.Write([]byte("appended some data\n")); err != nil {
		log.Fatal(err)
	}
	*/

	/**
	*WriteAt 将 len（b） 个字节写入从字节偏移 off 开始的 File 。它返回写入的字节数和错误
	*（如果有的话）。当 n！= len（b） 时，WriteAt 返回一个非零错误。
	*func (f *File) WriteAt(b []byte, off int64) (n int, err error)
	*/

	/*
	file, _ := os.Open("tmp.txt")
	n, err := file.WriteAt([]byte("hello world"), 10)
	fmt.Println(n, err)
	*/

	/**
	* WriteString 就像 Write 一样，但是写入字符串s的内容而不是一个字节片段。
	*func (f *File) WriteString(s string) (n int, err error)
	*/

	/*
	file, _ := os.Open("tmp.txt")
	n, err := file.WriteString("sdffhgj")
	fmt.Println(n, err)
	*/




	/*********************************************************************/
	/******************** FileInfo中相关方法讲解 *************************/
	/********************************************************************/


	/**
	*返回一个描述指定文件的FileInfo,如果指定的文件对象是一个符号链接，返回的FileInfo描述
	*该符号链接的信息，本函数不会试图跳转该链接。如果出错，返回的错误值为*PathError类型
	*func Lstat(name string) (FileInfo, error)
	*/

	/*
	fi, err := os.Lstat(FilePath)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("permissions: %#o\n", fi.Mode().Perm()) // 0400, 0777, etc.
	switch mode := fi.Mode(); {
	case mode.IsRegular():
		fmt.Println("regular file")
	case mode.IsDir():
		fmt.Println("directory")
	case mode&os.ModeSymlink != 0:
		fmt.Println("symbolic link")
	case mode&os.ModeNamedPipe != 0:
		fmt.Println("named pipe")
	}
	*/


	/**
	*判断文件是否存在
	*func Stat(name string) (FileInfo, error)
	*/

	/*
	if _, err := os.Stat(FilePath); err != nil {
		if os.IsNotExist(err) {
			fmt.Println("file does not exist")
		} else {
			log.Fatal(err)
		}
	}
	*/


	/*********************************************************************/
	/******************** LinkError中相关方法讲解 ***********************/
	/********************************************************************/

	/**
	*返回错误的类型
	*func (e *LinkError) Error() string
	*/


	/**
	*返回原始的error
	*func (e *LinkError) Unwrap() erroros包部分的讲解内容比较多，有一些函数和方法没有列出使用案例，可能后续会加以补充，但从应用的角度来看，这个部分的内容也是需要重点掌握的。

	*/


	/*********************************************************************/
	/******************** Process中相关方法讲解 *************************/
	/********************************************************************/

	/**
	*根据进程id查找一个运行中的进程
	*func FindProcess(pid int) (*Process, error)
	*/

	/*
	p, err = os.FindProcess(p.Pid)
	if err != nil {
		log.Fatal(err)
	}
	*/

	/**
	* 使用提供的属性、程序名、命令行参数开始一个新进程
	*func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)
	*/

	/*
	p, err := os.StartProcess("/usr/bin/vim", []string{"/usr/bin/vim", "temp.txt"}, attr)
	if err != nil {
		log.Fatal(err)
	}
	*/

	/**
	*立刻退出进程
	*func (p *Process) Kill() error
	*/

	/*
	p, err = os.FindProcess(p.Pid)
	if err != nil {
		log.Fatal(err)
	}

	if err := p.Kill(); err != nil {
		log.Fatal(err)
	}
	*/

	/**
	*释放将释放与进程 p 关联的任何资源，以便将来无法使用。只有等待时才需要调用 Release
	*func (p *Process) Release() error
	*/

	/*
	p, err = os.FindProcess(p.Pid)
	if err != nil {
		log.Fatal(err)
	}

	err := p.Release()
	*/

	/**
	*信号向过程发送信号。未在Windows上发送中断。
	*func (p *Process) Signal(sig Signal) error
	*/

	/*
	go func() {
		for {
			sig := <-sc
			switch sig {
			case syscall.SIGINT:
				// MySQL Clinet会通过stdin监听SIGINT，再次传入会造成两次kill
				// proc.Signal(syscall.SIGINT)
			default:
				err := proc.Signal(sig)
				if err != nil {
					Error.Fatalln(err)
				}
			}
		}
	}()
	*/


	/**
	*Wait等待进程退出，并返回进程状态和错误。Wait释放进程相关的资源。在大多数的系统上，
	*进程p必须是当前进程的子进程，否则会返回一个错误。
	*func (p *Process) Wait() (*ProcessState, error)
	*/


	/*********************************************************************/
	/******************** ProcessState中相关方法讲解 ********************/
	/********************************************************************/

	/**
	*执行退出的执行状态码
	*func (p *ProcessState) ExitCode() int
	*/


	/**
	*判断是否退出成功
	*func (p *ProcessState) Exited() bool
	*/

	/**
	*返回pid
	*func (p *ProcessState) Pid() int
	*/

	/**
	*
	*func (p *ProcessState) String() string
	*/


	/**
	*
	*func (p *ProcessState) Success() bool
	*/


	/**
	*
	*func (p *ProcessState) Sys() interface{}
	*/

	/**
	*
	*func (p *ProcessState) SysUsage() interface{}
	*/


	/**
	*
	* func (p *ProcessState) SystemTime() time.Duration
	*/

	/**
	*
	*func (p *ProcessState) UserTime() time.Duration
	*/


	/**********************************************************************/
	/******************** SyscallError中相关方法讲解 *********************/
	/********************************************************************/

	/**
	*
	*func (e *SyscallError) Error() string
	*/

	/**
	*
	*func (e *SyscallError) Timeout() bool
	*/

	/**
	*
	*func (e *SyscallError) Unwrap() error
	*/
}

小结

os包部分的讲解内容比较多，有一些函数和方法没有列出使用案例，可能后续会加以补充，但从应用的角度来看，这个部分的内容也是需要重点掌握的。