C'è un modo per controllare le stringhe per nile ""in Swift? In Rails, posso usare blank()per controllare.

Al momento ho questo, ma sembra eccessivo:

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

Se hai a che fare con stringhe opzionali, funziona:

(string ?? "").isEmpty

L' ??operatore di coalescenza zero restituisce il lato sinistro se è diverso da zero, altrimenti restituisce il lato destro.

Puoi anche usarlo in questo modo per restituire un valore predefinito:

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

Potresti forse usare la clausola if-let-where:

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

Se stai usando Swift 2, ecco un esempio del mio collega, che aggiunge la proprietà isNilOrEmpty su Stringhe opzionali:

protocol OptionalString {}
extension String: OptionalString {}

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

È quindi possibile utilizzare isNilOrEmpty sulla stringa opzionale stessa

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

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

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

Usando la guarddichiarazione

Stavo usando Swift per un po 'prima di conoscere la guarddichiarazione. Ora sono un grande fan. È usato in modo simile ifall'istruzione, ma consente un ritorno anticipato e rende il codice molto più pulito in generale.

Per usare guard quando si controlla per assicurarsi che una stringa non sia né nulla né vuota, è possibile effettuare le seguenti operazioni:

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)

In questo modo viene scartata la stringa facoltativa e viene verificato che non sia vuoto tutto in una volta. Se è zero (o vuoto), ritorni immediatamente dalla tua funzione (o ciclo) e tutto ciò che viene ignorato. Ma se l'istruzione guard passa, allora puoi tranquillamente usare la tua stringa da scartare.

Guarda anche

• Documentazione delle dichiarazioni
• La dichiarazione della guardia in Swift 2

Con Swift 5, puoi implementare Optionalun'estensione per il Stringtipo con una proprietà booleana che ritorna se una stringa opzionale non ha valore o è vuota:

extension Optional where Wrapped == String {

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

}

Tuttavia, Stringimplementa la isEmptyproprietà conformandosi al protocollo Collection. Pertanto, possiamo sostituire il vincolo generico ( Wrapped == String) del codice precedente con uno più ampio ( Wrapped: Collection) in modo che Array, Dictionarye Setanche beneficiare della nostra nuova isNilOrEmptyproprietà:

extension Optional where Wrapped: Collection {

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

}

Utilizzo con 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

Utilizzo con 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

fonti:

• swiftbysundell.com - Estensione degli optional in Swift
• objc.io - Swift Tip: Collezioni non vuote

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

So che ci sono molte risposte a questa domanda, ma nessuna di queste sembra essere conveniente come questa (secondo me) per convalidare i UITextFielddati, che è uno dei casi più comuni per usarli :

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

Puoi semplicemente usare

textField.text.isNilOrEmpty

Puoi anche saltare il .trimmingCharacters(in:.whitespaces)se non consideri gli spazi bianchi come una stringa vuota o usarlo per test di input più complessi come

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

Io raccomanderei.

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

mapapplica l'argomento della funzione se l'opzione è .Some.
L'acquisizione del parco giochi mostra anche un'altra possibilità con il nuovo Swift 1.2 se si lascia l'associazione opzionale.

Se vuoi accedere alla stringa come non opzionale, dovresti usare la risposta di Ryan , ma se ti interessa solo la non vacuità della stringa, la mia scorciatoia preferita per questo è

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

Dato che ==funziona bene con i booleani opzionali, penso che questo lasci il codice leggibile senza oscurare l'intenzione originale.

Se vuoi verificare il contrario: se la stringa è nilo "", preferisco controllare entrambi i casi in modo esplicito per mostrare l'intenzione corretta:

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

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

Usa così su una stringa opzionale:

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

Swift 3 Per controllare la stringa migliore nel modo migliore

if !string.isEmpty{

// do stuff

}

Puoi creare la tua funzione personalizzata, se è qualcosa che ti aspetti di fare molto.

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

Soluzione Swift 3 Utilizzare il valore non imballato opzionale e verificare il valore booleano.

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

Utilizzando isEmpty

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

Utilizzando allSatisfy

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

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

Utilizzando una stringa opzionale

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

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

Riferimento: https://useyourloaf.com/blog/empty-strings-in-swift/

Creare un'estensione della classe String:

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

Si noti che questo restituirà VERO se la stringa contiene uno o più spazi vuoti. Per considerare la stringa vuota come "vuota", utilizzare ...

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

... anziché. Ciò richiede la Fondazione.

Usalo così ...

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

Swift 3 Funziona bene per verificare se la stringa è veramente vuota. Perché isEmpty ritorna vero quando c'è uno spazio bianco.

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

Esempi:

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

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

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

Dovresti fare qualcosa del genere:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

L'operatore a coalescenza zero verifica se l'opzione non è nulla, nel caso in cui non sia nulla quindi controlla la sua proprietà, in questo caso è vuota. Poiché questa opzione può essere nulla, si fornisce un valore predefinito che verrà utilizzato quando l'opzione è nulla.

Questa è una soluzione generale per tutti i tipi conformi al Collectionprotocollo, che include String:

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

Quando ho a che fare con il passaggio di valori dal db locale al server e viceversa, ho avuto troppi problemi con? E se! E cosa no.

Così ho creato un'utilità Swift3.0 per gestire casi nulli e posso quasi completamente evitare? 'E!' 'Nel codice.

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

Ex:-

Prima :

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

Dopo :

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

e quando è richiesto per verificare una stringa valida,

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

Questo mi ha risparmiato di dover affrontare il problema di aggiungere e rimuovere numerosi? 'E!' Dopo aver scritto il codice che ha ragionevolmente senso.

Utilizzare l'operatore ternario (noto anche come operatore condizionale, C++ forever!):

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

Lo stringA!scartamento forzato avviene solo quando stringA != nil, quindi è sicuro. La == falseverbosità è in qualche modo più leggibile di un altro punto esclamativo in !(stringA!.isEmpty).

Personalmente preferisco una forma leggermente diversa:

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

Nell'affermazione precedente, è immediatamente chiaro che l'intero ifblocco non viene eseguito quando una variabile è nil.

utile quando si ottiene valore da UITextField e si verifica la presenza di nil& emptystring

@IBOutlet weak var myTextField: UITextField!

Ecco la tua funzione (quando tocchi a button) che ottiene la stringa da UITextField e fa alcune altre cose

@IBAction func getStringFrom_myTextField(_ sender: Any) {

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

Questo si occuperà del nilvalore e della emptystringa.

Ha funzionato perfettamente per me.

Secondo me, il modo migliore per controllare lo zero e la stringa vuota è prendere il conteggio delle stringhe.

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

puoi usare questa funzione

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