Swift-元类型有什么区别。类型和自我？

Question

元类型之间有什么区别。键入和。Swift中的self？

做. Self和。类型返回一个结构？

我知道. Self可以用来检查DynamicType。你如何使用。类型？

Answer 1

它们在句法上出现在不同的地方。

在语法上必须指定类型的地方，Type是一个有效的类型，对应于类型是元类型（类的元类）。

在一个语法上必须编写表达式的地方，Something。self是一个有效的表达式。这是一个类型的表达式。类型，值是表示类型某物的对象（“类对象”）<代码>什么。类型不是有效的表达式语法。

Answer 2

首先也是最重要的一点，请参见苹果文档的type（of:）

函数签名很有趣：

func type<T, Metatype>(of value: T) -> Metatype

在哪里使用？

如果您正在编写/创建接受类型的函数，例如UIView。键入，而不是实例，例如，UIView（），然后将T.Type作为参数的类型写入。它所期望的参数可以是：String。self，自定义表格视图。self，其他类。self。

通常，需要类型的函数是为您实例化对象的函数。我可以想出两个很好的例子：

1. 从tableview注册函数

tableView.register(CustomTableViewCell.self, forCellReuseIdentifier: "CustomTableViewCell")

请注意，您传递了CustomTableViewCell.self。如果稍后您尝试退出类型为CustomTableViewCell的tableView，但没有注册CustomTableViewCell类型，那么它将崩溃，因为tableView没有退出/实例化任何CustomTableViewCell类型的tableviewcell。

struct GroceryProduct: Codable {
    var name: String
    var points: Int
    var description: String?
}

let json = """
{
    "name": "Durian",
    "points": 600,
    "description": "A fruit with a distinctive scent."
}
""".data(using: .utf8)!

let decoder = JSONDecoder()
let product = try decoder.decode(GroceryProduct.self, from: json)

print(product.name)

注意尝试decoder.decode（GroceryProduct.self，来自：json）。因为您传递了GroceryProduct.self，所以它知道需要实例化类型为GroceryProducts的对象。如果不能，那么它会抛出一个错误。有关JSONDecoder的更多信息，请参阅这个写得很好的答案

有关内部结构及其工作原理的更多信息：

类、结构或枚举类型的元类型是该类型的名称后跟。类型协议类型的元类型（不是在运行时符合协议的具体类型）是该协议的名称，后跟。协议例如，类类型SomeClass的元类型是SomeClass。类型和协议的元类型SomeProtocol是SomeProtocol。协议。

_{来自Apple:metaType}

发动机罩下AnyClass为

typealias AnyClass = AnyObject.Type // which is why you see T.Type 

基本上，无论你在哪里看到AnyClass，Any。键入，任何对象。类型，因为它需要一个类型。当我们想使用registerfunc为tableView注册一个类时，我们会看到一个非常常见的地方。

func register(_ cellClass: Swift.AnyClass?, forCellReuseIdentifier identifier: String)

_{如果您不清楚“Swift”是什么意思执行上述操作，然后查看此处的评论}

上述内容也可以写成：

func register(_ cellClass: AnyObject.Type, forCellReuseIdentifier identifier: String)

可以使用后缀自表达式以值的形式访问类型。例如，某些lass.self返回某些类本身，而不是某个类的实例。而且rotocol.self返回的是某些协议本身，而不是在运行时符合某些协议的类型的实例。您可以将type（of：）表达式与类型的实例一起使用，以作为值访问该实例的动态运行时类型，如以下示例所示：

_{来自Apple:metaType}

游乐场代码：

简单的例子

struct Something {
    var x = 5
}

let a = Something()
type(of:a) == Something.self // true

艰难的例子

class BaseClass {
    class func printClassName() {
        print("BaseClass")
    }
}
class SubClass: BaseClass {
    override class func printClassName() {
        print("SubClass")
    }
}


let someInstance: BaseClass = SubClass()
/*                      |                |
                    compileTime       Runtime
                        |                | 
To extract, use:       .self          type(of)
 
  Check the runtime type of someInstance use `type(of:)`: */

print(type(of: someInstance) == SubClass.self) // True
print(type(of: someInstance) == BaseClass.self) // False

 /* Check the compile time type of someInstance use `is`: */

print(someInstance is SubClass) // True
print(someInstance is BaseClass) // True

我强烈建议阅读类型上的苹果留档。也看到这里

Answer 3

下面是一个简单的例子：

func printType<T>(of type: T.Type) {
    // or you could do "\(T.self)" directly and
    // replace `type` parameter with an underscore
    print("\(type)") 
} 

printType(of: Int.self) // this should print Swift.Int


func printInstanceDescription<T>(of instance: T) {
    print("\(instance)")
} 

printInstanceDescription(of: 42) // this should print 42

假设每个实体由两个东西表示：

>

元类型：#实体名称#。类型

元类型是指任何类型的类型，包括类类型、结构类型、枚举类型和协议类型。

来源。

您可以很快注意到，这是递归的，并且可以通过（（T.Type））之类的类型执行。类型）。类型）等。

。Type返回元类型的实例。

有两种方法可以获取元类型的实例：

>

在一个具体类型上调用. Self，如Int.self，这将创建一个静态元类型实例Int。类型。

从任何实例通过type（of：某物实例）获取动态元类型实例。

危险区域：

struct S {}
protocol P {}

print("\(type(of: S.self))")      // S.Type
print("\(type(of: S.Type.self))") // S.Type.Type
print("\(type(of: P.self))")      // P.Protocol
print("\(type(of: P.Type.self))") // P.Type.Protocol

。协议是另一种仅存在于协议上下文中的元类型。也就是说，我们无法表达我们只想要P.Type。这会阻止所有通用算法使用协议元类型，并可能导致运行时崩溃。

对于更多好奇的人：

由于不一致性，类型（of:）函数实际上由编译器处理。协议创建。

// This implementation is never used, since calls to `Swift.type(of:)` are
// resolved as a special case by the type checker.
public func type<T, Metatype>(of value: T) -> Metatype { ... }