Cette documentation est encore en cours de rédaction chez Apple et des corrections peuvent être apportées au cours des semaines à venir.

Swift supporte quatre opérateurs arithmétiques standards pour tous les types de nombres :

  • Les additions (+)
  • Les soustractions (-)
  • Les multiplications (*)
  • Les divisions (/)
1 1 + 2         // égal à 3
2 5 - 3         // égal à 2
3 2 * 3         // égal à 6
4 10.0 / 2.5    // égal à 4.0

Contrairement aux opérateurs arithmétiques en C et en Objective-C, les opérateurs arithmétiques du langage Swift ne permettent pas aux valeurs de déborder par défaut. Pour réaliser ce type d’opération, vous devrez utiliser les opérateurs de débordement (comme dans a &+ b). Voir la partie Opérateurs de débordement.

L’opérateur d’addition est aussi supporté pour la concaténation entre chaîne de caractères :

"hello, " + "world" // égal à "hello, world"

Il est possible d’utiliser des valeurs de types character, comme des émoticones avec les opérateurs numériques. Ils répondent aux même règles que les chaînes de caractères.

La division avec reste

L’opérateur numérique qui sert a effectuer des divisions avec reste correspond au signe pourcentage sur votre clavier (%). dans l’opération a % b, la division avec reste permet de calculer combien de multiple de b se trouve dans a et ensuite de retourner le restant indivisible (le reste).

Note : L’opérateur de division avec reste est aussi connu sous le nom d’opérateur modulo dans d’autres langages. Toutefois, son comportement dans Swift pour les nombres négatifs signifie qu’il est à proprement parlé, un reste plutôt qu’une opération de type modulo.

Voilà comment la division avec reste fonctionne. Pour calculer 9 % 4, la première chose à faire de savoir combien de fois le chiffre 4 rentre entièrement dans l’entier 9 :

Division avec reste

On peut mettre deux fois 4 à l’intérieur 9, et il reste 1, indivisible par le chiffre 4 (en orange). Dans Swift on pourrait l’écrire :

9 % 4    // égal à 1

Pour déterminer la réponse de a % b, l’opérateur de division avec reste calcule l’équation ci-dessous et retourne le reste :

a = ( b * multiplicateur ) + reste

Lorsque le multiplicateur est le nombre le plus large des multiples de b il est indiqué dans a. Insérez 9 dans l’équation pour vérifier :

9 = ( 4 * 2 ) + 1

La même méthode est appliquée lorsque vous calculez le reste d’une valeur négative de a :

-9 % 4   // égal à -1
-9 = ( 4 * -2 ) + -1   // le reste vaut -1

Le signe de b est ignoré pour les valeurs négatives de b. Ce qui signifie que a % b et a % -B donneront toujours le même résultat.

Calculer le reste avec des nombres à virgule

Contrairement à l’opérateur de division avec reste en C et en Objective-C, Swift permet d’effectuer ce genre d’opération avec des nombres à virgule :

8 % 2.5  // égal à 0,5

Dans cet exemple, 8 divisé par 2.5 vaut 3, et il reste 0.5. L’opérateur numérique retourne une valeur du type Double.

Calculer le reste des nombres

Opérateurs d’incrémentation et de décrémentation

Comme en C, Swift dispose d’un opérateur d’incrémentation (++) un d’un opérateur de décrémentation (--) agissant comme des raccourcis pour augmenter ou diminuer la valeur d’une variable numérique par 1. Vous pouvez utiliser ces opérateurs avec des variables de n’importe n’importe quel type numérique.

1 var i = 0
2 ++i    // i vaut maintenant 1

Chaque fois que vous appelez i++, la valeur de i est incrémentée de 1. Essentiellement, i++ est un raccourcis pour l’opération i = i + 1. Du coup, i-- peut être utilisé comme raccourcis pour i = i - 1.

Les symboles ++ et -- peuvent être utilisés comme préfixe ou comme suffixe. ++i et i++ sont deux solutions valides pour incrémenter la valeur de i par 1. Idem avec l’opérateur --, qui peut se placer avant ou après la variable concernée pour décrémenter une valeur.

Notez que ces opérateurs modifient i et retournent systématiquement une valeur. Si vous voulez juste incrémenter ou décrémenter la valeur stockée dans i, vous pouvez ignorer la nouvelle valeur retournée. Il faut aussi savoir que si l’opérateur est placé avant la variable, il incrémente la variable avant de retourner sa valeur. S’il est placé après, il incrémente la variable après avoir retourné sa valeur. Par exemple :

1 var a = 0
2 letb = ++a
3 // a et b valent maintenant tous les deux 1
4 letc = a++
5 // a est maintenant égal à 2, mais c a été initialisé avec la valeur 1

Dans l’exemple ci-dessus, let b = ++a incrémente a avant de retourner sa valeur. Voilà pourquoi a et b valent tous les deux 1.

Cependant, let c = a++ incrémente a après avoir retourné sa valeur. Donc c est initialisé avec l’ancienne valeur de a et récupère la valeur 1. Ensuite a est incrémenté et vaut au final 2.

A moins que vous en ayiez vraiment besoin, il est recommandé d’utiliser ++i et --i dans tous les cas, afin d’éviter les confusions et les erreurs de valeurs.

Opérateur unaire “Moins”

Le symbole numérique - utilisé normalement pour les opérations numériques comme la soustraction peut aussi être utilisé comme opérateur unaire devant une variable ou une constante de type numérique :

1 let trois = 3
2 let moinsTrois = -trois  // moinsTrois vaut -3
3 let plusTrois = -moinsTrois  // plusTrois vaut 3 (--3)

Cet opérateur unaire est mit directement avant la valeur sur laquelle il faut opérer, sans espace.

Opérateur unaire “Plus”

Comme l’opérateur unaire précédent, il existe aussi la version normalement utilisée avec les additions qui, devant une variable ou une constante de type numérique, retourne simplement la valeur sans aucun changement :

1 let moisHuit = -8
2 let tjsMoinsHuit = +moinsHuit    // tjsMoinsHuit vaut -8 (+-8)

L’opérateur unaire + ne sert pas à grand chose en fait. Vous pouvez l’utiliser pour permettre une meilleure compréhension de votre code mais il est totalement facultatif.