Tour rapide de Swift 2

Ce petit cours à pour vocation de faire un tour rapide du langage Swift afin d’en appréhender les aspects principaux. Si vous souhaitez aller plus loin je vous conseille le guide q’Apple à mis à disposition gratuitement (en anglais uniquement). Nous allons survoler plusieurs concepts comme les variables, les structures de contrôle, les classes et plus encore.

Variables vs. Constantes en Swift

Swift fait la différence entre les variables qui sont mutables et celles qui ne le sont pas. Pour cela il existe 2 mots clés qui sont var et let :

var = variable (mutable).
let = constante (non mutable).

Par example :

// Ceci est possible
var nom = "Swift"
nom     = "Swift Tuto"

// Ceci est impossible
let nom = "Swift"
nom     = "Swift Tuto" // Erreur car nom est une constante

Vous me direz pourquoi ne pas tout déclarer en tant que variable vu que c’est beaucoup plus simple ? Tout simplement par ce que le compilateur est capable de faire des optimisations sur les constantes pour améliorer les performances. Donc une bonne pratique est de toujours utiliser let quand cela est possible.

Typage Explicite vs. Implicite

En swift il est possible d’utiliser de choisir entre 2 typages :

Le typage explicite : vous spécifiez vous même le type de la variable.
Le typage implicite : vous laissez le compilateur deviner le type de la variable.

Voici un example simple :

let monAge = 25 // Typage implicite

let sonAge: Int = 32 // Type explicite

Dans le premier cas le compilateur devine tout seul que la constante monAge est un entier tandis que dans le deuxième cas on spécifie nous même que sonAge est un entier. Alors dans quel cas il est utile d’utiliser le type explicite en swift ?

En pratique il vaut mieux laisser le compilateur faire, mais quelque fois vous n’aurez d’autre choix que de l’aider car il n’arrivera pas à faire l’inférence de type tout seul. Par example dans ce cas :

let vitesse = 1.2

Par défaut swift va définir vitesse en tant que Double, mais si vous souhaiter un Float vous devrez lui dire explicitement :

let vitesse: Float = 1.2

// ou
let vitesse = Float(1.2)

Types de base en Swift

Maintenant attaquons nous aux types de base qui permette de créer un programme :

Integer : un entier.
Float : un nombre flottant.
Double : un nombre rationnel avec plus de précision qu’un Float.
Bool : un booléen.
String : une chaine de caractère.

Sous forme de code :

let nombreEntier: Int     = 1
let nombreFlottant: Float = 1.2
let nombreDouble: Double  = 1.2
let booleen: Bool         = true
let chaine: String        = "Salut"

Les structures de contrôle

Une structure de contrôle est une commande qui permet de contrôler l’ordre dans lequel le code va s’exécuter.

If-else

La plus simple pour commencer s’appelle if-else :

let nom = "Swift"

if nom == "Swift" {
  // right
}
else {
  // wrong
}

Dans cet example, on déclare une chaine de caractère puis on teste si elle est égale à « Swift ». Si le résultat est valide on exécute le premier cas, sinon on va dans le deuxième. Ici comme nom est bien égale à swift on va dans la première branche.

Switch-case

Une deuxième structure de contrôle très utile est le switch-case :

let age = 30

switch age {
case 0 ..< 30:
  print("jeune")
case 30:
  print("la trentaine")
case 31 ..< 60:
  print("moins jeune")
case 60 ..< 120:
  print("sage")
default:
  print("age invalide")
}

Ici l’example peut paraitre un peu complexe mais il montre beaucoup de chose. Premièrement on se rend compte que cette structure est finalement assez similaire au if-else car il permet d’exécuter certaines branches en fonction de certaine condition. Par example le switch prend en paramètre l’age et en fonction de sa valeur il va exécuter un d’entre elle. Donc ici il va regarder si l’age est entre 0 et 30 ans, si il a 30 ans, si il est entre 31 et 60 ans, entre 60 et 120 ans et pour finir à défaut (et il est obligatoire) il exécutera la dernière branche. Ici bien évidemment il affichera « la trentaine ».

Il est a noter qu’en Swift, les cas de test doivent être exhaustifs et par conséquent si l’on n’a pas tester (ou que l’on ne peut pas tester tout les cas possibles) il est obligatoire d’utiliser le mot clé default qui sera appelé si aucune des autres conditions a été validée.

De plus contrairement à d’autre language break n’est obligatoire uniquement qu’en cas de condition avec un corps vide et que si l’on veut exécuter plusieurs bloc il faut utiliser le mot clé fallthrough.

For-in

Une autre catégorie de structure de contrôle très importante est ce que l’on appelle les boucles. Il en existe plusieurs mais on va s’arrêter aux boucles for-in et while.
Tout d’abord la boucle for-in :

for i in 0 ..< 10 {
  print(i)
}

La boucle for-in va ici afficher tout les chiffres entre 0 et 10 (non inclus). En fait la boucle for est très utile avec les listes ou les dictionnaires pour parcourir les éléments. Nous les verrons en peu plus en détails après.

While

La boucle while quant à elle ressemble à ceci :

var i = 0

while i < 10 {
  i = i + 1
}

Ce code est équivalent à celui de la boucle de for-in. Il permet de lire le code d’une autre manière et est souvent utile quand on ne connait pas exactement le nombre de boucle que l’on doit effectuer.

Classes et Méthodes

Une des choses les plus commune en Swift que vous allez faire c’est la création de classe et de méthode, donc regardons d’un peu plus prêt ce qu’il vous attend !

Tout d’abord voici la création d’une classe qui s’appelle Voiture :

class Voiture {
}

Il suffit d’utiliser le mot clé class, d’ajouter le nom de votre classe et d’ouvrir et fermer les accolades et cotre classe est créée. Maintenant nous allons ajouter des propriétés et des méthodes à cette classe :

class Voiture {
  var litreEssence = 0.0

  func ajouterEssence(litre: Double) {
    litreEssence = litreEssence + litre
  }
}

Nous avons ajouter une variable à notre voiture qui est le nombre de litre d’essence qui lui reste pour rouler. Par défaut il n’y a pas d’essence dans la voiture. Pour en ajouter nous avons créer une méthode ajouterEssence grâce au mot clé func et qui prend en paramètre litre qui permet d’ajouter de l’essence à notre voiture.

On pourrait aussi créer une voiture avec de l’essence par défaut. Pour cela il nous faut créer un initialiser en utilisant le mot clé init :

class Voiture {
  var litreEssence = 0.0

  init(litre: Double) {
    litreEssence = litre
  }

  func ajouterEssence(litre: Double) {
    litreEssence = litreEssence + litre
  }
}

Maintenant nous pouvons créer un voiture avec de l’essence par défaut :

var maVoiture = Voiture(litre: 10)

Simple, non ?

Les listes

Une liste en swift (et dans beaucoup d’autre langage de programmation) est un ensemble d’élément. Il permet de regrouper des éléments de même type ou autre au sein d’un même objet afin d’en faciliter la manipulation. Par example, au lieu d’avoir une liste de variable comme ceci :

var entier1 = 2
var entier2 = 7
var entier3 = 14
var entier4 = 36

print(entier1) // 2
print(entier2) // 7
print(entier3) // 14
print(entier4) // 36

On peut utiliser à la place une liste (Array) pour arriver au même résultat :

var liste = [2, 7, 14, 36]

for entier in liste {
  print(entier)
}

Avec l’utilisation d’une liste et d’une boucle for on arrive à réduire le nombre de ligne écrite et surtout la lisibilité et la maintenabilité du code. Maintenant si nous voulons ajouter d’autres entier il suffit juste de l’ajouter à la liste et c’est tout. Aucune duplication de code n’est nécéssaire contrairement au premier cas.

Les dictionnaires

Un dictionnaire (Dictionary) ou table de hachage dans d’autres langage est une structure de donnée qui permet de ranger les éléments par clé-valeur. Contrairement à une liste où l’on doit parcourir celle ci entièrement pour trouver un élément, un dictionnaire permet de retrouver un élément directement grâce à sa clé. Par example, vous souhaitez stocker l’age de tous vos amis. Vous avez alors 2 possibilités (plus en réalité, mais pour les besoins du tutoriel on va faire simple), utiliser un dictionnaire ou une liste. Regardons un peu comment faire cela :

 // Avec une liste
let anniversaire = [("Robert", 50), ("Marcel", 76), ("Irène", 56)]

// Avec un dictionnaire
let anniversaire = [
  "Robert": 50,
  "Marcel": 76,
  "Irène": 56
]

Dans le premier cas nous avons stocké couple (prénom, age) dans une liste, tandis que dans le deuxième cas nous avons utilisé le prénom comme clé, et l’age en valeur.

Pour retrouvé l’age d’Irène, dans le premier cas nous somme obligé de parcourir la liste pour trouver le prénom Irène et récupérer son age :

var ageIrene = -1

for couple in anniversaire {
  if couple.0 == "Irène" {
    ageIrene = couple.1
  }
}

Comme vous pouvez le voir, cela est assez fastidieux. Avec l’utilisation d’un dictionnaire cela est beaucoup plus simple, une ligne de code suffit :

var ageIrene = anniversaire["Irène"]

Voilà, maintenant à vous de faire votre choix entre les listes et les dictionnaires en fonction du contexte dans lequel vous les utilisés.

Que faire maintenant ?

Ceci est le premier article sur les bases de Swift, d’autres viendront pas la suite. Mais si vous souhaitez dès à présent approfondir le sujet vous pouvez allez un coup d’oeil au guide fournie par Apple ici : Swift Programming Language.
Nous espérons que ce petit cours vous à plu et bienvenue dans le monde de Swift ! À bientôt !