Swift 泛型函数 类型约束(十三)

前端之家收集整理的这篇文章主要介绍了Swift 泛型函数 类型约束(十三)前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

非泛型函数

/// 交换两个整形的值
    func swapTwoNumbersInt(inout a: Int,inout _ b:Int)
    {
        let temp = a
        a = b
        b = temp
    }
/// 交换两个字符串的值
    func swapTwoString(inout string1: String,inout _ string2: String)
    {
        let temp = string1
        string1 = string2
        string2 = temp
    }

如果想实现不确定类型值的交换上面的方法是不是显得太过死板,所以泛型的出现很好的解决这个

泛型

泛型函数–泛型函数可以适用于任何类型
1. 这个函数的泛型版本使用了占位类型名(在这里用字母 T 来表示)来代替实际类型名(例如 IntString,占位类型名没有指明 T 必须是什么类型,但是它指明了 ab 必须是同一类型 T,无论 T 代表什么类型
2. 这个泛型函数名(swapTwoValues(::))后面跟着占位类型名(T),并用尖括号括起来()。这个尖括号告诉 Swift 那个 T 是 swapTwoValues(::) 函数定义内的一个占位类型名,因此 Swift 不会去查找名为 T 的实际类型

/// 实现不确定类型值交换
 func swapTwoValues<T>(inout a: T,inout _ b: T)
    {
        let temp = a
        a = b
        b = temp
    }

类型约束

  1. SwiftDictionary 类型对字典的键的类型做了些限制。在字典的描述中,字典的键的类型必须是可哈希(hashable)的。也就是说,必须有一种方法能够唯一地表示它。Dictionary 的键之所以要是可哈希的,是为了便于检查字典是否已经包含某个特定键的值。若没有这个要求,Dictionary 将无法判断是否可以插入或者替换某个指定键的值,也不能查找到已经存储在字典中的指定键的值。
  2. 为了实现这个要求,一个类型约束被强制加到 Dictionary 的键类型上,要求其键类型必须符合 Hashable 协议,这是 Swift 标准库中定义的一个特定协议。所有的 Swift 基本类型(例如 StringIntDoubleBool)默认都是可哈希的。
  3. 当你创建自定义泛型类型时,你可以定义你自己的类型约束,这些约束将提供更为强大的泛型编程能力。抽象概念,例如可哈希的,描述的是类型在概念上的特征,而不是它们的显式类型
for example 类型约束
/// 非泛型
    func findStringIndex(array: [String],_ valueToFind: String) -> Int? {
        for (index,value) in array.enumerate() {
            if value == valueToFind {
                return index
            }
        }
        return nil
    }
/// 泛型
/// T 遵循 Equatable
    func findIndex<T: Equatable>(array: [T],_ valueToFind: T) -> Int? {
        for (index,value) in array.enumerate() {
            /// 不是所有的 Swift 类型都可以用等式符(==)进行比较
            /// Swift 标准库中定义了一个 Equatable 协议,该协议要求任何遵循该协议的类型必须实现等式符(==)及不等符(!=),从而能对该类型的任意两个值进行比较。所有的 Swift 标准类型自动支持 Equatable 协议。
            if value == valueToFind {
                return index
            }
        }
        return nil
    }

下面是我在viewDidLoad中的调用

var a = 10
        var b = 20
// self.swapTwoNumbersInt(&a,&b)
        print("b: \(b)")

        var string1 = "Big"
        var string2 = "Small"
// self.swapTwoString(&string1,&string2)
        print("string2: \(string2)")
        ///
        self.swapTwoValues(&a,&b)
        print("b: \(b)")
        ///
        self.swapTwoValues(&string1,&string2)
        print("string2: \(string2)")
        ///
        let strings = ["button","label","view","model","Controller"]
        if let foundIndex = findStringIndex(strings,"label") {
            print("\(foundIndex)")
        }
        ///
        if let foundIndex = findIndex(strings,"view") {
            print("view: \(foundIndex)")
        }
        ///
        let ints = [1,2,3,4,55,6]
        if let foundIndex = findIndex(ints,55) {
            print("55: \(foundIndex)")
        }

类型格式转化

1. labelTitle.text = NSString(format: "%d",indexPath.row) as String
String <-> int
2. a = Int(scrollView.contentOffset.x)
int   <->  cgfloat
3. dic["title"] as? String
NSString <-> String

总结: 使用泛型写出的代码是不是功能很强大? 学起来吧.

原文链接:https://www.f2er.com/swift/324050.html

猜你在找的Swift相关文章