Opérateurs de base en Swift

Opérateur d'assignation

L'opérateur d'affectation = initialise la valeur d'une variable ou d'une constante ou met à jour une variable en lui attribuant une nouvelle valeur.

let b = 10
var a = 5
a = b  
// a est maintenant égal à 10

Cela marche aussi pour les tuples :

let (x, y) = (1, 2)
// x est égal à 1, et y est égal à 2

Opérateur d'affectation combiné

L'opérateur d'affectation combiné, ou composé, effectue une opération et attribue le résultat à une variable. Il permet à votre code de gagner en lisibilité. Prenons un exemple, vous disposez d'une variable nommée points, de type Int et ayant pour valeur 10. Pour ajouter 5 à cette valeur, vous pourriez écrire :

var points: Int = 10

// On ajoute 5
points = points + 5

// Maintenant, points a pour valeur 15

Grâce à l'opérateur d'affectation combiné, il est plus simple d'écrire comme ceci :

var points: Int = 10

// On ajoute 5
points +=  5

// Maintenant, points a pour valeur 15

On ajoute l'opérateur arithmétique de son choix juste avant le signe = puis la valeur qui subira l'opération mathématique après ce signe. Cela fonctionne avec le signe pour une addition (+), pour une soustraction (-), pour une multiplication (*) ou pour une division (/).

Opérateur arithmétique

Addition (+), Soustraction (-), Multiplication (*), Division (/)

1 + 2       // égal 3
5 - 3       // égal 2
2 * 3       // égal 6
10.0 / 2.5  // égal 4.0

L'opérateur d'addition permet également de concaténer des chaînes de caractères (type String). La concaténation, c'est comme attacher deux morceaux de texte pour n'en former qu'un :

"Bonjour " + "à tous" 
// égal à "Bonjour à tous"

L'opérateur de reste % renvoie à la valeur restante (aussi connue sous le nom de modulo)

9 % 4    // reste 1
-9 % 4   // reste -1

Opérateur de comparaison

• Égal à (==) : a == b
• Pas égal à (!) : a != b
• Supérieur à (>) : a > b
• Moins de (<) : a < b
• Supérieur ou égal à (>=) : a >= b
• Inférieur ou égal à (<=) : a <= b

L'opérateur d'égalité vérifie si deux valeurs sont égales :

let a = 5
let b = 5

let estEgal = a == b // true

À l'inverse, l'opérateur d'inégalité vérifie si deux valeurs ne sont pas égales :

let x = 8
let y = 3

let nEstPasEgal = x != y // true

Vous pouvez comparer deux tuples s'ils ont le même type et le même nombre de valeurs. Les tuples sont comparés de gauche à droite, une valeur à la fois, jusqu'à ce que la comparaison trouve deux valeurs qui ne sont pas égales.

Ces deux valeurs sont comparées et le résultat de cette comparaison détermine le résultat global de la comparaison de tuples. Si tous les éléments sont égaux, les tuples eux-mêmes sont égaux.

(1, "zoo") < (2, "arbre")   
// Vrai (true) car 1 est plus petit que 2; "zoo" et "arbre" ne sont pas comparé

(3, "arbre") < (3, "balle")    
// Vrai (true) car 3 est égal à 3, et "arbre" est plus petit que "balle"

(4, "drapeau") == (4, "drapeau")      
// Vrai (true) car 4 est égal à 4, et "drapeau" est "égal à "drapeau"

("bleu", false) < ("violet", true)  
// Erreur car < ne peut comparer une valeur Booléenne

Durant ces premiers chapitres, vous avez emmagasiné beaucoup de nouvelles informations. Ne lâchez pas, votre travail va commencer à payer dès les prochains chapitres où nous allons pouvoir faire pas mal de petites choses très sympas ...