泛型：实质上就是不使用具体数据类型（例如 int、double、float 等），而是使用一种通用类型来进行程序设计的方法，该方法可以大规模的减少程序代码的编写量，让程序员可以集中精力用于业务逻辑的实现。
在OC中泛型通常用于以下情况：
class MyContainer<T> { private var list: [T] init(){ list = [T]() } func append(_ el: T) { list.append(el) } func last() -> T? { list.last } } func runTest() -> Void{ let container = MyContainer<String>() for c in "abcd" { container.append(String(c)) } if let el = container.last(){ print("last: \(el)") }else{ print("last: nil") } }
而在Swift中泛型同样可以用于函数，如下：
func equal<T: Equatable>(left lv: T, right rv: T) -> Bool{ return lv == rv } func runTest() -> Void{ _ = equal(left: 1, right: 1) // Int _ = equal(left: 1.0, right: 1.0) // Double _ = equal(left: "abc", right: "abc")// String }
some（Opaque Type）：不透明类型，它只能应用于“Any”、“AnyObject”、协议和/class类型，我们先不说它的作用，先看下面一个场景：
protocol Animal { func eat(food: String) func call() } struct Dog: Animal{ var name: String func eat(food: String) { print("\(name) 吃了 \(food)") } func call() { print("我是一只狗，我的名字叫：\(name)") } } struct Cat: Animal{ var name: String func eat(food: String) { print("\(name) 吃了 \(food)") } func call() { print("我是一只猫，我的名字叫：\(name)") } } struct Zoo{ func dog() -> Animal { Dog(name: "旺财") } func cat() -> Animal { Cat(name: "小花") } } func runTest() -> Void{ let zoo = Zoo() let dog = zoo.dog() dog.call() dog.eat(food: "骨头") let cat = zoo.cat() cat.call() cat.eat(food: "鱼") }
动物园里有小动物，猫和狗，从动物园中可以获取小动物，但是往往我们不希望返回具体的类，所以我们需要定义一个协议，从而返回这个协议即可，上面Zoo返回的小动物类型为Animal协议
这里都没问题，接下来的做法将会让你惊呆！
swift中可以在协议中添加关联类型，associatedtype：作为协议实现泛型的一种方式，可以在协议中预先定义一个占位符，实现协议的时候再确定这个占位符具体的类型。那么接下来我们在Animal协议中添加一个关联类型，用于定义动物的名字的类型。
protocol Animal { associatedtype NameType // 动物名字类型占位符，即：协议实现泛型的方式（我们可能不清楚这个动物的名字的类型是啥，所以这里需要定义一个泛型，让具体实现的动物类中自己决定） var name: NameType { get set } // 动物的名字属性，其类型为NameType泛型 func eat(food: String) func call() } struct Dog: Animal{ var name: String // 这里的name类型为String func eat(food: String) { print("\(name) 吃了 \(food)") } func call() { print("我是一只狗，我的名字叫：\(name)") } } struct Cat: Animal{ var name: [String] // 这里的name类型为[String]，它可能有多个名字 func eat(food: String) { print("\(name.joined(separator: ",")) 吃了 \(food)") } func call() { print("我是一只猫，我的名字叫：\(name.joined(separator: ","))") } }
好了，经过上面的改造，我们会发现，Zoo类中的dog和cat两个方法报错了，错误为：Protocol ‘Animal‘ can only be used as a generic constraint because it has Self or associated type requirements，从错误原因我们感到很尴尬，就因为我们的协议Animal添加了associated type ，就不能用于返回值类型了。
why！why！why！
我们都知道swift是类型严格的开发语言，并且支持类型推断，让我们来分析一下上面的原因。首先Animal增加了关联类型，相当于定义了一个泛型占位符，这就导致Animal的类型是不确定的，既然它是类型不确定的，那就不能推断出它的类型是什么，所以swift不允许这样的事情发生。
那这种情况我们该怎么办呢？
写过SwiftUI的都看到过这样的代码：
struct TestContentView: View { var body: some View { // 这里的some Text("Hello") } }
计算型属性body的类型为 some标示的 View协议的类型，我们知道View协议中同样也定义了associated type ，于是我们修改Zoo的两个方法如下：
struct Zoo{ func dog() -> some Animal { Dog(name: "旺财") } func cat() -> some Animal { Cat(name: ["小花", "多啦A梦"]) } }
我们在两个方法的返回值类型前添加了some关键字修饰，结果编译通过，程序完美运行。
到此我们大概应该知道了这个some得作用，应该就是用来确定Animal的具体类型的，通过some修饰的协议类型，是一种固定的、确定的类型，从而支持类型推断，那么接下来我们验证一下这个想法。
struct Zoo{ enum AnimalType { case dog case cat } func animal(type: AnimalType) -> some Animal { if type == .dog { return Dog(name: "旺财") } return Cat(name: ["小花", "多啦A梦"]) } }
我们定义了一个animal的方法，通过传入动物的类型，返回对应的动物，此时你会看到编译错误：Function declares an opaque return type, but the return statements in its body do not have matching underlying types
从错误信息中可以看出，编译器无法推断出Animal的具体类型，因为在这个函数体内，增加了条件判断，返回了不同类型的动物，它无法推断出Animal的name属性到底是什么类型的。
到这里，我们可以知道，我们上面的推断是正确的。也就是说，some修饰的类型，必须在方法体内就是确认的、固定的，不能存在多种类型的关联类型。
针对这种情况我们在编写SwiftUI的时候，有些同学应该也遇到过，如下：
struct ContentView: View { var body: some View { if #available(iOS 14.0, *) { return LazyHStack(alignment: .center, spacing: 10) { Text("Lazy H Stack") } } else { return HStack(alignment: .center, spacing: 10) { Text("H Stack") } } } }
这里同样也报了错误：Function declares an opaque return type, but the return statements in its body do not have matching underlying types
解决办法就是要确保我们返回的是同一个类型，像ContentView，这里我们可以这样做：
struct ContentView: View { var body: some View { if #available(iOS 14.0, *) { return AnyView(LazyHStack(alignment: .center, spacing: 10) { Text("Lazy H Stack") }) } else { return AnyView(HStack(alignment: .center, spacing: 10) { Text("H Stack") }) } } }
我们在LazyHStack和HStack上包了一层AnyView，AnyView是A type-erased （类型擦除）view，将被包裹的视图的类型擦除掉，从而实现类型的统一。我们通过AnyView的原理，就可以解决我们的例子中的问题。
首选我们需要新建一个AnyAnimal的类，该类必须同样实现Animal协议
struct AnyAnimal: Animal{ private typealias Func1 = (String) -> Void private typealias Func2 = () -> Void private let eat: Func1 private let _call: Func2 var name: String = "AnyAnimal" init<T>(_ _animal: T) where T: Animal{ eat = { food in _animal.eat(food: food) } _call = { _animal.call() } } func eat(food: String) { eat(food) } func call() { _call() } }
然后调整我们Zoo的方法
struct Zoo{ enum AnimalType { case dog case cat } func animal(type: AnimalType) -> some Animal { if type == .dog { return AnyAnimal(Dog(name: "旺财")) } return AnyAnimal(Cat(name: ["小花", "多啦A梦"])) } }
返回的类型统一由AnyAnimal包装，这样编译通过，运行完美。好了，我通过举了一个动物园中的动物这个例子，介绍了泛型与some的区别，虽然有点牵强，但大体意思是表达出来了，大家可以慢慢体会。