मैं तार कैसे समतल करूं?

Question

मैं निम्नलिखित प्रकारों के संयोजन को कैसे तैयार करूं:

• str तथा str
• String तथा str
• String तथा String

Comments

ध्यान दें कि strऔर &strकर रहे हैं विभिन्न प्रकार के और समय के 99% के लिए, आप केवल के बारे में ध्यान देना चाहिए &str। उनके बीच के अंतरों का विवरण देने वाले अन्य प्रश्न हैं।

— शेमपस्टर

Answer 1

जब आप तारों को समतल करते हैं, तो आपको परिणाम को संग्रहीत करने के लिए मेमोरी आवंटित करने की आवश्यकता होती है। के साथ शुरू करने के लिए सबसे आसान है Stringऔर &str:

fn main() {
    let mut owned_string: String = "hello ".to_owned();
    let borrowed_string: &str = "world";

    owned_string.push_str(borrowed_string);
    println!("{}", owned_string);
}

यहां, हमारे पास एक स्वामित्व स्ट्रिंग है जिसे हम म्यूट कर सकते हैं। यह कुशल है क्योंकि यह संभवतः हमें मेमोरी आवंटन का पुन: उपयोग करने की अनुमति देता है। वहाँ के लिए एक समान मामला है, Stringऔर Stringके रूप में &String dereferenced जा सकता है&str ।

fn main() {
    let mut owned_string: String = "hello ".to_owned();
    let another_owned_string: String = "world".to_owned();

    owned_string.push_str(&another_owned_string);
    println!("{}", owned_string);
}

इसके बाद, another_owned_stringअछूता है (नोट नो mutक्वालीफायर)। एक और वैरिएंट है जो खपत करता है , Stringलेकिन इसके लिए म्यूट होने की आवश्यकता नहीं है। यह एक है के कार्यान्वयन Addविशेषता है कि एक लेता है Stringऔर बाएं हाथ की ओर के रूप में एक &strदाएँ हाथ की ओर के रूप में:

fn main() {
    let owned_string: String = "hello ".to_owned();
    let borrowed_string: &str = "world";

    let new_owned_string = owned_string + borrowed_string;
    println!("{}", new_owned_string);
}

ध्यान दें कि owned_stringकॉल के बाद अब पहुँच योग्य नहीं है +।

क्या होगा यदि हम दोनों अछूते छोड़कर एक नई स्ट्रिंग का उत्पादन करना चाहते हैं? उपयोग करने का सबसे सरल तरीका है format!:

fn main() {
    let borrowed_string: &str = "hello ";
    let another_borrowed_string: &str = "world";

    let together = format!("{}{}", borrowed_string, another_borrowed_string);
    println!("{}", together);
}

ध्यान दें कि दोनों इनपुट चर अपरिवर्तनीय हैं, इसलिए हम जानते हैं कि उन्हें छुआ नहीं गया है। यदि हम किसी भी संयोजन के लिए एक ही काम करना चाहते हैं String, तो हम इस तथ्य का उपयोग कर सकते हैं कि Stringप्रारूपित भी किया जा सकता है:

fn main() {
    let owned_string: String = "hello ".to_owned();
    let another_owned_string: String = "world".to_owned();

    let together = format!("{}{}", owned_string, another_owned_string);
    println!("{}", together);
}

हालांकि आपको इसका उपयोग नहीं करना है format!। आप एक स्ट्रिंग को क्लोन कर सकते हैं और दूसरे स्ट्रिंग को नए स्ट्रिंग में जोड़ सकते हैं :

fn main() {
    let owned_string: String = "hello ".to_owned();
    let borrowed_string: &str = "world";

    let together = owned_string.clone() + borrowed_string;
    println!("{}", together);
}

नोट - मेरे द्वारा किए गए सभी प्रकार के विनिर्देश निरर्थक हैं - संकलक यहां सभी प्रकार के नाटक कर सकता है। मैंने उन्हें केवल रस्ट में नए लोगों के लिए स्पष्ट होने के लिए जोड़ा, क्योंकि मुझे उम्मीद है कि यह प्रश्न उस समूह के साथ लोकप्रिय होगा!

Comments

आप Add/ +प्रतीक के बारे में क्या सोचते हैं ? आप चाहें तो इसे कवर कर सकते हैं।

— bluss

हो सकता है कि यह काफी सरल हो, लेकिन इसे समझने के लिए Add with String के लिए संभावित प्रकार के हस्ताक्षर देखने की आवश्यकता होती है।

— bluss

धन्यवाद! क्या आप थोड़ा और गहराई में जाने में सक्षम हैं कि कैसे और स्ट्रिंग को एक & str के रूप में परिभाषित किया जा सकता है? इसके कार्यान्वयन का कौन सा हिस्सा अनुमति देता है और / या यह डोको में कहां कहता है?

— jsalter

@jsalter एक बहुत ही अलग विषय है, इसलिए यह एक और शीर्ष-स्तरीय प्रश्न के रूप में अच्छा हो सकता है। मैंने उपयुक्त डॉक्स से लिंक करने के लिए अपडेट किया है (जितना मैं कम से कम प्राप्त कर सकता हूं ...)

— शेकपास्टर

@ क्रिसमोरोन यह ध्यान दिया जाना चाहिए कि विसंगति .to_owned()और .to_string()उपरोक्त टिप्पणी के बाद से तय किया गया है ताकि विशेषज्ञता को निहित किया जा सके । वे दोनों अब एक ही प्रदर्शन है जब एक पर बुलाया &str। प्रासंगिक प्रतिबद्धता: github.com/rust-lang/rust/pull/32586/files

— chad

Answer 2

एक तार में कई तारों को समेटने के लिए, दूसरे वर्ण द्वारा अलग किए गए, कुछ तरीके हैं।

मेरे द्वारा देखा गया सबसे अच्छा joinतरीका सरणी पर विधि का उपयोग कर रहा है :

fn main() {
    let a = "Hello";
    let b = "world";
    let result = [a, b].join("\n");

    print!("{}", result);
}

आपके उपयोग के मामले के आधार पर आप अधिक नियंत्रण भी पसंद कर सकते हैं:

fn main() {
    let a = "Hello";
    let b = "world";
    let result = format!("{}\n{}", a, b);

    print!("{}", result);
}

कुछ और मैनुअल तरीके हैं जो मैंने देखे हैं, कुछ यहां और वहां एक या दो आवंटन से बचते हैं। पठनीयता उद्देश्यों के लिए मुझे उपरोक्त दोनों पर्याप्त हैं।

Comments

joinदस्तावेज कहाँ है ? यह एक ऐरे और एक स्ट्रिंग के बीच आधे रास्ते में बैठती है। मैंने सरणी प्रलेखन के माध्यम से खोज की और जल्दी से भ्रमित हो गया।

— डुआने जे

@DuaneJ joinवास्तव में SliceContactExtविशेषता से जुड़ा हुआ है । लक्षण को अस्थिर रूप में चिह्नित किया गया है, लेकिन इसके तरीके स्थिर हैं और प्रस्तावना में शामिल हैं, इसलिए वे डिफ़ॉल्ट रूप से हर जगह उपयोग करने योग्य हैं। टीम अच्छी तरह से जानती है कि इस विशेषता का अस्तित्व नहीं है और मुझे लगता है कि भविष्य में इसके साथ चीजें बदल जाएंगी।

— साइमन व्हाइटहेड

Answer 3

मुझे लगता है कि concatविधि और +यहाँ भी उल्लेख किया जाना चाहिए:

assert_eq!(
  ("My".to_owned() + " " + "string"),
  ["My", " ", "string"].concat()
);

और concat!मैक्रो भी है लेकिन केवल शाब्दिक के लिए:

let s = concat!("test", 10, 'b', true);
assert_eq!(s, "test10btrue");

Comments

+मौजूदा उत्तर में पहले ही उल्लेख किया गया है । ( इस के एक कार्यान्वयन है Addऐसी विशेषता है जो लेता है एक Stringबाएं ओर है और एक के रूप में &strदाएँ हाथ की ओर के रूप में: )

— Shepmaster

सच है, मौजूदा जवाब इतना व्यापक है , हालांकि मैंने नोटिस नहीं किया।

— suside

Answer 4

RUST में तार को समाप्‍त करने के सरल तरीके

RUST को सुगम बनाने के लिए RUST में विभिन्न विधियाँ उपलब्ध हैं

पहली विधि (उपयोग करके concat!()):

fn main() {
    println!("{}", concat!("a", "b"))
}

उपरोक्त कोड का आउटपुट है:

अब

---

दूसरी विधि (उपयोग push_str()और +ऑपरेटर):

fn main() {
    let mut _a = "a".to_string();
    let _b = "b".to_string();
    let _c = "c".to_string();

    _a.push_str(&_b);
    
    println!("{}", _a);
 
    println!("{}", _a + &_b);
}

उपरोक्त कोड का आउटपुट है:

अब

एबीसी

---

तीसरा तरीका ( Using format!()):

fn main() {
    let mut _a = "a".to_string();
    let _b = "b".to_string();
    let _c = format!("{}{}", _a, _b);
    
    println!("{}", _c);
}

उपरोक्त कोड का आउटपुट है:

अब

इसे देखें और जंग खेलने के मैदान के साथ प्रयोग करें

Comments

यह उत्तर मौजूदा उत्तरों में कुछ नया नहीं जोड़ता है।

— शेमपस्टर