os包

# 3. os包

package main

import (
	"fmt"
	"os"
)

func main() {
	// 1、获取当前目录
	fmt.Println(os.Getwd())
	// 2、修改当前目录
	os.Chdir("/Users/")
	fmt.Println(os.Getwd())
	// 3、创建文件夹
	os.Mkdir("go_demo", 0777)
	// 4、删除文件夹或者文件
	os.Remove("go_demo")
	// 5、修改文件夹或者文件的名称
	os.Rename("go_demo", "new_demo_go")
	// 6、新建文件
	os.Create("./file.txt")
	// 7、打开文件并写入文件
	/*
	   O_RDONLY 打开只读文件
	   O_WRONLY 打开只写文件
	   O_RDWR 打开既可以读取又可以写入文件
	   O_APPEND 写入文件时将数据追加到文件尾部
	   O_CREATE 如果文件不存在，则创建一个新的文件
	*/
	file, _ := os.OpenFile("file.txt", os.O_RDWR|os.O_APPEND, 0666)
	_, err := file.WriteString("你好222")
	fmt.Println(err)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

原文：https://cloud.tencent.com/developer/article/1342799

os包提供了操作系统函数的不依赖平台的接口。设计为Unix (opens new window)风格的，虽然错误处理是go风格的；失败的调用会返回错误值而非错误码。通常错误值里包含更多信息。例如，如果某个使用一个文件名的调用（如Open、Stat）失败了，打印错误时会包含该文件名，错误类型将为*PathError，其内部可以解包获得更多信息。

os包的接口规定为在所有操作系统中都是一致的。非公用的属性可以从操作系统特定的syscall包获取.

# 1.获取当前目录

func Getwd() (dir string, err error)

示例

func main() {
  fmt.Println(os.Getwd())
}

1
2
3

# 2.修改当前目录

func Chdir(dir string) error
package main
import (
  "fmt"
  "os"
)
func main() {
  fmt.Println(os.Getwd())
  os.Chdir("/Users/xujie")
  fmt.Println(os.Getwd())
}

1
2
3
4
5
6
7
8
9
10
11

我们通过os.Chdir("/Users/xujie")当前目录修改为/Users/xujie

我们看一个应用案例,比如我们要读取桌面上的一个文件file.txt里面的内容

package main

import (
  "fmt"
  "os"
  "log"
    "io/ioutil"
)

func main() {
  fmt.Println(os.Getwd())
  // 切换当前目录为桌面
  os.Chdir("/Users/xujie/Desktop")
  // 打开文件
  file,error := os.Open("file.txt")
  
  defer file.Close()
  if error != nil{
    log.Fatal(error)
  }
  // 读取文件
  data,_ := ioutil.ReadAll(file)
  fmt.Println(string(data))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

注意文件操作完成后，需要调用close()方法关闭文件

# 3.修改文件权限

func Chmod(name string, mode FileMode) error

什么是文件或者文件夹的权限?

先使用命令行在任意目录下输入指令 ls -lih

rwxr-xr-- 中前三个字符“rwx”表示文件所属用户对该文件有读，写和运行权限；中间三个字符“r-x”表示该文件所属用户组成员对该文件有读和运行权限，没有写权限；最后三个字符“r--”表示其他用户对该文件只有读权限，没有写权限和运行权限。

第一字段：inode
第二字段：第一个字符表示文件类型，后面9个字符表示文件权限；
第三字段：硬链接个数；
第四字段：属主；
第五字段：所归属的组；
第六字段：文件或目录的大小；
第七字段和第八字段：最后访问或修改时间；
第九字段：文件名或目录名

第二个字段还包含 SUID, SGID, SBIT 权限

SUID

当 s 这个标志出现在文件拥有者的 x 权限上时,如上 /usr/bin/passwd 这个文件的权限状态，此时就被称为 Set UID，简称为 SUID 的特殊权限。基本上SUID有这样的限制与功能：

SUID 权限仅对二进位程序(binary program)有效(不能够用在 shell script 上面)
运行者对於该程序需要具有 x 的可运行权限
本权限仅在运行该程序的过程中有效 (run-time)
运行者将具有该程序拥有者 (owner) 的权限

SGID

与 SUID 不同的是，SGID 可以针对文件或目录来配置！如果是对文件来说， SGID 有如下的功能：

SGID 对二进位程序有用,程序运行者对於该程序来说，需具备 x 的权限
运行者在运行的过程中将会获得该程序群组的权限

如果针对的是目录,SGID 有如下的功能：

使用者若对於此目录具有 r 与 x 的权限时，该使用者能够进入此目录；
使用者在此目录下的有效群组(effective group)将会变成该目录的群组；

Sticky Bit

这个 Sticky Bit, SBIT 目前只针对目录有效作用是：

当使用者对於此目录具有 w, x 权限，亦即具有写入的权限时；
当使用者在该目录下创建文件或目录时，仅有自己与 root 才有权力删除该文件

chmod

改变文件的权限, SUID, SGID, SBIT等等的特性

数字类型改变文件权限

各权限的分数对照表如下：

SUID: 4
SGID: 2
SBIT: 1
r: 4
w: 2
x: 1

每种身份特殊权限(SUID/SGID/SBIT)和(owner/group/others)各自的三个权限(r/w/x)分数是需要累加的

例如当权限为： [-rwxrwx---] 分数则是：

owner = rwx = 4+2+1 = 7

group = rwx = 4+2+1 = 7

others= --- = 0+0+0 = 0

例如当权限为： [-rwsr-sr-x] 分数则是：

特殊权限 = SUID&&SGID = 4+2 = 6

owner = rws = 4+2+1 = 7

group = r-s = 4+1 = 5

others= r-x = 4+1 = 5

试着将刚才的目录修改为不可读

package main

import (
  "fmt"
  "os"
    )

func main() {
  fmt.Println(os.Getwd())
  os.Chdir("/Users/xujie/Desktop")
  os.Chmod("file.txt",0)
}

1
2
3
4
5
6
7
8
9
10
11
12

当我们再次打开文件时，提示不可读

我们想要可读可写,只要把文件的权限打开即可如下

package main

import (
  "fmt"
  "os"
      )

func main() {
  fmt.Println(os.Getwd())
  os.Chdir("/Users/xujie/Desktop")
  os.Chmod("file.txt",0777)
}

1
2
3
4
5
6
7
8
9
10
11
12

# 4.获取用户识别码uid 和群组识别码gid

func Getuid()  int 
func Getgid()  int  // 有效的用户识别码
func Geteuid() int  // 有效的群组识别码
func Getgid()  int

1
2
3
4

示例代码

package main

import (
  "fmt"
  "os"
  )

func main() {
  fmt.Println(os.Getwd())
  os.Chdir("/Users/xujie/Desktop")
  fmt.Println(os.Getuid())
  println(os.Getgid())
}

1
2
3
4
5
6
7
8
9
10
11
12
13

# 5.查看用户所属组的列表

func Getgroups() ([]int, error)
package main

import (
  "fmt"
  "os"
      )

func main() {
  fmt.Println(os.Getgroups())
}

1
2
3
4
5
6
7
8
9
10
11

# 6. 获取调用者有效的用户标识

返回调用者的数字有效用户标识
package main

import (
  "fmt"
  "os"
      )

func main() {
  fmt.Println(os.Geteuid())
}

1
2
3
4
5
6
7
8
9
10
11

# 7.返回底层系统的内存页面大小

func Getpagesize() int
package main

import (
  "fmt"
  "os"
      )

func main() {
  fmt.Println(os.Getpagesize())
}

1
2
3
4
5
6
7
8
9
10
11

# 8.获取主机名称

func Hostname() (name string, err error)
package main

import (
  "fmt"
  "os"
      )
func main() {
  fmt.Println(os.Hostname())
}

1
2
3
4
5
6
7
8
9
10

# 9.获取当前进程id 和其父进程id

func Getpid() 获取当前进程id

func Getppid() 获取父进程id

package main

import (
  "fmt"
  "os"
      )

func main() {
  fmt.Println(os.Getpid())
  fmt.Println(os.Getppid())
}

1
2
3
4
5
6
7
8
9
10
11

# 10.获取文件的状态

func Stat(name string) (FileInfo, error)

package main

import (
  "fmt"
  "os"
)

func main() {
  filename := "/Users/xujie/Desktop/file.txt"
  file,_:=os.Stat(filename)
  fmt.Println(file.Name())
  fmt.Println(file.IsDir())
  fmt.Println(file.Size())
  fmt.Println(file.Mode())
  fmt.Println(file.Sys())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 11.错误检测

func IsExist(err error) bool // 文件存在,但是由系统产生错误
func IsNotExist(err error) bool // 目录或者文件不存在时返回true
func IsPermission(err error)bool // 检测是不是由于权限不足导致的错误

1
2
3

package main

import (
  "fmt"
  "os"
)

func main() {
  filename := "file.txt"
  _, err := os.Stat(filename);
  fmt.Println(os.IsExist(err))
  fmt.Println(os.IsNotExist(err))
}

1
2
3
4
5
6
7
8
9
10
11
12
13

我们把文件file.txt 的权限修改为只读的，执行下面的代码

package main

import (
  "os"
    "fmt"
)

func main() {
  os.Chdir("/Users/xujie/Desktop")
  file,error := os.OpenFile("file.txt",os.O_RDWR,0444)
  if error != nil {
    fmt.Println(os.IsPermission(error))
    fmt.Println(os.IsPermission(error))
    return
  }
  _,error = file.WriteString("neirong")
   if error != nil {
     fmt.Println(error)
     fmt.Println(os.IsPermission(error))
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 12.创建文件夹

func Mkdir(name string, perm FileMode) error

示例

package main

import (
    "os"
  "fmt"
)

func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 创建一个文件夹
 error := os.Mkdir("go_demo",0777)
 if error != nil{
   fmt.Println(error)
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

如果我们再次运行这个程序,会发生什么?

# 13.删除文件夹或者文件

func Remove(name string) error
package main

import (
    "os"
  "fmt"
)

func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 移除文件夹
 error := os.Remove("go_demo")
 if error != nil{
   fmt.Println(error)
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 14.修改文件夹或者文件的名称

func Rename(oldpath, newpath string) error

示例

package main
import (
    "os"
  "fmt"
)
func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 创建一个文件夹
 error := os.Rename("go_demo","new_demo_go")
 if error != nil{
   fmt.Println(error)
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 15.移动文件夹或者文件

func Rename(oldpath, newpath string) error

和14用的是同一个方法

package main
import (
    "os"
  "fmt"
)
func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 创建一个文件夹
 error := os.Rename("new_demo_go","/Users/xujie/Desktop/未命名文件夹/new_demo_go")
 if error != nil{
   fmt.Println(error)
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 16.新建文件

func Create(name string) (*File, error)

这个方法创建文件是默认的权限为0666,如果已经存在同名的文件,则调用此方法,会覆盖掉原来的文件

package main

import (
    "os"
  "fmt"
)
func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 创建一个文件夹
 file,error := os.Create("file.txt")
 if error != nil{
   fmt.Println(error)
 }
 fmt.Println(file)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 17.打开文件

func Open(name string) (*File, error)

示例

package main

import (
    "os"
  "fmt"
)

func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 创建一个文件夹
 file,error:= os.Open("file.txt")
 if error != nil {
   fmt.Println(error)
 }
 fmt.Println(file)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

如果打开的文件不存在,则会返回错误 open file1.txt: no such file or directory

# 18.写入文件

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)

1
2
3

复制

package main

import (
    "os"
  "fmt"
)

func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 创建一个文件夹
 file,error:= os.Open("file2.txt")
 if error != nil {
   fmt.Println(error)
 }
 _,error = file.WriteString("你好")
  fmt.Println(error)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

为什么会报错？我们先看一下open方法 `func Open(name string) (*File, error) {

return OpenFile(name, O_RDONLY, 0)

参数传递的是只读的,所以我们写入不成功,这里我们需要用到下面一个方法

func OpenFile(name string, flag int, perm FileMode) (*File, error)

第二个参数

O_RDONLY 打开只读文件
O_WRONLY 打开只写文件
O_RDWR 打开既可以读取又可以写入文件
O_APPEND 写入文件时将数据追加到文件尾部
O_CREATE 如果文件不存在，则创建一个新的文件
O_EXCL 文件必须不存在，然后会创建一个新的文件
O_SYNC 打开同步I/0
O_TRUNC 文件打开时可以截断

第三个参数就是权限模式

下面我们看下面的例子

package main

import (
    "os"
  "fmt"
)

func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 创建一个文件夹
 file,error:= os.OpenFile("file.txt",os.O_RDWR,0666)
 defer file.Close()
 if error != nil {
   fmt.Println(error)
 }
 _,error = file.WriteString("你好")
  _,error = file.WriteString("从天有一个书")
  fmt.Println(error)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这样就完成了文件的写入，我们发现文件原来的内容已经被替换掉了,如果我们只想向文件中追加部分内容该如何实现？

package main

import (
    "os"
  "fmt"
)

func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
  // 创建一个文件夹
 file,error:= os.OpenFile("file.txt",os.O_RDWR|os.O_APPEND,0666)
 defer file.Close()
 if error != nil {
   fmt.Println(error)
 }
 _,error = file.WriteString("\n---酷走天涯")
  fmt.Println(error)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 19.读取文件

示例

package main

import (
    "os"
  "fmt"
)

func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
 file,error:= os.Open("file.txt")

 defer file.Close()
 if error != nil {
   fmt.Println(error)
   return
 }
  fileInfo,_ := file.Stat()
  fmt.Println(fileInfo.Size())
  
  // 创建缓冲区
 data := make([]byte,fileInfo.Size())
 // 一次性读取所有内容到缓冲区中
 _,error = file.Read(data)

  fmt.Println(error)
 fmt.Println(string(data))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

那么如何多次读取文件里面的内容呢?

package main

import (
    "os"
  "fmt"
)

func main() {
  // 进入桌面目录
  os.Chdir("/Users/xujie/Desktop")
 file,error:= os.Open("file.txt")

 defer file.Close()
 if error != nil {
   fmt.Println(error)
   return
 }
  fileInfo,_ := file.Stat()
  fmt.Println(fileInfo.Size())

  // 创建缓冲区
  var max = 3
  var offset int64 = 0
  data := make([]byte,max)
 // 多次读取缓冲区内容

 for {
   _,error = file.ReadAt(data,offset)
   if error != nil {
     fmt.Println(error)
     break;
   }
   offset += 3
   fmt.Println(string(data))

 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 20.删除文件

func Remove(name string) error
package main

import (
    "os"
  "fmt"
)

func main() {
  error := os.Remove("/Users/xujie/Desktop/file.txt")
  if error != nil{
    fmt.Println(error)
  }
  fmt.Println("删除成功")

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

通过上面的代码就删除了指定的文件,如果你删除一个空的文件夹也可使用这个方法,如果需要删除指定目录下面的所有文件呢？

package main

import (
  "os"
  "fmt"
)

func main() {
  error := os.RemoveAll("/Users/xujie/Desktop/未命名文件夹")
  if error != nil{
    fmt.Println(error)
  }
  fmt.Println("删除成功")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 21.关闭文件

func (f *File) Close() error

文件操作完毕后,需要调用此方法进行i/o

# 22.检测文件是否是同一个

func SameFile(fi1, fi2 FileInfo) bool
package main

import (
  "os"
  "fmt"
)

func main() {
  fileInfo1,_:= os.Stat("/Users/xujie/Desktop/DataParser.zip")
  fileInfo2,_:= os.Stat("/Users/xujie/Downloads/DataParser.zip")
  fmt.Println(fileInfo1)
  fmt.Println(fileInfo2)
  fmt.Println(os.SameFile(fileInfo1,fileInfo2))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

复制

image.png

就算是同一个文件,没在同一个路径下也会返回false，判断依据如下

这意味着两个基础结构的 inode 字段是相同的

# 23.获取文件模式相关信息

func (m FileMode) IsDir() bool
func (m FileMode) IsRegular() bool
func (m FileMode) Perm() FileMode
func (m FileMode) String() string

1
2
3
4

复制

package main

import (
"os"
"fmt"
)

func main() {
  fileInfo1,_:= os.Stat("/Users/xujie/Desktop/DataParser.zip")
  fmt.Println(fileInfo1.Mode().String())
  fmt.Println(fileInfo1.Mode().IsRegular())
  fmt.Println(fileInfo1.Mode().IsDir())
  fmt.Println(fileInfo1.Mode().Perm())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

复制

image.png

func (f *File) Chdir() error
package main

import (
  "os"
    "fmt"
)

func main() {
  fmt.Println(os.Getwd())
  os.Chdir("/Users/xujie/Desktop")
  file,_ := os.OpenFile("file.txt",os.O_RDWR,0444)
  file.Chdir()
  fmt.Println(os.Getwd())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

复制

image.png

我们发现当前目录从/Users/xujie/go/src/awesomeProject <nil>切换到了 /Users/xujie/Desktop

# 25.查看文件名称

func (f *File) Name() string

示例

package main

import (
  "os"
    "fmt"
)

func main() {

  os.Chdir("/Users/xujie/Desktop")
  file,_ := os.Open("file.txt")
  fmt.Println(file.Name())
}

1
2
3
4
5
6
7
8
9
10
11
12
13

复制

image.png

# 26.如何查看所有文件夹下的所有文件和文件数量

func (f *File) Readdir(n int) ([]FileInfo, error)

n 表示读取目录下文件的最大数量,n < 0 表示全部

package main
import (
  "os"
    "fmt"
)
func main() {
  file,_ := os.Open("/Users/xujie/Desktop/未命名文件夹")
  files,_ := file.Readdir(10)
  for _,f := range  files {
    fmt.Println(f.Name())
  }
}

1
2
3
4
5
6
7
8
9
10
11
12

复制

# 27.读取文件夹的下面文件的名称

func (f *File) Readdirnames(n int) (names []string, err error)

示例

package main

import (
  "os"
    "fmt"
)

func main() {
  file,_ := os.Open("/Users/xujie/Desktop/未命名文件夹")
  fileNames,_ := file.Readdirnames(-1)
  for _,name := range  fileNames {
    fmt.Println(name)
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

复制

image.png

# 28.获取临时目录的文件夹路径

func TempDir() string
package main
import (
  "os"
  "fmt"
)

func main() {
  dir := os.TempDir()
  fmt.Println(dir)
}

1
2
3
4
5
6
7
8
9
10
11

复制

image.png

# 29.判断字符是否是支持的路径分割符

func IsPathSeparator(c uint8) bool
package main

import (
    "fmt"
  "os"
)

func main() {
 fmt.Println(os.IsPathSeparator('c'))
  fmt.Println(os.IsPathSeparator('\\'))
  fmt.Println(os.IsPathSeparator('/'))
}

1
2
3
4
5
6
7
8
9
10
11
12
13

复制

image.png

# 30.查看环境变量

func Getenv(key string) string
package main

import (
"fmt"
"os"
)

func main() {
  fmt.Println(os.Getenv("GOPATH"))
  fmt.Println(os.Getenv("GOROOT"))
}

1
2
3
4
5
6
7
8
9
10
11
12

复制

image.png

# 31.获取文件对应的unix文件描述符

func (f *File) Fd() uintptr
package main

import (
"fmt"
"os"
)

func main() {
  file,_:= os.Open("/Users/xujie/Desktop")
  fmt.Println(file.Fd())

  file,_= os.Open("/Users/xujie/Desktop/未命名文件夹")
  fmt.Println(file.Fd())
  // 如果文件关闭,将不能获取正确的文件描述符
  file.Close()

  fmt.Println(file.Fd())

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

复制

image.png

# 32.Chown修改文件的用户ID和组ID

func Chown(name string, uid, gid int) error

# 32.修改文件权限

func (f *File) Chmod(mode FileMode) error
package main

import (
"os"
  "fmt"
)

func main() {
  file,_:= os.OpenFile("/Users/xujie/Desktop/file.txt",os.O_RDWR|os.O_APPEND,777)
  fileInfo,_ := file.Stat()
  fmt.Println(fileInfo.Mode())

  err := file.Chmod(0444)
  if err != nil{
    fmt.Println(err)
  }
  fileInfo,_ = file.Stat()
  fmt.Println(fileInfo.Mode())

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

复制

image.png

# 33.强制改变文件大小

两个方法如下

func Truncate(name string, size int64) error
func (f *File)Truncate(size int64) error

1
2

image.png

package main

import (
"os"
  "fmt"
)

func main() {
  file,_:= os.OpenFile("/Users/xujie/Desktop/file.txt",os.O_RDWR|os.O_APPEND,777)
  fileInfo,_ := file.Stat()
  fmt.Println(fileInfo.Size())
  error := file.Truncate(3)
  if error != nil {
   fmt.Println(error)
  }
  fileInfo,_ = file.Stat()
  fmt.Println(fileInfo.Size())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

复制

image.png

代码执行后

image.png

# 34.链接硬链接

硬链接(hard link, 也称链接)就是一个文件的一个或多个文件名。再说白点，所谓链接无非是把文件名和计算机文件系统 (opens new window)使用的节点号链接起来。因此我们可以用多个文件名与同一个文件进行链接，这些文件名可以在同一目录或不同目录

func Link(oldname, newname string) error
package main
import (
"os"
  "fmt"
)
func main() {
  file,error := os.Open("/Users/xujie/Desktop/file.txt")
  if error != nil{
    fmt.Println(error)
  }
  error = os.Link(file.Name(),"/Users/xujie/Desktop/bb.txt")
  if error != nil {
    fmt.Println(error)
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

复制

这个时候就会在桌面生成一个file.txt文件的副本

image.png

# 35.同步保存当前文件的内容

func (f *File) Sync() error

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

package main

import (
  "os"
  "fmt"
)

func main() {
  file,error := os.OpenFile("/Users/xujie/Desktop/file.txt",os.O_RDWR,0777)
  if error != nil{
   fmt.Println(error)
  }
  file.WriteString("新内容")
  file.Sync()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

复制

# 36.NewFile使用给出的Unix文件描述符和名称创建一个文件

func NewFile(fd uintptr, name string) *File

示例如下

package main

import (
  "os"
  "fmt"
)

func main() {
  file,error := os.OpenFile("/Users/xujie/Desktop/file.txt",os.O_RDWR,0777)
  if error != nil{
   fmt.Println(error)
  }
  file = os.NewFile(file.Fd(),"/Users/xujie/Desktop/hahha.txt")
  file.WriteString("dddddd")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

复制

此时你会发现文件file.txt 里面的内容已经被修改为ddddd

# 37.Lstat返回一个描述name指定的文件对象的FileInfo

func Lstat(name string) (fi FileInfo, err error)

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

package main

import (
"os"
"fmt"
)

func main() {

 fileInfo,_ :=  os.Lstat("/Users/xujie/Desktop/file.txt")
 fmt.Println(fileInfo.Name())
 fmt.Println(fileInfo.Size())
 fmt.Println(fileInfo.IsDir())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

复制

image.png

# 38.查看所有环境变量

func Environ() []string

Environ返回表示环境变量的格式为"key=value"的字符串的切片拷贝

package main

import (
"os"
"fmt"
)

func main() {

 envs :=  os.Environ()
 for _,env := range envs{
   fmt.Println(env)
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

复制

image.png

# 39.查看指定值对应的环境变量

func LookupEnv(key string) (string, bool)

key值是区分大小写的

package main

import (
"os"
"fmt"
)

func main() {

 name,_ :=  os.LookupEnv("HOME")
 fmt.Println(name)
}

1
2
3
4
5
6
7
8
9
10
11
12

复制

image.png

# 39.清除环境变量

func Environ() []string

请谨慎操作

# 40.获取当前程序可执行的文件地址

func Executable() (string, error)
package main

import (
  "os"
  "fmt"
)

func main() {

  name,_ := os.Executable()
  fmt.Println(name)
}

1
2
3
4
5
6
7
8
9
10
11
12
13

复制

image.png

# 41.查找指定环境变量

func func Expand(s string, mapping func(string) string) string
func ExpandEnv(s string) string

1
2

方法 -

package main

import (
  "os"
  "fmt"
)

func main() {
  //HOME=/Users/xujie
  fmt.Println(os.Expand("${GOPATH}",os.Getenv))
}

1
2
3
4
5
6
7
8
9
10
11

复制

image.png

方法 2

package main

import (
  "os"
  "fmt"
)

func main() {
  //HOME=/Users/xujie

  fmt.Println(os.ExpandEnv("${HOME}"))
  fmt.Println(os.ExpandEnv("$GOPATH"))
}

1
2
3
4
5
6
7
8
9
10
11
12
13

复制

# 42.让程序已给定的状态码退出

Exit让当前程序以给出的状态码code退出。一般来说，状态码0表示成功，非0表示出错。程序会立刻终止，defer的函数不会被执行

func Exit(code int)
package main

import "os"

func main() {
   os.Exit(23)

}

1
2
3
4
5
6
7
8
9

复制

image.png

# 43.设置环和取消环境变量

func Unsetenv(key string) error
func Setenv(key, value string) error

1
2

示例

package main

import (
	"os"
)

func main() {
	os.Setenv("TMPDIR", "/my/tmp")
	defer os.Unsetenv("TMPDIR")
}

1
2
3
4
5
6
7
8
9
10

复制

# 44.创建软链接

软链接和硬链接的区别 (opens new window)

func Symlink(oldname, newname string) error

示例

package main

import (
  "os"
  "fmt"
)

func main() {

  err := os.Symlink("/Users/xujie/Desktop/file.txt","/Users/xujie/Desktop/软链接.txt")
  fmt.Println(err)
}

1
2
3
4
5
6
7
8
9
10
11
12

复制

image.png

# 45.获取软链接文件对应的实际文件路径地址

func Readlink(name string) (string, error)
package main

import (
  "os"
  "fmt"
)
func main() {
  err := os.Symlink("/Users/xujie/Desktop/file.txt","/Users/xujie/Desktop/软链接.txt")
  path,_ := os.Readlink("/Users/xujie/Desktop/软链接.txt")
  fmt.Println(err)
  fmt.Println(path)
}

1
2
3
4
5
6
7
8
9
10
11
12
13

复制

image.png

# 46.更改指定文件的访问和修改时间

func Chtimes(name string, atime time.Time, mtime time.Time) error

第二个参数访问时间第三个参数修改时间

 os.Chtimes("/Users/xujie/Desktop/file.txt",time.Now(),time.Now().Add(time.Hour * 24))

复制

image.png

我们把修改时间改成了明天

# 47.创建文件夹,并设置权限

func MkdirAll(path string, perm FileMode) error

规则

1.如果已经存在同名文件夹,则此方法不做任何事情

2.文件夹里面所有文件都是同样的权限

 os.MkdirAll("/Users/xujie/Desktop/未命名文件夹2",0200)

复制

image.png

# 48.设置文章的读写位置

func (f *File) Seek(offset int64, whence int) (ret int64, err error)

Seek设置下一次读/写的位置。offset为相对偏移量，而whence决定相对位置：0为相对文件开头，1为相对当前位置，2为相对文件结尾。它返回新的偏移量（相对开头）和可能的错误

我们写一个示例,以此读取10个自己,知道读取文件所有的内容

package main

import (
  "os"
  "fmt"
)

func main() {

 file,error := os.Open("/Users/xujie/Desktop/file.txt")
 defer  file.Close()
 if error != nil {
   fmt.Println(error)
   return
 }

 offset := int64(0)
 data := make([]byte,10)
 totalData := make([]byte,0,100)

 for {
  // 设置偏移量 
  file.Seek(offset,0)
  offset += 10
  // 读取数据
  _,error = file.Read(data)
   if error != nil{
     fmt.Println(error)
     break
   }
  // 拼接数据
  totalData = append(totalData,data...)
   fmt.Println(string(data))
 }
  fmt.Println(string(totalData))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

复制

image.png

file.Seek(offset,0) offset = 0 从文件中读取10个数据,之后偏移量设置为offset = 10,则从文件内容第11个字节开始读取，当Read方法读取文件到结尾时,会返回EOF标识,这个时候程序退出for循环

# 49.修改文件权限

func Lchown(name string, uid, gid int) error
package main
import (
  "os"
  "fmt"
)
func main() {
 error := os.Lchown("/Users/xujie/Desktop/file.txt",os.Getuid(),-1)
  if error != nil {
    fmt.Println(error)
  }
}

1
2
3
4
5
6
7
8
9
10
11
12

复制

修改权限前

image.png

修改权限后

image.png

# 50.管道的用法

func Pipe() (r *File, w *File, err error)

复制

这个方法主要在协程之间进行数据传递，r.read 方法会等待接受w文件中写数据

package main

import (
  "os"
    "fmt"
    "time"
)

func main() {
  r,w,error := os.Pipe()
  go write(w)
  data := make([]byte,1000)
  // 如果数据没有写入w中,则此方法一直在等待
  n,_ := r.Read(data)
  if error != nil{
    println(error)
  }
  fmt.Println("读取数据：")
  fmt.Println(string(data[:n]))
}

func write(w *os.File){
  time.AfterFunc(time.Second* 2, func() {
     w.WriteString("ABCD")
     w.WriteString("EFGH")
     fmt.Println("数据已写入w")
  })
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

复制

# 51.创建系统错误

func NewSyscallError(syscall string, err error) error

# 52.通过pid查找进行进程

func FindProcess(pid int) (*Process, error)

查找增加运行的进程,但是在 Unix 系统上，无论过程是否存在，FindProcess 都会成功并为给定的 PID 返回一个 Process

package main

import (
  "os"
    "fmt"
  )

func main() {
 pid := os.Getpid()
 process,error := os.FindProcess(pid)
 if error != nil{
   fmt.Println(error)
 }
 fmt.Println(pid)
 fmt.Println(process)
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

复制

image.png

# 53.启动一个进行

func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)

# 54.杀死进程

func (p *Process) Kill() error
package main

import (
  "os"
    "fmt"
      )

func main() {

 pid := os.Getpid()
 process,error := os.FindProcess(pid)
 if error != nil{
   fmt.Println(error)
 }
 process.Kill()
 // 进行杀死 下面就不会执行了
 fmt.Println(pid)
 fmt.Println(process)

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

复制

image.png

# 55.释放与进行p关联的任何资源

func (p *Process) Release() error

Release释放进程p绑定的所有资源，使它们（资源）不能再被（进程p）使用。只有没有调用Wait方法时才需要调用本方法

func (p *Process) Signal(sig Signal) error

func (p *Process) Wait() (*ProcessState, error)

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

func (e *SyscallError) Error() string

上次更新: 2023/11/21, 16:59:48

← time包 flag包→

os包

# 3. os包

# 1.获取当前目录

# 2.修改当前目录

# 3.修改文件权限

# 4.获取用户识别码uid 和 群组识别码gid

# 5.查看用户所属组的列表

# 6. 获取调用者有效的用户标识

# 7.返回底层系统的内存页面大小

# 8.获取主机名称

# 9.获取当前进程id 和其父进程id

# 10.获取文件的状态

# 11.错误检测

# 12.创建文件夹

# 13.删除文件夹或者文件

# 14.修改文件夹或者文件的名称

# 15.移动文件夹或者文件

# 16.新建文件

# 17.打开文件

# 18.写入文件

# 19.读取文件

# 20.删除文件

# 21.关闭文件

# 22.检测文件是否是同一个

# 23.获取文件模式相关信息

# 24.把文件所在的目录切换为当前目录

# 25.查看文件名称

# 26.如何查看所有文件夹下的所有文件和文件数量

# 27.读取文件夹的下面文件的名称

# 28.获取临时目录的文件夹路径

# 29.判断字符是否是支持的路径分割符

# 30.查看环境变量

# 31.获取文件对应的unix文件描述符

# 32.Chown修改文件的用户ID和组ID

# 32.修改文件权限

# 33.强制改变文件大小

# 34.链接 硬链接

# 35.同步保存当前文件的内容

# 36.NewFile使用给出的Unix文件描述符和名称创建一个文件

# 37.Lstat返回一个描述name指定的文件对象的FileInfo

# 38.查看所有环境变量

# 39.查看指定值对应的环境变量

# 39.清除环境变量

# 40.获取当前程序可执行的文件地址

# 41.查找指定环境变量

# 42.让程序已给定的状态码退出

# 43.设置环和取消环境变量

# 44.创建软链接

# 45.获取软链接文件对应的实际文件路径地址

# 46.更改指定文件的访问和修改时间

# 47.创建文件夹,并设置权限

# 48.设置文章的读写位置

# 49.修改文件权限

# 50.管道的用法

# 51.创建系统错误

# 52.通过pid查找进行进程

# 53.启动一个进行

# 54.杀死进程

# 55.释放与进行p关联的任何资源

# 4.获取用户识别码uid 和群组识别码gid

# 34.链接硬链接