我在追加模式下将事件流保存在 YAML 日志文件中，其中每个事件都由一个单独的文档表示，如下所示：
---
type: event
id: 1
---
type: trigger
id: 2
在稍后的某个时刻，我想迭代这些事件，解析每个 via serde_yaml。但据我了解，serde_yaml似乎不支持从单个阅读器解析多个文档，因为没有可用的方法提到它，并且尝试一次解析多个文档会导致错误MoreThanOneDocument。
use std::io::{self, BufRead};
use serde_yaml;
use serde::{self, Deserialize};
#[derive(Deserialize, Debug)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Message {
Event { id: i32 },
Trigger { id: i32},
}
fn main() -> io::Result<()> {
let yaml = "---\ntype: event\nid: 1\n---\n\ntype: trigger\nid: 2";
let v: Message = serde_yaml::from_reader(yaml.as_bytes()).unwrap();
println!("{:?}", v);
Ok(())
}
我对 Rust 完全陌生，所以也许我完全错过了重点serde，只是不明白如何去做。
请问您如何解析这样的 YAML？ …
我是 Rust 新手。我正在尝试解析 JSON 文件并将数据存储为 Rust 中的对象。
JSON 文件如下所示：
{
"comment": ["some comments"],
"data": [
["name", "line 1"],
["name", ["line 1", "line 2"]],
......
["name", "line 1"]
]
//(The line where the error is coming)
}
我做了这样的结构：
#[derive(Debug, Deserialize)]
struct my_data {
comment: String,
data: Vec<sub_data>,
}
#[derive(Debug, Deserialize)]
struct sub_data {
name: String,
pattern: Vec<String>,
}
然后我尝试了这段代码，但出现错误：
Error("missing field `Comment`", line: 1381, column: 1)',
代码：
pub fn read_json () {
let path = "./src/my_file.json";
let data = fs::read_to_string(path).expect("Unable to …我现在正在学习 rust serde 库，想了解这两种包含序列化/反序列化功能的方法有什么区别
正确的方法是什么（在生产代码中使用）？
实施例1
# Cargo.toml
serde = { version = "1.0", features = ["derive"] }
我这种情况我必须使用use serde::{Deserialize, Serialize};）
实施例2
# Cargo.toml
[dependencies]
serde = {version="1.0.117"}
serde_derive = {version="1.0.117"}
我这种情况我必须使用use serde_derive::{Deserialize, Serialize};）
我有一个 IPC 实现，其中进程使用bincode序列化结构
在另一端，我正在接收它，可以说这个进程不知道它正在接收的结构，在这里，我想做类似的事情
let parsed: Result<serde_json::Value, serde_json::Error> = serde_json::from_str(json_str);
但是用bincode，有可能吗？
我尝试做
let deser = bincode::deserialize::<serde_json::Value>(msg.bytes()))?;
但它会抛出错误
Error: Bincode does not support the serde::Deserializer::deserialize_any method
我一直在尝试实现结构的反序列化和序列化特征。我只是沿着编译器告诉我的路线走下去，然后就陷入了困境。
我从这个结构开始：
#[derive(Serialize, Deserialize)]
struct FileMetadata {
file_path: PathBuf,
last_updated: SystemTime,
mime_type: MediaType,
}
并得到以下错误：expected named lifetime parameter, help: consider introducing a named lifetime parameter.
所以我这样做：
#[derive(Serialize, Deserialize)]
struct FileMetadata<'a> {
file_path: PathBuf,
last_updated: SystemTime,
mime_type: MediaType<'a>,
}
这给出了以下错误：requires that 'de must outlive'a , help: consider adding the following bound: 'de: 'a。
所以我就按照它说的去做：
#[derive(Serialize, Deserialize)]
struct FileMetadata<'a, 'de>
where
'de: 'a {
file_path: PathBuf,
last_updated: SystemTime,
mime_type: MediaType<'a>,
}
现在我收到两个错误：
cannot deserialize when there is a …这就是我所拥有的，但我想避免使用unwrap我的 reqwest 值：
extern crate base64;
extern crate reqwest;
use serde_json;
use serde_json::json;
pub fn perform_get(id: String) -> serde_json::value::Value {
let client = reqwest::Client::builder().build().unwrap();
let url = String::from("SomeURL");
let res = client.get(&url).send().unwrap().text();
let mut v = json!(null);
match res {
Ok(n) => {
v = serde_json::from_str(&n).unwrap();
}
Err(r) => {
println!("Something wrong happened {:?}", r);
}
}
v
}
fn main() {
println!("Hi there! i want the function above to return a result instead of a Serde value …我有一个JSON数据流，其中某些JSON对象可能缺少某些字段或具有我事先不知道的字段。
我的解决方案是使用：
let v: Value = serde_json::from_str(data)?;
如何处理该字段stuff？如果我知道它存在，则可以使用：
v["stuff"]
如果数据stuff中没有字段，该如何处理？
我有一个 API 端点，actix_web用于反序列化传入的 JSON 有效负载（actix_web最终serde用于 JSON 反序列化）。
例如，我有一些看起来像这样的东西：
pub struct IncomingPayload {
pub field1: i32,
pub field2: String
}
pub async fn update_platforms(
pool: web::Data<Pool>,
req: web::Json<Vec<IncomingPayload>>,
) -> Result<HttpResponse, error::Error> {
println!(req.field1); // will be an i32
println!(req.field2); // will be a String
}
目前，只有serde能够反序列化结构的所有字段，此端点才会成功返回。即一个请求必须包含field1和field2键。
例如，这将是成功的：
curl --header "Content-Type: application/json" \
--request POST \
--data '{"field1": 1,"field2":"something"}' \
http://localhost:8080
但这不会（因为field2有效载荷中缺少）：
curl --header "Content-Type: application/json" \ …使用serde和url_serde板条箱，我收到错误提示我需要满足不相关的特征边界：
Compiling ser v0.1.0 (/data/scratch/ser)
error[E0277]: the trait bound `for<'a> url_serde::Ser<'a, url::Url>: a::_::_serde::Serialize` is not satisfied
--> src/b.rs:4:10
|
4 | #[derive(Serialize, Deserialize)]
| ^^^^^^^^^ the trait `for<'a> a::_::_serde::Serialize` is not implemented for `url_serde::Ser<'a, url::Url>`
|
::: /home/danj/.cargo/registry/src/github.com-1ecc6299db9ec823/url_serde-0.2.0/src/lib.rs:77:46
|
77 | where S: Serializer, for<'a> Ser<'a, T>: Serialize
| --------- required by this bound in `url_serde::serialize`
|
= help: the following implementations were found:
<url_serde::Ser<'a, std::option::Option<url::Url>> as a::_::_serde::Serialize>
<url_serde::Ser<'a, url::Url> as a::_::_serde::Serialize>
<url_serde::Ser<'a, url::host::Host<String>> as a::_::_serde::Serialize> …我有一个struct Foo我想在 JSON 中序列化为一个由两部分组成的字符串，例如"01abcdef:42"，但在 bincode 中是正常的。
（出于大小原因，我需要在 bincode 中正常序列化它。在某些情况下，Bar或者Baz是大字节数组，它们占用的空间是十六进制的两倍多。）
我当前的代码正是我想要的：
pub struct Foo {
pub bar: Bar,
pub baz: Baz
}
impl<'de> ::serde::Deserialize<'de> for Foo {
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Foo, D::Error> {
use ::serde::de::Error;
use core::str::FromStr;
if d.is_human_readable() {
let sl: &str = ::serde::Deserialize::deserialize(d)?;
Foo::from_str(sl).map_err(D::Error::custom)
} else {
let clone: FooClone = FooClone::deserialize(d)?;
Ok(Foo { bar: clone.bar, baz: clone.baz })
}
}
}
#[derive(Deserialize)]
pub struct FooClone {
pub bar: …