如何序列化[u8; N]和[u8]？

直截了当地说，这里是serde 1.0.151如何实现每个方法的。serialize_bytes实际上不是serde的一部分，因此它被视为一个序列。

// [T; N] is serialized as a tuple. However, this is only implemented for N 0 to 32 inclusively.
let mut seq = try!(serializer.serialize_tuple(N));
for e in self {
    try!(seq.serialize_element(e));
}
seq.end()

// [T] is serialized as a sequence.
serializer.collect_seq(self)

方法serialize_tuple和collect_seq由您正在使用的特定序列化器实现。

简单的方法

一个常见的问题是serde只为长度不超过32的数组实现Serialize/Deserialize。最简单的方法是使用像serde_with这样的crate，它添加了额外的序列化/反序列化实现，您可以将其附加到您的结构体中。下面是一个取自其文档的示例：

#[serde_as]
#[derive(Deserialize, Serialize)]
struct Arrays<const N: usize, const M: usize> {
    #[serde_as(as = "[_; N]")]
    constgeneric: [bool; N],

    #[serde_as(as = "Box<[[_; 64]; N]>")]
    nested: Box<[[u8; 64]; N]>,

    #[serde_as(as = "Option<[_; M]>")]
    optional: Option<[u8; M]>,
}

我们如何自己实现它？Rust Playground

一米十一分

执行序列化实际上非常简单。Serde没有数组的概念，所以我们需要在serialize_tuple或serialize_seq之间进行选择。在幕后，唯一的区别是serialize_seq可能没有已知的长度，所以我们可以选择serialize_tuple。

pub fn serialize<S, T, const N: usize>(this: &[T; N], serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
    T: Serialize,
{
    let mut seq = serializer.serialize_tuple(N)?;
    for element in this {
        seq.serialize_element(element)?;
    }
    seq.end()
}

一米十六分一秒

另一方面，反序列化变得有点复杂。我们需要定义一个访问者，然后指定应该如何访问每个元素。我写出了一个简单的例子，说明在数组的一般情况下如何完成它，但这不是最佳的解决方案，因为它首先被解串到堆栈上。我还必须使用unsafe代码一次只初始化数组的一个元素，但是如果使用T: Default或者如果替代地使用如Vec<T>的扩展数据结构，则可以容易地去除unsafe代码。通常，这更倾向于作为在序列上实现反串行化的指南。

pub fn deserialize<'de, D, T, const N: usize>(deserializer: D) -> Result<[T; N], D::Error>
where
    D: Deserializer<'de>,
    T: 'de + Deserialize<'de>,
{
    deserializer.deserialize_seq(ArrayVisitor { _phantom: PhantomData })
}

struct ArrayVisitor<'de, T, const N: usize> {
    _phantom: PhantomData<&'de [T; N]>,
}

impl<'de, T, const N: usize> Visitor<'de> for ArrayVisitor<'de, T, N>
where
    T: Deserialize<'de>,
{
    type Value = [T; N];

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "array of length {}", N)
    }

    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    where
        A: SeqAccess<'de>,
    {
        let mut array: MaybeUninit<[T; N]> = MaybeUninit::uninit();

        for index in 0..N {
            // Get next item as Result<Option<T>, A::Error>. Since we know
            // exactly how many elements we should receive, we can flatten
            // this to a Result<T, A::Error>.
            let next = seq.next_element::<T>()
                .and_then(|x| x.ok_or_else(|| Error::invalid_length(N, &self)));
        
            match next {
                Ok(x) => unsafe {
                    // Safety: We write into the array without reading any
                    // uninitialized memory and writes only occur within the
                    // array bounds at multiples of the array stride.
                    let array_base_ptr = array.as_mut_ptr() as *mut T;
                    ptr::write(array_base_ptr.add(index), x);
                },
                Err(err) => {
                    // Safety: We need to manually drop the parts we
                    // initialized before we can return.
                    unsafe {
                        let array_base_ptr = array.as_mut_ptr() as *mut T;

                        for offset in 0..index {
                            ptr::drop_in_place(array_base_ptr.add(offset));
                        }
                    }
                    
                    return Err(err)
                },
            }
        }

        // Safety: We have completely initialized every element
        unsafe { Ok(array.assume_init()) }
    }
}

如果有人好奇derive(Deserialize)是如何处理结构体的，我推荐大家看一下Rust Playground，我在其中扩展了宏，然后清理了输出，使其更易于阅读，了解serialize/deserialize是如何工作的，可以真正帮助揭开这个过程的神秘面纱。