import Foundation

extension Array {
    var randomItem: Element? {
        let idx = Int(arc4random_uniform(UInt32(self.count)))
        return self.isEmpty ? nil : self[idx]
    }
}

我看了一下Swift 2标准库的头文件，这里是过滤器函数的原型，这使得如何滚动您自己的头文件变得非常明显。

extension CollectionType {
    func filter(@noescape includeElement: (Self.Generator.Element) -> Bool) -> [Self.Generator.Element]
}

它不是Array的扩展，而是CollectionType的扩展，所以同样的方法也适用于其他集合类型。@noescape意味着传入的块不会离开过滤器函数的作用域，这使得一些优化成为可能。大写S的Self是我们要扩展的类。自我。Generator是一个迭代器，遍历集合中的对象，Self.Generator.Element是对象的类型，例如对于数组[Int?Self.Generator.Element将是Int?

总而言之，这个过滤器方法可以应用于任何CollectionType，它需要一个过滤器块，该过滤器块接受集合中的一个元素并返回Bool值，它返回原始类型的数组。所以把这些放在一起，这里有一个我觉得有用的方法:它结合了map和filter，通过取一个块，将一个集合元素映射到一个可选值，并返回一个由那些非nil的可选值组成的数组。

extension CollectionType {

    func mapfilter<T>(@noescape transform: (Self.Generator.Element) -> T?) -> [T] {
        var result: [T] = []
        for x in self {
            if let t = transform (x) {
                result.append (t)
            }
        }
        return result
    }
}

使用Swift 2.2: 我在尝试从字符串数组中删除重复项时遇到了类似的问题。我能够在Array类上添加一个扩展，这正是我想要做的。

extension Array where Element: Hashable {
    /**
     * Remove duplicate elements from an array
     *
     * - returns: A new array without duplicates
     */
    func removeDuplicates() -> [Element] {
        var result: [Element] = []
        for value in self {
            if !result.contains(value) {
                result.append(value)
            }
        }
        return result
    }

    /**
     * Remove duplicate elements from an array
     */
    mutating func removeDuplicatesInPlace() {
        var result: [Element] = []
        for value in self {
            if !result.contains(value) {
                result.append(value)
            }
        }
        self = result
    }
}

将这两个方法添加到Array类中允许我调用数组上的两个方法中的一个，并成功地删除重复项。注意数组中的元素必须符合Hashable协议。现在我可以这样做:

 var dupes = ["one", "two", "two", "three"]
 let deDuped = dupes.removeDuplicates()
 dupes.removeDuplicatesInPlace()
 // result: ["one", "two", "three"]

扩展所有类型:

extension Array where Element: Any {
    // ...
}

可比较的类型:

extension Array where Element: Comparable {
    // ...
}

扩展一些类型:

extension Array where Element: Comparable & Hashable {
    // ...
}

扩展一个特定类型:

extension Array where Element == Int {
    // ...
}

经过一段时间的尝试，解决方案似乎从签名中删除<T>:

extension Array {
    func find(fn: (T) -> Bool) -> [T] {
        var to = [T]()
        for x in self {
            let t = x as T;
            if fn(t) {
                to += t
            }
        }
        return to
    }
}

现在可以正常工作，没有构建错误:

["A","B","C"].find { $0.compare("A") > 0 }

我有一个类似的问题——想用swap()方法扩展通用数组，该方法应该接受与数组相同类型的参数。但是如何指定泛型类型呢?经过反复试验，我发现以下方法是有效的:

extension Array {
    mutating func swap(x:[Element]) {
        self.removeAll()
        self.appendContentsOf(x)
    }
}

关键是“元素”这个词。注意，我没有在任何地方定义这种类型，它似乎自动存在于数组扩展的上下文中，并引用数组元素的任何类型。

我不是100%确定那里发生了什么，但我认为这可能是因为“元素”是数组的关联类型(见“关联类型”这里https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Generics.html#//apple_ref/doc/uid/TP40014097-CH26-ID189)

然而，我在数组结构参考(https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_Array_Structure/index.html#//apple_ref/swift/struct/s:Sa)中看不到任何这方面的参考…所以我还是有点不确定。