08 Operación de archivos y conversión de formato JSON

Operaciones de archivo

os.File encapsula todas las operaciones relacionadas con archivos, el archivo es una estructura

Acceda a los archivos
func Abrir (nombre de la cadena) (archivo * Archivo, error err)
para abrir un archivo para la operación posterior, la operación es exitosa se devuelve el objeto del archivo; de lo contrario, devuelve información de excepción
fun (f * Archivo) Cerrar ( ) error
cerró el archivo para que el archivo no pueda ser Se pueden producir errores al leer, escribir y devolver.

func OpenFile (cadena de nombre, indicador int, perm fileMode) (file * File, err error)
Abrir función de archivo, use la opción especificada, el modo especificado para abrir el archivo especificado.
Los valores de las banderas son los siguientes:

valor del parámetro fileMode: lo mismo que el control de permisos de archivos de Linux, 0666 significa lectura y escritura

func Copy (dst Writer, src Reader) (escrito int64, err error)
copia de archivo

Leer código de archivo

func test01(){
    
    
	//打开文件
	file,err := os.Open("C:\\E\\goworks\\src\\go04\\file\\test01.txt")
	if err!= nil {
    
    
		fmt.Println("open file err",err)
		return
	}
	
	//fmt.Printf("file=v% \n",file)

	//读取文件内容
	reader := bufio.NewReader(file)
	for{
    
    
		str,err := reader.ReadString('\n')//读到一个换行就结束
		fmt.Println(str)
		if err == io.EOF{
    
    
			break
		}
		
	}

	err = file.Close()//关闭文件
	if err!= nil{
    
    
		fmt.Println("close file err",err)
		return 
	}
}

Escribir código de archivo

//文件写入
func test02(){
    
    
	//打开文件
	filePath :="C:\\E\\goworks\\src\\go04\\file\\test02.txt"
	file,err := os.OpenFile(filePath,os.O_WRONLY|os.O_CREATE,0666)

	if err!= nil {
    
    
		fmt.Println("open file err",err)
		return
	}
	defer file.Close()
	
	//fmt.Printf("file=v% \n",file)

	//读取文件内容
	writer := bufio.NewWriter(file)
	for i:=0;i<5;i++{
    
    
		writer.WriteString("nihao\n")
	}
	//writer 是写缓存，因此写完后必须调用Flush 方法，将缓存数据持久化
	writer.Flush()
}

Copia de archivo

//文件复制
func CopyFile(dstFileName string,srcFileName string)(written int64,err error){
    
    
	srcFile,err:=os.Open(srcFileName)
	if(err != nil){
    
    
		fmt.Println("打开文件异常",err)
		return
	}
	//if()
	disFile,err:=os.OpenFile(dstFileName,os.O_WRONLY|os.O_CREATE,0666)
	if(err != nil){
    
    
		fmt.Println("打开文件异常",err)
		return
	}
	defer srcFile.Close()
	defer disFile.Close()
	reader := bufio.NewReader(srcFile)
	writer:=bufio.NewWriter(disFile)

	return io.Copy(writer,reader)

}

¿Existe el archivo?

//判断文件是否存在
func PathExists(path string)(bool,error){
    
    
	_,err := os.Stat(path)
	//如果os.Stat 方法未返回异常 则 表示目录存在
	if err==nil{
    
    
		return true,nil
	}
	//如果 返回了异常 判断 os.IsNotExist 返回true 
	//表示目录不存在
	
	if os.IsNotExist(err){
    
    
		return false,nil
	}
	//其他情况不确定是否存在
	return false,err
}

Conversión de formato JSON

La notación de objetos javascript es un formato ligero de intercambio de datos. Se ha convertido en el formato de datos principal. La conversión entre la cadena de formato json y la estructura de datos es un estándar de lenguaje.

Serialización: convierte la estructura de datos calificada en una cadena JSON.
Deserialización: la deserialización se refiere a la conversión de una cadena JSON en la estructura de datos correspondiente
.

1. Para la serialización de la estructura, si queremos volver a personalizar el nombre del campo después de la serialización, podemos definir la etiqueta etiqueta en la estructura.
   Código de muestra

func test05(){
    
    
	mon :=Monster{
    
    
		Name:"牛魔王",
		Age:100,
		Skill:"必杀技",
	}
	//序列化
	data,_:=json.Marshal(&mon)
	//{"Name":"牛魔王","MonsterAge":100,"Skill":"必杀技"}
	fmt.Println(string(data))

	//反序列化
	var a Monster ;
	json.Unmarshal(data,&a) 
	fmt.Println("struct反序列化结果：",a)


	//map 序列化
	map1 := map[string] interface{
    
    }{
    
    
		"name":"tom",
		"age":18,
		"skill":"bisha",
	}

	data,_ =json.Marshal(map1)
	fmt.Println(string(data))//{"age":18,"name":"tom","skill":"bisha"}
	
	//反序列化
	var b map[string] interface{
    
    }
	json.Unmarshal(data,&b) 
	fmt.Println("map反序列化结果：",b)
	
	//切片序列化
	var sli []map[string]interface{
    
    } 
	var m1 map[string]interface{
    
    }
	m1 = make(map[string]interface{
    
    })
	m1["name"]="tom"
	m1["age"]=19
	m1["skill"]="haha"
	sli=append(sli,m1)

	data,_ = json.Marshal(sli)
	//[{"age":19,"name":"tom","skill":"haha"}]
	fmt.Println(string(data))
	//反序列化
	var c []map[string]interface{
    
    } 
	json.Unmarshal(data,&c) 
	fmt.Println("map反序列化结果：",c)

	//基本类型序列化
	data,_ = json.Marshal(18)
	fmt.Println(string(data))//18
}