Comment lire la saisie de l'utilisateur dans la Rouille?

Rouille 1.x (voir la documentation):

use std::io;
use std::io::prelude::*;

fn main() {
    let stdin = io::stdin();
    for line in stdin.lock().lines() {
        println!("{}", line.unwrap());
    }
}

La rouille de 0,10–0,12 (voir la documentation):

use std::io;

fn main() {
    for line in io::stdin().lines() {
        print!("{}", line.unwrap());
    }
}

La rouille de 0,9 (voir 0.9 documentation):

use std::io;
use std::io::buffered::BufferedReader;

fn main() {
    let mut reader = BufferedReader::new(io::stdin());
    for line in reader.lines() {
        print(line);
    }
}

Rouille 0.8:

use std::io;

fn main() {
    let lines = io::stdin().read_lines();
    for line in lines.iter() {
        println(*line);
    }
}

Rouille 0.7:

use std::io;

fn main() {
    let lines = io::stdin().read_lines();
    for lines.iter().advance |line| {
        println(*line);
    }
}

La question est de lire des lignes à partir de stdin et le retour d'un vecteur. Sur La Rouille 1.7:

fn readlines() -> Vec<String> {
    use std::io::prelude::*;
    let stdin = std::io::stdin();
    let v = stdin.lock().lines().map(|x| x.unwrap()).collect();
    v
}

À Rust 1.0 et les versions ultérieures, vous pouvez utiliser le lignes méthode sur tout ce qui met en œuvre la std::io::BufRead trait pour obtenir un itérateur sur les lignes de l'entrée. Vous pouvez également utiliser read_line , mais à l'aide de l'itérateur est plus probable que ce que vous voulez. Voici une version de la fonction en question à l'aide des itérateurs; voir ci-dessous pour une explication plus détaillée. (aire de jeux lien)

use std::io;
use std::io::prelude::*;

pub fn read_lines() -> Vec<String> {
    let stdin = io::stdin();
    let stdin_lock = stdin.lock();
    let vec = stdin_lock.lines().filter_map(|l| l.ok()).collect();

    vec
}

Et voici une version qui ressemble plus à la version C++ dans la question, mais n'est pas vraiment le idiomatiques moyen de le faire dans de Rouille (aire de jeux):

use std::io;
use std::io::prelude::*;

pub fn read_lines() -> Vec<String> {
    let mut vec = Vec::new();
    let mut string = String::new();

    let stdin = io::stdin();
    let mut stdin_lock = stdin.lock();

    while let Ok(len) = stdin_lock.read_line(&mut string) {
        if len > 0 {
           vec.push(string);
           string = String::new();
        } else {
            break
        }
    }

    vec
}

Pour obtenir quelque chose qui implémente BufRead, qui est nécessaire pour appeler lines() ou read_line(), vous appelez std::io::stdin() pour obtenir un handle vers l'entrée standard, et ensuite appeler lock() sur le résultat à obtenir le contrôle exclusif du flux d'entrée standard (vous devez avoir le contrôle exclusif d'obtenir un BufRead, parce que sinon, la mise en mémoire tampon pourrait produire des résultats arbitraires si deux threads ont été la lecture de l'entrée standard stdin à la fois).

De recueillir le résultat dans un Vec<String>, vous pouvez utiliser le collecter méthode sur un itérateur. lines() renvoie un itérateur sur Result<String>, nous avons donc besoin de traiter les cas d'erreur dans lequel une ligne ne peut pas être lu; pour cet exemple, nous venons d'ignorer les erreurs avec un filter_map que seulement ignore les erreurs.

Le C++ comme version utilise read_line, qui ajoute la ligne de lecture d'une chaîne de caractères, et nous avons ensuite pousser la corde dans notre Vec. Parce que nous transférer la propriété de la chaîne à la Vec quand nous faisons cela, et parce que read_line serait autrement garder l'ajout à la string, nous avons besoin d'allouer une nouvelle chaîne pour chaque boucle (ce qui semble être un bogue dans l'original de la version C++ dans la question, dans lequel la même chaîne est partagé et donc ne s'accumulent chaque ligne). Nous utilisons alors laissez - de continuer à lire jusqu'à ce que nous avons touché une erreur, et nous casser si jamais nous lire zéro octets qui indique la fin de l'entrée.

C'est ce que j'ai (avec l'aide de la gentillesse des gens dans le #rouille canal IRC sur irc.mozilla.org):

use core::io::ReaderUtil;

fn read_lines() -> ~[~str] {
    let mut all_lines = ~[];

    for io::stdin().each_line |line| {
        //each_line provides us with borrowed pointers, but we want to put
        //them in our vector, so we need to *own* the lines
        all_lines.push(line.to_owned());
    }

    all_lines
}

fn main() {
    let all_lines = read_lines();

    for all_lines.eachi |i, &line| {
        io::println(fmt!("Line #%u: %s", i + 1, line));
    }
}

Et la preuve que ça marche 🙂

$ rustc readlines.rs
$ echo -en 'this\nis\na\ntest' | ./readlines
Line #1: this
Line #2: is
Line #3: a
Line #4: test