Najbardziej eleganckim sposobem porównać dwa ewentualne, w Swift

Question

Mam dwa AnyObject? zmienne, które chciałbym porównać dla równości odniesienia:

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

to nie działa choć, jak ja widocznie nie można porównać dwa składniki ewentualne bezpośrednio. Chcę zachowanie jakbym porównując id S w Objective-C, to jest:

• true jeśli oba są nil
• true jeśli oba mają wartość i wartości są także równe
• false inaczej

Czy istnieje elegancki sposób na napisanie tego w Swift (najlepiej bez pisania niestandardowego rozszerzenia)?

Jest to najlepszy jaki wymyślić:

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

niezbyt ładna. :(

Answer 1

Można użyć. !==

Od Swift Programming Language

Swift udostępnia również dwa operatory tożsamości (=== i !==), których używa się do testowania dwóch odwołań do obiektów zarówno w odniesieniu do tej samej instancji obiektu.

Niektóre dobre przykłady i objaśnienia są również w Difference between == and ===

na punkt @PEEJWEEJ, wykonując następujące czynności spowoduje false

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

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

Answer 2

Zakładając, że używasz podmioty porównywalne, to będzie działać na niczym:

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

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

To nie jest dokładnie to krótkie i słodkie, ale to wyraziste, jasne i wielokrotnego użytku

Answer 3

zdefiniować operator zwyczaj Infix z funkcją zarówno w odniesieniu typy i typy wartości.

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