शून्य और खाली के लिए स्ट्रिंग की जाँच करें

Question

वहाँ के लिए तार की जांच करने के लिए एक रास्ता है nilऔर ""स्विफ्ट में? रेल में, मैं blank()जाँच करने के लिए उपयोग कर सकता हूँ ।

वर्तमान में मेरे पास यह है, लेकिन यह अधिक लगता है:

    if stringA? != nil {
        if !stringA!.isEmpty {
            ...blah blah
        }
    }

Comments

— Unwrap

(@ सूत्र और @ इमानौ-पेटिट) के उत्तर बेहतर हैं।

— श्री मिंग

Answer 1

यदि आप वैकल्पिक स्ट्रिंग्स के साथ काम कर रहे हैं, तो यह काम करता है:

(string ?? "").isEmpty

??शून्य वालों ऑपरेटर बाईं ओर वापस लौट आता है यह गैर शून्य है, अन्यथा यह सही पक्ष देता है।

डिफ़ॉल्ट मान वापस करने के लिए आप इसका उपयोग इस तरह भी कर सकते हैं:

(string ?? "").isEmpty ? "Default" : string!

Comments

सुरुचिपूर्ण ??? आपने मूल रूप से लिखा है "यदि स्ट्रिंग शून्य नहीं है तो रिक्त स्ट्रिंग और उस पर कॉल रिक्त है ... क्या एक तार्किक कथन है।

— रेनेटिक

Answer 2

आप शायद अगर-जहां-जहां क्लॉज का उपयोग कर सकते हैं:

स्विफ्ट 3:

if let string = string, !string.isEmpty {
    /* string is not blank */
}

स्विफ्ट 2:

if let string = string where !string.isEmpty {
    /* string is not blank */
}

Comments

स्विफ्ट 2 के साथ काम नहीं करता है, यह रन टाइम त्रुटि हो रही है fatal error: unexpectedly found nil while unwrapping an Optional valueलेकिन मेरे स्थिरांक stringमें एक स्ट्रिंग डेटा है।

— नागेन्द्र राव

स्विफ्ट 3 में यह काम करता है:if let string = string, !string.isEmpty { /* string is not blank */ }

— 20

@AmrLotfy guard letएक विकल्प है यदि आप कथन के नीचे नियंत्रण प्रवाह को समाप्त करना चाहते हैं। हालाँकि यहाँ क्लॉज़ में कुछ भी नहीं दिखाया जा रहा है (यह एक बूलियन नेगशन है)

— रयान

तो यह इस बारे में कैसे? स्ट्रिंग? स्ट्रिंग के बजाय .Empty = स्ट्रिंग कहाँ है? string.isEmpty

— पंकज

Answer 3

यदि आप स्विफ्ट 2 का उपयोग कर रहे हैं, तो यहां एक उदाहरण मेरे सहयोगी के साथ आया है, जो वैकल्पिक स्ट्रिंग्स पर isNilOrEmpty संपत्ति जोड़ता है:

protocol OptionalString {}
extension String: OptionalString {}

extension Optional where Wrapped: OptionalString {
    var isNilOrEmpty: Bool {
        return ((self as? String) ?? "").isEmpty
    }
}

फिर आप वैकल्पिक स्ट्रिंग पर ही NNOOEEpty का उपयोग कर सकते हैं

func testNilOrEmpty() {
    let nilString:String? = nil
    XCTAssertTrue(nilString.isNilOrEmpty)

    let emptyString:String? = ""
    XCTAssertTrue(emptyString.isNilOrEmpty)

    let someText:String? = "lorem"
    XCTAssertFalse(someText.isNilOrEmpty)
}

Comments

क्या आप स्पष्ट कर सकते हैं कि आपने यहां क्या किया या कुछ संसाधन जो इस बारे में विस्तार से बता सकते हैं। जैसे OptionalString क्यों घोषित किया जाता है? मुझे सिंटेक्स नहीं मिल रहा है। यह सामान्य विस्तार कार्यान्वयन की तरह नहीं है। बहुत पहले से धन्यवाद

— विनायक परमार

@VinayakParmar OptionalString यहां घोषित किया गया है क्योंकि where Wrapped:एक प्रोटोकॉल निर्दिष्ट करना चाहिए और एक प्रकार नहीं।

— एडम जॉन्स

हो सकता है आप नाम दे सकते हैं isNilOrEmptyकरने के लिए hasValue(या ऐसा ही कुछ) और तर्क रिवर्स

— इस्लाम प्र

Answer 4

guardकथन का उपयोग करना

guardकथन के बारे में जानने से पहले मैं थोड़ी देर के लिए स्विफ्ट का उपयोग कर रहा था । अब मैं बहुत बड़ा प्रशंसक हूं। यह ifकथन के समान उपयोग किया जाता है , लेकिन यह प्रारंभिक वापसी की अनुमति देता है और सामान्य रूप से बहुत क्लीनर कोड के लिए बनाता है।

यह सुनिश्चित करने के लिए कि जब कोई स्ट्रिंग न तो शून्य हो और न ही खाली हो, तो गार्ड का उपयोग करने के लिए, आप निम्नलिखित कार्य कर सकते हैं:

let myOptionalString: String? = nil

guard let myString = myOptionalString, !myString.isEmpty else {
    print("String is nil or empty.")
    return // or break, continue, throw
}

/// myString is neither nil nor empty (if this point is reached)
print(myString)

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

यह सभी देखें

• कथन प्रलेखन
• स्विफ्ट 2 में गार्ड स्टेटमेंट

Comments

सावधान रहे। प्रिंट (myString) नहीं चलेगा, अगर स्ट्रिंग शून्य या खाली है, क्योंकि गार्ड को दूसरे चरण में आने के बाद नीचे नहीं गिरने के लिए डिज़ाइन किया गया है।

— कांग बायुल

@ कांगब्युल, यह सही है और यहाँ तर्क का आशय है। संभवतः यदि स्ट्रिंग nilया खाली है, तो कोई कॉल नहीं करना चाहेगा print(myString)। यदि आपको एक nilया खाली होने के बाद निष्पादन जारी रखने की आवश्यकता है String, तो आप इसके if letबजाय उपयोग करेंगे guard।

— सुरगाछ

एक प्रशंसा के लिए धन्यवाद। मुझे पता है, मैं सिर्फ अन्य लोगों को बताता हूं जो न ही गार्ड के बारे में ज्यादा जानते हैं।

— कांग बायुल

@KangByul मैं अपने "सावधान रहना होगा" टिप्पणी की बात समझ में नहीं आता, मुझे लगता है कि यह एक बहुत अच्छा समाधान से बंद लोगों को डराता है, वापसी कथन सही गार्ड किसी और बयान में स्पष्ट रूप से है, मुझे लगता है कि आप अपनी टिप्पणी को हटाना चाहिए

— ब्रायन ओग्डेन

Answer 5

स्विफ्ट 5 के साथ, आप एक बूलियन संपत्ति के साथ टाइप के Optionalलिए एक एक्सटेंशन लागू कर सकते Stringहैं जो रिटर्न करता है यदि वैकल्पिक स्ट्रिंग का कोई मूल्य नहीं है या खाली है:

extension Optional where Wrapped == String {

    var isNilOrEmpty: Bool {
        return self?.isEmpty ?? true
    }

}

हालांकि, प्रोटोकॉल के अनुरूप संपत्ति को Stringलागू isEmptyकरता है Collection। इसलिए हम पिछले कोड के सामान्य बाधा (जगह ले सकता है Wrapped == Stringएक व्यापक एक (के साथ) Wrapped: Collection) ताकि Array, Dictionaryऔर Setभी हमारे नए लाभ isNilOrEmptyसंपत्ति:

extension Optional where Wrapped: Collection {

    var isNilOrEmpty: Bool {
        return self?.isEmpty ?? true
    }

}

---

उपयोग के साथ String:

let optionalString: String? = nil
print(optionalString.isNilOrEmpty) // prints: true

let optionalString: String? = ""
print(optionalString.isNilOrEmpty) // prints: true

let optionalString: String? = "Hello"
print(optionalString.isNilOrEmpty) // prints: false

उपयोग के साथ Array:

let optionalArray: Array<Int>? = nil
print(optionalArray.isNilOrEmpty) // prints: true

let optionalArray: Array<Int>? = []
print(optionalArray.isNilOrEmpty) // prints: true

let optionalArray: Array<Int>? = [10, 22, 3]
print(optionalArray.isNilOrEmpty) // prints: false

---

सूत्रों का कहना है:

• स्विफ्टबायसंडेल डॉट कॉम - स्विफ्ट में वैकल्पिक विस्तार
• objc.io - स्विफ्ट टिप: गैर-खाली संग्रह

Comments

मुझे यह पसंद है, मैं केवल एक ही मोड़ बनाऊंगा इसका नाम उपसर्ग से मिलान isNilOrEmptyकरने के isEmptyOrNilलिए है ताकि यह आसानी से स्वत: पूर्ण के लिए उसी पैटर्न के माध्यम से खोजा जा सके। मैंने उन सहयोगियों से इस विस्तार को अपनाने पर ध्यान दिया है, जिनके साथ मैं इस तरह से काम करता हूं।

— हारून

Answer 6

var str: String? = nil

if str?.isEmpty ?? true {
    print("str is nil or empty")
}

str = ""

if str?.isEmpty ?? true {
    print("str is nil or empty")
}

Comments

सुरुचिपूर्ण, लेकिन अजीब;), "सच्चा" थोड़े

— अंतर

Answer 7

मुझे पता है कि इस सवाल के बहुत सारे उत्तर हैं, लेकिन उनमें से कोई भी UITextFieldडेटा () मेरी राय में , डेटा को मान्य करने के लिए उतना सुविधाजनक नहीं लगता है , जो इसका उपयोग करने के लिए सबसे आम मामलों में से एक है:

extension Optional where Wrapped == String {
    var isNilOrEmpty: Bool {
        return self?.trimmingCharacters(in: .whitespaces).isEmpty ?? true
    }
}

आप बस उपयोग कर सकते हैं

textField.text.isNilOrEmpty

.trimmingCharacters(in:.whitespaces)यदि आप व्हॉट्सएप को एक रिक्त स्ट्रिंग के रूप में नहीं मानते हैं या इसे अधिक जटिल इनपुट परीक्षणों जैसे उपयोग करने के लिए भी छोड़ सकते हैं

var isValidInput: Bool {
    return !isNilOrEmpty && self!.trimmingCharacters(in: .whitespaces).characters.count >= MIN_CHARS
}

Comments

शानदार उत्तर, यदि व्हॉट्सएप को रिक्त स्थान के रूप में गिना जाता है, तो Op सटीक नहीं था, यहां मेरा संस्करण है: सार्वजनिक विस्तार वैकल्पिक जहां लिपटा हुआ == स्ट्रिंग {var isEmptyOrNil: बूल {वापसी (स्वयं ?? "") .isEmpty}}

— sachadso

Answer 8

मैं सलाह दूँगा।

if stringA.map(isEmpty) == false {
    println("blah blah")
}

mapवैकल्पिक होने पर फ़ंक्शन तर्क लागू करता है .Some।
खेल के मैदान पर कब्जा भी नई स्विफ्ट 1.2 के साथ एक और संभावना को दर्शाता है अगर वैकल्पिक बंधन दें।

Answer 9

यदि आप स्ट्रिंग को गैर-वैकल्पिक के रूप में एक्सेस करना चाहते हैं, तो आपको रयान के उत्तर का उपयोग करना चाहिए , लेकिन यदि आप केवल स्ट्रिंग के गैर-खालीपन की परवाह करते हैं, तो इसके लिए मेरा पसंदीदा आशुलिपि है।

if stringA?.isEmpty == false {
    ...blah blah
}

चूंकि ==वैकल्पिक बूलियन के साथ ठीक काम करता है, मुझे लगता है कि यह मूल इरादे को अस्पष्ट किए बिना कोड को पठनीय बनाता है।

यदि आप इसके विपरीत की जांच करना चाहते हैं: यदि स्ट्रिंग है nilया "", मैं सही इरादे दिखाने के लिए स्पष्ट रूप से दोनों मामलों की जांच करना पसंद करता हूं:

if stringA == nil || stringA?.isEmpty == true {
    ...blah blah
}

Comments

@ TruMan1 यह सही है, पहले उदाहरण का लक्ष्य यह जांचना है कि क्या स्ट्रिंग खाली नहीं है।

— एलेक्स प्रेट्ज़लाव

Answer 10

स्विफ्ट 3

extension Optional where Wrapped == String {

    /// Checks to see whether the optional string is nil or empty ("")
    public var isNilOrEmpty: Bool {
        if let text = self, !text.isEmpty { return false }
        return true
    }
}

वैकल्पिक स्ट्रिंग पर इस तरह का उपयोग करें:

if myString.isNilOrEmpty { print("Crap, how'd this happen?") } 

Answer 11

स्विफ्ट 3 चेक खाली खाली सबसे अच्छा तरीका है

if !string.isEmpty{

// do stuff

}

Answer 12

आप अपना खुद का कस्टम फंक्शन बना सकते हैं, अगर ऐसा कुछ है जो आप बहुत कुछ करने की उम्मीद करते हैं।

func isBlank (optionalString :String?) -> Bool {
    if let string = optionalString {
        return string.isEmpty
    } else {
        return true
    }
}



var optionalString :String? = nil

if isBlank(optionalString) {
    println("here")
}
else {
    println("there")
}

Answer 13

स्विफ्ट 3 समाधान वैकल्पिक अलिखित मूल्य का उपयोग करें और बूलियन के खिलाफ जांच करें।

if (string?.isempty == true) {
    // Perform action
}

Answer 14

का उपयोग कर रहा है

"Hello".isEmpty  // false
"".isEmpty       // true

AllSatisfy का उपयोग करना

extension String {
  var isBlank: Bool {
    return allSatisfy({ $0.isWhitespace })
  }
}

"Hello".isBlank        // false
"".isBlank             // true

वैकल्पिक स्ट्रिंग का उपयोग करना

extension Optional where Wrapped == String {
  var isBlank: Bool {
    return self?.isBlank ?? true
  }
}

var title: String? = nil
title.isBlank            // true
title = ""               
title.isBlank            // true

संदर्भ: https://useyourloaf.com/blog/empty-strings-in-swift/

Answer 15

स्ट्रिंग वर्ग एक्सटेंशन बनाएं:

extension String
{   //  returns false if passed string is nil or empty
    static func isNilOrEmpty(_ string:String?) -> Bool
    {   if  string == nil                   { return true }
        return string!.isEmpty
    }
}// extension: String

ध्यान दें कि यदि स्ट्रिंग में एक या अधिक रिक्तियाँ हैं तो यह TRUE लौटाएगा। रिक्त स्ट्रिंग को "खाली" मानने के लिए, उपयोग करें ...

return string!.trimmingCharacters(in: CharacterSet.whitespaces).isEmpty

... बजाय। इसके लिए फाउंडेशन की जरूरत है।

इस प्रकार इसका उपयोग करें ...

if String.isNilOrEmpty("hello world") == true 
{   print("it's a string!")
}

Answer 16

स्विफ्ट 3 यह जांचने के लिए अच्छी तरह से काम करता है कि क्या स्ट्रिंग वास्तव में खाली है। क्योंकि व्हॉट्सएप होने पर अमुक रिटर्न सही है।

extension String {
    func isEmptyAndContainsNoWhitespace() -> Bool {
        guard self.isEmpty, self.trimmingCharacters(in: .whitespaces).isEmpty
            else {
               return false
        }
        return true
    }
}

उदाहरण:

let myString = "My String"
myString.isEmptyAndContainsNoWhitespace() // returns false

let myString = ""
myString.isEmptyAndContainsNoWhitespace() // returns true

let myString = " "
myString.isEmptyAndContainsNoWhitespace() // returns false

Answer 17

आपको कुछ इस तरह करना चाहिए:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

यदि कोई वैकल्पिक नहीं है, तो निल सहवर्ती ऑपरेटर जाँच करता है कि यदि वह शून्य नहीं है, तो वह अपनी संपत्ति की जाँच करता है, इस मामले में वह खाली है। क्योंकि यह वैकल्पिक शून्य हो सकता है आप एक डिफ़ॉल्ट मान प्रदान करते हैं जो आपके वैकल्पिक शून्य होने पर उपयोग किया जाएगा।

Answer 18

यह Collectionप्रोटोकॉल के अनुरूप होने वाले सभी प्रकारों के लिए एक सामान्य समाधान है, जिसमें शामिल हैं String:

extension Optional where Wrapped: Collection {
    var isNilOrEmpty: Bool {
        self?.isEmpty ?? true
    }
}

Answer 19

जब स्थानीय db से सर्वर और इसके विपरीत से गुजरने वाले मूल्यों के साथ काम कर रहा हूं, तो मुझे बहुत परेशानी हो रही है? 'S! और क्या नहीं।

इसलिए मैंने null मामलों को संभालने के लिए एक Swift3.0 उपयोगिता बनाई और मैं कोड में लगभग पूरी तरह से बच सकता हूं?

func str(_ string: String?) -> String {
    return (string != nil ? string! : "")
}

उदाहरण के लिए: -

इससे पहले :

    let myDictionary: [String: String] = 
                      ["title": (dbObject?.title != nil ? dbObject?.title! : "")]

उपरांत :

    let myDictionary: [String: String] = 
                        ["title": str(dbObject.title)]

और जब इसकी वैध स्ट्रिंग की जाँच करना आवश्यक हो,

    if !str(dbObject.title).isEmpty {
        //do stuff
    }

यह मुझे जोड़ने और कई को हटाने की परेशानी से गुजरने से बचाया? 'कोड लिखने के बाद कि उचित समझ में आता है।

Answer 20

टर्नरी ऑपरेटर (सशर्त ऑपरेटर के रूप में भी जाना जाता है C++ forever!) का उपयोग करें:

if stringA != nil ? stringA!.isEmpty == false : false { /* ... */ }

stringA!बल-unwrapping केवल जब ऐसा होता है stringA != nil, तो यह सुरक्षित है। == falseशब्दाडंबर में अभी तक एक विस्मयादिबोधक चिह्न की तुलना में कुछ अधिक पठनीय है !(stringA!.isEmpty)।

मैं व्यक्तिगत रूप से थोड़ा अलग रूप पसंद करता हूं:

if stringA == nil ? false : stringA!.isEmpty == false { /* ... */ }

ऊपर दिए गए बयान में, यह तुरंत स्पष्ट है कि ifजब एक चर होता है तो पूरा ब्लॉक निष्पादित नहीं करता है nil।

Answer 21

UITextField से मान प्राप्त करते समय और nil& emptyस्ट्रिंग के लिए जाँच करने में सहायक

@IBOutlet weak var myTextField: UITextField!

अपने फ़ंक्शन (जब आप पर टैप करते हैं button) का उपयोग करता है जो UITextField से स्ट्रिंग प्राप्त करता है और कुछ अन्य सामान करता है

@IBAction func getStringFrom_myTextField(_ sender: Any) {

guard let string = myTextField.text, !(myTextField.text?.isEmpty)!  else { return }
    //use "string" to do your stuff.
}

इससे nilमूल्य के साथ-साथ देखभाल भी होगीempty स्ट्रिंग का ।

इसने मेरे लिए पूरी तरह से काम किया।

Answer 22

मेरी राय में, शून्य और खाली स्ट्रिंग की जांच करने का सबसे अच्छा तरीका स्ट्रिंग गिनती लेना है।

var nilString : String?
print(nilString.count) // count is nil

var emptyString = ""
print(emptyString.count) // count is 0

// combine both conditions for optional string variable
if string?.count == nil || string?.count == 0 {
   print("Your string is either empty or nil")
}

Answer 23

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

 class func stringIsNilOrEmpty(aString: String) -> Bool { return (aString).isEmpty }

Comments

एक स्विफ्ट उपयोगकर्ता नहीं; क्या आप बता सकते हैं कि अगर नील को पास किया गया तो यह अपवाद क्यों नहीं है?

— टेलीफोन

यह एक अपवाद नहीं फेंकता है क्योंकि आप nilइस फ़ंक्शन में बिलकुल नहीं छोड़ सकते हैं (objc को छोड़कर, जिस स्थिति में यह वास्तव में दुर्घटनाग्रस्त होगा)।

— अल्फोंसो

इस सवाल का जवाब नहीं है। यह शून्य के लिए जाँच नहीं करता है क्योंकि यह एक वैकल्पिक

— वेन एलरी