दिलचस्प पोस्ट
क्या पायथन में एक स्ट्रिंग 'शामिल' सबस्ट्रिंग पद्धति है? मिलान कोष्ठक को संतुलित करने के लिए RegEx का उपयोग करना JFrame के लिए अनुत्तरदायी कुंजीलिस्टर पायथन कक्षा का आईडी अद्वितीय क्यों नहीं है, जब इसे जल्दी से बुलाया जाता है? AngularJs "नियंत्रक के रूप में" वाक्यविन्यास – स्पष्टीकरण? जांच करें कि क्या कोई वर्ग किसी दिए गए हस्ताक्षर का सदस्य कार्य है या नहीं दूरस्थ मॉडल के साथ बूटस्ट्रैप 3 अल्पसंख्यक पीछे सूची में क्यों हैं? कैसे मजबूत पैरामीटर के साथ एक सरणी की अनुमति के लिए जेएलैबल में न्यूलाइन टाइम-टाइम कॉलबैक सेट करने के लिए सही "यह" संदर्भ पास करें? यूटीएफ -8 बनाम यूनिकोड रेल के साथ पूरी तरह से कस्टम सत्यापन त्रुटि संदेश क्यों थ्रेड फ़ंक्शन को ऑब्जेक्ट रेफरेंस आर्ग्यूमेंट्स को संकलित करने में विफल रहता है? मैं अग्रणी शून्य के साथ एक मूल्य कैसे पैड कर सकता हूं?

आप String.substringWithRange का उपयोग कैसे करते हैं? (या, रेंज कैसे स्विफ्ट में काम करते हैं?)

स्विफ्ट में एक String उपस्ट्रिंग को कैसे निकालना है, मैं यह जानने में अभी तक सक्षम नहीं हूं:

 var str = “Hello, playground” func test(str: String) -> String { return str.substringWithRange( /* What goes here? */ ) } test (str) 

मैं स्विफ्ट में एक रेंज बनाने में सक्षम नहीं हूँ खेल का मैदान में स्वत: पूर्ण सुपर उपयोगी नहीं है – यह वही है जो यह सुझाता है:

 return str.substringWithRange(aRange: Range<String.Index>) 

मुझे स्विफ्ट स्टैंडर्ड रेफरेंस लाइब्रेरी में कुछ भी नहीं मिला है जो मदद करता है यहाँ एक और जंगली अनुमान था:

 return str.substringWithRange(Range(0, 1)) 

और इस:

 let r:Range<String.Index> = Range<String.Index>(start: 0, end: 2) return str.substringWithRange(r) 

मैंने अन्य उत्तर देखा है ( स्विफ्ट स्ट्रिंग में चरित्र का इंडेक्स ढूँढना ) जो कि सुझाव देते हैं कि String एक NSString लिए एक पुल प्रकार है, "पुराने" तरीकों को काम करना चाहिए, लेकिन यह स्पष्ट नहीं है कि कैसे – यह काम नहीं करता है या तो (वैध वाक्यविन्यास प्रतीत नहीं होता है):

 let x = str.substringWithRange(NSMakeRange(0, 3)) 

विचार?

वेब के समाधान से एकत्रित समाधान "आप String.substringWithRange का उपयोग कैसे करते हैं? (या, रेंज कैसे स्विफ्ट में काम करते हैं?)"

आप substringWithRange विधि का उपयोग कर सकते हैं इसमें स्ट्रिंग.इंडेक्स की शुरुआत और समाप्ति होती है।

 var str = "Hello, playground" str.substringWithRange(Range<String.Index>(start: str.startIndex, end: str.endIndex)) //"Hello, playground" 

प्रारंभ और अंत सूचकांक को बदलने के लिए, उन्नत (एन) का उपयोग करें

 var str = "Hello, playground" str.substringWithRange(Range<String.Index>(start: str.startIndex.advancedBy(2), end: str.endIndex.advancedBy(-1))) //"llo, playgroun" 

आप अब भी NSRange के साथ NSString विधि का उपयोग कर सकते हैं, लेकिन आपको यह सुनिश्चित करना है कि आप इस तरह से एक NSString का उपयोग कर रहे हैं:

 let myNSString = str as NSString myNSString.substringWithRange(NSRange(location: 0, length: 3)) 

नोट: जैसा कि JanX2 उल्लेख किया गया है, यह दूसरी विधि यूनिकोड स्ट्रिंग्स के साथ सुरक्षित नहीं है।

स्विफ्ट 2

सरल

 let str = "My String" let subStr = str[str.startIndex.advancedBy(3)...str.startIndex.advancedBy(7)] //"Strin" 

स्विफ्ट 3

 let startIndex = str.index(str.startIndex, offsetBy: 3) let endIndex = str.index(str.startIndex, offsetBy: 7) str[startIndex...endIndex] // "Strin" str.substring(to: startIndex) // "My " str.substring(from: startIndex) // "String" 

स्विफ्ट 4

substring(to:) और substring(from:) को Swift 4 में पदावनत किया गया है

 String(str[..<startIndex]) // "My " String(str[startIndex...]) // "String" String(str[startIndex...endIndex]) // "Strin" 

नोट: इस दृष्टिकोण के ट्रेड-ऑफ पर विशेष रूप से छिपे हुए प्रदर्शन प्रभावों पर, मारर्सपेड्सविफ्ट ने कुछ बहुत ही व्यावहारिक बिंदु बनाए हैं । तार सरल जानवर नहीं हैं, और किसी विशेष सूचकांक को प्राप्त करने के लिए ओ (एन) समय लग सकता है, जिसका मतलब है कि एक सब्सक्रिप्शन का उपयोग करने वाला एक लूप ओ (एन ^ 2) हो सकता है आपको चेतावनी दी गई है।

आपको बस एक नया subscript फ़ंक्शन जोड़ना होगा जो एक श्रेणी लेता है और advancedBy() कहां उपयोग करता है advancedBy() जहाँ आप चाहते हैं वहां चलें:

 import Foundation extension String { subscript (r: Range<Int>) -> String { get { let startIndex = self.startIndex.advancedBy(r.startIndex) let endIndex = startIndex.advancedBy(r.endIndex - r.startIndex) return self[Range(start: startIndex, end: endIndex)] } } } var s = "Hello, playground" println(s[0...5]) // ==> "Hello," println(s[0..<5]) // ==> "Hello" 

(यह निश्चित रूप से भाषा का हिस्सा होना चाहिए। कृपया dupe rdar: // 17158813 )

मजे के लिए, आप इंडेक्स पर एक + ऑपरेटर भी जोड़ सकते हैं:

 func +<T: ForwardIndex>(var index: T, var count: Int) -> T { for (; count > 0; --count) { index = index.succ() } return index } s.substringWithRange(s.startIndex+2 .. s.startIndex+5) 

(मुझे अभी तक पता नहीं है अगर यह एक भाषा का हिस्सा होना चाहिए या नहीं।)

जब मैं लिख रहा हूं, कोई भी एक्सटेंशन पूरी तरह से स्विफ्ट 3 संगत नहीं है, इसलिए ये एक है जो सभी जरूरतों को पूरा करता है जो मैं सोच सकता हूं:

 extension String { func substring(from: Int?, to: Int?) -> String { if let start = from { guard start < self.characters.count else { return "" } } if let end = to { guard end >= 0 else { return "" } } if let start = from, let end = to { guard end - start >= 0 else { return "" } } let startIndex: String.Index if let start = from, start >= 0 { startIndex = self.index(self.startIndex, offsetBy: start) } else { startIndex = self.startIndex } let endIndex: String.Index if let end = to, end >= 0, end < self.characters.count { endIndex = self.index(self.startIndex, offsetBy: end + 1) } else { endIndex = self.endIndex } return self[startIndex ..< endIndex] } func substring(from: Int) -> String { return self.substring(from: from, to: nil) } func substring(to: Int) -> String { return self.substring(from: nil, to: to) } func substring(from: Int?, length: Int) -> String { guard length > 0 else { return "" } let end: Int if let start = from, start > 0 { end = start + length - 1 } else { end = length - 1 } return self.substring(from: from, to: end) } func substring(length: Int, to: Int?) -> String { guard let end = to, end > 0, length > 0 else { return "" } let start: Int if let end = to, end - length > 0 { start = end - length + 1 } else { start = 0 } return self.substring(from: start, to: to) } } 

और फिर, आप इसका उपयोग कर सकते हैं:

 let string = "Hello,World!" 

string.substring(from: 1, to: 7) आपको मिलती है: ello,Wo

string.substring(to: 7) आपको मिलती है: Hello,Wo

string.substring(from: 3) आप हो जाता है: lo,World!

string.substring(from: 1, length: 4) आपको मिलती है: ello

string.substring(length: 4, to: 7) आपको मिलती है: o,Wo

शून्य से शुरू होने से समर्थन करने के लिए अपडेट किए गए substring(from: Int?, length: Int)

SWIFT 2.0

सरल:

 let myString = "full text container" let substring = myString[myString.startIndex..<myString.startIndex.advancedBy(3)] // prints: ful 

SWIFT 3.0

 let substring = myString[myString.startIndex..<myString.index(myString.startIndex, offsetBy: 3)] // prints: ful 

SWIFT 4.0

सबस्ट्रिंग ऑपरेशन स्ट्रिंग के बजाय सबस्ट्रिंग प्रकार का एक उदाहरण लौटाता है।

 let substring = myString[myString.startIndex..<myString.index(myString.startIndex, offsetBy: 3)] // prints: ful // Convert the result to a String for long-term storage. let newString = String(substring) 

यहां दिए गए किसी भी उत्तर की तुलना में यह बहुत आसान है, एक बार जब आप सही सिंटैक्स पाते हैं

मैं दूर [और] ले जाना चाहता हूं

 let myString = "[ABCDEFGHI]" let startIndex = advance(myString.startIndex, 1) //advance as much as you like let endIndex = advance(myString.endIndex, -1) let range = startIndex..<endIndex let myNewString = myString.substringWithRange( range ) 

परिणाम "एबीसीडीईएफजीएचआई" होगा और शुरुआत आईएनडेएक्स और एंड इंडेक्स का भी इस्तेमाल किया जा सकता है

 let mySubString = myString.substringFromIndex(startIndex) 

और इसी तरह!

पुनश्च: जैसा कि टिप्पणी में बताया गया है, स्विफ्ट 2 में कुछ सिंटैक्स बदलाव हैं जो एक्सोड 7 और आईओएस 9 के साथ आता है!

कृपया इस पृष्ठ को देखें

उदाहरण के लिए मेरे पूरे नाम में पहला नाम (प्रथम स्थान तक) खोजने के लिए:

 let name = "Joris Kluivers" let start = name.startIndex let end = find(name, " ") if end { let firstName = name[start..end!] } else { // no space found } 

start और end प्रकार String.Index हैं और एक Range<String.Index> बनाने के लिए उपयोग किया जाता है और सबस्क्रिप्ट Range<String.Index> में उपयोग किया जाता है (यदि कोई स्थान मूल स्ट्रिंग में बिल्कुल भी पाया जाता है)।

प्रारंभिक पोस्ट में उपयोग किए जाने वाले पूर्णांक की स्थिति से सीधे String.Index बनाना मुश्किल है। ऐसा इसलिए है क्योंकि मेरे नाम में प्रत्येक चरित्र बाइट्स में बराबर आकार का होगा। लेकिन अन्य भाषाओं में विशेष लहजे का उपयोग करने वाले वर्णों में कई बाइट्स का उपयोग किया जा सकता था (उपयोग किए गए एन्कोडिंग के आधार पर)। तो क्या बाइट को पूर्णांक का उल्लेख करना चाहिए?

विधियों succ और pred का उपयोग करते हुए मौजूदा String.Index से एक नया String.Index बनाना संभव है जो यह सुनिश्चित करेगा कि एन्कोडिंग में अगले कोड बिंदु पर जाने के लिए बाइट्स की सही संख्या छोड़ दी गई है। हालांकि इस मामले में अंत इंडेक्स को खोजने के लिए स्ट्रिंग में पहले स्थान के सूचकांक को खोजना आसान है।

चूंकि स्ट्रिंग NSString के लिए एक पुल प्रकार है, "पुरानी" विधियों को काम करना चाहिए, लेकिन यह स्पष्ट नहीं है कि कैसे – जैसे, यह काम नहीं करता है (वैध सिंटैक्स नहीं प्रतीत होता है):

  let x = str.substringWithRange(NSMakeRange(0, 3)) 

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

 // delete all spaces from Swift String stateName stateName = stateName.stringByReplacingOccurrencesOfString(" ", withString:"") 

लेकिन, जैसा कि अक्सर होता है, "मुझे अपना मोोजो वर्किन मिला, लेकिन यह सिर्फ आप पर काम नहीं करता है।" आप केवल दुर्लभ मामलों में से एक को चुनते हैं जहां स्विफ्ट पद्धति की समानांतर नाम की एक समानांतर मौजूद है , और इस मामले में, स्विफ्ट पद्धति के उद्देश्य-सी पद्धति को भारी पड़ती है। इस प्रकार, जब आप कहते हैं कि str.substringWithRange , स्विफ्ट सोचता है कि आपको NSString विधि की बजाय स्विफ्ट पद्धति का मतलब है – और फिर आपको रोक दिया गया है, क्योंकि स्विफ्ट पद्धति को एक Range<String.Index> उम्मीद है, और आपको नहीं पता कि कैसे बनाने के लिए उनमें से एक।

आसान तरीका यह है कि स्विफ्ट को इस तरह से छानने से रोकना है, स्पष्ट रूप से कास्ट करके:

 let x = (str as NSString).substringWithRange(NSMakeRange(0, 3)) 

ध्यान दें कि यहां कोई महत्वपूर्ण अतिरिक्त कार्य शामिल नहीं है। "कास्ट" का अर्थ "कन्वर्ट" नहीं है; स्ट्रिंग प्रभावी रूप से एक NSString है हम सिर्फ स्विफ्ट को बता रहे हैं कि इस वैरिएबल को कोड के इस एक लाइन के प्रयोजन के लिए कैसे देखें

इस पूरी चीज़ का सचमुच अजीब हिस्सा है कि स्विफ्ट पद्धति, जो कि यह सब परेशानी का कारण बनती है, वह बिना दस्तावेज है। मुझे पता नहीं है कि यह कहां है; यह NSString हेडर में नहीं है और यह स्विफ्ट हेडर में भी नहीं है

संक्षेप में उत्तर यह है कि स्विफ्ट में यह वास्तव में कठिन है मेरा कूड़ा यह है कि एप्पल के इस तरह की चीजों के लिए सुविधा के तरीकों पर काम करने के लिए अभी भी काम का एक गुच्छा है।

String.substringWithRange() एक Range<String.Index> पैरामीटर की अपेक्षा कर रहा है, और जहाँ तक मैं बता सकता हूं कि String.Index प्रकार के लिए कोई जनरेटर विधि नहीं है। आप aString.startIndex वापस aString.startIndex और aString.endIndex मान सकते हैं और aString.endIndex .succ() या .pred() कॉल कर सकते हैं, लेकिन यह पागलपन है

कैसे स्ट्रिंग वर्ग पर एक विस्तार के बारे में है जो अच्छे पुराने Int एस लेता है?

 extension String { subscript (r: Range<Int>) -> String { get { let subStart = advance(self.startIndex, r.startIndex, self.endIndex) let subEnd = advance(subStart, r.endIndex - r.startIndex, self.endIndex) return self.substringWithRange(Range(start: subStart, end: subEnd)) } } func substring(from: Int) -> String { let end = countElements(self) return self[from..<end] } func substring(from: Int, length: Int) -> String { let end = from + length return self[from..<end] } } let mobyDick = "Call me Ishmael." println(mobyDick[8...14]) // Ishmael let dogString = "This 🐶's name is Patch." println(dogString[5..<6]) // 🐶 println(dogString[5...5]) // 🐶 println(dogString.substring(5)) // 🐶's name is Patch. println(dogString.substring(5, length: 1)) // 🐶 

अद्यतन: स्विफ्ट बीटा 4 नीचे दिए गए मुद्दों को हल करता है!

चूंकि यह [बीटा 3 और पहले] में है, यहां तक ​​कि स्विफ्ट-नेटिव स्ट्रिंग में यूनिकोड वर्णों को संभालने में कुछ समस्याएं हैं। कुत्ते के ऊपर काम किया, लेकिन निम्नलिखित नहीं है:

 let harderString = "1:1️⃣" for character in harderString { println(character) } 

आउटपुट:

 1 : 1 ️ ⃣ 

नए Xcode 7.0 उपयोग में

 //: Playground - noun: a place where people can play import UIKit var name = "How do you use String.substringWithRange?" let range = name.startIndex.advancedBy(0)..<name.startIndex.advancedBy(10) name.substringWithRange(range) //OUT: 

यहां छवि विवरण दर्ज करें

आप इस एक्सटेंशन का उपयोग substringWithRange बढ़ाने के लिए कर सकते हैं

स्विफ्ट 2.3

 extension String { func substringWithRange(start: Int, end: Int) -> String { if (start < 0 || start > self.characters.count) { print("start index \(start) out of bounds") return "" } else if end < 0 || end > self.characters.count { print("end index \(end) out of bounds") return "" } let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(end)) return self.substringWithRange(range) } func substringWithRange(start: Int, location: Int) -> String { if (start < 0 || start > self.characters.count) { print("start index \(start) out of bounds") return "" } else if location < 0 || start + location > self.characters.count { print("end index \(start + location) out of bounds") return "" } let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(start + location)) return self.substringWithRange(range) } } 

स्विफ्ट 3

 extension String { func substring(start: Int, end: Int) -> String { if (start < 0 || start > self.characters.count) { print("start index \(start) out of bounds") return "" } else if end < 0 || end > self.characters.count { print("end index \(end) out of bounds") return "" } let startIndex = self.characters.index(self.startIndex, offsetBy: start) let endIndex = self.characters.index(self.startIndex, offsetBy: end) let range = startIndex..<endIndex return self.substring(with: range) } func substring(start: Int, location: Int) -> String { if (start < 0 || start > self.characters.count) { print("start index \(start) out of bounds") return "" } else if location < 0 || start + location > self.characters.count { print("end index \(start + location) out of bounds") return "" } let startIndex = self.characters.index(self.startIndex, offsetBy: start) let endIndex = self.characters.index(self.startIndex, offsetBy: start + location) let range = startIndex..<endIndex return self.substring(with: range) } } 

उपयोग:

 let str = "Hello, playground" let substring1 = str.substringWithRange(0, end: 5) //Hello let substring2 = str.substringWithRange(7, location: 10) //playground 

स्विफ्ट 2.0 में सबस्ट्रिंग कैसे प्राप्त करें का नमूना कोड

(i) सूचकांक शुरू करने से सबस्ट्रिंग

इनपुट: –

 var str = "Swift is very powerful language!" print(str) str = str.substringToIndex(str.startIndex.advancedBy(5)) print(str) 

आउटपुट: –

 Swift is very powerful language! Swift 

(ii) विशेष सूचकांक से सबस्ट्रिंग

इनपुट: –

 var str = "Swift is very powerful language!" print(str) str = str.substringFromIndex(str.startIndex.advancedBy(6)).substringToIndex(str.startIndex.advancedBy(2)) print(str) 

आउटपुट: –

 Swift is very powerful language! is 

मुझे आशा है कि यह आपकी मदद करेगा!

छोटे कोड के साथ आसान समाधान

एक ऐसा एक्सटेंशन बनाएं जिसमें बुनियादी उप-स्ट्रिंगिंग शामिल है जो लगभग सभी अन्य भाषाओं में है:

 extension String { func subString(start: Int, end: Int) -> String { let startIndex = self.index(self.startIndex, offsetBy: start) let endIndex = self.index(startIndex, offsetBy: end) let finalString = self.substring(from: startIndex) return finalString.substring(to: endIndex) } } 

बस इस के साथ फोन करें

 someString.subString(start: 0, end: 6) 

यह मेरे खेल के मैदान में काम करता है 🙂

 String(seq: Array(str)[2...4]) 

Xcode के लिए अपडेट किया गया 7. स्ट्रिंग विस्तार जोड़ता है:

उपयोग:

 var chuck: String = "Hello Chuck Norris" chuck[6...11] // => Chuck 

कार्यान्वयन:

 extension String { /** Subscript to allow for quick String substrings ["Hello"][0...1] = "He" */ subscript (r: Range<Int>) -> String { get { let start = self.startIndex.advancedBy(r.startIndex) let end = self.startIndex.advancedBy(r.endIndex - 1) return self.substringWithRange(start..<end) } } } 

खेल के मैदान में इस कोशिश करो

 var str:String = "Hello, playground" let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,8)) 

यह आपको "ello, p" देगा

हालांकि, जहां यह वास्तव में दिलचस्प हो जाता है, यदि आप खेल के मैदान में स्ट्रिंग से बड़ा पिछले इंडेक्स बनाते हैं तो यह स्ट्रिंग के बाद परिभाषित कोई स्ट्रिंग दिखाएगा: o

रेंज () एक जेनेरिक फ़ंक्शन है, ऐसा लगता है कि उसे उस प्रकार के बारे में पता होना चाहिए जिसमें वह काम कर रहा है।

आपको इसे खेल के मैदानों में रुचि रखने वाली वास्तविक स्ट्रिंग भी देना पड़ता है क्योंकि ऐसा लगता है कि अनुक्रम में सभी कड़ियों को एक दूसरे के बाद उनके चर नामों के साथ रखा जाता है।

इसलिए

 var str:String = "Hello, playground" var str2:String = "I'm the next string" let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,49)) 

देता है "ello, खेल का मैदान" मैं अगले स्ट्रिंग 2str2 ​​"

काम करता है भले ही str2 को परिभाषित किया जाता है

🙂

रोब नेपियर ने पहले से ही सबस्क्रिप्ट का उपयोग करके एक भयानक उत्तर दिया था लेकिन मुझे उसमें एक खामी महसूस हुई क्योंकि बाध्य परिस्थितियों के लिए कोई जांच नहीं है। इससे दुर्घटना हो सकती है इसलिए मैंने विस्तार को संशोधित किया और यहां यह है

 extension String { subscript (r: Range<Int>) -> String? { //Optional String as return value get { let stringCount = self.characters.count as Int //Check for out of boundary condition if (stringCount < r.endIndex) || (stringCount < r.startIndex){ return nil } let startIndex = self.startIndex.advancedBy(r.startIndex) let endIndex = self.startIndex.advancedBy(r.endIndex - r.startIndex) return self[Range(start: startIndex, end: endIndex)] } } } 

नीचे का उत्पादन

 var str2 = "Hello, World" var str3 = str2[0...5] //Hello, var str4 = str2[0..<5] //Hello var str5 = str2[0..<15] //nil 

तो मैं हमेशा इस बात का सुझाव देता हूं कि अगर चलो

 if let string = str[0...5] { //Manipulate your string safely } 

स्विफ्ट 3 में

पूर्व के लिए: एक चर "ड्यूक जेम्स थॉमस", हमें "जेम्स" प्राप्त करने की आवश्यकता है

 let name = "Duke James Thomas" let range: Range<String.Index> = name.range(of:"James")! let lastrange: Range<String.Index> = img.range(of:"Thomas")! var middlename = name[range.lowerBound..<lstrange.lowerBound] print (middlename) 

रोब नेपियर से एक पृष्ठ लेते हुए, मैंने इन सामान्य स्ट्रिंग एक्सटेंशन को विकसित किया, जिनमें से दो हैं:

 subscript (r: Range<Int>) -> String { get { let startIndex = advance(self.startIndex, r.startIndex) let endIndex = advance(self.startIndex, r.endIndex - 1) return self[Range(start: startIndex, end: endIndex)] } } func subString(startIndex: Int, length: Int) -> String { var start = advance(self.startIndex, startIndex) var end = advance(self.startIndex, startIndex + length) return self.substringWithRange(Range<String.Index>(start: start, end: end)) } 

उपयोग:

 "Awesome"[3...7] //"some" "Awesome".subString(3, length: 4) //"some" 

स्ट्रिंग से आपको एक सीमा मिलती है:

 var str = "Hello, playground" let startIndex = advance(str.startIndex, 1) let endIndex = advance(startIndex, 8) let range = startIndex..<endIndex let substr = str[range] //"ello, pl" 

मुख्य बिंदु यह है कि आप स्ट्रिंग.इंडेक्स के प्रकार के मानों को पारित कर रहे हैं (यह है कि अग्रिम रिटर्न) के बजाय इंटिजर्स

यह आवश्यक है कि इसका कारण यह है कि स्विफ्ट में तारों की यादृच्छिक पहुंच नहीं है (मूलतः यूनिकोड वर्णों की चर लंबाई के कारण)। तुम भी str[1] नहीं कर सकते String.Index को अपनी आंतरिक संरचना के साथ काम करने के लिए डिज़ाइन किया गया है।

आप हालांकि एक सबस्क्रिप्ट के साथ एक एक्सटेंशन बना सकते हैं, जो आपके लिए यह करता है, ताकि आप बस एक पूर्णांक संख्या को पार कर सकें (जैसे रोब नेपियर का जवाब देखें )

मैंने कुछ पायथनिक के साथ आने की कोशिश की

यहां सभी सब्स्क्रिप्स बहुत अच्छे होते हैं, लेकिन बार-बार मुझे कुछ सरलता की आवश्यकता होती है, आमतौर पर जब मैं वापस से गिनती करना चाहता हूं, जैसे string.endIndex.advancedBy(-1)

यह शुरुआत और समापन सूचकांक दोनों के लिए nil मानों का समर्थन करता है, जहां nil का मतलब प्रारंभ के लिए 0 पर सूचकांक होगा, अंत के लिए string.characters.count

 extension String { var subString: (Int?) -> (Int?) -> String { return { (start) in { (end) in let startIndex = start ?? 0 < 0 ? self.endIndex.advancedBy(start!) : self.startIndex.advancedBy(start ?? 0) let endIndex = end ?? self.characters.count < 0 ? self.endIndex.advancedBy(end!) : self.startIndex.advancedBy(end ?? self.characters.count) return startIndex > endIndex ? "" : self.substringWithRange(startIndex ..< endIndex) } } } } let dog = "Dog‼🐶" print(dog.subString(nil)(-1)) // Dog!! 

संपादित करें

एक और अधिक सुरुचिपूर्ण समाधान:

 public extension String { struct Substring { var start: Int? var string: String public subscript(end: Int?) -> String { let startIndex = start ?? 0 < 0 ? string.endIndex.advancedBy(start!) : string.startIndex.advancedBy(start ?? 0) let endIndex = end ?? string.characters.count < 0 ? string.endIndex.advancedBy(end!) : string.startIndex.advancedBy(end ?? string.characters.count) return startIndex > endIndex ? "" : string.substringWithRange(startIndex ..< endIndex) } } public subscript(start: Int?) -> Substring { return Substring(start: start, string: self) } } let dog = "Dog‼🐶" print(dog[nil][-1]) // Dog!! 

सबसे पहले रेंज बनाएं, फिर ऑथिस्ट्रिंग। आप fromIndex..<toIndex उपयोग कर सकते हैं fromIndex..<toIndex वाक्यविन्यास ऐसा है:

 let range = fullString.startIndex..<fullString.startIndex.advancedBy(15) // 15 first characters of the string let substring = fullString.substringWithRange(range) 

यहां पूरे यूआरएल से स्विफ्ट में वीडियो-आईडी केवल .ie (6oL687G0 भी) प्राप्त करने के लिए एक उदाहरण है।

 let str = "https://www.youtube.com/watch?v=6oL687G0Iso&list=PLKmzL8Ib1gsT-5LN3V2h2H14wyBZTyvVL&index=2" var arrSaprate = str.componentsSeparatedByString("v=") let start = arrSaprate[1] let rangeOfID = Range(start: start.startIndex,end:start.startIndex.advancedBy(11)) let substring = start[rangeOfID] print(substring) 
 let startIndex = text.startIndex var range = startIndex.advancedBy(1) ..< text.endIndex.advancedBy(-4) let substring = text.substringWithRange(range) 

पूर्ण नमूना आप यहाँ देख सकते हैं

http://www.learnswiftonline.com/reference-guides/string-reference-guide-for-swift/ दिखाता है कि यह अच्छी तरह से काम करता है:

 var str = "abcd" str = str.substringToIndex(1) 

ठीक है, मुझे एक ही समस्या थी और "पुलटो ऑब्जेक्टसी ()" फ़ंक्शन के साथ हल किया गया था:

 var helloworld = "Hello World!" var world = helloworld.bridgeToObjectiveC().substringWithRange(NSMakeRange(6,6)) println("\(world)") // should print World! 

कृपया ध्यान दें कि उदाहरण में, एनएसएमकेरेंज के साथ संयोजन के रूप में उप-स्थान बदलें सूचकांक 6 (वर्ण "डब्ल्यू") से शुरू होने वाले स्ट्रिंग का हिस्सा लेते हैं और 6 + 6 पदों पर आगे बढ़ते हैं (चरित्र "!")

चीयर्स।

आप किसी स्विफ्ट स्ट्रिंग एक्सटेंशन में किसी भी ऑथिस्ट्रिंग विधियों का उपयोग कर सकते हैं जो मैंने https://bit.ly/JString लिखा था।

 var string = "hello" var sub = string.substringFrom(3) // or string[3...5] println(sub)// "lo" 

यदि आपके पास एक NSRange , तो NSRange को पूरा करने के लिए NSString काम करता है NSString उदाहरण के लिए, मैं UITextFieldDelegate साथ कुछ काम कर रहा था और मैं जल्दी से नई स्ट्रिंग मान की गणना करना चाहता था जब पूछा गया कि क्या यह रेंज को बदलना चाहिए।

 func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool { let newString = (textField.text as NSString).stringByReplacingCharactersInRange(range, withString: string) println("Got new string: ", newString) } 

String लिए सरल एक्सटेंशन :

 extension String { func substringToIndex(index: Int) -> String { return self[startIndex...startIndex.advancedBy(min(index, characters.count - 1))] } } 

स्विफ्ट 3.0

मैंने इसके साथ थोड़ा मज़ेदार होने का निर्णय लिया और String पर एक एक्सटेंशन का निर्माण किया। हो सकता है कि मैं इस शब्द का इस्तेमाल ठीक से नहीं कर सकता कि मैं वास्तव में क्या कर रहा हूं।

 extension String { func truncate(from initialSpot: Int, withLengthOf endSpot: Int) -> String? { guard endSpot > initialSpot else { return nil } guard endSpot + initialSpot <= self.characters.count else { return nil } let truncated = String(self.characters.dropFirst(initialSpot)) let lastIndex = truncated.index(truncated.startIndex, offsetBy: endSpot) return truncated.substring(to: lastIndex) } } let favGameOfThronesSong = "Light of the Seven" let word = favGameOfThronesSong.truncate(from: 1, withLengthOf: 4) // "ight"