Apprenez les fondamentaux de Swift

Nous avons compris ce qu'étaient les variables dans le chapitre précédent. Elles permettent d'associer un nom à une valeur. Nous avons pu jouer un peu avec ces variables et les opérateurs pour faire des opérations simples. Mais tout ne s'est pas passé sans encombre. Vous vous souvenez de ceci :

3/2   // Le résultat est 1
3/2.0 // Le résultat est 1.5

Ça n'a quand même pas l'air très logique ; alors investiguons !

Découvrez les types

La raison principale, c'est que je ne vous ai pas tout dit sur les variables ! Elles contiennent en fait trois informations :

• un nom ;

• une valeur ;

• ... et un type !

C'est tout simplement le type d'information que l'on va stocker dans la variable. Il y en a une infinité, et vous allez même apprendre à en créer. Mais pour vous donner quelques exemples, un type peut être :

• un nombre entier ;

• un nombre décimal ;

• une chaîne de caractères ;

• etc.

Il y en a 2.

1. Lorsque l'on va utiliser une variable, puisqu'elle a un type, l'ordinateur va savoir de quoi il s'agit. Il va donc pouvoir nous suggérer des méthodes logiques. Par exemple : si c'est une chaîne de caractères, il nous proposera une méthode pour tout mettre en majuscules.

2. Surtout, cela permet de stocker la variable correctement en mémoire. Un nombre entier et un nombre décimal ne prennent pas la même place en mémoire. Donc en sachant à l'avance de quel type il va s'agir, l'ordinateur va pouvoir allouer directement la place nécessaire en reconnaissant le type. C'est plus optimisé comme ceci.

Rentrons tout de suite dans le vif du sujet avec les types numériques.

Appréhendez les types numériques

Pour déclarer un nombre avec Swift, il existe trois types :

•  Int  pour déclarer un nombre entier ;

•  Float  pour déclarer un nombre décimal ;

•  Double  pour déclarer un nombre décimal.

Oui, bien vu ! Il y a 2 types différents pour déclarer un nombre décimal :  Float  et  Double  . Pourquoi ? Comme son nom l'indique,  Double  est un type deux fois plus gros que  Float  .

Cela veut dire qu'une variable de type  Double  peut stocker des nombres deux fois plus précisément que  Float  .

Vous êtes exigeant ! Prenons un exemple. Admettons que je veuille créer une variable qui contient la valeur  1876.79797657  . C'est une valeur sacrément précise ! Elle contient 12 chiffres ! Un  Double  pourra la stocker en mémoire, car ce type prévoit suffisamment de place pour 12 chiffres.

Mais un  Float  ne pourra stocker que les 6 premiers chiffres, car il a deux fois moins de place que le  Double  . Il stockera donc    1876.79  .

Bien essayé, mais je ne peux pas plus détailler. J'ai fait de mon mieux...

Cela dépend de la précision que vous souhaitez obtenir. En pratique, si les deux solutions peuvent convenir, Apple recommande l'utilisation de  Double  . Un nombre à virgule est d'ailleurs évalué comme un  Double  par défaut par Swift. Cela vous permettra d'être large dans la précision, et Swift est suffisamment optimisé pour vous permettre cette concession.

Par exemple, il est déconseillé d’utiliser un Float  pour une opération arithmétique telle qu’une simple soustraction, par exemple.

Vous allez finir par me faire cracher le morceau ! ;)

Allez, je vous montre un exemple. Dans le Playground, lorsque je fais :

var cinqMillions: Float = 5000000.0
var moins: Float = 1149.8
var reste: Float = cinqMillions - moins

On obtient 4998850  et non 4998850.2  :

Il faut donc toujours garder en tête qu’en utilisant un Float  , on peut avoir une perte de précision sur des opérations, de par sa nature même et sa conception dans un compilateur. N'utilisez donc les Float  que si Swift l'exige, ou que vous avez un fort besoin de performance.

Déclarez une variable avec un type

Avec Swift, une variable a toujours un type. Swift est capable de déduire le type tout seul. Mais comme on vous l’a dit, il est toujours préférable de donner un type à ses variables. Question de bonne pratique ! :p

Pour cela, on utilise la syntaxe suivante :

var nom: Type = valeur

Par exemple :

var taille: Float = 180.5

Je déclare le nom de ma variable,  taille  puis son type,  Float  ,  puis je lui assigne une valeur,  180.5  .

Pour bien comprendre cela, je vous propose le petit exercice suivant. Copiez ceci dans votre Playground :

var a:Double = 1876.79797657765609870978709780987
var b:Float = 1876.79797657765609870978709780987
var c = 1876.79797657765609870978709780987

On déclare  a   comme étant un  Double  ,  b   est un  Float  , et on laisse Swift deviner le type de   c   . Voici ce que Swift vous propose sur la droite :

On peut constater plusieurs choses :

1. Le nombre est trop grand pour être stocké en entier même pour un type  Double  . Il est donc tronqué après le 16e chiffre.

2. La variable  b   est bien un  Float  puisqu'elle est tronquée à la moitié de la variable  a   qui est un  Double  .

3. Swift a bien déduit que la variable  c   était un  Double  en reconnaissant un chiffre à virgule.  Double  est bien le type par défaut des nombres décimaux. 

Reprenons maintenant notre code :

// Le prix du voyage aux Caraïbes de Joe
var price = 1499
// Le bénéfice quotidien de Joe avec sa ferme
var dailyBenefit = 10
// Le nombre de jours pendant lesquelles Joe doit économiser
var result = price / dailyBenefit

La variable  result  est un entier, donc de type  Int  . Or, on prévoit que le résultat de 1499/10  ne sera pas un nombre entier. On va donc modifier nos déclarations pour obtenir un résultat non entier.

var price: Double = 1499 // ou alternativement => var price = 1499.0

Avec cette modification, le Playground vous présente une erreur. En effet, la variable price  est maintenant un Double  , mais la variable  dailyBenefit  est toujours un entier.

Pour corriger ça, c'est évidemment très simple. Il suffit de déclarer  dailyBenefit  de type Double  . Je vous laisse le faire et constater que maintenant la variable  result  contient un nombre décimal.

Découvrez le type String

Non, on ne va pas parler slip...

Le type  String  , c'est simplement le type des chaînes de caractères, plus simplement des mots et des lettres.

Pour que l'ordinateur puisse faire la différence entre le code et une chaîne de caractères, on déclare une chaîne de caractères entre guillemets   "    comme ceci :

"Je suis une chaîne de caractères"

Évidemment, on peut déclarer une variable qui contient une chaîne de caractères. Dans ce cas, Swift devine son type :  String  .

var text = "Je suis un texte" // Swift déduit que la variable text est du type String

On peut également indiquer le type de façon explicite comme pour les types numériques :

var explicitText: String = "Je suis à coup sûr un texte"

En pratique, vous n'aurez pas à le faire, car Swift le déduit seul.

Comme vous le savez maintenant : les chaînes de caractères utilisent des guillemets doubles ! ;)

En revanche, ces dernières ne permettent pas d’y inclure aussi des sauts de lignes. Donc sachez que pour faire cela, on utilise les chaînes de caractères multilignes.

Pour ce faire, vous avez besoin d’une syntaxe légèrement différente : commencez et finissez par trois guillemets doubles, comme ceci :

var multilineText = """
Je suis
à coup
sûr
un texte
"""

Lorsque votre code source inclut un saut de ligne à l'intérieur d'une chaîne de caractères multiligne, ce saut de ligne apparaît également dans la valeur de la chaîne. Ce qui nous donne  "Je suis\nà coup\nsûr\nun texte"  .

Si vous souhaitez utiliser des sauts de ligne pour faciliter la lecture de votre code, mais que vous ne voulez pas que les sauts de ligne fassent partie de la valeur de la chaîne comme dans l’exemple ci-dessus, écrivez tout simplement un antislash ( \  ) à la fin de ces lignes :

var multilineText2 = """
Je suis \
à coup \
sûr \
un texte
"""

Voici le résultat :  "Je suis à coup sûr un texte" .

Les méthodes

Comme pour les types numériques, on va pouvoir utiliser des opérateurs pour les strings, et leur affecter des modifications. La première façon de les modifier, c'est la concaténation.

La concaténation  ! C'est le fait d'assembler deux chaînes de caractères l'une à la suite de l'autre. On fait cela en utilisant l'opérateur  +   . Par exemple :

var phrase = "Je suis le début de la phrase... " + "Et moi la fin !"
// Le playground affiche : "Je suis le début de la phrase... Et moi la fin !"

Simple, non ?

Allez, on grimpe un peu en difficulté. Essayons d’inclure un nombre dans une phrase. Par exemple la variable suivante :

var age = 24

Avec cette information, je pourrais construire la phrase :

"Vous avez 24 ans !"

Pour cela, on remplace 24 par la syntaxe suivante :

"Vous avez \(age) ans !" // Le playground lit : "Vous avez 24 ans !"

On place entre parenthèses la variable  age  , et l’on ajoute l'antislash devant.

Faisons un petit exercice pour vérifier que vous m'avez bien suivi ! Le contenu de l’exercice se trouve dans le dossier Github P1C4.

1. Ouvrez un nouveau Playground Xcode.

2. Copiez le contenu du fichier “main.swift” dans votre Playground.

3. Suivez les instructions.

Avec cette nouvelle technique, nous allons pouvoir générer notre réponse à Joe directement depuis le Playground !

Un peu de philosophie

Avant de clore ce chapitre, je vous propose un petit peu de philosophie... N'ayez crainte, rien de grave !

Ce qui différencie les langages de programmation, au-delà de leur syntaxe, c'est surtout l'approche avec laquelle ils ont été conçus.

Swift a été conçu pour être particulièrement protégé. C'est la philosophie de ceux qui l'ont conçu. Cela signifie que, contrairement à d'autres langages, Swift est très très structuré. Cela permet d'éviter aux développeurs quelques bêtises, en leur signalant tout de suite qu'ils s'apprêtent à faire quelque chose de dangereux.

Cela est particulièrement vrai pour les types. C'est la raison pour laquelle je vous en parle maintenant  !

Contrairement à d'autres langages, Swift est très strict sur les variables qui doivent obéir à 2 règles.

1. Une variable ne peut pas changer de type. 

Essayons (faites-le avec moi  !) de transgresser cette règle :

var text = "Je suis un texte" // La variable est de type String
text = 2 // Pour contenir ce nombre, la variable doit devenir de type Int

Swift présente une erreur : Cannot assign value of type 'Int' to type 'String'. En français : "Je ne peux assigner une valeur de type  Int  à une variable de type  String  " .

2. Une variable a toujours un type

Autrement dit, une variable sans type n'existe pas. On ne peut donc pas écrire le code suivant :

var chose

Swift déclare : Type annotation missing in pattern. En français : le type n'est pas indiqué.

On peut en revanche déclarer une variable sans valeur. Comme ceci :

var chose: String

La variable a un type. Swift est content ! C'est tout ce qu'il lui faut. Il accepte qu'on lui donne la valeur plus tard.

En résumé

• Une variable a trois informations :

  • une valeur ;

  • un nom ;

  • un type.

• Vous connaissez désormais 4 types :

  • 3 types numériques :

    •  Int  pour les nombres entiers ;

    •  Float  pour les nombres décimaux ;

    •  Double  pour les nombres décimaux avec 2 fois plus de précisions.

  • 1 type pour les chaînes de caractères :  String  . 

• Swift est un langage strict. On ne peut pas faire n'importe quoi ! Notamment :

  • Une variable a toujours un type.

  • Une variable ne peut pas changer de type.

Nous y voilà ! Comme promis, les variables n’ont dorénavant plus de secret pour vous. Et si maintenant, si on retournait voir Joe pour lui annoncer la bonne nouvelle ?  ;) N’oubliez pas de valider vos acquis avec le quiz !