假设你正在使用Comparable实体，这将适用于任何东西：

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

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

它并不完全简短和甜蜜，但它富有表现力，清晰，可重用。

您可以使用!==
Swift编程语言（Swift Programming Language）
Swift还提供了两个恒等运算符（===和!==），用于测试两个对象引用是否都引用同一个对象示例。
Difference between == and ===上也有一些很好的示例和解释
在@PEEJWEEJ点，执行以下操作将得到false

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

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

我喜欢@基思的解决方案。但我认为它不是用Swift 4写的，因为我不能用Swift 4编译器编译它。
所以我把他的代码转换成Swift 4版本。
请记住，如果您使用的是比Swift 4.1更高版本的Swift语言，那么这个答案是没有必要的，因为它默认提供此功能。您可以参考here了解更多详细信息。

Swift 4版本@基思的代码：

infix operator ==? : ComparisonPrecedence

func ==? <T: Comparable>(lhs: T?, rhs: T?) -> Bool {
    if let lhs = lhs, let rhs = rhs {
        return lhs == rhs
    } else {
        return lhs == nil && rhs == nil
    }
}

func ==? <T: AnyObject>(lhs: T?, rhs: T?) -> Bool {
    if let lhs = lhs, let rhs = rhs {
        return lhs === rhs
    } else {
        return lhs == nil && rhs == nil
    }
}

我定义了一个自定义中缀运算符，它带有一个用于引用类型和值类型的函数。

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

可以为某些Comparable类型重载==运算符

public func ==<T: SomeType>(lhs: T?, rhs: T?) -> Bool {
    switch (lhs,rhs) {
    case (.some(let lhs), .some(let rhs)):
        return lhs == rhs
    case (.none, .none):
        return true
    default:
        return false
    }
}

或者对AnyObject使用===比较，不过，我个人更倾向于首先不使用AnyObject。

我相信这是基思的旧解决方案的Swift 5版本然而这是泛型。例如，如果您正在比较的对象是String?，它将认为String? = nil与String? = ""不相同，尽管两者在语义级别上都是“空”的

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