如何在Swift中测量运行函数所用的时间？我想要显示经过的时间，例如：“经过了0.05秒”。在Java中看到可以使用System.nanoTime()，在Swift中是否有等效的方法来完成这个任务？
请查看示例程序：
func isPrime(_ number: Int) -> Bool {
var i = 0;
for i=2; i<number; i++ {
if number % i == 0, i != 0 {
return false
}
}
return true
}
var number = 5915587277
if isPrime(number) {
print("Prime number")
} else {
print("NOT a prime number")
}
更新
随着Swift 5.7的推出，下面的内容变得过时了。Swift 5.7引入了一个Clock的概念，该函数的设计正好可以满足此处所需。
提供了两个具体的Clock示例：ContinuousClock和SuspendingClock。前者在系统挂起时继续运行，而后者则不会。
以下是在Swift 5.7中要做的示例。
func doSomething()
{
for i in 0 ..< 1000000
{
if (i % 10000 == 0)
{
print(i)
}
}
}
let clock = ContinuousClock()
let result = clock.measure(doSomething)
print(result) // On my laptop, prints "0.552065882 seconds"
let clock = ContinuousClock()
let result = clock.measure {
for i in 0 ..< 1000000
{
if (i % 10000 == 0)
{
print(i)
}
}
}
print(result) // "0.534663798 seconds"
Swift 5.7之前
这是我用Swift编写的一个函数，用于测量Project Euler问题。
自Swift 3以来，现在有一个“swiftified”版本的Grand Central Dispatch。因此，正确的答案可能是使用DispatchTime API。
我的函数大致如下：
// Swift 3
func evaluateProblem(problemNumber: Int, problemBlock: () -> Int) -> Answer
{
print("Evaluating problem \(problemNumber)")
let start = DispatchTime.now() // <<<<<<<<<< Start time
let myGuess = problemBlock()
let end = DispatchTime.now() // <<<<<<<<<< end time
let theAnswer = self.checkAnswer(answerNum: "\(problemNumber)", guess: myGuess)
let nanoTime = end.uptimeNanoseconds - start.uptimeNanoseconds // <<<<< Difference in nano seconds (UInt64)
let timeInterval = Double(nanoTime) / 1_000_000_000 // Technically could overflow for long running tests
print("Time to evaluate problem \(problemNumber): \(timeInterval) seconds")
return theAnswer
}
对于Swift 1和2，我的函数使用NSDate：
// Swift 1
func evaluateProblem(problemNumber: Int, problemBlock: () -> Int) -> Answer
{
println("Evaluating problem \(problemNumber)")
let start = NSDate() // <<<<<<<<<< Start time
let myGuess = problemBlock()
let end = NSDate() // <<<<<<<<<< end time
let theAnswer = self.checkAnswer(answerNum: "\(problemNumber)", guess: myGuess)
let timeInterval: Double = end.timeIntervalSinceDate(start) // <<<<< Difference in seconds (double)
println("Time to evaluate problem \(problemNumber): \(timeInterval) seconds")
return theAnswer
}
CoreFoundation的方便的计时器类，它使用了CFAbsoluteTime。import CoreFoundation
class ParkBenchTimer {
let startTime: CFAbsoluteTime
var endTime: CFAbsoluteTime?
init() {
startTime = CFAbsoluteTimeGetCurrent()
}
func stop() -> CFAbsoluteTime {
endTime = CFAbsoluteTimeGetCurrent()
return duration!
}
var duration: CFAbsoluteTime? {
if let endTime = endTime {
return endTime - startTime
} else {
return nil
}
}
}
你可以像这样使用它:
let timer = ParkBenchTimer()
// ... a long runnig task ...
print("The task took \(timer.stop()) seconds.")
mach_absolute_time 函数可以避免这个问题，所以我想知道为什么它不是广为人知的。也许只是因为它没有很好的文档说明。 - Franklin Yuclock、ProcessInfo.systemUptime 或者 DispatchTime 来简单地测量启动时间。据我所知，至少有十种方法来测量经过的时间：
ProcessInfo.systemUptime。mach_absolute_time，如这个答案中所提到的mach_timebase_info。clock() 在POSIX标准中。times() 在POSIX标准中。（过于复杂，因为我们需要考虑用户时间与系统时间之间的区别，并且子进程也涉及在内）DispatchTime（封装了Mach时间API），如被接受的答案中JeremyP所提到的。CACurrentMediaTime()。（不要用来做指标测量：下面说明原因）
NSDate/Date，其他人提到过。CFAbsoluteTime，其他人提到过。DispatchWallTime。gettimeofday() 在POSIX标准中。选项1、2和3将在下面进行详细阐述。
do {
let info = ProcessInfo.processInfo
let begin = info.systemUptime
// do something
let diff = (info.systemUptime - begin)
}
其中diff:NSTimeInterval表示经过的时间（以秒为单位）。
do {
var info = mach_timebase_info(numer: 0, denom: 0)
mach_timebase_info(&info)
let begin = mach_absolute_time()
// do something
let diff = Double(mach_absolute_time() - begin) * Double(info.numer) / Double(info.denom)
}
diff:Double表示经过纳秒计算的时间差。
do {
let begin = clock()
// do something
let diff = Double(clock() - begin) / Double(CLOCKS_PER_SEC)
}
diff:Double是经过秒计算的已经过去的时间。
多次调用此函数不能保证递增的结果。
原因与Java中的currentTimeMillis和nanoTime类似:
你不能把其中一个用于另一个目的。原因是因为没有计算机时钟是完美的；它总是会漂移并偶尔需要校准。这种校准可能是手动的，或者在大多数机器上，有一个进程运行并持续发出系统时钟（“挂钟”）的小修正。这些往往经常发生。每当有闰秒时也会发生这样的校正。
在这里，CFAbsoluteTime提供的是挂钟时间而不是启动时间。 NSDate也是挂钟时间。
clock()函数。 - Misha SvyatoshenkoProcessInfo.processInfo.systemUptime、mach_absolute_time()、DispatchTime.now()和CACurrentMediaTime()。但是使用clock()的解决方案无法正确转换为秒。因此，我建议将您的第一句话更新为：“请使用ProcessInfo.systemUptime或DispatchTime获取准确的启动时间。” - Cœurclock_gettime_nsec_np(CLOCK_UPTIME_RAW) 进行优化，它会为您进行时间基准转换并提供纳秒值（请参见 http://www.manpagez.com/man/3/clock_gettime_nsec_np/）。 - oscaroscarSwift 4最短的答案:
let startingPoint = Date()
// ... intensive task
print("\(startingPoint.timeIntervalSinceNow * -1) seconds elapsed")
它将会打印出一些类似于1.02107906341553 seconds elapsed的内容（当然，时间会根据任务而异，我只是展示这个测量的小数精度水平给大家看看）。
希望对Swift 4有所帮助！
更新
如果你想要一种通用的测试代码片段的方法，我建议使用下面的代码：
func measureTime(for closure: @autoclosure () -> Any) {
let start = CFAbsoluteTimeGetCurrent()
closure()
let diff = CFAbsoluteTimeGetCurrent() - start
print("Took \(diff) seconds")
}
使用方法
measureTime(for: <insert method signature here>)
控制台日志
Took xx.xxxxx seconds
只需复制并粘贴此函数。用 Swift 5 编写。这里是 JeremyP 的代码。
func calculateTime(block : (() -> Void)) {
let start = DispatchTime.now()
block()
let end = DispatchTime.now()
let nanoTime = end.uptimeNanoseconds - start.uptimeNanoseconds
let timeInterval = Double(nanoTime) / 1_000_000_000
print("Time: \(timeInterval) seconds")
}
像这样使用
calculateTime {
exampleFunc()// function whose execution time to be calculated
}
let start = NSDate()
for index in 1...10000 {
// do nothing
}
let elapsed = start.timeIntervalSinceNow
// elapsed is a negative value.
time函数来测量你的调用时间。我受到Klaas'回答的启发。func time <A> (f: @autoclosure () -> A) -> (result:A, duration: String) {
let startTime = CFAbsoluteTimeGetCurrent()
let result = f()
let endTime = CFAbsoluteTimeGetCurrent()
return (result, "Elapsed time is \(endTime - startTime) seconds.")
}
time (isPrime(7))，返回一个包含结果和经过时间描述的元组。time (isPrime(7)).duration。看起来 iOS 13 引入了一种新的API，可与 DispatchTime 一起使用，不再需要手动计算两个时间戳之间的差异。
let start: DispatchTime = .now()
heavyTaskToMeasure()
let duration = start.distance(to: .now())
print(duration)
// prints: nanoseconds(NUMBER_OF_NANOSECONDS_BETWEEN_TWO_TIMESTAMPS)
遗憾的是没有提供文档，但在进行了一些测试后，.nanoseconds 情况似乎总是返回。
通过一个简单的扩展，可以将 DispatchTimeInterval 转换为 TimeInterval。 参考来源
extension TimeInterval {
init?(dispatchTimeInterval: DispatchTimeInterval) {
switch dispatchTimeInterval {
case .seconds(let value):
self = Double(value)
case .milliseconds(let value):
self = Double(value) / 1_000
case .microseconds(let value):
self = Double(value) / 1_000_000
case .nanoseconds(let value):
self = Double(value) / 1_000_000_000
case .never:
return nil
}
}
}
使用闭包的简单助手函数，用于测量执行时间。
func printExecutionTime(withTag tag: String, of closure: () -> ()) {
let start = CACurrentMediaTime()
closure()
print("#\(tag) - execution took \(CACurrentMediaTime() - start) seconds")
}
使用方法：
printExecutionTime(withTag: "Init") {
// Do your work here
}
结果：
#初始化 - 执行花费了1.00104497105349秒
我使用这个:
public class Stopwatch {
public init() { }
private var start_: NSTimeInterval = 0.0;
private var end_: NSTimeInterval = 0.0;
public func start() {
start_ = NSDate().timeIntervalSince1970;
}
public func stop() {
end_ = NSDate().timeIntervalSince1970;
}
public func durationSeconds() -> NSTimeInterval {
return end_ - start_;
}
}
记得在测试性能时提高你的构建优化：
sqrt(number)处停止，而不是在number处停止，这样可以节省更多时间 - 但是还有更多优化寻找质数的想法。 - holexNSDate对象并且可以测量它们之间的差异。 - holex