"++"和" - "运算符已弃用Xcode 7.3

Question

我正在看Xcode 7.3笔记,我注意到了这个问题.

++和 - 运算符已被弃用

有人可以解释为什么它被弃用了吗？我是对的,在Xcode的新版本中,你现在要使用而不是++这个x += 1;

例:

for var index = 0; index < 3; index += 1 {
    print("index is \(index)")
}

Answer 1

一个在这里充分说明,从克里斯·拉特纳,斯威夫特的创造者.我将总结一下要点:

1. 这是学习Swift时必须学习的另一项功能
2. 不比短得多 x += 1
3. 斯威夫特不是C.不应该只是为了取悦C程序员
4. 它的主要用途是C风格的循环:for i = 0; i < n; i++ { ... }Swift有更好的选择,比如for i in 0..<n { ... }(C风格的循环也是如此)
5. 可能会非常棘手阅读和维护,用于例如,什么是价值x - ++x还是foo(++x, x++)？
6. 克里斯拉特纳不喜欢它.

对于那些感兴趣的人(并避免链接腐烂),Lattner用他自己的话说的理由是:

1. 这些运算符增加了将Swift作为第一种编程语言学习的负担 - 或者您不熟悉其他语言的这些运算符的任何其他情况.

2. 它们的表现优势很小 - x ++并不比x + = 1短.

3. Swift已经偏离C,因为=,+ =和其他类似赋值的操作返回Void(由于多种原因).这些运算符与该模型不一致.

4. Swift具有强大的功能,消除了在其他语言的C风格循环中使用++ i的许多常见原因,因此这些在编写良好的Swift代码中相对较少使用.这些功能包括for-in循环,范围,枚举,地图等.

5. 实际使用这些运算符的结果值的代码通常会让代码的读者/维护者感到困惑和微妙.他们鼓励"过于棘手"的代码,这些代码可能很可爱,但很难理解.

6. 虽然Swift具有良好定义的评估顺序,但任何依赖于它的代码(如foo(++ a,a ++))都是不可取的,即使它是明确定义的.

7. 这些运算符适用于相对较少的类型:整数和浮点标量,以及类似迭代器的概念.它们不适用于复数,矩阵等.

最后,这些失败的指标"如果我们还没有这些,我们会将它们添加到Swift 3吗？"

Answer 2

我知道这评论不回答这个问题仍然有可能是人们寻找一个解决方案如何使这些运营商合作,这样的解决方案可以在底部找到.

我个人更喜欢++和--运营商.我不能同意这样的观点,即它们很棘手或难以管理.一旦开发人员了解了这些操作符的作用(我们谈论的是非常简单的东西),代码应该非常清楚.

在解释为什么运营商被弃用时,提到他们的主要用途是C风格的循环.我不了解其他人,但我个人根本不使用C风格的循环,还有很多其他的地方或情况,++或者--运营商是有用的.

我还想提一下,它varName++返回一个值,因此它可以用于return而varName += 1不能.

对于任何想要让这些运营商在这里工作的人来说,解决方案是:

prefix operator ++ {}
postfix operator ++ {}

prefix operator -- {}
postfix operator -- {}


// Increment
prefix func ++(inout x: Int) -> Int {
    x += 1
    return x
}

postfix func ++(inout x: Int) -> Int {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt) -> UInt {
    x += 1
    return x
}

postfix func ++(inout x: UInt) -> UInt {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int8) -> Int8 {
    x += 1
    return x
}

postfix func ++(inout x: Int8) -> Int8 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt8) -> UInt8 {
    x += 1
    return x
}

postfix func ++(inout x: UInt8) -> UInt8 {
    x += 1
    return (x - 1)
}
prefix func ++(inout x: Int16) -> Int16 {
    x += 1
    return x
}

postfix func ++(inout x: Int16) -> Int16 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt16) -> UInt16 {
    x += 1
    return x
}

postfix func ++(inout x: UInt16) -> UInt16 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int32) -> Int32 {
    x += 1
    return x
}

postfix func ++(inout x: Int32) -> Int32 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt32) -> UInt32 {
    x += 1
    return x
}

postfix func ++(inout x: UInt32) -> UInt32 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int64) -> Int64 {
    x += 1
    return x
}

postfix func ++(inout x: Int64) -> Int64 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt64) -> UInt64 {
    x += 1
    return x
}

postfix func ++(inout x: UInt64) -> UInt64 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Double) -> Double {
    x += 1
    return x
}

postfix func ++(inout x: Double) -> Double {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Float) -> Float {
    x += 1
    return x
}

postfix func ++(inout x: Float) -> Float {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Float80) -> Float80 {
    x += 1
    return x
}

postfix func ++(inout x: Float80) -> Float80 {
    x += 1
    return (x - 1)
}

prefix func ++<T : _Incrementable>(inout i: T) -> T {
    i = i.successor()
    return i
}

postfix func ++<T : _Incrementable>(inout i: T) -> T {
    let y = i
    i = i.successor()
    return y
}

// Decrement
prefix func --(inout x: Int) -> Int {
    x -= 1
    return x
}

postfix func --(inout x: Int) -> Int {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt) -> UInt {
    x -= 1
    return x
}

postfix func --(inout x: UInt) -> UInt {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int8) -> Int8 {
    x -= 1
    return x
}

postfix func --(inout x: Int8) -> Int8 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt8) -> UInt8 {
    x -= 1
    return x
}

postfix func --(inout x: UInt8) -> UInt8 {
    x -= 1
    return (x + 1)
}
prefix func --(inout x: Int16) -> Int16 {
    x -= 1
    return x
}

postfix func --(inout x: Int16) -> Int16 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt16) -> UInt16 {
    x -= 1
    return x
}

postfix func --(inout x: UInt16) -> UInt16 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int32) -> Int32 {
    x -= 1
    return x
}

postfix func --(inout x: Int32) -> Int32 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt32) -> UInt32 {
    x -= 1
    return x
}

postfix func --(inout x: UInt32) -> UInt32 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int64) -> Int64 {
    x -= 1
    return x
}

postfix func --(inout x: Int64) -> Int64 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt64) -> UInt64 {
    x -= 1
    return x
}

postfix func --(inout x: UInt64) -> UInt64 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Double) -> Double {
    x -= 1
    return x
}

postfix func --(inout x: Double) -> Double {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Float) -> Float {
    x -= 1
    return x
}

postfix func --(inout x: Float) -> Float {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Float80) -> Float80 {
    x -= 1
    return x
}

postfix func --(inout x: Float80) -> Float80 {
    x -= 1
    return (x + 1)
}

prefix func --<T : BidirectionalIndexType>(inout i: T) -> T {
    i = i.predecessor()
    return i
}

postfix func --<T : BidirectionalIndexType>(inout i: T) -> T {
    let y = i
    i = i.predecessor()
    return y
}

Answer 3

苹果已经删除++了它,并使用另一种传统的旧方式使其变得更加简单.

而不是++,你需要写+=.

例:

var x = 1

//Increment
x += 1 //Means x = x + 1 

类似地,对于递减运算符--,您需要编写-=

例:

var x = 1

//Decrement
x -= 1 //Means x = x - 1

For for循环:

增量示例:

代替

for var index = 0; index < 3; index ++ {
    print("index is \(index)")
}

你可以写:

//Example 1
for index in 0..<3 {
    print("index is \(index)")
}

//Example 2
for index in 0..<someArray.count {
    print("index is \(index)")
}

//Example 3
for index in 0...(someArray.count - 1) {
    print("index is \(index)")
}

减量示例:

for var index = 3; index >= 0; --index {
   print(index)
}

你可以写:

for index in 3.stride(to: 1, by: -1) {
   print(index)
}
//prints 3, 2

for index in 3.stride(through: 1, by: -1) {
   print(index)
}
//prints 3, 2, 1

for index in (0 ..< 3).reverse() {
   print(index)
}

for index in (0 ... 3).reverse() {
   print(index)
}

希望这可以帮助!

Answer 4

克里斯拉特纳已经开始对抗++和 - .他写道,"实际使用这些运算符的结果值的代码通常会让代码的读者/维护者感到困惑和微妙.他们鼓励"过于棘手"的代码,这些代码可能很可爱但很难理解......虽然Swift有很好的定义评估顺序,任何依赖它的代码(如foo(++ a,a ++))都是不可取的,即使它定义明确......这些失败的指标"如果我们还没有这些,我们会将它们添加到Swift 3吗？"

Apple希望尽快保持干净,清晰,不混淆且直截了当的语言.所以他们弃用了++和 - keyword.

Answer 5

对于 Swift 4，您可以将++and--运算符恢复为Intand 其他类型的扩展。下面是一个例子：

extension Int{
   static prefix func ++(x: inout Int) -> Int {
        x += 1
        return x
    }

    static postfix func ++(x: inout  Int) -> Int {
        defer {x += 1}
        return x
    }

    static prefix func --(x: inout Int) -> Int {
        x -= 1
        return x
    }

    static postfix func --(x: inout Int) -> Int {
        defer {x -= 1}
        return x
    }
}

对于其他类型，如、、、 等UIInt，它的工作方式相同。Int8FloatDouble

您可以将这些扩展名粘贴到根目录中的单个文件中，它们将可供您在那里的所有其他文件中使用。如果您在操场上查看它，它可以完美运行。

Answer 6

在Fix-it featureXcode中的提供了明确的答案.

更换++ increment operator用老式的value += 1(短手操作),并-- decrement operator用value -= 1

Answer 7

这是迄今为止发布的一些代码的通用版本。我会表达与其他人相同的担忧：最好不要在 Swift 中使用这些。我同意这可能会让将来阅读您的代码的人感到困惑。

prefix operator ++
prefix operator --
prefix func ++<T: Numeric> (_ val: inout T) -> T {
    val += 1
    return val
}

prefix func --<T: Numeric> (_ val: inout T) -> T {
    val -= 1
    return val
}

postfix operator ++
postfix operator --
postfix func ++<T: Numeric> (_ val: inout T) -> T {
    defer { val += 1 }
    return val
}

postfix func --<T: Numeric> (_ val: inout T) -> T {
    defer { val -= 1 }
    return val
}

这也可以写成 Numeric 类型的扩展。