在Swift中展开两种类型之一

我有一个方法，它对Swift中的两种类型的数据执行完全相同的操作

为了保持简单（并且不复制方法），我将

AnyObject

作为参数传递给我的方法，它可以是这两种类型中的任何一种。如何使用

|

（或）语句将其展开，以便继续？或者这样做了

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
    }

}

func myFunc（数据：AnyObject）{
如果让数据=数据为？类型一{
//这很好用。但我需要它看起来像下面的展开
}
如果让data=data作为？TypeOne | |让data=data作为？TypeTwo{/您不能统一同一事物的两个不同类型转换。您必须将它们分开，因为它们是对两个不同类型的两个不同类型的转换，编译器需要以两种不同的方式处理

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
}

如果您有一种向同一方法传递字符串或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) {

但问题是，您还没有接近执行实际的强制转换。强制转换仍然必须单独执行。
基于Clashsoft的评论，我认为协议是解决问题的方法。您可以在协议中表示两种类型都符合的所需功能，而不是传入任何对象并展开

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

我在操场上模拟了一些代码，展示了这是如何工作的

希望它能有所帮助

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))

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

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.
    }
}

你是说像这样

enum IntOrString{
案例int（值：int）
大小写字符串（值：string）
}
func parseInt（str:String）->IntOrString{
如果让intValue=Int（str）{
返回IntOrString.int（值：intValue）
}
返回IntOrString.string（值：str）
}
开关parseInt（“123”）{
case.int（let值）：
打印（“整数值\（数值）”）
case.string（let值）：
打印（“字符串值\（值）”）
}
开关parseInt（“abc”）{
case.int（let值）：
打印（“整数值\（数值）”）
case.string（let值）：
打印（“字符串值\（值）”）
}

输出：

int value 123
string value abc

不，这不是小菜一碟。假设你的第二个演员阵容正常。现在你怎么知道
数据
是
TypeOne
还是
TypeTwo
？最好使用
如果TypeOne{}或者如果TypeTwo{/code>，这就是为什么我问是否有“或”
| |
。两种类型中的任何一种都可以通过，这应该足以继续..但从下面的一些答案中，我看到可能没有“或”：）也许你应该重新考虑你的设计。在OO中，类型检查和强制转换被认为是代码的味道，应该避免。例如，你可以为这两种类型引入一个通用的协议。是的，在这种情况下，switch工作得更好，这样我就可以重用unwrapped变量。谢谢！
var x=“howdy”在我看来，这太可怕了，因为你正在将你的类型连接到一个Objc类型，并试图将它与标准的swift类型相匹配。当然它能做到这一点，但我仍然希望我们能尽快摆脱Objc的东西，使用纯swift。
println
是如此2014…）@JoshuaKaden他们在使用swift 2.0！
println
已经死了！：）