模式匹配和类型转换之间的区别

Question

my understanding is that the 'as?' and 'as!' operators are for downcasting and 'as' for upcasting, disambiguation, bridging, and pattern matching. But during pattern matching, the 'thing' of type 'any' is converted and dowoncasted to — for example — someInt as Int. why is the syntax not 'as?' instead of 'as' ? I'm confused why pattern matching is differentiated from type casting in this case?

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({ (name: String) -> String in "Hello, \(name)" })

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 stringConverter as (String) -> String:
        print(stringConverter("Michael"))
    default:
        print("something else")
}
}

Answer 1

In the pattern-matching switch statement, a case is only accessed if thing 's type matches the type specified in that case . The corresponding cast cannot fail (otherwise you wouldn't be in that case ) so you don't need to worry about unwrapping the cast with as? or as! .