Question

我有一个方法可以对Swift中的两种数据执行完全相同的操作。

为了简单起见（并且没有重复方法），我将AnyObject作为参数传递给我的方法，该方法可以是这两种类型中的任何一种。如何用||（OR）语句打开它以便我可以继续？或者可能这样做了吗？

func myFunc(data:AnyObject) {

    if let data = data as? TypeOne {
        // This works fine. But I need it to look something like unwrapping below
    }

    if let data = data as? TypeOne || let data = data as? TypeTwo { // <-- I need something like this
        // Do my stuff here, but this doesn't work
    }

}

我确信这在Swift中是微不足道的，我无法弄清楚如何让它工作。

Answer 1

你无法统一同一事物的两个不同演员阵容。你必须将它们分开，因为它们是两种不同的类型转换为两种不同的类型，编译器需要以两种不同的方式处理它们。

var x = "howdy" as AnyObject
// x = 1 as AnyObject

// so x could have an underlying String or Int
switch x {
case let x as String:
    print(x)
case let x as Int:
    print(x)
default: break
}

如果你有办法将String或Int传递给它，你可以在这两种不同的情况下调用相同的方法;但这是你能做的最好的事情。

func printAnything(what:Any) {
    print(what)
}
switch x {
case let x as String:
    printAnything(x)
case let x as Int:
    printAnything(x)
default: break
}

当然你可以问

if (x is String || x is Int) {

但问题是你没有接近执行实际的演员。演员阵容仍然必须单独进行。

Answer 2

基于Clashsoft的评论，我认为协议是这里的方式。您可以在两种类型符合的协议中表示所需的功能，而不是传入AnyObject并解包。

这应该使代码更易于维护，因为您需要针对特定行为而不是特定类进行编码。

我在操场上嘲笑了一些代码，显示了它是如何工作的。

希望它会有所帮助！

protocol ObjectBehavior {
    var nickname: String { get set }
}

class TypeOne: ObjectBehavior {
    var nickname = "Type One"
}

class TypeTwo: ObjectBehavior {
    var nickname = "Type Two"
}

func myFunc(data: ObjectBehavior) -> String {
    return data.nickname
}

let object1 = TypeOne()
let object2 = TypeTwo()

println(myFunc(object1))
println(myFunc(object2))

Answer 3

查找两种类型的共享代码是否完全相同。如果是的话：

protocol TypeOneOrTypeTwo {}

extension TypeOneOrTypeTwo {

    func thatSharedCode() {

        print("Hello, I am instance of \(self.dynamicType).")
    }
}

extension TypeOne: TypeOneOrTypeTwo {}
extension TypeTwo: TypeOneOrTypeTwo {}

如果不是：

protocol TypeOneOrTypeTwo {

    func thatSharedMethod()
}

extension TypeOne: TypeOneOrTypeTwo {

    func thatSharedMethod() {

        // code here:
    } 
}

extension TypeTwo: TypeOneOrTypeTwo {

    func thatSharedMethod() {

        // code here:
    } 
}

你走了：

func myFunc(data: AnyObject) {

    if let data = data as? TypeOneOrTypeTwo {

        data.thatSharedCode() // Or `thatSharedMethod()` if your implementation differs for types.
    }
}

Answer 4

您的意思是这样吗？

enum IntOrString {
    case int(value: Int)
    case string(value: String)
}

func parseInt(_ str: String) -> IntOrString {
    if let intValue = Int(str) {
        return IntOrString.int(value: intValue)
    }
    return IntOrString.string(value: str)
}

switch parseInt("123") {
case .int(let value):
    print("int value \(value)")
case .string(let value):
    print("string value \(value)")
}

switch parseInt("abc") {
case .int(let value):
    print("int value \(value)")
case .string(let value):
    print("string value \(value)")
}

输出：

int value 123
string value abc

在Swift中打开两种类型中的任何一种

4 个答案: