命令交互
package main
import "fmt"
func main() {
var age int
n1, err1 := fmt.Scanln(&age) //12
fmt.Println(n1, err1, age)
var str string
n2, err2 := fmt.Scanf("%d %s", &age, &str) //12 Jack
fmt.Println(n2, err2, age, str)
}
文件
OS包下FIle结构体封装文件操作
打开文件
os.Open
package main
import (
"fmt"
"os"
)
func main() {
file, err := os.Open("./text.txt")
if err != nil {
fmt.Println(err)
return
}
err = file.Close()
if err != nil {
fmt.Println(err)
return
}
}
os.Create
os.OpenFile
func OpenFile(name string, flag int, perm FileMode) (*File, error)
os.Open()、os.Create()都是调用的os.OpenFile()
flag可以使用|进行组合
// Flags to OpenFile wrapping those of the underlying system. Not all
// flags may be implemented on a given system.
const (
// Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
O_RDONLY int = syscall.O_RDONLY // open the file read-only.
O_WRONLY int = syscall.O_WRONLY // open the file write-only.
O_RDWR int = syscall.O_RDWR // open the file read-write.
// The remaining values may be or'ed in to control behavior.
O_APPEND int = syscall.O_APPEND // append data to the file when writing.
O_CREATE int = syscall.O_CREAT // create a new file if none exists.
O_EXCL int = syscall.O_EXCL // used with O_CREATE, file must not exist.
O_SYNC int = syscall.O_SYNC // open for synchronous I/O.
O_TRUNC int = syscall.O_TRUNC // truncate regular writable file when opened.
)
perm是unix下的文件权限控制，windows下无效
一次性读写文件
package main
import (
"fmt"
"os"
)
func main() {
filePath := "E:\\GoBaseCode\\src\\gocode\\test.txt"
content, err := os.ReadFile(filePath)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(content)
fmt.Printf("%s", content)
err = os.WriteFile(filePath, append(content, "\nHello World 5"...), 0666)
if err != nil {
fmt.Println(err)
return
}
}
缓冲区读写文件
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main() {
file, err := os.Open("E:\\GoBaseCode\\src\\gocode\\test.txt")
if err != nil {
fmt.Println(err)
panic("xxx")
}
defer func(file *os.File) {
err := file.Close()
if err != nil {
}
}(file)
reader := bufio.NewReader(file)
for {
str, err := reader.ReadString('\n')
fmt.Print(str)
if err == io.EOF {
break
}
}
}
package main
import (
"bufio"
"os"
)
func main() {
file, err := os.OpenFile("E:\\GoBaseCode\\src\\gocode\\test.txt", os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
return
}
defer func(file *os.File) {
err := file.Close()
if err != nil {
}
}(file)
writer := bufio.NewWriter(file)
writer.WriteString("Hello World 4")
writer.Flush() //将缓存区数据刷到磁盘
}
复制文件
io.CopyBuffer()
func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)
序列化和反序列化
json
package main
import (
"encoding/json"
"fmt"
)
func main() {
//序列化的目的在于系统间传输
//一般个系统间对于数据的存储格式是不一致的，所以需要序列化为通用数据格式
//一般基本数据如整型、字符等基本类型各系统表示一致
//所以最需要序列化的其实是复杂数据类型，如Go中的结构体、Java中的类
//基本数据类型
var num float64 = .314
bytes, err := json.Marshal(num)
if err != nil {
return
}
fmt.Printf("%s\n", bytes)
var num2 float64
err2 := json.Unmarshal(bytes, &num2) //基本数据类型需要由系统开辟栈内存或者手动开辟堆内存
var num3 *float64 = new(float64)
json.Unmarshal(bytes, num3) //感觉有点理解指针和引用的区别了，好像还是不太一样的
fmt.Println(*num3)
if err != nil {
fmt.Println(err2)
return
}
println(num2)
//结构体
type User struct {
Name string `json:"name,omitempty"`
Gender string `json:"gender,omitempty"`
Age int `json:"age,omitempty"`
}
user := User{
Name: "张三",
Gender: "男",
Age: 18,
}
bytes2, err := json.Marshal(user)
if err != nil {
return
}
fmt.Printf("%s\n", bytes2)
var user2 User
err3 := json.Unmarshal(bytes2, &user2)
if err3 != nil {
return
}
fmt.Printf("%v\n", user2)
//map序列化
m := map[string]interface{}{"A": 1, "B": 2}
bytes3, err := json.Marshal(m)
if err != nil {
return
}
fmt.Printf("%s\n", bytes3)
var m2 map[string]interface{}
err4 := json.Unmarshal(bytes3, &m2) //引用数据类型自动make
if err4 != nil {
return
}
fmt.Printf("%v\n", m2)
//slice序列化
s := []map[string]any{
{"A": 1, "B": 2},
{"A": 1, "B": 2},
{"A": 1, "B": 2},
}
bytes4, err := json.Marshal(s)
if err != nil {
return
}
fmt.Printf("%s\n", bytes4)
var s2 []map[string]any
err5 := json.Unmarshal(bytes4, &s2)
if err5 != nil {
return
}
fmt.Printf("%v\n", s2)
}
xml
两个核心函数
- 将struct编码为xml，可以接收任意类型
func Marshal(v interface{}) ([]byte, error)
- 将xml转码为struct结构体
func Unmarshal(data []byte, v interface{}) error
两个核心结构体
- 从输入流读取并解析xml
type Decoder struct {
// ...
}
- 写xml到输出流
type Encoder struct {
// contains filtered or unexported fields
}