爪哇语；等于；等同于Swift

我正在寻找与Swift中Java的“.equals”完全相同的版本

两个数据值

val1

和

val2

被声明为

Any

（也尝试了

AnyObject

-仍然没有运气）。如果数据是值类型或定义了

isEqual

，则它们将按值（==）进行比较，否则它们将作为参考（==）进行比较

我希望==可以这样做，但事实并非如此：编译器给出错误消息“Binary operator==无法应用”

---

有没有办法做到这一点？

Swift是一种类型安全语言。类型安全语言鼓励您明确代码可以使用的值的类型。如果部分代码需要字符串，则不能错误地将Int传递给它

您可以比较任意两个值。我不能这样做，因为不能比较字符串和Int值。您需要将两个值强制转换为同一类型，然后比较它们

例如，您有两个值

let val1: Any (in fact this is String)
let val2: Any (in fact this is also String)

if let cast1 = val1 as? String,
   let cast2 = val2 as? String {
   return cast1 == cast2
}

---

Swift是一种类型安全语言。类型安全语言鼓励您明确代码可以使用的值的类型。如果部分代码需要字符串，则不能错误地将Int传递给它

您可以比较任意两个值。我不能这样做，因为不能比较字符串和Int值。您需要将两个值强制转换为同一类型，然后比较它们

例如，您有两个值

let val1: Any (in fact this is String)
let val2: Any (in fact this is also String)

if let cast1 = val1 as? String,
   let cast2 = val2 as? String {
   return cast1 == cast2
}

---

我在Java方面没有太多经验，但根据您的描述，您可以定义一些函数重载来提供类似的功能

// Two instances of the same type which implements Equatable
func isEqual<T>(_ a: T, _ b: T) -> Bool where T : Equatable {
    return a == b
}

// Pointer equal
func isEqual(_ a: AnyObject, _ b: AnyObject) -> Bool {
    return a === b
}

// Between an object and an value or between 2 values that do not implement Equatable
func isEqual(_ a: Any, _ b: Any) -> Bool {
    return false
}

// Test
assert(isEqual(1, 1) == true)
assert(isEqual("a", 1) == false)
assert(isEqual(NSData(), "a" as NSString) == false)
assert(isEqual("a", NSDecimalNumber(value: 42)) == false)

// Two instance values that do not implement Equatable
struct A { }
struct B { }
assert(isEqual(A(), B()) == false)

// Pointer equal
var num = 42
let ptr1 = withUnsafePointer(to: &num) { $0 }
let ptr2 = withUnsafePointer(to: &num) { $0 }
assert(isEqual(ptr1, ptr2) == true)

//实现equalable的同一类型的两个实例
func-isEqual（a:T，b:T）->Bool其中T:equalable{
返回a==b
}
//指针相等
func isEqual（a:AnyObject，b:AnyObject）->Bool{
返回a==b
}
//在一个对象和一个值之间，或在两个不实现Equalable的值之间
函数相等（a:Any，b:Any）->Bool{
返回错误
}
//试验
断言（isEqual（1，1）==true）
断言（isEqual（“a”，1）==false）
断言（isEqual（NSData（），“a”作为NSString）=false）
断言（isEqual（“a”，NSDecimalNumber（值：42））==false）
//两个不实现equalable的实例值
结构A{}
结构B{}
断言（isEqual（A（），B（））==false）
//指针相等
var num=42
设ptr1=withUnsafePointer（to:&num）{$0}
设ptr2=withUnsafePointer（to:&num）{$0}
断言（相等（ptr1，ptr2）==true）

我在Java方面没有太多经验，但根据您的描述，您可以定义一些函数重载来提供类似的功能

// Two instances of the same type which implements Equatable
func isEqual<T>(_ a: T, _ b: T) -> Bool where T : Equatable {
    return a == b
}

// Pointer equal
func isEqual(_ a: AnyObject, _ b: AnyObject) -> Bool {
    return a === b
}

// Between an object and an value or between 2 values that do not implement Equatable
func isEqual(_ a: Any, _ b: Any) -> Bool {
    return false
}

// Test
assert(isEqual(1, 1) == true)
assert(isEqual("a", 1) == false)
assert(isEqual(NSData(), "a" as NSString) == false)
assert(isEqual("a", NSDecimalNumber(value: 42)) == false)

// Two instance values that do not implement Equatable
struct A { }
struct B { }
assert(isEqual(A(), B()) == false)

// Pointer equal
var num = 42
let ptr1 = withUnsafePointer(to: &num) { $0 }
let ptr2 = withUnsafePointer(to: &num) { $0 }
assert(isEqual(ptr1, ptr2) == true)

//实现equalable的同一类型的两个实例
func-isEqual（a:T，b:T）->Bool其中T:equalable{
返回a==b
}
//指针相等
func isEqual（a:AnyObject，b:AnyObject）->Bool{
返回a==b
}
//在一个对象和一个值之间，或在两个不实现Equalable的值之间
函数相等（a:Any，b:Any）->Bool{
返回错误
}
//试验
断言（isEqual（1，1）==true）
断言（isEqual（“a”，1）==false）
断言（isEqual（NSData（），“a”作为NSString）=false）
断言（isEqual（“a”，NSDecimalNumber（值：42））==false）
//两个不实现equalable的实例值
结构A{}
结构B{}
断言（isEqual（A（），B（））==false）
//指针相等
var num=42
设ptr1=withUnsafePointer（to:&num）{$0}
设ptr2=withUnsafePointer（to:&num）{$0}
断言（相等（ptr1，ptr2）==true）

我正在寻找与Swift中Java的“.equals”完全相同的版本

你用错语言了。我还认为你从错误的角度看待平等检查

Swift的概念是

equalable

类型，它公开了

=

运算符，但是该运算符仅适用于同一类型的具体值，

任何

都不符合此条件

Java中的情况有些不同，

equals

几乎可以接收任何对象作为参数。这可能会导致一些有趣的场景，比如使

文件句柄

和

房屋

相等，请不要试图说服我这实际上是有用的，即使语言允许

Swift的

equalable

与Java的

equals

相比有一个巨大的优势：它保证在编译时您不会试图比较不兼容的类型。现在您可能认为这比Java中的更严格，但这不一定是真的，因为在大多数情况下，您不需要比较不同类型的值

总之，如果需要检查是否相等，请使用

equalable

。使您的类型符合此协议，并实现

=

方法。让编译器完成其余的工作

我正在寻找与Swift中Java的“.equals”完全相同的版本

你用错语言了。我还认为你从错误的角度看待平等检查

Swift的概念是

equalable

类型，它公开了

=

运算符，但是该运算符仅适用于同一类型的具体值，

任何

都不符合此条件

Java中的情况有些不同，

equals

几乎可以接收任何对象作为参数。这可能会导致一些有趣的场景，比如使

文件句柄

和

房屋

相等，请不要试图说服我这实际上是有用的，即使语言允许

Swift的

equalable

与Java的

equals

相比有一个巨大的优势：它保证在编译时您不会试图比较不兼容的类型。现在您可能认为这比Java中的更严格，但这不一定是真的，因为在大多数情况下，您不需要比较不同类型的值

总之，如果需要检查是否相等，请使用

equalable

。使您的类型符合此协议，并实现

=

方法。让编译器完成剩下的工作。

代码等于

// this is the interface
protocol JavaEquality {
    func javaEquals(other: Any) -> Bool
}

// two structs/objects are equal only if their references are equal
extension JavaEquality {
    func javaEquals(other: Any) -> Bool {
        guard
            let selfObject = self as? AnyObject,
            let otherObject = other as? AnyObject
        else {
            return false
        }

        if selfObject === otherObject {
            return true
        }

        return false
    }
}

// implement for equatable structs/objects
extension JavaEquality where Self: Equatable {
    func javaEquals(other: Any) -> Bool {
        guard type(of: self) == type(of: other) else {
            return false
        }

        return self == (other as! Self)
    }
}

// let's test this
class A: Equatable {
    let x: Int

    init(x: Int) {
        self.x = x
    }

    static func == (left: A, right: A) -> Bool {
        return left.x == right.x
    }
}

class B: A {}

// the only flaw is that you have to add the protocol to any struct/object you need
extension String: JavaEquality {}
extension Int: JavaEquality {}
extension NSNumber: JavaEquality {}
extension A: JavaEquality {}

let string1 = "a"
let string2 = "a"
let string3 = "b"
let int1 = 1
let number1 = A(x: 100)
let number2 = A(x: 100)
let number3 = A(x: 200)
let number4: B = B(x: 100)
let number5: A = B(x: 100)

print(string1.javaEquals(other: string2)) // true
print(string1.javaEquals(other: string3)) // false
print(string1.javaEquals(other: int1)) // false
print(number1.javaEquals(other: number2)) // true
print(number1.javaEquals(other: number3)) // false
print(number1.javaEquals(other: number4)) // false
print(number4.javaEquals(other: number5)) // true