Question

（这可能需要更好的标题......）

我想在代码中使用一组访问器来快速表达持续时间。 E.g：

42.seconds
3.14.minutes
0.5.hours
13.days

This post说明您无法使用简单的新协议，扩展程序以及强制IntegerType和FloatingPointType采用该协议。所以我认为我只是采用更冗余的路线，只是直接扩展IntegerType（然后重复FloatingPointType的代码。）

extension IntegerType {
    var seconds:NSTimeInterval {
        return NSTimeInterval(self)
    }
}

产生的错误令人困惑：

Playground execution failed: /var/folders/2k/6y8rslzn1m95gjpg534j7v8jzr03tz/T/./lldb/9325/playground131.swift:31:10: error: cannot invoke initializer for type 'NSTimeInterval' with an argument list of type '(Self)'
                return NSTimeInterval(self)
                       ^
/var/folders/2k/6y8rslzn1m95gjpg534j7v8jzr03tz/T/./lldb/9325/playground131.swift:31:10: note: overloads for 'NSTimeInterval' exist with these partially matching parameter lists: (Double), (UInt8), (Int8), (UInt16), (Int16), (UInt32), (Int32), (UInt64), (Int64), (UInt), (Int), (Float), (Float80), (String), (CGFloat), (NSNumber)
                return NSTimeInterval(self)

让我感到困惑的是，它似乎说我无法使用（Self）执行NSTimeInterval（）初始化程序，但是Self表示的所有内容都列在下一行中，其中显示了NSTimeInterval的所有可能的初始化程序。我在这里缺少什么？

除此之外：如果有一个关于Swift类型系统的精心编写的教程并做这些事情，我会很高兴。 Apple的稀疏Swift文档中没有很好地介绍中级/高级内容

更新/澄清：

我想要的是能够评估上述任何表达式：

42.seconds   --> 42
3.14.minutes --> 188.4
0.5.hours    --> 1800
13.days      --> 1123200

此外，我希望这些返回类型为NSTimeInterval（Double的类型别名），这样：

42.seconds is NSTimeInterval   --> true
3.14.minutes is NSTimeInterval --> true
0.5.hours is NSTimeInterval    --> true
13.days is NSTimeInterval      --> true

我知道我可以通过简单地延长Double和Int来实现这一目标：

extension Int {
    var seconds:NSTimeInterval {
        return NSTimeInterval(self)
    }

    var minutes:NSTimeInterval {
        return NSTimeInterval(self * 60)
    }

    var hours:NSTimeInterval {
        return NSTimeInterval(self * 3600)
    }

    var days:NSTimeInterval {
        return NSTimeInterval(self * 3600 * 24)
    }
}

extension Double {
    var seconds:NSTimeInterval {
        return NSTimeInterval(self)
    }

    var minutes:NSTimeInterval {
        return NSTimeInterval(self * 60)
    }

    var hours:NSTimeInterval {
        return NSTimeInterval(self * 3600)
    }

    var days:NSTimeInterval {
        return NSTimeInterval(self * 3600 * 24)
    }
}

但我还想使用以下表达式：

let foo:Uint = 4242
foo.minutes                   --> 254520
foo.minutes is NSTimeInterval --> true

这不会起作用，因为我只延长了Int，而不是UInt。我可以冗余地延伸Uint，然后UInt16，然后Int16等......

我想将Int的扩展名概括为IntegerType，如原始列表中所示，这样我就可以获得所有整数类型的转换。然后对FloatingPointType而不是具体Double执行相同的操作。但是，这会产生原始错误。我想知道为什么我不能像通常所示那样扩展IntegerType。是否有其他IntegerType采用者而不是列表中显示的那些，这使得NSTimeInterval（）初始化程序无法解析？

Answer 1

我可以冗余地扩展Uint，然后是UInt16，然后是Int16等......

正确。这就是今天在Swift中的表现。您无法声明协议符合扩展中的其他协议。（＆＃34;为什么？＆＃34;＆＃34;因为编译器不允许它。＆＃34;）

但这并不意味着你必须重写所有的实现。您目前必须实施三次（如果您需要Float80，则需要执行四次，但这在这里似乎没有用）。首先，你声明你的协议。

import Foundation

// Declare the protocol
protocol TimeIntervalConvertible {
    func toTimeInterval() -> NSTimeInterval
}

// Add all the helpers you wanted
extension TimeIntervalConvertible {
    var seconds:NSTimeInterval {
        return NSTimeInterval(self.toTimeInterval())
    }

    var minutes:NSTimeInterval {
        return NSTimeInterval(self.toTimeInterval() * 60)
    }

    var hours:NSTimeInterval {
        return NSTimeInterval(self.toTimeInterval() * 3600)
    }

    var days:NSTimeInterval {
        return NSTimeInterval(self.toTimeInterval() * 3600 * 24)
    }
}

// Provide the implementations. FloatingPointType doesn't have an equivalent to
// toIntMax(). There's no toDouble() or toFloatMax(). Converting a Float to
// a Double injects data noise in a way that converting Int8 to IntMax does not.
extension Double {
    func toTimeInterval() -> NSTimeInterval { return NSTimeInterval(self) }
}

extension Float {
    func toTimeInterval() -> NSTimeInterval { return NSTimeInterval(self) }
}

extension IntegerType {
    func toTimeInterval() -> NSTimeInterval { return NSTimeInterval(self.toIntMax()) }
}

// And then we tell it that all the int types can get his implementation
extension Int: TimeIntervalConvertible {}
extension Int8: TimeIntervalConvertible {}
extension Int16: TimeIntervalConvertible {}
extension Int32: TimeIntervalConvertible {}
extension Int64: TimeIntervalConvertible {}
extension UInt: TimeIntervalConvertible {}
extension UInt8: TimeIntervalConvertible {}
extension UInt16: TimeIntervalConvertible {}
extension UInt32: TimeIntervalConvertible {}
extension UInt64: TimeIntervalConvertible {}

这是当前在Swift中完成数字类型的方式。通过stdlib查看。你会看到很多东西：

extension Double {
    public init(_ v: UInt8)
    public init(_ v: Int8)
    public init(_ v: UInt16)
    public init(_ v: Int16)
    public init(_ v: UInt32)
    public init(_ v: Int32)
    public init(_ v: UInt64)
    public init(_ v: Int64)
    public init(_ v: UInt)
    public init(_ v: Int)
}

在某些情况下谈论类似数字的东西会不会很好？＆＃34;当然。你今天不能在斯威夫特。

＆＃34;为什么＆＃34;

因为编译器没有实现它。有一天它可能会。在此之前，为您想要的每种类型创建扩展。一年前，这将需要更多的代码。

请注意，虽然的某些是＆＃34;但Swift还没有这个功能，＆＃34;有些也是故意的。 Swift故意要求在数字类型之间进行显式转换。数字类型之间的转换通常会导致信息丢失或注入噪音，并且历史上一直是棘手的错误来源。每次转换数字时都应该考虑这个问题。例如，从Int64到Int8或从UInt8到Int8的明显情况可能会丢失信息。但是从Int64到Double也会丢失信息。并非所有64位整数都可以表示为Double。这是一个微妙的事实，在处理非常大的数字时会经常烧伤人，Swift会鼓励你处理它。即使将Float转换为Double也会将噪声注入数据中。表示为Float的1/10是与表示为Double的1/10不同的值。当你将Float转换为Double时，你的意思是扩展重复数字吗？根据您选择的内容，您会引入不同类型的错误，因此您需要选择。

另请注意，.days可能会根据确切的问题域引入细微错误。一天不总是24小时。根据DST的变化，它可以是23小时或25小时。有时这很重要。有时它不会。但是，对于治疗＆＃34; days＆＃34;而言，这是一个非常谨慎的理由。好像它是一个特定的秒数。通常，如果您想在几天内工作，则应该使用NSDate，而不是NSTimeInterval。我对那个特别的人非常怀疑。

顺便说一下，您可能对my old implementation of this idea感兴趣。而不是使用语法：

1.seconds

我使用了语法：

1 * Second

然后重载乘法以返回结构而不是Double。以这种方式返回结构可以提供更好的类型安全性。例如，我可以键入 - 检查＆＃34; time * frequency == cycles＆＃34;和＆＃34;周期/时间==频率＆＃34;，这是Double可以做的事情。不幸的是，NSTimeInterval不是一个单独的类型;它只是Double的另一个名字。因此，您放在NSTimeInterval上的任何方法都应用于每个Double（有时候很奇怪）。

我个人可能会这样解决这个问题：

let Second: NSTimeInterval = 1
let Seconds = Second
let Minute = 60 * Seconds
let Minutes = Minute
let Hour = 60 * Minutes
let Hours = Hour

let x = 100*Seconds

您甚至不需要超载运营商。它已经为你完成了。

Answer 2

NSTimeInterval只是Double的别名。您可以通过定义自己的结构来轻松实现所需的结构，如下所示：

struct MyTimeInterval {
    var totalSecs: NSTimeInterval

    var totalHours: NSTimeInterval {
        get {
            return self.totalSecs / 3600.0
        }
        set {
            self.totalSecs = newValue * 3600.0
        }
    }

    init(_ secs: NSTimeInterval) {
        self.totalSecs = secs
    }

    func totalHourString() -> String {
        return String(format: "%.2f hours", arguments: [self.totalHours])
    }
}

var t = MyTimeInterval(5400)
print(t.totalHourString())

Answer 3

extension Int {
    var seconds: Int {
            return self
        }
    var minutes: Int {
        get {
            return self * 60
        }
    }
    var hours: Int {
        get {
            return minutes * 60
        }
    }
    var timeString: String {
        get {
            let seconds = abs(self) % 60
            let minutes = ((abs(self) - seconds) / 60) % 60
            let hours = ((abs(self) - seconds) / 3660)
            let sign = self < 0 ? "-" :" "
            let str = String(format: "\(sign)%2d:%02d:%02d", arguments: [Int(hours),Int(minutes),Int(seconds)])
            return str
        }
    }
}

6.minutes == 360.seconds                    // true

let t1 = 1.hours + 22.minutes + 12.seconds
let t2 = 12.hours - 15.minutes
let time = t1 - t2

print("t1    =",t1.timeString,t1)             // t1    =   1:22:12 4932
print("t2    =",t2.timeString,t2)             // t2    =  11:45:00 42300
print("t1-t2 =",time.timeString,time)         // t1-t2 = -10:22:48 -37368

(12.hours / 30.minutes) == 24                 // true

试图扩展IntegerType（和FloatingPointType）;为什么不能将所有Int类型转换为NSTimeInterval

3 个答案: