Swift - 让你的[数组]溜得飞起来

由于Swfit强大的扩展特性，搞得现在很少自定义过自己的类型。一般都是直接XXX+extension.swift 文件了。然后几乎直接点语法...其实这样也简洁我们的代码，相当于把具体的实现逻辑交给那个接口，返回自己想要的东西就足够了。

下面就让我们小小扩展下数组 让它飞一下 ︿(￣︶￣)︿

前面的分解数组语法参考objc的一篇博客

一些小扩展命名参考Haskell语言

虫子来自Haskell趣味玩法

extension Array {
    
    ///SELF -> 头 + [尾巴部分]
    var decomposeHead: (head: Element, tail: [Element])? {
        return (count > 0) ? (self[0], Array(self[1..<count])) : nil
    }
    
    ///SELF -> [头部分] + 尾巴
    var decomposeTail: (initt: [Element], last:Element)? {
        return (count > 0 ) ? (Array(self[0..<count-1]), self[self.count-1]) : nil
    }
    
    ///返回首个元素 Swift本身已实现方法有 .first
    var head: Element? {
        return decomposeHead?.head
    }
    
    //返回首个元素 Swift本身已实现方法有 .last
    var last: Element? {
        return decomposeTail?.last
    }
    
    //返回数组的尾部，即除掉头部之后的部分
    var tail: [Element]? {
        return decomposeHead?.tail
    }
    
    ///返回数组的前部，即除掉最后一个元素
    var initt: [Element]? {
        return decomposeTail?.initt
    }

    ///返回随机元素
    var randomElement: Element? {
        guard count > 0 else { return nil }
        return self[Int(arc4random_uniform(UInt32(count)))]
    }        

    ///数组 -> 转字典 按照原序号当键值，这里默认键为整数类型
    var transIntoDict: [Int: Element]? {
        
        var listDict = [Int: Element]()
        self.enumerate().forEach {
            listDict[$0] = $1
        }
        return listDict
    }
    
    ///判断是否存在该元素 Swift本身已实现方法有 contains
    func elem<T : Equatable>(elem: T) -> Bool {
        let filtered = self.filter {$0 as? T == elem}
        return filtered.count > 0
    }
    
    ///判断元素的总数
    func elemNum<T : Equatable>(elem: T) -> Int {
        let filtered = self.filter {$0 as? T == elem}
        return filtered.count
    }

    /// 随意转移一个元素到头部 如果存在相同 同时转移全部到前面
    func customHeads<T : Equatable>(elem: T) -> [Element] {

        let head = self.filter { $0 as? T == elem }
        let tail =  self.filter { $0 as? T != elem }
        return head + tail
    }
    
    /// 随意转移一个元素到头部 如果存在相同 只转移遇到最先那个
    func customHead<T : Equatable>(elem: T) -> [Element] {
        
        var isHasElem = false
        var newArr = [Element]()
        self.forEach { currElem in
            if (currElem as? T) == elem && isHasElem == false {
                isHasElem = true
                newArr.insert(currElem, atIndex: 0)
            } else {
                newArr.append(currElem)
            }
        }
        return newArr
    }
    
    /*
      * |--⬆️值类型------华丽丽分界线-----⬇️引用类型--|
    */
    
    //take 返回前面几个元素-如果大于数组即返回全部
    mutating func take(index: Int) -> [Element]? {
        guard self.count >= index else {
            return self
        }
        self = Array(self[0..<index])
        return self
    }
    
    ///drop 删除前面几个元素-如果大于数组个数-默认全部删除
    mutating func drop(index: Int) -> [Element]? {
        guard self.count >= index else {
            self = []
            return self
        }
        self = Array(self[index..<self.count])
        return self
    }

    /*
     * 打乱数组
    */
    mutating func shuffle() {
        for i in (0..<self.count).reverse() {
            let ix1 = i
            let ix2 = Int(arc4random_uniform(UInt32(i+1)))
            (self[ix1], self[ix2]) =  (self[ix2], self[ix1])
        }
    }
}

---

使用例子：

var list = [1,2,3,4,5,6]

list.head              // = 1
list.last             // = 6
list.tail            // = [2, 3, 4, 5, 6]
list.initt          // = [1, 2, 3, 4, 5]
list.transIntoDict // = [4: 5, 5: 6, 2: 3, 0: 1, 1: 2, 3: 4]

list.elem(1) // = true
list.elem(8) // = false

list.take(5) // -> [1, 2, 3, 4, 5]
list.drop(2) // -> [3, 4, 5]

其他基本特性参考哥这篇：Swift 类型 - 数组