如何将 DispatchTimeInterval 转换为 NSTimeInterval（或 Double）？答案

【问题标题】：How to convert DispatchTimeInterval to NSTimeInterval (or Double)?如何将 DispatchTimeInterval 转换为 NSTimeInterval（或 Double）？
【发布时间】：2017-12-08 12:35:53
【问题描述】：

我需要从NSTimeInterval（或Double）中减去DispatchTimeInterval。

是否有将DispatchTimeInterval 转换为NSTimeInterval 的标准方法？

【问题讨论】：

DispatchTimeInterval 与 DispatchTime 一起使用，而不是与 (NS)Date 或 (NS)TimeInterval 一起使用。你能详细说明你为什么需要这个吗？ – 无论如何，DispatchTimeInterval 是一个枚举，将其转换为 Double 将是一个简单的 switch/case 问题。
@MartinR 有一个用DispatchTimeInterval 设置的计时器，我在NSTimeInterval 中测量经过的实时时间。我需要减去两者才能得到延迟。

标签： swift nstimeinterval

【解决方案1】：

DispatchTimeInterval 是一个枚举：

public enum DispatchTimeInterval : Equatable {
    case seconds(Int)
    case milliseconds(Int)
    case microseconds(Int)
    case nanoseconds(Int)
    case never
}

您可以使用以下方法初始化DispatchTimeInterval：

    let tenSeconds: DispatchTimeInterval = .seconds(10)
    let tenNanoseconds: DispatchTimeInterval = .nanoseconds(10)

要从枚举中获取值，您需要将值与枚举中的 case 值匹配

    if case .seconds(let value) = tenSeconds {
        print("DispatchTimeInterval is seconds \(value)")
    } else if case .nanoseconds(let value) = tenNanoseconds {
        print("DispatchTimeInterval is seconds \(value)")
    }

转换函数可能如下所示：

func toDouble(_ interval: DispatchTimeInterval) -> Double? {
        var result: Double? = 0

        switch interval {
        case .seconds(let value):
            result = Double(value)
        case .milliseconds(let value):
            result = Double(value)*0.001
        case .microseconds(let value):
            result = Double(value)*0.000001
        case .nanoseconds(let value):
            result = Double(value)*0.000000001

        case .never:
            result = nil
        }

        return result
    }

More about Enumeration see in Apple Documentation

更新：

为DispatchTimeInterval创建扩展

extension DispatchTimeInterval {
    func toDouble() -> Double? {
        var result: Double? = 0

        switch self {
        case .seconds(let value):
            result = Double(value)
        case .milliseconds(let value):
            result = Double(value)*0.001
        case .microseconds(let value):
            result = Double(value)*0.000001
        case .nanoseconds(let value):
            result = Double(value)*0.000000001

        case .never:
            result = nil
        }

        return result
    }
}

【讨论】：

【解决方案2】：

一个快速的解决方案是创建一个TimeInterval 扩展并在其中添加一个带有DispatchTimeInterval 参数的failable initializer。下面的 Swift 5 代码展示了如何实现它：

import Foundation

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
        }
    }

}

用法：

let dispatchTimeInterval = DispatchTimeInterval.seconds(5)
let timeInterval = TimeInterval(dispatchTimeInterval: dispatchTimeInterval)
print(String(describing: timeInterval)) // Optional(5.0)

let dispatchTimeInterval = DispatchTimeInterval.milliseconds(30)
let timeInterval = TimeInterval(dispatchTimeInterval: dispatchTimeInterval)
print(String(describing: timeInterval)) // Optional(0.03)

【讨论】：