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

139

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

Screenshot zur Warnung

Oleg Gordiichuk
quelle
6
Ich denke, diese Frage liegt außerhalb des Bereichs des Stackoverflow, hauptsächlich weil alle akzeptierten Vorschläge für die schnelle Entwicklung in Github zu finden sind. Sie können mehr über das Warum dieses Vorschlags lesen. Github.com/apple/swift-evolution/blob/master / Vorschläge /…
Victor Sigler
7
Ich denke ernsthaft darüber nach, einfach zu Objective-C zurückzukehren. Es lohnt sich nicht, mit all den Änderungen an Swift Schritt zu halten.
Greg Brown
3
@OlegGordiichuk Es ist die Sache, dass die for-Schleifen, da der C-Stil auch entfernt werden würde, siehe diese github.com/Vkt0r/swift-evolution/blob/master/proposals/…, so dass Sie nicht mehr die ++und ---Operatoren verwenden müssen
Victor Sigler
10
Es gibt zu viele bahnbrechende Veränderungen für meinen Geschmack. Ich bin alles für Verbesserungen, aber ich möchte meine Zeit nicht wirklich damit verbringen, wesentliche Teile meiner Codebasis jedes Mal neu zu schreiben, wenn eine Xcode-Punktveröffentlichung herauskommt.
Greg Brown
4
@Fogmeister Ich bin mir nicht sicher, wie ich klarer sein könnte. Ich würde Swift lieber verwenden, aber ich glaube nicht, dass es stabil genug ist. Ich habe in der Vergangenheit ausgiebig mit anderen Sprachen gearbeitet und bin in so kurzer Zeit noch nie auf so viele bahnbrechende Veränderungen gestoßen. Ich habe das Gefühl, Apple möchte, dass wir alle Swift übernehmen, aber sie machen es schwieriger, als es sein sollte.
Greg Brown

Antworten:

210

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

Code anders
quelle
54
Ich denke, die eigentliche Antwort ist Nummer 6. Das ist in Ordnung, wir (ehemalige C-, Java-, ... Programmierer) sind flexibel genug :-). Im Allgemeinen reichen für die reale Welt Mutation, Crossover und Selektion aus. Ich, Sie und Cris auch, wir sind alle Ergebnisse dieser drei Operatoren ...
user3441734
5
Punkt 5: Diese waren in C immer implementierungsabhängig, und niemand mit Sinn hat sie jemals getan. Definieren Sie einfach das Verhalten und wir werden uns daran gewöhnen. Besser, als ohne wirklichen Grund zurückgehen und vollkommen guten alten Code ändern zu müssen.
Echelon
3
Ich mag Punkt 3. Sie können nicht für immer an den Vertrag des Vermächtnisses gefesselt sein. Ich liebe C, aber Sie erstellen eine neue Programmiersprache. Es ist sinnvoll, mit dem Schiefer so sauber zu beginnen, wie Sie es brauchen.
Nicolas Miari
8
Es ist so, weil Apple dich gerne zwingt, so zu denken, wie sie es tun. Ich denke, es ist vollkommen in Ordnung und wird überall dort verwendet, wo Sie eine Variable erhöhen oder verringern müssen. Es ist nicht etwas, was man "lernen muss", ohne das man gut zurechtkommt. Und # 5 ist nur schlecht geschriebener Code, wie ich ihn noch nie gesehen habe. Also # 6 ist es. Es reicht aus, mich am Kopf zu kratzen und eine Google-Suche durchzuführen. Vielen Dank, dass Sie meine Zeit verschwendet haben, Chris.
csga5000
4
@ csga5000 Das ist ein ziemlich schwaches Argument, wenn man bedenkt, dass man den Operator einfach selbst definieren kann, wenn man es wirklich will. Es hat nichts mit Apfel zu tun, der möchte, dass die Leute so denken wie sie. Es passt einfach nicht zur Sprache. Wenn das ++nicht in Sprachen im C-Stil existiert, würde niemand, der bei klarem Verstand ist, das Design von Swift 3.0 betrachten und denken, dass ein ++Operator eine nette Ergänzung dazu wäre.
Overactor
37

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
}
0101
quelle
Ich mag Ihre return (x - 1)für die Postfix-Operatoren nicht - IMHO ist es sauberer, die Semantik beizubehalten, dass sie (eine Kopie) des ursprünglichen Werts zurückgeben, anstatt das, was Sie erhalten, wenn Sie dies tunx + 1 - 1
Alnitak
Ich mag es auch nicht, aber ich kenne keine andere (bessere, sauberere) Art, dies zu tun. Ich verstehe Ihren zweiten Punkt nicht ganz.
0101
1
Ich verstehe, ich wollte das nicht nur tun, um eine andere Variable (oder in diesem Fall eher eine Konstante) zu erstellen. Wenn wir nur darüber sprechen, wird Intdas Ergebnis von (x + 1)überflogen, was die Ausführung unterbricht und daher result - 1nicht einmal ausgeführt wird. Andere Datentypen wie Doublezum Beispiel verhalten sich jedoch anders, daher muss ich das untersuchen.
0101
3
Sie können deferdies auch verwenden. defer { x += 1 }; return x
Tim Vermeulen
4
Warum nicht Generika verwenden und dies in ein paar Zeilen schreiben?
μολὼν.λαβέ
22

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!

Sohil R. Memon
quelle
Sie haben nichts ersetzt; +=war die ganze Zeit dort.
Nicolas Miari
@NicolasMiari Ja, gerade mit dem viel besseren Format
bearbeiten
@NicolasMiari Kannst du bitte jetzt nachsehen?
Sohil R. Memon
3
Was ist mit ++iund --i?
Zigii Wong
7

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.

Jay Mehta
quelle
9
Reinigen? Schauen Sie sich diese Rückrufhölle an und nennen Sie sie sauber? Ich bin anderer Meinung ... Und ich würde hinzufügen: Lassen Sie die ++ & - allein
mcatach
22
so etwas wie ...for i in 0.stride(to: 10, by: 2)...oder ...for i in (1...10).reverse()...ist sauber?!
mad_manny
6
Genau. Das "saubere" Argument widerspricht dem Rest von Swift grundsätzlich. Ausgehend von Objective-C, das objektiv unrein ist, ist es ziemlich schwierig, "sauber" als Apple-Sprachziel zu akzeptieren.
Adrian Bartholomew
2
Versuchen Sie, json zu analysieren und schnell und sagen Sie mir, wie sauber es ist.
Nickthedude
6

Screenshot zur Warnung

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

Lösung zur Warnung

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

Jayprakash Dubey
quelle
6

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.


quelle
Ich liebe es, wenn Sprachen es „wagen“, anders zu sein. Es gibt ehrlich gesagt zu viele 'C-Syntax'-Sprachen, und C wurde vor langer Zeit entwickelt. Es gibt über 50 Jahre Spracherfahrung. Unabhängig davon, da diese Antwort immer noch nicht zu einer Tirade über die Operatoren führte eine Gegenstimme.
user2864740
5

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.

Doghound
quelle
Ich habe @discardableResultzu jeder dieser Funktionen hinzugefügt , um die Warnung zu unterdrücken, dass der Rückgabewert nicht verwendet wird. sonst genau das, wonach ich gesucht habe.
Devin Lane
4

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.

Dániel Nagy
quelle
Mit anderen Worten, diese Operation ist zu teuer, um verwendet zu werden?
Oleg Gordiichuk
2
github.com/apple/swift-evolution/blob/master/proposals/… hier können Sie darüber lesen, aber es liegt nicht daran, dass es teuer ist, sondern am Sprachdesign.
Dániel Nagy
Also, wie ich andersen Swift die Unterstützung für die C-Style-Funktionen
einstellen werde
2
@OlegGordiichuk Nun, ich würde sagen, sie möchten betonen, dass Swift im Gegensatz zu Objective-C keine Obermenge von C ist.
Dániel Nagy
1
@mah vieles, was du gesagt hast, macht überhaupt keinen Sinn. "Nicht auf bestehende Entwickler ausgerichtet" in welcher Weise? Ebenso wie Java nicht auf PHP-Entwickler ausgerichtet ist? "orientiert an denen, die möglicherweise nicht die Neigung haben, Entwickler zu sein"? Ja, weil all diese Nicht-Entwickler da draußen mit protokollorientierter Programmierung und Generika die Hand abbeißen. "Ein Weg, gutes Design zu ermöglichen" Schauen Sie sich SO an, Sie werden sehen, dass keine Programmiersprache "gutes Design ermöglichen" kann.
Fogmeister
0
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?

Ausgestoßene
quelle
5
Sie meinen elegant wie in "Sie müssen sich an alle Feinheiten der Programmiersprache C erinnern, sonst ist nicht sofort ersichtlich, ob der erste Aufruf 1 oder 2 zurückgibt"? Ich denke, wir können alle ein paar zusätzliche Codezeilen
sparen,
0

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
}
LimeRed
quelle
-3

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.

Elad Lavi
quelle