web-dev-qa-db-fra.com

Afficher la tranche u8 en représentation hexadécimale

J'ai besoin de convertir &[u8] en une représentation hexadécimale. Par exemple [ A9, 45, FF, 00 ... ].

Le trait std::fmt::UpperHex n'est pas implémenté pour les tranches (je ne peux donc pas utiliser std::fmt::format). Rust a le trait serialize::hex::ToHex, qui convertit &[u8] en une chaîne hexadécimale, mais j'ai besoin d'une représentation avec des octets séparés.

Je peux implémenter le trait UpperHex pour &[u8] moi-même, mais je ne suis pas sûr de savoir si cela serait canonique. Quel est le moyen le plus canonique de faire cela?

hexrustslice
14
Aleksandr

Rouille 1.26.0 et plus

Le formateur :x? "débogage avec entiers hexadécimaux" peut être utilisé: 

let data = b"hello";
println!("{:x?}", data);
println!("{:X?}", data);

[68, 65, 6c, 6c, 6f]
[68, 65, 6C, 6C, 6F]

Il peut également être combiné avec le joli modificateur:

let data = b"hello";
println!("{:#x?}", data);
println!("{:#X?}", data);

[
    0x68,
    0x65,
    0x6c,
    0x6c,
    0x6f
]
[
    0x68,
    0x65,
    0x6C,
    0x6C,
    0x6F
]

Si vous avez besoin de plus de contrôle ou si vous devez prendre en charge les anciennes versions de Rust, continuez à lire.

Rouille 1.0 et plus

use std::fmt::Write;

fn main() {
    let mut s = String::new();
    for &byte in "Hello".as_bytes() {
        write!(&mut s, "{:X} ", byte).expect("Unable to write");
    }

    println!("{}", s);
}

Cela peut être imaginé en implémentant l’un des traits de formatage (fmt::Debug, fmt::Display, fmt::LowerHex, fmt::UpperHex, etc.) sur une structure et en ayant un petit constructeur:

use std::fmt;

struct HexSlice<'a>(&'a [u8]);

impl<'a> HexSlice<'a> {
    fn new<T>(data: &'a T) -> HexSlice<'a> 
        where T: ?Sized + AsRef<[u8]> + 'a
    {
        HexSlice(data.as_ref())
    }
}

// You can even choose to implement multiple traits, like Lower and UpperHex
impl<'a> fmt::Display for HexSlice<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        for byte in self.0 {
            // Decide if you want to pad out the value here
            write!(f, "{:X} ", byte)?;
        }
        Ok(())
    }
}

fn main() {
    // To get a `String`
    let s = format!("{}", HexSlice::new("Hello"));

    // Or print it directly
    println!("{}", HexSlice::new("world"));

    // Works with 
    HexSlice::new("Hello");              // string slices (&str)
    HexSlice::new(b"Hello");             // byte slices (&[u8])
    HexSlice::new(&"World".to_string()); // References to String
    HexSlice::new(&vec![0x00, 0x01]);    // References to Vec<u8>  
}
25
Shepmaster

Puisque la réponse acceptée ne fonctionne pas sur Rust 1.0 stable, voici ma tentative. Devrait être sans allocation et donc raisonnablement rapide. Ceci est fondamentalement un formateur pour [u8], mais à cause des règles de cohérence, nous devons encapsuler [u8] dans un type auto-défini ByteBuf(&[u8]) pour l'utiliser:

struct ByteBuf<'a>(&'a [u8]);

impl<'a> std::fmt::LowerHex for ByteBuf<'a> {
    fn fmt(&self, fmtr: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        for byte in self.0 {
            try!( fmtr.write_fmt(format_args!("{:02x}", byte)));
        }
        Ok(())
    }
}

Usage:

let buff = [0_u8; 24];
println!("{:x}", ByteBuf(&buff));
5
GolDDranks

Il y a une caisse pour ceci: hex-slice .

Par exemple:

extern crate hex_slice;
use hex_slice::AsHex;

fn main() {
    let foo = vec![0u32, 1, 2 ,3];
    println!("{:02x}", foo.as_hex());
}
1
Gabriel