swift泛型有哪些

本篇内容介绍了“swift泛型有哪些”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

泛型类型约束

//泛型类型约束
func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

print(findIndex(of: "abc", in: ["a", "b", "c", "abc"]))
//Optional(3)

关联类型：协议使用泛型

//关联类型：协议使用泛型
protocol Container {
    associatedtype ItemType: Equatable
    
    mutating func append(_ item: ItemType)
    
    var count: Int { get }
    
    subscript(i: Int) -> ItemType { get }
}

struct IntStack: Container {
    var items = [Int]()
    
    mutating func push(_ item: Int) {
        items.append(item)
    }
    
    mutating func pop() -> Int {
        return items.removeLast()
    }
    
    //指定类型
    typealias ItemType = Int
    
    mutating func append(_ item: Int) {
        self.push(item)
    }
    
    var count: Int {
        return items.count
    }
    
    subscript(i: Int) -> Int {
        return items[i]
    }
}

泛型结构体使用泛型协议

泛型结构体使用泛型协议，不需要用 typealias 指定类型，可以推断出来

//泛型结构体使用泛型协议，不需要用 typealias 指定类型，可以推断出来
struct Stack<Element: Equatable>: Container {
    var items = [Element]()
    
    mutating func push(_ item: Element) {
        items.append(item)
    }
    
    mutating func pop() -> Element {
        return items.removeLast()
    }
    
    mutating func append(_ item: Element) {
        self.push(item)
    }
    
    var count: Int {
        return items.count
    }
    
    subscript(i: Int) -> Element {
        return items[i]
    }
}

var stack = Stack<String>()
stack.push("abc")
print(stack.count)
//1

泛型 where 子句

//泛型 where 子句
func allItemMatch<C1: Container, C2: Container>(_ someContainer: C1, _ anotherContainer: C2) -> Bool where C1.ItemType == C2.ItemType {
    if someContainer.count != anotherContainer.count {
        return false
    }
    
    for i in 0..<someContainer.count {
        if someContainer[i] != anotherContainer[i] {
            return false
        }
    }
    
    return true
}

where扩展泛型

//where扩展泛型
extension Stack where Element: Comparable {
    
}

关联类型的泛型 where 子句

//关联类型的泛型 where 子句
protocol ContainerTwo {
    associatedtype ItemType: Equatable
    
    mutating func append(_ item: ItemType)
    
    var count: Int { get }
    
    subscript(i: Int) -> ItemType { get }
    
    associatedtype Iterator: IteratorProtocol where Iterator.Element == ItemType
    
    func makeIterator() -> Iterator
}

扩展泛型下标

//扩展泛型下标
extension ContainerTwo {
    subscript<Indices: Sequence>(indices: Indices) -> [ItemType] where Indices.Iterator.Element == Int {
        var result = [ItemType]()
        for index in indices {
            result.append(self[index])
        }
        return result
    }
}

“swift泛型有哪些”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站，小编将为大家输出更多高质量的实用文章！