Question

我有一组子视图，我想找到最低标签和最高标签（〜 min 和 max ）。我尝试使用Swift的功能方法，并根据我的知识允许我进行优化，但是当我这样做时：

let startVals = (min:Int.max, max:Int.min)
var minMax:(min: Int, max: Int) = subviews.filter({$0 is T2GCell}).reduce(startVals) {
        (min($0.min, $1.tag), max($0.max, $1.tag))
}

我的表现仍然比（周期的）差得多（大约慢10倍）：

var lowest2 = Int.max var highest2 = Int.min for view in subviews { if let cell = view as? T2GCell { lowest2 = lowest2 > cell.tag ? cell.tag : lowest2 highest2 = highest2 < cell.tag ? cell.tag : highest2 } }

为了完全准确，我还包括测量代码的片段。请注意，人类可读时间的“重新计算后”是在任何测量之外完成的：

let startDate: NSDate = NSDate() // code let endDate: NSDate = NSDate() // outside of measuring block let dateComponents: NSDateComponents = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!.components(NSCalendarUnit.CalendarUnitNanosecond, fromDate: startDate, toDate: endDate, options: NSCalendarOptions(0)) let time = Double(Double(dateComponents.nanosecond) / 1000000.0)

我的问题是 - 我做错了，或者这个用例根本不适用于功能方法？

修改

2x 更慢：

var extremes = reduce(lazy(subviews).map({$0.tag}), startValues) { (min($0.lowest, $1), max($0.highest, $1)) }

这只 20％更慢：

var extremes2 = reduce(lazy(subviews), startValues) { (min($0.lowest, $1.tag), max($0.highest, $1.tag)) }

缩小并缩小到非常好的演奏时间，但仍然没有周期那么快。

编辑2

我注意到我在之前的修改中遗漏了filter。添加时：

var extremes3 = reduce(lazy(subviews).filter({$0 is T2GCell}), startValues) { (min($0.lowest, $1.tag), max($0.highest, $1.tag)) }

我回到 2x 性能较慢。

Answer 1

在优化版本中，reduce和for在性能上应完全相同。但是，在未经优化的调试版本中，for循环可能会超过reduce版本，因为reduce不会被专门化和内联。可以删除过滤器，从而消除了不必要的额外数组创建，但是数组创建速度非常快（它所做的只是将指针复制到内存中）所以这并不是什么大不了的事情，为了清晰起见，消除它更为明确。

但是，我认为部分问题在于您reduce，您在.tag上调用AnyObject属性，而在for循环版本中，您正在呼叫T2GCell.tag。这可能会产生很大的不同。如果你打破过滤器，你可以看到这个：

// filtered will be of type [AnyObject]
let filtered = subviews.filter({$0 is T2GCell})

let minMax:(min: Int, max: Int) = filtered.reduce(startVals) {
    // so $1.tag is calling AnyObject.tag, not T2GCell.tag
    (min($0.min, $1.tag), max($0.max, $1.tag))
}

这意味着.tag将在运行时动态绑定，可能是一个较慢的操作。

这是一些展示差异的示例代码。如果你编译这将swiftc -O，你会看到静态绑定（或者说非常不那么动态绑定）reduce和for循环执行几乎相同：< / p>

import Foundation

@objc class MyClass: NSObject {
    var someProperty: Int
    init(_ x: Int) { someProperty = x }
}
let classes: [AnyObject] = (0..<10_000).map { _ in MyClass(Int(arc4random())) }

func timeRun<T>(name: String, f: ()->T) -> String {
    let start = CFAbsoluteTimeGetCurrent()
    let result = f()
    let end = CFAbsoluteTimeGetCurrent()
    let timeStr = toString(Int((end - start) * 1_000_000))
    return "\(name)\t\(timeStr)µs, produced \(result)"
}

let runs = [
    ("Using AnyObj.someProperty", { 
        reduce(classes, 0) { prev,next in max(prev,next.someProperty) } 
    }),
    ("Using MyClass.someProperty", { 
        reduce(classes, 0) { prev,next in 
          (next as? MyClass).map { max(prev,$0.someProperty) } ?? prev 
        }
    }),
    ("Using plain ol' for loop", {
        var maxSoFar = 0
        for obj in classes {
            if let mc = obj as? MyClass {
                maxSoFar = max(maxSoFar, mc.someProperty)
            }
        }
        return maxSoFar
    }),
]

println("\n".join(map(runs, timeRun)))

在我的机器上输出：

Using AnyObj.someProperty       4115µs, produced 4294310151
Using MyClass.someProperty      1169µs, produced 4294310151
Using plain ol' for loop        1178µs, produced 4294310151

Answer 2

无法重现您的确切示例，但您可以尝试移开过滤器。以下代码在功能上应与您上次的尝试相同。

var extremes4 = reduce(subviews, startValues) {
    $1 is T2GCell ? (min($0.lowest, $1.tag), max($0.highest, $1.tag)) : $0
}

因此，您不会在子视图上迭代两次。请注意，我删除了lazy，因为它似乎总是使用整个列表。

顺便说一下，恕我直言，函数式编程可能是一种非常有用的方法，但在牺牲代码清晰度之前我会三思而后行，只是为了花哨的功能方法。因此，如果for循环更清晰，甚至更快......只需使用它;-)也就是说，您可以尝试不同的方法来解决同样的问题。

Answer 3

我能想到的一个问题是循环完成了两次。首先，过滤器返回一个已过滤的数组，然后在reduce中循环。

过滤器（_：）

返回一个数组，其中包含提供的闭包表示匹配的数组元素。

声明

func filter（includeElement：（T） - ＆gt; Bool） - ＆gt; [T]

讨论

使用此方法通过过滤现有数组来返回新数组。您为includeElement提供的闭包：应该返回一个布尔值，以指示是否应该从最终集合中包含（true）或排除（false）元素：

在第二种情况下，只有一个循环。

我不确定'is'的执行时间是否与'as'有任何不同？操作

使用功能方法查找min和max时的性能问题

3 个答案: