Vérifiez la chaîne pour rien et vide

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

Je l’ai actuellement, mais il semble exagéré:

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

Si vous avez affaire à des chaînes optionnelles, cela fonctionne:

 (ssortingng ?? "").isEmpty 

Le ?? nil l’opérateur de coalescence 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 retourner une valeur par défaut:

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

Vous pourriez peut-être utiliser la clause if-let-where:

Swift 3:

 if let ssortingng = ssortingng, !ssortingng.isEmpty { /* ssortingng is not blank */ } 

Swift 2:

 if let ssortingng = ssortingng where !ssortingng.isEmpty { /* ssortingng is not blank */ } 

Utiliser la déclaration de guard

J’utilisais Swift pendant un moment avant que j’apprenne la déclaration de guard . Maintenant je suis un grand fan. Il est utilisé de manière similaire à l’instruction if , mais il permet un retour rapide et rend le code beaucoup plus propre en général.

Pour utiliser la garde lors de la vérification afin de s’assurer qu’une chaîne n’est ni vide ni vide, vous pouvez effectuer les opérations suivantes:

 let myOptionalSsortingng: Ssortingng? = nil guard let mySsortingng = myOptionalSsortingng, !mySsortingng.isEmpty else { print("Ssortingng is nil or empty.") return // or break, continue, throw } /// mySsortingng is neither nil nor empty (if this point is reached) print(mySsortingng) 

Cela déballe la chaîne optionnelle et vérifie qu’elle n’est pas vide en une fois. Si elle est nulle (ou vide), vous revenez immédiatement de votre fonction (ou de votre boucle) et tout ce qui suit est ignoré. Mais si le relevé de garde réussit, vous pouvez utiliser en toute sécurité votre chaîne non emballée.

Voir également

  • Documentation des relevés
  • Déclaration de la garde dans Swift 2

Si vous utilisez Swift 2, voici un exemple que mon collègue a proposé, qui ajoute la propriété isNilOrEmpty aux chaînes facultatives:

 protocol OptionalSsortingng {} extension Ssortingng: OptionalSsortingng {} extension Optional where Wrapped: OptionalSsortingng { var isNilOrEmpty: Bool { return ((self as? Ssortingng) ?? "").isEmpty } } 

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

 func testNilOrEmpty() { let nilSsortingng:Ssortingng? = nil XCTAssertTrue(nilSsortingng.isNilOrEmpty) let emptySsortingng:Ssortingng? = "" XCTAssertTrue(emptySsortingng.isNilOrEmpty) let someText:Ssortingng? = "lorem" XCTAssertFalse(someText.isNilOrEmpty) } 
 var str: Ssortingng? = nil if str?.isEmpty ?? true { print("str is nil or empty") } str = "" if str?.isEmpty ?? true { print("str is nil or empty") } 

Je recommanderais.

 if ssortingngA.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 le nouveau Swift 1.2 si vous le souhaitez.

entrer la description de l'image ici

Si vous voulez accéder à la chaîne en tant que non optionnel, vous devez utiliser la réponse de Ryan , mais si vous ne vous souciez que de la non-vacuité de la chaîne, mon raccourci préféré est:

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

Puisque == fonctionne bien avec les booléens optionnels, je pense que cela laisse le code lisible sans masquer l’intention originale.

Si vous voulez vérifier le contraire: si la chaîne est nil ou "" , je préfère vérifier explicitement les deux cas pour montrer l’intention correcte:

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

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

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

Vous pouvez simplement utiliser

 textField.text.isNilOrEmpty 

Vous pouvez également ignorer les .sortingmmingCharacters(in:.whitespaces) si vous ne considérez pas les espaces blancs comme une chaîne vide ou si vous l’utilisez pour des tests d’entrée plus complexes comme

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

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

 func isBlank (optionalSsortingng :Ssortingng?) -> Bool { if let ssortingng = optionalSsortingng { return ssortingng.isEmpty } else { return true } } var optionalSsortingng :Ssortingng? = nil if isBlank(optionalSsortingng) { println("here") } else { println("there") } 

Solution Swift 3 Utilisez la valeur facultative non emballée et vérifiez la valeur booléenne.

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

Swift 3 For check Chaîne vide meilleure façon

 if !ssortingng.isEmpty{ // do stuff } 

Créez une extension de classe Ssortingng:

 extension Ssortingng { // returns false if passed ssortingng is nil or empty static func isNilOrEmpty(_ ssortingng:Ssortingng?) -> Bool { if ssortingng == nil { return true } return ssortingng!.isEmpty } }// extension: Ssortingng 

Notez que cela retournera TRUE si la chaîne contient un ou plusieurs espaces. Pour traiter une chaîne vide comme “vide”, utilisez …

 return ssortingng!.sortingmmingCharacters(in: CharacterSet.whitespaces).isEmpty 

… au lieu. Cela nécessite la Fondation.

Utilisez-le donc …

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

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

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

Exemples:

 let mySsortingng = "My Ssortingng" mySsortingng.isEmptyAndContainsNoWhitespace() // returns false let mySsortingng = "" mySsortingng.isEmptyAndContainsNoWhitespace() // returns true let mySsortingng = " " mySsortingng.isEmptyAndContainsNoWhitespace() // returns false 

SWIFT 3

 extension Optional where Wrapped == Ssortingng { /// Checks to see whether the optional ssortingng 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 mySsortingng.isNilOrEmpty { print("Crap, how'd this happen?") } 

En ce qui concerne les valeurs de passage de la firebase database locale au serveur et vice versa, j’ai eu trop de problèmes avec les? Et les!

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(_ ssortingng: Ssortingng?) -> Ssortingng { return (ssortingng != nil ? ssortingng! : "") } 

Ex:-

Avant :

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

Après :

  let myDictionary: [Ssortingng: Ssortingng] = ["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 append et supprimer de nombreux codes? Et! Après avoir écrit du code raisonnablement logique.

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

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

La ssortingngA! Le ssortingngA != nil ne se produit que lorsque ssortingngA != nil , il est donc sûr. La == false verbosité == false est un peu plus lisible qu’un autre point d’exclamation !(ssortingngA!.isEmpty) .

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

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

Dans l’énoncé ci-dessus, il est très clair que le bloc if complet ne s’exécute pas lorsqu’une variable est nil .

utile pour obtenir la valeur de UITextField et vérifier la chaîne empty et empty

 @IBOutlet weak var myTextField: UITextField! 

Heres votre fonction (quand vous appuyez sur un button ) qui obtient la chaîne de UITextField et fait d’autres choses

 @IBAction func getSsortingngFrom_myTextField(_ sender: Any) { guard let ssortingng = myTextField.text, !(myTextField.text?.isEmpty)! else { return } //use "ssortingng" to do your stuff. } 

Cela prendra en compte la valeur nil ainsi que la chaîne empty .

Cela a parfaitement fonctionné pour moi.

vous pouvez utiliser ce func

  class func ssortingngIsNilOrEmpty(aSsortingng: Ssortingng) -> Bool { return (aSsortingng).isEmpty }