Swift: test des options pour nul

J'utilise Xcode 6 Beta 4. J'ai cette situation étrange où je ne peux pas comprendre comment tester correctement les options.

Si j'ai un xyz facultatif, est la bonne façon de tester:

if (xyz) // Do something

ou

if (xyz != nil) // Do something

Les documents disent de le faire de la première manière, mais j'ai trouvé que parfois, la deuxième méthode est requise et ne génère pas d'erreur de compilation, mais d'autres fois, la deuxième méthode génère une erreur de compilation.

Mon exemple spécifique utilise l'analyseur XML GData couplé à swift:

let xml = GDataXMLDocument(
    XMLString: responseBody,
    options: 0,
    error: &xmlError);

if (xmlError != nil)

Ici, si je viens de le faire:

if xmlError

cela reviendrait toujours vrai. Cependant, si je fais:

if (xmlError != nil)

puis cela fonctionne (comme cela fonctionne en Objective-C).

Y a-t-il quelque chose avec le XML GData et la façon dont il traite les options qui me manquent?

Dans Xcode Beta 5, ils ne vous permettent plus de faire:

var xyz : NSString?

if xyz {
  // Do something using `xyz`.
}

Cela produit une erreur:

n'est pas conforme au protocole 'BooleanType.Protocol'

Vous devez utiliser l'un de ces formulaires:

if xyz != nil {
   // Do something using `xyz`.
}

if let xy = xyz {
   // Do something using `xy`.
}

Pour ajouter aux autres réponses, au lieu d'affecter à une variable nommée différemment à l'intérieur d'une ifcondition:

var a: Int? = 5

if let b = a {
   // do something
}

vous pouvez réutiliser le même nom de variable comme ceci:

var a: Int? = 5

if let a = a {
    // do something
}

Cela peut vous éviter de manquer de noms de variables créatives ...

Cela tire parti de l' ombre variable prise en charge dans Swift.

L'une des façons les plus directes d'utiliser les options est la suivante:

En supposant qu'il xyzest de type facultatif, comme Int?par exemple.

if let possXYZ = xyz {
    // do something with possXYZ (the unwrapped value of xyz)
} else {
    // do something now that we know xyz is .None
}

De cette façon, vous pouvez à la fois tester si xyz contient une valeur et si c'est le cas, travailler immédiatement avec cette valeur.

En ce qui concerne votre erreur de compilation, le type UInt8n'est pas facultatif (notez pas de «?») Et ne peut donc pas être converti en nil. Assurez-vous que la variable avec laquelle vous travaillez est facultative avant de la traiter comme telle.

Swift 3.0 et 4.0

Il existe principalement deux façons de vérifier facultatif pour nil. Voici des exemples avec comparaison entre eux

1. si loué

if letest le moyen le plus simple de vérifier facultatif pour nil. D'autres conditions peuvent être ajoutées à cette vérification nulle, séparées par une virgule. La variable ne doit pas être nulle pour passer à la condition suivante. Si seule une vérification nulle est requise, supprimez les conditions supplémentaires dans le code suivant.

À part cela, si ce xn'est pas nul, la fermeture if sera exécutée et x_valsera disponible à l'intérieur. Sinon, la fermeture else est déclenchée.

if let x_val = x, x_val > 5 {
    //x_val available on this scope
} else {

}

2. garde laisser

guard letpeut faire des choses similaires. Son objectif principal est de le rendre logiquement plus raisonnable. C'est comme dire Assurez-vous que la variable n'est pas nulle, sinon arrêtez la fonction . guard letpeut également faire une vérification de condition supplémentaire comme if let.

Les différences sont que la valeur non emballée sera disponible sur la même portée que guard let, comme indiqué dans le commentaire ci-dessous. Cela conduit aussi au point que la fermeture d' autre, le programme doit quitter la portée actuelle, par return, breaketc.

guard let x_val = x, x_val > 5 else {
    return
}
//x_val available on this scope

À partir du guide de programmation rapide

Instructions en cas et déballage forcé

Vous pouvez utiliser une instruction if pour savoir si une option contient une valeur. Si un optionnel a une valeur, il prend la valeur true; s'il n'a aucune valeur du tout, il est évalué à faux.

La meilleure façon de procéder est donc

// swift > 3
if xyz != nil {}

et si vous utilisez l' xyzinstruction in if. Vous pouvez ensuite dérouler l' xyzinstruction if dans une variable constante. Ainsi, vous n'avez pas besoin de dérouler chaque endroit de l'instruction if où xyzest utilisé.

if let yourConstant = xyz{
      //use youtConstant you do not need to unwrap `xyz`
}

Cette convention est suggérée par appleet elle sera suivie par les développeurs.

Bien que vous deviez toujours comparer explicitement un optionnel avec nilou utiliser une liaison optionnelle pour extraire en plus sa valeur (c'est-à-dire que les options ne sont pas implicitement converties en valeurs booléennes), il convient de noter que Swift 2 a ajouté l' guardinstruction pour éviter la pyramide de malheur lorsque vous travaillez avec plusieurs valeurs facultatives.

En d'autres termes, vos options incluent désormais la vérification explicite de nil:

if xyz != nil {
    // Do something with xyz
}

Reliure facultative:

if let xyz = xyz {
    // Do something with xyz
    // (Note that we can reuse the same variable name)
}

Et guarddéclarations:

guard let xyz = xyz else {
    // Handle failure and then exit this code block
    // e.g. by calling return, break, continue, or throw
    return
}

// Do something with xyz, which is now guaranteed to be non-nil

Notez comment une liaison facultative ordinaire peut entraîner une plus grande indentation lorsqu'il existe plusieurs valeurs facultatives:

if let abc = abc {
    if let xyz = xyz {
        // Do something with abc and xyz
    }        
}

Vous pouvez éviter cette imbrication avec des guardinstructions:

guard let abc = abc else {
    // Handle failure and then exit this code block
    return
}

guard let xyz = xyz else {
    // Handle failure and then exit this code block
    return
}

// Do something with abc and xyz

Extension du protocole Swift 5

Voici une approche utilisant l'extension de protocole afin que vous puissiez facilement intégrer une vérification facultative de nil:

import Foundation

public extension Optional {

    var isNil: Bool {

        guard case Optional.none = self else {
            return false
        }

        return true

    }

    var isSome: Bool {

        return !self.isNil

    }

}

Usage

var myValue: String?

if myValue.isNil {
    // do something
}

if myValue.isSome {
    // do something
}

Vous pouvez maintenant faire rapidement la chose suivante qui vous permet de retrouver un peu de l'objectif-c if nil else

if textfieldDate.text?.isEmpty ?? true {

}

Au lieu de if, l'opérateur ternaire peut être utile lorsque vous souhaitez obtenir une valeur basée sur le fait que quelque chose est nul:

func f(x: String?) -> String {
    return x == nil ? "empty" : "non-empty"
}

Une autre approche en plus d'utiliser des instructions ifou guardpour effectuer la liaison facultative consiste à étendre Optionalavec:

extension Optional {

    func ifValue(_ valueHandler: (Wrapped) -> Void) {
        switch self {
        case .some(let wrapped): valueHandler(wrapped)
        default: break
        }
    }

}

ifValuereçoit une fermeture et l'appelle avec la valeur comme argument lorsque l'option n'est pas nil. Il est utilisé de cette façon:

var helloString: String? = "Hello, World!"

helloString.ifValue {
    print($0) // prints "Hello, World!"
}

helloString = nil

helloString.ifValue {
    print($0) // This code never runs
}

Vous devriez probablement utiliser un ifou guardcependant car ce sont les approches les plus conventionnelles (donc familières) utilisées par les programmeurs Swift.

Une option qui n'a pas été spécifiquement couverte consiste à utiliser la syntaxe de valeur ignorée de Swift:

if let _ = xyz {
    // something that should only happen if xyz is not nil
}

J'aime ça depuis que la vérification ne nilsemble pas à sa place dans une langue moderne comme Swift. Je pense que la raison pour laquelle il ne semble pas à sa place est qu'il nils'agit essentiellement d'une valeur sentinelle. Nous avons éliminé les sentinelles à peu près partout ailleurs dans la programmation moderne, alors nous avons l' nilimpression que cela devrait aussi aller.

Vous pouvez également utiliser Nil-Coalescing Operator

Le nil-coalescing operator( a ?? b) déballe un optionnel as'il contient une avaleur, ou renvoie la avaleur par défaut bsi ac'est nil. L'expression a est toujours de type facultatif. L'expression bdoit correspondre au type stocké à l'intérieur a.

let value = optionalValue ?? defaultValue

Si optionalValuec'est le cas nil, il attribue automatiquement une valeur àdefaultValue

var xyz : NSDictionary?

// case 1:
xyz = ["1":"one"]
// case 2: (empty dictionary)
xyz = NSDictionary() 
// case 3: do nothing

if xyz { NSLog("xyz is not nil.") }
else   { NSLog("xyz is nil.")     }

Ce test a fonctionné comme prévu dans tous les cas. BTW, vous n'avez pas besoin des crochets ().

Si vous avez des conditions conditionnelles et que vous souhaitez dérouler et comparer, que diriez-vous de profiter de l'évaluation de court-circuit de l'expression booléenne composée comme dans

if xyz != nil && xyz! == "some non-nil value" {

}

Certes, ce n'est pas aussi lisible que certains des autres messages suggérés, mais fait le travail et est quelque peu succinct que les autres solutions suggérées.