Rust
स्ट्रिंग्स

परिचय

बुनियादी स्ट्रिंग हेरफेर

fn main() {
    // Statically allocated string slice
    let hello = "Hello world";

    // This is equivalent to the previous one
    let hello_again: &'static str = "Hello world";

    // An empty String
    let mut string = String::new();

    // An empty String with a pre-allocated initial buffer
    let mut capacity = String::with_capacity(10);

    // Add a string slice to a String
    string.push_str("foo");

    // From a string slice to a String
    // Note: Prior to Rust 1.9.0 the to_owned method was faster
    // than to_string. Nowadays, they are equivalent.      
    let bar = "foo".to_owned();
    let qux = "foo".to_string();

    // The String::from method is another way to convert a
    // string slice to an owned String.
    let baz = String::from("foo");

    // Coerce a String into &str with &
    let baz: &str = &bar;
}

नोट: String::new और String::with_capacity विधियों से रिक्त स्ट्रिंग्स String::with_capacity । हालाँकि, बाद वाला एक प्रारंभिक बफर आवंटित करता है, जिससे यह शुरू में धीमा हो जाता है, लेकिन बाद के आवंटन को कम करने में मदद करता है। यदि स्ट्रिंग का अंतिम आकार ज्ञात है, तो String::with_capacity को प्राथमिकता दी जानी चाहिए।

कटा हुआ टुकड़ा

fn main() {
    let english = "Hello, World!";

    println!("{}", &english[0..5]); // Prints "Hello"
    println!("{}", &english[7..]);  // Prints "World!"
}

ध्यान दें कि हमें यहां & ऑपरेटर का उपयोग करना होगा। यह एक संदर्भ लेता है और इस प्रकार संकलक को स्लाइस प्रकार के आकार के बारे में जानकारी देता है, जिसे इसे प्रिंट करने की आवश्यकता होती है। संदर्भ के बिना, दो println! कॉल एक संकलन-समय त्रुटि होगी।

चेतावनी: बाइट ऑफ़सेट द्वारा स्लाइसिंग कार्य करता है, चरित्र ऑफसेट नहीं, और जब सीमा एक वर्ण सीमा पर नहीं होती है तो घबराएँगे:

fn main() {
    let icelandic = "Halló, heimur!"; // note that “ó” is two-byte long in UTF-8

    println!("{}", &icelandic[0..6]); // Prints "Halló", “ó” lies on two bytes 5 and 6
    println!("{}", &icelandic[8..]);  // Prints "heimur!", the “h” is the 8th byte, but the 7th char
    println!("{}", &icelandic[0..5]); // Panics!
}

यही कारण है कि तार सरल अनुक्रमण का समर्थन नहीं करते हैं (उदाहरण। icelandic[5] । icelandic[5] । icelandic[5] । icelandic[5] )।

एक तार को विभाजित करें

let strings = "bananas,apples,pear".split(",");

split एक पुनरावृत्ति देता है।

for s in strings {
  println!("{}", s)
}

और Iterator::collect विधि के साथ एक Vec में "एकत्र" किया जा सकता है।

let strings: Vec<&str> = "bananas,apples,pear".split(",").collect(); // ["bananas", "apples", "pear"]

उधार से लेकर स्वामित्व तक

// all variables `s` have the type `String`
let s = "hi".to_string();  // Generic way to convert into `String`. This works
                           // for all types that implement `Display`.

let s = "hi".to_owned();   // Clearly states the intend of obtaining an owned object

let s: String = "hi".into();       // Generic conversion, type annotation required
let s: String = From::from("hi");  // in both cases!

let s = String::from("hi");  // Calling the `from` impl explicitly -- the `From` 
                             // trait has to be in scope!

let s = format!("hi");       // Using the formatting functionality (this has some
                             // overhead)

format!() अलावा, उपरोक्त सभी विधियां समान रूप से तेज़ हैं।

लंबी स्ट्रिंग शाब्दिक तोड़ना

नियमित स्ट्रिंग शाब्दिक को \ चरित्र से तोड़ें

let a = "foobar";
let b = "foo\
         bar";

// `a` and `b` are equal.
assert_eq!(a,b);

स्ट्रिंग्स को अलग करने के लिए कच्चे-स्ट्रिंग शाब्दिक को तोड़ें, और उन्हें concat! साथ जोड़ दें concat! मैक्रो

let c = r"foo\bar";
let d = concat!(r"foo\", r"bar");

// `c` and `d` are equal.
assert_eq!(c, d);