road - swift vxi




स्विफ्ट में स्ट्रिंग में एक और स्ट्रिंग है या नहीं, तो मैं कैसे जांचूं? (16)

विस्तार रास्ता

स्विफ्ट 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 contains विधि होती है हालांकि यह आईओएस 8.0+ से उपलब्ध है

स्विफ्ट 3.1

आप एक्सटेंशन लिख सकते contains: और 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

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

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

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


स्विफ्ट 4.0 में

उपयोग

func contains(_ str: String) -> Bool

उदाहरण

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

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

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

दस्तावेज़ों से:

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

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


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

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

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

स्विफ्ट 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 करने के लिए मत भूलना


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

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

एक्सकोड 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 भी उपयोग कर सकते contains :

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

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

स्विफ्ट 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
}

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

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

हालांकि, ऐसा लगता है कि ऐसा नहीं लगता है।

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

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

ब्रिजिंग करके, आपको मिल जाएगा:

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

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

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

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

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")
}

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

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

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

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
    }()

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

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 string: String = "hello Swift"
if string.rangeOfString("Swift") != nil
{
    println("exists")
}

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


स्विफ्ट 3 में

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

हेयर यू गो! एक्सकोड 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

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

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


// 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.
}




swift