wake-up-neo.net

Überprüfen Sie die Zeichenfolge auf Null und leer

Gibt es eine Möglichkeit, Zeichenfolgen in Swift auf nil und "" zu überprüfen? In Rails kann ich blank() zum Überprüfen verwenden. 

Ich habe derzeit das, aber es scheint übertrieben zu sein:

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

Wenn Sie mit optionalen Strings arbeiten, funktioniert das:

(string ?? "").isEmpty

Der ?? nil-Koaleszenzoperator gibt die linke Seite zurück, wenn er nicht null ist, andernfalls die rechte Seite.

Sie können es auch so verwenden, um einen Standardwert zurückzugeben:

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

Sie könnten vielleicht die if-let-where-Klausel verwenden:

Swift 3:

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

Swift 2:

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

Wenn Sie Swift 2 verwenden, finden Sie hier ein Beispiel, das mein Kollege entworfen hat und fügt die Eigenschaft isNilOrEmpty zu optionalen Strings hinzu:

protocol OptionalString {}
extension String: OptionalString {}

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

Sie können dann isNilOrEmpty für die optionale Zeichenfolge selbst verwenden

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

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

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

Verwendung der Anweisung guard

Ich habe Swift eine Weile benutzt, bevor ich von der guard -Anweisung erfuhr. Jetzt bin ich ein großer Fan. Sie wird ähnlich wie die Anweisung if verwendet, ermöglicht jedoch eine frühzeitige Rückgabe und sorgt im Allgemeinen für viel saubereren Code. 

Um Guard zu verwenden, um zu überprüfen, ob eine Zeichenfolge weder leer noch leer ist, können Sie Folgendes tun:

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)

Dies entpackt die optionale Zeichenfolge und prüft, dass sie nicht alle gleichzeitig leer ist. Wenn es null ist (oder leer ist), kehren Sie sofort von Ihrer Funktion (oder Schleife) zurück und alles, was danach passiert, wird ignoriert. Wenn die Guard-Anweisung jedoch erfolgreich ist, können Sie Ihre unverpackte Zeichenfolge sicher verwenden. 

Siehe auch

21
Suragch
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")
}
10
Sutra

Ich weiß, dass es viele Antworten auf diese Frage gibt, aber keine davon scheint (meiner Meinung nach) zur Überprüfung von UITextField-Daten geeignet zu sein.

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

Sie können einfach verwenden 

textField.text.isNilOrEmpty

Sie können .trimmingCharacters(in:.whitespaces) auch überspringen, wenn Sie Whitespaces nicht als leeren String betrachten oder für komplexere Eingabetests verwenden möchten 

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

Ich würde empfehlen.

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

map wendet das Funktionsargument an, wenn die Option .Some ist.
Das Spielplatz-Capture zeigt mit dem neuen Swift 1.2 auch eine andere Möglichkeit, wenn die Bindung optional ist.

enter image description here

7
Price Ringo

Wenn Sie auf den String als nicht optionales Element zugreifen möchten, sollten Sie Ryans Answer verwenden. Wenn Sie jedoch nur auf die Nicht-Leere des Strings achten, ist dies meine bevorzugte Abkürzung

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

Da == mit optionalen Booleans gut funktioniert, denke ich, dass der Code lesbar bleibt, ohne die ursprüngliche Absicht zu beeinträchtigen.

Wenn Sie das Gegenteil überprüfen möchten: Wenn die Zeichenfolge nil oder "" ist, ziehe ich es vor, beide Fälle explizit zu überprüfen, um die richtige Absicht anzuzeigen:

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

Sie können Ihre eigene benutzerdefinierte Funktion erstellen, wenn Sie damit viel tun.

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

Swift-3-Lösung Verwenden Sie den optionalen unverpackten Wert, und prüfen Sie den booleschen Wert.

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

Swift 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
    }
}

Verwenden Sie diese Option für optionale Zeichenfolgen:

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

Swift 3 Zur Überprüfung der Methode Empty String

if !string.isEmpty{

// do stuff

}
2
Anas

Swift 3. Dies funktioniert gut, um zu überprüfen, ob die Zeichenfolge wirklich leer ist. Weil isEmpty true zurückgibt, wenn ein Leerzeichen vorhanden ist.

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

Beispiele:

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

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

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

Sie sollten so etwas tun:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

Der Null-Koaleszenz-Operator prüft, ob die Option nicht null ist. Ist sie nicht null, prüft er ihre Eigenschaft. In diesem Fall ist sie leer. Da dieses optionale Attribut null sein kann, geben Sie einen Standardwert an, der verwendet wird, wenn Ihr optionales Attribut null ist.

1
Dominik Babić

Erstellen Sie eine String-Klassenerweiterung:

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

Beachten Sie, dass dies TRUE zurückgibt, wenn die Zeichenfolge ein oder mehrere Leerzeichen enthält. Um leere Zeichenfolgen als "leer" zu behandeln, verwenden Sie ... 

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

... stattdessen. Dies erfordert eine Grundlage.

Verwenden Sie es also ...

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

Mit Swift 4.2 können Sie eine Optional-Erweiterung für den String-Typ mit einer booleschen Eigenschaft implementieren, die zurückgibt, wenn eine optionale Zeichenfolge keinen Wert hat oder leer ist:

extension Optional where Wrapped == String {

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

}

String implementiert jedoch die isEmpty-Eigenschaft durch Konformität mit dem Protokoll Collection. Daher können wir die generische Einschränkung des vorherigen Codes (Wrapped == String) durch eine breitere Einschränkung (Wrapped: Collection) ersetzen, sodass Array, Dictionary und Set auch unserer neuen isNilOrEmpty-Eigenschaft zugute kommen:

extension Optional where Wrapped: Collection {

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

}

Verwendung mit Strings:

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

Verwendung mit Arrays:

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

Quellen:

1
Imanou Petit

Dies ist eine allgemeine Lösung für alle Typen, die dem Protokoll Collection entsprechen, einschließlich String:

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

Verwenden von isEmpty

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

Verwenden von allSatisfy

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

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

Verwenden einer optionalen Zeichenfolge

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

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

Referenz: https://useyourloaf.com/blog/empty-strings-in-Swift/

0
raaz

Verwenden Sie den ternären Operator (auch als bedingter Operator C++ forever! bezeichnet):

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

Das stringA!-Force-Unwrapping geschieht nur, wenn stringA != nil, also sicher ist. Die == false-Ausführlichkeit ist etwas lesbarer als ein weiteres Ausrufezeichen in !(stringA!.isEmpty).

Ich persönlich bevorzuge eine etwas andere Form:

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

In der obigen Anweisung ist sofort klar, dass der gesamte if-Block nicht ausgeführt wird, wenn eine Variable nil ist.

0
Gary

Bei der Weitergabe von Werten von der lokalen Datenbank an den Server und umgekehrt hatte ich zu viele Probleme mit den Zeichen? Und? Und was nicht.

Also habe ich ein Swift3.0-Dienstprogramm erstellt, um Nullfälle zu behandeln, und ich kann die? Und? Im Code fast vollständig vermeiden.

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

Ex:-

Vor :

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

Nach dem :

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

und wenn es erforderlich ist, nach einer gültigen Zeichenfolge zu suchen,

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

Dies ersparte mir die Mühe, zahlreiche? Und? Nach dem Schreiben von Code, der vernünftigerweise Sinn macht, hinzuzufügen und zu entfernen.

0
Nikhil Mathew

hilfreich, wenn Wert aus UITextField abgerufen wird und nach nil & empty string gesucht wird

@IBOutlet weak var myTextField: UITextField!

Hier ist Ihre Funktion (wenn Sie auf eine Variable button tippen), die eine Zeichenfolge von UITextField abruft und andere Aufgaben ausführt

@IBAction func getStringFrom_myTextField(_ sender: Any) {

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

Dadurch werden sowohl der nil-Wert als auch die empty-Zeichenfolge berücksichtigt.

Es hat perfekt für mich funktioniert.

0
Soropromo