在 Swift 的编程世界里，不透明返回类型是一个挺有用的特性。下面咱就好好唠唠它的应用场景。
一、不透明返回类型是什么
简单来说，不透明返回类型就是在函数返回值那，不直接告诉别人返回的具体类型，而是用一个协议或者有特定规则的描述来表示。就好比咱去抽奖，奖品盒外面包着纸，我们只知道大概是个啥东西（符合某个条件），但不知道具体是啥。
先看个示例，用 Swift 技术栈：
// Swift 技术栈
// 定义一个 Shape 协议，包含一个描述属性
protocol Shape {
var description: String { get }
}
// 定义一个 Circle 结构体，遵循 Shape 协议
struct Circle: Shape {
var radius: Double
var description: String {
return "我是一个半径为 \(radius) 的圆"
}
}
// 定义一个 Square 结构体，遵循 Shape 协议
struct Square: Shape {
var sideLength: Double
var description: String {
return "我是一个边长为 \(sideLength) 的正方形"
}
}
// 定义一个返回不透明类型的函数，返回值符合 Shape 协议
func getRandomShape() -> some Shape {
if Bool.random() {
return Circle(radius: Double.random(in: 1...10))
} else {
return Square(sideLength: Double.random(in: 1...10))
}
}
// 调用函数获取随机形状并打印描述
let randomShape = getRandomShape()
print(randomShape.description)
在这个示例里，getRandomShape 函数返回的是 some Shape，这就是不透明返回类型。调用者只知道返回的东西符合 Shape 协议，但不知道具体是 Circle 还是 Square。
二、应用场景
1. 隐藏实现细节
有时候，我们写的代码不想让别人知道具体的实现类型，就可以用不透明返回类型。比如，我们开发一个图形绘制库，里面有很多不同的图形类，但我们只想让用户知道能拿到一个可以绘制的图形，而不想让他们知道具体是哪个图形类。
// Swift 技术栈
// 定义一个 Drawable 协议，包含一个 draw 方法
protocol Drawable {
func draw()
}
// 定义一个 Triangle 结构体，遵循 Drawable 协议
struct Triangle: Drawable {
func draw() {
print("绘制一个三角形")
}
}
// 定义一个 Pentagon 结构体，遵循 Drawable 协议
struct Pentagon: Drawable {
func draw() {
print("绘制一个五边形")
}
}
// 定义一个返回不透明类型的函数，返回值符合 Drawable 协议
func getDrawableShape() -> some Drawable {
if Bool.random() {
return Triangle()
} else {
return Pentagon()
}
}
// 调用函数获取可绘制形状并调用 draw 方法
let drawableShape = getDrawableShape()
drawableShape.draw()
在这个例子中，调用 getDrawableShape 函数的人只知道能拿到一个可绘制的形状，但不知道具体是 Triangle 还是 Pentagon，这样就隐藏了实现细节。
2. 简化泛型代码
在一些泛型代码里，返回类型可能很复杂，用不透明返回类型可以让代码更简洁。比如，我们有一个函数，根据不同条件返回不同类型的数组，但这些数组元素都遵循同一个协议。
// Swift 技术栈
// 定义一个 Animal 协议，包含一个 makeSound 方法
protocol Animal {
func makeSound()
}
// 定义一个 Dog 结构体，遵循 Animal 协议
struct Dog: Animal {
func makeSound() {
print("汪汪汪")
}
}
// 定义一个 Cat 结构体，遵循 Animal 协议
struct Cat: Animal {
func makeSound() {
print("喵喵喵")
}
}
// 定义一个返回不透明类型的函数，返回值是符合 Animal 协议的数组
func getAnimalGroup() -> some Collection<Animal> {
if Bool.random() {
return [Dog(), Dog()]
} else {
return [Cat(), Cat()]
}
}
// 调用函数获取动物组合并遍历调用 makeSound 方法
let animalGroup = getAnimalGroup()
for animal in animalGroup {
animal.makeSound()
}
在这个示例中，getAnimalGroup 函数返回的是 some Collection<Animal>，不用去管具体是 [Dog] 还是 [Cat] 数组，简化了代码。
3. 实现协议组合的返回值
当我们需要返回一个同时符合多个协议的对象时，不透明返回类型就很方便。
// Swift 技术栈
// 定义一个 Printable 协议，包含一个 printInfo 方法
protocol Printable {
func printInfo()
}
// 定义一个 Savable 协议，包含一个 save 方法
protocol Savable {
func save()
}
// 定义一个 DataObject 结构体，遵循 Printable 和 Savable 协议
struct DataObject: Printable, Savable {
func printInfo() {
print("打印数据对象信息")
}
func save() {
print("保存数据对象")
}
}
// 定义一个返回不透明类型的函数，返回值同时符合 Printable 和 Savable 协议
func getPrintableAndSavable() -> some (Printable & Savable) {
return DataObject()
}
// 调用函数获取对象并调用方法
let printableSavable = getPrintableAndSavable()
printableSavable.printInfo()
printableSavable.save()
这里，getPrintableAndSavable 函数返回的是同时符合 Printable 和 Savable 协议的对象，不透明返回类型让这种组合实现起来很容易。
三、技术优缺点
优点
1. 封装性好
就像前面说的隐藏实现细节，使用不透明返回类型可以很好地把具体的实现类型封装起来，别人只能用符合协议的功能，而看不到具体的类型。这样可以避免别人依赖具体的类型，让我们的代码在后续修改具体实现时更加灵活。
2. 代码简洁
在处理复杂的泛型和组合返回值时，不透明返回类型能让代码变得更简洁。不需要在函数签名里写一堆复杂的类型信息，调用者也更容易理解函数的用途。
缺点
1. 类型受限
不透明返回类型只能在函数返回值处使用，不能用于变量声明等其他地方。这就限制了它的使用范围，有些场景下可能就没办法用它来解决问题。
2. 调试难度增加
由于不知道具体的返回类型，在调试的时候可能会有点麻烦。如果出现了问题，很难直接定位到具体的类型上。
四、注意事项
1. 一致性原则
在使用不透明返回类型时，同一个函数的多次调用返回的具体类型可以不同，但这些类型必须都符合返回值声明的协议。比如前面的 getRandomShape 函数，无论返回 Circle 还是 Square，它们都要符合 Shape 协议。
2. 不要滥用
虽然不透明返回类型有很多优点，但也不要滥用。如果在不需要隐藏实现细节的地方使用，会让代码变得不必要的复杂。一定要根据实际的需求来决定是否使用。
五、文章总结
不透明返回类型是 Swift 里一个很有用的特性，它在隐藏实现细节、简化泛型代码和实现协议组合返回值等方面都有很好的应用。通过使用不透明返回类型，我们可以提高代码的封装性和简洁性。但同时，它也有一些缺点，比如类型受限和增加调试难度。在使用的时候，我们要遵循一致性原则，并且不要滥用。只要合理运用，不透明返回类型能让我们的 Swift 代码更加优雅和健壮。
评论