0
点赞
收藏
分享

微信扫一扫

Rust 结构数组、序列化与反序列化


文章目录

  • ​​一、结构数组​​
  • ​​二、序列化​​
  • ​​三、反序列化​​

一、结构数组

const v0: i8 = 0;
const v1: i8 = 1;
const v2: i8 = 2;
const v3: i8 = 3;

struct Arr {
v: i8,
s: &'static str,
}

const str: [Arr; 4] = [
Arr {v: v0, s:"zero",},
Arr {v: v1, s:"one",},
Arr {v: v2, s:"two",},
Arr {v: v3, s:"three",},
];

fn main() {
println!("{}", str[2].v);
}

初始化一些方法:
此方法安全,但是效率不高,会复制10份Foo { a: 10, b: 10}结构体。

#[derive(Copy, Clone, Debug)]
struct Foo {
a: u32,
b: u32,
}

fn main() {
let mut foo_array = [Foo { a: 10, b: 10 }; 10];
}

高效方法:
​​​Cargo.toml​

...
[dependencies]
arrayvec = "0.4.10"

​main.rs​

use arrayvec::ArrayVec; 
use std::iter;

#[derive(Clone)]
struct Foo {
a: u32,
b: u32,
}

fn main() {
let foo_array: [Foo; 10] = iter::repeat(Foo { a: 10, b: 10 })
.collect::<ArrayVec<_>>()
.into_inner()
.unwrap_or_else(|_| unreachable!());
}

或者

struct Foo {
foo: isize,
}

impl Foo {
pub fn new(i: isize) -> Foo {
//do stuff with i
Foo { foo: i }
}
}

fn main() {
//this was my best guess...
let foo_array: [Foo; N] = [0..N].iter().map(|i| Foo::new(i));
}

二、序列化

Rust Crate 使用:serde
序列化和反序列化是非常通用的功能,在网络传输,数据存储上极其常见的。序列化和反序列化的通用解释是:

​seriallization​​​ 序列化 : 将对象转化为便于传输的格式, 常见的序列化格式:二进制格式,字节数组,json字符串,xml字符串。
​​​deseriallization​​ 反序列化:将序列化的数据恢复为对象的过程。

格式编写者只需实现 Serde 的 ​​trait​​​ 即可,而用户通过​​#[derive(Serialize,Deserialize)]​​对其对象进行序列化,而无需考虑格式。

​Cargo.toml​

...
[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0.0"
...

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Person {
name: String,
age: u8,
phones: Vec<String>,
weight: Option<u8>,
}

fn main() {
let data = r#"
{
"name": "John Doe",
"age": 43,
"phones": [
"+44 1234567",
"+44 2345678"
]
}"#;

// 解析字符串到Person对象。
let p: Person = serde_json::from_str(data).unwrap();
println!("Please call {} at the number {}", p.name, p.phones[0]);

// Person对象转为JSON字符串.
let serialized = serde_json::to_string(&p).unwrap();
println!("serialized = {}", serialized);
}

关于更多:​​https://blog.logrocket.com/rust-serialization-whats-ready-for-production-today/​​

三、反序列化

use serde_json;
use std::result::Result;
use std::error::Error;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
enum Speech {
Str(String),
StrArray(Vec<String>),
}

#[derive(Debug, Serialize, Deserialize)]
struct Foo {
pub foo: String,
#[serde(skip_serializing_if = "Option::is_none")]
speech: Option<Speech>,
}

fn main() -> Result<(), Box<dyn Error>> {

let json1 = r#"
{
"foo": "bar",
"speech": "something"
}
"#;

let json2 = r#"
{
"foo": "bar",
"speech": ["something", "something else"]
}
"#;


let json3 = r#"
{
"foo": "bar"
}
"#;

let foo1: Foo = serde_json::from_str(json1)?;
let back_to_str_foo1 = serde_json::to_string(&foo1).unwrap();
println!("foo1 {:#?}", foo1);
println!("back_to_str_foo1 {}", back_to_str_foo1);

let foo2: Foo = serde_json::from_str(json2)?;
let back_to_str_foo2 = serde_json::to_string(&foo2).unwrap();
println!("foo1 {:#?}", foo2);
println!("back_to_str_foo2 {}", back_to_str_foo2);


let foo3: Foo = serde_json::from_str(json3)?;
let back_to_str_foo3 = serde_json::to_string(&foo3).unwrap();
println!("foo1 {:#?}", foo3);
println!("back_to_str_foo3 {}", back_to_str_foo3);

Ok(())
}

参考:https://www.qttc.net/509-rust-parse-json.html


举报

相关推荐

0 条评论