जंग में उपयोगकर्ता इनपुट कैसे पढ़ा जाए?

Question

संपादक का नोट: यह प्रश्न जंग के उन हिस्सों को संदर्भित करता है जो जंग 1.0 का अनुमान लगाते हैं, लेकिन सामान्य अवधारणा अभी भी जंग 1.0 में मान्य है।

मैं टोकननाइज़र बनाने का इरादा रखता हूं। उपयोगकर्ता को ctrl - डी दबाए जाने के बाद मुझे उपयोगकर्ता प्रकार की प्रत्येक पंक्ति को पढ़ने और पढ़ने को रोकने की आवश्यकता है।

मैंने चारों ओर खोज की और केवल जंगली आईओ पर one example पाया जो संकलन भी नहीं करता है। मैंने io मॉड्यूल के दस्तावेज को देखा और पाया कि read_line() फ़ंक्शन ReaderUtil इंटरफ़ेस का हिस्सा है, लेकिन stdin() इसके बजाय Reader देता है।

कोड है कि मैं अनिवार्य रूप से सी ++

vector<string> readLines() { 
    vector<string> allLines; 
    string line; 

    while (cin >> line) { 
     allLines.push_back(line); 
    } 

    return allLines; 
} 

Answer 1

संपादक की टिप्पणी: इस जवाब से पहले जंग 1.0। आधुनिक समाधान के लिए कृपया अन्य उत्तरों देखें।

जंग 0.4 में, विशेषता का उपयोग read_line फ़ंक्शन तक पहुंचने के लिए करें। ध्यान दें कि आप स्पष्ट रूप से एक विशेषता प्रकार के लिए मूल्य कास्ट करने के लिए की जरूरत है जैसे, reader as io::ReaderUtil

fn main() { 
     let mut allLines = ~[]; 
     let reader = io::stdin(); 

     while !reader.eof() { 
       allLines.push((reader as io::ReaderUtil).read_line()); 
     } 

     for allLines.each |line| { 
       io::println(fmt!("%s", *line)); 
     } 
} 

Answer 2

उह में निम्नलिखित प्रकार दिखाई देगा ... कई परीक्षणों और त्रुटियों के बाद चाहते हैं, मैं एक समाधान मिल गया है।

मैं अभी भी एक बेहतर समाधान देखना चाहता हूं इसलिए मैं अपना स्वयं का समाधान स्वीकार नहीं कर रहा हूं।

नीचे दिया गया कोड प्रिंट करता है कि उपयोगकर्ता वास्तव में क्या इनपुट करता है।

mod tokenizer { 

pub fn read() -> ~[int] { 
    let reader = io::stdin(); 
    let mut bytes: ~[int] = ~[]; 

    loop { 
     let byte: int = reader.read_byte(); 
     if byte < 0 { 
      return bytes; 
     } 
     bytes += [byte]; 
    } 
} 

} 

fn main() { 
    let bytes: ~[int] = tokenizer::read(); 
    for bytes.each |byte| { 
     io::print(#fmt("%c", *byte as char)); 
    } 
} 

Answer 3

यह वह जगह है जो मैं irc.mozilla पर #rust आईआरसी चैनल में अनुकूल लोगों से कुछ मदद के साथ (के साथ आए हैं .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)); 
    } 
} 

और सबूत यह काम करता है कि :)

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

Answer 4

जंग 1.x (documentation देखें):

012,

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

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

जंग 0.10-0.12 (documentation देखें):

use std::io; 

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

जंग 0.9 (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); 
    } 
} 

जंग 0.8:

use std::io; 

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

जंग 0.7:

use std::io; 

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

Answer 5

17 अप्रैल 2015 तक mdcox से मोज़िला जंग आईआरसी पर।

use std::io; 

fn main() { 
    let mut stdin = io::stdin(); 
    let input = &mut String::new(); 

    loop { 
     input.clear(); 
     stdin.read_line(input); 
     println!("{}", input); 
    } 
} 

Answer 6

प्रश्न स्टडीन से लाइनें पढ़ने और एक वेक्टर लौटने का सवाल है। जंग पर 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 
} 

Answer 7

ऐसे कुछ तरीके हैं जिन पर मैं सोच सकता हूं।

Vector में एकल String

let mut input = String::new(); 
io::stdin().read_to_end(&mut input); 

पढ़ें लाइनों में सभी इनपुट पढ़ें। लाइन पढ़ने पर यह panic नहीं करता है, इसके बजाय यह उस असफल लाइन को छोड़ देता है।

let stdin = io::stdin(); 
let locked = stdin.lock(); 
let v: Vec<String> = locked.lines().filter_map(|line| line.ok()).collect(); 

इसके अलावा आप इसे पार्स करने के लिए चाहते हैं:

स्ट्रिंग में यह पढ़ने के बाद यह करते हैं। आप इसे अन्य संग्रहों में पार्स कर सकते हैं जो FromIterator लागू करते हैं। संग्रह में शामिल तत्वों को भी FromStr लागू करना होगा। जब तक विशेषता बाधा को संतुष्ट करता है के रूप में आप किसी भी Collection:FromIterator को वीइसी बदल सकते हैं Collection<T: FromStr>

let v: Vec<i32> = "4 -42 232".split_whitespace().filter_map(|w| w.parse().ok()).collect(); 

इसके अलावा, आप StdinLock

let vv: Vec<Vec<i32>> = locked 
    .lines() 
    .filter_map(|l| 
     l.ok().map(|s| 
      s.split_whitespace().filter_map(|word| word.parse().ok()).collect() 
     ) 
    ) 
    .collect();