W celu C można wykonać następujące czynności, aby sprawdzić ciągi:

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

Jak można wykryć puste ciągi w języku Swift?

Istnieje teraz wbudowana możliwość wykrywania pustego ciągu za pomocą .isEmpty:

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

Dokumentacja Apple w wersji wstępnej: „Ciągi znaków i znaki” .

Zwięzły sposób sprawdzenia, czy łańcuch jest zerowy lub pusty, to:

var myString: String? = nil

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

Całkowicie przepisuję swoją odpowiedź ( ponownie ). Tym razem to dlatego, że stałem się fanem guardwypowiedzi i wczesnego powrotu . To sprawia, że ​​kod jest znacznie czystszy.

Ciąg nieopcjonalny

Sprawdź długość zerową.

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)

Jeśli ifinstrukcja przejdzie pomyślnie, możesz bezpiecznie użyć ciągu, wiedząc, że nie jest on pusty. Jeśli jest pusty, funkcja wróci wcześniej i nic nie będzie miało znaczenia.

Opcjonalny ciąg

Sprawdź długość zerową lub zerową.

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)

Spowoduje to rozpakowanie opcjonalnego i sprawdzenie, czy nie jest on jednocześnie pusty. Po przekazaniu guardinstrukcji możesz bezpiecznie użyć nieopakowanego niepustego ciągu.

W Xcode 11.3 swift 5.2 i nowszych

Posługiwać się

var isEmpty: Bool { get } 

Przykład

let lang = "Swift 5"

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

Jeśli chcesz zignorować spacje

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

Oto jak sprawdzam, czy ciąg jest pusty. Przez „pusty” rozumiem ciąg, który jest albo pusty, albo zawiera tylko znaki spacji / nowej linii.

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

Jak używać:

MyString.blank(" ") // true

Możesz także użyć opcjonalnego rozszerzenia, aby nie martwić się o rozpakowywanie lub używanie == 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
        }
    }
}

Uwaga: wywołując to jako opcjonalne, upewnij się, że nie używasz, ?bo w przeciwnym razie nadal będzie wymagało rozpakowania.

Aby wykonać zerową kontrolę i długość jednocześnie, Swift 2.0 i iOS 9 i nowsze wersje, możesz użyć

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

isEmpty zrobi to, co myślisz, że jeśli string == "", zwróci wartość true. Niektóre inne odpowiedzi wskazują na sytuację, w której masz opcjonalny ciąg.

PROSZĘ użyj opcjonalnego łączenia !!!!

Jeśli ciąg nie jest nil, zostanie użyty isEmpty, w przeciwnym razie nie.

Poniżej opcjonalny ciąg NIE zostanie ustawiony, ponieważ ciąg jest zerowy

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

Oczywiście nie użyłbyś powyższego kodu. Zyski pochodzą z analizowania JSON lub innych takich sytuacji, w których albo masz wartość, albo nie. Gwarantuje to, że kod zostanie uruchomiony, jeśli istnieje wartość.

Sprawdź, czy w tekście nie ma tylko spacji i znaków nowej linii

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

za pomocą

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

W przypadku opcjonalnych ciągów, co powiesz na:

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

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

Co powiesz na

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

Mogę polecić dodanie małego rozszerzenia do String lub Array, które wygląda jak

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

Dzięki niemu możesz napisać kod, który jest łatwiejszy do odczytania. Porównaj te dwie linie

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

i

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

Łatwo go przegapić ! zarejestruj się na początku pierwszej linii.

Możesz użyć tego rozszerzenia:

extension String {

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

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

}

a następnie użyj tego w ten sposób:

let isMyStringEmptyOrNil = String.isNilOrEmpty(string: myString)