type(of:)

Return Value 戻り値

The dynamic type, which is a metatype instance. 動的型、それはメタタイプインスタンスです。

Discussion 解説

You can use the type(of:) function to find the dynamic type of a value, particularly when the dynamic type is different from the static type. The static type of a value is the known, compile-time type of the value. The dynamic type of a value is the value’s actual type at run-time, which can be a subtype of its concrete type. あなたは、type(of:)を使うことである値の動的型を見つけることができます、とりわけ動的型が静的型と異なる場合に。ある値の静的型は、既知の、コンパイル時のその値の型です。ある値の動的型は、その値の実行時での実際の型です、それはそれの具象型の下位型であることができます。

In the following code, the count variable has the same static and dynamic type: Int. When count is passed to the printInfo(_:) function, however, the value parameter has a static type of Any (the type declared for the parameter) and a dynamic type of Int. 以下のコードにおいて、count変数は同じ静的および動的型：Intを持ちます。countがprintInfo(_:)関数に渡される場合は、しかしながら、valueパラメータはAnyの静的型（このパラメータに対して宣言された型）そしてIntの動的型を持ちます。

func printInfo(_ value: Any) {
    let t = type(of: value)
    print("'\(value)' of type '\(t)'")
}


let count: Int = 5
printInfo(count)
// '5' of type 'Int'

The dynamic type returned from type(of:) is a concrete metatype (T.Type) for a class, structure, enumeration, or other nonprotocol type T, or an existential metatype (P.Type) for a protocol or protocol composition P. When the static type of the value passed to type(of:) is constrained to a class or protocol, you can use that metatype to access initializers or other static members of the class or protocol. type(of:)から返される動的型は、クラス、構造体、列挙、または他の非プロトコル型Tに対して具象メタタイプ（T.Type）、またはプロトコルやプロトコル合成Pに対して存在メタタイプ（P.Type）です。type(of:)に渡される値の静的型があるクラスまたはプロトコルに制約される場合、あなたはそのメタタイプを使うことでイニシャライザやそのクラスまたはプロトコルの他の静的メンバーにアクセスできます。

For example, the parameter passed as value to the printSmileyInfo(_:) function in the example below is an instance of the Smiley class or one of its subclasses. The function uses type(of:) to find the dynamic type of value, which itself is an instance of the Smiley.Type metatype. 例えば、下の例においてvalueとしてprintSmileyInfo(_:)関数に渡されるパラメータは、Smileyクラスまたはそれのサブクラスの１つのインスタンスです。この関数は、type(of:)を使ってvalueの動的型を見つけます、それはそれ自身がSmiley.Typeメタタイプのインスタンスです。

class Smiley {
    class var text: String {
        return ":)"
    }
}


class EmojiSmiley: Smiley {
     override class var text: String {
        return "😀"
    }
}


func printSmileyInfo(_ value: Smiley) {
    let smileyType = type(of: value)
    print("Smile!", smileyType.text)
}


let emojiSmiley = EmojiSmiley()
printSmileyInfo(emojiSmiley)
// Smile! 😀

In this example, accessing the text property of the smileyType metatype retrieves the overridden value from the EmojiSmiley subclass, instead of the Smiley class’s original definition. この例において、smileyTypeメタタイプのtextプロパティにアクセスすることは、EmojiSmileyサブクラスからオーバーライドされた値を取って来ます、Smileyクラスのもつ元の定義ではなく。

Finding the Dynamic Type in a Generic Context 総称体の文脈において動的型を見つける

Normally, you don’t need to be aware of the difference between concrete and existential metatypes, but calling type(of:) can yield unexpected results in a generic context with a type parameter bound to a protocol. In a case like this, where a generic parameter T is bound to a protocol P, the type parameter is not statically known to be a protocol type in the body of the generic function. As a result, type(of:) can only produce the concrete metatype P.Protocol. 通常、あなたは具象と存在のメタタイプの間の違いを意識する必要はありません、しかしtype(of:)を呼び出すことは、あるプロトコルに束縛された型パラメータを伴うある総称体の文脈において予期しない結果を生み出すことができます。このような場合において、総称体パラメータTがプロトコルPに束縛されるところでは、その型パラメータは、プロトコル型であることを総称体関数の本文において静的に知られません。結果として、type(of:)は具象メタタイプP.Protocolを生成することだけが可能です。

The following example defines a printGenericInfo(_:) function that takes a generic parameter and declares the String type’s conformance to a new protocol P. When printGenericInfo(_:) is called with a string that has P as its static type, the call to type(of:) returns P.self instead of String.self (the dynamic type inside the parameter). 以下の例は、printGenericInfo(_:)関数を定義します、それは総称体パラメータを取り、String型のもつ準拠を新しいプロトコルPに宣言します。printGenericInfo(_:)が、Pをそれの静的型として持つ文字列とともに呼ばれる時、type(of:)への呼び出しはP.selfを返します、String.self（パラメータの内部の動的型）ではなく。

func printGenericInfo<T>(_ value: T) {
    let t = type(of: value)
    print("'\(value)' of type '\(t)'")
}


protocol P {}
extension String: P {}


let stringAsP: P = "Hello!"
printGenericInfo(stringAsP)
// 'Hello!' of type 'P'

This unexpected result occurs because the call to type(of: value) inside printGenericInfo(_:) must return a metatype that is an instance of T.Type, but String.self (the expected dynamic type) is not an instance of P.Type (the concrete metatype of value). To get the dynamic type inside value in this generic context, cast the parameter to Any when calling type(of:). この予期しない結果は、type(of: value)への呼び出しがprintGenericInfo(_:)内部において、T.Typeのインスタンスであるメタタイプを返さなければならない、しかしString.self（期待された動的型）はP.Type（valueの具象メタタイプ）のインスタンスでないことから起こります。value内部の動的型をこの総称体の文脈において得るには、このパラメータをAnyへとtype(of:)を呼び出す時にキャストしてください。

func betterPrintGenericInfo<T>(_ value: T) {
    let t = type(of: value as Any)
    print("'\(value)' of type '\(t)'")
}


betterPrintGenericInfo(stringAsP)
// 'Hello!' of type 'String'