Swift 何时使用typealias？

到目前为止，我了解到typealias是现有类型的命名别名。通过使用typealias，我可以执行以下操作：

typealias MyString = String
var str: MyString?

typealias Strings = [String]
var strs: Strings?

这导致将

str

变量声明为字符串，将

strs

声明为字符串数组

即使对于自定义类型：

class MyClass {}
typealias MyClsType = MyClass
var myClass: MyClsType

---

然而，它似乎有点无用；从逻辑上讲，例如将

var str:MyString？

声明为字符串而不是

var str:String？

的目的是什么？更重要的是，

var str:String

更具表现力。

事实上，毫无疑问，为-String:

typealias MyString=String

创建一个typealias是没有用的，（我还假设为Dictionary声明一个具有特定键/值类型的typealias:

typealias CustomDict=Dictionary

可能对您没有多大用处

但是，在使用时，您肯定会注意到类型别名的好处

示例：

假设您正在实现一个manager，它在函数中反复使用具有许多参数的闭包：

class MyManager {
    //...

    func foo(success: (_ data: Data, _ message: String, _ status: Int, _ isEnabled: Bool) -> (), failure: (_ error: Error, _ message: String, _ workaround: AnyObject) -> ()) {
        if isSuccess {
            success(..., ..., ..., ...)
        } else {
            failure(..., ..., ...)
        }
    }

    func bar(success: (_ data: Data, _ message: String, _ status: Int, _ isEnabled: Bool) -> (), failure: (_ error: Error, _ message: String, _ workaround: AnyObject) -> ()) {
        if isSuccess {
            success(..., ..., ..., ...)
        } else {
            failure(..., ..., ...)
        }
    }

    // ...
}

如您所见，方法签名看起来非常乏味！这两种方法都使用

success

和

failure

参数，它们都是带参数的闭包；而且，对于实现类似的函数，保留复制粘贴参数也不太合理

为这种情况实施

typealias

非常合适：

class MyManager {
    //...

    typealias Success = (_ data: Data, _ message: String, _ status: Int, _ isEnabled: Bool) -> ()
    typealias Failure = (_ error: Error, _ message: String, _ workaround: AnyObject) -> ()

    func foo(success: Success, failure: Failure) {
        if isSuccess {
            success(..., ..., ..., ...)
        } else {
            failure(..., ..., ...)
        }
    }

    func bar(success: Success, failure: Failure) {
        if isSuccess {
            success(..., ..., ..., ...)
        } else {
            failure(..., ..., ...)
        }
    }

    // ...
}

因此，它将更具表现力和可读性。

---

此外，您可能需要查看我发布的关于它的信息。

我使用typealias的常用方法是使用闭包：

typealias VoidClosure=（）->Void

---

func updateFrom（completion:@escaping VoidClosure）{}

这里有一个实用的例子：不仅对于闭包，提到“复合类型”更准确。你可以在我的答案中检查复合类型的链接，查看它的含义（类型）@AhmadF是的。我完全同意你的看法。当一些复杂的类型参数出现时，它使代码更容易阅读。

typealias

，因为

字符串

可能有用：-为读者提供语义含义：

let result:Token

而不是

let result:String

会更有意义。-如果你如果决定从原始值迁移到自定义类型，类型别名将指导您。例如，如果

标记

成为

结构

，那么编译器将告诉您使用的位置。将

类型别名

更改为

结构

后的第一次编译将按原样编译！我现在也处于同样的困境。有一大堆长泛型类型，如

Results

到

Results

（以

ObjcX

为例）和一些具有类似形式的词典：

[ObjA:[ObjB]]

使用诸如ObjAQueryResult或ObjAObjBMapping这样的名称更有意义，因为只需输入更少的代码。但是，我觉得当另一个开发人员接管时，在查找每个类型别名时会有额外的认知负荷，不管它有多小，至少在它们被用于代码的这个特定部分之前是如此，这部分代码已经是c反正是复杂的。