2

Commencer avec swift : les opérateurs

On est reparti avec du swift et cette fois-ci on va s’attarder sur les opérateurs. Nous avons effleuré le sujet dans l’article sur les variables (que je conseille de lire avant) mais on va s’y intéresser encore un peu et approfondir le sujet. Les opérateurs sont la base même sur laquelle va reposer notre code. Ils nous permettent d’effectuer : des opérations !

Les plus simples, ils nous permettent d’effectuer des opérations mathématiques très simples. En fait, elles sont au nombre de quatre :

  • + l’addition
  • la soustraction
  • * la multiplication
  • / la division

Facile ! On peut faire des calculs et assigner les résultats à des variables, on peut même opérer deux variables entre elles a conditions qu’elles aient le même type. Essayons dans un playground :

1
2
3
4
5
let nombre = 17                            // 17
let plusVingt = nombre + 20                // 37
let moinsTreize = plusVingt - 13           // 24
let foisDeux = plusVingt * nombre          // 629
let divisePar = foisDeux / moinsTreize     // 26

Les types

Les plus attentifs d’entre vous auront remarqué que 629 / 24 n’est pas égal à 26 mais plutôt à 26,208333… C’est par ce que toutes les opérations effectuées ici sont faites sur des variables de type Int. Rappelez vous : lorsque vous ne déclarez pas vous-même le type d’une variable, Xcode va tenter d’en attribuer un par défaut. La première variable que nous initialisons var nombre = 17 obtient donc le type Int par défaut. Les autres opérations découle de ce type, puisque cette variable a un type assigné il s’assignera aussi aux autres variables qui contiendraient sa valeur.

Lorsque l’on ajoute 20 sur la deuxième opération, puisque l’opérateur ne peut effectuer des opérations qu’entre variables du même type, il va se baser sur le type type de variable sur lequel il opère. 20 n’a pas encore de type défini mais nombre oui. Et tout le reste découle de ça ; a la fin puisqu’une variable de type Int ne peut pas contenir de nombre à virgule, il ne nous est retourné que la partie entière.

Si jamais on change le type de la variable nombre :

1
2
3
4
5
let nombre:Float = 17                      // 17
let plusVingt = nombre + 20                // 37
let moinsTreize = plusVingt - 13           // 24
let foisDeux = plusVingt * nombre          // 629
let divisePar = foisDeux / moinsTreize     // 26.20833

Le résultat se trouve aussitôt corrigé, et en déclarant un type Double on aura une plus grande précision.

Il est possible d’additionner des chaines de caractères ce qui a pour résultat de les mettre bout à bout, cela s’appelle la concaténation. Il n’est néanmoins pas encore possible de multiplier des phrases entre elles…

Les préfixes

Les opérateurs + et – ne servent pas qu’a faire des calculs. Enfin si mais parfois ils peuvent servir de préfixe à une variable pour inverser son signe.

1
2
3
4
let vingt = 20

let moinsVingt = -vingt          
let plusVingt = +moinsVingt

On peut aussi se servir des opérateurs lorsque l’on assigne une valeur à une variable. Cela permet d’effectuer l’opération entre la valeur actuelle de la variable et sa nouvelle valeur.

1
2
3
4
5
6
var nombre = 20

nombre += 20        // nombre = nombre + 20
nombre -= 20        // nombre = nombre - 20
nombre *= 20        // nombre = nombre * 20
nombre /= 20        // nombre = nombre / 20

Il n’est pas possible d’effectuer cette opération lors de l’initialisation de la variable :

1
var nombre *= 20 // ERROR

Modulo %

Le modulo est un opérateur particulier qui est hérité du langage C. Il permet d’obtenir le reste d’une division euclidienne. En clair si l’on calcule 11 % 5, swift va compter combien de 5 peuvent entrer dans 11 (à savoir 2), puis il va les soustraire à 11 (donc 11 – 10) ce qui correspond à un. Si on divise 11 par 5, on obtient un résultat de 2 modulo 1 (2 * 5 + 1 = 11)

1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
1
2
3
4
5
1

 
C’est comme si on distribuait un jeu de 52 cartes à 5 personnes, il en resterait deux. Tiens d’ailleurs voici le code :

1
2
3
4
5
let cartes = 52
let joueurs = 5

let cartesParJoueur = cartes / joueurs       // 10
let resteCartes = cartes % joueurs           // 2

Les opérations multiples

Si le signe pourcentage ne permet pas d’en calculer un en swift, il y a un autre moyen : la méthode classique du produit en croix (Wikihow). Essayons de calculer ça :

1
2
3
4
5
6
7
8
9
10
11
let cartes = 52
let joueurs = 5

let cartesParJoueur = cartes / joueurs    // 10
let resteCartes = cartes % joueurs        // 2

let nbCartesDistribuees = Float(cartesParJoueur * joueurs)              // 50
// let nbCartesDistribuees = Float(cartes - resteCartes)                // 50

var pctCartesDstribuees:Float = nbCartesDistribuees / Float(cartes)     // 0.9615384
pctCartesDstribuees *= 100                                              // 96.15384

Soit 96.15384% de cartes distribuées. Vous remarquez que j’ai du convertir les valeurs des variables déjà déclarées en type Float pour pouvoir travailler avec les virgules. Il y a également deux moyen pour calculer nbCartesDistribuees Il est possible d’effectuer ce calcul de pourcentage en une seule ligne.

1
let pctCartesDstribuees = Float(cartesParJoueur * joueurs) / Float(cartes) * 100

Les règles de calcul des opérateurs swift sont exactement les mêmes que les règles de bases de l’arithmétiques, il est également possible de forcer le regroupement des calculs via l’utilisation de parenthèses comme en mathématiques (Wikipedia). On ne peut cependant pas écrire d’opérations trop complexe sur une seule ligne. Le compilateur doit interpréter l’opération en langage assembleur et moins elle sera éclatée sur plusieurs opérations distinctes, plus elle sera complexe à générer, et plus le processeur mettra de temps à la calculer.

1
let xyz = Float(cartesParJoueur * joueurs) / Float(cartes) * 100 + cartes - (joueurs * resteCartes) / (joueurs + cartes)

Ce code nous génère une erreur : Expression was too complex to be solved in reasonable time; consider breaking up the expression into distinct sub-expressions , il faut donc trouver un juste milieu pour la longueur des opérations que l’on souhaite exécuter.

Bien voilà qui est fait ! On va pouvoir maintenant s’attaquer aux opérations logiques et aux comparaisons. A bientôt !

Suite du tutoriel

Les conditions

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *