path/filepath

filepath 包提供对文件路径的操作，兼容不同的操作系统

网站查询：
filepath使用方法
本地查询方法：

# 如果官网访问不了或时间太长可以查看本地的标准库 与官网没什么区别。只不过官网更直观而已
ligz@DESKTOP-911J8B9 MINGW64 /d/projects
# 查看filepath下面的方法及filepath的说明
$ go doc path/filepath
package filepath // import "path/filepath"
Package filepath implements utility routines for manipulating filename paths
in a way compatible with the target operating system-defined file paths.
The filepath package uses either forward slashes or backslashes, depending
on the operating system. To process paths such as URLs that always use
forward slashes regardless of the operating system, see the path package.
const Separator = os.PathSeparator ...
var ErrBadPattern = errors.New("syntax error in pattern")
var SkipDir error = fs.SkipDir
func Abs(path string) (string, error)
func Base(path string) string
func Clean(path string) string
func Dir(path string) string
func EvalSymlinks(path string) (string, error)
func Ext(path string) string
func FromSlash(path string) string
func Glob(pattern string) (matches []string, err error)
func HasPrefix(p, prefix string) bool
func IsAbs(path string) (b bool)
func Join(elem ...string) string
func Match(pattern, name string) (matched bool, err error)
func Rel(basepath, targpath string) (string, error)
func Split(path string) (dir, file string)
func SplitList(path string) []string
func ToSlash(path string) string
func VolumeName(path string) string
func Walk(root string, fn WalkFunc) error
func WalkDir(root string, fn fs.WalkDirFunc) error
type WalkFunc func(path string, info fs.FileInfo, err error) error
ligz@DESKTOP-911J8B9 MINGW64 /d/projects
# 查看Abs详细用法及说明
$ go doc path/filepath Abs
package filepath // import "path/filepath"
func Abs(path string) (string, error)
    Abs returns an absolute representation of path. If the path is not absolute
    it will be joined with the current working directory to turn it into an
    absolute path. The absolute path name for a given file is not guaranteed to
    be unique. Abs calls Clean on the result.

常用的函数：

Abs: 绝对路径
Base：文件名
Clean：清除文件路径中.、..等字符
Dir: 文件目录
Ext：获取文件后缀
FromSlash：格式化路径分隔符(\t)
ToSlash:格式化路径分隔符(/)
Glob：获取匹配格式的文件路径切片
IsAbs：判断是否为绝对路径
Json：链接路径
Match：判断路径是否匹配
Split：分割文件目录和文件名
SplitList：分割路径分隔符(冒号或分号)连接的文件路径
Walk：遍历目录中文件(子孙)
实操

说明：实操代码贴入2个文件代码，一个文件是演示代码本身，另外一个文件是运行时的测试代码，如果是新手建议使用goland，配置简单容易上手,如不做特殊说明这些文件都处于同一个目录中

$ ll learnFilePath/
total 5
-rw-r--r-- 1 ligz 197121 1285 Aug 25 22:49 learnFilePath.go
-rw-r--r-- 1 ligz 197121   94 Aug 25 22:35 learnFilePath_test.go

learnFilePath.go

package learnFilePath
import (
    "fmt"
    "io/fs"
    "os"
    "path/filepath"
)
func BasicFilePath() {
    // 绝对路径
    fmt.Println(filepath.Abs("."))
    // 是否绝对路径
    fmt.Println(filepath.IsAbs("."))
    // 可执行文件返回启动当前进程的可执行文件的路径名
    exe, _ := os.Executable()
    fmt.Println(filepath.IsAbs(exe))
    // 目录
    fmt.Println(filepath.Dir(exe))
    fmt.Println(filepath.Base(exe))
    fmt.Println(filepath.Split(exe))
    fmt.Println(filepath.Ext(exe))
    fmt.Println(filepath.FromSlash(exe))
    fmt.Println(filepath.FromSlash("D:/projects/golangLearn/basicproject/learnFilePath"))
    fmt.Println(filepath.ToSlash(exe))
    fmt.Println(filepath.ToSlash("D:\\projects\\golangLearn\\basicproject\\learnFilePath"))
    fmt.Println(filepath.Glob("c:\\Users\\ligz\\Downloads\\*.pdf"))
    fmt.Println(filepath.Match("D:\\*\\learnFilePath\\*.go", "D:\\projects\\golangLearn\\basicproject\\learnFilePath\\learnFilePath.go"))
    fmt.Println(filepath.Join("d:\\", "projects", "test.go"))
    fmt.Println(filepath.SplitList(os.Getenv("PATH")))
    // 遍历目录中的文件
    filepath.Walk("d:\\projects", func(path string, info fs.FileInfo, err error) error {
        if info.IsDir() && info.Name() != "projects" {
            return filepath.SkipDir
        }
        fmt.Println(path)
        return nil
    })
}

learnFilePath_test.go

package learnFilePath
import "testing"
func TestFilePath(t *testing.T) {
    BasicFilePath()
}

执行结果

GOROOT=C:\Program Files\Go #gosetup
GOPATH=C:\Users\ligz\go #gosetup
"C:\Program Files\Go\bin\go.exe" test -c -o C:\Users\ligz\AppData\Local\Temp\GoLand\___basicproject_learnFilePath__TestFilePath.test.exe basicproject/learnFilePath #gosetup
"C:\Program Files\Go\bin\go.exe" tool test2json -t C:\Users\ligz\AppData\Local\Temp\GoLand\___basicproject_learnFilePath__TestFilePath.test.exe -test.v -test.paniconexit0 -test.run ^\QTestFilePath\E$ #gosetup
=== RUN   TestFilePath
D:\projects\golangLearn\basicproject\learnFilePath <nil>
false
true
C:\Users\ligz\AppData\Local\Temp\GoLand
___basicproject_learnFilePath__TestFilePath.test.exe
C:\Users\ligz\AppData\Local\Temp\GoLand\ ___basicproject_learnFilePath__TestFilePath.test.exe
.exe
C:\Users\ligz\AppData\Local\Temp\GoLand\___basicproject_learnFilePath__TestFilePath.test.exe
D:\projects\golangLearn\basicproject\learnFilePath
C:/Users/ligz/AppData/Local/Temp/GoLand/___basicproject_learnFilePath__TestFilePath.test.exe
D:/projects/golangLearn/basicproject/learnFilePath
[c:\Users\ligz\Downloads\gorm-210111075400.pdf c:\Users\ligz\Downloads\上课环境须知.pdf] <nil>
false <nil>
d:\projects\test.go
[C:\Windows\system32 C:\Windows C:\Windows\System32\Wbem C:\Windows\System32\WindowsPowerShell\v1.0\ C:\Windows\System32\OpenSSH\ C:\Program Files\Go\bin C:\Program Files\Git\cmd C:\Users\ligz\AppData\Local\Microsoft\WindowsApps  C:\Users\ligz\AppData\Local\Programs\Microsoft VS Code\bin C:\Users\ligz\go\bin C:\Program Files\Go\bin]
d:\projects
--- PASS: TestFilePath (0.00s)
PASS
进程 已完成，退出代码为 0

os

os包提供了对文件、系统和进程的操作函数

网站查询：
os使用方法
本地查询方法：

~ go doc os

文件操作

常用的常量

Stdin 标准输入
Stdout 标准输出
Stderr 标准错误
ModePerm: 0777 默认内置常量权限码值是0777 最大权限

常用的函数
Chmod: 修改文件权限
Chown: 修改文件所属用户、用户组
Chtimes: 修改文件访问时间和修改时间
IsExist: 与os.Stat 一起用于判断文件存在
IsNotExit: 与os.Stat 一起用于判断文件不存在
Link: 创建软连接
Mkdir: 创建文件夹
MkdirAll: 创建文件夹(父目录或多层目录不存在则逐层创建相当于linux下mkdir -p)
Remove: 移除文件或空文件夹
Remove: 移除所有文件
Rename: 重命名
实操
learnOs.go
```go package learnOs

import ( “fmt” “os” “time” )

func BasicLearnOS() { // 创建多层目录，并指定最高权限777 这个可以自己手写755 600等数字 fmt.Println(os.Mkdir(“test/test01/test02”, os.ModePerm)) fmt.Println(os.Mkdir(“test02”, 0755)) fmt.Println(os.MkdirAll(“test/test01/test02”, os.ModePerm))

fmt.Println(os.Rename("test", "test03"))
fmt.Println(os.Rename("test02", "test04"))
time.Sleep(3 * time.Second) // 暂停3秒钟
fmt.Println(os.Remove("test04"))
fmt.Println(os.Remove("test03"))
fmt.Println(os.RemoveAll("test03"))

}

<a name="1zLxy"></a>
#### learnOs_test
```go
package learnOs
import "testing"
func TestBasicLearnOS(t *testing.T) {
    BasicLearnOS()
}

结果

GOROOT=C:\Program Files\Go #gosetup
GOPATH=C:\Users\ligz\go #gosetup
"C:\Program Files\Go\bin\go.exe" test -c -o C:\Users\ligz\AppData\Local\Temp\GoLand\___basicproject_learnOs__TestBasicLearnOS.test.exe basicproject/learnOs #gosetup
"C:\Program Files\Go\bin\go.exe" tool test2json -t C:\Users\ligz\AppData\Local\Temp\GoLand\___basicproject_learnOs__TestBasicLearnOS.test.exe -test.v -test.paniconexit0 -test.run ^\QTestBasicLearnOS\E$ #gosetup
=== RUN   TestBasicLearnOS
mkdir test/test01/test02: The system cannot find the path specified.
<nil>
<nil>
<nil>
<nil>
<nil>
remove test03: The directory is not empty.
<nil>
--- PASS: TestBasicLearnOS (3.01s)
PASS
进程 已完成，退出代码为 0

常用结构体

File 对文件操作

常用函数

Create：创建文件并返回文件对象指针(文件不存在则创建，文件存在则清空)
Open: 打开文件并返回文件对象指针
OpenFile：按指定权限打开文件，并返回文件指针对象

常用方法

Read: 读取文件到字节切片
Write: 写入字节切片到文件
WriteString: 写入字符串到文件
Readdir：获取目录下所有文件信息
Readdirnames：获取目录下所有文件名
Seek：设置文件指针位置
Stat：获取文件状态信息
Sync: 同步文件到硬盘
Close: 关闭文件

实操
learnFile.go

package learnFile
import (
    "fmt"
    "io"
    "os"
)
func LearnFile() {
    f01, err := os.Create("t01.txt")
    if err != nil {
        defer func() {
            _ = f01.Close()
        }()
        fmt.Printf("os create err: %v\n", err)
    }
    n, err := f01.WriteString("我是输入内容")
    fmt.Printf("错误 err: %v\n", err)
    fmt.Printf("影响行数 [%d]\n", n)
    f02, err := os.Open("t01.txt")
    if err != nil {
        defer func() {
            _= f02.Close()
        }()
    }
    var r = make([]byte, 3)
    for {
        n, err := f02.Read(r)
        if err != nil {
            if err == io.EOF{
                break
            }
            fmt.Printf("read file err: %v\n", err)
        }
        fmt.Printf("内容: %v\n", string(r[:n]))
    }
}
func LearnFileSet() {
    f01, err := os.Create("t02.txt")
    if err != nil {
        defer func() {
            _ = f01.Close()
        }()
    }
    n1, err := f01.WriteString("aaaaa")
    if err != nil {
        fmt.Printf("write string err: %v\n", err)
    }
    fmt.Printf("写入内容长度: %d\n", n1)
    var r = make([]byte, 30)
    ret, err := f01.Seek(0, 0)
    fmt.Printf("ret: %v err: %v\n", ret, err)
    for {
        n, err := f01.Read(r)
        if err != nil {
            if err == io.EOF{
                break
            }
            fmt.Printf("read file err: %v\n", err)
        }
        fmt.Printf("读取到的数据: %s\n", string(r[0:n]))
    }
}
func LearnFileOpenErr() {
    f04, err := os.Open("test.txt")
    if err != nil {
        defer func() {
            _ = f04.Close()
        }()
        fmt.Printf("错误信息: %v\n", err)
    }
    n, err := f04.WriteString("init error!")
    if err != nil {
        fmt.Printf("warit string error err: %v\n", err)
    }
    fmt.Printf("n:[%v]\n", n)
}
func LearnOpenFIle() {
    f05, err := os.OpenFile("t03.txt", os.O_CREATE|os.O_APPEND|os.O_RDWR, os.ModePerm)
    if err != nil {
        defer func() {
            _ = f05.Close()
        }()
        fmt.Printf("openfile err: %v\n", err)
    }
    n, err := f05.WriteString("我是使用os.OpenFile方式写入的")
    if err != nil {
        fmt.Printf("write string error err: %v\n", err)
    }
    fmt.Printf("insert number: %d\n", n)
}
func LearnOpenFileOnlyRead() {
    f06, err := os.OpenFile("t03.txt", os.O_RDONLY, os.ModePerm)
    if err != nil {
        defer func() {
            _ = f06.Close()
        }()
        fmt.Printf("openfile err: %v\n", err)
    }
    r := make([]byte, 3)
    for {
        n, err := f06.Read(r)
        if err != nil {
            if err == io.EOF{
                break
            }
            fmt.Printf("read file error err: %v\n", err)
        }
        fmt.Printf("读取到的内容: %s\n", string(r[0:n]))
    }
}

learnFile_test.go

package learnFile
import "testing"
func TestLearnFile(t *testing.T) {
    LearnFile()
}
func TestLearnFileSet(t *testing.T) {
    LearnFileSet()
}
func TestLearnFileOpenErr(t *testing.T) {
    LearnFileOpenErr()
}
func TestLearnOpenFIle(t *testing.T) {
    LearnOpenFIle()
}
func TestLearnOpenFileOnlyRead(t *testing.T) {
    LearnOpenFileOnlyRead()
}

FileInfo 文件状态信息

常用函数

Lstat：获取文件路径文件信息(对于链接返回连接文件信息)
State：获取文件路径文件信息(对于链接返回连接到的文件的信息)、

常用方法

Name：获取文件名
Size：获取文件大小
Mode：获取文件模式
ModTime：获取修改时间
IsDir：判断是否为文件夹

FileMode 文件模式
常用方法
IsDir：判断是否为文件夹

系统操作

常用函数

Environ: 获取环境变量切片
Setenv：设置环境变量
Getenv：获取环境变量
LookupEnv：获取环境变量
Unsetenv：清楚环境变量
Clearenv：清空环境变量
Executable：获取当前执行文件路径
Hostname：获取文件名
TempDir：获取用户home目录
UserHomeDir：获取用户home目录
UserCacheDir：获取用户缓存目录
实操
learnSystem.go
```go package learnSystem

import ( “fmt” “os” )

func LearnSystem() { fmt.Println(os.Executable()) fmt.Println(os.Environ()) fmt.Println(os.Getenv(“PATH”)) fmt.Println(os.Getenv(“DEBUG”)) fmt.Println(os.LookupEnv(“DEBUG”))

fmt.Println(os.Setenv("DEBUG", "True"))
fmt.Println(os.LookupEnv("DEBUG"))
fmt.Println(os.Unsetenv("DEBUG"))
fmt.Println(os.LookupEnv("DEBUG"))
os.Clearenv()
fmt.Println(os.Environ())
fmt.Println(os.Hostname())
fmt.Println(os.TempDir())
fmt.Println(os.UserHomeDir())
fmt.Println(os.UserConfigDir())
fmt.Println(os.UserCacheDir())

}

<a name="ZAcpg"></a>
#### learnSystem_test.go
```go
package learnSystem
import "testing"
func TestLearnSystem(t *testing.T) {
    LearnSystem()
}

执行结果

=== RUN   TestLearnSystem
C:\Users\ligz\AppData\Local\Temp\GoLand\___basicproject_learnSystem__TestLearnSystem.test.exe <nil>
[=::=::\ ALLUSERSPROFILE=C:\ProgramData APPDATA=C:\Users\ligz\AppData\Roaming AR=ar CC=gcc CGO_ENABLED=1 CommonProgramFiles=C:\Program Files\Common Files CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files CommonProgramW6432=C:\Program Files\Common Files COMPUTERNAME=DESKTOP-911J8B9 ComSpec=C:\Windows\system32\cmd.exe CXX=g++ DriverData=C:\Windows\System32\Drivers\DriverData FPS_BROWSER_APP_PROFILE_STRING=Internet Explorer FPS_BROWSER_USER_PROFILE_STRING=Default GCCGO=gccgo GO111MODULE=on GOARCH=amd64 GOCACHE=C:\Users\ligz\AppData\Local\go-build GOENV=C:\Users\ligz\AppData\Roaming\go\env GOEXE=.exe GOHOSTARCH=amd64 GOHOSTOS=windows GOMODCACHE=C:\Users\ligz\go\pkg\mod GONOPROXY=https://goproxy.cn GOOS=windows GOPATH=C:\Users\ligz\go GOPROXY=https://goproxy.cn,https://goproxy.io GOROOT=C:\Program Files\Go GOSUMDB=sum.golang.org GOTOOLDIR=C:\Program Files\Go\pkg\tool\windows_amd64 GOVERSION=go1.16.7 HOMEDRIVE=C: HOMEPATH=\Users\ligz IDEA_INITIAL_DIRECTORY=C:\Users\ligz\Desktop LOCALAPPDATA=C:\Users\ligz\AppData\Local LOGONSERVER=\\DESKTOP-911J8B9 NUMBER_OF_PROCESSORS=12 OneDrive=C:\Users\ligz\OneDrive OS=Windows_NT Path=C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Windows\System32\OpenSSH\;C:\Program Files\Go\bin;C:\Program Files\Git\cmd;C:\Users\ligz\AppData\Local\Microsoft\WindowsApps;;C:\Users\ligz\AppData\Local\Programs\Microsoft VS Code\bin;C:\Users\ligz\go\bin;C:\Program Files\Go\bin PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC PROCESSOR_ARCHITECTURE=AMD64 PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 165 Stepping 3, GenuineIntel PROCESSOR_LEVEL=6 PROCESSOR_REVISION=a503 ProgramData=C:\ProgramData ProgramFiles=C:\Program Files ProgramFiles(x86)=C:\Program Files (x86) ProgramW6432=C:\Program Files PSModulePath=C:\Program Files\WindowsPowerShell\Modules;C:\Windows\system32\WindowsPowerShell\v1.0\Modules PUBLIC=C:\Users\Public SESSIONNAME=Console SystemDrive=C: SystemRoot=C:\Windows TEMP=C:\Users\ligz\AppData\Local\Temp TMP=C:\Users\ligz\AppData\Local\Temp USERDOMAIN=DESKTOP-911J8B9 USERDOMAIN_ROAMINGPROFILE=DESKTOP-911J8B9 USERNAME=ligz USERPROFILE=C:\Users\ligz windir=C:\Windows WXDRIVE_START_ARGS=--wxdrive-setting=0 --disable-gpu --disable-software-rasterizer --enable-features=NetworkServiceInProcess]
C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Windows\System32\OpenSSH\;C:\Program Files\Go\bin;C:\Program Files\Git\cmd;C:\Users\ligz\AppData\Local\Microsoft\WindowsApps;;C:\Users\ligz\AppData\Local\Programs\Microsoft VS Code\bin;C:\Users\ligz\go\bin;C:\Program Files\Go\bin
 false
<nil>
True true
<nil>
 false
[]
DESKTOP-911J8B9 <nil>
C:\Windows
 %userprofile% is not defined
 %AppData% is not defined
 %LocalAppData% is not defined
--- PASS: TestLearnSystem (0.00s)
PASS
进程 已完成，退出代码为 0

进程操作

常用常量

Args：获取命令行参数

常用函数
Getuid：获取进程所属用户ID
Getid：获取进程所属用户组ID
Getpid：获取当前进程id
Getppid：获取父进程ID
Getwd：获取工作目录
Chdir：修改当前工作目录
Exit：退出程序
实操
learnSystem.go
```go package learnSystem

import ( “fmt” “os” )

func LearnProc() { fmt.Println(len(os.Args), os.Args)

fmt.Println(os.Getuid(), os.Getgid(), os.Geteuid())
fmt.Println(os.Getpid(), os.Getppid())
fmt.Println(os.Getwd())
fmt.Println(os.Chdir("d:\\"))
fmt.Println(os.Getwd())

}

<a name="MY8b0"></a>
#### learnSystem_test.go
```go
package learnSystem
import "testing"
func TestLearnProc(t *testing.T) {
    LearnProc()
}

执行结果

API server listening at: 127.0.0.1:51564
=== RUN   TestLearnProc
5 [C:\Users\ligz\AppData\Local\Temp\GoLand\___basicproject_learnSystem__TestLearnProc.test.exe -test.v -test.paniconexit0 -test.run ^\QTestLearnProc\E$]
-1 -1 -1
9512 2708
D:\projects\golangLearn\basicproject\learnSystem <nil>
<nil>
d:\ <nil>
--- PASS: TestLearnProc (0.00s)
PASS
调试器 已完成，退出代码为 0

常用结构体

Process

常用方法

FindProcess：根据进程id查找进程对象指针
StartProcess：启动进程
Kill：杀死进程
Release：释放进程资源信息
Signal：发送信息给进程
Wait: 等待进程退出，并返回进程状态信息指针
- ProcessState

常用方法

ExitCode：退出状态码
Exited：是否已经退出
Pid：进程id
Success：是否成功退出
SystemTime：内核态执行时间
UserTime：用户态执行时间
实操
learnSystem.go
```go package learnSystem

import ( “fmt” “os” “time” )

func LearnProcess(){ process, _ := os.FindProcess(os.Getppid()) fmt.Printf(“process: %T,%+v\n”, process, process)

attr := &os.ProcAttr{
    Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
}
sprocess, err := os.StartProcess("E:\\GoLand 2021.2.1\\bin\\goland64.exe", []string{}, attr)
fmt.Println(sprocess, err)
fmt.Println("--------------------")
// 15秒后kill进程
go func() {
    time.Sleep(15 * time.Second)
    sprocess.Kill()
}()
state, err := sprocess.Wait() // 等待进程结束
if err == nil {
    fmt.Println(state.ExitCode())
    fmt.Println(state.Exited())
    fmt.Println(state.Pid())
    fmt.Println(state.Success())
    fmt.Println(state.Sys())
    fmt.Println(state.SysUsage())
    fmt.Println(state.SystemTime())
    fmt.Println(state.UserTime())
    if err := sprocess.Release(); err != nil {
        fmt.Println(err)
    } // 释放进程资源信息
} else {
    fmt.Println(err)
}

}

<a name="CWxYE"></a>
#### learnSystem_test.go
```go
package learnSystem
import (
    "testing"
)
func TestLearnProcess(t *testing.T) {
    LearnProcess()
}

执行结果

=== RUN   TestLearnProcess
process: *os.Process,&{Pid:7700 handle:308 isdone:0 sigMu:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0}}
&{9596 332 0 {{0 0} 0 0 0 0}} <nil>
--------------------
0
true
9596
true
{0}
&{{234177826 30907116} {234284835 30907116} {0 0} {0 0}}
0s
0s
invalid argument
--- PASS: TestLearnProcess (0.04s)
PASS
进程 已完成，退出代码为 0

os/exec

exec包提供了启动一个外部进程并使用标准输入和输出进行通信

常用函数

LookPath：查找程序所在路径

常用结构体
Cmd：执行命令

常用函数

Command

常用方法

Output：执行并获取标准输出结果
Run：执行命令
Start：启动命令
Wait：与Start 一起使用等待命令结束
StdoutPipe：输出管道
StdinPipe：输入管道
实操
learnExec
```go package learnSystem

import ( “encoding/json” “fmt” “io” “os” “os/exec” )

func LearnExec() { // 查找程序所在的路径 fmt.Println(“查找程序所在的路径”) fmt.Println(exec.LookPath(“语雀.exe”))

// 执行命令获取命令执行后的结果
fmt.Println("执行命令获取命令执行后的结果")
cmd := exec.Command("ping", "-n", "3", "www.taobao.com")
fmt.Printf("%+v\n", cmd)
output, _ := cmd.Output()
fmt.Println(string(output))
// 执行命令
fmt.Println("执行命令")
cmd = exec.Command("ping", "-n", "5", "www.taobao.com")
fmt.Println(cmd.Path, cmd.Args)
fmt.Println(cmd.Run())
// 执行命令通过管道获取结果
fmt.Println("执行命令通过管道获取结果")
cmd = exec.Command("ping", "-n", "5", "www.taobao.com")
stdout, _ := cmd.StdoutPipe()
fmt.Println(cmd.Path, cmd.Args)
fmt.Println(cmd.Start())
water, err := io.Copy(os.Stdout, stdout)
fmt.Println("err:", err, "wter", water)
fmt.Println(cmd.Wait())
// 执行命令， 使用管道获取结果并输入给Json Decoder
fmt.Println("执行命令， 使用管道获取结果并输入给Json Decoder")
user := make(map[string]string)
cmd = exec.Command("C:\\Program Files\\Git\\usr\\bin\\echo", `{"name": "ligz"}`)
stdout, _ = cmd.StdoutPipe()
cmd.Start()
json.NewDecoder(stdout).Decode(&user)
cmd.Wait()
fmt.Printf("%+v\n", user)
// 执行命令， 使用管道连接多个执行命令
fmt.Println("执行命令， 使用管道连接多个执行命令")
cmd01 := exec.Command("C:\\Program Files\\Git\\usr\\bin\\echo", `{"name":"ligz"}`)
cmd02 := exec.Command("c:\\Users\\ligz\\AppData\\Local\\Programs\\Python\\Python39\\python", "-m", "json.tool")
stdout01, _ := cmd01.StdoutPipe()
cmd02.Stdin = stdout01
stdout02, _ := cmd02.StdoutPipe()
fmt.Println(cmd01.Start())
fmt.Println(cmd02.Start())
fmt.Println(cmd01.Wait())
io.Copy(os.Stdout, stdout02)
fmt.Println(cmd02.Wait())

}

<a name="Okbwg"></a>
#### learnExec_test.go
```go
package learnSystem
import "testing"
func TestLearnExec(t *testing.T) {
    LearnExec()
}

执行结果

=== RUN   TestLearnExec
查找程序所在的路径
 exec: "语雀.exe": executable file not found in %PATH%
执行命令获取命令执行后的结果
C:\Windows\system32\ping.exe -n 3 www.taobao.com
���� Ping www.taobao.com.danuoyi.tbcache.com [124.200.113.166] ���� 32 �ֽڵ�����:
���� 124.200.113.166 �Ļظ�: �ֽ�=32 ʱ��=3ms TTL=58
���� 124.200.113.166 �Ļظ�: �ֽ�=32 ʱ��=3ms TTL=58
���� 124.200.113.166 �Ļظ�: �ֽ�=32 ʱ��=4ms TTL=58
124.200.113.166 �� Ping ͳ����Ϣ:
    ���ݰ�: �ѷ��� = 3���ѽ��� = 3����ʧ = 0 (0% ��ʧ)��
�����г̵Ĺ���ʱ��(�Ժ���Ϊ��λ):
    ���� = 3ms��� = 4ms��ƽ�� = 3ms
执行命令
C:\Windows\system32\ping.exe [ping -n 5 www.taobao.com]
<nil>
执行命令通过管道获取结果
C:\Windows\system32\ping.exe [ping -n 5 www.taobao.com]
<nil>
���� Ping www.taobao.com.danuoyi.tbcache.com [124.200.113.166] ���� 32 �ֽڵ�����:
���� 124.200.113.166 �Ļظ�: �ֽ�=32 ʱ��=3ms TTL=58
���� 124.200.113.166 �Ļظ�: �ֽ�=32 ʱ��=3ms TTL=58
���� 124.200.113.166 �Ļظ�: �ֽ�=32 ʱ��=3ms TTL=58
���� 124.200.113.166 �Ļظ�: �ֽ�=32 ʱ��=3ms TTL=58
���� 124.200.113.166 �Ļظ�: �ֽ�=32 ʱ��=3ms TTL=58
124.200.113.166 �� Ping ͳ����Ϣ:
    ���ݰ�: �ѷ��� = 5���ѽ��� = 5����ʧ = 0 (0% ��ʧ)��
�����г̵Ĺ���ʱ��(�Ժ���Ϊ��λ):
    ���� = 3ms��� = 3ms��ƽ�� = 3ms
err: <nil> wter 526
<nil>
执行命令， 使用管道获取结果并输入给Json Decoder
map[name:ligz]
执行命令， 使用管道连接多个执行命令
<nil>
<nil>
<nil>
exit status 1
--- PASS: TestLearnExec (10.27s)
PASS
进程 已完成，退出代码为 0

fmt

fmt包提供输入和输出功能

常用函数

错误类型

Errorf：创建error类型

输出到数据流
Fprint：将数据输出到输出流中，不添加换行
Fprintf：将数据输出到按照一定格式输出到输出流中
Fprintln：将数据输出到输出六种，并添加换行
Fscan：从输入流中读出
Fscanf：从输入流中按照指定格式读取数据
Fscanln：从输入流中读取数据，回车作为结束符

输出到标准输出
Print：将数据输出到标准输出流中，不添加换行
Printf：将数据输出到按照一定格式输出到标准输出流中
Println：将数据输出到标准输出六种，并添加换行

标准输入中读取数据
Scan：从标准输入流中读取数据
Scanf：从标准输入流中按照指定格式读取数据
Scanln：从标准输入流中读取数据，回车作为结束符

转换字符串
Sprint：将数据转换为字符串，不添加换行
Sprintf：将数据按照格式转换为字符串
Sprintln：将数据转换为字符串，并添加换行

字符串中读取数据
Sscan：从字符串中读取数据
Sscanf：从字符串中按照格式读取数据
Sscanln：从字符串中读取数据，回车作为结束符
实操
learnPrint.go
```go package learnPrint

import ( “fmt” “os” )

func LearnErrorf() { fmt.Println(fmt.Errorf(“我是个错误”)) }

func LearnPrint() { fmt.Print(“我是不带换行的标准输出\n”) fmt.Printf(“输出需要指定类型 %s\n”, “args:string”) fmt.Println(“我是带换行的标准输出”)

fmt.Fprint(os.Stdout, "func fmt.Fprint\n")
fmt.Fprintf(os.Stdout, "func %s\n", "fmt.Fprintf")
fmt.Fprintln(os.Stdout, "func fmt.Fprintln")
fmt.Printf("%q\n", fmt.Sprint("我是被当作参数引入的 不带换行\n"))
fmt.Printf("%q\n", fmt.Sprintf("我是被当作参数引入的 %s\n", "引入内容"))
fmt.Printf("%q\n", fmt.Sprintln("我是被当作参数引入的"))

}

func LearnScan() { var ( name string age int weight float32 )

fmt.Print("请输入信息：")
fmt.Scan(&name, &age, &weight)
fmt.Println(name, age, weight)
fmt.Print("请输入信息:")
fmt.Scanf("%s %d %f", &name, &age, &weight)
fmt.Println(name, age, weight)
fmt.Print("请输入信息：")
fmt.Scanln(&name, &age, &weight)
fmt.Println(name, age, weight)

}

<a name="YRLG3"></a>
#### learnPrint_test.go
```go
package learnPrint
import "testing"
func TestLearnErrorf(t *testing.T) {
    LearnErrorf()
}
func TestLearnPrint(t *testing.T) {
    LearnPrint()
}
func TestLearnScan(t *testing.T) {
    LearnScan()
}

实操

=== RUN   TestLearnErrorf
我是个错误
--- PASS: TestLearnErrorf (0.00s)
=== RUN   TestLearnPrint
我是不带换行的标准输出
输出需要指定类型 args:string
我是带换行的标准输出
func fmt.Fprint
func fmt.Fprintf
func fmt.Fprintln
"我是被当作参数引入的 不带换行\n"
"我是被当作参数引入的 引入内容\n"
"我是被当作参数引入的\n"
--- PASS: TestLearnPrint (0.00s)
=== RUN   TestLearnScan
# 由于需要输入内容，在测试中没有进行输入内容。所以获取不到输入内容信息 所以打印了默认值 0 0 ""
请输入信息： 0 0  
请输入信息: 0 0
请输入信息： 0 0
--- PASS: TestLearnScan (0.00s)
PASS
进程 已完成，退出代码为 0

io

io包主要提供对流的基本操作功能

常用常量

EOF：表示文件读取结束

常用函数
Copy：将输出流复制到输入流中
CopyBuffer：将输出流复制到输出流中，同时拷贝到字节切片中
CopyN：从输入流中复制N个字节到输出流
WriteString：像输出流中写入字符串

常用结构体
MultiReader：将多个流合并为一个流，依次从不同流读取数据
MultiWriter：将多个流合并为一个流，在写入时对所有流进行写入
实操

与ioutil写在一起

io/ioutil

ioutil 包主要提供对流的实用操作功能

常用函数

ReadAll：读取流中所有内容
ReadDir：读取目录中文件信息
ReadFile：读取文件
TempDir：创建临时目录
TempFile：创建临时文件
WriteFile：写入文件
实操
learnio.go
```go package learnio

import ( “bytes” “fmt” “io” “io/ioutil” “os” “strings” )

func LearnIo() { sreader := strings.NewReader(“Hello, ligz\n”) io.Copy(os.Stdout, sreader)

breader := bytes.NewReader([]byte("Hello, ligz\n"))
io.Copy(os.Stdout, breader)
bbuffer := bytes.NewBufferString("Hello, ligz\n")
io.CopyN(os.Stdout, bbuffer, 2)
fmt.Println()
io.CopyN(os.Stdout, bbuffer, 2)
fmt.Println()
io.CopyN(os.Stdout, bbuffer, 2)
fmt.Println()
io.WriteString(os.Stdout, "hello, ligz\n")

}

func LearnIoutil() { // 读取文件所有内容 if file, err := os.Open(“t01.txt”); err == nil { defer func() { = file.Close() }() content, := ioutil.ReadAll(file) fmt.Println(string(content)) }

// 读取文件目录
if ffs, err := ioutil.ReadDir("."); err == nil {
    for _, fs := range ffs{
        fmt.Println(fs.Name(), fs.IsDir(), fs.Size(), fs.ModTime(), fs.Mode())
    }
}
// 读取文件内容
if content, err := ioutil.ReadFile("t01.txt"); err == nil {
    fmt.Println(string(content))
}
// 写入文件
ioutil.WriteFile("t01.txt", []byte("我是一只小小鸟，怎么飞也飞不高！"), 0755)
//创建临时文件夹
fmt.Println(ioutil.TempDir("", "test"))
// 创建临时文件
tempFile, _ := ioutil.TempFile("", "test")
defer tempFile.Close()
fmt.Println(tempFile.Name())
io.WriteString(tempFile, "我就看看不说话")
var tmpStr = make([]byte, 1024)
n, _ := tempFile.Read(tmpStr)
fmt.Println(string(tmpStr[:n]))

}

<a name="YI7wL"></a>
#### learnio_test.go
```go
package learnio
import "testing"
func TestLearnIo(t *testing.T) {
    LearnIo()
}
func TestLearnIoutil(t *testing.T) {
    LearnIoutil()
}

执行结果

=== RUN   TestLearnIoutil
我是一只小小鸟，怎么飞也飞不高！
learnio.go false 1467 2021-08-27 15:39:25.2450786 +0800 CST -rw-rw-rw-
learnio_test.go false 135 2021-08-27 15:36:46.8712191 +0800 CST -rw-rw-rw-
t01.txt false 48 2021-08-27 15:36:48.2102834 +0800 CST -rw-rw-rw-
我是一只小小鸟，怎么飞也飞不高！
C:\Users\ligz\AppData\Local\Temp\test108347351 <nil>
C:\Users\ligz\AppData\Local\Temp\test959636298
--- PASS: TestLearnIoutil (0.01s)
PASS
进程 已完成，退出代码为 0

bufio

bufio包提供缓冲流的功能

常用结构体

Reader

常用函数

NewReader：创建缓冲输入流

常用方法

Read：读取数据到切片中
ReadLine：读取一行内容到字节切片中
ReadSlice：根据分隔符读取数据到字节切片
ReadString：根据分隔符读取数据到字符串
Reset：重设缓冲流
WriteTo：将数据写入到输出流
- Scanner

常用函数

NewScanner：创建扫描对象

常用方法

Scan：扫描数据
Split：定义流分割函数，默认是空格
Text：读取数据
Err：获取错误
- Writer

常用函数

NewWriter：创建缓冲输出流

常用方法

Write：将字节切片内容写入
WriteString：将字符串写入
Reset：重置输出流
Flush：刷新数据到输出流
实操
learnBufio.go
```go package learnBufio

import ( “bufio” “bytes” “fmt” “os” “strings” )

func LearnBufio() { // 缓冲输入流 sreader := strings.NewReader(“Hello ligz\nhello, lisi”) breader := bufio.NewReader(sreader) fmt.Println(breader.ReadLine()) fmt.Println(breader.ReadLine()) fmt.Println(breader.ReadLine())

sreader.Seek(0, 0) // 将读取文件的指针位置指向文件起始位置
breader.WriteTo(os.Stdout) // 将数据输出到终端
fmt.Println()

}

func LearnScanner() { // 定义扫描器 scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { fmt.Println(scanner.Text()) }

if err := scanner.Err(); err != nil {
    fmt.Println(err)
}

}

func LearnWriter() { // 缓冲输入流 bbuffer := bytes.NewBufferString(“”) bwriter := bufio.NewWriter(bbuffer) bwriter.WriteString(“hello, ligz\n”) bwriter.Write([]byte(“hello, zhangsan”)) bwriter.Flush()

bbuffer.WriteTo(os.Stdout)

}

<a name="iebUr"></a>
#### learnBufio_test.go
```go
package learnBufio
import "testing"
func TestLearnBufio(t *testing.T) {
    LearnBufio()
}
func TestLearnScanner(t *testing.T) {
    LearnScanner()
}
func TestLearnWriter(t *testing.T) {
    LearnWriter()
}

文件及文件处理

path/filepath

常用的函数：

实操

learnFilePath.go

learnFilePath_test.go

执行结果

os

文件操作

常用的常量

常用的函数

实操

learnOs.go

结果

常用结构体

File 对文件操作

FileInfo 文件状态信息

FileMode 文件模式

系统操作

常用 函数

实操

learnSystem.go

执行结果

进程操作

常用常量

常用函数

实操

learnSystem.go

执行结果

常用结构体

实操

learnSystem.go

执行结果

os/exec

常用函数

常用结构体

实操

learnExec

执行结果

fmt

常用函数

错误类型

输出到数据流

输出到标准输出

标准输入中读取数据

转换字符串

字符串中读取数据

实操

learnPrint.go

实操

io

常用常量

常用函数

常用结构体

实操

io/ioutil

常用函数

实操

learnio.go

执行结果

bufio

常用结构体

实操

learnBufio.go

常用函数