En Objective C, on pourrait faire ce qui suit pour vérifier les chaînes:

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

Comment détecter les chaînes vides dans Swift?

Il existe maintenant la capacité intégrée de détecter une chaîne vide avec .isEmpty:

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

Documentation de pré-version Apple: "Chaînes et caractères" .

Un moyen concis de vérifier si la chaîne est nulle ou vide serait:

var myString: String? = nil

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

Je réécris complètement ma réponse ( encore ). Cette fois, c'est parce que je suis devenu fan de la guarddéclaration et du retour anticipé . Cela donne un code beaucoup plus propre.

Chaîne non facultative

Vérifiez la longueur zéro.

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)

Si l' ifinstruction réussit, vous pouvez utiliser la chaîne en toute sécurité en sachant qu'elle n'est pas vide. S'il est vide, la fonction reviendra tôt et rien après cela n'a d'importance.

Chaîne facultative

Vérifiez la longueur nulle ou nulle.

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)

Cela déballe l'option facultative et vérifie qu'elle n'est pas vide en même temps. Après avoir transmis l' guardinstruction, vous pouvez utiliser en toute sécurité votre chaîne non vide non encapsulée.

Dans Xcode 11.3 swift 5.2 et versions ultérieures

Utilisation

var isEmpty: Bool { get } 

Exemple

let lang = "Swift 5"

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

Si vous voulez ignorer les espaces blancs

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

Voici comment je vérifie si la chaîne est vide. Par «vide», j'entends une chaîne qui est vide ou qui ne contient que des caractères d'espace / nouvelle ligne.

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

Comment utiliser:

MyString.blank(" ") // true

Vous pouvez également utiliser une extension facultative pour ne pas avoir à vous soucier du déballage ou de l'utilisation == 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
        }
    }
}

Remarque: lorsque vous appelez ceci sur une option, assurez-vous de ne pas l'utiliser, ?sinon cela nécessitera toujours un déballage.

Pour faire le contrôle de zéro et la longueur simultanément Swift 2.0 et iOS 9, vous pouvez utiliser

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

isEmpty fera ce que vous pensez qu'il fera, si string == "", il retournera true. Certaines des autres réponses indiquent une situation où vous avez une chaîne facultative.

VEUILLEZ utiliser le chaînage facultatif !!!!

Si la chaîne n'est pas nulle, isEmpty sera utilisé, sinon ce ne sera pas le cas.

Ci-dessous, la chaîne optionalString ne sera PAS définie car la chaîne est nulle

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

Évidemment, vous n'utiliseriez pas le code ci-dessus. Les gains proviennent de l'analyse JSON ou d'autres situations similaires dans lesquelles vous avez une valeur ou non. Cela garantit que le code sera exécuté s'il y a une valeur.

Vérifier vérifier uniquement les espaces et les caractères de retour à la ligne dans le texte

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

en utilisant

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

Pour les chaînes facultatives, que diriez-vous:

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

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

Qu'en est-il de

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

Je peux recommander d'ajouter une petite extension à String ou Array qui ressemble à

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

Avec lui, vous pouvez écrire du code plus facile à lire. Comparez ces deux lignes

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

et

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

C'est facile à rater ! signez au début de la première ligne.

Vous pouvez utiliser cette extension:

extension String {

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

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

}

puis utilisez-le comme ceci:

let isMyStringEmptyOrNil = String.isNilOrEmpty(string: myString)