泛型 – 比较通用结构类型

如何确定通用结构的两个实例是否是相同类型？

例如，给定以下结构：

struct FooBar<T> {
    let variable: T
    init(arg: T) {
        variable = arg
    }
}

并且以下片段：

let foo = FooBar(1)
let bar = FooBar(1.0)
let baz = FooBar("1")

我如何确定foo，bar或baz是相同或不同类型？

func areExactType(x: FooBar) -> Bool {
    return self.dynamicType === x.dynamicType
}

这给了

Type ‘Foo’ does not conform to protocol ‘AnyObject’

func areExactType(x: FooBar) -> Bool {
    return self.dynamicType === x.dynamicType
}

这给了

Cannot invoke ‘==’ with an argument list of type ‘(Foo.Type,Foo.Type)’

func areExactType(x: FooBar) -> Bool {
    return self is x.dynamicType
}

这会产生三个错误：

Consecutive statements on a line must be separated by ‘;’

(这想要在句点和’dynamicType’之间放置一个分号)

Expected identifier in dotted type

和

Expected expression

@H_404_47@

编辑：

对不起，早期的答案，它实际上不工作，因为编译器将选择不同类型的函数时从另一个函数内调用：

func foobar<T,U> (lhs: Foo<T>,rhs: Foo<U>) -> Bool {
    return lhs.sameType(rhs)
}

如果你留在纯粹的斯威夫特领土，以下将工作：

给定一个简单的通用结构

struct Foo<T> {
    let v : T
}

你可以定义一个函数sameType，它接受相同类型的Foos并返回true：

func sameType<T> (a: Foo<T>,b: Foo<T>) -> Bool {
    return true
}

并用两种不同的Foos重载函数：

func sameType<T,U> (a: Foo<T>,b: Foo<U>) -> Bool {
    return false;
}

编译器将根据参数类型选择一个方法：

let a = Foo(v: 1.0)
let b = Foo(v: "asdf")
sameType(a,b) // false
sameType(a,a) // true

这与结构上的实例方法的工作方式相同：

func sameType (other: Foo) -> Bool {
        return true
    }

    func sameType<U> (other: Foo<U>) -> Bool {
        return false
    }

如果你混合Swift和Objective-C或者由于其他原因不得不依赖于动态类型，这可能会有意想不到的结果：

import Foundation
let x = NSArray(object: 1)
let y = NSArray(object: "string")
sameType(Foo(v: x[0]),Foo(v: y[0])) // true

结果是真的，因为因为Foo(v：x [0])具有类型Foo< AnyObject>

@H_404_47@ 原文链接：https://www.f2er.com/swift/320890.html

猜你在找的Swift相关文章