Convertir un tableau de u32 en Vec <u8> dans Rust

Question

Dans Rust, je veux prendre un tableau de u32valeurs, convertir chacune en quatre octets en big endian et les concaténer pour donner un Vec<u8>résultat. Exemple:

let input: [u32; 5] = [
    0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];

(... Do some data conversion work ...)

let output: Vec<u8> = vec![
    0x67, 0x45, 0x23, 0x01,
    0xEF, 0xCD, 0xAB, 0x89,
    0x98, 0xBA, 0xDC, 0xFE,
    0x10, 0x32, 0x54, 0x76,
    0xC3, 0xD2, 0xE1, 0xF0,
];

J'ai plusieurs morceaux de code de travail qui donnent tous la même réponse.

Algorithme A (boucle for):

let mut output = Vec::<u8>::new();
for val in &input{
    output.extend_from_slice(&val.to_be_bytes());
}

Algorithme B (pour chacun):

let mut output = Vec::<u8>::new();
input.iter().for_each(|val| output.extend_from_slice(&val.to_be_bytes()));

Algorithme C (plier-ajouter):

let output = input.iter().fold(Vec::<u8>::new(),
    |mut acc, val| {acc.extend_from_slice(&val.to_be_bytes()); acc});

Algorithme D (carte plate):

let output: Vec<u8> = input.iter().flat_map(|val| val.to_be_bytes().to_vec()).collect();

Existe-t-il un moyen encore plus court et plus clair d'accomplir la tâche? Peut-être que l'algorithme D to_vec()pourrait être évité d'une manière ou d'une autre?

La vitesse n'est pas un problème car ce code ne s'exécute que quelques fois et la longueur du tableau d'entrée est fixée à 5.

Answer 1

L'algorithme A me semble le plus clair. Une amélioration pourrait être d'utiliser Vec::with_capacitypour éviter l'allocation. En effet, les tableaux de Rust sont actuellement assez compliqués à utiliser.

Mon conseil serait de l'envelopper dans une fonction et de ne pas s'en soucier plus tard:

pub fn to_bytes(input: &[u32]) -> Vec<u8> {
    let mut bytes = Vec::with_capacity(4 * input.len());

    for value in input {
        bytes.extend(&value.to_be_bytes());
    }

    bytes
}

#[cfg(test)]
mod tests {
    #[test]
    fn to_bytes() {
        use super::*;

        assert_eq!(to_bytes(&[]), &[]);

        let input = &[0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];
        let output = &[
            0x67, 0x45, 0x23, 0x01, 0xEF, 0xCD, 0xAB, 0x89, 0x98, 0xBA, 0xDC, 0xFE, 0x10, 0x32,
            0x54, 0x76, 0xC3, 0xD2, 0xE1, 0xF0,
        ];

        assert_eq!(to_bytes(input), output);
    }
}

( aire de jeux )