modo più elegante per confrontare due optional a Swift

Question

ho due AnyObject? variabili che vorrei confrontare per l'uguaglianza di riferimento:

var oldValue: AnyObject? 
var newValue: AnyObject? 
... 
if oldValue != newValue { 
    changed = true 
} 

Questo non funziona se, come io a quanto pare non posso paragonare direttamente due optionals. Voglio che il comportamento come se stessi paragonando id s in Objective-C, vale a dire:

• true se entrambi sono nil
• true se entrambi hanno un valore ed i valori sono uguali
• false altrimenti

C'è un modo elegante per scrivere questo in Swift (idealmente senza dover scrivere un'estensione personalizzata)?

Questo è il migliore che è venuta in mente:

if !(oldValue != nil && newValue != nil && oldValue == newValue) 

Non molto carina. :(

Answer 1

è possibile utilizzare. !==

Da La Swift linguaggio di programmazione

Swift fornisce anche due operatori di identità (=== e !==), che vengono utilizzati per verificare se due riferimenti di oggetti si riferiscono entrambi alla stessa istanza di oggetto.

Alcuni buoni esempi e le spiegazioni sono anche a Difference between == and ===

Sul punto @PEEJWEEJ, facendo quanto segue si tradurrà in false

var newValue: AnyObject? = "String" 
var oldValue: AnyObject? = "String" 

if newValue === oldValue { 
    print("true") 
} else { 
    print("false") 
} 

Answer 2

si Supponendo che sta utilizzando le entità comparabili, questo funzionerà su qualsiasi cosa:

func optionalsAreEqual<T: Comparable>(firstVal: T?, secondVal: T?) -> Bool{ 

    if let firstVal = firstVal, secondVal = secondVal { 
     return firstVal == secondVal 
    } 
    else{ 
     return firstVal == nil && secondVal == nil 
    } 
} 

Non è esattamente breve e dolce, ma è espressivo, chiara, e riutilizzabile

Answer 3

definisco un operatore infisso personalizzato con una funzione sia di riferimento tipi e tipi di valore.

func ==? <T: Comparable>(lhs: T?, rhs: T?) -> Bool { 
    if let lhs = lhs, rhs = rhs { 
     return lhs == rhs 
    } else{ return lhs == nil && rhs == nil } 
} 
func ==? <T: AnyObject>(lhs: T?, rhs: T?) -> Bool { 
    if let lhs = lhs, rhs = rhs { 
     return lhs === rhs 
    } else{ return lhs == nil && rhs == nil } 
} 
infix operator ==? { associativity left precedence 130 } 

var aString: String? = nil 
var bString: String? = nil 
print(aString ==? bString) // true 

aString = "test" 
bString = "test" 
print(aString ==? bString) // true 

aString = "test2" 
bString = "test" 
print(aString ==? bString) // false 

aString = "test" 
bString = nil 
print(aString ==? bString) // false 

class TT {} 
let x = TT() 

var aClass: TT? = TT() 
var bClass: TT? = TT() 
print(aClass ==? bClass) // false 

aClass = TT() 
bClass = nil 
print(aClass ==? bClass) // false 

aClass = nil 
bClass = nil 
print(aClass ==? bClass) // true 

aClass = x 
bClass = x 
print(aClass ==? bClass) // true