दिलचस्प पोस्ट
सर्वश्रेष्ठ सी ++ कोड फॉर्मेटर / श्वेतफ़ीयर संदर्भ: चर गुंजाइश क्या है, जहां से चर "अनपरिर्वरित चर" त्रुटियों और कहां से सुलभ हैं? क्या SPARQL में आरडीएफ संग्रह में एक तत्व की स्थिति प्राप्त करना संभव है? लेन () फ़ंक्शन की लागत पीडीओ को अंतिम आईडी डाला गया त्रुटि: (26, 0) Gradle DSL विधि नहीं मिली: 'रनप्रागार्ड ()' सीएसएस के साथ पीडीएफ के रूप में एक पूर्व तत्व सहेजें पीडीओ बाँध पाराम बनाम एंड्रॉइड: एप्लिकेशन-चौड़े फ़ॉन्ट-आकार वरीयता व्यावसायिक परत के लिए jsp स्प्रिंग सिक्योरिटी 3.एक्स को एक से अधिक एंट्री पॉइंट्स को कॉन्फ़िगर करना Django प्रोजेक्ट के लिए डायरेक्टरी संरचना का सर्वश्रेष्ठ अभ्यास आप बाल प्रक्रिया के लिए विशेषाधिकारों को कैसे हटा सकते हैं? Zlib का उपयोग करते हुए एक .zip फ़ाइल खोलने का आसान तरीका zlib.error: त्रुटि 3 जबकि विघटित करना: गलत हेडर चेक

मैं कैसे जांच करूं अगर स्ट्रिंग में स्विफ्ट में कोई अन्य स्ट्रिंग है?

Objective-C में NSString में एक सबस्ट्रिंग की जांच करने के लिए कोड है:

 NSString *string = @"hello Swift"; NSRange textRange =[string rangeOfString:@"Swift"]; if(textRange.location != NSNotFound) { NSLog(@"exists"); } 

लेकिन स्विफ्ट में मैं यह कैसे कर सकता हूं?

वेब के समाधान से एकत्रित समाधान "मैं कैसे जांच करूं अगर स्ट्रिंग में स्विफ्ट में कोई अन्य स्ट्रिंग है?"

स्विफ्ट के साथ आप एक ही कॉल कर सकते हैं:

स्विफ्ट 3.0+

 var string = "hello Swift" if string.range(of:"Swift") != nil { print("exists") } // alternative: not case sensitive if string.lowercased().range(of:"swift") != nil { print("exists") } 

पुराने स्विफ्ट

 var string = "hello Swift" if string.rangeOfString("Swift") != nil{ println("exists") } // alternative: not case sensitive if string.lowercaseString.rangeOfString("swift") != nil { println("exists") } 

मुझे उम्मीद है कि यह एक उपयोगी समाधान है क्योंकि मेरे सहित कुछ लोगों ने फोन करके स्ट्रिंग containsString() को लेकर कुछ अजीब समस्याओं का सामना किया है।

पुनश्च। import Foundation को import Foundation करना मत भूलना

विस्तार तरीका

स्विफ्ट 4

 extension String { func contains(find: String) -> Bool{ return self.range(of: find) != nil } func containsIgnoringCase(find: String) -> Bool{ return self.range(of: find, options: .caseInsensitive) != nil } } var value = "Hello world" print(value.contains("Hello")) // true print(value.contains("bo")) // false print(value.containsIgnoringCase(find: "hello")) // true print(value.containsIgnoringCase(find: "Hello")) // true print(value.containsIgnoringCase(find: "bo")) // false 

आमतौर पर स्विफ्ट 4 में आईओएस 8.0+ से उपलब्ध तरीक़ा है


स्विफ्ट 3.1

आप एक्सटेंशन contains: लिख सकते contains: और containsIgnoringCase String लिए String containsIgnoringCase है

 extension String { func contains(_ find: String) -> Bool{ return self.range(of: find) != nil } func containsIgnoringCase(_ find: String) -> Bool{ return self.range(of: find, options: .caseInsensitive) != nil } } 

पुराने स्विफ्ट संस्करण

 extension String { func contains(find: String) -> Bool{ return self.rangeOfString(find) != nil } func containsIgnoringCase(find: String) -> Bool{ return self.rangeOfString(find, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil } } 

उदाहरण:

 var value = "Hello world" print(value.contains("Hello")) // true print(value.contains("bo")) // false print(value.containsIgnoringCase("hello")) // true print(value.containsIgnoringCase("Hello")) // true print(value.containsIgnoringCase("bo")) // false 

डॉक्स से, ऐसा लगता है कि स्ट्रिंग पर कॉलिंग स्ट्रिंग containsString() को कार्य करना चाहिए:

स्विफ्ट का स्ट्रिंग प्रकार फाउंडेशन के एनएसएसटीरिंग क्लास के लिए सीमांकित है। यदि आप कोको या कोको टच में फाउंडेशन ढांचे के साथ काम कर रहे हैं, तो पूरे अध्याय NSString एपीआई आपके द्वारा निर्मित किसी भी स्ट्रिंग मूल्य पर कॉल करने के लिए उपलब्ध है, इस अध्याय में वर्णित स्ट्रिंग सुविधाओं के अतिरिक्त। आप किसी भी API के साथ एक स्ट्रिंग मान का उपयोग कर सकते हैं जिसके लिए NSString आवृत्ति की आवश्यकता होती है।

हालांकि, ऐसा लगता है कि इस तरह से काम नहीं करता है

यदि आप someString.containsString(anotherString) का उपयोग करने का प्रयास करते हैं, तो आपको एक संकलन समय त्रुटि मिलेगी जो बताता है कि 'String' does not contain a member named 'containsString'

इसलिए, आप कुछ विकल्पों के साथ छोड़े गए हैं, जिनमें से एक स्पष्ट रूप से अपने String को उद्देश्य-सी पुल को bridgeToObjectiveC() सी bridgeToObjectiveC() का उपयोग करके bridgeToObjectiveC() करना है जिसमें दो अन्य स्पष्ट रूप से bridgeToObjectiveC() का प्रयोग करते हैं और अंतिम एक में String को एक NSString

ब्रिजिंग करके, आपको प्राप्त होगा:

 var string = "hello Swift" if string.bridgeToObjectiveC().containsString("Swift") { println("YES") } 

स्पष्ट रूप से स्ट्रिंग को एक NSString रूप में टाइप करके, आप प्राप्त करेंगे:

 var string: NSString = "hello Swift" if string.containsString("Swift") { println("YES") } 

यदि आपके पास एक मौजूदा String , तो आप NSString (स्ट्रिंग 🙂 का उपयोग कर इसे से NSString आरंभ कर सकते हैं:

 var string = "hello Swift" if NSString(string: string).containsString("Swift") { println("YES") } 

और अंत में, आप नीचे एक मौजूदा String को एक NSString डाल सकते हैं

 var string = "hello Swift" if (string as NSString).containsString("Swift") { println("YES") } 

और एक। केस और डाइक्रिटिक विकल्प का समर्थन करता है

स्विफ्ट 3.0

 struct MyString { static func contains(_ text: String, substring: String, ignoreCase: Bool = true, ignoreDiacritic: Bool = true) -> Bool { var options = NSString.CompareOptions() if ignoreCase { _ = options.insert(NSString.CompareOptions.caseInsensitive) } if ignoreDiacritic { _ = options.insert(NSString.CompareOptions.diacriticInsensitive) } return text.range(of: substring, options: options) != nil } } 

प्रयोग

 MyString.contains("Niels Bohr", substring: "Bohr") // true 

आईओएस 9+

आईओएस 9 के बाद से केस और डाइरेक्टिक असंवेदनशील फ़ंक्शन उपलब्ध हैं

 if #available(iOS 9.0, *) { "Für Elise".localizedStandardContains("fur") // true } 

Xcode 7.1 और स्विफ्ट 2.1 के रूप में शामिल स्ट्रिंग containsString() मेरे लिए ठीक काम कर रहा है

 let string = "hello swift" if string.containsString("swift") { print("found swift") } 

स्विफ्ट 4:

 let string = "hello swift" if string.contains("swift") { print("found swift") } 

और एक मामले असंवेदनशील स्विफ्ट 4 उदाहरण:

 let string = "Hello Swift" if string.lowercased().contains("swift") { print("found swift") } 

या केस असंवेदनशील String विस्तार का उपयोग कर:

 extension String { func containsIgnoreCase(_ string: String) -> Bool { return self.lowercased().contains(string.lowercased()) } } let string = "Hello Swift" let stringToFind = "SWIFT" if string.containsIgnoreCase(stringToFind) { print("found: \(stringToFind)") // found: SWIFT } print("string: \(string)") print("stringToFind: \(stringToFind)") // console output: found: SWIFT string: Hello Swift stringToFind: SWIFT 

आप कोड का उपयोग करके स्विफ्ट में बहुत आसानी से यह कर सकते हैं:

 let string = "hello Swift"; let subString = (string as NSString).containsString("Swift") if(subString){println("Exist")} 

> स्विफ्ट 3.0 में

 let str = "Hello Swift" if str.lowercased().contains("Swift".lowercased()) { print("String Contains Another String") } else { print("Not Exists") } 

उत्पादन

 String Contains Another String 

स्विफ्ट 4.0 में

उपयोग

 func contains(_ str: String) -> Bool 

उदाहरण

 let string = "hello Swift" let containsSwift = string.contains("Swift") print(containsSwift) // prints true 

यहां सभी उत्तरों में से, मुझे लगता है कि वे या तो काम नहीं करते हैं, या वे कुछ हैक (NSString पर वापस कास्टिंग) यह बहुत संभावना है कि इसका सही उत्तर अलग बीटा रिलीज के साथ बदल गया है।

यहां मैं जो उपयोग करता हूं:

 let string: String = "hello Swift" if string.rangeOfString("Swift") != nil { println("exists") } 

"! = शून्य" बीटा 5 के साथ आवश्यक हो गया

स्विफ्ट खेल के मैदान में यह मेरी पहली चीख है मैं दो नए फ़ंक्शंस प्रदान करके स्ट्रिंग का विस्तार करता हूं (इसमें शामिल है और इसमें अज्ञातकैस)

 extension String { func contains(other: String) -> Bool{ var start = startIndex do{ var subString = self[Range(start: start++, end: endIndex)] if subString.hasPrefix(other){ return true } }while start != endIndex return false } func containsIgnoreCase(other: String) -> Bool{ var start = startIndex do{ var subString = self[Range(start: start++, end: endIndex)].lowercaseString if subString.hasPrefix(other.lowercaseString){ return true } }while start != endIndex return false } } 

इसे इस तरह प्रयोग करें

 var sentence = "This is a test sentence" sentence.contains("this") //returns false sentence.contains("This") //returns true sentence.containsIgnoreCase("this") //returns true "This is another test sentence".contains(" test ") //returns true 

मुझे किसी भी प्रतिक्रिया का स्वागत है 🙂

आप यहाँ हैं:

 let s = "hello Swift" if let textRange = s.rangeOfString("Swift") { NSLog("exists") } 

यहां उत्तर के लिए सिर्फ एक परिशिष्ट है।

आप एक स्थानीय केस असंवेदनशील परीक्षण भी कर सकते हैं:

  - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString 

उदाहरण:

  import Foundation var string: NSString = "hello Swift" if string.localizedCaseInsensitiveContainsString("Hello") { println("TRUE") } 

अद्यतन करें

यह आईओएस और मैक ओएस एक्स 10.10.x के फाउंडेशन फ्रेमवर्क का हिस्सा है और मेरे मूल पोस्टिंग के समय में 10.10 का हिस्सा था।

दस्तावेज़ जनरेट किया गया: 2014-06-05 12:26:27 -0700 ओएस एक्स रिलीज़ नोट्स कॉपीराइट © 2014 एपल इंक। सभी अधिकार सुरक्षित

ओएस एक्स 10.10 रिलीज नोट्स कोका फाउंडेशन फ्रेमवर्क

NSString में अब निम्नलिखित दो सुविधा विधियों हैं:

- (BOOL)containsString:(NSString *)str;

- (BOOL)localizedCaseInsensitiveContainsString:(NSString *)str;

इसके लिए आपको कोई कस्टम कोड लिखने की आवश्यकता नहीं है। 1.2 संस्करण से शुरू करें स्विफ्ट के पास पहले से ही सभी तरीकों की आवश्यकता है जो आपको चाहिए:

  • स्ट्रिंग की लंबाई प्राप्त करना: count(string) ;
  • जाँचकर कि स्ट्रिंग में उपस्ट्रिंग शामिल है: contains(string, substring) ;
  • जाँच कर रहा है कि स्ट्रिंग startsWith(string, substring) साथ शुरू होती है: startsWith(string, substring)
  • और आदि।

स्विफ्ट 3 में

 if((a.range(of: b!, options: String.CompareOptions.caseInsensitive, range: nil, locale: nil)) != nil){ print("Done") } 

हेयर यू गो! Xcode 8 और स्विफ्ट 3 के लिए तैयार

 import UIKit let mString = "This is a String that contains something to search." let stringToSearchUpperCase = "String" let stringToSearchLowerCase = "string" mString.contains(stringToSearchUpperCase) //true mString.contains(stringToSearchLowerCase) //false mString.lowercased().contains(stringToSearchUpperCase) //false mString.lowercased().contains(stringToSearchLowerCase) //true 

string.containsString केवल 10.10 Yosemite (और शायद आईओएस 8) में उपलब्ध है। इसके अलावा 10.9 में ऑब्जेक्टिव सी में दुर्घटनाओं को तोड़ दिया। आप NSString को NSCFString को पास करने का प्रयास कर रहे हैं मुझे अंतर नहीं पता, लेकिन जब मैं ओएस एक्स 10.9 एप में इस कोड को कार्यान्वित करता हूं, तो मैं 10.9 बैरफ कह सकता हूँ।

10.9 और 10.10 के साथ स्विफ्ट में अंतर यहां दिए गए हैं: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html इसमें स्ट्रिंग केवल 10.10 में उपलब्ध है

ऊपर स्ट्रिंग की रेंज 10.9 पर महान काम करता है। मुझे 10.9 पर विकसित हो रहा है। Xcode बीटा 2 के साथ सुपर स्थिर है। मैं खेल के मैदानों के माध्यम से या खेल के मैदानों के कमांड लाइन संस्करण का उपयोग नहीं करता हूं। मुझे पता चल रहा है कि उचित ढांचा आयात किए जाने पर स्वत: पूर्ण बहुत उपयोगी है

Xcode 8 / स्विफ्ट 3 संस्करण:

 let string = "hello Swift" if let range = string.range(of: "Swift") { print("exists at range \(range)") } else { print("does not exist") } if let lowercaseRange = string.lowercased().range(of: "swift") { print("exists at range \(lowercaseRange)") } else { print("does not exist") } 

आप इसका उपयोग भी कर सकते contains :

 string.contains("swift") // false string.contains("Swift") // true 

जांचें कि इसमें 'हैलो' है

 let s = "Hello World" if s.rangeOfString("Hello") != nil { print("Yes it contains 'Hello'") } 
 // Search string exist in employee name finding. var empName:NSString! = employeeDetails[filterKeyString] as NSString Case sensitve search. let rangeOfSearchString:NSRange! = empName.rangeOfString(searchString, options: NSStringCompareOptions.CaseInsensitiveSearch) // Not found. if rangeOfSearchString.location != Foundation.NSNotFound { // search string not found in employee name. } // Found else { // search string found in employee name. } 

IOS 8 और नए में, आप इन दो NSString विधियों का उपयोग कर सकते हैं:

 @availability(iOS, introduced=8.0) func containsString(aString: String) -> Bool @availability(iOS, introduced=8.0) func localizedCaseInsensitiveContainsString(aString: String) -> Bool 

मुझे दिलचस्प उपयोग के कुछ मामलों में पाया गया है ये वेरिएंट ओफ़स्ट्रिंग पद्धति का उपयोग करते हैं और मैं यह दिखाने के लिए समानता उदाहरण शामिल करता हूं कि स्विफ्ट 2.0 में स्ट्रिंग की खोज और तुलनात्मक सुविधाओं का सबसे अच्छा इस्तेमाल कैसे हो सकता है।

 //In viewDidLoad() I assign the current object description (A Swift String) to self.loadedObjectDescription self.loadedObjectDescription = self.myObject!.description 

बाद में मैंने स्वयं को बदल दिया है। MyObject, मैं निम्नलिखित स्ट्रिंग की तुलना रूटीन (आलसी चर के रूप में सेटअप जो Bool लौटाता है) के रूप में देख सकते हैं। यह किसी को किसी भी समय राज्य को देखने की अनुमति देता है।

 lazy var objectHasChanges : Bool = { guard self.myObject != nil else { return false } return !(self.loadedObjectDescription == self.myObject!.description) }() 

इसका एक रूप तब होता है जब कभी-कभी मुझे उस ऑब्जेक्ट पर लापता संपत्ति का विश्लेषण करने की आवश्यकता होती है। एक स्ट्रिंग खोज मुझे किसी विशेष सबस्ट्रिंग को शून्य पर सेट करने की अनुमति देता है (डिफ़ॉल्ट जब ऑब्जेक्ट बनाया जाता है)।

  lazy var isMissingProperty : Bool = { guard self.myObject != nil else { return true } let emptyPropertyValue = "myProperty = nil" return (self.myObject!.description.rangeOfString(emptyPropertyValue) != nil) ? true : false }() 

स्विफ्ट 3: यहां आप मेरा स्मार्ट खोज एक्सटेंशन fro स्ट्रिंग देख सकते हैं जो आपको स्ट्रिंग पर खोज करने के लिए, यदि यह है, या खोज टेक्स्ट के आधार पर संग्रह को फ़िल्टर करने के लिए खोज कर सकते हैं।

https://github.com/magonicolas/Swift-Smart-String-Search

आपने जो कुछ भी उल्लेख किया है, वह कर सकते हैं:

 import Foundation ... string.containsString("Swift"); 

डॉक्स से:

स्विफ्ट का String प्रकार फाउंडेशन के NSString क्लास के लिए NSString । यदि आप कोको या कोको टच में फाउंडेशन ढांचे के साथ काम कर रहे हैं, तो पूरे अध्याय NSString एपीआई आपके द्वारा NSString किसी भी String मूल्य पर कॉल करने के लिए उपलब्ध है, इस अध्याय में वर्णित स्ट्रिंग सुविधाओं के अतिरिक्त। आप किसी भी API के साथ एक स्ट्रिंग मान का उपयोग कर सकते हैं जिसके लिए NSString आवृत्ति की आवश्यकता होती है।

आपको NSString तरीकों को पुल करने के लिए import Foundation को import Foundation करना होगा और उन्हें स्विफ्ट स्ट्रिंग क्लास के लिए उपलब्ध कराना होगा।