Json序列化与反序列化
var animla = Animal{
Name: "ni",
Age: 3,
Wife: "sad",
Hobby: "bash",
}
by, err :=json.Marshal(animla)
if err != nil{
fmt.Println("转化失败",err)
return
}
fmt.Println(string(by))
var a Animal
s :=`{"name":"ni","age":3,"Hobby":"bash"}`
json.Unmarshal([]byte(s), &a)
fmt.Println(a)
var a map[string]interface{}=make(map[string]interface{})
a["name"] = "小子"
a["age"] = 6
a["address"] = "浦东新区"
data, _ := json.Marshal(a)
s:=string(data)
fmt.Println(s)
var m =make(map[string]interface{})
json.Unmarshal([]byte(s),&m)
fmt.Println(m["age"])
xml
type Root struct {
XMLName xml.Name `xml:"root"`
Version string `xml:"version,attr"`
Part []Part `xml:"part"`
}
type Part struct {
Id string `xml:"id,attr"`
AName string `xml:"name,attr"`
Name string `xml:"name"`
Age string `xml:"age"`
Sex string `xml:"sex"`
}
func main() {
var root Root
data, err :=ioutil.ReadFile("./text.xml")
if err != nil{
fmt.Println("打开文件错误",err)
return
}
err1:=xml.Unmarshal(data,&root)
if err1 !=nil{
fmt.Println("解析出错", err1)
}
fmt.Println(root)
for i:=0;i<len(root.Part);i++{
fmt.Printf("部分编号:%v,部分名:%v,具体姓名:%v,年龄:%v,性别:%v\n",
root.Part[i].Id,root.Part[i].AName,root.Part[i].Name,root.Part[i].Age,root.Part[i].Sex)
}
}
func main() {
var root=Root{Version: "3"}
root.Part=append(root.Part, Part{Id: "05", AName: "第二部分", Name: "李华", Age: "18", Sex: "male"})
root.Part=append(root.Part, Part{Id: "06", AName: "第三部分", Name: "王华", Age: "8", Sex: "male"})
root.Part=append(root.Part, Part{Id: "07", AName: "第四部分", Name: "吴华", Age: "10", Sex: "female"})
fmt.Println(root)
data, err :=xml.Marshal(root)
if err != nil{
fmt.Println("xml转化失败")
return
}
werr :=ioutil.WriteFile("./text.xml", data, 0666)
if werr != nil{
fmt.Println("文件写入出错", err)
return
}
}
MessagePack格式
type Dog struct {
Name string
Age int
Type string
}
func main() {
var dog =Dog{"二哈",1,"哈士奇"}
data,err:=msgpack.Marshal(dog)
if err != nil {
fmt.Println("转换出错",err)
return
}
fmt.Println(data)
fmt.Println(string(data))
ioutil.WriteFile("./dog.msg",data,0666)
var dog Dog
data,_:=ioutil.ReadFile("./dog.msg")
msgpack.Unmarshal(data,&dog)
fmt.Println(dog)
}
Gob格式
type Animal struct {
Name string
Age int
Sex string
}
func main() {
var animal=Animal{Name: "鸟",Age: 3, Sex: "male"}
var buf =new(bytes.Buffer)
encoder :=gob.NewEncoder(buf)
err :=encoder.Encode(animal)
if err != nil{
fmt.Println("转换出错", err)
return
}
fmt.Println(buf.Bytes())
ioutil.WriteFile("./gob.txt", buf.Bytes(), 0666)
}
file, err :=os.Open("./gob.txt")
if err != nil{
fmt.Println("文件读取错误",err)
return
}
var animal Animal
decoder :=gob.NewDecoder(file)
decoder.Decode(&animal)
fmt.Println(animal)
rand标准库
-有种子。通常以时钟、输入输出等特殊节点作为参数,初始化。该类型生成的随机数相比无种子时重复概率较低
-无种子。可以理解为此时种子为1,无种子编译后运行的结果是定值
fmt.Println(rand.Intn(10))
rand.Seed(time.Now().Unix())
fmt.Println(rand.Intn(100))
r :=rand.New(rand.NewSource(time.Now().Unix()))
fmt.Println(r.Intn(999))
// 3 常用方法
//rand.Seed(time.Now().Unix()) // 时间戳
//fmt.Println(rand.Int())
//fmt.Println(rand.Int31())
//fmt.Println(rand.Int63())
//fmt.Println(rand.Uint32())
//fmt.Println(rand.Float32())
//fmt.Println(rand.Float64())
// 随机生成100内的整数
//fmt.Println("随机生成100内的整数:",int(rand.Float32()*100))
// 使用Intn生成
//fmt.Println(rand.Intn(999))
//fmt.Println(rand.Int31n(100))
//fmt.Println(rand.Int63n(9999))
//fmt.Println("随机生成100内的整数:",rand.Intn(100))
// 4 生成定长的随机数 长度是4位的int
//fmt.Println(rand.Int63n(9999))
//res:=rand.Int31()
//fmt.Println(res)
//fmt.Printf("%.4d \n", res%10000)
反射
var order1 Order=Order{num: "e3rw", price: 12}
var t reflect.Type=reflect.TypeOf(order1)
var v reflect.Value=reflect.ValueOf(order1)
fmt.Println(t)
fmt.Println(v)
var order = Order{"1001", 99}
t:=reflect.TypeOf(order)
fmt.Println(t) // 类型是:main.Order
fmt.Println(t.Kind()) // 种类:struct
var i =9
var s ="lqz"
var sli=make([]int,3)
var m=make(map[int]string)
fmt.Printf("i的类型是:%s,i的种类是:%s\n",reflect.TypeOf(i),reflect.TypeOf(i).Kind()) // i的类型是:int,i的种类是:int
fmt.Printf("s的类型是:%s,s的种类是:%s\n",reflect.TypeOf(s),reflect.TypeOf(s).Kind()) //s的类型是:string,s的种类是:string
fmt.Printf("sli的类型是:%s,sli的种类是:%s\n",reflect.TypeOf(sli),reflect.TypeOf(sli).Kind()) //sli的类型是:[]int,sli的种类是:slice
fmt.Printf("m的类型是:%s,m的种类是:%s\n",reflect.TypeOf(m),reflect.TypeOf(m).Kind()) // m的类型是:map[int]string,m的种类是:map
// 4 reflect.ValueOf()-->返回的是reflect.Value类型,其中包含了原始值的值信息。reflect.Value与原始值之间可以互相转换
// reflect.Value有一些方法,可以把它转成具体的类型,案例如下
// 整形
var i int =19
v:=reflect.ValueOf(i)
////fmt.Println(v)
res:=v.Int() // res是真正的值,因为v是reflect.Value类型---》res才是int64类型
fmt.Println(res)
// 字符串
var s ="lqz is Nb"
v:=reflect.ValueOf(s)
res:=v.String() // res是真正的值,因为v是reflect.Value类型---》res才是string类型
fmt.Println(res)
// 结构体类型
var order = Order{"1001", 99}
v:=reflect.ValueOf(order)
res:=v.Interface() // 先把结构体转成空接口类型
// 类型断言
o,ok:=res.(Order)
if ok{
fmt.Println(o)
}
func getRealValue(i interface{}) {
v:=reflect.ValueOf(i)
k:=v.Kind() // 通过判断种类---》强制转换成对应的类型
switch k {
case reflect.Int64:
// 转成具体的值
// v.Int()从反射中获取整型的原始值,然后通过int64()强制类型转换
fmt.Printf("该类型是%T类型,值为%d\n", int64(v.Int()),int64(v.Int()))
case reflect.String:
fmt.Printf("该类型是%T类型,值为%s\n", v.String(),v.String())
case reflect.Float32:
fmt.Printf("该类型是%T类型,值为%f\n", float32(v.Float()),float32(v.Float()))
case reflect.Float64:
fmt.Printf("该类型是%T类型,值为%f\n", v.Float(),v.Float())
case reflect.Struct:
r:=v.Interface() // 转成空接口类型
o,ok:=r.(Order)
if ok {
fmt.Printf("该类型是%T类型,值为:%v\n",o,o)
}
}
}
i :=10
v :=reflect.ValueOf(&i)
v.Elem().SetInt(99) // 取到原来的地址然后修改值
fmt.Println(i)
s :="dsf"
v2 :=reflect.ValueOf(&s)
v2.Elem().SetString("fdsdfds")
fmt.Println(s)
// reflect.ValueOf的方法isNil()、isValid()
//IsValid()返回v是否持有一个值。如果v是Value零值会返回假,此时v除了IsValid、String、Kind之外的方法都会导致panic。
//IsNil()常被用于判断指针是否为空;IsValid()常被用于判定返回值是否有效
// 反射结构体==》反射结构体中所有的字段===》反射结构体字段值以及方法并执行
type Order2 struct {
orderId string `json:"order_id"` // 通过反射,tag也能拿到
price int `json:"price"`
}
func (o Order2)PrintOrder() {
fmt.Printf("订单号为:%s,价格为:%d\n",o.orderId,o.price)
}
func (o Order2)ChangePrice(price int) {
o.price=price
fmt.Println("价格被改为:",o.price)
}
func main() {
var order Ord = Ord{OrderId: "fdsf",price: 12}
t :=reflect.TypeOf(order)
// t.Name 类型
// t.Kind 种类
fmt.Println(t.Name(), t.Kind())
fmt.Println(t.NumField()) // 结构体中有几个字段
// 循环取出所有字段
for i:=0;i<t.NumField();i++{
field:=t.Field(i)
fmt.Printf("name:%s,index:%d,type:%v,json tag%v", field.Name, field.Index, field.Type, field.Tag)
}
field, ok:=t.FieldByName("price")
if ok{
fmt.Printf("name:%s,index:%d,type:%v,json tag%v", field.Name, field.Index, field.Type, field.Tag)
}
var order Order2 = Order2{orderId: "ewqew", price: 223}
v:=reflect.ValueOf(order)
t:=reflect.TypeOf(order)
val :=v.FieldByName("price")
fmt.Printf("结构体的price的值为%v\n", val)
// 对象才有方法,使用reflect.ValueOf
fmt.Println(v.NumMethod()) // 查看对象有多少方法
for j:=0;j<v.NumMethod();j++{
methodv:=v.Method(j)
methodt:=t.Method(j)
fmt.Printf("方法名叫%s\n",methodt.Name)
fmt.Printf("方法l类型是%s\n",methodv.Type())
}
f :=v.MethodByName("PrintOrder")
var args1 = []reflect.Value{}
f.Call(args1)
f2 :=v.MethodByName("ChangePrice")
var args2 = []reflect.Value{reflect.ValueOf(55)}
f2.Call(args2)
}