The as keyword used to do both upcasts and downcasts:

// Before Swift 1.2var aView: UIView = someView()var object = aView as NSObject // upcast var specificView = aView as UITableView // downcast

The upcast, going from a derived class to a base class, can be checked at compile time and will never fail.

However, downcasts can fail since you can’t always be sure about the specific class. If you have a UIView, it’s possible it’s a UITableView or maybe a UIButton. If your downcast goes to the correct type – great! But if you happen to specify the wrong type, you’ll get a runtime error and the app will crash.

In Swift 1.2, downcasts must be either optional with as? or “forced failable” with as!. If you’re sure about the type, then you can force the cast with as! similar to how you would use an implicitly-unwrapped optional:

// After Swift 1.2var aView: UIView = someView()var tableView = aView as! UITableView

The exclamation point makes it absolutely clear that you know what you’re doing and that there’s a chance things will go terribly wrong if you’ve accidentally mixed up your types!

As always, as? with optional binding is the safest way to go:

// This isn't new to Swift 1.2, but is still the safest wayvar aView: UIView = someView()if let tableView = aView as? UITableView {  // do something with tableView}

Got this from a site: SOURCE

as

In Swift 1.2 and later, as can only be used for upcasting (or disambiguation) and pattern matching:

// 'as' for disambiguationlet width = 42 as CGFloatlet block = { x in x+1 } as Double -> Doublelet something = 3 as Any?  // optional wrapper can also be added with 'as'

// 'as' for pattern matchingswitch item {case let obj as MyObject:    // this code will be executed if item is of type MyObjectcase let other as SomethingElse:    // this code will be executed if item is of type SomethingElse...}

as?

The conditional cast operator as? tries to perform a conversion, but returns nil if it can't. Thus its result is optional.

let button = someView as? UIButton  // button's type is 'UIButton?'if let label = (superview as? MyView)?.titleLabel {    // ...}

as!

The as! operator is for forced type conversion.

Use the forced form of the type cast operator (as!) only when you are sure that the downcast will always succeed. This form of the operator will trigger a runtime error if you try to downcast to an incorrect class type.

// 'as!' for forced conversion.// NOT RECOMMENDED.let buttons = subviews as! [UIButton]  // will crash if not all subviews are UIButtonlet label = subviews.first as! UILabel

The correct idiom that should do exactly what you want (in all versions of Swift at least upto and including 1.2) is the as? optional cast.

if let width = imageDetails["width"] as? Int

The optional cast returns an optional (Int? in this case) and is tested at runtime. Your original code probably forced a cast to the optional type.