Nell'obiettivo C, si potrebbe fare quanto segue per controllare le stringhe:

if ([myString isEqualToString:@""]) {
    NSLog(@"myString IS empty!");
} else {
    NSLog(@"myString IS NOT empty, it is: %@", myString);
}

Come si rilevano le stringhe vuote in Swift?

Ora c'è la possibilità integrata di rilevare una stringa vuota con .isEmpty:

if emptyString.isEmpty {
    print("Nothing to see here")
}

Documentazione preliminare di Apple: "Stringhe e caratteri" .

Un modo conciso per verificare se la stringa è nulla o vuota sarebbe:

var myString: String? = nil

if (myString ?? "").isEmpty {
    print("String is nil or empty")
}

Sto riscrivendo completamente la mia risposta (di nuovo ). Questa volta è perché sono diventato un fan della guarddichiarazione e ritorno presto . Rende il codice molto più pulito.

Stringa non opzionale

Verificare la lunghezza zero.

let myString: String = ""

if myString.isEmpty {
    print("String is empty.")
    return // or break, continue, throw
}

// myString is not empty (if this point is reached)
print(myString)

Se l' ifistruzione passa, puoi tranquillamente utilizzare la stringa sapendo che non è vuota. Se è vuoto, la funzione tornerà presto e nulla dopo che sarà importante.

Stringa opzionale

Verificare la lunghezza zero o zero.

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 scartato il componente opzionale e viene verificato che non sia vuoto allo stesso tempo. Dopo aver passato l' guardistruzione, puoi tranquillamente utilizzare la stringa non vuota non imballata.

In Xcode 11.3 swift 5.2 e versioni successive

Uso

var isEmpty: Bool { get } 

Esempio

let lang = "Swift 5"

if lang.isEmpty {
   print("Empty string")
}

Se vuoi ignorare gli spazi bianchi

if lang.trimmingCharacters(in: .whitespaces).isEmpty {
   print("Empty string")
}

Ecco come controllo se la stringa è vuota. Per "vuoto" intendo una stringa che è vuota o contiene solo spazi / caratteri di nuova riga.

struct MyString {
  static func blank(text: String) -> Bool {
    let trimmed = text.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
    return trimmed.isEmpty
  }
}

Come usare:

MyString.blank(" ") // true

Puoi anche usare un'estensione opzionale in modo da non doverti preoccupare di scartare o usare == true:

extension String {
    var isBlank: Bool {
        return self.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }
}
extension Optional where Wrapped == String {
    var isBlank: Bool {
        if let unwrapped = self {
            return unwrapped.isBlank
        } else {
            return true
        }
    }
}

Nota: quando si chiama questo su un opzionale, assicurarsi di non utilizzare ?altrimenti richiederà comunque lo scartamento.

Per eseguire il controllo zero e la lunghezza contemporaneamente Swift 2.0 e iOS 9 in poi è possibile utilizzare

if(yourString?.characters.count > 0){}

isEmpty farà come pensi che, se string == "", tornerà vero. Alcune delle altre risposte indicano una situazione in cui si dispone di una stringa facoltativa.

Si prega di utilizzare il concatenamento opzionale !!!!

Se la stringa non è nulla, verrà utilizzato isEmpty, altrimenti no.

Di seguito, opzionaleString NON verrà impostato perché la stringa è nulla

let optionalString: String? = nil
if optionalString?.isEmpty == true {
     optionalString = "Lorem ipsum dolor sit amet"
}

Ovviamente non useresti il ​​codice sopra. I guadagni provengono dall'analisi JSON o da altre situazioni simili in cui si ha un valore oppure no. Questo codice di garanzia verrà eseguito se esiste un valore.

Controlla controlla solo gli spazi e i caratteri di nuova riga nel testo

extension String
{
    var  isBlank:Bool {
        return self.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).isEmpty
    }
}

utilizzando

if text.isBlank
{
  //text is blank do smth
}

Per stringhe opzionali che ne dici di:

if let string = string where !string.isEmpty
{
    print(string)
}

if myString?.startIndex != myString?.endIndex {}

Che dire

if let notEmptyString = optionalString where !notEmptyString.isEmpty {
    // do something with emptyString 
    NSLog("Non-empty string is %@", notEmptyString)
} else {
    // empty or nil string
    NSLog("Empty or nil string")
}

Posso consigliare di aggiungere una piccola estensione a String o Array che assomiglia

extension Collection {
    public var isNotEmpty: Bool {
        return !self.isEmpty
    }
}

Con esso puoi scrivere codice che è più facile da leggere. Confronta queste due righe

if !someObject.someParam.someSubParam.someString.isEmpty {}

e

if someObject.someParam.someSubParam.someString.isNotEmpty {}

È facile perdere ! accedi all'inizio della linea del pugno.

Puoi usare questa estensione:

extension String {

    static func isNilOrEmpty(string: String?) -> Bool {
        guard let value = string else { return true }

        return value.trimmingCharacters(in: .whitespaces).isEmpty
    }

}

e poi usalo in questo modo:

let isMyStringEmptyOrNil = String.isNilOrEmpty(string: myString)