catalogue
preface
Files in a computer are data sets stored on external media (hard disk). Files are divided into text files and binary files.
1. Opening and closing files
os. The open() function can open a File and return a * File and an err. For the obtained File example, the close() method can close the File.
Example:
package main import ( "fmt" "os" ) //Opening and closing of files func main() { //Open ABC. In the current directory Txt file file, err := os.Open("./abc.txt") if err != nil { fmt.Println("File open failed", err) } else { fmt.Println("File opened successfully") file.Close() fmt.Println("File closed successfully") } } //The operation result is: D:\goproject\src\dev_code\day25\demo1>go run main.go File opened successfully File closed successfully
2. Read file
Receive a byte slice, return the number of bytes read and possible specific errors, and return 0 and IO when reading to the end of the file EOF.
func (f *File) Read(b []byte) (n int,err error)
Example:
defer is generally used for resource release and exception capture.
The defer statement will delay the following statements; The language following defer will be executed after the final return of the program.
When the function to which defer belongs is about to return, the delayed statements are executed in the reverse order of defer, that is, the statements first deferred are executed last, and the statements last deferred are executed first.
package main import "fmt" func main() { //Delay processing, execute before the function is closed defer fmt.Println("implement defer sentence") for i := 0; i < 5; i++ { fmt.Println(i) } } //The output results are as follows 0 1 2 3 4 implement defer sentence
Example:
package main import "fmt" func hello() { for i := 0; i < 10; i++ { fmt.Println(i) if i == 8 { break } } //Delay processing, execute before the function is closed defer fmt.Println("implement defer") } func main() { hello() } //The operation result is: 0 1 2 3 4 5 6 7 8 implement defer
Example: open a file and get the content.
package main import ( "fmt" "io" "os" ) //read file func main() { //In the created ABC Txt file input content "hello world" file, err := os.Open("./abc.txt") if err != nil { fmt.Println("File open failed", err) return } //Execute file resource release before the end of main function defer file.Close() fmt.Println("File opened successfully") //Define parameter slice var result [128]byte n, err := file.Read(result[:]) //File read complete if err == io.EOF { fmt.Println("File read complete", err) return } //An exception occurred during reading if err != nil { fmt.Println("File read failed", err) return } fmt.Printf("Number of bytes%d individual\n", n) fmt.Printf("The contents obtained are:%s\n", string(result[:])) } //The operation result is: D:\goproject\src\dev_code\day25\demo3>go run main.go File opened successfully Number of bytes: 11 The contents obtained are: hello world
Example: what should I do when the read file content becomes a long document?
Using bufio to read, bufio encapsulates a layer of API based on file and supports more functions.
package main import ( "bufio" "fmt" "io" "os" ) //bufio read file func main() { file, err := os.Open("./abc.txt") if err != nil { fmt.Println("File open failed", err) return } defer file.Close() //bufio buffer reads data reader := bufio.NewReader(file) for { str, err := reader.ReadString('\n') if err == io.EOF { fmt.Print(str) return } if err != nil { fmt.Println("File read failed", err) return } fmt.Print(str) } } //The operation result is: D:\goproject\src\dev_code\day25\demo4>go run main.go <Born in sorrow and die in happiness Shun hair in the mu, Fu Shuo in the plate building, glue in the fish and salt, Guan Yiwu in the scholar, sun shuao in the sea, Baili Xi in the city. Therefore, heaven will lower the great responsibility, so people must first work hard, work their muscles and bones, starve their body and skin, lack their body, and brush their actions. Therefore, they are moved and patient, which has benefited what they can't. People can change after constant mistakes. They are trapped in the heart and balanced in consideration; Sign in color, send in sound, and then metaphor. If you enter, there will be no Legalists, and if you leave, there will be no enemy or foreign invasion. The country will die forever, and then you will know that you were born in hardship and died in happiness. Author: Mencius
Example: ioutil convenient way to read files.
package main import ( "fmt" "io/ioutil" ) //Read file contents in ioutil mode func ReaderFile(path string) { content, err := ioutil.ReadFile(path) if err != nil { fmt.Println("File reading exception") return } fmt.Println(string(content)) //Convert string format and output } func main() { ReaderFile("./abc.txt") } //The operation result is: D:\goproject\src\dev_code\day25\demo5>go run main.go zhangsan lisi 12345 abc123 abc456
Example: read parity line content.
package main import ( "bufio" "fmt" "io" "os" ) func main() { //read file file, err := os.Open("./abc.txt") if err != nil { fmt.Println("File open failed", err) return } //Execute file resource release before the end of main function defer file.Close() //bufio buffer read reader := bufio.NewReader(file) //Count parity rows count := 0 for { str, _, err := reader.ReadLine() count++ if err == io.EOF { // fmt.Println("file read complete") return } if err != nil { fmt.Println("File reading exception", err) return } if count%2 == 1 { fmt.Println(string(str)) } } } //The operation result is: D:\goproject\src\dev_code\day25\demo6>go run main.go zhangsan 12345 abc456
Example: log in and judge whether the user name exists.
package main import ( "bufio" "fmt" "io" "os" ) //read file func main() { //var doing bool var name string fmt.Print("enter one user name:") fmt.Scan(&name) //defer fmt.Println("user does not exist") file, err := os.Open("./abc.txt") if err != nil { fmt.Println("File open failed", err) return } //Before the main function ends, execute file resource release defer file.Close() //Using bufio buffer to read files reader := bufio.NewReader(file) //Create a buffer and put the contents of the file into the buffer //Count parity rows a := 0 for { str, _, err := reader.ReadLine() //Each read, a+1 a++ if err == io.EOF { fmt.Println("File read complete") //If the file is not returned after reading, it indicates that the user does not exist fmt.Println("user does not exist") return } if err != nil { fmt.Println("File read error") return } if a%2 == 1 { if name == string(str) { fmt.Println("Login successful") return } } } } //The operation result is: D:\goproject\src\dev_code\day25\demo7>go run main.go enter one user name:zhangsan Login successful
3. Write file
os. The openfile() function can open a file in the specified mode, so as to realize the functions related to file writing.
func OpenFile(name string,flag int,perm FileMode)(*File,error) { ... } name:File name to open flag:Open file mode
Mode type:
pattern | meaning |
---|---|
os.O_WRONLY | Write only |
os.O_CREATE | create a file |
os.O_RDONLY | read-only |
os.O_RDWR | Reading and writing |
os.O_TRUNC | empty |
os.O_APPEND | Add |
perm: file permission, an octal number. R (read) 04, w (write) 02, X (execute) 01.
Example: Write and WriteString.
package main import ( "fmt" "os" ) //Write using write and writestring func main() { //Open the file in write mode, create a new file, open write only mode, file permission 644 file, err := os.OpenFile("abc.txt", os.O_CREATE|os.O_WRONLY, 0644) if err != nil { fmt.Println("File open failed", err) return } //Byte slice write file.Write([]byte("this is byte write\n")) //String write str := "this is string write" file.WriteString(str) } //The operation result is: After executing the command, a message appears in the current directory abc.txt file D:\goproject\src\dev_code\day25\demo8>go run main.go The contents are as follows: this is byte write this is string write
Example: bufio Write in newwriter mode.
package main import ( "bufio" "fmt" "os" ) //bufio write func main() { file, err := os.OpenFile("tmp.txt", os.O_CREATE|os.O_WRONLY, 0666) //WRONLY, empty if err != nil { fmt.Println("File open failed", err) return } defer file.Close() //File write buffer write := bufio.NewWriter(file) for i := 0; i < 5; i++ { //Content write buffer write.WriteString("this is bufio write\n") } //Buffer data commit write file write.Flush() } //The operation result is: After executing this command, a message appears tmp.txt file D:\goproject\src\dev_code\day25\demo9>go run main.go The contents are as follows: this is bufio write this is bufio write this is bufio write this is bufio write this is bufio write
Example: ioutil Write in WriteFile mode.
package main import ( "fmt" "io/ioutil" ) func main() { str := "this is ioutil write\nthis is test content" //Write directly in iotuil mode, and convert the string into byte array err := ioutil.WriteFile("./tmp.txt", []byte(str), 0666) if err != nil { fmt.Println("File write failed", err) return } } //The operation result is: When this command is executed, an error appears tmp.txt Documents D:\goproject\src\dev_code\day25\demo10>go run main.go The contents are as follows: this is ioutil write this is test content