"++"및 "-"연산자는 더 이상 사용되지 않습니다. Xcode 7.3

Xcode 7.3 노트를보고 있는데이 문제를 발견했습니다.

++ 및-연산자는 더 이상 사용되지 않습니다.

왜 더 이상 사용되지 않는지 설명 할 수 있습니까? 그리고 나는 Xcode의 새로운 버전에서 ++이것 대신에 이것을 사용할 것이라고 맞습니까?x += 1 .

예:

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

Swift의 제작자 인 Chris Lattner 의 전체 설명 입니다. 요점을 요약하겠습니다.

1. Swift를 배우면서 배우는 또 다른 기능입니다.
2. 보다 짧지 않은 x += 1
3. Swift는 C가 아닙니다. C 프로그래머를 기쁘게하기 위해 그것들을 넘겨서는 안됩니다.
4. 주요 용도는 C-style for loop : for i = 0; i < n; i++ { ... }입니다. Swift는 for i in 0..<n { ... }(C-style for loop도 나옵니다.) )
5. 예를 들어 x - ++x또는 의 가치가 무엇인지 읽고 유지하기 까다로울 수 있습니다.foo(++x, x++) .
6. Chris Lattner는 그것을 좋아하지 않습니다.

Lattner의 관심은 (그리고 링크 부패를 피하기 위해) 자신의 말로 설명합니다.

1. 이 연산자는 Swift를 첫 번째 프로그래밍 언어 또는 다른 언어에서이 연산자를 아직 모르는 다른 경우로 배우는 부담을 증가시킵니다.

2. x ++는 x + = 1보다 훨씬 짧지 않습니다.

3. Swift는 =, + = 및 다른 할당과 유사한 연산이 Void를 반환한다는 점에서 이미 C와 다릅니다 (여러 가지 이유로). 이 연산자는 해당 모델과 일치하지 않습니다.

4. Swift는 다른 언어의 C 스타일 for 루프에서 ++ i를 사용하는 많은 일반적인 이유를 제거하는 강력한 기능을 갖추고 있으므로 잘 작성된 Swift 코드에서는 비교적 드물게 사용됩니다. 이러한 기능에는 for-in 루프, 범위, 열거, 맵 등이 포함됩니다.

5. 이러한 연산자의 결과 값을 실제로 사용하는 코드는 종종 혼란스럽고 코드의 리더 / 유지 보수 자에게 미묘합니다. 귀엽지 만 이해하기 어려운 "과도하게 까다로운"코드를 권장합니다.

6. Swift는 평가 순서가 잘 정의되어 있지만, foo (++ a, a ++)와 같이 그것에 의존하는 코드는 잘 정의되어 있어도 바람직하지 않습니다.

7. 이 연산자는 정수 및 부동 소수점 스칼라 및 반복 자형 개념과 같은 비교적 적은 유형에 적용 할 수 있습니다. 복소수, 행렬 등에 적용되지 않습니다.

마지막으로 이것들은 "아직 가지고 있지 않다면 Swift 3에 추가하겠습니까?"

그럼에도 불구 하고이 의견은이 질문에 대답하지 못한다는 것을 알고 있습니다. 사람들 이이 연산자를 계속 작동시키는 방법을 찾고있는 사람들이있을 수 있으며 그러한 해결책은 맨 아래에 있습니다. 😇

나는 개인적으로 선호 ++하고 --운영자입니다. 나는 그들이 까다 롭거나 관리하기 어렵다는 의견에 동의 할 수 없습니다. 개발자가 이러한 연산자의 기능을 이해하면 (그리고 우리는 매우 간단한 것들에 대해 이야기하고 있습니다) 코드는 매우 명확해야합니다.

설명에서 연산자가 더 이상 사용되지 않는 이유는 C 스타일 for 루프에서 주로 사용되었다고 언급되어 있습니다. 나는 다른 사람들에 대해 알지 못하지만 개인적으로 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
}

애플은 ++ 기존의 다른 기존 방식으로 훨씬 간단하게 만들었습니다.

대신 ++, 당신은 작성해야합니다 +=.

예:

var x = 1

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

감소 연산자 --와 마찬가지로 다음을 작성해야합니다.-=

예:

var x = 1

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

대한 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)
}

도움이 되었기를 바랍니다!

Chris Lattner는 ++와-. 그는“이러한 연산자의 결과 값을 실제로 사용하는 코드는 종종 혼란스럽고 독자 / 유지 코드 관리자에게 미묘합니다. 귀엽지 만 이해하기 어려운“과도하게 까다로운”코드를 권장합니다…. Swift는 평가 순서를 잘 정의하고 있지만, foo (++ a, a ++)와 같은 코드에 의존하는 코드는 바람직하지 않습니다. "이것이 없다면, Swift 3에 추가하겠습니까?"

Apple은 신속하고 깨끗하고 명확하며 혼란스럽지 않고 정확한 언어를 원했습니다. 그래서 그들은 ++와-키워드를 더 이상 사용하지 않습니다.

Fix-it feature엑스 코드의이에 명확한 답을 제공합니다.

교체 ++ increment operator구식으로 value += 1(짧은 손 운영자)와 -- decrement operator함께value -= 1

Swift 4의 경우 ++및 --연산자를 확장명 Int및 기타 유형 으로 복원 할 수 있습니다. 예를 들면 다음과 같습니다.

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, Int8, Float, Double, 등

이 확장명을 루트 디렉토리의 단일 파일에 붙여 넣을 수 있으며, 다른 모든 파일에서 사용할 수 있습니다.

나는 내가 게시하자마자 여기에 내 대답에 대한 두 개의 투표를 보았습니다. 내 코드가 어떻게 작동하는지에 대한 비판보다는 철학적 의견 불일치로 생각합니다. 운동장에서 체크 아웃하면 완벽하게 작동합니다.

이 답변을 게시 한 이유는 컴퓨터 프로그래밍 언어를 불필요하게 다르게 만드는 데 동의하지 않기 때문입니다.

언어간에 많은 유사점이 있으면 사람들이 한 언어에서 다른 언어로 쉽게 배우고 전환 할 수 있습니다.

개발자는 보통 하나 이상의 프로그래밍 언어가 아닌 여러 프로그래밍 언어를 사용합니다. 언어간에 규칙이없고 일반적인 표준화가없는 경우 한 언어에서 다른 언어로 전환하는 것은 매우 번거로운 일입니다.

언어 사이에는 구문 차이가 있어야하며 그 이상은 필요하지 않다고 생각합니다.

다음은 지금까지 게시 된 일부 코드의 일반 버전입니다. 다른 사람들과 같은 우려를 표명합니다 . 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 유형의 확장으로 작성 될 수도 있습니다.

로부터 문서 :

Swift의 증분 / 감소 연산자는 C에서 이월하여 Swift의 개발 초기에 추가되었습니다. 이들은 크게 고려하지 않고 추가되었으며 그 이후로는 많이 고려되지 않았습니다. 이 문서는 그것들을 새롭게 보여 주므로 혼란스럽고 무게를 지니지 않기 때문에 완전히 제거하는 것이 좋습니다.

var value : Int = 1

func theOldElegantWay() -> Int{
return value++
}

func theNewFashionWay() -> Int{
let temp = value
value += 1
return temp
}

이것은 분명히 단점입니다.

Swift에서 포인터로 실제로 작업하지 않기 때문에 내 의견으로 는 ++및 --연산자 를 제거하는 것이 좋습니다 . 그러나 당신이없이 살 수 없다면, 다음 Swift 5+ 연산자 선언을 프로젝트에 추가 할 수 있습니다 :

@discardableResult
public prefix func ++<T: Numeric>(i: inout T) -> T {
    i += 1
    return i
}

@discardableResult
public postfix func ++<T: Numeric>(i: inout T) -> T {
    defer { i += 1 }
    return i
}

@discardableResult
public prefix func --<T: Numeric>(i: inout T) -> T {
    i -= 1
    return i
}

@discardableResult
public postfix func --<T: Numeric>(i: inout T) -> T {
    defer { i -= 1 }
    return i
}

Swift 4.1에서는 다음과 같이 얻을 수 있습니다.

    prefix operator ++
    postfix operator ++
    extension Int{
        static prefix func ++(x: inout Int)->Int{
            x += 1
            return x
        }
        static postfix func ++(x: inout Int)->Int{
            x += 1
            return x-1
        }
    }
    //example:
    var t = 5
    var s = t++
    print("\(t) \(s)")

이 솔루션은이 게시물의 이전 솔루션과 유사하지만 Swift 4.1에서는 더 이상 작동하지 않으며이 예제에서는 작동하지 않습니다. 또한 + =가 ++를 대체한다고 언급 한 사람은 할당과 결합 된 ++가 실제로 두 개의 조작이므로 단축키를 이해하는 것은 아닙니다. 내 예에서 :var s = t++t의 값을 s에 할당 한 다음 t를 증가시키는 두 가지 작업을 수행합니다. ++가 앞에 오면 반대 순서로 수행되는 것과 동일한 두 작업입니다. 내 의견으로는,이 연산자를 제거하는 이유 (이전 답변에서 언급)에 대한 Apple의 추론은 잘못된 추론 일뿐 만 아니라 거짓말이라고 생각하며 진정한 이유는 컴파일러가 처리 할 수 ​​없다는 것입니다. 이전 버전에서는 문제가 발생하여 포기했습니다. Swift에는 제거되지 않은 연산자가 훨씬 더 복잡하고 유용하지 않기 때문에 "연산자를 이해하기에는 너무 복잡하여 제거되었습니다"라는 논리는 분명히 거짓말입니다. 또한 대다수의 프로그래밍 언어가 있습니다. JavaScript, C, C #, Java, C ++ 등 프로그래머는 그것을 행복하게 사용합니다. 이 연산자를 이해하기가 너무 어려운 사람은

스위프트의 기본 전략은 간단하다. 애플은 프로그래머가 멍청하다고 믿고 따라서 적절히 다루어야한다.

진실은 2014 년 9 월에 시작된 Swift가 지금까지 다른 곳에 있어야한다는 것입니다. 다른 언어는 훨씬 빨리 자랐습니다.

나는 심각한 것에서부터 참조가 아닌 값으로 붙여 넣은 배열과 같은 성가신 것들에 이르기까지 언어에서 많은 주요 실수를 나열 할 수 있습니다. 나는 애플의 직원들조차 자바와 같은 다른 언어를 볼 수 있다고 생각하지 않기 때문에 애플이 몇 년 뒤에 있다는 것을 알지 못한다. 애플은 자바를 언어로 채택 할 수 있었지만 요즘은 기술이 아니라 자아이다. 만약 그들이 Java를 작성하기 위해 IntelliJ를 열었다면,이 시점에서 그들은 지금까지 따라 올 수없고 잡을 수 없다는 것을 이해하고있는 그들의 사업을 확실히 닫을 것입니다.