python转go学习笔记———文件操作

文件操作

打开和关闭文件

func main()  {
    //这里的file是file指针或file对象(一个意思)
	file,err := os.Open("D:\\Go_node\\src\\Go_study\\基础\\xixi.txt")
	if err != nil {
		fmt.Println("打开失败：",err)
	}
	fmt.Println("file = ",file)				// file =  &{0xc00007c780}
	//关闭文件
	err = file.Close()
	if err != nil{
		fmt.Println("close file err = ",err)
	}
}

带缓冲区的读取文件内容

func main()  {
	file,err := os.Open("D:\\Go_node\\src\\Go_study\\基础\\xixi.txt")
	if err != nil {
		fmt.Println("打开失败：",err)
	}
	defer file.Close()
	//创建一个reader,是带缓冲的   默认缓冲区为4096
	reader := bufio.NewReader(file)
	//循环读取
	for {
		str,err := reader.ReadString('\n') //读取到换行符就结束
		if err != nil {
			if err == io.EOF { // io.EOF表示文件末尾
				break
			}
		}
		// 输出内容
		fmt.Print(str)
	}
}

读取文件并显示到终端：不适合文件过大的情况，不需要显式的Open和Close文件，已经封装在ReadFile内部。 （不推荐使用）

func main()  {	
	file := "D:\\Go_node\\src\\Go_study\\基础\\xixi.txt"
	content,err := ioutil.ReadFile(file)
	if err != nil{
		//fmt.Println("error is ",err)
		log.Fatal(err)
	}
	fmt.Printf("file content :\n%s",content)
}

创建文件并写入内容

• OpenFile

func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
// FileMode: 只在Linux、Unix有用，不作用于windows系统

//flag文件打开模式：
const (
    O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
    O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
    O_RDWR   int = syscall.O_RDWR   // 读写模式打开文件
    O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
    O_CREATE int = syscall.O_CREAT  // 如果不存在将创建一个新文件
    O_EXCL   int = syscall.O_EXCL   // 和O_CREATE配合使用，文件必须不存在
    O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O
    O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件
)
//FileMode权限控制模式：
const (
    // 单字符是被String方法用于格式化的属性缩写。
    ModeDir        FileMode = 1 << (32 - 1 - iota) // d: 目录
    ModeAppend                                     // a: 只能写入，且只能写入到末尾
    ModeExclusive                                  // l: 用于执行
    ModeTemporary                                  // T: 临时文件（非备份文件）
    ModeSymlink                                    // L: 符号链接（不是快捷方式文件）
    ModeDevice                                     // D: 设备
    ModeNamedPipe                                  // p: 命名管道（FIFO）
    ModeSocket                                     // S: Unix域socket
    ModeSetuid                                     // u: 表示文件具有其创建者用户id权限
    ModeSetgid                                     // g: 表示文件具有其创建者组id的权限
    ModeCharDevice                                 // c: 字符设备，需已设置ModeDevice
    ModeSticky                                     // t: 只有root/创建者能删除/移动文件
    // 覆盖所有类型位（用于通过&获取类型位），对普通文件，所有这些位都不应被设置
    ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
    ModePerm FileMode = 0777 // 覆盖所有Unix权限位（用于通过&获取类型位）
)

例：创建一个新文件，写入任意内容

func main()  {
	//创建一个新文件，写入任意内容
	FilePath := "D:\\Go_node\\src\\Go_study\\基础\\haha.txt"
	file,err := os.OpenFile(FilePath,os.O_CREATE|os.O_WRONLY,0777)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()
	// 写入内容
	str := "你叉叉！\n"
	writer := bufio.NewWriter(file)
	for i := 0;i<5;i++ {
		writer.WriteString(str)
	}
	// 因为writer带缓冲，内容先写入buf
	// 所以需要调用flush，将缓存内容真正写入数据
	writer.Flush()
}

判断文件或文件夹是否存在：

os.Stat()

1. 如果返回的错误为nil，说明文件或文件夹存在
2. 如果返回的错误类型使用os.IsNotExist()判断为True，说明文件或文件夹不存在
3. 如果返回的错误为其他类型，则不确定文件是否存在

func PathExists(path string) (bool,error) {
	_,err := os.Stat(path)
	if err == nil{
		return true,nil
	}
	if os.IsNotExist(err){
		return false,nil
	}
	return false,err
}

拷贝文件

func Copy(dst Writer, src Reader) (written int64, err error)
//将src的数据拷贝到dst，直到在src上到达EOF或发生错误。返回拷贝的字节数和遇到的第一个错误。

例：拷贝图片

func CopyFile(dstName string,srcName string) (written int64,err error) {
	srcfile,err := os.Open(srcName)
	if err != nil {
		log.Fatal(err)
	}
	defer srcfile.Close()
	reader := bufio.NewReader(srcfile)

	dstfile,err := os.OpenFile(dstName,os.O_WRONLY|os.O_CREATE,0777)
	if err != nil {
		log.Fatal(err)
	}
	writer := bufio.NewWriter(dstfile)
	writer.Flush()
	defer dstfile.Close()

	return io.Copy(writer,reader)
}

func main()  {
	src := "C:\\Users\\11140\\Desktop\\简历\\IMG_3090 .jpg"
	dst := "C:\\Users\\11140\\Desktop\\照片 .jpg"
	_,err := CopyFile(dst,src)
	if err == nil{
		fmt.Println("拷贝完成")
	}
}

JSON序列化

func Marshal(v interface{}) ([]byte, error)

type Person struct {
	Name string
	Age int
	Birthday string
	Sal float64
}
func testJson(datajson interface{})  {
	//序列化
	data,err := json.Marshal(datajson)
	if err != nil{
		log.Fatal(err)
	}
	fmt.Printf("%v\n",string(data))
}
func main()  {
	//将结构体，map，切片序列化
	person := Person{
		Name: "flandre",
		Age: 20,
		Birthday: "1999-1015",
		Sal: 10000,
	}
	testJson(person)
	//map
	var a map[string]interface{}
	a = make(map[string]interface{})
	a["name"] = "翠花"
	a["age"] = 21
	a["birthday"] = "2021-12-27"
	testJson(a)
	//切片
	var slice []map[string]interface{}

	var m1 map[string]interface{}
	m1 = make(map[string]interface{})
	m1["name"] = "flandre翠花"
	m1["Age"] = "18"
	m1["Sal"] = 8000
	slice = append(slice,m1)

	var m2 map[string]interface{}
	m2 = make(map[string]interface{})
	m2["name"] = "flandre翠花儿"
	m2["Age"] = "10"
	m2["Sal"] = 500
	slice = append(slice,m2)
	testJson(slice)
}

JSON反序列化

type Person struct {
	Name string	`json:"person_name"`	//tag
	Age int `json:"person_age"`
	Birthday string `json:"person_birth"`
	Sal float64 `json:"person_sal"`
}
func main()  {
	myperson := Person{}
	err = json.Unmarshal(data,&myperson)
	if err != nil{
		log.Fatal(err)
	}
	fmt.Println(myperson)
}