Swift: 数组无序排列，自定义模型去重，冒泡排序

前言：在开发过程中，不可避免会对一些基本类型做特殊处理，本文今天主要列举三种模型处理

1.数组无序排列

// 数组无序排列
    public func zmShuffle() -> Array {
        var list = self
        for index in 0...list.count {
            let newIndex = Int(arc4random_uniform(UInt32(list.count-index))) + index
            if index != newIndex {
                list.swapAt(index, newIndex)
            }
        }
        return list
    }

swapAt 方法可以实现两个元素的位置交换,也是swift4新特性之一，详情可查看
最全的 Swift 4 新特性解析

2.去重(自定义模型，根据给定的规则进行去重)

//该函数的参数filterCall是一个带返回值的闭包，传入模型Element，返回一个E类型
    public func handleFilter<E: Equatable>(_ filterCall: (Element) -> E) -> [Element] {
        var temp = [Element]()
        for model in self {
            //调用filterCall，获得需要用来判断的属性E
            let identifer = filterCall(model)
            //此处利用map函数 来将model类型数组转换成E类型的数组，以此来判断
            if !temp.map( { filterCall($0) } ).contains(identifer) {
                temp.append(model)
            }
        }
        return temp
    }

去重函数理解起来比较简单，就是传入指定模型，通过指定模型，去重，生成新的数组

3.冒泡排序

// 根据函数返回的Int，去区分，可使用在字符串根据count排序，或者int类型排序
public func bubbleSort(_ filterCall: (Element) -> Int) -> [Element] {
        var temp: [Element] = self
        for i in 0...self.count - 1 {
            for j in (i...self.count - 1).reversed() {
                // rs 必须写到内循环里边
                let rs = filterCall(temp[i])
                let js = filterCall(temp[j])
                if rs > js {
                    let t = temp[i]
                    temp[i] = temp[j]
                    temp[j] = t
                }
            }
        }
        return temp
    }