Rust में String को int में बदलना: उदाहरणों के साथ पूर्ण गाइड

परिचय: Rust स्ट्रिंग को संख्या में बदलने की अनुमति क्यों नहीं देता?

यदि आप Python या JavaScript से आए हैं, तो आप int("42") या parseInt("42") जैसे जादू के आदी हैं। Rust में ऐसा कोई करतब काम नहीं करेगा — कंपाइलर स्पष्ट रूप से बताने की मांग करेगा कि आप स्ट्रिंग को किस प्रकार में बदलना चाहते हैं। क्यों? क्योंकि Rust एक ऐसी भाषा है जो लापरवाही को माफ नहीं करती। यह आपको सीमा मामलों के बारे में सोचने पर मजबूर करती है: यदि स्ट्रिंग में कोई संख्या नहीं है तो क्या होगा? यदि संख्या चुने गए प्रकार के लिए बहुत बड़ी है तो क्या होगा?

इस लेख में, हम Rust में शुरुआती लोगों के बीच Stack Overflow पर सबसे लोकप्रिय प्रश्न को हल करेंगे: String को int में कैसे बदलें। आपको केवल तैयार कोड ही नहीं मिलेगा, बल्कि यह भी पूरी समझ मिलेगी कि हुड के नीचे क्या हो रहा है।

parse() विधि — रूपांतरण का मुख्य उपकरण

Rust में स्ट्रिंग को संख्या में बदलने का मुख्य तरीका parse() विधि है, जो String और &str प्रकारों के लिए उपलब्ध है। यह FromStr ट्रेट के माध्यम से कार्यान्वित किया गया है और Result<T, E> लौटाता है।

मूल उदाहरण: String → i32

fn main() {\n    let number_string = String::from("42");\n    let number: i32 = number_string.parse().unwrap();\n    println!("संख्या: {}", number); // आउटपुट: संख्या: 42\n}

unwrap() पर ध्यान दें। यह Result से मान निकालने का एक त्वरित तरीका है, लेकिन यह खतरनाक है: यदि स्ट्रिंग कोई संख्या नहीं है, तो प्रोग्राम पैनिक करेगा और क्रैश हो जाएगा।

सही त्रुटि प्रबंधन

वास्तविक कोड में, आपको कभी भी बिना सोचे-समझे unwrap() का उपयोग नहीं करना चाहिए। सही तरीका यह है:

use std::num::ParseIntError;\n\nfn main() {\n    let input = String::from("hello");\n    \n    match input.parse::<i32>() {\n        Ok(number) => println!("सफल: {}", number),\n        Err(e) => println!("रूपांतरण त्रुटि: {}", e),\n    }\n}

या if let के साथ अधिक संक्षिप्त संस्करण:

fn main() {\n    let input = String::from("2024");\n    \n    if let Ok(year) = input.parse::<i32>() {\n        println!("वर्ष: {}", year);\n    } else {\n        println!("स्ट्रिंग को पार्स करने में विफल");\n    }\n}

रूपांतरण के लिए उपलब्ध पूर्णांक प्रकार

Rust पूर्णांक प्रकारों का एक समृद्ध चयन प्रदान करता है। आप स्ट्रिंग को इनमें से किसी में भी बदल सकते हैं:

\n
• i8, i16, i32, i64, i128 — साइन वाले पूर्णांक
\n
• u8, u16, u32, u64, u128 — बिना साइन वाले पूर्णांक
\n
• isize, usize — आकार आर्किटेक्चर पर निर्भर करता है
\n

विभिन्न प्रकारों में रूपांतरण का उदाहरण:

fn main() {\n    let val = "255";\n    \n    let a: u8  = val.parse().unwrap();   // 255\n    let b: i16 = val.parse().unwrap();   // 255\n    let c: u32 = val.parse().unwrap();   // 255\n    \n    // लेकिन यह त्रुटि देगा — 255 i8 में फिट नहीं होता\n    // let d: i8 = val.parse().unwrap(); // PANIC!\n}

उन्नत तकनीकें: from_str और कस्टम प्रकार

parse() विधि आंतरिक रूप से FromStr ट्रेट से from_str() को कॉल करती है। आप अपनी संरचनाओं के लिए इस ट्रेट को कार्यान्वित कर सकते हैं:

use std::str::FromStr;\nuse std::num::ParseIntError;\n\n#[derive(Debug)]\nstruct Version {\n    major: u32,\n    minor: u32,\n}\n\nimpl FromStr for Version {\n    type Err = ParseIntError;\n    \n    fn from_str(s: &str) -> Result<Self, Self::Err> {\n        let parts: Vec<&str> = s.split('.').collect();\n        if parts.len() != 2 {\n            // अपनी त्रुटि बनाएँ, लेकिन उदाहरण के लिए ParseIntError का उपयोग करें\n            return Err("1.0".parse::<u32>().unwrap_err());\n        }\n        \n        let major = parts[0].p