Le “++” et “--” les opérateurs ont été dépréciées Xcode 7.3

Un explication complète ici de Chris Lattner, Swift du créateur. Je vais résumer les points:

1. C'est une autre fonction que vous avez à apprendre tout en apprenant Swift
2. Pas beaucoup plus courte que x += 1
3. Swift n'est pas C. Ne pas les porter tout pour plaire programmeurs C
4. Son utilisation principale est de style C pour la boucle: for i = 0; i < n; i++ { ... }, Swift a de meilleures alternatives, comme for i in 0..<n { ... } (C-style de boucle est sortir aussi)
5. Peut être difficile à lire et à maintenir, par exemple, quelle est la valeur de x - ++x ou foo(++x, x++)?
6. Chris Lattner ne l'aime pas.

---

Pour ceux qui sont intéressés (et pour éviter la pourriture des liens), Lattner motifs dans ses propres mots sont:

1. Ces opérateurs augmentation de la charge pour en savoir Swift comme premier langage de programmation ou tout autre cas où vous ne savez pas déjà ces opérateurs dans une autre langue.

2. De leur expression avantage est minime - x++ n'est pas beaucoup plus court que x += 1.

3. Swift déjà s'écarte de C dans l'=, +=, et d'autres à l'affectation des opérations de type Void (pour diverses raisons). Ces opérateurs sont incompatibles avec ce modèle.

4. Swift a de puissantes fonctionnalités d'éliminer beaucoup de raisons les plus courantes que vous souhaitez utiliser ++i dans un style C pour la boucle dans d'autres langues, afin que ceux-ci sont relativement peu utilisés, écrits en code Swift. Ces fonctionnalités incluent la pour-en boucle, les gammes, les énumérer, carte, etc.

5. Code qui utilise en fait le résultat de la valeur de ces opérateurs est souvent source de confusion et subtile, un lecteur/responsable de code. Ils encouragent "exagérément difficile" le code qui peut être mignon, mais difficile à comprendre.

6. Alors que Swift a bien défini l'ordre de l'évaluation, tout code qui en dépendait (comme foo (++, a++)) ne serait pas souhaitable, même si elle a été bien défini.

7. Ces opérateurs sont applicables à relativement peu de types: entiers et à virgule flottante scalaires, et itérateur-comme les concepts. Ils ne s'appliquent pas aux nombres complexes, matrices, etc.

Enfin, ces échec de la métrique de "si nous ne l'avons pas déjà ces, pourrions-nous ajouter à Swift 3?"

OriginalL'auteur Code Different

Apple a supprimé le ++ et il fait beaucoup plus simple avec l'autre de façon traditionnelle.

Au lieu de ++, vous devez écrire +=.

Exemple:

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

De même pour l'opérateur de décrémentation --, vous devez écrire -=

Exemple:

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

Pour for boucles:

Incrément Exemple:

Au lieu de

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

Vous pouvez écrire:

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

Décrémenter Exemple:

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

Vous pouvez écrire:

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

Espérons que cette aide!

OriginalL'auteur Sohil R. Memon

La Fix-it feature de Xcode donne de réponse claire à cette.

Remplacer ++ increment operator à l'ancienne value += 1 (à court de main de l'opérateur) et -- decrement operator avec value -= 1

OriginalL'auteur Jayprakash Dubey

Pour Swift 4, vous pouvez restaurer les ++ et -- opérateurs que des extensions pour Int et d'autres types. Voici un exemple:

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

Il fonctionne de la même manière pour les autres types, tels que UIInt, Int8, Float, Double, etc.

Vous pouvez coller ces extensions dans un seul fichier dans votre répertoire racine, et ils seront disponibles pour une utilisation à l'intérieur de tous vos autres fichiers.

J'ai remarqué un couple de votes pour ma réponse ici, presque dès que je l'ai posté. Que je prends comme un désaccord philosophique, plutôt que critique de la façon dont mon code fonctionne. Il fonctionne parfaitement, si vous le vérifier dans une aire de jeux.

La raison pour laquelle j'ai posté cette réponse, c'est parce que je suis en désaccord avec le fait de faire de la programmation informatique langues inutilement différents les uns des autres.

Avoir beaucoup de similitudes entre les langues rend easer pour les gens d'apprendre et de passer d'une langue à l'autre.

Développeurs normalement l'utilisation de plusieurs langages de programmation, plutôt qu'une seule. Et c'est une vraie galère de passer d'une langue à l'autre, quand il n'existe pas de conventions et de l'absence de communauté de la normalisation à travers les langues.

Je crois qu'il devrait être syntaxe des différences entre les langues uniquement la quantité nécessaire, et pas plus que cela.

OriginalL'auteur Mike

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

C'est certainement un inconvénient, à droite?

OriginalL'auteur outcast

Dans Swift 4.1 il pourrait être atteint de cette façon:

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

Avis que, malgré le fait que cette solution similaire aux précédentes solutions dans ce post, ils ne travaillent pas plus rapide 4.1 et cet exemple n'.
Notez également que celui ci-dessus mentionne que += est un remplacement pour l'++, il suffit de ne pas comprendre pleinement l'opérateur ++ est combiné avec d'affectation est en fait deux activités, d'où un raccourci.
Dans mon exemple: var s = t++ fait deux choses: d'affecter la valeur de t à s et puis incrémenter t. Si l' ++ vient avant, c'est les deux mêmes opérations effectuées dans l'ordre inverse.
À mon avis, le raisonnement de Apple au sujet de pourquoi supprimer cet opérateur(mentionné dans les réponses précédentes), n'est pas seulement faux raisonnement, mais en outre, je crois que c'est un mensonge et la vraie raison est qu'ils ne pouvaient pas faire leur compilateur de le gérer. Il leur a donné des problèmes dans les versions précédentes de sorte qu'ils ont abandonné.
La logique de "trop compliqué à comprendre opérateur, donc à l'écart" est évidemment un mensonge parce que Swift contient des opérateurs beaucoup plus compliqué et beaucoup moins utiles qui n'ont pas été supprimés. Aussi, la grande majorité des langages de programmation.
JavaScript, C, C#, Java, C++ et bien d'autres. Les programmeurs heureux de l'utiliser.
Qui il est trop difficile de comprendre cette opérateur de, elles et elles seules devraient faire l' += (ou peut-être s = s + 1 si += est trop complexé).

La stratégie derrière Swift est simple: Apple estime que le programmeur est muet, et, par conséquent, doit être traitée en conséquence.

La vérité est que Swift, lancé en septembre 2014 était censé être ailleurs maintenant. D'autres langues ont augmenté beaucoup plus vite.

Que je puisse les énumérer beaucoup de grosses erreurs dans la langue, à partir de sérieux: comme les tableaux collés par valeur et non par référence à gênants: des paramètres variants. les fonctions peuvent pas accepter un tableau qui est l'idée derrière elle.
Je ne pense pas que les employés d'Apple sont même pas autorisés à regarder les autres langages tels que Java, afin qu'ils ne savent même pas qu'Apple est à des années lumières derrière. Apple pourrait avoir adopté Java en tant que langage, mais ces jours-ci, le défi n'est pas la technologie, mais l'ego est.
S'ils ont ouvert IntelliJ pour écrire du Java, ils seraient pour vous de fermer leur compréhension des affaires, qui, à ce point, ils ne peuvent pas et ne rattrapera jamais.

OriginalL'auteur Elad Lavi