使用 serde 反序列化数组时跳过空对象

Question

我需要反序列化一个类型的数组(JSON)，让调用Foo。我已经实现了这个，它适用于大多数东西，但我注意到最新版本的数据有时会包含错误的空对象。

在此更改之前，可以将每个Foo反序列化为以下枚举：

#[derive(Deserialize)]
#[serde(untagged)]
pub enum Foo<'s> {
Error {
// My current workaround is using Option<Cow<'s, str>>
error: Cow<'s, str>,
},
Value {
a: u32,
b: i32,
// etc.
}
}
/// Foo is part of a larger struct Bar.
#[derive(Deserialize)]
#[serde(untagged)]
pub struct Bar<'s> {
foos: Vec<Foo<'s>>,
// etc.
}

此结构可能表示以下 JSON 值之一：

// Valid inputs
[]
[{"a": 34, "b": -23},{"a": 33, "b": -2},{"a": 37, "b": 1}]
[{"error":"Unable to connect to network"}]
[{"a": 34, "b": -23},{"error":"Timeout"},{"a": 37, "b": 1}]
// Possible input for latest versions of data 
[{},{},{},{},{},{},{"a": 34, "b": -23},{},{},{},{},{},{},{},{"error":"Timeout"},{},{},{},{},{},{}]

这种情况并不经常发生，但足以引起问题。通常，数组应包含 3 个或更少的条目，但这些无关的空对象打破了这一惯例。我无法从解析{}中获得有意义的信息，在最坏的情况下，一个数组中可能有数百个信息。

我不想在解析{}时出错，因为数组仍然包含其他有意义的值，但我也不想在解析的数据中包含{}。理想情况下，我也可以使用tinyvec::ArrayVec<[Foo<'s>; 3]>而不是Vec<Foo<'s>>来节省内存并减少在配对期间执行分配所花费的时间，但由于此问题而无法做到。

在 Rust 中使用serde反序列化数组时如何跳过{}JSON 值？

我还用一些测试用例组装了一个 Rust Playground 来尝试不同的解决方案。

Answer 1

serde_with::VecSkipError提供了一种通过跳过反序列化失败的元素来忽略它们的方法。这将忽略任何错误，而不仅仅是空对象{}。所以它可能太宽容了。

#[serde_with::serde_as]
#[derive(Deserialize)]
pub struct Bar<'s> {
#[serde_as(as = "serde_with::VecSkipError<_>")]
foos: Vec<Foo<'s>>,
}

操场

Answer 2

最简单但性能不佳的解决方案是定义一个枚举，该枚举同时捕获Foo情况和空大小写，反序列化为这些向量，然后过滤该向量以获取非空向量。

#[derive(Deserialize, Debug)]
#[serde(untagged)]
pub enum FooDe<'s> {
Nonempty(Foo<'s>),
Empty {},
}
fn main() {
let json = r#"[
{},{},{},{},{},{},
{"a": 34, "b": -23},
{},{},{},{},{},{},{},
{"error":"Timeout"},
{},{},{},{},{},{}
]"#;
let foo_des = serde_json::from_str::<Vec<FooDe>>(json).unwrap();
let foos = foo_des
.into_iter()
.filter_map(|item| {
use FooDe::*;
match item {
Nonempty(foo) => Some(foo),
Empty {} => None,
}
})
.collect();
let bar = Bar { foos };
println!("{:?}", bar);
// Bar { foos: [Value { a: 34, b: -23 }, Error { error: "Timeout" }] }
}

从概念上讲，这很简单，但您为最终不需要Empty案例分配了大量空间。相反，您可以通过自己实现反序列化来准确控制反序列化的完成方式。

struct BarVisitor<'s> {
marker: PhantomData<fn() -> Bar<'s>>,
}
impl<'s> BarVisitor<'s> {
fn new() -> Self {
BarVisitor {
marker: PhantomData,
}
}
}
// This is the trait that informs Serde how to deserialize Bar.
impl<'de, 's: 'de> Deserialize<'de> for Bar<'s> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
impl<'de, 's: 'de> Visitor<'de> for BarVisitor<'s> {
// The type that our Visitor is going to produce.
type Value = Bar<'s>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a list of objects")
}
fn visit_seq<V>(self, mut access: V) -> Result<Self::Value, V::Error>
where
V: SeqAccess<'de>,
{
let mut foos = Vec::new();
while let Some(foo_de) = access.next_element::<FooDe>()? {
if let FooDe::Nonempty(foo) = foo_de {
foos.push(foo)
}
}
let bar = Bar { foos };
Ok(bar)
}
}
// Instantiate our Visitor and ask the Deserializer to drive
// it over the input data, resulting in an instance of Bar.
deserializer.deserialize_seq(BarVisitor::new())
}
}
fn main() {
let json = r#"[
{},{},{},{},{},{},
{"a": 34, "b": -23},
{},{},{},{},{},{},{},
{"error":"Timeout"},
{},{},{},{},{},{}
]"#;
let bar = serde_json::from_str::<Bar>(json).unwrap();
println!("{:?}", bar);
// Bar { foos: [Value { a: 34, b: -23 }, Error { error: "Timeout" }] }
}