Wenn ich überprüfen möchte, ob ein optionaler Bool wahr ist, funktioniert dies nicht:

var boolean : Bool? = false
if boolean{
}

Dies führt zu diesem Fehler:

Optionaler Typ '@IvalueBool?' kann nicht als Boolescher Wert verwendet werden; Teste stattdessen auf '! = nil'

Ich möchte nicht nach Null suchen. Ich möchte überprüfen, ob der zurückgegebene Wert wahr ist.

Muss ich immer tun, if boolean == truewenn ich mit einem optionalen Bool arbeite?

Sollte BooleanTypeder Compiler nicht wissen, dass ich den Wert des Bool überprüfen möchte, da Optionals nicht mehr den Anforderungen entsprechen?

Bei optionalen Booleschen Werten muss die Prüfung explizit erfolgen:

if boolean == true {
    ...
}

Andernfalls können Sie das optionale auspacken:

if boolean! {
    ...
}

Aber das erzeugt eine Laufzeitausnahme, wenn boolean ist nil- um das zu verhindern:

if boolean != nil && boolean! {
    ...
}

Vor Beta 5 war dies möglich, aber es wurde geändert, wie in den Versionshinweisen angegeben:

Optionale Werte werden nicht mehr implizit als wahr ausgewertet, wenn sie einen Wert haben, und als falsch, wenn dies nicht der Fall ist, um Verwirrung bei der Arbeit mit optionalen Bool-Werten zu vermeiden. Führen Sie stattdessen eine explizite Prüfung gegen nil mit den Operatoren == oder! = Durch, um herauszufinden, ob ein optionales Element einen Wert enthält.

Nachtrag: Wie von @MartinR vorgeschlagen, verwendet eine kompaktere Variante der dritten Option den Koaleszenzoperator:

if boolean ?? false {
    // this code runs only if boolean == true
}

Dies bedeutet: Wenn der Boolesche Wert nicht Null ist, wird der Ausdruck als Boolescher Wert ausgewertet (dh unter Verwendung des nicht umschlossenen Booleschen Werts), andernfalls wird der Ausdruck als ausgewertet false

Optionale Bindung

Schnelle 3 & 4

var booleanValue : Bool? = false
if let booleanValue = booleanValue, booleanValue {
    // Executes when booleanValue is not nil and true
    // A new constant "booleanValue: Bool" is defined and set
    print("bound booleanValue: '\(booleanValue)'")
}

Swift 2.2

var booleanValue : Bool? = false
if let booleanValue = booleanValue where booleanValue {
    // Executes when booleanValue is not nil and true
    // A new constant "booleanValue: Bool" is defined and set
    print("bound booleanValue: '\(booleanValue)'")
}

Der Code let booleanValue = booleanValuegibt , falsewenn booleanValueist nilund der ifBlock wird nicht ausgeführt. Wenn dies booleanValuenicht der Fall ist nil, definiert dieser Code eine neue Variable mit dem Namen booleanValuetype Bool(anstelle einer optionalen Variablen Bool?).

Der Swift 3 & 4-Code booleanValue(und der Swift 2.2-Code where booleanValue) wertet die neue booleanValue: BoolVariable aus. Wenn dies der Fall ist, wird der ifBlock mit der neu definierten booleanValue: BoolVariablen im Gültigkeitsbereich ausgeführt (sodass die Option den gebundenen Wert innerhalb des ifBlocks erneut referenzieren kann ).

Hinweis: Es ist eine Swift-Konvention, die gebundene Konstante / Variable genauso zu benennen wie die optionale Konstante / Variable wie z let booleanValue = booleanValue. Diese Technik wird als variable Abschattung bezeichnet . Sie könnten von der Konvention abweichen und so etwas verwenden let unwrappedBooleanValue = booleanValue, unwrappedBooleanValue. Ich weise darauf hin, um zu verstehen, was passiert. Ich empfehle die Verwendung von variablem Shadowing.

Andere Ansätze

Nichts verschmilzt

Für diesen speziellen Fall ist keine Koaleszenz klar

var booleanValue : Bool? = false
if booleanValue ?? false {
    // executes when booleanValue is true
    print("optional booleanValue: '\(booleanValue)'")
}

Das Überprüfen auf falseist nicht so klar

var booleanValue : Bool? = false
if !(booleanValue ?? false) {
    // executes when booleanValue is false
    print("optional booleanValue: '\(booleanValue)'")
}

Hinweis: if !booleanValue ?? falseKompiliert nicht.

Optionales Auspacken erzwingen (vermeiden)

Das erzwungene Auspacken erhöht die Wahrscheinlichkeit, dass jemand in Zukunft eine Änderung vornimmt, die kompiliert wird, aber zur Laufzeit abstürzt. Daher würde ich so etwas vermeiden:

var booleanValue : Bool? = false
if booleanValue != nil && booleanValue! {
    // executes when booleanValue is true
    print("optional booleanValue: '\(booleanValue)'")
}

Ein allgemeiner Ansatz

Obwohl diese Stack - Überlauf Frage ausdrücklich fragt , wie zu überprüfen , ob eine Bool?ist truein einer ifAussage, ist es hilfreich , einen allgemeinen Ansatz zu erkennen , ob für eine echte Kontrolle, falschen oder den ungeöffneten Wert mit anderen Ausdrücken kombinieren.

Wenn der Ausdruck komplizierter wird, finde ich den optionalen Bindungsansatz flexibler und verständlicher als andere Ansätze. Beachten Sie, dass optionale Bindung funktioniert mit jedem optional Typ ( Int?, String?usw.).

var enabled: Bool? = true

if let enabled = enabled, enabled == true {
    print("when is defined and true at the same moment")
}

if enabled ?? false {
    print("when is defined and true at the same moment")
}

if enabled == .some(true) {
    print("when is defined and true at the same moment")
}

if enabled == (true) {
    print("when is defined and true at the same moment")
}

if case .some(true) = enabled {
    print("when is defined and true at the same moment")
}

if enabled == .some(false) {
    print("when is defined and false at the same moment")
}

if enabled == (false) {
    print("when is defined and false at the same moment")
}

if enabled == .none {
    print("when is not defined")
}

if enabled == nil {
    print("when is not defined")
}

Ich habe eine andere Lösung gefunden, die die Booleschen Operatoren überlastet. Beispielsweise:

public func < <T: Comparable> (left: T?, right: T) -> Bool {
    if let left = left {
        return left < right
    }
    return false
}

Dies ist möglicherweise nicht ganz im "Geist" der Sprachänderungen, ermöglicht jedoch das sichere Auspacken von Optionen und kann für Bedingungen überall verwendet werden, auch für while-Schleifen.

Die Antwort, die ich am einfachsten zu lesen fand, ist das Definieren einer Funktion. Nicht sehr kompliziert, macht aber die Arbeit.

func isTrue(_ bool: Bool?) -> Bool {
    guard let b = bool else {
        return false
    }
    return b
}

Verwendung:

let b: Bool? = true
if isTrue(b) {
    // b exists and is true
} else {
    // b does either not exist or is false
}

Wie Antonio sagte

Optionale Werte werden nicht mehr implizit als wahr ausgewertet, wenn sie einen Wert haben, und als falsch, wenn dies nicht der Fall ist, um Verwirrung bei der Arbeit mit optionalen Bool-Werten zu vermeiden. Führen Sie stattdessen eine explizite Prüfung gegen nil mit den Operatoren == oder! = Durch, um herauszufinden, ob ein optionales Element einen Wert enthält.

Ich habe ein paar Stunden damit verbracht, eine Codezeile zu verstehen, auf die ich gestoßen bin, aber dieser Thread hat mich auf den richtigen Weg gebracht.

Dieses Zitat stammt aus dem August 2014 und wurde seitdem von Apple Nevernach dem Vorschlag SE-0102 eingeführt. Letzterer hat es an Equatable, Hashable, Error und Comparable angepasst

Es ist jetzt möglich zu überprüfen, ob ein Boolescher Wert nilverwendet Never?:

var boolean: Bool? = false
boolean is Never? // false
boolean = true
boolean is Never? // false
boolean = nil
boolean is Never? // true

Sie können tatsächlich alle anderen unbewohnbaren Typen verwenden:

public enum NeverEver { }
var boolean: Bool? = false
boolean is NeverEver? // false
boolean = true
boolean is NeverEver? // false
boolean = nil
boolean is NeverEver? // true

Abgesehen davon ist es jetzt auch möglich, einen Property Wrapper zu verwenden :

@propertyWrapper struct OptionalBool {
    public var wrappedValue: Bool?
    public var projectedValue: Bool { wrappedValue ?? false }
    public init(wrappedValue: Bool?) {
        self.wrappedValue = wrappedValue
    }
}

struct Struct {
    @OptionalBool var predicate: Bool?
    var description: String {
        if $predicate {
            return "predicate is true"
        }
        return "predicate is false"
    }
}

var object = Struct()
object.description // "predicate is false"
object.predicate = false
object.description // "predicate is false"
object.predicate = true
object.description // "predicate is true"

oder auch:

@propertyWrapper struct OptionalBool {
    var wrappedValue: Bool?
    var projectedValue: OptionalBool { self }
    var isNil: Bool { wrappedValue is Never? }
    var value: Bool { wrappedValue ?? false }
    
    init(wrappedValue: Bool?) {
        self.wrappedValue = wrappedValue
    }
}

struct Struct {
    @OptionalBool var predicate: Bool?
    var description: String {
        if $predicate.value {
            return "predicate is true"
        }
        if !$predicate.isNil {
            return "predicate is false"
        }
        return "predicate is nil"
    }
}

var object = Struct()
object.description // "predicate is nil"
object.predicate = false
object.description // "predicate is false"
object.predicate = true
object.description // "predicate is true"