[置顶] [swift] is & as、Any & AnyObject

is & as

是用于swift 的类型检测

用简单的话来说就是：

is 是判断某个实例是否是某种类型的子类型
as 用于类型转换， 将父类类型的实例转换成子类类型，

as? 试图向下转换，如果不能成功则返回nil
as!试图向下转换，并强制解包

class FatherClass {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class SubClassA: FatherClass {
    var proA: String
    init(name: String, proA: String) {
        self.proA = proA
        super.init(name: name)
    }
}

class SubClassB: FatherClass {
    var proB: String
    init(name: String, proB: String) {
        self.proB = proB
        super.init(name: name)
    }
}

let dic = [
    SubClassA(name: "One", proA: "A pro one"),
    SubClassA(name: "Two", proA: "A pro two"),
    SubClassB(name: "Three", proB: "B pro one"),
    SubClassA(name: "Four", proA: "A pro three"),
    SubClassA(name: "Five", proA: "A pro four")
]

for item in dic {
    if item is SubClassA {
        print("\(item.name) is SubClassA")
    } else if item is SubClassB {
        print("\(item.name) is SubClassB")
    }
}

//One is SubClassA
//Two is SubClassA
//Three is SubClassB
//Four is SubClassA
//Five is SubClassA

for item in dic {
    if let subClassA = item as? SubClassA {
        print("SubClassA: '\(subClassA.name)', proA. \(subClassA.proA)")
    } else if let subClassB = item as? SubClassB {
        print("SubClassB: '\(subClassB.name)', proB. \(subClassB.proB)")
    }
}

//SubClassA: 'One', proA. A pro one
//SubClassA: 'Two', proA. A pro two
//SubClassB: 'Three', proB. B pro one
//SubClassA: 'Four', proA. A pro three
//SubClassA: 'Five', proA. A pro four

Any & AnyObject

两种不确定类型

AnyObject可以代表任何class类型的实例。
Any可以表示任何类型，除了方法类型（function types）。

var things = [Any]()

things.append(0)
things.append(0.0)
things.append(42)
things.append(3.14159)
things.append("hello")
things.append((3.0, 5.0))
things.append(SubClassA(name: "Six", proA: "A pro five"))
things.append(SubClassB(name: "Seven", proB: "B pro two"))

for thing in things {
    switch thing {
    case 0 as Int:
        print("zero as an Int")
    case 0 as Double:
        print("zero as a Double")
    case let someInt as Int:
        print("an integer value of \(someInt)")
    case let someDouble as Double where someDouble > 0:
        print("a positive double value of \(someDouble)")
    case is Double:
        print("some other double value that I don't want to print")
    case let someString as String:
        print("a string value of \"\(someString)\"")
    case let (x, y) as (Double, Double):
        print("an (x, y) point at \(x), \(y)")
    case let subClassA as SubClassA:
        print("a subclass called '\(subClassA.name)', proA. \(subClassA.proA)")
    case let subClassB as SubClassB:
        print("a subclass called '\(subClassB.name)', proB. \(subClassB.proB)")
    default:
        print("something else")
    }
}

//zero as an Int
//zero as a Double
//an integer value of 42
//a positive double value of 3.14159
//a string value of "hello"
//an (x, y) point at 3.0, 5.0
//a subclass called 'Six', proA. A pro five
//a subclass called 'Seven', proB. B pro two

⚠️注意：在一个switch语句的case中使用强制形式的类型检查操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。