मैं जंग में एक स्ट्रिंग कैसे विभाजित करूं?

Question

से प्रलेखन , यह स्पष्ट नहीं है। जावा में आप इस splitतरह विधि का उपयोग कर सकते हैं :

"some string 123 ffd".split("123");

Comments

doc.rust-lang.org/std/string/struct.String.html

— Dulguun Otgon

@ कैसे एक वेक्टर के बजाय इसे एक स्ट्रिंग सरणी बनाने का एक तरीका है?

— ग्रेग

मैं ऐसा करने के किसी भी तरीके के बारे में नहीं जानता, सीधे तौर पर। आपको संभवतः इसे मैन्युअल रूप से पुनरावृत्त करना होगा Splitऔर इसे सरणी में सेट करना होगा। बेशक इसका मतलब है कि प्रत्येक विभाजन में आइटम की संख्या समान होनी चाहिए क्योंकि सरणियाँ निश्चित आकार हैं और आपके पास पहले परिभाषित सरणी होनी चाहिए। मुझे लगता है कि यह सिर्फ बनाने की तुलना में अधिक परेशानी हो सकती है Vec।

— धनुष

Answer 1

उपयोग split()

let mut split = "some string 123 ffd".split("123");

यह एक पुनरावृत्ति देता है, जिसे आप लूप या collect()वेक्टर में बदल सकते हैं।

for s in split {
    println!("{}", s)
}
let vec = split.collect::<Vec<&str>>();
// OR
let vec: Vec<&str> = split.collect();

Comments

आप इसे भी लिख सकते हैं .collect::<Vec<_>>()।

— क्रिस मॉर्गन

मुझे परिणाम की लंबाई कैसे मिलेगी - let split? split.len()मौजूद नहीं है।

— ッ ク ス

@AlexanderSupertramp उपयोग .count()। len()केवल पुनरावृत्तियों के लिए है जो उनके सटीक आकार को जानते हैं बिना भस्म किए बिना, count()पुनरावृत्ति करने वाले का उपभोग करते हैं।

— मनिशिथ

error: cannot borrow immutable local variable विभाजित करें 'म्यूटेबल' के रूप में

— ア レ ク ス

@AlexanderSupertramp let mut split, क्षमा करें।

— मनीषीर्थ

Answer 2

इसके तीन सरल तरीके हैं:

1. विभाजक द्वारा :

   s.split("separator")  |  s.split('/')  |  s.split(char::is_numeric)

2. व्हाट्सप्प द्वारा :

   s.split_whitespace()

3. Newlines द्वारा :

   s.lines()

प्रत्येक प्रकार का परिणाम एक पुनरावृत्ति है:

let text = "foo\r\nbar\n\nbaz\n";
let mut lines = text.lines();

assert_eq!(Some("foo"), lines.next());
assert_eq!(Some("bar"), lines.next());
assert_eq!(Some(""), lines.next());
assert_eq!(Some("baz"), lines.next());

assert_eq!(None, lines.next());

Answer 3

splitसंरचना के लिएString एक विशेष विधि है :

fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>

चार्ली द्वारा विभाजित:

let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

स्ट्रिंग द्वारा विभाजित करें:

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

बंद करके विभाजित करें:

let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

Answer 4

splitएक रिटर्न Iterator, जिसे आप एक में बदल सकते हैं Vecका उपयोग कर collect: split_line.collect::<Vec<_>>()। Vecसीधे वापस लौटने के बजाय एक सूचना के माध्यम से जाने के कई फायदे हैं:

• splitआलसी है। इसका मतलब है कि यह वास्तव में लाइन को विभाजित नहीं करेगा जब तक कि आपको इसकी आवश्यकता न हो। इस तरह यह पूरी स्ट्रिंग को विभाजित करने में समय बर्बाद नहीं करेगा यदि आपको केवल पहले कुछ मूल्यों की आवश्यकता है: split_line.take(2).collect::<Vec<_>>()या यहां तक ​​कि अगर आपको केवल पहले मूल्य की आवश्यकता है जिसे पूर्णांक में परिवर्तित किया जा सकता है split_line.filter_map(|x| x.parse::<i32>().ok()).next():। यह अंतिम उदाहरण "23.0" को संसाधित करने का समय बर्बाद नहीं करेगा, लेकिन "1" का पता चलने पर तुरंत प्रसंस्करण बंद हो जाएगा।
• splitपरिणाम को संग्रहीत करने के तरीके पर कोई धारणा नहीं बनाता है। आप एक का उपयोग कर सकते हैं Vec, लेकिन आप किसी भी चीज़ का उपयोग कर सकते हैं जो कि लागू करता है FromIterator<&str>, उदाहरण के लिए एक LinkedListया एक VecDeque, या किसी भी कस्टम प्रकार जो लागू करता है FromIterator<&str>।

Comments

आपके विस्तृत उत्तर के लिए धन्यवाद, कोई भी विचार let x = line.unwrap().split(",").collect::<Vec<_>>();तब तक काम क्यों नहीं करता जब तक कि उसे दो अलग-अलग पंक्तियों में अलग नहीं किया जाता: let x = line.unwrap();और let x = x.split(",").collect::<Vec<_>>();? त्रुटि संदेश कहता है:temporary value created here ^ temporary value dropped here while still borrowed

— ग्रेग

हालाँकि यह अपेक्षा के अनुरूप काम करता है यदि मैं उपयोग करता हूंlet x = line.as_ref().unwrap().split(",").collect::<Vec<_>>();

— ग्रेग

Answer 5

वहाँ भी split_whitespace()

fn main() {
    let words: Vec<&str> = "   foo   bar\t\nbaz   ".split_whitespace().collect();
    println!("{:?}", words);
    // ["foo", "bar", "baz"] 
}