Swift编译器为什么无法找出混合类型数组中元素的类型？

Question

Here's my code:

let string: String = "hello"
let int: Int = 5
let double: Double = 3.14

let mixedTypeArray = [string, int, double]
let elementOfApparentlyUnknownType = mixedTypeArray[0] // AnyObject

I've very explicitly stated the types of each element in the mixed-type array mixedTypeArray . However, when grabbing the first element in the array, the compiler doesn't infer the element to be a String . Instead, it's of type AnyObject .

mixedTypeArray is an NSArray , since Swift's native Array type doesn't allow storing elements of mixed types (unless they're all converted to AnyObject , but that would lose type information). But if NSArray is cool with storing elements of different types, why is mixedTypeArray[0] of type AnyObject ? Is NSArray converting all the elements to AnyObject behind the scenes? Is there any way to get the true type of mixedTypeArray[0] at compile time? I'd like to avoid individually downcasting each element in mixedTypeArray from AnyObject to its actual type.

Answer 1

Swift arrays only hold one type. In pure Swift code, your example wouldn't even compile. You would get the error: error: type of expression is ambiguous without more context .

You code is compiling because you have Foundation imported, either because you explicitly stated import Foundation , or because you imported UIKit or Cocoa each of which imports Foundation .

When Foundation is imported, mixed arrays are treated as NSArray which is essentially the same as [AnyObject] . This means anything that is put in that array has to be an instance of a class . Since String is a struct, and Int and Double are primitive types, they are not classes. The String gets promoted to NSString , and the Int and Double get wrapped in NSNumber .

You can see this if you print out the dynamicTypes of the values:

print(mixedTypeArray[0].dynamicType)  // _NSContiguousString
print(mixedTypeArray[1].dynamicType)  // __NSCFNumber.Type
print(mixedTypeArray[2].dynamicType)  // __NSCFNumber.Type

_NSContiguousString is an internal representation of an NSString . __NSCFNumber.Type is an internal representation of NSNumber .

But the array itself only holds one type: AnyObject .

When you do:

let elementOfApparentlyUnknownType = mixedTypeArray[0] // AnyObject

then the value has the type AnyObject because that is what the array is storing. Swift does not look to see that the item is really an NSString because that is a runtime consideration. At compile time, Swift is not tracking that you put a String in position 0 of that array. It only knows that that array has a type of NSString (also known as [AnyObject] ).

The types of variables are known at compile time in Swift. At any time, you can Option -click on any variable to see its type. For this reason, the best Swift can do is make your variable AnyObject because at compile time it doesn't know the underlying types of the values in your array.

You could have declared your array to be of type [Any] and then the dynamicTypes of your values would have remained String , Int , and Double . But then, any array access would have yielded a variable of type Any .

Swift will not infer an array to be of type [Any] . It will only give you that if you explicitly ask for it. As a general design rule, if you find yourself using Any , you probably are approaching the problem in the wrong way.

Answer 2

In Swift, all array elements must have the same type. In this case, all the array elements have type Any (not AnyObject, because you supplied one value of type Int). The first array element is of type Any, not of type String. The second is of type Any, not of type Int. And so on.