golang 第5章 （包管理、序列化和反序列化、反射、文件操作）

最新推荐文章于 2024-07-18 15:51:26 发布
最新推荐文章于 2024-07-18 15:51:26 发布
阅读量1k 收藏 20
点赞数 25
分类专栏： golang 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49827178/article/details/135237337
版权

文章目录

包管理

change.go

package ch1

import "fmt"
//ch1 声明一个struct
type Person struct {
	Name string
	Sex  string
	Age  int
}

tempchange.go

package ch1
//不同文件 同包名 对Person结构体（*Perwson 指针类型） 创建方法 Work
import "fmt"
//Work 需要大写 用于可暴露可访问
func (p *Person) Work(x string) string {
	return fmt.Sprintf("%v岁的%v性%v的工作是%v", p.Age, p.Sex, p.Name, x)
}


package main
import (
	"fmt"
	myPkg "testPkg/gopl.io/ch1"
)
//main包中 导入重命名 myPkg（ch1）
func main() {
	v := myPkg.Person{
		Name: "张三",
		Age:  12,
		Sex:  "男",
	}
	//调用指针类型的 Person结构体的实例方法 Work
	fmt.Println((&v).Work("干饭"))
}

1.序列化

Marshal

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

package main

import (
   "encoding/json"
   "fmt"
)

func main() {
   p := Person{Name: "小王", Age: 12}
   data, err := json.Marshal(p)
   if err != nil {
      fmt.Println(err)
   } else {
   //返回一个[]byte//使用string转换//{"Name":"小王","Age":12}
      fmt.Println(string(data))
   }
}

type Person struct {
   Name string
   Age  int
}

2.反序列化

Unmarshal

func Unmarshal([]byte,*type)

package main

import (
   "encoding/json"
   "fmt"
)

func main() {
   p := Person{Name: "小王", Age: 12}
   data, err := json.Marshal(p)
   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(string(data))

   }
   var b Person
   json.Unmarshal(data, &b)
   fmt.Println(b)
   //反序列化
}

type Person struct {
   Name string
   Age  int
}

反射

reflect

import "reflect"

1.反射可以在运行时动态获取变量的各种信息，比如变量的类型（type）,类别（kind）

2.如果是结构体变量，还可以获取结构体本身的信息（包括结构体的字段、方法）

1、reflect.TypeOf()和reflect.ValueOf()

interface{}类型变量其具体类型可以使用reflect.Tpye来表示，而其具体值则使用reflect.Value来表示。而reflect.Type和reflect.Value分别提供reflect.TypeOf()和reflect.ValueOf()来获取interface{}的具体类型及具体值。

package main

import (
	"fmt"
	"reflect"
)

type order struct {
	ordId     int
	customeId int
}

func query(i interface{}) {
	t := reflect.TypeOf(i)
	v := reflect.ValueOf(i)
	fmt.Println(t)
	fmt.Println(v)
}
func main() {
	o := order{
		ordId:     1,
		customeId: 2,
	}
	query(o)
	//main.order
	//{1 2}
}

2、reflect.Kind()//获取的是底层类型（struct、ptr等）

reflect.Name()获取的是类型名称

import (
	"fmt"
	"reflect"
)

func reflectFn(i interface{}) {
	v := reflect.TypeOf(i)
	fmt.Println(reflect.ValueOf(i))
	fmt.Println("v.Name():", v.Name()) //
	fmt.Println("v.Kind():", v.Kind())
}

type Person struct {
	name string
}

func main() {
	p := Person{name: "123"}
	var h = 25
	reflectFn(&h) // Name Person Kind Struct
	reflectFn(p)
}

0xc0000a6058
v.Name():    
v.Kind(): ptr
&{123}       
v.Name():    
v.Kind(): ptr

在reflect还有一个比较重要的类型Kind，也是代表类型，看起来和我们前面提到的reflect.Type很相似，其实两者有着很大的差异：

package main

import (
	"fmt"
	"reflect"
)

type order struct {
	ordId     int
	customeId int
}

func query(i interface{}) {
	t := reflect.TypeOf(i)
	v := reflect.ValueOf(i)
	k := t.Kind()
	fmt.Println(t)
	fmt.Println(v)
	fmt.Println(k)
}
func main() {
	o := order{
		ordId:     1,
		customeId: 2,
	}
	query(o)
	//main.order
	//{1 2}
	//struct
}

通过输出结果我们能够很清楚的看出来reflect.Type和reflect.Kind：Type代表interface{}实际类型main.order;而Kind代表具体类型struct。

3、NumField() 和Field()

NumField()方法获取一个struct所有的fields，Field(i int)获取指定第i个field的reflect.Value,结合具体实例：

package main

import (
	"fmt"
	"reflect"
)

type order struct {
	ordId     int
	customeId int
}

func query(i interface{}) {
	t := reflect.TypeOf(i)
	v := reflect.ValueOf(i)
	k := t.Kind()
	fmt.Println(t)
	fmt.Println(v)
	fmt.Println(k)
	if reflect.ValueOf(i).Kind() == reflect.Struct {
		value := reflect.ValueOf(i)                       //获取i的值
		fmt.Println("Number of fields", value.NumField()) //获取字段总个数
		for j := 0; j < value.NumField(); j++ {
			fmt.Printf("Field:%d type:%T value:%v\n", j, v.Field(j), v.Field(j)) //获取第j个字段的 reflect.Value的类型 和reflect.value
		}
	}
}
func main() {
	o := order{
		ordId:     1,
		customeId: 2,
	}
	query(o)
	//main.order
	//{1 2}
	//struct
	//Number of fields 2
	//Field:0 type:reflect.Value value:1
	//Field:1 type:reflect.Value value:2
}

4、Int() 和String()

Int()和String()主要用于从reflect.Value提取对应值作为int64和string类型

package main
 
import (  
    "fmt"
    "reflect"
)
 
func main() {  
    a := 56
    x := reflect.ValueOf(a).Int()
    fmt.Printf("type:%T value:%v\n", x, x)
    b := "Naveen"
    y := reflect.ValueOf(b).String()
    fmt.Printf("type:%T value:%v\n", y, y)
 
}
//type:int64 value:56  
//type:string value:Naveen

示例：

package main

import (
	"fmt"
	"reflect"
)

type person struct {
	name string
	age  int
}

func main() {
	p := person{
		name: "嚣张",
		age:  123,
	}
	fmt.Println(reflect.TypeOf(p))
	fmt.Println(reflect.ValueOf(p).Kind())
	x := reflect.ValueOf(p)
	fmt.Println(x.NumField())//reflect.Value的字段个数
	fmt.Println(x.Field(0))//reflect.Value第一个字段的值
	fmt.Println(x.Field(1))//第二个字段的值
	fmt.Printf("%T", x.Field(1))//打印第二个字段的值类型//
	fmt.Printf("%T",x.Field(1).String())//使用String()转类型
}

main.person
struct
2     
嚣张  
123   
reflect.Value
string

1.interface{}类型的值到反射reflecton对象.
根源上来说， reflection的原理就是检查interface中保存的一对值和类型, 所以在reflect包中，有两个类型我们需要记住， Type和Value两个类型. 通过这两个类型，我们可以访问一个interface变量的内容. 调用reflect.ValueOf和reflect.TypeOf可以检索出一个interface的值和具体类型. 当然通过reflect.Value我们也可以获得reflect.Type。
2.反射reflection对象到interface{}类型的值.
通过reflect.Value的Interface方法，我们可以获得一个Interface值。实际上这个方法将一个type和value打包回interface
3.当修改一个反射reflection时, 其值必须是settable.

5.Elem()

当传入的是一个指针类型时候

使用Elem()获取具体的元素值

package main

import (
	"fmt"
	"reflect"
)

func reflectSetValue1(x interface{}) {
	//var a = reflect.ValueOf(x)//ptr 获取到的是指针
	//if a.Kind() == reflect.Int64 {
	//	a.SetInt(120)
	//}
	v := reflect.ValueOf(x)
	fmt.Println(v)//ptr 获取到的是指针
	//v.Elem()获取具体的元素值.Kind()获取类型 
	if v.Elem().Kind() == reflect.Int64 {
	//使用setInt修改
		v.Elem().SetInt(123)
	}

}

func reflectSetValue2(x interface{}) {

}
func main() {
	var a int64 = 100
	reflectSetValue1(&a)//传入指针
	fmt.Println(a)
}

文件操作

读取

1.os.Open//只读方式打开文件

package main

import (
   "fmt"
   "io"
   "os"
)

func main() {
   //绝对路径
   //os.Open("E:/GO/demo03/main.go")
   //相对路径
   file, err := os.Open("E:/GO/demo03/main.go")
   defer file.Close()
   if err != nil {
      fmt.Println("打开文件失败", err)
      return
   }
   fmt.Println(file)
   //2读取文件里面的记录
   var tempSlice = make([]byte, 128) //
   var strSlice []byte
   for {
      //
      n, err := file.Read(tempSlice)
      if err == io.EOF {
         fmt.Println("读取完毕")
         break
      }
      if err != nil {
         fmt.Println("读取失败")
         return
      }

      fmt.Println("读取到了", n, "字节")
      strSlice = append(strSlice, tempSlice[:n]...)
   }
   fmt.Println(string(strSlice), "string")
}

2.bufio

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {
	file, err := os.Open("E:/GO/demo01/main.go")
	defer file.Close()
	if err != nil {
		fmt.Println(err)
		return
	}
	var fileStr string
	//bufio读取文件
	reader := bufio.NewReader(file)

	for {
		str, err := reader.ReadString('\n') //表示一次读取一行
		if err == io.EOF {//读取完了可能还会返回io
			fileStr += str
			fmt.Println("文件读取完毕")
			break
		}
		if err != nil {
			fmt.Println("err=", err)
			return
		}
		fmt.Println(str)
	}
	fmt.Println(fileStr)
}

3.readFile（小的简单的文件使用）

package main

import (
	"fmt"
	"os"
)

func main() {
	str, err := os.ReadFile("E:/GO/deo02/main.go")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(str))

}

写入

方法1：

file.Write

package main

import (
	"fmt"
	"os"
)

// 第一种写入文件的方法
func main() {
	file, err := os.OpenFile("E:/GO/README.txt", os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
	defer file.Close()
	if err != nil {
		fmt.Println("失败", err)
		return
	}
	var str = "卧槽\n"
	//写入文件[]byte
	file.Write([]byte(str))
	//写入文件 string
	//file.WriteString(str)

}

方法2：

bufio操作写入

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	file, err := os.OpenFile("E:/GO/README.txt", os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
	defer file.Close()
	if err != nil {
		fmt.Println(err)
		return
	}
	var str = "你好222\n"
	Writer := bufio.NewWriter(file) // bufio.NewWriter传入file对象，创建Writer对象
	//Writer.WriteString(str)         //将数据先写入缓存
	Writer.Write([]byte(str))
	Writer.Flush() //将缓存中的内容写入文件
}

方法2：

os.WriteFile(名字，byte类型切片，权限)

package main

import (
	"fmt"
	"os"
)

func main() {
	//绝对路径
	//os.Open("E:/GO/demo03/main.go")
	//相对路径
	var str = "你好 golang\n"
	err := os.WriteFile("E:/GO/README.txt", []byte(str), 0666)
	if err != nil {
		fmt.Println("失败", err)
	}
}

复制

第一种：os

package main

import (
	"fmt"
	"os"
)

func copy(srcFileName string, dstFileName string) (err error) {
	//读取文件
	byteStr, err := os.ReadFile(srcFileName)
	if err != nil {
		fmt.Println(err)
		return err
	}
	err1 := os.WriteFile(dstFileName, byteStr, 0666)
	if err1 != nil {
		fmt.Println(err1)
		return err1
	}
	fmt.Println("复制文件成功")
	return nil
}
func main() {
	copy("E:/GO/README.txt", "D:/README.txt")
}

第二种：

package main

import (
	"fmt"
	"io"
	"os"
)

func copy(srcFileName string, dstFileName string) (err error) {
	sFile1, err1 := os.Open(srcFileName)
	defer sFile1.Close()
	sFile2, err2 := os.OpenFile(dstFileName, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)//创建 读写 追加
	defer sFile2.Close()
	if err1 != nil {
		return err1
	}
	if err2 != nil {
		return err2
	}
	var tempSlice = make([]byte, 128)
	for {
		//读取数据
		n1, err := sFile1.Read(tempSlice)

		if err == io.EOF {
			fmt.Println("读取完成")
			break
		}
		if err != nil {
			return err
		}
		//写入数据
		if _, err1 := sFile2.Write(tempSlice[:n1]); err1 != nil {
			return err1
		}

	}
	return nil
}
func main() {
	copy("E:/GO/README.txt", "D:/README.txt")
}

创建文件夹

单个文件夹创建

err:=os.Mkdir("./abc",0666)//在当前目录创建文件夹abc
if err!=nil{
	fmt.Println(err)
}

//重复创建

mkdir ./abc: Cannot create a file when that file already exists.

多级创建

err1 := os.MkdirAll("./dir1/dir2/dir3", 0666)
	if err1 != nil {
		fmt.Println(err1)
	}

删除

删除文件和删除一个目录
package main

import (
	"fmt"
	"os"
)

func main() {
	err := os.Remove("D:/README.txt")
	if err != nil {
		fmt.Println(err)
	}
}

err := os.Remove("abc")
	if err != nil {
		fmt.Println(err)
	}

删除所有的目录

err1 := os.RemoveAll("dir1")
	if err1 != nil {
		fmt.Println(err1)
	}

重命名

err := os.Rename("D:/README.txt", "D:/README1.txt")
	if err != nil {
		fmt.Println(err)
	}
青山绿水的蓝
关注
  • 25
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
golang protobuf 的序列化和反序列化
onlymayao的博客
06-30 1175
1、通过proto文件生成go代码 hello.proto syntax = "proto3"; package prototest; message Test { int32 num = 1; string msf = 2; } hello.pb.go // Code generated by protoc-gen-go. DO NOT EDIT. // source: hello.proto /* Package prototest is a generated protocol
Java golang序列化_golang对象序列化和反序列化
weixin_35474374的博客
03-01 270
模拟测试1,000, 000条数据 每条10个字节 也就是10M不到的 数据(高度结构化的数据)过程1.对象序列化为 byte2.byte反序为对象3.gzip压缩byte测试语言go测试方案： raw byte，json ,bson, msgpack (protostuff需要先做对象配置文件，比较麻烦，通常认为和msgpack性能相当 )结果：msgpack 胜出大小gzip压缩后大小对象到...
Java golang序列化_Golang JSON的序列化和反序列化
weixin_35752233的博客
03-04 282
序列化json.Marshal结构体Golang设定结构体字段小写为不可导出，无法序列化不可导出字段。大写字段导出后JSON字符串也将大写，故使用struct tag添加标注json自定义JSON字段名。type Result struct {Code int `json:"code"`Msg string `json:"msg"`Data interface{} `j...
golang json 序列化 和 反序列化
qq_39657769的博客
04-09 762
文章目录结构体 map slice 数据序列化结构体 序列化map 序列化slice 序列化结构体 map slice 数据反序列化结构体 反序列化map 反序列化切片slice 反序列化 结构体 map slice 数据序列化 公用代码 package main import( "fmt" "encoding/json" ) //转换序列号 func testResult(data interface{}){ //返回 []byte 所以打印时需要string 转换 result , er
golang中json反序列化可能遇到的问题
09-20
在Golang中，JSON反序列化是一个常见的任务，但在这个过程中可能会遇到一些问题。本文将深入探讨这些问题并提供相应的解决方案。 首先，让我们了解Golang如何处理JSON反序列化。Golang的标准库`encoding/json`提供...
golang的序列化与反序列化的几种方式
01-19
golang用来序列化的模块有很多，我们来介绍3个。 json 首先登场的是json，这个几乎毋庸置疑。 序列化 package main import ( encoding/json fmt ) type Girl struct { Name string Age int Gender string ...
丰富的Golang二进制（反）序列化库-Golang开发
05-26
restruct restruct是一个用于在Go中读取和写入二进制数据的库。 与lunixbochs struc和encoding / binary类似，该库基于结构布局读取数据，并且像struc一样，基于包含的内容restruct restruct是用于在Go中读写二进制...
Golang处理JSON（二） 反序列化
01-08
在Go语言中，encoding/json标准包处理json数据的序列化与反序列化问题。如果想了解序列化可以看这一篇序列化。与编码json的Marshal类似，解析json也提供了Unmarshal方法。对于解析json，也大致分两步，首先定义结构...
go 实现websocket以及详细设计流程过程，确保通俗易懂
每天进步一点
07-17 882
数据只能单向传送为单工；数据能双向传送但不能同时双向传送称为半双工；数据能够同时双向传送则称为全双工。上面是简单的接受了websocket情况以及和其他协议的区别及联系，在做之前，还是要了解下这块，对后期实战有帮助。
golang小案例获取命令行的的参数并求得最大值
preserveXing的博客
07-15 229
这个案例是Golang理解os.Args的案例 场景就是: 当我们打包后 生成的.exe文件 执行exe肯定会出现哪些命令 例如 npm install app 这里的npm 就是npm .exe install app 就是我们要获取的参数 我们的案例: 编写go程序---->打包成exe--->执行exe--->添加命令行参数 一些数值---->求得最大化数值
Go: IM系统技术架构梳理 (2)
Wang的专栏
07-15 1081
整个IM系统的一般架构如下我们这张图展示了整个IM系统的一般架构可见分为四层那最上面这一层是前端，包括哪些东西呢？它包括两部分，第一部分是跟用户直接交互的比如说各种IOS APP, 各种安卓 APP还有各种 web APP 在浏览器里面打开的以及windows上面跑的那种客户端第二部分是跟我们程序相关的SDK，API，Websocket这些我们都统称为前端第二个是接入层，这里展示了几种常用的接入协议实际上还会用到Mqtt, Xmpp 等各种协议这是接入层。
解决 go 引用私有包，安装失败
Dreamy_LIN的博客
07-17 212
go mod tidy 或者 go run main.go 时，提示失败，例如 no such host（设置GOPRIVATE）或者 x509: certificate signed by unknown authority 之类的报错（设置GOINSECURE）
Golang中读写锁的底层实现
qq_42538588的博客
07-16 781
读写锁是一种并发控制机制，它允许多个线程同时对共享资源进行读访问，但在进行写操作时需要互斥访问，以确保数据的一致性和完整性。读写锁的主要功能是提高系统在读多写少场景下的并发处理能力，从而提升整体性能。读写锁在实际应用中扮演着重要的角色，可以有效地降低系统的并发访问冲突，提高系统的并发处理能力，同时也能够避免写操作对读操作的阻塞，从而减少了线程的等待时间，提升了系统的整体响应速度。w Mutex // 互斥锁L *Locker本文介绍了如何在Go语言中使用读写锁的应用实例。
go-zero框架入门
最新发布
qq_63728673的博客
07-18 559
使用 Raft 共识算法**，确保了在分布式环境中的强一致性**。再举个例子：正常项目中配置文件写在代码中，若配置文件修改，项目就该重新启动，但是若使用了etcd，每次去查看对应RPC的配置信息时都是从etcd中实时获取。并且etcd本身为分布式系统设计，提供了原生的服务发现和配置管理功能，支持 Watch 机制，可以。之后打开一个命令行窗口，输入：etcd就可以启动了，然后再打开一个黑窗口（上一个不要关）这就是go-zero使用前的前置工作了，下一步就是去写简单的项目。1.在根目录下创建一个user包。
golang mux组件兼容转移url
国产-达芬奇
07-16 229
UseEncodedPath
GO——GMP 好文整理
sy_123a的专栏
07-17 190
GMP相关好文推荐：Golang的协程调度器原理及GMP设计思想
goLang 通过 Select + Channels 实现定时任务与调度
JineD的博客
07-15 316
time 包 在与 channel 结合时提供了很多有用的功能，其中 time.Ticker 结构体能够处理定时事件，它会定期在指定 channel 上发送时间值。在这篇文章中，我们深入探讨了如何使用 Go 语言中的 time 包与 channel 结合来处理定时事件和任务调度。通过 time.Ticker 结构体的周期性触发和 select 语句的多路复用能力，我们可以创建高效且响应迅速的定时任务处理系统。Ticker 对于在 goroutine 中周期性执行任务（如日志记录或计算）非常方便。
golang读取嵌套json文件并序列化
06-03
下面是一个示例代码，演示了如何读取嵌套的 JSON 文件并序列化： ```go package main import ( "encoding/json" "fmt" "io/ioutil" ) type Address struct { City string `json:"city"` State string `json:...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值