मैं कैसे जांच करूं कि एक स्ट्रिंग में स्विफ्ट में एक और स्ट्रिंग है?

Question

Objective-Cकोड में एक विकल्प के लिए जाँच करने के लिए NSStringहै:

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

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

Comments

@rckoenes मैं नया हूँ स्विफ्ट करने के लिए, मुझे पता है कि यह उद्देश्य कैसे करना है

— Rajneesh071

तो फिर तुम सिर्फ खेल का मैदान क्यों नहीं शुरू करते और इसे आजमाते हो।

— rckoenes

यदि आप अभी भी आस-पास हैं, तो कृपया उपयोगकर्ता के लिए स्वीकार किए गए उत्तर को बदल दें। user1021430 ... यह सही है

— Dan Rosenstark

Answer 1

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

स्विफ्ट 4 और स्विफ्ट 5

स्विफ्ट 4 स्ट्रिंग में Characterमूल्यों का एक संग्रह है , यह स्विफ्ट 2 और 3 में ऐसा नहीं था, इसलिए आप इस अधिक संक्षिप्त कोड ^{1 का} उपयोग कर सकते हैं :

let string = "hello Swift"
if string.contains("Swift") {
    print("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

फुटनोट

1. बस याद रखें कि स्ट्रिंग्स पर संग्रह कार्यों का उपयोग करने से कुछ किनारे मामले होते हैं जो आपको अप्रत्याशित परिणाम दे सकते हैं, उदाहरण के लिए जब एमोजिस या अन्य अंगूर के समूहों जैसे उच्चारण पत्रों के साथ काम करते हैं।

Comments

Apple का प्रलेखन कहता है: An NSRange structure giving the location and length in the receiver of the first occurrence of aString. Returns {NSNotFound, 0} if aString is not found or is empty (@"").तो शायद nilठीक से काम नहीं करेगा।

— एलेक्स

string.lowercaseString.rangeOfString ("स्विफ्ट") स्थान। = NSNotFound। कृपया दस्तावेज़ पढ़ें .. आपको एक शून्य ऑब्जेक्ट वापस नहीं मिलेगा।

— theCodingArt

@ TheGamingArt हां आप करेंगे। स्विफ्ट राउंड-ट्रिप आपके लिए पूरी तरह से स्वचालित रूप से चलती है ताकि यदि NSRange है तो {NSNotFound, 0}यह आपके लिए शून्य के रूप में दर्शाया जाए। यदि यह एक वास्तविक सीमा है, तो यह आपके लिए एक स्विफ्ट रेंज (वैकल्पिक) के रूप में दर्शाया गया है। ठंडा।

— मैट

Grr। इसमें शामिल है, डॉक्स में नहीं है, यहां तक ​​कि Xcode 6.3.1 के रूप में भी।

— डंकन सी

@TheGoonie: यह बुला नहीं है NSString'एस .rangeOfString()। यह बुला रहा है Stringकी .rangeOfString(), जो के रूप में घोषित किया जाता हैfunc rangeOfString(aString: String, options mask: NSStringCompareOptions = default, range searchRange: Range<Index>? = default, locale: NSLocale? = default) -> Range<Index>?

— newacct

Answer 2

एक्सटेंशन का तरीका

स्विफ्ट 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 में विधि होती है लेकिन यह iOS 8.0+ से उपलब्ध है

---

स्विफ्ट 3.1

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

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

Comments

मामले को अनदेखा करने के लिए रिटर्न स्व.ऑर्गऑनस्ट्रीमिंग का उपयोग करें (खोजें, विकल्प: NSStringCompareOptions.CaseInsensitiveSearch)! = nil

— masgar

जब तक आपके पास नहीं है, तब तक आवश्यक नहीं है Foundation... containsStringठीक काम करता है।

— दान रोसेनस्टार्क

तेजी से 3.0 के लिए। नीचे बदलें: स्ट्रिंग {func में शामिल है (ढूंढें: स्ट्रिंग) -> बूल {वापसी सेल्फ। अरेंज (ऑफ: फाइंड)! = नील} फंक में इग्नोरिंग कैस (खोज: स्ट्रिंग) -> बूल {रिटर्न सेल्फ। अरेंज: (खोजें) , विकल्प: .caseInsensitive)! = nil}}

— माइकल शांग

स्विफ्ट 4 के लिए -> एक्सटेंशन स्ट्रिंग {फंक में होता है (ढूंढें: स्ट्रिंग) -> बूल {रिटर्न सेल्फ. अरेंज (ऑफ: फाइंड)! = एनआईएल} फंक में इग्नोरिंग कैस (खोज: स्ट्रिंग) -> बूल (सेल्फ अरेंज): खोजें, विकल्प: .caseInsensitive)! = nil}}

— shokaveli

Answer 3

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

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

हालाँकि, यह उस तरह से काम नहीं करता है।

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

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

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

Comments

अंतिम उदाहरण (मैंने दूसरों की कोशिश नहीं की है) मेरे लिए iOS 7 (डिवाइस) पर क्रैश करता है; स्विफ्ट ऐप्स को iOS 7 पर ठीक चलना चाहिए [__NSCFString containsString:]: unrecognized selector sent to instance। मुझे जो त्रुटि मिलती है । इसके अलावा, मैं containsStringदेव डॉक्स में इस विधि की पुष्टि नहीं कर सकता कि क्या यह iOS 8 के लिए नया है।

— जेसन लीच

दिलचस्प। मैंने केवल एक खेल के मैदान पर इसका परीक्षण किया। जब मैं अपने कंप्यूटर पर हूँ, तब मैं इसे एक कोशिश दूँगा।

— सीजर

तीसरे और चौथे विकल्प केवल वे ही हैं जिन्हें संकलक ने अनुमति दी है। दोनों iOS 4 में बीटा 4 में मेरे लिए दुर्घटनाग्रस्त।

— 5:00 पर palmi

Answer 4

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

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

iOS 9+

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

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

Answer 5

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

Comments

आप की जरूरत है import Foundation, अन्यथा यह काम नहीं करेगा।

— एंड्री चेर्नेंको

या तो import UIKitकी import Foundationआवश्यकता होती है, आईओएस 11 और स्विफ्ट 4. साथ कम से कम

— मरे Sagal

लेकिन यह मामला संवेदनशील है। आप मामले की अनदेखी करते हुए तुलना कैसे करते हैं। जैसे जावा String.equalsIgnoreCase (एक और स्ट्रिंग)?

— zulkarnain shah

@zulkarnainshah मैंने उत्तर में एक उदाहरण जोड़ा।

— मुरैना सागर

@MurraySagal Thats अभी भी असंवेदनशील खोज के मामले में नहीं हैं। आप मूल स्ट्रिंग को लोअरकेस में परिवर्तित कर रहे हैं और फिर उस की तुलना स्पष्ट रूप से कम केस स्ट्रिंग से कर रहे हैं। यह काम करेगा, लेकिन ऐसा करने का आदर्श तरीका नहीं है

— zulkarnain shah

Answer 6

स्विफ्ट में 4.2

उपयोग

func contains(_ str: String) -> Bool

उदाहरण

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

Comments

कृपया ध्यान दें कि इसके लिए आपको फाउंडेशन का आयात करना होगा।

— 3

Answer 7

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

Answer 8

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

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

Answer 9

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

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

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

उदाहरण:

    import Foundation

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

अपडेट करें

यह iOS और Mac OS X 10.10.x के लिए फाउंडेशन फ्रेमवर्क का हिस्सा है और मेरी मूल पोस्टिंग के समय 10.10 का हिस्सा था।

दस्तावेज़ उत्पन्न: 2014-06-05 12:26:27 -0700 OS X रिलीज़ नोट्स कॉपीराइट © 2014 Apple Inc. सर्वाधिकार सुरक्षित।

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

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

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

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

Comments

ध्यान रखें इस दृष्टिकोण को iOS 8 की आवश्यकता है।

— एंड्रयू एबलिंग

Answer 10

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

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

मैं किसी भी प्रतिक्रिया का स्वागत करता हूँ :)

Comments

अगला चरण: इसे एक सामान्य कार्य बनाएं जो सभी संग्रह के :-) पर काम करता है। 'इग्नोर केस' वेरिएंट में, केवल एक बार स्ट्रिंग्स को नीचे लाएँ (lc = other.lowercaseString do से पहले)

— hnh

Answer 11

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

यहाँ मेरा उपयोग है:

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

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

Answer 12

आप यहाँ हैं:

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

Comments

कुछ समय के लिए आपको एक संक्षिप्त रूप की आवश्यकता हो सकती है: निम्न श्रेणी दें :ExExists = string.rangeOfString ("स्विफ्ट") ?? गलत जो या तो एक बूलियन के रूप में गलत है, अगर वह निहित या NSRange अन्यथा नहीं है

— स्टीफन डे लुका

Answer 13

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

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

Comments

स्विफ्ट 2 समान नहीं है।

— सुरगाछ

स्विफ्ट 2 : string.hasPrefix ("शुरू")

— SwiftArchitect

Answer 14

स्विफ्ट 3 में

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

Answer 15

हेयर यू गो! 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

Answer 16

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

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

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

Answer 17

स्विफ्ट 4 में नए सिंटैक्स के साथ आप बस कर सकते हैं

string.contains("Swift 4 is the best")

स्ट्रिंग आपका स्ट्रिंग चर है

Answer 18

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

Answer 19

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

let s = "Hello World"

if s.rangeOfString("Hello") != nil {
    print("Yes it contains 'Hello'")
}

Answer 20

आवश्यक Foundation(या UIKit) फ्रेमवर्क आयात सहित, सबस्ट्रिंग की जांच करने के लिए 4 तरीका स्विफ्ट करें :

import Foundation // or UIKit

let str = "Oh Canada!"

str.contains("Can") // returns true

str.contains("can") // returns false

str.lowercased().contains("can") // case-insensitive, returns true

जब तक Foundation(या UIKit) फ्रेमवर्क आयात नहीं किया जाता है, str.contains("Can")एक संकलक त्रुटि देगा।

---

यह उत्तर मनोजोर्सेस के उत्तर को पुन: उत्पन्न कर रहा है, जो पूरी तरह से सही है। मैं क्यों इतने सारे जवाब से बनाने के लिए इतना मुसीबत के माध्यम से जाने पता नहीं है Foundationकी String.contains(subString: String)विधि।

Answer 21

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

Answer 22

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

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

Answer 23

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

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

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

Comments

क्या? ऐसा लगता है कि यह उपलब्ध नहीं है? संस्करण में जो xcode 6.1 के साथ आता है

— Ali

Answer 24

मुझे कुछ दिलचस्प उपयोग के मामले मिले हैं। ये वेरिएंट रेंजऑफस्ट्रिंग विधि का उपयोग करते हैं और मैं यह दिखाने के लिए समानता उदाहरण शामिल करता हूं कि स्विफ्ट 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
    }()

Answer 25

अगर आप जांचना चाहते हैं कि एक स्ट्रिंग में एक और सब-स्ट्रिंग है या नहीं, तो आप इसे इस तरह भी चेक कर सकते हैं,

var name = String()  
name = "John has two apples." 

अब, इस विशेष स्ट्रिंग में यदि आप जानना चाहते हैं कि इसमें फल का नाम 'सेब' है या नहीं, तो आप क्या कर सकते हैं,

if name.contains("apple")      
{  
print("Yes , it contains fruit name")    
}    
else      
{    
 print(it does not contain any fruit name)    
}    

उम्मीद है इससे आपका काम बनेगा।

Answer 26

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

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

डॉक्स से:

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

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

Comments

मुझे नहीं, लेकिन नहीं, यह नहीं है।

— सेज़र

हां। एक प्लेग्राउंड में, एक मैक ऐप और एक आईओएस ऐप में। इसके अलावा कोको, यूइकिट, फाउंडेशन और उन तीनों के सभी संभावित संयोजनों को कोको (यूकोइट को छोड़कर, जिसमें कोई मतलब नहीं है) को प्लेग्राउंड में आज़माया

— सेज़र

स्विफ्ट 1.2

— केल्विन लाउ

Answer 27

स्विफ्ट 4 बहुत आसान है !!

if (yourString.contains("anyThing")) {
   Print("Exist")
}

Comments

यह यहाँ के कई अन्य उत्तरों में से किस तरह अलग है?

— एशले मिल्स

$ swift Welcome to Apple Swift version 4.2 (swiftlang-1000.11.37.1 clang-1000.11.45.1). Type :help for assistance. 1> print ("Ping") Ping 2> Print ("Ping") error: repl.swift:2:1: error: use of unresolved identifier 'Print' Print ("Ping") ^~~~~ एक अप्रयुक्त उत्तर प्रदान करके जो काम नहीं करता है। प्रिंट! = प्रिंट।

— फ्रेड गनेट