Comment faire pour envoyer la sortie stderr?

On utilise cette fonction pour envoyer la sortie vers stdout:

println!("some output")

Je pense qu'il n'y a pas de macro pour faire la même chose pour stderr.

InformationsquelleAutor tshepang | 2014-12-21
  1. 71

    Après La Rouille 1.19

    Comme de la Rouille 1.19, vous pouvez utiliser le eprint et eprintln macros:

    fn main() {
    eprintln!("This is going to standard error!, {}", "awesome");
}

    Cela a été proposé à l'origine dans RFC 1896.

    Avant De Rouille 1.19

    Vous pouvez voir la la mise en œuvre de println! de plonger dans exactement comment cela fonctionne, mais c'était un peu écrasante quand je l'ai lu.

    Vous pouvez mettre des trucs sur la sortie stderr, utilisent des macros si:

    use std::io::Write;

let name = "world";
writeln!(&mut std::io::stderr(), "Hello {}!", name);

    Cela vous donnera une unused result which must be used mais attention, comme l'impression de IO peut échouer (ce n'est pas quelque chose que nous avons l'habitude de penser lors de l'impression!). Nous pouvons voir que les méthodes existantes simplement de panique dans ce cas, afin que nous puissions mettre à jour notre code pour faire la même chose:

    use std::io::Write;

let name = "world";
let r = writeln!(&mut std::io::stderr(), "Hello {}!", name);
r.expect("failed printing to stderr");

    C'est un peu beaucoup, donc laisser envelopper dans un macro:

    use std::io::Write;

macro_rules! println_stderr(
    ($($arg:tt)*) => { {
        let r = writeln!(&mut ::std::io::stderr(), $($arg)*);
        r.expect("failed printing to stderr");
    } }
);

fn main() {
    let name = "world";
    println_stderr!("Hello {}!", name)
}
    • Donc, c'est println_stderr!("Hello {}!", name) vs writeln!(&mut std::stdio::stderr(), "Hello {}!", name), à la fois, qui font à peu près la même chose?
    • Ils font la même chose, mais la macro gère les cas d'échec (la valeur de retour), sans tous les trucs. Sans elle, vous obtenez un avertissement.
    • Vous pouvez également faire de writeln!(...).unwrap(); à gérer l'échec possible de la façon la plus simple.
    InformationsquelleAutor Shepmaster
  2. 19

    print! et println! sont des méthodes pratiques pour l'écriture sur la sortie standard. Il y a d'autres macros avec les mêmes fonctionnalités de mise en forme disponibles pour différentes tâches:

    À écrire dans le flux d'erreur standard, vous pouvez utiliser, par exemple, writeln! comme ceci:

    use std::io::Write;

fn main() {
    let mut stderr = std::io::stderr();
    writeln!(&mut stderr, "Error!").unwrap();
}
    InformationsquelleAutor Francis Gagné
  3. 3

    C'est fait:

    use std::io::Write;

fn main() {
    std::io::stderr().write(b"some output\n");
}

    Vous pouvez le tester en envoyant le programme de sortie de /dev/null pour s'assurer qu'il fonctionne (j'ignore l'avertissement):

    $ rustc foo.rs && ./foo > /dev/null
foo.rs:4:5: 4:42 warning: unused result which must be used, #[warn(unused_must_use)] on by default
foo.rs:4     io::stderr().write(b"some output\n");
             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
some output

    De même, on peut effectuer les opérations suivantes pour stdout:

    use std::io::Write;

fn main() {
    std::io::stdout().write(b"some output\n");
}

    Je pense que cela signifie println! est juste une commodité: il est plus court, et il permet également une mise en forme. Comme un exemple de ce dernier, le message suivant s'affiche 0x400:

    println!("0x{:x}", 1024u)
    InformationsquelleAutor tshepang
  4. 3

    Tout en ne répondant pas à la question précise, c'est peut-être de l'intérêt qu'il y a un log caisse qui spécifie une interface pour nivelé la journalisation que d'autres caisses en bois (par exemple env_logger) peut répondre.

    La sortie de cet enregistrement sera envoyé à stderr, et il y a d'autres avantages pour les utilisateurs, notamment en spécifiant le niveau de journal.

    C'est de cette façon en utilisant par exemple un enregistreur pourrait ressembler à:

    #[macro_use]
extern crate log;
extern crate env_logger;

fn main() {
    env_logger::init().unwrap();
    error!("this is printed by default");
}

    (Exemple adapté de http://burntsushi.net/rustdoc/env_logger/index.html#example)

    InformationsquelleAutor Michael
  5. 0

    Objectif

    stderr!("Code {}: Danger, Will Robinson!  Danger!", 42);

    Notes

    Autres réponses générer un solde non utilisé de l'importation d'avertissement avec la dernière nightly, voici donc un moderne macro qui Fonctionne TM.

    Code

    macro_rules! stderr {
    ($($arg:tt)*) => (
        use std::io::Write;
        match writeln!(&mut ::std::io::stderr(), $($arg)* ) {
            Ok(_) => {},
            Err(x) => panic!("Unable to write to stderr (file handle closed?): {}", x),
        }
    )
}
    • Ma réponse n'a pas d'avertissements sur le prix de la nuit sur la Rouille aire de Jeux tous les soirs. Que voyez-vous?
    • Cette solution ne fonctionne pas: erreur: les importations ne sont pas autorisés après non point déclarations
    • Ce qui se passe pour moi, si vous utilisez la macro dans un bloc après une autre déclaration. Si vous enroulez l'intérieur peu avec le use et match dans un autre bloc, ça fonctionne pour moi. Donc ($($arg:tt)*) => ({ use ... })
    InformationsquelleAutor