160 lines
3.3 KiB
Markdown
160 lines
3.3 KiB
Markdown
# 7.5 Files
|
|
|
|
Files are essential objects on every single computer device. It won't come as any surprise to you that web applications also make heavy use of them. In this section, we're going to learn how to operate on files in Go.
|
|
|
|
## Directories
|
|
|
|
In Go, most of the file operation functions are located in the `os` package. Here are some directory functions:
|
|
|
|
- func Mkdir(name string, perm FileMode) error
|
|
|
|
Create a directory with `name`. `perm` is the directory permissions, i.e 0777.
|
|
|
|
- func MkdirAll(path string, perm FileMode) error
|
|
|
|
Create multiple directories according to `path`, like `astaxie/test1/test2`.
|
|
|
|
- func Remove(name string) error
|
|
|
|
Removes directory with `name`. Returns error if it's not a directory or not empty.
|
|
|
|
- func RemoveAll(path string) error
|
|
|
|
Removes multiple directories according to `path`. Directories will not be deleted if `path` is a single path.
|
|
|
|
Code sample:
|
|
```Go
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
)
|
|
|
|
func main() {
|
|
os.Mkdir("astaxie", 0777)
|
|
os.MkdirAll("astaxie/test1/test2", 0777)
|
|
err := os.Remove("astaxie")
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
os.RemoveAll("astaxie")
|
|
}
|
|
```
|
|
## Files
|
|
|
|
### Create and open files
|
|
|
|
There are two functions for creating files:
|
|
|
|
- func Create(name string) (file *File, err Error)
|
|
|
|
Create a file with `name` and return a read-writable file object with permission 0666.
|
|
|
|
- func NewFile(fd uintptr, name string) *File
|
|
|
|
Create a file and return a file object.
|
|
|
|
|
|
There are also two functions to open files:
|
|
|
|
- func Open(name string) (file *File, err Error)
|
|
|
|
Opens a file called `name` with read-only access, calling `OpenFile` under the covers.
|
|
|
|
- func OpenFile(name string, flag int, perm uint32) (file *File, err Error)
|
|
|
|
Opens a file called `name`. `flag` is open mode like read-only, read-write, etc. `perm` are the file permissions.
|
|
|
|
### Write files
|
|
|
|
Functions for writing files:
|
|
|
|
- func (file *File) Write(b []byte) (n int, err Error)
|
|
|
|
Write byte type content to a file.
|
|
|
|
- func (file *File) WriteAt(b []byte, off int64) (n int, err Error)
|
|
|
|
Write byte type content to a specific position of a file.
|
|
|
|
- func (file *File) WriteString(s string) (ret int, err Error)
|
|
|
|
Write a string to a file.
|
|
|
|
Code sample:
|
|
```Go
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
)
|
|
|
|
func main() {
|
|
userFile := "astaxie.txt"
|
|
fout, err := os.Create(userFile)
|
|
if err != nil {
|
|
fmt.Println(userFile, err)
|
|
return
|
|
}
|
|
defer fout.Close()
|
|
for i := 0; i < 10; i++ {
|
|
fout.WriteString("Just a test!\r\n")
|
|
fout.Write([]byte("Just a test!\r\n"))
|
|
}
|
|
}
|
|
```
|
|
### Read files
|
|
|
|
Functions for reading files:
|
|
|
|
- func (file *File) Read(b []byte) (n int, err Error)
|
|
|
|
Read data to `b`.
|
|
|
|
- func (file *File) ReadAt(b []byte, off int64) (n int, err Error)
|
|
|
|
Read data from position `off` to `b`.
|
|
|
|
Code sample:
|
|
```Go
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
)
|
|
|
|
func main() {
|
|
userFile := "asatxie.txt"
|
|
fl, err := os.Open(userFile)
|
|
if err != nil {
|
|
fmt.Println(userFile, err)
|
|
return
|
|
}
|
|
defer fl.Close()
|
|
buf := make([]byte, 1024)
|
|
for {
|
|
n, _ := fl.Read(buf)
|
|
if 0 == n {
|
|
break
|
|
}
|
|
os.Stdout.Write(buf[:n])
|
|
}
|
|
}
|
|
```
|
|
### Delete files
|
|
|
|
Go uses the same function for removing files and directories:
|
|
|
|
- func Remove(name string) Error
|
|
|
|
Remove a file or directory called `name`.( *** a `name` ending with `/` signifies that it's a directory*** )
|
|
|
|
## Links
|
|
|
|
- [Directory](preface.md)
|
|
- Previous section: [Templates](07.4.md)
|
|
- Next section: [Strings](07.6.md)
|