成为 Swift 泛型的高阶玩家（附实战适配 Demo）

作者: 灵度Ling | 来源:发表于2017-10-07 15:22 被阅读1168次

我们之前多的是，去定义某一个类型的对象、定义某一个功能型函数，有试过定义对象族、函数族？而所谓泛型编程，即我们将所需定义的对象和函数抽象出来，极大拓宽了使用场景，减少代码的冗余！其实，我们可能没有定义过泛型函数，但肯定有使用过 Swift 标准库中的泛型函数：map()、filter()、reduce()。而这些泛型函数，众所周知，应用场合极大，基本可以作用于任何参数类型。而我们平时使用最多的 Array 和 Dictionary 也都是泛型集合，我们可以向这两个集合传输基本任何类型的值，而输出的类型也由我们输入的类型确定，这也是泛型的一大特性。
而这篇文章将会结合一个使用泛型编程的适配工具来谈谈泛型的高阶玩法。

悬念： 我们希望如下图般的，在不同尺寸的设备适配不同的封面图及文本。

效果图

而且，我们期望效果代码越简单越好，可读性越高越好，像下面一样就能达到效果：

ScreenFeatureManager.shared
.adapt(toDevice: .iPhone(inch35: 30, inch40: 40, inch47: 50, inch55: 60))

那么，我们该怎么做呢？在此之前，先介绍下即将使用到的泛型函数。

Swift 标准库中的泛型函数

其实，如果你深谙函数式编程，那么你对这些泛型函数应该了如指掌，如果你了解且喜欢上了函数式编程，何不使用 RxSwift 进行函数响应式编程呢？这里有几篇 RxSwift 开发的实战，望有助于大家进一步深入认识 RxSwift 函数响应式开发：

以上皆为实战篇，往后会出其 知识点讲解篇。

Map：

Map 函数一般是接受一个给定的数组，然后通过一些非降维的计算处理，得到并返回一个新的数组。

苹果官方定义：

extension Array {
    func map<T>( transform: Element ->  T) -> [T] {
      var result: [T] = []
       for x in self {
          result.append(transform(x))
       }
       return result
    }
}

在 Map 中定义一个泛型类，经过 transform 闭包函数处理之后，通过泛型数组去拿到处理后的新数据，成为新的数组。

应用
将以下数组中的每个元素增加1后输出

let objects: [Int] = [1, 2, 3]

先使用熟悉不过的 For 循环

var newObjects: [Int] = [] 
for object in objects {
   let newObject = object + 1
   newObjects.append(newObject)
}

接下来，使用 Map 函数

// objects.map { newObject in  return newObject + 1 } 
// 上面是完整的 Map 函数编写，但如果闭包中的代码比较简单，我们都会省略 return，如下：
objects.map { newObject in  newObject + 1 }

可以看到，四行的的代码块经 Map 函数处理之后，成为了链式的代码段，借此也可以引入一个新的概念，即函数式编程：主要是为了消灭冗余且复用场景极大的代码块，抽象成复用性极强的代码段，当然以上代码还不够函数式，我们可以继续优化：

// 定义好计算函数
func addCompute(_ object: Int) -> Int {
  return object + 1
}
//进一步优化调整输出函数
objects.map { newObject in  addCompute(newObject) }

函数式编程：需要我们将函数作为其他函数的参数传递，或者作为返回值返还，有时亦被称为高阶函数。

Filter：

Filter 函数同样是接收一个给定的数组，通过给定的筛选条件，取得数组中符合条件的元素，并返回一个新的数组。

苹果官方定义

extension Array {
    func  filter( includeElement: Element ->  Bool) -> [Element] {
      var result: [Element] = []
       for x in self {
          result.append(includeElement(x))
       }
       return result
    }
}

在 filter 中定义一个泛型元素 Element，经过 includeElement 闭包函数筛选处理之后，再经由泛型数组拿到处理后的新数据，成为新的数组。

应用
我们拿到以上定义好的 objects 数组，拿到其中所有的偶数
for 循环

let newObjects: [Int] = []
for oldObject in Objects {
   if oldObject%2 == 0 {
      newObjects.append(oldObject)   
   }
}

filter 函数

 objects.filter { filterElement in  filterElement%2 == 0 }

同样的，你可以感受下 filter 函数处理之后，链式代码的可读性。

Reduce

Reduce 函数接收一个输入数组，同时需要接收一个 T 类型的初始值，
通过 combine 函数处理之后，返回一个同为 T 类型的结果。在一些像 OCaml 和 Haskell 一样的函数语言中，reduce 函数被称为 fold 或 fold_left。而 reduce 可英译为整合，简单来说就是通过我们所想的方式整合一个数组中的元素。

苹果官方定义

extension Array {
    func  reduce<T>( initialValue: T, combine: (T, Element) -> T) -> [T] {
      var result = initialValue
       for x in self {
          result = combine(result, x)
       }
       return result
    }
}

在 reduce 中有两个泛型元素 T && Element，combine 是针对于数组的处理函数，我们输入初始值和数组中的每一个元素之后，即可输出返回一个理想的值。

应用
我们再次拿到 map 中定义好的 objects 数组，拿到其中每个元素相乘后的结果。
for 循环

func reduceInstance() {
  let newObject: Int = 1
  for oldObject in Objects {
     newObject * oldObject
  }
  return newObject
}

reduce 函数

 objects.reduce(1) { result, x in  result * x }

 // 我们也可以将运算符作为最后一个参数，让这段代码更短且不影响可读性
 objects.reduce(1, combine: *)

以上，即为使用 reduce 后处理的结果

最后

我们试着同时使用以上三个函数去作用一个数组。

let lastObjects: [Int] = [2017, 10, 7, 11, 09, 6]

场景：
我们需要将一个整形数组中的元素：

先将所有的元素 + 1
筛选出其中的偶数元素
将所有筛选到的元素相加

lastObjects.map { element in element + 1 }
.filter { element in element%2 == 0 }
.reduce(0, combine: +)

类似复杂的应用场景，使用泛型函数编程是不是变得很简单？以上场景你试试使用 for 循环？

泛型编程：适配工具的实战开发

以上，我们讲解了苹果使用泛型构建的函数，接下来我们进入一个简单但特别实用的泛型实战。

特别广泛的应用场景

我们显示到界面上的元素：图片、文字，很多时候需要在不同尺寸的设备上呈现不同的姿态（大小、位置、样式），这个时候我们该怎么办？仔细一想，其实这个还是有挺多种情况的，可能也会造成很多功能性冗余代码块，该怎么办？
使用泛型编程恰好可解决了这些问题。

属性定义

定义屏幕类型（iPhone/iPad），而每种类型，都有不同尺寸的屏幕大小：

enum DeviceType<T> {
    case iPhone(inch35: T, inch40: T, inch47: T, inch55: T)
    case iPad(common: T, pro: T)
}

定义屏幕的尺寸系数及当前屏幕尺寸，目的是让外界可以通过该属性直接知道当前是那种尺寸的屏幕：

struct DeviceDiaonal {
    static let iPhone4: Double = 3.5
    static let iPhoneSE: Double = 4.0
    static let iPhone6: Double = 4.7
    static let iPhone6Plus: Double = 5.5
}

// 当前屏幕尺寸
var currentDiaonal: Double = DeviceDiaonal.iPhone6

定义屏幕的规格及当前屏幕规格，目的是让外界可以通过该属性直接知道当前是那种屏幕规格的：

// 屏幕规格
enum ScreenSpecs {
    enum PhoneInch {
        case inch35, inch40, inch47, inch55
    }
    enum PadInch {
        case common, pro
    }
    case iPhone(PhoneInch), iPad(PadInch)
}

// 当前屏幕规格
var screenSpecs: ScreenSpecs = .iPhone(.inch47)

初始化构造器的构建

因为当前工具类是一个处理类，所以我们可将其定义为单例类，而其初始化构造器仅限于被单例调用。那么，我们需要在初始化构造器初始化什么属性呢？因为这是一个屏幕特性的单例类，毋庸置疑，我们可以直接通过该类，就可以拿到当前屏幕的所有特性，因此在初始化构造器中，我们需要对当前一些屏幕特性进行初始化

// 构造单例（调用 init 构造函数）
static let shared = ScreenFeatureManager()

fileprivate init() {
    let screenWidth = UIScreen.main.bounds.width
    switch screenWidth {
    case 320:
        if screenHeight <= 480 {
            currentDiaonal = DeviceDiaonal.iPhone4
            screenSpecs = .iPhone(.inch35)
        } else {
            currentDiaonal = DeviceDiaonal.iPhoneSE
            screenSpecs = .iPhone(.inch40)
        }
        
    case 375:
        currentDiaonal = DeviceDiaonal.iPhone6
        screenSpecs = .iPhone(.inch47)
        
    case 414:
        currentDiaonal = DeviceDiaonal.iPhone6Plus
        screenSpecs = .iPhone(.inch55)
        
    case 768:
        screenSpecs = .iPad(.common)
        
    case 1024:
        screenSpecs = .iPad(.pro)
        
    default:
        break
    }
}

至此，我们初始化了一些屏幕特性，接下来，我们将这些屏幕特性加到正菜中！

使用泛型类构造适配函数

利用前面定义好的 DeviceType 类型，对于这个类型，我们可以根据不同的类型输入不同的泛型值（T），然后在函数内，拿到上一步就处理好的屏幕特性，结合输入值进行判断处理，不同的屏幕会映射会出不同的泛型值（T），并拿到该映射下的泛型值输出返回。

func adapt<T>(toDevice type: DeviceType<T>) -> T {

    // 多个输入值，判断处理之后，输出一个单一的泛型值（多对一的映射）
    switch type {
    case let .iPhone(inch35, inch40, inch47, inch55):
        switch screenSpecs {
        case .iPhone(.inch35):
            return inch35
        case .iPhone(.inch40):
            return inch40
        case .iPhone(.inch47):
            return inch47
        case .iPhone(.inch55):
            return inch55
        default:
            return inch47
        }
        
    case let .iPad(common, pro):
        switch screenSpecs {
        case .iPad(.common):
            return common
        case .iPad(.pro):
            return pro
        default:
            return common
        }
    }
}

应用

以上泛型函数构造好之后，适配工作就变得特别简单。
例如有三个适配点：

不同设备，拥有不同的封面图
不同设备，封面图的 size 是不一样的
不同设备，其标题颜色、样式、大小都不一样

我们该如何适配以上的需求呢？

fileprivate func adaptiveConfiguration() {
    //适配封面图的宽度（在 storyBoard 中宽度与高度成一比例，适配了宽度，高度也会跟着变化）
    coverImageViewWidthConstraint.constant = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: 150, inch40: 250, inch47: 350, inch55: 420))
    
    // 适配不同的设备不同的封面图
    coverImageView.image = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: UIImage(named: "home_adapt_inch35"), inch40: UIImage(named: "home_adapt_inch40"), inch47: UIImage(named: "home_adapt_inch47"), inch55: UIImage(named: "home_adapt_inch55")))
    
    //适配主题标题内容
    themeTitleLabel.text = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: "杳无音迅（inch35）", inch40: "杳无音迅（inch40）", inch47: "杳无音迅（inch47）", inch55: "杳无音迅（inch55）"))

    //适配主题标题的字体样式
    themeTitleLabel.font = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: UIFont.boldSystemFont(ofSize: 15), inch40: UIFont.boldSystemFont(ofSize: 18), inch47: UIFont.boldSystemFont(ofSize: 21), inch55: UIFont.boldSystemFont(ofSize: 25)))
    
    //适配主题标题的字体颜色
    themeTitleLabel.textColor = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: UIColor.black, inch40: UIColor.gray, inch47: UIColor.lightGray, inch55: UIColor.green))

}

至此，适配工具已开发完成，如果你是使用 Swift 开发，那么可以直接将其引入你的项目使用。如果有更好的实现方式，期待你评论告知。

Demo： https://github.com/iJudson/ScreenFeature
欢迎 stars
Thanks：多谢观看，欢迎收藏文章，欢迎关注、交流...

网友评论

小歪分纷:普及泛型给萌新是义举, 但标题未免浮夸, 仅本文中的泛型用法顶多算初阶。
田小北北:补充一下，当然这么定义泛型没有问题，只是局限性太大，如果我想用你这泛型去描述别的事物的这种行为显然不合适
田小北北:这种情况用泛型是不是让泛型变得狭隘了？仅代表个人的观点，泛型应该是不同事物间抽象出相同的部分，局部有变，但抽象出来的功能是相同的，比如官方的交换泛型示例，交换任何类型都可以，不局限于苹果手机还是安卓手机，又或者是交换座位？只要是交换的操作，都可以用这个泛型，你这个明显不行，换做其他事物的话成啥了？其他事物有这些属性吗？这种情况我感觉多此一举，因为它真的不够泛型
魔法黛:写的挺好，但是泛型用的还是不够简练。加油
灵度Ling:@魔法黛哈哈哈加油！简练？你可以留下你的意见。

成为 Swift 泛型的高阶玩家（附实战适配 Demo）

Swift 标准库中的泛型函数

Map：

Filter：

Reduce

最后

泛型编程：适配工具的实战开发

特别广泛的应用场景

属性定义

初始化构造器的构建

使用泛型类构造适配函数

应用

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOS-swift

RXswift

Swift

iOS + RxSwift 开发专栏

程序员

首页投稿（暂停使用，暂停投稿）

技术文章

Swift开发