जंग में स्ट्रिंग स्लाइस को int में कनवर्ट करें

Question

नोट इस प्रश्न का कोड 1.0 से पहले जंग के संस्करण से संबंधित है लेकिन उत्तरों को जंग 1.0 के लिए अद्यतन किया गया है।

मुझे एक स्ट्रिंग को एक पूर्णांक में परिवर्तित करने में समस्या है।

fn main() { 
    let input_text = io::stdin() 
     .read_line() 
     .ok() 
     .expect("failed to read line"); 

    let input: Option<int> = from_str(input_text.as_slice()); 

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

मैं कंसोल (उदाहरण के लिए 42) और मेरे कार्यक्रम प्रिंट None पर कोई संख्या दर्ज करें।

The documentation says कि स्ट्रिंग बीमार स्वरूपित होने पर यह सामान्य स्थिति है, लेकिन मेरे 42 में क्या गलत है?

Answer 1

आप str::parse() कॉल कर सकते हैं, लेकिन आप यह सुनिश्चित करें कि read_line काम कर रहा है बनाने की जरूरत है। हम एक रीडर की आवश्यकता:

use std::io; 

fn main() { 
    let reader = io::stdin(); 
} 

stdin वैश्विक बफर कि इनपुट धारा संभालती है पढ़ता है और भी BufRead विशेषता जो read_line method विधि है लागू करता है। यह एक इनपुट बफर के रूप में एक mutable String लेता है और स्ट्रीम से सभी बाइट्स पढ़ता है जब तक कि एक न्यूलाइन बाइट तक नहीं पहुंच जाता है और उन्हें बफर में जोड़ता है। #expect() विधि Result को अनदेखा करती है; यदि यह Err है तो यह संदेश और कारण से घबराएगा।

use std::io; 

fn main() { 
    let reader = io::stdin(); 
    let mut input_text = String::new(); 
    reader.read_line(&mut input_text).expect("failed to read line"); 
} 

अब हम इनपुट पाठ है कि हम एक i32 में तब्दील करना चाहते हैं। यह वह जगह है जहां str::parse() हमारे लिए काम करेगा, जब तक हम इसे एक प्रकार का विश्लेषण करने के लिए देते हैं। str::trim() हम अभी भी सुनिश्चित करना है कि हम सफलतापूर्वक इनपुट पैटर्न मिलान का उपयोग कर पार्स जरूरत है क्योंकि read_line न्यू लाइन बाइट बफर

use std::io; 

fn main() { 
    let reader = io::stdin(); 
    let mut input_text = String::new(); 
    reader.read_line(&mut input_text).expect("failed to read line"); 
    let input = input_text.trim().parse::<i32>(); 
} 

हम अभी तक नहीं किया है भी शामिल है के लिए आवश्यक है,। सभी कोड आप एक प्रयोग करने योग्य पूर्णांक में अपने मूल इनपुट बफर बदलने की आवश्यकता है:

use std::io; 

fn main() { 
    let reader = io::stdin(); 
    let mut input_text = String::new(); 

    reader.read_line(&mut input_text).expect("failed to read line"); 

    let input_opt = input_text.trim().parse::<i32>(); 

    let input_int = match input_opt { 
     Ok(input_int) => input_int, 
     Err(e) => { 
      println!("please input a number ({})", e); 
      return; 
     } 
    }; 

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

यह त्रुटि या चेतावनी के बिना संकलित करता है।

Answer 2

इनपुट में अंत में एक नई लाइन शामिल है, जैसा कि read_line के लिए प्रलेखन में बताया गया है। यह विफल होने के लिए from_str() का कारण बनता है। std::str::trim() का प्रयोग करते हैं और इस बदलते:

let input: Result<i32, _> = input_text.parse(); 

इस में

:

let input: Result<i32, _> = input_text.trim().parse(); 

काम करने के लिए लगता है।

Answer 3

इस प्रयास करें:

fn main() { 
    let input_text = std::old_io::stdin() 
     .read_line() 
     .ok() 
     .expect("failed to read line"); 
    let input_number: Option<i32> = input_text.trim().parse().ok(); 
    let number = match input_number{ 
     Some(num) => num, 
     None => { 
      println!("Wrong input data! Input a number."); 
      return; 
     } 
    }; 
    println!("{}", number); 
} 

Answer 4

जंग के रूप में 1।14, The Rust Programming Language has this example:

let guess: u32 = guess.trim().parse() 
    .expect("Please type a number!"); 

तुम भी सिर्फ एक ही चर नाम फिर से उपयोग कर सकते हैं और नए प्रकार होगा "छाया" पुराना प्रकार:

use std::io; 

fn main() { 
    let mut input_text = String::new(); 

    io::stdin() 
     .read_line(&mut input_text) 
     .expect("failed to read line"); 

    let input: u32 = input_text.trim().parse() 
     .expect("Please type a number!"); 
} 

Answer 5

स्ट्रिंग पूर्णांक हम ट्रिम का उपयोग परिवर्तित करने के लिए और पार्स। स्ट्रिंग्स पर ट्रिम() विधि हमारी स्ट्रिंग की शुरुआत और अंत में किसी भी व्हाइटस्पेस को खत्म कर देगी।

इसका मतलब है कि अगर हम 5 टाइप करते हैं और हिट रिटर्न देते हैं, तो अनुमान इस तरह दिखता है: 5 \ n। \ N 'न्यूलाइन', एंटर कुंजी का प्रतिनिधित्व करता है। ट्रिम() इस से छुटकारा पाता है, हमारी स्ट्रिंग को केवल 5 के साथ छोड़ देता है।

तारों पर पार्स() विधि किसी प्रकार की संख्या में एक स्ट्रिंग को पार करती है। चूंकि यह विभिन्न प्रकारों को पार्स कर सकता है, इसलिए हमें जंग को एक सटीक प्रकार की संख्या के रूप में संकेत देना होगा जो हम चाहते हैं। इसलिए, a_int: i32 दें। कॉलन (:) अनुमान के बाद जंग जंग को बताता है कि हम इसके प्रकार को एनोटेट करने जा रहे हैं। i32 एक पूर्णांक, तीस-दो-बिट पूर्णांक है। यदि कोई त्रुटि है तो हम उम्मीद() विधि को क्रैश करने के लिए उपयोग करते हैं।

let a_int: i32 = input_1.trim().parse() 
.ok() 
.expect("Please type a number!"); 

रेफरी:

• https://users.rust-lang.org/t/from-string-to-integer/3632
• https://doc.rust-lang.org/stable/book/guessing-game.html