web-dev-qa-db-fra.com

Vérifiez la chaîne pour zéro et vide

Existe-t-il un moyen de vérifier les chaînes pour nil et "" dans Swift? Dans Rails, je peux utiliser blank() pour vérifier. 

J'ai actuellement cela, mais il semble exagéré:

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

Si vous utilisez des chaînes facultatives, cela fonctionne:

(string ?? "").isEmpty

L'opérateur coalescent ?? nil renvoie le côté gauche s'il est non nul, sinon il renvoie le côté droit.

Vous pouvez également l'utiliser comme ceci pour renvoyer une valeur par défaut:

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

Vous pourriez peut-être utiliser la clause 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 */
}
70
Ryan

Si vous utilisez Swift 2, voici un exemple cité par mon collègue, qui ajoute la propriété isNilOrEmpty sur des chaînes facultatives:

protocol OptionalString {}
extension String: OptionalString {}

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

Vous pouvez ensuite utiliser isNilOrEmpty sur la chaîne facultative elle-même

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

Utilisation de l'instruction guard

J'utilisais Swift pendant un moment avant que je connaisse la déclaration guard . Maintenant je suis un grand fan. Il est utilisé de la même manière que l'instruction if , mais il permet le retour rapide et permet généralement un code beaucoup plus propre. 

Pour utiliser la protection lors de la vérification afin de vous assurer qu'une chaîne n'est ni nulle ni vide, vous pouvez procéder comme suit:

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 ouvre la chaîne facultative et vérifie qu'elle n'est pas vide en une fois. Si elle est nulle (ou vide), alors vous revenez de votre fonction (ou boucle) immédiatement et tout ce qui suit est ignoré. Mais si l'instruction Guard réussit, vous pouvez utiliser en toute sécurité votre chaîne non enveloppée. 

Voir également

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

Je sais qu'il y a beaucoup de réponses à cette question, mais aucune ne semble être aussi pratique que cela (à mon avis) pour valider les données UITextField, ce qui est l'un des cas les plus courants d'utilisation:

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

Vous pouvez simplement utiliser 

textField.text.isNilOrEmpty

Vous pouvez également ignorer le .trimmingCharacters(in:.whitespaces) si vous ne considérez pas les espaces comme une chaîne vide, ni l’utilisez pour des tests d’entrée plus complexes tels que 

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

Je recommanderais.

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

map applique l'argument de la fonction si l'option est .Some.
La capture du terrain de jeu montre également une autre possibilité avec la nouvelle version 1.2 de Swift si elle est facultative.

enter image description here

7
Price Ringo

Si vous souhaitez accéder à la chaîne de manière non facultative, vous devez utiliser Réponse de Ryan , mais si vous vous souciez uniquement de la non-vacuité de la chaîne, mon raccourci préféré est

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

Puisque == fonctionne bien avec des booléens facultatifs, je pense que cela laisse le code lisible sans obscurcir l’intention initiale.

Si vous voulez vérifier le contraire: si la chaîne est nil ou "", je préfère vérifier les deux cas de manière explicite pour indiquer l'intention correcte:

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

Vous pouvez créer votre propre fonction personnalisée, si vous souhaitez en faire beaucoup.

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

Solution Swift 3 Utilisez la valeur non enveloppée facultative et comparez-la avec le booléen.

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

Utilisez comme ceci sur une chaîne optionnelle:

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

Swift 3 Pour vérifier Chaîne vide meilleure manière

if !string.isEmpty{

// do stuff

}
2
Anas

Swift 3 Cela fonctionne bien pour vérifier si la chaîne est vraiment vide. Parce que isEmpty renvoie true lorsqu'il y a un espace.

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

Exemples:

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

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

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

Créez une extension de 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

Notez que ceci retournera TRUE si la chaîne contient un ou plusieurs blancs. Pour traiter une chaîne vide comme "vide", utilisez ... 

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

... au lieu. Cela nécessite une fondation.

Utilisez-le ainsi ...

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

Avec Swift 4.2, vous pouvez implémenter une extension Optional pour le type String avec une propriété boolean renvoyée si une chaîne facultative ne contient aucune valeur ou est vide:

extension Optional where Wrapped == String {

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

}

Cependant, String implémente la propriété isEmpty en se conformant au protocole Collection. Par conséquent, nous pouvons remplacer la contrainte générique du code précédent (Wrapped == String) par une contrainte plus large (Wrapped: Collection) afin que Array, Dictionary et Set profite également à notre nouvelle propriété isNilOrEmpty:

extension Optional where Wrapped: Collection {

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

}

Utilisation avec 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

Utilisation avec 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

Sources:

1
Imanou Petit

Ceci est une solution générale pour tous les types conformes au protocole Collection, qui inclut String:

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

Utilisation de isEmpty 

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

Utiliser allSatisfy 

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

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

Utilisation de la chaîne facultative 

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

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

Référence: https://useyourloaf.com/blog/empty-strings-in-Swift/

0
raaz

Utilisez l'opérateur ternaire (également appelé opérateur conditionnel, C++ forever!):

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

Le stringA! force-uncrapping ne se produit que lorsque stringA != nil, il est donc sans danger. La verbosité == false est un peu plus lisible qu’un autre point d’exclamation dans !(stringA!.isEmpty).

Personnellement, je préfère une forme légèrement différente:

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

Dans la déclaration ci-dessus, il est immédiatement évident que le bloc if n’est pas exécuté dans son intégralité lorsqu’une variable est nil.

0
Gary

Lorsqu’il s’agissait de transmettre des valeurs de la base de données locale au serveur et inversement, j’avais trop de problèmes avec les paramètres?.

J'ai donc créé un utilitaire Swift3.0 pour gérer les cas nuls et je peux presque totalement éviter les? Et les! Du code.

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

Ex:-

Avant :

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

Après :

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

et quand il est nécessaire de vérifier une chaîne valide,

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

Cela m'a évité de devoir ajouter et supprimer de nombreux?! Et! Après l'écriture d'un code raisonnablement logique.

0
Nikhil Mathew

utile pour obtenir une valeur de UITextField et pour rechercher les chaînes nil & empty

@IBOutlet weak var myTextField: UITextField!

Heres votre fonction (lorsque vous appuyez sur une button) qui obtient une chaîne de UITextField et fait d'autres choses

@IBAction func getStringFrom_myTextField(_ sender: Any) {

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

Ceci prendra en charge la valeur nil ainsi que la chaîne empty.

Cela a parfaitement fonctionné pour moi.

0
Soropromo