Operatory „++” i „-” zostały wycofane. Xcode 7.3

Patrzę na notatki Xcode 7.3 i zauważam ten problem.

Operatory ++ i - zostały wycofane

Czy ktoś mógłby wyjaśnić, dlaczego jest przestarzały? I mam rację, że w nowej wersji Xcode teraz użyjesz zamiast ++tego x += 1;

Przykład:

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

Pełne wyjaśnienie tutaj z Chrisem Lattner, twórca Swifta. Podsumuję punkty:

1. To kolejna funkcja, której musisz się nauczyć podczas nauki Swift
2. Niewiele krócej niż x += 1
3. Swift to nie C. Nie należy ich przenosić tylko po to, by zadowolić programistów C.
4. Jego głównym zastosowaniem jest pętla for w stylu C: for i = 0; i < n; i++ { ... }który Swift ma lepsze alternatywy, na przykład for i in 0..<n { ... }(pojawia się również pętla for w stylu C )
5. Może być trudne do odczytania i utrzymania, np. Jaka jest wartość x - ++xlub foo(++x, x++)?
6. Chris Lattner tego nie lubi.

Dla zainteresowanych (i dla uniknięcia zgnilizny linków) Lattner ma następujące powody:

1. Operatorzy ci zwiększają obciążenie związane z nauką Swift jako pierwszego języka programowania - lub w każdym innym przypadku, w którym nie znasz jeszcze tych operatorów z innego języka.

2. Ich wyrazista przewaga jest minimalna - x ++ jest niewiele krótsze niż x + = 1.

3. Swift już różni się od C tym, że =, + = i inne operacje podobne do przypisania zwracają Void (z wielu powodów). Te operatory są niezgodne z tym modelem.

4. Swift ma potężne funkcje, które eliminują wiele typowych powodów, dla których używasz ++ i w pętli for w stylu C w innych językach, więc są one stosunkowo rzadko używane w dobrze napisanym kodzie Swift. Funkcje te obejmują pętlę for-in, zakresy, wyliczanie, mapę itp.

5. Kod, który faktycznie wykorzystuje wartość wynikową tych operatorów, jest często mylący i subtelny dla czytelnika / osoby obsługującej kod. Zachęcają do stosowania „zbyt skomplikowanego” kodu, który może być uroczy, ale trudny do zrozumienia.

6. Chociaż Swift ma dobrze zdefiniowaną kolejność oceny, każdy kod, który od niego zależy (jak foo (++ a, a ++)) byłby niepożądany, nawet jeśli byłby dobrze zdefiniowany.

7. Operatory te mają zastosowanie do stosunkowo niewielu typów: skalarów całkowitych i zmiennoprzecinkowych oraz pojęć podobnych do iteratorów. Nie dotyczą liczb zespolonych, macierzy itp.

Wreszcie, nie spełniają one kryterium „gdybyśmy ich jeszcze nie mieli, czy dodalibyśmy je do Swift 3?”

Zdaję sobie sprawę, że ten komentarz nie odpowiada na pytanie, ale mogą być osoby szukające rozwiązania, jak utrzymać pracę tych operatorów i takie rozwiązanie można znaleźć na dole. 😇

Osobiście wolę ++i --operatorów. Nie mogę zgodzić się z opinią, że są trudne lub trudne w zarządzaniu. Gdy programista zrozumie, co robią te operatory (i mówimy o całkiem prostych rzeczach), kod powinien być bardzo przejrzysty.

W wyjaśnieniu, dlaczego operatory zostały uznane za przestarzałe, wspomniano, że ich głównym zastosowaniem było pętle w stylu C. Nie wiem o innych, ale osobiście w ogóle nie używam pętli w stylu C i jest jeszcze wiele innych miejsc lub sytuacji, w których operator ++lub --jest przydatny.

Chciałbym również wspomnieć, że varName++zwraca wartość, więc może być używany w przypadku, returngdy varName += 1nie można.

Dla każdego, kto chciałby, aby ci operatorzy pracowali tutaj, jest rozwiązaniem:

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
}

Firma Apple usunęła ++i uprościła ją w inny stary tradycyjny sposób.

Zamiast tego ++musisz pisać +=.

Przykład:

var x = 1

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

Podobnie dla operatora dekrementacji --, musisz pisać-=

Przykład:

var x = 1

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

W przypadku forpętli:

Przykład przyrostu:

Zamiast

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

Możesz pisać:

//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)")
}

Przykład zmniejszenia:

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

Możesz pisać:

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

Mam nadzieję że to pomoże!

Chris Lattner wyruszył na wojnę przeciwko ++ i -. Pisze: „Kod, który faktycznie wykorzystuje wartość wynikową tych operatorów, jest często zagmatwany i subtelny dla czytelnika / opiekuna kodu. Zachęcają do „zbyt skomplikowanego” kodu, który może być uroczy, ale trudny do zrozumienia… Chociaż Swift ma dobrze zdefiniowaną kolejność oceniania, każdy kod, który od niego zależy (jak foo (++ a, a ++)) byłby niepożądany, nawet jeśli był dobrze zdefiniowany… te nie spełniają kryterium „gdybyśmy ich jeszcze nie mieli, czy dodalibyśmy je do Swift 3?” ”

Firma Apple chciała zachować przejrzysty, przejrzysty, niezrozumiały i bezpośredni język. Dlatego wycofali słowa kluczowe ++ i -.

Fix-it featureZ Xcode daje jasnej odpowiedzi na to.

Wymienić ++ increment operatorz old-fashioned value += 1(operator krótki ręki) i -- decrement operatorzevalue -= 1

W przypadku Swift 4 można przywrócić operatory ++i --jako rozszerzenia dla Inti innych typów. Oto przykład:

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

To działa w ten sam sposób do innych typów, takich jak UIInt, Int8, Float, Double, etc.

Możesz wkleić te rozszerzenia w jednym pliku w katalogu głównym i będą one dostępne do użytku we wszystkich innych plikach.

Zauważyłem tutaj kilka głosów negatywnych na moją odpowiedź, prawie natychmiast po jej opublikowaniu. Które traktuję jako filozoficzną niezgodę, a nie krytykę tego, jak działa mój kod. Działa idealnie, jeśli sprawdzisz to na placu zabaw.

Powodem, dla którego zamieściłem tę odpowiedź, jest to, że nie zgadzam się z tym, aby języki programowania komputerów niepotrzebnie różniły się od siebie.

Wiele podobieństw między językami ułatwia ich naukę i przechodzenie z jednego języka na inny.

Programiści zwykle używają kilku języków programowania, a nie tylko jednego. A przejście z jednego języka na inny jest prawdziwym kłopotem, gdy nie ma konwencji ani wspólnej standaryzacji we wszystkich językach.

Uważam, że różnice składniowe między językami powinny być tylko w takim stopniu, w jakim jest to konieczne, i nie więcej niż to.

Oto ogólna wersja niektórych dotychczas opublikowanych kodów. Chciałbym wyrazić te same obawy, co inni: najlepszą praktyką jest nie używać ich w Swift. Zgadzam się, że może to być mylące dla osób czytających Twój kod w przyszłości.

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
}

Można to również zapisać jako rozszerzenie typu numerycznego.

Z dokumentów :

Operatory inkrementacji / dekrementacji w języku Swift zostały dodane na bardzo wczesnym etapie rozwoju języka Swift, jako przeniesienie z C. Zostały one dodane bez większego zastanowienia i od tamtej pory niewiele się nad nimi zastanawiano. Ten dokument zapewnia im świeże spojrzenie i ostatecznie zaleca, abyśmy po prostu je całkowicie usunęli, ponieważ są mylące i nie niosą ze sobą swojej wagi.

var value : Int = 1

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

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

To zdecydowanie wada, prawda?

Ponieważ w Swift nigdy nie pracujesz ze wskaźnikami, moim zdaniem ma sens usunięcie operatorów ++i --. Jeśli jednak nie możesz żyć bez, możesz dodać te deklaracje operatora Swift 5+ do swojego projektu:

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

W Swift 4.1 można to osiągnąć w następujący sposób:

    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)")

Zauważ, że pomimo tego, że to rozwiązanie jest podobne do poprzednich rozwiązań w tym poście, nie działają one już w Swift 4.1 i ten przykład działa. Zauważ również, że ktokolwiek powyżej wspomina, że ​​+ = jest zamiennikiem dla ++, po prostu nie w pełni rozumie operator, ponieważ ++ w połączeniu z przypisaniem to w rzeczywistości dwie operacje, stąd skrót. W moim przykładzie:var s = t++robi dwie rzeczy: przypisuje wartość t do s, a następnie zwiększa t. Jeśli ++ występuje wcześniej, to te same dwie operacje wykonane w odwrotnej kolejności. Moim zdaniem rozumowanie Apple dotyczące tego, dlaczego usunąć tego operatora (wspomniane w poprzednich odpowiedziach), jest nie tylko fałszywym rozumowaniem, ale ponadto uważam, że to kłamstwo, a prawdziwym powodem jest to, że nie mogli zmusić kompilatora do tego. W poprzednich wersjach sprawiało im to kłopoty, więc zrezygnowali. Logika „operatora zbyt skomplikowanego, aby go zrozumieć, stąd usunięta” jest oczywiście kłamstwem, ponieważ język Swift zawiera operatory o wiele bardziej skomplikowane i znacznie mniej przydatne, których nie usunięto. Posiada go również ogromna większość języków programowania. JavaScript, C, C #, Java, C ++ i wiele innych. Programiści chętnie z niego korzystają. Komu trudno jest zrozumieć tego operatora,

Strategia Swift jest prosta: Apple uważa, że ​​programista jest głupi i dlatego powinien być odpowiednio traktowany.

Prawda jest taka, że ​​Swift, uruchomiony we wrześniu 2014 r., Miał już być gdzie indziej. Inne języki rosły znacznie szybciej.

Mogę wymienić wiele głównych błędów w języku, od poważnych: takich jak tablice wklejane według wartości, a nie przez odniesienie, po irytujące: funkcje z parametrami zmiennymi nie mogą zaakceptować tablicy, która jest podstawą jej działania. Nie sądzę, aby pracownicy Apple'a mogli nawet patrzeć na inne języki, takie jak Java, więc nawet nie wiedzą, że Apple jest o lata świetlne w tyle. Apple mogło przyjąć Javę jako język, ale obecnie wyzwaniem nie jest technologia, ale ego. Gdyby otworzyli IntelliJ, aby napisać trochę Javy, z pewnością zamknęliby swoje biznesowe zrozumienie, że w tym momencie nie mogą i nigdy nie nadrobią zaległości.