golang中os包用法

func main() {
	var path string
	if os.IsPathSeparator('') {
		path = ""
	} else {
		path = "/"
	}
	pwd,_ := os.Getwd()
	err := os.Mkdir(pwd+path+"tmp",os.ModePerm)
	if err != nil {
		fmt.Println(err)　　
	}
}

func main() {
	a := os.NewSyscallError("mkdir",nil)
	fmt.Println(a) // nil
	a = os.NewSyscallError("mkdir",errors.New("bad error"))
	fmt.Println(a) //mkdir: bad error
}

func main() {
	err := os.MkdirAll("./a",os.ModePerm)
	os.Chdir("./a")
	os.Create("file.txt")
	fmt.Println(err)//成功创建文件file.txt，返回nil
	os.Chdir("../")
	err = os.RemoveAll("./a")
	fmt.Println(err)//成功删除目录a，返回nil
}

func main() {
	err := os.Setenv("goenv","go environment")
	a := os.Getenv("goenv")
	fmt.Println(err,a) //  <nil> go environment
}

func Symlink(oldname,newname string) error　　　//创建一个newname作为oldname的符号连接，这是一个符号连接（Link是硬连接），与link的硬连接不同，利用Link创建的硬连接，则newname和oldname的file互不影响，一个文件删除，另外一个文件不受影响；但是利用SymLink创建的符号连接，其newname只是一个指向oldname文件的符号连接，当oldname　file删除之后，则newname的文件也就不能够继续使用．
func TempDir() string　　　　　　　　//创建临时目录用来存放临时文件，这个临时目录一般为/tmp
func Truncate(name string,size int64) error //按照指定长度size将文件截断，如果这个文件是一个符号链接，则同时也改变其目标连接的长度，如果有错误，则返回一个错误．

文件操作：

type File

type File struct {
    // contains filtered or unexported fields
}

func Create(name string) (file *File,err error)　　//创建一个文件，文件mode是0666(读写权限)，如果文件已经存在，则重新创建一个，原文件被覆盖，创建的新文件具有读写权限，能够备用与i/o操作．其相当于OpenFile的快捷操作，等同于OpenFile(name string,O_CREATE,0666)
func NewFile(fd uintptr,name string) *File　　　//根据文件描述符和名字创建一个新的文件

   Stdin  = NewFile(uintptr(syscall.Stdin),"/dev/stdin")
    Stdout = NewFile(uintptr(syscall.Stdout),"/dev/stdout")
    Stderr = NewFile(uintptr(syscall.Stderr),"/dev/stderr")

func OpenFile(name string,flag int,perm FileMode) (file *File,err error)　//指定文件权限和打开方式打开name文件或者create文件，其中flag标志如下:

打开标记：

至于操作权限perm，除非创建文件时才需要指定，不需要创建新文件时可以将其设定为０.虽然go语言给perm权限设定了很多的常量，但是习惯上也可以直接使用数字，如0666(具体含义和Unix系统的一致).

func Pipe() (r *File,w *File,err error) //返回一对连接的文件，从r中读取写入w中的数据，即首先向w中写入数据，此时从r中变能够读取到写入w中的数据，Pipe()函数返回文件和该过程中产生的错误．

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

func main() {
	dir,_ := os.Getwd()
	fmt.Println(dir)
	f,_ := os.Open("tmp.txt") 
	err := f.Chdir()
	if err != nil {
		fmt.Println(err)　　　//chdir tmp.txt: not a directory，因为tmp.txt不是目录，所以报错
	}
	f,_ = os.Open("develop")
	err = f.Chdir()
	if err != nil {
		fmt.Println(err)
	}
	dir1,_ := os.Getwd()
	fmt.Println(dir1)　　　 //home/work/develop，因为develop是工作目录，所以变切换到该目录
}

如果n>0，Readdir返回最多n个FileInfo结构。在这种情况下，如果Readdir返回一个空的切片，它将会返回一个非空的错误来解释原因。在目录的结尾，错误将会是io.EOF。

如果n<=0，Readdir返回目录的所有的FileInfo，用一个切片表示。在这种情况下，如果Readdir成功（读取直到目录的结尾），它会返回切片和一个空的错误。如果它在目录的结尾前遇到了一个错误，Readdir返回直到当前所读到的FIleInfo和一个非空的错误。

Readdirnames读取并返回目录f里面的文件的名字切片。

如果n>0，Readdirnames返回最多n个名字。在这种情况下，如果Readdirnames返回一个空的切片，它会返回一个非空的错误来解释原因。在目录的结尾，错误为EOF。

如果n<0，Readdirnames返回目录下所有的文件的名字，用一个切片表示。在这种情况下，如果用一个切片表示成功（读取直到目录结尾），它返回切片和一个空的错误。如果在目录结尾之前遇到了一个错误，Readdirnames返回直到当前所读到的names和一个非空的错误。

package main

import (
	"fmt"
	"os"
)

func main() {
	file,err := os.Open("/home/chenbaoke")
	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)　　　　　//输出所有文件的名字
	}
}

func main() {
	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 main() {
	file,_ := os.Create("tmp.txt")
	a := "hellobyte"
	file.WriteAt([]byte(a),10)      //在文件file偏移量10处开始写入hellobyte
	file.WriteString("string")　　//在文件file偏移量0处开始写入string
	file.Write([]byte(a))                //在文件file偏移量string之后开始写入hellobyte，这个时候就会把开始利用WriteAt在offset为10处开始写入的hellobyte进行部分覆盖
	b := make([]byte,20)
	file.Seek(0,0)          　　　　//file指针指向文件开始位置
	n,_ := file.Read(b)
	fmt.Println(string(b[:n]))  //stringhellobytebyte，这是由于在写入过程中存在覆盖造成的
}

type FileInfo interface {
	Name() string       //文件名字
	Size() int64        // length in bytes for regular files; system-dependent for others，文件大小
	Mode() FileMode     // file mode bits，文件权限
	ModTime() time.Time // modification time　文件更改时间
	IsDir() bool        // abbreviation for Mode().IsDir()　文件是否为目录
	Sys() interface{}   // underlying data source (can return nil)　　基础数据源
}

func Lstat(name string) (fi FileInfo,err error) //返回描述文件的FileInfo信息。如果文件是符号链接，返回的FileInfo描述的符号链接。Lstat不会试着去追溯link。如果出错，将是 *PathError类型。
func Stat(name string) (fi FileInfo,err error) //返回描述文件的FileInfo信息。如果出错，将是 *PathError类型。

type FileMode

type FileMode uint32

const (
	// The single letters are the abbreviations
	// used by the String method's formatting.
	ModeDir        FileMode = 1 << (32 - 1 - iota) // d: is a directory
	ModeAppend                                     // a: append-only
	ModeExclusive                                  // l: exclusive use
	ModeTemporary                                  // T: temporary file (not backed up)
	ModeSymlink                                    // L: symbolic link
	ModeDevice                                     // D: device file
	ModeNamedPipe                                  // p: named pipe (FIFO)
	ModeSocket                                     // S: Unix domain socket
	ModeSetuid                                     // u: setuid
	ModeSetgid                                     // g: setgid
	ModeCharDevice                                 // c: Unix character device,when ModeDevice is set
	ModeSticky                                     // t: sticky

	// Mask for the type bits. For regular files,none will be set.
	ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice

	ModePerm FileMode = 0777 // permission bits
)

func main() {
	fd,err := os.Stat("tmp.txt")
	if err != nil {
		fmt.Println(err)
	}
	fm := fd.Mode()
	fmt.Println(fm.IsDir())     //false
	fmt.Println(fm.IsRegular()) //true
	fmt.Println(fm.Perm())      //-rwxrwxrwx
	fmt.Println(fm.String())    //-rwxrwxrwx
}

type LinkError struct { Op string Old string New string Err error }

func (e *LinkError) Error() string　　　　//LinkError记录了一个在链接或者符号连接或者重命名的系统调用中发生的错误和引起错误的文件的路径。

type PathError

type PathError struct {
Op string
Path string
Err error
}

进程相关操作：

type ProcAttr

type ProcAttr struct {
    Dir   string               //如果dir不是空，子进程在创建之前先进入该目录
    Env   []string　　　//如果Env不是空，则将里面的内容赋值给新进程的环境变量，如果他为空，则使用默认的环境变量
    Files []*File　　　  //Files指定新进程打开文件，前三个实体分别为标准输入，标准输出和标准错误输出，可以添加额外的实体，这取决于底层的操作系统，当进程开始时，文
　　　　　　　　　　//件对应的空实体将被关闭
    Sys   *syscall.SysProcAttr  //操作系统特定进程的属性，设置该值也许会导致你的程序在某些操作系统上无法运行或者编译
}

Process存储了通过StartProcess创建的进程信息。

type Process struct {
    Pid int
     handle uintptr 　　//处理指针
      isdone uint32        // 如果进程正在等待则该值非０，没有等待该值为０
 }