Die Operatoren "++" und "-" sind veraltet. Xcode 7.3

Ich sehe mir Xcode 7.3-Notizen an und stelle dieses Problem fest.

Die Operatoren ++ und - sind veraltet

Könnte jemand erklären, warum es veraltet ist? Und bin ich richtig , dass in der neuen Version von Xcode jetzt Sie statt verwenden ++diese x += 1;

Beispiel:

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

Eine vollständige Erklärung hier von Chris Lattner, Swifts Schöpfer. Ich werde die Punkte zusammenfassen:

1. Es ist eine weitere Funktion, die Sie lernen müssen, während Sie Swift lernen
2. Nicht viel kürzer als x += 1
3. Swift ist nicht C. Sollte sie nicht übertragen, nur um C-Programmierern zu gefallen
4. Seine Hauptverwendung ist im C-Stil für Schleife:, für for i = 0; i < n; i++ { ... }die Swift bessere Alternativen hat, wie for i in 0..<n { ... }(C-Stil für Schleife geht ebenfalls aus )
5. Kann schwierig zu lesen und zu pflegen sein, zum Beispiel, was ist der Wert von x - ++xoder foo(++x, x++)?
6. Chris Lattner mag es nicht.

Für Interessierte (und um Link Rot zu vermeiden) sind Lattners Gründe in seinen eigenen Worten:

1. Diese Operatoren erhöhen die Belastung für das Erlernen von Swift als erste Programmiersprache - oder in jedem anderen Fall, in dem Sie diese Operatoren noch nicht aus einer anderen Sprache kennen.

2. Ihr Ausdrucksvorteil ist minimal - x ++ ist nicht viel kürzer als x + = 1.

3. Swift weicht bereits von C darin ab, dass die =, + = und andere zuweisungsähnliche Operationen Void zurückgeben (aus einer Reihe von Gründen). Diese Operatoren stimmen nicht mit diesem Modell überein.

4. Swift verfügt über leistungsstarke Funktionen, die viele der häufigsten Gründe beseitigen, warum Sie ++ i in einer for-Schleife im C-Stil in anderen Sprachen verwenden würden. Daher werden diese Funktionen in selten geschriebenem Swift-Code relativ selten verwendet. Diese Funktionen umfassen die For-In-Schleife, Bereiche, Aufzählung, Karte usw.

5. Code, der tatsächlich den Ergebniswert dieser Operatoren verwendet, ist für einen Leser / Verwalter von Code oft verwirrend und subtil. Sie fördern "übermäßig kniffligen" Code, der zwar niedlich, aber schwer zu verstehen ist.

6. Während Swift eine genau definierte Reihenfolge der Auswertung hat, wäre jeder Code, der davon abhängt (wie foo (++ a, a ++)), unerwünscht, selbst wenn er gut definiert wäre.

7. Diese Operatoren sind auf relativ wenige Typen anwendbar: Ganzzahl- und Gleitkomma-Skalare sowie iteratorähnliche Konzepte. Sie gelten nicht für komplexe Zahlen, Matrizen usw.

Schließlich verfehlen diese die Metrik "Wenn wir diese nicht bereits hätten, würden wir sie zu Swift 3 hinzufügen?"

Mir ist klar, dass dieser Kommentar die Frage nicht beantwortet, dennoch gibt es möglicherweise Leute, die nach einer Lösung suchen, um diese Operatoren am Laufen zu halten, und eine solche Lösung finden Sie unten. 😇

Ich persönlich bevorzuge ++und --Betreiber. Ich kann der Meinung nicht zustimmen, dass sie schwierig oder schwer zu handhaben sind. Sobald der Entwickler versteht, was diese Operatoren tun (und wir sprechen von ziemlich einfachen Dingen), sollte der Code sehr klar sein.

In der Erklärung, warum die Operatoren veraltet waren, wird erwähnt, dass ihre Hauptverwendung im C-Stil für Schleifen war. Ich weiß nichts über andere, aber ich persönlich verwende überhaupt keine C-Schleifen und es gibt noch viele andere Orte oder Situationen, in denen ++oder --Operator nützlich ist.

Ich möchte auch erwähnen, dass varName++ein Wert zurückgegeben wird, damit er in der returnwohingegen varName += 1nicht verwendet werden kann.

Für jeden von Ihnen, der diese Operatoren hier weiterarbeiten lassen möchte, ist die Lösung:

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
}

Apple hat das entfernt ++und es mit dem anderen alten traditionellen Weg viel einfacher gemacht.

Stattdessen ++müssen Sie schreiben +=.

Beispiel:

var x = 1

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

In ähnlicher Weise müssen Sie für den Dekrementierungsoperator --schreiben-=

Beispiel:

var x = 1

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

Für forSchleifen:

Inkrement Beispiel:

Anstatt

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

Du kannst schreiben:

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

Beispiel für Dekrementierung:

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

Du kannst schreiben:

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

Hoffe das hilft!

Chris Lattner ist gegen ++ und - in den Krieg gezogen. Er schreibt: „Code, der tatsächlich den Ergebniswert dieser Operatoren verwendet, ist für einen Leser / Verwalter von Code oft verwirrend und subtil. Sie fördern „übermäßig kniffligen“ Code, der zwar niedlich, aber schwer zu verstehen ist. Obwohl Swift eine genau definierte Reihenfolge für die Auswertung hat, wäre jeder Code, der davon abhängt (wie foo (++ a, a ++)), unerwünscht, selbst wenn dies der Fall wäre war gut definiert ... diese scheitern an der Metrik "Wenn wir diese nicht schon hätten, würden wir sie zu Swift 3 hinzufügen?"

Apple wollte schnell eine saubere, klare, nicht verwirrende und auf den Punkt gebrachte Sprache beibehalten. Und so veralteten sie ++ und - Schlüsselwort.

Das Fix-it featurevon Xcode gibt eine klare Antwort darauf.

Ersetzen Sie ++ increment operatordurch altmodisch value += 1(Kurzhandbediener) und -- decrement operatordurchvalue -= 1

Für Swift 4 können Sie die Operatoren ++und --als Erweiterungen für Intund andere Typen wiederherstellen . Hier ist ein Beispiel:

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

Es funktioniert auf die gleiche Art und Weise für andere Arten, wie UIInt, Int8, Float, Double, usw.

Sie können diese Erweiterungen in eine einzelne Datei in Ihrem Stammverzeichnis einfügen, und sie können dort in allen anderen Dateien verwendet werden.

Ich habe ein paar Abstimmungen für meine Antwort hier bemerkt, fast sobald ich sie gepostet habe. Was ich eher als philosophische Meinungsverschiedenheit als als Kritik an der Funktionsweise meines Codes betrachte. Es funktioniert perfekt, wenn Sie es auf einem Spielplatz auschecken.

Der Grund, warum ich diese Antwort gepostet habe, ist, dass ich nicht damit einverstanden bin, Computerprogrammiersprachen unnötig voneinander zu unterscheiden.

Viele Ähnlichkeiten zwischen Sprachen erleichtern es den Menschen, zu lernen und von einer Sprache in eine andere zu wechseln.

Entwickler verwenden normalerweise mehrere Programmiersprachen und nicht nur eine. Und es ist ein echtes Problem, von einer Sprache in eine andere zu wechseln, wenn es keine Konventionen und keine gemeinsame Standardisierung zwischen den Sprachen gibt.

Ich glaube, dass es nur so viele Syntaxunterschiede zwischen den Sprachen geben sollte, wie nötig, und nicht mehr.

Hier ist eine generische Version eines Teils des bisher veröffentlichten Codes. Ich würde die gleichen Bedenken wie andere Stimme: es eine bewährte Methode ist es , nicht diese in Swift zu verwenden. Ich bin damit einverstanden, dass dies für diejenigen, die Ihren Code in Zukunft lesen, verwirrend sein könnte.

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
}

Dies kann auch als Erweiterung des numerischen Typs geschrieben werden.

Aus den Dokumenten :

Die Inkrementierungs- / Dekrementierungsoperatoren in Swift wurden sehr früh in der Entwicklung von Swift als Übertragung von C hinzugefügt. Diese wurden ohne große Überlegung hinzugefügt und seitdem nicht mehr viel überlegt. Dieses Dokument bietet einen neuen Blick auf sie und empfiehlt letztendlich, sie nur vollständig zu entfernen, da sie verwirrend sind und nicht ihr Gewicht tragen.

var value : Int = 1

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

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

Das ist definitiv ein Nachteil, oder?

Da Sie in Swift nie wirklich mit Zeigern arbeiten, ist es meiner Meinung nach sinnvoll, die Operatoren ++und zu entfernen --. Wenn Sie jedoch nicht ohne leben können, können Sie Ihrem Projekt die folgenden Operatordeklarationen für Swift 5+ hinzufügen :

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

In Swift 4.1 konnte dies folgendermaßen erreicht werden:

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

Beachten Sie, dass diese Lösung trotz der Tatsache, dass sie den vorherigen Lösungen in diesem Beitrag ähnelt, in Swift 4.1 nicht mehr funktioniert und in diesem Beispiel. Beachten Sie auch, dass jeder, der oben erwähnt, dass + = ein Ersatz für ++ ist, den Operator nicht vollständig versteht, da ++ in Kombination mit der Zuweisung tatsächlich zwei Operationen sind, daher eine Verknüpfung. In meinem Beispiel:var s = t++macht zwei Dinge: Weisen Sie s den Wert von t zu und erhöhen Sie dann t. Wenn das ++ vorher kommt, sind es die gleichen zwei Operationen, die in umgekehrter Reihenfolge ausgeführt werden. Meiner Meinung nach ist die Argumentation von Apple, warum dieser Operator entfernt werden soll (in früheren Antworten erwähnt), nicht nur eine falsche Argumentation, sondern ich halte es auch für eine Lüge, und der wahre Grund ist, dass sie ihren Compiler nicht dazu bringen konnten, damit umzugehen. Es gab ihnen Probleme in früheren Versionen, also gaben sie auf. Die Logik "zu kompliziert, um den Operator zu verstehen, daher entfernt" ist offensichtlich eine Lüge, da Swift Operatoren enthält, die weitaus komplizierter und viel weniger nützlich sind und nicht entfernt wurden. Auch die überwiegende Mehrheit der Programmiersprachen hat es. JavaScript, C, C #, Java, C ++ und viele mehr. Programmierer nutzen es gerne. Für wen es zu schwierig ist, diesen Operator zu verstehen,

Die Strategie hinter Swift ist einfach: Apple hält den Programmierer für dumm und sollte daher entsprechend behandelt werden.

Die Wahrheit ist, dass Swift, das im September 2014 gestartet wurde, inzwischen woanders sein sollte. Andere Sprachen sind viel schneller aufgewachsen.

Ich kann viele wichtige Fehler in der Sprache auflisten, von schwerwiegenden: wie nach Wert und nicht nach Referenz eingefügte Arrays bis hin zu nervigen: Variadische Parameterfunktionen können kein Array akzeptieren, was die ganze Idee dahinter ist. Ich glaube nicht, dass Apples Mitarbeiter sich andere Sprachen wie Java ansehen dürfen, damit sie nicht einmal wissen, dass Apple Lichtjahre zurückliegt. Apple hätte Java als Sprache übernehmen können, aber heutzutage ist Herausforderung keine Technologie, sondern Ego. Wenn sie IntelliJ geöffnet hätten, um Java zu schreiben, würden sie mit Sicherheit ihr Geschäftsverständnis schließen, dass sie zu diesem Zeitpunkt niemals aufholen können und werden.